fix(core): large response body logging causes memory growth

hold_body_chunk accumulated every response body chunk into a Lua table
and, once the size limit was reached or on eof, concatenated the whole
table into a single string with table.concat. For large bodies (the
issue reports ~128K), this keeps both the list of chunks and the final
concatenated string alive at the same time, and every concat allocates
a fresh string, causing excessive memory allocation/retention.

Rewrite the accumulation to use a LuaJIT string.buffer
(require("string.buffer")): chunks are appended with buffer:put and the
final body is produced with buffer:get, which avoids holding the chunk
table plus an intermediate concatenated copy. For the truncation path
buffer:get(max_resp_body_bytes) returns exactly the first
max_resp_body_bytes bytes; the buffer is then dropped once `done` is set.

All existing semantics are preserved: the hold_the_copy flag,
max_resp_body_bytes truncation, the done flag (later chunks/eof return
nil after truncation), the single-chunk eof path and the per-buffer-key
storage.

Add t/core/response-hold-body.t covering multi-chunk accumulation, byte
truncation across chunks, the done flag, the single-chunk eof case and
small-body passthrough.

Fixes #11244

Author: AlinsRan

apisix/core/response.lua

@@ -35,11 +35,11 @@ local error = error
 local select = select
 local type = type
 local ngx_exit = ngx.exit
-local concat_tab = table.concat
 local str_sub = string.sub
 local tonumber = tonumber
 local clear_tab = require("table.clear")
 local pairs = pairs
+local str_buffer = require("string.buffer")
 local ngx_var = ngx.var
 local table = require("apisix.core.table")
 
@@ -348,21 +348,23 @@ function _M.hold_body_chunk(ctx, hold_the_copy, max_resp_body_bytes, body_buffer
 
         if not body_buffer then
             body_buffer = {
-                chunk,
-                n = 1,
-                bytes = #chunk,
+                buf = str_buffer.new(),
+                bytes = 0,
             }
             ctx._body_buffer[buffer_key] = body_buffer
-        else
-            local n = body_buffer.n + 1
-            body_buffer.n = n
-            body_buffer[n] = chunk
-            body_buffer.bytes = body_buffer.bytes + #chunk
         end
+        -- Accumulate chunks into a LuaJIT string buffer instead of a Lua
+        -- table of chunks. This avoids retaining every chunk plus the final
+        -- concatenated string at the same time, which previously caused
+        -- excessive memory growth for large response bodies (e.g. ~128K).
+        body_buffer.buf:put(chunk)
+        body_buffer.bytes = body_buffer.bytes + #chunk
 
         if max_resp_body_bytes and body_buffer.bytes >= max_resp_body_bytes then
-            local body_data = concat_tab(body_buffer, "", 1, body_buffer.n)
-            body_data = str_sub(body_data, 1, max_resp_body_bytes)
+            -- get() consumes the first max_resp_body_bytes bytes from the
+            -- buffer; the remaining bytes are dropped together with the buffer
+            -- once `done` is set, so no further accumulation happens.
+            local body_data = body_buffer.buf:get(max_resp_body_bytes)
             body_buffer.done = true
             return body_data
         end
@@ -380,7 +382,7 @@ function _M.hold_body_chunk(ctx, hold_the_copy, max_resp_body_bytes, body_buffer
             return nil
         end
 
-        local body_data = concat_tab(body_buffer, "", 1, body_buffer.n)
+        local body_data = body_buffer.buf:get()
         ctx._body_buffer[buffer_key] = nil
         return body_data
     end

t/core/response-hold-body.t

@@ -0,0 +1,261 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+use t::APISIX 'no_plan';
+
+repeat_each(1);
+no_long_string();
+no_root_location();
+log_level("info");
+
+run_tests;
+
+__DATA__
+
+=== TEST 1: hold_body_chunk accumulates a large multi-chunk body (string.buffer)
+--- config
+    location = /t {
+        content_by_lua_block {
+            local core = require("apisix.core")
+            local ctx = {_plugin_name = "test"}
+
+            -- Drive the body_filter chunks through a mocked ngx.arg, the same
+            -- way ngx feeds body_filter_by_lua: N data chunks then an eof marker
+            -- where ngx.arg[1] == "".
+            local t = ngx.arg
+            local metatable = getmetatable(t)
+            local chunk = string.rep("a", 16 * 1024)
+            local total_chunks = 8
+            local idx_call = 0
+            setmetatable(t, {__index = function(_, idx)
+                local step = math.floor(idx_call / 2)        -- which filter call
+                local which = idx_call % 2                    -- 0 -> arg[1], 1 -> arg[2]
+                if idx == 1 then
+                    idx_call = idx_call + 1
+                    if step < total_chunks then
+                        return chunk
+                    end
+                    return ""    -- eof marker chunk
+                end
+                -- idx == 2 (eof flag)
+                idx_call = idx_call + 1
+                return step >= total_chunks
+            end, __newindex = metatable.__newindex})
+
+            local final_body
+            for i = 1, total_chunks + 1 do
+                local res = core.response.hold_body_chunk(ctx, true, nil)
+                if res then
+                    final_body = res
+                end
+            end
+            setmetatable(t, metatable)
+
+            ngx.say("len: ", final_body and #final_body or "nil")
+            ngx.say("ok: ", final_body == string.rep("a", 16 * 1024 * total_chunks))
+        }
+    }
+--- request
+GET /t
+--- response_body
+len: 131072
+ok: true
+
+
+
+=== TEST 2: hold_body_chunk truncates at max_resp_body_bytes across chunks
+--- config
+    location = /t {
+        content_by_lua_block {
+            local core = require("apisix.core")
+            local ctx = {_plugin_name = "test"}
+
+            local t = ngx.arg
+            local metatable = getmetatable(t)
+            local chunk = string.rep("b", 50 * 1024)
+            local total_chunks = 4   -- 200K total, far above the limit
+            local max = 128 * 1024   -- 131072
+            local idx_call = 0
+            setmetatable(t, {__index = function(_, idx)
+                local step = math.floor(idx_call / 2)
+                if idx == 1 then
+                    idx_call = idx_call + 1
+                    if step < total_chunks then
+                        return chunk
+                    end
+                    return ""
+                end
+                idx_call = idx_call + 1
+                return step >= total_chunks
+            end, __newindex = metatable.__newindex})
+
+            local truncated
+            for i = 1, total_chunks + 1 do
+                local res = core.response.hold_body_chunk(ctx, true, max)
+                if res and not truncated then
+                    truncated = res
+                end
+            end
+            setmetatable(t, metatable)
+
+            ngx.say("len: ", truncated and #truncated or "nil")
+            ngx.say("ok: ", truncated == string.rep("b", max))
+        }
+    }
+--- request
+GET /t
+--- response_body
+len: 131072
+ok: true
+
+
+
+=== TEST 3: after truncation, later chunks and eof return nil (done flag)
+--- config
+    location = /t {
+        content_by_lua_block {
+            local core = require("apisix.core")
+            local ctx = {_plugin_name = "test"}
+
+            local t = ngx.arg
+            local metatable = getmetatable(t)
+            local chunk = string.rep("c", 100 * 1024)
+            local max = 128 * 1024
+            -- 4 filter calls:
+            --   call1: 100K chunk, below max          -> nil
+            --   call2: +100K = 200K >= max            -> truncated 128K
+            --   call3: another chunk, buffer done     -> nil
+            --   call4: eof marker, buffer done         -> nil
+            local plan = {
+                {chunk, false},
+                {chunk, false},
+                {chunk, false},
+                {"",    true},
+            }
+            local call = 0
+            local part = 1
+            setmetatable(t, {__index = function(_, idx)
+                local cur = plan[call + 1]
+                if idx == 1 then
+                    return cur[1]
+                end
+                -- arg[2]: advance to next call after reading eof flag
+                local eof = cur[2]
+                call = call + 1
+                return eof
+            end, __newindex = metatable.__newindex})
+
+            local r = {}
+            for i = 1, 4 do
+                r[i] = core.response.hold_body_chunk(ctx, true, max)
+            end
+            setmetatable(t, metatable)
+
+            ngx.say("r1: ", r[1] == nil)
+            ngx.say("r2_len: ", r[2] and #r[2] or "nil")
+            ngx.say("r2_ok: ", r[2] == string.rep("c", max))
+            ngx.say("r3: ", r[3] == nil)
+            ngx.say("r4: ", r[4] == nil)
+        }
+    }
+--- request
+GET /t
+--- response_body
+r1: true
+r2_len: 131072
+r2_ok: true
+r3: true
+r4: true
+
+
+
+=== TEST 4: single chunk that is also eof, truncated to max_resp_body_bytes
+--- config
+    location = /t {
+        content_by_lua_block {
+            local core = require("apisix.core")
+            local ctx = {_plugin_name = "test"}
+
+            local t = ngx.arg
+            local metatable = getmetatable(t)
+            local chunk = string.rep("d", 200 * 1024)
+            local max = 128 * 1024
+            -- single body_filter call: chunk present AND eof true, body above max.
+            -- The chunk is buffered, the byte limit is hit and a truncated body
+            -- is returned before the eof branch runs.
+            setmetatable(t, {__index = function(_, idx)
+                if idx == 1 then return chunk end
+                return true
+            end, __newindex = metatable.__newindex})
+
+            local res = core.response.hold_body_chunk(ctx, true, max)
+            setmetatable(t, metatable)
+
+            ngx.say("len: ", res and #res or "nil")
+            ngx.say("ok: ", res == string.rep("d", max))
+        }
+    }
+--- request
+GET /t
+--- response_body
+len: 131072
+ok: true
+
+
+
+=== TEST 5: small body, single chunk + eof, no max returns full body
+--- config
+    location = /t {
+        content_by_lua_block {
+            -- Same pattern as t/core/response.t TEST 8: arg[1] is the data on the
+            -- first call and "" on the eof call where arg[2] becomes true.
+            local t = ngx.arg
+            local metatable = getmetatable(t)
+            local count = 0
+            setmetatable(t, {__index = function(_, idx)
+                if count == 0 then
+                    if idx == 1 then
+                        return "hello "
+                    end
+                    count = count + 1
+                    return false
+                end
+                if count == 1 then
+                    if idx == 1 then
+                        return "world\n"
+                    end
+                    count = count + 1
+                    return true
+                end
+                return metatable.__index(t, idx)
+            end, __newindex = metatable.__newindex})
+
+            ngx.print("A")
+        }
+        body_filter_by_lua_block {
+            local core = require("apisix.core")
+            ngx.ctx._plugin_name = "test"
+            local final_body = core.response.hold_body_chunk(ngx.ctx)
+            if not final_body then
+                return
+            end
+            ngx.arg[1] = final_body
+        }
+    }
+--- request
+GET /t
+--- response_body
+hello world