fluentd 1.19.1 → 1.19.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7d0597141166c9db2f30b7ea1761610ec6dc2e3c5b8443f3ff980530c4afd33
-  data.tar.gz: eb02d36ab94976985da49b0abe845dfe17056806f02e99cb8fa38a88addb79be
+  metadata.gz: 9613f1dacdb60cfccb245e988e67cec002daee2f81cbe38c2b80c30d525ad7b8
+  data.tar.gz: 4a85aa6c3bdaebd9cd069d508ac969d8792586247bef1d73d25cc906f6cd7c87
 SHA512:
-  metadata.gz: cd04fb1ed5a9407cae8d150fdb5875cac15d5e906356ba76232e82cb4c28053199f9b09fa403fad5733623b758ec713defb205d8bcc6058e067a71f01c0ec30c
-  data.tar.gz: eba375ae694bf113a9a70bce6c77575ed42e6d8f14d5c463890ae570c14dfe48576eb7eecd90fb401480ebfd910ecd45fdfed1130f909b8c541440bdf7a3c407
+  metadata.gz: c2d63e0bd8cf51a61d254cfda559f38ed1bcc79ceb1bf1f0d0c80b21b922e67091d2ee8c291a0dc0fcac0110873d0045874df297e0795c0cd604af64f431f845
+  data.tar.gz: 5fe9e2450048bacc978389621b0e3f2c8aed0e9136ffe11192945a754173c1ce13ff50c310cfcdf1633d7dc784e14e9a4fc5a6de519da3bc81decb12f6d5b28d

data/CHANGELOG.md

@@ -1,5 +1,65 @@
 # v1.19
 
+## Release v1.19.3 - 2026/06/25
+
+### Bug Fix
+
+* out_http: add strict host validation for dynamic endpoints https://github.com/fluent/fluentd/pull/5394
+* buffer, in_http: enforce size limits on decompressed payloads https://github.com/fluent/fluentd/pull/5393
+* in_monitor_agent: change default visibility of config, retry, and debug info https://github.com/fluent/fluentd/pull/5392
+* output: enforce strict path boundary validation for tag https://github.com/fluent/fluentd/pull/5391
+* engine: remove duplicated word in unreloadable plugin error message https://github.com/fluent/fluentd/pull/5389
+* storage_local: fix encoding error when reading non-ASCII characters https://github.com/fluent/fluentd/pull/5382
+* parser_csv: skip empty or unparseable lines https://github.com/fluent/fluentd/pull/5359
+* out_forward: avoid reusing closed keepalive sockets after remote disconnects https://github.com/fluent/fluentd/pull/5343
+* buffer: resume buffer correctly even though path contains [] https://github.com/fluent/fluentd/pull/5305
+* in_debug_agent: accept only from local machine by default https://github.com/fluent/fluentd/pull/5279
+
+### Misc
+
+* gem: add win32-registry as runtime dependency for Ruby 4.1 https://github.com/fluent/fluentd/pull/5317
+* output windows: check shorter service timeout on shutdown https://github.com/fluent/fluentd/pull/5306
+* buffer: warn if default timekey (1d) will be used https://github.com/fluent/fluentd/pull/5291
+* warn recommended exclusion path for antivirus https://github.com/fluent/fluentd/pull/5280
+* CI fixes
+  * https://github.com/fluent/fluentd/pull/5387
+  * https://github.com/fluent/fluentd/pull/5386
+  * https://github.com/fluent/fluentd/pull/5366
+  * https://github.com/fluent/fluentd/pull/5342
+  * https://github.com/fluent/fluentd/pull/5341
+  * https://github.com/fluent/fluentd/pull/5340
+  * https://github.com/fluent/fluentd/pull/5339
+  * https://github.com/fluent/fluentd/pull/5338
+  * https://github.com/fluent/fluentd/pull/5337
+  * https://github.com/fluent/fluentd/pull/5336
+  * https://github.com/fluent/fluentd/pull/5335
+  * https://github.com/fluent/fluentd/pull/5334
+  * https://github.com/fluent/fluentd/pull/5333
+
+## Release v1.19.2 - 2026/02/13
+
+### Bug Fix
+
+* out_forward: add timeout to establish_connection to prevent infinite loop https://github.com/fluent/fluentd/pull/5138
+* gem: use latest net-http to solve IPv6 addr error https://github.com/fluent/fluentd/pull/5192
+* in_tail: fix error when files without read permission are included in glob patterns https://github.com/fluent/fluentd/pull/5222
+* command/fluentd: load win32/registry when edit registry for Ruby 4.0 https://github.com/fluent/fluentd/pull/5221
+* plugin_helper/http_server: Ensure request body is closed to prevent socket leaks in POST requests https://github.com/fluent/fluentd/pull/5234
+* config: fix duplicate config file loading in config_include_dir https://github.com/fluent/fluentd/pull/5235
+* gem: add ostruct gem as dependency for Ruby 4.0 https://github.com/fluent/fluentd/pull/5251
+
+### Misc
+
+* config: warn when backed-up config file will be included https://github.com/fluent/fluentd/pull/5252
+* filter_record_transformer: use cgi/escape to avoid Ruby 4.0 deprecation https://github.com/fluent/fluentd/pull/5256
+* CI fixes
+  * https://github.com/fluent/fluentd/pull/5257
+  * https://github.com/fluent/fluentd/pull/5229
+  * https://github.com/fluent/fluentd/pull/5225
+  * https://github.com/fluent/fluentd/pull/5186
+  * https://github.com/fluent/fluentd/pull/5184
+  * https://github.com/fluent/fluentd/pull/5176
+
 ## Release v1.19.1 - 2025/11/06
 
 ### Bug Fix

data/Rakefile

@@ -78,4 +78,11 @@ task :coverity do
   FileUtils.rm_rf(['./cov-int', 'cov-fluentd.tar.gz'])
 end
 
+task :check_env do
+  unless ENV['GEM_HOST_API_KEY']
+    abort "Missing required environment variable: GEM_HOST_API_KEY\nSee https://guides.rubygems.org/api-key-scopes/"
+  end
+end
+Rake::Task["release:rubygem_push"].enhance(["check_env"])
+
 task default: [:test, :build]

data/lib/fluent/command/fluentd.rb

@@ -344,6 +344,7 @@ if winsvcinstmode = opts[:regwinsvc]
 end
 
 if fluentdopt = opts[:fluentdopt]
+  require "win32/registry"
   Win32::Registry::HKEY_LOCAL_MACHINE.open("SYSTEM\\CurrentControlSet\\Services\\#{opts[:winsvc_name]}", Win32::Registry::KEY_ALL_ACCESS) do |reg|
     reg['fluentdopt', Win32::Registry::REG_SZ] = fluentdopt
   end

data/lib/fluent/config/v1_parser.rb

@@ -27,17 +27,18 @@ module Fluent
     class V1Parser < LiteralParser
       ELEMENT_NAME = /[a-zA-Z0-9_]+/
 
-      def self.parse(data, fname, basepath = Dir.pwd, eval_context = nil)
+      def self.parse(data, fname, basepath = Dir.pwd, eval_context = nil, on_file_parsed: nil)
         ss = StringScanner.new(data)
-        ps = V1Parser.new(ss, basepath, fname, eval_context)
+        ps = V1Parser.new(ss, basepath, fname, eval_context, on_file_parsed: on_file_parsed)
         ps.parse!
       end
 
-      def initialize(strscan, include_basepath, fname, eval_context)
+      def initialize(strscan, include_basepath, fname, eval_context, on_file_parsed: nil)
         super(strscan, eval_context)
         @include_basepath = include_basepath
         @fname = fname
         @logger = defined?($log) ? $log : nil
+        @on_file_parsed = on_file_parsed
       end
 
       def parse!
@@ -138,6 +139,8 @@ module Fluent
           end
         end
 
+        @on_file_parsed&.call(File.expand_path(File.join(@include_basepath, @fname))) if root_element
+
         return attrs, elems
       end
 
@@ -163,10 +166,15 @@ module Fluent
           Dir.glob(pattern).sort.each { |entry|
             basepath = File.dirname(entry)
             fname = File.basename(entry)
+            suspicious_backup_extensions = %w(bak old backup orig prev conf tmp temp debug wip)
+            if path.end_with?('*.conf') and
+              suspicious_backup_extensions.any? { |ext| fname.end_with?(".#{ext}.conf", "_#{ext}.conf") }
+              @logger.warn "There is a possibility that '@include #{uri}' includes duplicated backed-up config file such as <#{fname}>" if @logger
+            end
             data = File.read(entry)
             data.force_encoding('UTF-8')
             ss = StringScanner.new(data)
-            V1Parser.new(ss, basepath, fname, @eval_context).parse_element(true, nil, attrs, elems)
+            V1Parser.new(ss, basepath, fname, @eval_context, on_file_parsed: @on_file_parsed).parse_element(true, nil, attrs, elems)
           }
         else
           require 'open-uri'
@@ -175,7 +183,7 @@ module Fluent
           data = u.open { |f| f.read }
           data.force_encoding('UTF-8')
           ss = StringScanner.new(data)
-          V1Parser.new(ss, basepath, fname, @eval_context).parse_element(true, nil, attrs, elems)
+          V1Parser.new(ss, basepath, fname, @eval_context, on_file_parsed: @on_file_parsed).parse_element(true, nil, attrs, elems)
         end
       rescue SystemCallError => e
         cpe = ConfigParseError.new("include error #{uri} - #{e}")

data/lib/fluent/config/yaml_parser/loader.rb

@@ -30,9 +30,10 @@ module Fluent
         FLUENT_STR_TAG = 'tag:fluent/s'.freeze
         SHOVEL = '<<'.freeze
 
-        def initialize(context = Kernel.binding)
+        def initialize(context = Kernel.binding, on_file_parsed: nil)
           @context = context
           @current_path = nil
+          @on_file_parsed = on_file_parsed
         end
 
         # @param [String] path
@@ -55,9 +56,13 @@ module Fluent
             Fluent::Config::YamlParser::FluentValue::StringValue.new(val, @context)
           end
 
-          path.open do |f|
+          config = path.open do |f|
             visitor.accept(Psych.parse(f))
           end
+
+          @on_file_parsed&.call(File.expand_path(path.to_s))
+
+          config
         end
 
         def eval_include(path, parent)

data/lib/fluent/config/yaml_parser.rb

@@ -21,7 +21,7 @@ require 'pathname'
 module Fluent
   module Config
     module YamlParser
-      def self.parse(path)
+      def self.parse(path, on_file_parsed: nil)
         context = Kernel.binding
 
         unless context.respond_to?(:use_nil)
@@ -48,7 +48,7 @@ module Fluent
           end
         end
 
-        s = Fluent::Config::YamlParser::Loader.new(context).load(Pathname.new(path))
+        s = Fluent::Config::YamlParser::Loader.new(context, on_file_parsed: on_file_parsed).load(Pathname.new(path))
         Fluent::Config::YamlParser::Parser.new(s).build.to_element
       end
     end

data/lib/fluent/config.rb

@@ -26,7 +26,7 @@ module Fluent
     # @param additional_config [String] config which is added to last of config body
     # @param use_v1_config [Bool] config is formatted with v1 or not
     # @return [Fluent::Config]
-    def self.build(config_path:, encoding: 'utf-8', additional_config: nil, use_v1_config: true, type: nil)
+    def self.build(config_path:, encoding: 'utf-8', additional_config: nil, use_v1_config: true, type: nil, on_file_parsed: nil)
       if type == :guess
         config_file_ext = File.extname(config_path)
         if config_file_ext == '.yaml' || config_file_ext == '.yml'
@@ -35,7 +35,7 @@ module Fluent
       end
 
       if type == :yaml || type == :yml
-        return Fluent::Config::YamlParser.parse(config_path)
+        return Fluent::Config::YamlParser.parse(config_path, on_file_parsed: on_file_parsed)
       end
 
       config_fname = File.basename(config_path)
@@ -49,10 +49,10 @@ module Fluent
         s
       end
 
-      Fluent::Config.parse(config_data, config_fname, config_basedir, use_v1_config)
+      Fluent::Config.parse(config_data, config_fname, config_basedir, use_v1_config, on_file_parsed: on_file_parsed)
     end
 
-    def self.parse(str, fname, basepath = Dir.pwd, v1_config = nil, syntax: :v1)
+    def self.parse(str, fname, basepath = Dir.pwd, v1_config = nil, syntax: :v1, on_file_parsed: nil)
       parser = if fname =~ /\.rb$/ || syntax == :ruby
                  :ruby
                elsif v1_config.nil?
@@ -68,7 +68,7 @@ module Fluent
       case parser
       when :v1
         require 'fluent/config/v1_parser'
-        V1Parser.parse(str, fname, basepath, Kernel.binding)
+        V1Parser.parse(str, fname, basepath, Kernel.binding, on_file_parsed: on_file_parsed)
       when :v0
         # TODO: show deprecated message in v1
         require 'fluent/config/parser'

data/lib/fluent/engine.rb

@@ -186,7 +186,7 @@ module Fluent
 
         ret.all_plugins.each do |plugin|
           if plugin.respond_to?(:reloadable_plugin?) && !plugin.reloadable_plugin?
-            raise Fluent::ConfigError, "Unreloadable plugin plugin: #{Fluent::Plugin.lookup_type_from_class(plugin.class)}, plugin_id: #{plugin.plugin_id}, class_name: #{plugin.class})"
+            raise Fluent::ConfigError, "Unreloadable plugin: #{Fluent::Plugin.lookup_type_from_class(plugin.class)}, plugin_id: #{plugin.plugin_id}, class_name: #{plugin.class})"
           end
         end
 

data/lib/fluent/event.rb

@@ -268,11 +268,12 @@ module Fluent
   end
 
   class CompressedMessagePackEventStream < MessagePackEventStream
-    def initialize(data, cached_unpacker = nil, size = 0, unpacked_times: nil, unpacked_records: nil, compress: :gzip)
+    def initialize(data, cached_unpacker = nil, size = 0, unpacked_times: nil, unpacked_records: nil, compress: :gzip, decompression_size_limit: Fluent::Plugin::Compressable::DEFAULT_DECOMPRESSION_SIZE_LIMIT)
       super(data, cached_unpacker, size, unpacked_times: unpacked_times, unpacked_records: unpacked_records)
       @decompressed_data = nil
       @compressed_data = data
       @type = compress
+      @decompression_size_limit = decompression_size_limit
     end
 
     def empty?

data/lib/fluent/plugin/buf_file.rb

@@ -205,7 +205,7 @@ module Fluent
       def generate_chunk(metadata)
         # FileChunk generates real path with unique_id
         perm = @file_permission || system_config.file_permission
-        chunk = Fluent::Plugin::Buffer::FileChunk.new(metadata, @path, :create, perm: perm, compress: @compress)
+        chunk = Fluent::Plugin::Buffer::FileChunk.new(metadata, @path, :create, perm: perm, compress: @compress, decompression_size_limit: @decompression_size_limit)
         log.debug "Created new chunk", chunk_id: dump_unique_id_hex(chunk.unique_id), metadata: metadata
 
         return chunk
@@ -247,8 +247,8 @@ module Fluent
 
       def escaped_patterns(patterns)
         patterns.map { |pattern|
-          # '{' '}' are special character in Dir.glob
-          pattern.gsub(/[\{\}]/) { |c| "\\#{c}" }
+          # '{', '}', '[' and ']' are special character in Dir.glob
+          pattern.gsub(/[\{\}\[\]]/) { |c| "\\#{c}" }
         }
       end
     end

data/lib/fluent/plugin/buf_file_single.rb

@@ -183,7 +183,7 @@ module Fluent
           end
 
           begin
-            chunk = Fluent::Plugin::Buffer::FileSingleChunk.new(m, path, mode, @key_in_path, compress: @compress)
+            chunk = Fluent::Plugin::Buffer::FileSingleChunk.new(m, path, mode, @key_in_path, compress: @compress, decompression_size_limit: @decompression_size_limit)
             chunk.restore_size(@chunk_format) if @calc_num_records
           rescue Fluent::Plugin::Buffer::FileSingleChunk::FileChunkError => e
             exist_broken_file = true
@@ -216,7 +216,7 @@ module Fluent
       def generate_chunk(metadata)
         # FileChunk generates real path with unique_id
         perm = @file_permission || system_config.file_permission
-        chunk = Fluent::Plugin::Buffer::FileSingleChunk.new(metadata, @path, :create, @key_in_path, perm: perm, compress: @compress)
+        chunk = Fluent::Plugin::Buffer::FileSingleChunk.new(metadata, @path, :create, @key_in_path, perm: perm, compress: @compress, decompression_size_limit: @decompression_size_limit)
 
         log.debug "Created new chunk", chunk_id: dump_unique_id_hex(chunk.unique_id), metadata: metadata
 

data/lib/fluent/plugin/buf_memory.rb

@@ -27,7 +27,7 @@ module Fluent
       end
 
       def generate_chunk(metadata)
-        Fluent::Plugin::Buffer::MemoryChunk.new(metadata, compress: @compress)
+        Fluent::Plugin::Buffer::MemoryChunk.new(metadata, compress: @compress, decompression_size_limit: @decompression_size_limit)
       end
     end
   end

data/lib/fluent/plugin/buffer/chunk.rb

@@ -48,7 +48,7 @@ module Fluent
 
         # TODO: CompressedPackedMessage of forward protocol?
 
-        def initialize(metadata, compress: :text)
+        def initialize(metadata, compress: :text, decompression_size_limit: Compressable::DEFAULT_DECOMPRESSION_SIZE_LIMIT)
           super()
           @unique_id = generate_unique_id
           @metadata = metadata
@@ -64,6 +64,7 @@ module Fluent
           elsif compress == :zstd
             extend ZstdDecompressable
           end
+          @decompression_size_limit = decompression_size_limit
         end
 
         attr_reader :unique_id, :metadata, :state

data/lib/fluent/plugin/buffer/file_chunk.rb

@@ -39,8 +39,8 @@ module Fluent
 
         attr_reader :path, :meta_path, :permission
 
-        def initialize(metadata, path, mode, perm: nil, compress: :text)
-          super(metadata, compress: compress)
+        def initialize(metadata, path, mode, perm: nil, compress: :text, decompression_size_limit: Compressable::DEFAULT_DECOMPRESSION_SIZE_LIMIT)
+          super(metadata, compress: compress, decompression_size_limit: decompression_size_limit)
           perm ||= Fluent::DEFAULT_FILE_PERMISSION
           @permission = perm.is_a?(String) ? perm.to_i(8) : perm
           @bytesize = @size = @adding_bytes = @adding_size = 0

data/lib/fluent/plugin/buffer/file_single_chunk.rb

@@ -35,8 +35,8 @@ module Fluent
 
         attr_reader :path, :permission
 
-        def initialize(metadata, path, mode, key, perm: Fluent::DEFAULT_FILE_PERMISSION, compress: :text)
-          super(metadata, compress: compress)
+        def initialize(metadata, path, mode, key, perm: Fluent::DEFAULT_FILE_PERMISSION, compress: :text, decompression_size_limit: Compressable::DEFAULT_DECOMPRESSION_SIZE_LIMIT)
+          super(metadata, compress: compress, decompression_size_limit: decompression_size_limit)
           @key = key
           perm ||= Fluent::DEFAULT_FILE_PERMISSION
           @permission = perm.is_a?(String) ? perm.to_i(8) : perm

data/lib/fluent/plugin/buffer/memory_chunk.rb

@@ -20,7 +20,7 @@ module Fluent
   module Plugin
     class Buffer
       class MemoryChunk < Chunk
-        def initialize(metadata, compress: :text)
+        def initialize(metadata, compress: :text, decompression_size_limit: Compressable::DEFAULT_DECOMPRESSION_SIZE_LIMIT)
           super
           @chunk = ''.force_encoding(Encoding::ASCII_8BIT)
           @chunk_bytes = 0

data/lib/fluent/plugin/buffer.rb

@@ -66,6 +66,9 @@ module Fluent
       desc 'Compress buffered data.'
       config_param :compress, :enum, list: [:text, :gzip, :zstd], default: :text
 
+      desc 'The size limit of the decompressed element.'
+      config_param :decompression_size_limit, :size, default: Compressable::DEFAULT_DECOMPRESSION_SIZE_LIMIT
+
       desc 'If true, chunks are thrown away when unrecoverable error happens'
       config_param :disable_chunk_backup, :bool, default: false
 

data/lib/fluent/plugin/compressable.rb

@@ -14,6 +14,7 @@
 #    limitations under the License.
 #
 
+require 'fluent/plugin/extractor'
 require 'stringio'
 require 'zlib'
 require 'zstd-ruby'
@@ -21,6 +22,8 @@ require 'zstd-ruby'
 module Fluent
   module Plugin
     module Compressable
+      DEFAULT_DECOMPRESSION_SIZE_LIMIT = 256 * 1024 * 1024
+
       def compress(data, type: :gzip, **kwargs)
         output_io = kwargs[:output_io]
         io = output_io || StringIO.new
@@ -60,79 +63,21 @@ module Fluent
 
       private
 
-      def string_decompress_gzip(compressed_data)
-        io = StringIO.new(compressed_data)
-        out = ''
-        loop do
-          reader = Zlib::GzipReader.new(io)
-          out << reader.read
-          unused = reader.unused
-          reader.finish
-          unless unused.nil?
-            adjust = unused.length
-            io.pos -= adjust
-          end
-          break if io.eof?
-        end
-        out
-      end
-
-      def string_decompress_zstd(compressed_data)
-        io = StringIO.new(compressed_data)
-        reader = Zstd::StreamReader.new(io)
-        out = ''
-        loop do
-          # Zstd::StreamReader needs to specify the size of the buffer
-          out << reader.read(1024)
-          # Zstd::StreamReader doesn't provide unused data, so we have to manually adjust the position
-          break if io.eof?
-        end
-        out
-      end
-
       def string_decompress(compressed_data, type = :gzip)
         if type == :gzip
-          string_decompress_gzip(compressed_data)
+          Extractor.decompress_gzip(compressed_data, limit: @decompression_size_limit || DEFAULT_DECOMPRESSION_SIZE_LIMIT)
         elsif type == :zstd
-          string_decompress_zstd(compressed_data)
+          Extractor.decompress_zstd(compressed_data, limit: @decompression_size_limit || DEFAULT_DECOMPRESSION_SIZE_LIMIT)
         else
           raise ArgumentError, "Unknown compression type: #{type}"
         end
       end
 
-      def io_decompress_gzip(input, output)
-        loop do
-          reader = Zlib::GzipReader.new(input)
-          v = reader.read
-          output.write(v)
-          unused = reader.unused
-          reader.finish
-          unless unused.nil?
-            adjust = unused.length
-            input.pos -= adjust
-          end
-          break if input.eof?
-        end
-        output
-      end
-
-      def io_decompress_zstd(input, output)
-        reader = Zstd::StreamReader.new(input)
-        loop do
-          # Zstd::StreamReader needs to specify the size of the buffer
-          v = reader.read(1024)
-          output.write(v)
-          # Zstd::StreamReader doesn't provide unused data, so we have to manually adjust the position
-          break if input.eof?
-        end
-        output
-      end
-
       def io_decompress(input, output, type = :gzip)
         if type == :gzip
-          io_decompress_gzip(input, output)
+          Extractor.io_decompress_gzip(input, output)
         elsif type == :zstd
-          io_decompress_zstd(input, output)
+          Extractor.io_decompress_zstd(input, output)
         else
           raise ArgumentError, "Unknown compression type: #{type}"
         end

data/lib/fluent/plugin/extractor.rb

@@ -0,0 +1,121 @@
+#
+# Fluentd
+#
+#    Licensed 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.
+#
+
+require 'stringio'
+require 'zlib'
+require 'zstd-ruby'
+require 'fluent/error'
+
+module Fluent
+  module Plugin
+    module Extractor
+      class SizeLimitError < UnrecoverableError; end
+
+      BYTES_TO_READ = 64 * 1024
+      INFLATE_BYTES_TO_READ = 1024
+
+      def self.decompress_gzip(compressed_data, limit:)
+        io = StringIO.new(compressed_data)
+        out = ''
+        loop do
+          reader = Zlib::GzipReader.new(io)
+          while (chunk = reader.read(BYTES_TO_READ))
+            out << chunk
+            if out.bytesize > limit
+              raise SizeLimitError, "Decompressed data exceeds limit of #{limit} bytes"
+            end
+          end
+
+          unused = reader.unused
+          reader.finish
+          unless unused.nil?
+            adjust = unused.length
+            io.pos -= adjust
+          end
+          break if io.eof?
+        end
+        out
+      end
+
+      def self.decompress_zstd(compressed_data, limit:)
+        io = StringIO.new(compressed_data)
+        reader = Zstd::StreamReader.new(io)
+        out = ''
+        loop do
+          # Zstd::StreamReader needs to specify the size of the buffer
+          out << reader.read(BYTES_TO_READ)
+          if out.bytesize > limit
+            raise SizeLimitError, "Decompressed data exceeds limit of #{limit} bytes"
+          end
+
+          # Zstd::StreamReader doesn't provide unused data, so we have to manually adjust the position
+          break if io.eof?
+        end
+        out
+      end
+
+      def self.decompress_deflate(compressed_data, limit:)
+        io = StringIO.new(compressed_data)
+        out = ''
+        begin
+          zstream = Zlib::Inflate.new
+          while (chunk = io.read(INFLATE_BYTES_TO_READ))
+            out << zstream.inflate(chunk)
+            if out.bytesize > limit
+              raise SizeLimitError, "Decompressed data exceeds limit of #{limit} bytes"
+            end
+          end
+          out << zstream.finish
+          if out.bytesize > limit
+            raise SizeLimitError, "Decompressed data exceeds limit of #{limit} bytes"
+          end
+        ensure
+          zstream&.close
+        end
+        out
+      end
+
+      def self.io_decompress_gzip(input, output)
+        loop do
+          reader = Zlib::GzipReader.new(input)
+          while (chunk = reader.read(BYTES_TO_READ))
+            output.write(chunk)
+          end
+          unused = reader.unused
+          reader.finish
+          unless unused.nil?
+            adjust = unused.length
+            input.pos -= adjust
+          end
+          break if input.eof?
+        end
+        output
+      end
+
+      def self.io_decompress_zstd(input, output)
+        reader = Zstd::StreamReader.new(input)
+        loop do
+          # Zstd::StreamReader needs to specify the size of the buffer
+          chunk = reader.read(BYTES_TO_READ)
+          output.write(chunk)
+          # Zstd::StreamReader doesn't provide unused data, so we have to manually adjust the position
+          break if input.eof?
+        end
+        output
+      end
+    end
+  end
+end

data/lib/fluent/plugin/filter_record_transformer.rb

@@ -71,7 +71,7 @@ module Fluent::Plugin
           # require utilities which would be used in ruby placeholders
           require 'pathname'
           require 'uri'
-          require 'cgi'
+          require 'cgi/escape'
           RubyPlaceholderExpander.new(placeholder_expander_params)
         else
           PlaceholderExpander.new(placeholder_expander_params)

data/lib/fluent/plugin/in_debug_agent.rb

@@ -26,7 +26,7 @@ module Fluent::Plugin
       super
     end
 
-    config_param :bind, :string, default: '0.0.0.0'
+    config_param :bind, :string, default: '127.0.0.1'
     config_param :port, :integer, default: 24230
     config_param :unix_path, :string, default: nil
     #config_param :unix_mode  # TODO

data/lib/fluent/plugin/in_forward.rb

@@ -54,6 +54,8 @@ module Fluent::Plugin
     config_param :chunk_size_warn_limit, :size, default: nil
     desc 'Received chunk is dropped if it is larger than this value.'
     config_param :chunk_size_limit, :size, default: nil
+    desc 'The size limit of the decompressed element.'
+    config_param :decompression_size_limit, :size, default: 256*1024*1024
     desc 'Skip an event if incoming event is invalid.'
     config_param :skip_invalid_event, :bool, default: true
 
@@ -311,7 +313,7 @@ module Fluent::Plugin
         size = option['size'] || 0
 
         if option['compressed'] && option['compressed'] != 'text'
-          es = Fluent::CompressedMessagePackEventStream.new(entries, nil, size.to_i, compress: option['compressed'].to_sym)
+          es = Fluent::CompressedMessagePackEventStream.new(entries, nil, size.to_i, compress: option['compressed'].to_sym, decompression_size_limit: @decompression_size_limit)
         else
           es = Fluent::MessagePackEventStream.new(entries, nil, size.to_i)
         end