fluentd 1.18.0 → 1.19.0

data/lib/fluent/plugin/out_forward.rb

@@ -87,7 +87,7 @@ module Fluent::Plugin
     config_param :verify_connection_at_startup, :bool, default: false
 
     desc 'Compress buffered data.'
-    config_param :compress, :enum, list: [:text, :gzip], default: :text
+    config_param :compress, :enum, list: [:text, :gzip, :zstd], default: :text
 
     desc 'The default version of TLS transport.'
     config_param :tls_version, :enum, list: Fluent::TLS::SUPPORTED_VERSIONS, default: Fluent::TLS::DEFAULT_VERSION
@@ -251,10 +251,14 @@ module Fluent::Plugin
       end
 
       unless @as_secondary
-        if @compress == :gzip && @buffer.compress == :text
-          @buffer.compress = :gzip
-        elsif @compress == :text && @buffer.compress == :gzip
-          log.info "buffer is compressed.  If you also want to save the bandwidth of a network, Add `compress` configuration in <match>"
+        if @buffer.compress == :text
+          @buffer.compress = @compress
+        else
+          if @compress == :text
+            log.info "buffer is compressed.  If you also want to save the bandwidth of a network, Add `compress` configuration in <match>"
+          elsif @compress != @buffer.compress
+            raise Fluent::ConfigError, "You cannot specify different compression formats for Buffer (Buffer: #{@buffer.compress}, Self: #{@compress})"
+          end
         end
       end
 
@@ -267,9 +271,15 @@ module Fluent::Plugin
       end
 
       raise Fluent::ConfigError, "ack_response_timeout must be a positive integer" if @ack_response_timeout < 1
+
+      if @compress == :zstd
+        log.warn "zstd compression feature is an experimental new feature supported since v1.19.0." +
+                 " Please make sure that the destination server also supports this feature before using it." +
+                 " in_forward plugin for Fluentd supports it since v1.19.0."
+      end
+
       @healthy_nodes_count_metrics = metrics_create(namespace: "fluentd", subsystem: "output", name: "healthy_nodes_count", help_text: "Number of count healthy nodes", prefer_gauge: true)
       @registered_nodes_count_metrics = metrics_create(namespace: "fluentd", subsystem: "output", name: "registered_nodes_count", help_text: "Number of count registered nodes", prefer_gauge: true)
-
     end
 
     def multi_workers_ready?
@@ -295,7 +305,7 @@ module Fluent::Plugin
       unless @heartbeat_type == :none
         if @heartbeat_type == :udp
           @usock = socket_create_udp(service_discovery_services.first.host, service_discovery_services.first.port, nonblock: true)
-          server_create_udp(:out_forward_heartbeat_receiver, 0, socket: @usock, max_bytes: @read_length, &method(:on_udp_heatbeat_response_recv))
+          server_create_udp(:out_forward_heartbeat_receiver, 0, socket: @usock, max_bytes: @read_length, &method(:on_udp_heartbeat_response_recv))
         end
         timer_execute(:out_forward_heartbeat_request, @heartbeat_interval, &method(:on_heartbeat_timer))
       end
@@ -481,7 +491,7 @@ module Fluent::Plugin
       end
     end
 
-    def on_udp_heatbeat_response_recv(data, sock)
+    def on_udp_heartbeat_response_recv(data, sock)
       sockaddr = Socket.pack_sockaddr_in(sock.remote_port, sock.remote_host)
       if node = service_discovery_services.find { |n| n.sockaddr == sockaddr }
         # log.trace "heartbeat arrived", name: node.name, host: node.host, port: node.port
@@ -567,8 +577,8 @@ module Fluent::Plugin
 
         @handshake = HandshakeProtocol.new(
           log: @log,
-          hostname: sender.security && sender.security.self_hostname,
-          shared_key: server.shared_key || (sender.security && sender.security.shared_key) || '',
+          hostname: sender.security&.self_hostname,
+          shared_key: server.shared_key || sender.security&.shared_key || '',
           password: server.password || '',
           username: server.username || '',
         )
@@ -584,7 +594,7 @@ module Fluent::Plugin
       attr_accessor :usock
 
       attr_reader :state
-      attr_reader :sockaddr  # used by on_udp_heatbeat_response_recv
+      attr_reader :sockaddr  # used by on_udp_heartbeat_response_recv
       attr_reader :failure # for test
 
       def validate_host_resolution!
@@ -711,7 +721,7 @@ module Fluent::Plugin
           end
         when :udp
           @usock.send "\0", 0, Socket.pack_sockaddr_in(@port, dest_addr)
-          # response is going to receive at on_udp_heatbeat_response_recv
+          # response is going to receive at on_udp_heartbeat_response_recv
           false
         when :none # :none doesn't use this class
           raise "BUG: heartbeat_type none must not use Node"
@@ -744,7 +754,7 @@ module Fluent::Plugin
       def resolve_dns!
         addrinfo_list = Socket.getaddrinfo(@host, @port, nil, Socket::SOCK_STREAM)
         addrinfo = @sender.dns_round_robin ? addrinfo_list.sample : addrinfo_list.first
-        @sockaddr = Socket.pack_sockaddr_in(addrinfo[1], addrinfo[3]) # used by on_udp_heatbeat_response_recv
+        @sockaddr = Socket.pack_sockaddr_in(addrinfo[1], addrinfo[3]) # used by on_udp_heartbeat_response_recv
         addrinfo[3]
       end
       private :resolve_dns!

data/lib/fluent/plugin/out_http.rb

@@ -270,7 +270,7 @@ module Fluent::Plugin
                               OpenSSL::SSL::VERIFY_PEER
                             end
         opt[:ciphers] = @tls_ciphers
-        opt[:ssl_version] = @tls_version
+        opt = Fluent::TLS.set_version_to_options(opt, @tls_version, nil, nil)
       end
 
       opt

data/lib/fluent/plugin/out_secondary_file.rb

@@ -98,11 +98,11 @@ module Fluent::Plugin
         raise Fluent::ConfigError, "out_secondary_file: basename or directory has an incompatible placeholder, remove time formats, like `%Y%m%d`, from basename or directory"
       end
 
-      if !@chunk_key_tag && (ph = placeholders.find { |placeholder| placeholder.match(/tag(\[\d+\])?/) })
+      if !@chunk_key_tag && (ph = placeholders.find { |placeholder| placeholder.match?(/tag(\[\d+\])?/) })
         raise Fluent::ConfigError, "out_secondary_file: basename or directory has an incompatible placeholder #{ph}, remove tag placeholder, like `${tag}`, from basename or directory"
       end
 
-      vars = placeholders.reject { |placeholder| placeholder.match(/tag(\[\d+\])?/) || (placeholder == 'chunk_id') }
+      vars = placeholders.reject { |placeholder| placeholder.match?(/tag(\[\d+\])?/) || (placeholder == 'chunk_id') }
 
       if ph = vars.find { |v| !@chunk_keys.include?(v) }
         raise Fluent::ConfigError, "out_secondary_file: basename or directory has an incompatible placeholder #{ph}, remove variable placeholder, like `${varname}`, from basename or directory"

data/lib/fluent/plugin/out_stdout.rb

@@ -25,6 +25,9 @@ module Fluent::Plugin
     DEFAULT_LINE_FORMAT_TYPE = 'stdout'
     DEFAULT_FORMAT_TYPE = 'json'
 
+    desc "If Fluentd logger outputs logs to a file (with -o option), this plugin outputs events to the file as well."
+    config_param :use_logger, :bool, default: true
+
     config_section :buffer do
       config_set_default :chunk_keys, ['tag']
       config_set_default :flush_at_shutdown, true
@@ -44,6 +47,10 @@ module Fluent::Plugin
       true
     end
 
+    def dest_io
+      @use_logger ? $log : $stdout
+    end
+
     attr_accessor :formatter
 
     def configure(conf)
@@ -57,9 +64,9 @@ module Fluent::Plugin
     def process(tag, es)
       es = inject_values_to_event_stream(tag, es)
       es.each {|time,record|
-        $log.write(format(tag, time, record))
+        dest_io.write(format(tag, time, record))
       }
-      $log.flush
+      dest_io.flush
     end
 
     def format(tag, time, record)
@@ -68,7 +75,7 @@ module Fluent::Plugin
     end
 
     def write(chunk)
-      chunk.write_to($log)
+      chunk.write_to(dest_io)
     end
   end
 end

data/lib/fluent/plugin/out_stream.rb

@@ -92,8 +92,8 @@ module Fluent
 
     def initialize
       super
-      $log.warn "'tcp' output is obsoleted and will be removed. Use 'forward' instead."
-      $log.warn "see 'forward' section in https://docs.fluentd.org/ for the high-availability configuration."
+      log.warn "'tcp' output is obsoleted and will be removed. Use 'forward' instead."
+      log.warn "see 'forward' section in https://docs.fluentd.org/ for the high-availability configuration."
     end
 
     config_param :port, :integer, default: LISTEN_PORT
@@ -114,7 +114,7 @@ module Fluent
 
     def initialize
       super
-      $log.warn "'unix' output is obsoleted and will be removed."
+      log.warn "'unix' output is obsoleted and will be removed."
     end
 
     config_param :path, :string

data/lib/fluent/plugin/output.rb

@@ -171,30 +171,6 @@ module Fluent
       # output_enqueue_thread_waiting: for test of output.rb itself
       attr_accessor :retry_for_error_chunk # if true, error flush will be retried even if under_plugin_development is true
 
-      def num_errors
-        @num_errors_metrics.get
-      end
-
-      def emit_count
-        @emit_count_metrics.get
-      end
-
-      def emit_size
-        @emit_size_metrics.get
-      end
-
-      def emit_records
-        @emit_records_metrics.get
-      end
-
-      def write_count
-        @write_count_metrics.get
-      end
-
-      def rollback_count
-        @rollback_count_metrics.get
-      end
-
       def initialize
         super
         @counter_mutex = Mutex.new
@@ -210,9 +186,11 @@ module Fluent
         @emit_records_metrics = nil
         @emit_size_metrics = nil
         @write_count_metrics = nil
+        @write_secondary_count_metrics = nil
         @rollback_count_metrics = nil
         @flush_time_count_metrics = nil
         @slow_flush_count_metrics = nil
+        @drop_oldest_chunk_count_metrics = nil
         @enable_size_metrics = false
 
         # How to process events is decided here at once, but it will be decided in delayed way on #configure & #start
@@ -278,9 +256,11 @@ module Fluent
         @emit_records_metrics = metrics_create(namespace: "fluentd", subsystem: "output", name: "emit_records", help_text: "Number of emit records")
         @emit_size_metrics =  metrics_create(namespace: "fluentd", subsystem: "output", name: "emit_size", help_text: "Total size of emit events")
         @write_count_metrics = metrics_create(namespace: "fluentd", subsystem: "output", name: "write_count", help_text: "Number of writing events")
+        @write_secondary_count_metrics = metrics_create(namespace: "fluentd", subsystem: "output", name: "write_secondary_count", help_text: "Number of writing events in secondary")
         @rollback_count_metrics = metrics_create(namespace: "fluentd", subsystem: "output", name: "rollback_count", help_text: "Number of rollbacking operations")
         @flush_time_count_metrics = metrics_create(namespace: "fluentd", subsystem: "output", name: "flush_time_count", help_text: "Count of flush time")
         @slow_flush_count_metrics = metrics_create(namespace: "fluentd", subsystem: "output", name: "slow_flush_count", help_text: "Count of slow flush occurred time(s)")
+        @drop_oldest_chunk_count_metrics = metrics_create(namespace: "fluentd", subsystem: "output", name: "drop_oldest_chunk_count", help_text: "Number of count that old chunk were discarded with drop_oldest_chunk")
 
         if has_buffer_section
           unless implement?(:buffered) || implement?(:delayed_commit)
@@ -572,7 +552,7 @@ module Fluent
             @output_flush_threads.each do |state|
               # to wakeup thread and make it to stop by itself
               state.mutex.synchronize {
-                if state.thread && state.thread.status
+                if state.thread&.status
                   state.next_clock = 0
                   state.cond_var.signal
                 end
@@ -999,6 +979,7 @@ module Fluent
               if oldest
                 log.warn "dropping oldest chunk to make space after buffer overflow", chunk_id: dump_unique_id_hex(oldest.unique_id)
                 @buffer.purge_chunk(oldest.unique_id)
+                @drop_oldest_chunk_count_metrics.inc
               else
                 log.error "no queued chunks to be dropped for drop_oldest_chunk"
               end
@@ -1014,13 +995,17 @@ module Fluent
       end
 
       FORMAT_MSGPACK_STREAM = ->(e){ e.to_msgpack_stream(packer: Fluent::MessagePackFactory.thread_local_msgpack_packer) }
-      FORMAT_COMPRESSED_MSGPACK_STREAM = ->(e){ e.to_compressed_msgpack_stream(packer: Fluent::MessagePackFactory.thread_local_msgpack_packer) }
+      FORMAT_COMPRESSED_MSGPACK_STREAM_GZIP = ->(e){ e.to_compressed_msgpack_stream(packer: Fluent::MessagePackFactory.thread_local_msgpack_packer) }
+      FORMAT_COMPRESSED_MSGPACK_STREAM_ZSTD = ->(e){ e.to_compressed_msgpack_stream(packer: Fluent::MessagePackFactory.thread_local_msgpack_packer, type: :zstd) }
       FORMAT_MSGPACK_STREAM_TIME_INT = ->(e){ e.to_msgpack_stream(time_int: true, packer: Fluent::MessagePackFactory.thread_local_msgpack_packer) }
-      FORMAT_COMPRESSED_MSGPACK_STREAM_TIME_INT = ->(e){ e.to_compressed_msgpack_stream(time_int: true, packer: Fluent::MessagePackFactory.thread_local_msgpack_packer) }
+      FORMAT_COMPRESSED_MSGPACK_STREAM_TIME_INT_GZIP = ->(e){ e.to_compressed_msgpack_stream(time_int: true, packer: Fluent::MessagePackFactory.thread_local_msgpack_packer) }
+      FORMAT_COMPRESSED_MSGPACK_STREAM_TIME_INT_ZSTD = ->(e){ e.to_compressed_msgpack_stream(time_int: true, packer: Fluent::MessagePackFactory.thread_local_msgpack_packer, type: :zstd) }
 
       def generate_format_proc
         if @buffer && @buffer.compress == :gzip
-          @time_as_integer ? FORMAT_COMPRESSED_MSGPACK_STREAM_TIME_INT : FORMAT_COMPRESSED_MSGPACK_STREAM
+          @time_as_integer ? FORMAT_COMPRESSED_MSGPACK_STREAM_TIME_INT_GZIP : FORMAT_COMPRESSED_MSGPACK_STREAM_GZIP
+        elsif @buffer && @buffer.compress == :zstd
+          @time_as_integer ? FORMAT_COMPRESSED_MSGPACK_STREAM_TIME_INT_ZSTD : FORMAT_COMPRESSED_MSGPACK_STREAM_ZSTD
         else
           @time_as_integer ? FORMAT_MSGPACK_STREAM_TIME_INT : FORMAT_MSGPACK_STREAM
         end
@@ -1036,17 +1021,17 @@ module Fluent
       #   iteration of event stream, and it should be done just once even if total event stream size
       #   is bigger than chunk_limit_size because of performance.
       def handle_stream_with_custom_format(tag, es, enqueue: false)
-        meta_and_data = {}
+        meta_and_data = Hash.new { |h, k| h[k] = [] }
         records = 0
         es.each(unpacker: Fluent::MessagePackFactory.thread_local_msgpack_unpacker) do |time, record|
           meta = metadata(tag, time, record)
-          meta_and_data[meta] ||= []
           res = format(tag, time, record)
           if res
             meta_and_data[meta] << res
             records += 1
           end
         end
+        meta_and_data.default_proc = nil
         write_guard do
           @buffer.write(meta_and_data, enqueue: enqueue)
         end
@@ -1057,14 +1042,14 @@ module Fluent
 
       def handle_stream_with_standard_format(tag, es, enqueue: false)
         format_proc = generate_format_proc
-        meta_and_data = {}
+        meta_and_data = Hash.new { |h, k| h[k] = MultiEventStream.new }
         records = 0
         es.each(unpacker: Fluent::MessagePackFactory.thread_local_msgpack_unpacker) do |time, record|
           meta = metadata(tag, time, record)
-          meta_and_data[meta] ||= MultiEventStream.new
           meta_and_data[meta].add(time, record)
           records += 1
         end
+        meta_and_data.default_proc = nil
         write_guard do
           @buffer.write(meta_and_data, format: format_proc, enqueue: enqueue)
         end
@@ -1146,7 +1131,7 @@ module Fluent
 
       def try_rollback_write
         @dequeued_chunks_mutex.synchronize do
-          while @dequeued_chunks.first && @dequeued_chunks.first.expired?
+          while @dequeued_chunks.first&.expired?
             info = @dequeued_chunks.shift
             if @buffer.takeback_chunk(info.chunk_id)
               @rollback_count_metrics.inc
@@ -1208,6 +1193,7 @@ module Fluent
           if output.delayed_commit
             log.trace "executing delayed write and commit", chunk: dump_unique_id_hex(chunk.unique_id)
             @write_count_metrics.inc
+            @write_secondary_count_metrics.inc if using_secondary
             @dequeued_chunks_mutex.synchronize do
               # delayed_commit_timeout for secondary is configured in <buffer> of primary (<secondary> don't get <buffer>)
               @dequeued_chunks << DequeuedChunkInfo.new(chunk.unique_id, Time.now, self.delayed_commit_timeout)
@@ -1220,6 +1206,7 @@ module Fluent
             dump_chunk_id = dump_unique_id_hex(chunk_id)
             log.trace "adding write count", instance: self.object_id
             @write_count_metrics.inc
+            @write_secondary_count_metrics.inc if using_secondary
             log.trace "executing sync write", chunk: dump_chunk_id
 
             output.write(chunk)
@@ -1389,7 +1376,7 @@ module Fluent
         @output_flush_thread_current_position = (@output_flush_thread_current_position + 1) % @buffer_config.flush_thread_count
         state = @output_flush_threads[@output_flush_thread_current_position]
         state.mutex.synchronize {
-          if state.thread && state.thread.status # "run"/"sleep"/"aborting" or false(successfully stop) or nil(killed by exception)
+          if state.thread&.status # "run"/"sleep"/"aborting" or false(successfully stop) or nil(killed by exception)
             state.next_clock = 0
             state.cond_var.signal
           else
@@ -1435,7 +1422,7 @@ module Fluent
       def flush_thread_wakeup
         @output_flush_threads.each do |state|
           state.mutex.synchronize {
-            if state.thread && state.thread.status
+            if state.thread&.status
               state.next_clock = 0
               state.cond_var.signal
             end
@@ -1587,9 +1574,11 @@ module Fluent
           'retry_count' => @num_errors_metrics.get,
           'emit_count' => @emit_count_metrics.get,
           'write_count' => @write_count_metrics.get,
+          'write_secondary_count' => @write_secondary_count_metrics.get,
           'rollback_count' => @rollback_count_metrics.get,
           'slow_flush_count' => @slow_flush_count_metrics.get,
           'flush_time_count' => @flush_time_count_metrics.get,
+          'drop_oldest_chunk_count' => @drop_oldest_chunk_count_metrics.get,
         }
 
         if @buffer && @buffer.respond_to?(:statistics)

data/lib/fluent/plugin/owned_by_mixin.rb

@@ -26,13 +26,13 @@ module Fluent
       end
 
       def owner
-        if instance_variable_defined?("@_owner")
+        if instance_variable_defined?(:@_owner)
           @_owner
         end
       end
 
       def log
-        if instance_variable_defined?("@log")
+        if instance_variable_defined?(:@log)
           @log
         end
       end

data/lib/fluent/plugin/parser.rb

@@ -29,7 +29,7 @@ module Fluent
     class Parser < Base
       class TimeoutChecker
         # This implementation now uses mutex because parser is typically used in input.
-        # If this has a performance issue under high concurreny, use concurrent-ruby's map instead.
+        # If this has a performance issue under high concurrent, use concurrent-ruby's map instead.
         def initialize(timeout)
           @map = {}
           @flag = ServerEngine::BlockingFlag.new
@@ -46,8 +46,8 @@ module Fluent
                 @map.keys.each { |th|
                   time = @map[th]
                   if now - time > @timeout
-                    th.raise UncatchableError, "parsing timed out"
                     @map.delete(th)
+                    th.raise UncatchableError, "parsing timed out"
                   end
                 }
               }
@@ -220,7 +220,7 @@ module Fluent
       end
 
       def string_like_null(value, null_empty_string = @null_empty_string, null_value_regexp = @null_value_pattern)
-        null_empty_string && value.empty? || null_value_regexp && string_safe_encoding(value){|s| null_value_regexp.match(s) }
+        null_empty_string && value.empty? || null_value_regexp && string_safe_encoding(value){|s| null_value_regexp.match?(s) }
       end
 
       TRUTHY_VALUES = ['true', 'yes', '1']

data/lib/fluent/plugin/parser_json.rb

@@ -52,9 +52,9 @@ module Fluent
         when :oj
           return [Oj.method(:load), Oj::ParseError] if Fluent::OjOptions.available?
 
-          log&.info "Oj is not installed, and failing back to Yajl for json parser"
-          configure_json_parser(:yajl)
-        when :json then [JSON.method(:load), JSON::ParserError]
+          log&.info "Oj is not installed, and failing back to JSON for json parser"
+          configure_json_parser(:json)
+        when :json then [JSON.method(:parse), JSON::ParserError]
         when :yajl then [Yajl.method(:load), Yajl::ParseError]
         else
           raise "BUG: unknown json parser specified: #{name}"

data/lib/fluent/plugin/sd_file.rb

@@ -27,7 +27,7 @@ module Fluent
       Plugin.register_sd('file', self)
 
       DEFAULT_FILE_TYPE = :yaml
-      DEFAUT_WEIGHT = 60
+      DEFAULT_WEIGHT = 60
       DEFAULT_SD_FILE_PATH = ENV['DEFAULT_SD_FILE_PATH'] || '/etc/fluent/sd.yaml'
 
       helpers :event_loop
@@ -126,7 +126,7 @@ module Fluent
             s.fetch('host'),
             s.fetch('port'),
             s['name'],
-            s.fetch('weight', DEFAUT_WEIGHT),
+            s.fetch('weight', DEFAULT_WEIGHT),
             s['standby'],
             s['username'],
             s['password'],

data/lib/fluent/plugin/storage_local.rb

@@ -19,7 +19,7 @@ require 'fluent/plugin'
 require 'fluent/plugin/storage'
 
 require 'fileutils'
-require 'yajl'
+require 'json'
 
 module Fluent
   module Plugin
@@ -90,7 +90,7 @@ module Fluent
                 log.warn "detect empty plugin storage file during startup. Ignored: #{@path}"
                 return
               end
-              data = Yajl::Parser.parse(data)
+              data = JSON.parse(data)
               raise Fluent::ConfigError, "Invalid contents (not object) in plugin storage file: '#{@path}'" unless data.is_a?(Hash)
             rescue => e
               log.error "failed to read data from plugin storage file", path: @path, error: e
@@ -114,7 +114,7 @@ module Fluent
         return unless File.exist?(@path)
         begin
           json_string = File.open(@path, 'r:utf-8'){ |io| io.read }
-          json = Yajl::Parser.parse(json_string)
+          json = JSON.parse(json_string)
           unless json.is_a?(Hash)
             log.error "broken content for plugin storage (Hash required: ignored)", type: json.class
             log.debug "broken content", content: json_string
@@ -130,7 +130,11 @@ module Fluent
         return if @on_memory
         tmp_path = @path + '.tmp.' + Fluent::UniqueId.hex(Fluent::UniqueId.generate)
         begin
-          json_string = Yajl::Encoder.encode(@store, pretty: @pretty_print)
+          if @pretty_print
+            json_string = JSON.pretty_generate(@store)
+          else
+            json_string = JSON.generate(@store)
+          end
           File.open(tmp_path, 'w:utf-8', @mode) { |io| io.write json_string; io.fsync }
           File.rename(tmp_path, @path)
         rescue => e

data/lib/fluent/plugin.rb

@@ -175,7 +175,7 @@ module Fluent
              else
                raise Fluent::ConfigError, "#{kind} plugin '#{type}' is not a Class nor callable (without arguments)."
              end
-      if parent && impl.respond_to?("owner=")
+      if parent && impl.respond_to?(:owner=)
         impl.owner = parent
       end
       impl.extend FeatureAvailabilityChecker

data/lib/fluent/plugin_helper/child_process.rb

@@ -143,7 +143,7 @@ module Fluent
         @_child_process_mutex.synchronize{ @_child_process_processes.keys }.each do |pid|
           process_info = @_child_process_processes[pid]
           next if !process_info
-          process_info.writeio && process_info.writeio.close rescue nil
+          process_info.writeio&.close rescue nil
         end
 
         super
@@ -183,7 +183,7 @@ module Fluent
 
             living_process_exist = true
 
-            process_info.killed_at ||= Fluent::Clock.now # for illegular case (e.g., created after shutdown)
+            process_info.killed_at ||= Fluent::Clock.now # for irregular case (e.g., created after shutdown)
             timeout_at = process_info.killed_at + @_child_process_kill_timeout
             now = Fluent::Clock.now
             next if now < timeout_at

data/lib/fluent/plugin_helper/http_server/request.rb

@@ -14,6 +14,7 @@
 #    limitations under the License.
 #
 
+require 'uri'
 require 'async/http/protocol'
 require 'fluent/plugin_helper/http_server/methods'
 
@@ -29,12 +30,22 @@ module Fluent
           @path, @query_string = path.split('?', 2)
         end
 
+        def headers
+          @request.headers
+        end
+
         def query
-          @query_string && CGI.parse(@query_string)
+          if @query_string
+            hash = Hash.new { |h, k| h[k] = [] }
+            # For compatibility with CGI.parse
+            URI.decode_www_form(@query_string).each_with_object(hash) do |(key, value), h|
+              h[key] << value
+            end
+          end
         end
 
         def body
-          @request.body && @request.body.read
+          @request.body&.read
         end
       end
     end

data/lib/fluent/plugin_helper/http_server/server.rb

@@ -68,11 +68,9 @@ module Fluent
               notify.push(:ready)
             end
 
-            if async_v2?
-              @server_task_queue = ::Thread::Queue.new
-              @server_task_queue.pop
-              @server_task&.stop
-            end
+            @server_task_queue = ::Thread::Queue.new
+            @server_task_queue.pop
+            @server_task&.stop
           end
 
           @logger.debug('Finished HTTP server')
@@ -80,11 +78,7 @@ module Fluent
 
         def stop
           @logger.debug('closing HTTP server')
-          if async_v2?
-            @server_task_queue&.push(:stop)
-          else
-            @server_task&.stop
-          end
+          @server_task_queue.push(:stop)
         end
 
         HttpServer::Methods::ALL.map { |e| e.downcase.to_sym }.each do |name|
@@ -100,10 +94,6 @@ module Fluent
             @router.mount(name, path, app || block)
           end
         end
-
-        private def async_v2?
-          Gem::Version.new(Async::VERSION) >= Gem::Version.new('2.0')
-        end
       end
     end
   end

data/lib/fluent/plugin_helper/http_server.rb

@@ -14,16 +14,9 @@
 #    limitations under the License.
 #
 
-begin
-  require 'async'
-  require 'fluent/plugin_helper/http_server/server'
-rescue LoadError => _
-  require 'fluent/plugin_helper/http_server/compat/server'
-  Fluent::PluginHelper::HttpServer::Server = Fluent::PluginHelper::HttpServer::Compat::Server
-end
-
 require 'fluent/plugin_helper/thread'
 require 'fluent/plugin_helper/server' # For Server::ServerTransportParams
+require 'fluent/plugin_helper/http_server/server'
 require 'fluent/plugin_helper/http_server/ssl_context_builder'
 
 module Fluent

data/lib/fluent/plugin_helper/metrics.rb

@@ -72,6 +72,13 @@ module Fluent
 
         @_metrics["#{@plugin_type_or_id}_#{namespace}_#{subsystem}_#{name}"] = metrics
 
+        # define the getter method for the calling instance.
+        singleton_class.module_eval do
+          unless method_defined?(name)
+            define_method(name) { metrics.get }
+          end
+        end
+
         metrics
       end
 

data/lib/fluent/plugin_helper/server.rb

@@ -356,7 +356,10 @@ module Fluent
       end
 
       def shutdown
-        @_server_connections.each do |conn|
+        # When it invokes conn.cose, it reduces elements in @_server_connections by close_callback,
+        # and it reduces the number of loops. This prevents the connection closing.
+        # So, it requires invoking #dup to avoid the problem.
+        @_server_connections.dup.each do |conn|
           conn.close rescue nil
         end
 

data/lib/fluent/plugin_helper/service_discovery.rb

@@ -91,7 +91,7 @@ module Fluent
       end
 
       # @param title [Symbol] the thread name. this value should be unique.
-      # @param configurations [Hash] hash which must has discivery_service type and its configuration like `{ type: :static, conf: <Fluent::Config::Element> }`
+      # @param configurations [Hash] hash which must has discovery_service type and its configuration like `{ type: :static, conf: <Fluent::Config::Element> }`
       # @param load_balancer [Object] object which has two methods #rebalance and #select_service
       # @param custom_build_method [Proc]
       def service_discovery_create_manager(title, configurations:, load_balancer: nil, custom_build_method: nil, interval: 3)

data/lib/fluent/plugin_helper/socket_option.rb

@@ -54,8 +54,8 @@ module Fluent
         if Fluent.windows?
           # To prevent closing socket forcibly on Windows,
           # this options shouldn't be set up when linger_timeout equals to 0 (including nil).
-          # This unintended behavior always ocurrs on Windows when linger_timeout.to_i == 0.
-          # This unintented behavior causes "Errno::ECONNRESET: An existing connection was forcibly
+          # This unintended behavior always occurs on Windows when linger_timeout.to_i == 0.
+          # This unintended behavior causes "Errno::ECONNRESET: An existing connection was forcibly
           # closed by the remote host." on Windows.
           if linger_timeout.to_i > 0
             if linger_timeout >= 2**16