fluentd 1.18.0 → 1.19.0

data/lib/fluent/plugin/in_tail.rb

@@ -36,7 +36,7 @@ module Fluent::Plugin
     helpers :timer, :event_loop, :parser, :compat_parameters
 
     RESERVED_CHARS = ['/', '*', '%'].freeze
-    MetricsInfo = Struct.new(:opened, :closed, :rotated, :throttled)
+    MetricsInfo = Struct.new(:opened, :closed, :rotated, :throttled, :tracked)
 
     class WatcherSetupError < StandardError
       def initialize(msg)
@@ -63,7 +63,7 @@ module Fluent::Plugin
 
     desc 'The paths to read. Multiple paths can be specified, separated by comma.'
     config_param :path, :string
-    desc 'path delimiter used for spliting path config'
+    desc 'path delimiter used for splitting path config'
     config_param :path_delimiter, :string, default: ','
     desc 'Choose using glob patterns. Adding capabilities to handle [] and ?, and {}.'
     config_param :glob_policy, :enum, list: [:backward_compatible, :extended, :always], default: :backward_compatible
@@ -96,9 +96,9 @@ module Fluent::Plugin
     config_param :enable_watch_timer, :bool, default: true
     desc 'Enable the stat watcher based on inotify.'
     config_param :enable_stat_watcher, :bool, default: true
-    desc 'The encoding after conversion of the input.'
-    config_param :encoding, :string, default: nil
     desc 'The encoding of the input.'
+    config_param :encoding, :string, default: nil
+    desc "The original encoding of the input. If set, in_tail tries to encode string from this to 'encoding'. Must be set with 'encoding'. "
     config_param :from_encoding, :string, default: nil
     desc 'Add the log path being tailed to records. Specify the field name to be used.'
     config_param :path_key, :string, default: nil
@@ -144,10 +144,10 @@ module Fluent::Plugin
       end
 
       if @glob_policy == :always && @path_delimiter == ','
-        raise Fluent::ConfigError, "cannot use glob_policy as always with the default path_delimitor: `,\""
+        raise Fluent::ConfigError, "cannot use glob_policy as always with the default path_delimiter: `,\""
       end
 
-      if @glob_policy == :extended && /\{.*,.*\}/.match(@path) && extended_glob_pattern(@path)
+      if @glob_policy == :extended && /\{.*,.*\}/.match?(@path) && extended_glob_pattern(@path)
         raise Fluent::ConfigError, "cannot include curly braces with glob patterns in `#{@path}\". Use glob_policy always instead."
       end
 
@@ -165,6 +165,7 @@ module Fluent::Plugin
         @path_formatters = @paths.map{|path| [path, Fluent::Timezone.formatter(@path_timezone, path)]}.to_h
         @exclude_path_formatters = @exclude_path.map{|path| [path, Fluent::Timezone.formatter(@path_timezone, path)]}.to_h
       end
+      check_dir_permission unless Fluent.windows?
 
       # TODO: Use plugin_root_dir and storage plugin to store positions if available
       if @pos_file
@@ -177,14 +178,14 @@ module Fluent::Plugin
         if @follow_inodes
           raise Fluent::ConfigError, "Can't follow inodes without pos_file configuration parameter"
         end
-        $log.warn "'pos_file PATH' parameter is not set to a 'tail' source."
-        $log.warn "this parameter is highly recommended to save the position to resume tailing."
+        log.warn "'pos_file PATH' parameter is not set to a 'tail' source."
+        log.warn "this parameter is highly recommended to save the position to resume tailing."
       end
 
       configure_tag
       configure_encoding
 
-      @multiline_mode = parser_config["@type"] =~ /multiline/
+      @multiline_mode = parser_config["@type"].include?("multiline")
       @receive_handler = if @multiline_mode
                            method(:parse_multilines)
                          else
@@ -205,11 +206,29 @@ module Fluent::Plugin
           @read_bytes_limit_per_second = min_bytes
         end
       end
+
       opened_file_metrics = metrics_create(namespace: "fluentd", subsystem: "input", name: "files_opened_total", help_text: "Total number of opened files")
       closed_file_metrics = metrics_create(namespace: "fluentd", subsystem: "input", name: "files_closed_total", help_text: "Total number of closed files")
       rotated_file_metrics = metrics_create(namespace: "fluentd", subsystem: "input", name: "files_rotated_total", help_text: "Total number of rotated files")
       throttling_metrics = metrics_create(namespace: "fluentd", subsystem: "input", name: "files_throttled_total", help_text: "Total number of times throttling occurs per file when throttling enabled")
-      @metrics = MetricsInfo.new(opened_file_metrics, closed_file_metrics, rotated_file_metrics, throttling_metrics)
+      # The metrics for currently tracking files. Since the value may decrease, it cannot be represented using the counter type, so 'prefer_gauge: true' is used instead.
+      tracked_file_metrics = metrics_create(namespace: "fluentd", subsystem: "input", name: "files_tracked_count", help_text: "Number of tracked files", prefer_gauge: true)
+
+      @metrics = MetricsInfo.new(opened_file_metrics, closed_file_metrics, rotated_file_metrics, throttling_metrics, tracked_file_metrics)
+    end
+
+    def check_dir_permission
+      expand_paths_raw.select { |path|
+        not File.exist?(path)
+      }.each { |path|
+        inaccessible_dir = Pathname.new(File.expand_path(path))
+          .ascend
+          .reverse_each
+          .find { |p| p.directory? && !p.executable? }
+        if inaccessible_dir
+          log.warn "Skip #{path} because '#{inaccessible_dir}' lacks execute permission."
+        end
+      }
     end
 
     def configure_tag
@@ -290,7 +309,7 @@ module Fluent::Plugin
     def close
       super
       # close file handles after all threads stopped (in #close of thread plugin helper)
-      # It may be because we need to wait IOHanlder.ready_to_shutdown()
+      # It may be because we need to wait IOHandler.ready_to_shutdown()
       close_watcher_handles
     end
 
@@ -300,7 +319,7 @@ module Fluent::Plugin
     end
 
     def extended_glob_pattern(path)
-      path.include?('*') || path.include?('?') || /\[.*\]/.match(path)
+      path.include?('*') || path.include?('?') || /\[.*\]/.match?(path)
     end
 
     # Curly braces is not supported with default path_delimiter
@@ -313,7 +332,7 @@ module Fluent::Plugin
         # regular expressions as much as possible.
         # This is because not using `true' as a returning value
         # when choosing :always here.
-        extended_glob_pattern(path) || /\{.*,.*\}/.match(path)
+        extended_glob_pattern(path) || /\{.*,.*\}/.match?(path)
       elsif @glob_policy == :extended
         extended_glob_pattern(path)
       elsif @glob_policy == :backward_compatible
@@ -321,7 +340,7 @@ module Fluent::Plugin
       end
     end
 
-    def expand_paths
+    def expand_paths_raw
       date = Fluent::EventTime.now
       paths = []
       @paths.each { |path|
@@ -350,7 +369,7 @@ module Fluent::Plugin
                 false
               end
             rescue Errno::ENOENT, Errno::EACCES
-              log.debug("#{p} is missing after refresh file list")
+              log.debug { "#{p} is missing after refresh file list" }
               false
             end
           }
@@ -367,10 +386,14 @@ module Fluent::Plugin
                end
         use_glob?(path) ? Dir.glob(path) : path
       }.flatten.uniq
+      paths - excluded
+    end
+
+    def expand_paths
       # filter out non existing files, so in case pattern is without '*' we don't do unnecessary work
       hash = {}
-      (paths - excluded).select { |path|
-        FileTest.exist?(path)
+      expand_paths_raw.select { |path|
+        File.exist?(path)
       }.each { |path|
         # Even we just checked for existence, there is a race condition here as
         # of which stat() might fail with ENOENT. See #3224.
@@ -382,7 +405,7 @@ module Fluent::Plugin
             hash[target_info.path] = target_info
           end
         rescue Errno::ENOENT, Errno::EACCES  => e
-          $log.warn "expand_paths: stat() for #{path} failed with #{e.class.name}. Skip file."
+          log.warn "expand_paths: stat() for #{path} failed with #{e.class.name}. Skip file."
         end
       }
       hash
@@ -431,7 +454,7 @@ module Fluent::Plugin
       removed_hash = existence_paths_hash.reject {|key, value| target_paths_hash.key?(key)}
       added_hash = target_paths_hash.reject {|key, value| existence_paths_hash.key?(key)}
 
-      # If an exisiting TailWatcher already follows a target path with the different inode,
+      # If an existing TailWatcher already follows a target path with the different inode,
       # it means that the TailWatcher following the rotated file still exists. In this case,
       # `refresh_watcher` can't start the new TailWatcher for the new current file. So, we
       # should output a warning log in order to prevent silent collection stops.
@@ -455,6 +478,7 @@ module Fluent::Plugin
 
       stop_watchers(removed_hash, unwatched: need_unwatch_in_stop_watchers) unless removed_hash.empty?
       start_watchers(added_hash) unless added_hash.empty?
+      @metrics.tracked.set(@tails.size)
       @startup = false if @startup
     end
 
@@ -499,7 +523,7 @@ module Fluent::Plugin
       begin
         target_info.ino = Fluent::FileWrapper.stat(path).ino
       rescue Errno::ENOENT, Errno::EACCES
-        $log.warn "stat() for #{path} failed. Continuing without tailing it."
+        log.warn "stat() for #{path} failed. Continuing without tailing it."
         return
       end
 
@@ -562,7 +586,7 @@ module Fluent::Plugin
     # refresh_watchers calls @tails.keys so we don't use stop_watcher -> start_watcher sequence for safety.
     def update_watcher(tail_watcher, pe, new_inode)
       # TODO we should use another callback for this.
-      # To supress impact to existing logics, limit the case to `@follow_inodes`.
+      # To suppress impact to existing logics, limit the case to `@follow_inodes`.
       # We may not need `@follow_inodes` condition.
       if @follow_inodes && new_inode.nil?
         # nil inode means the file disappeared, so we only need to stop it.
@@ -574,7 +598,7 @@ module Fluent::Plugin
         # In that case, `refresh_watcher` will add the new TailWatcher to tail the same target,
         # and it causes the log duplication.
         # (Other `detach_watcher_after_rotate_wait` may have the same problem.
-        #  We need the mechanism not to add duplicated TailWathcer with detaching TailWatcher.)
+        #  We need the mechanism not to add duplicated TailWatcher with detaching TailWatcher.)
         detach_watcher_after_rotate_wait(tail_watcher, pe.read_inode)
         return
       end
@@ -730,7 +754,7 @@ module Fluent::Plugin
               record[@path_key] ||= tail_watcher.path unless @path_key.nil?
               es.add(Fluent::EventTime.now, record)
             end
-            log.warn "pattern not matched: #{line.inspect}"
+            log.warn { "pattern not matched: #{line.inspect}" }
           end
         }
       rescue => e
@@ -795,6 +819,7 @@ module Fluent::Plugin
           'closed_file_count' => @metrics.closed.get,
           'rotated_file_count' => @metrics.rotated.get,
           'throttled_log_count' => @metrics.throttled.get,
+          'tracked_file_count' => @metrics.tracked.get,
         })
       }
       stats
@@ -803,17 +828,27 @@ module Fluent::Plugin
     private
 
     def io_handler(watcher, path)
-      TailWatcher::IOHandler.new(
-        watcher,
+      opts = {
         path: path,
         log: log,
         read_lines_limit: @read_lines_limit,
         read_bytes_limit_per_second: @read_bytes_limit_per_second,
         open_on_every_update: @open_on_every_update,
-        from_encoding: @from_encoding,
-        encoding: @encoding,
         metrics: @metrics,
         max_line_size: @max_line_size,
+      }
+      unless @encoding.nil?
+        if @from_encoding.nil?
+          opts[:encoding] = @encoding
+        else
+          opts[:encoding] = @from_encoding
+          opts[:encoding_to_convert] = @encoding
+        end
+      end
+
+      TailWatcher::IOHandler.new(
+        watcher,
+        **opts,
         &method(:receive_lines)
       )
     end
@@ -1006,46 +1041,30 @@ module Fluent::Plugin
       end
 
       class FIFO
-        def initialize(from_encoding, encoding, log, max_line_size=nil)
-          @from_encoding = from_encoding
-          @encoding = encoding
-          @need_enc = from_encoding != encoding
-          @buffer = ''.force_encoding(from_encoding)
-          @eol = "\n".encode(from_encoding).freeze
+        def initialize(encoding, log, max_line_size=nil, encoding_to_convert=nil)
+          @buffer = ''.force_encoding(encoding)
+          @eol = "\n".encode(encoding).freeze
+          @encoding_to_convert = encoding_to_convert
           @max_line_size = max_line_size
           @skip_current_line = false
           @skipping_current_line_bytesize = 0
           @log = log
         end
 
-        attr_reader :from_encoding, :encoding, :buffer, :max_line_size
+        attr_reader :buffer, :max_line_size
 
         def <<(chunk)
-          # Although "chunk" is most likely transient besides String#force_encoding itself
-          # won't affect the actual content of it, it is also probable that "chunk" is
-          # a reused buffer and changing its encoding causes some problems on the caller side.
-          #
-          # Actually, the caller here is specific and "chunk" comes from IO#partial with
-          # the second argument, which the function always returns as a return value.
-          #
-          # Feeding a string that has its encoding attribute set to any double-byte or
-          # quad-byte encoding to IO#readpartial as the second arguments results in an
-          # assertion failure on Ruby < 2.4.0 for unknown reasons.
-          orig_encoding = chunk.encoding
-          chunk.force_encoding(from_encoding)
           @buffer << chunk
-          # Thus the encoding needs to be reverted back here
-          chunk.force_encoding(orig_encoding)
         end
 
         def convert(s)
-          if @need_enc
-            s.encode!(@encoding, @from_encoding)
+          if @encoding_to_convert
+            s.encode!(@encoding_to_convert)
           else
             s
           end
         rescue
-          s.encode!(@encoding, @from_encoding, :invalid => :replace, :undef => :replace)
+          s.encode!(@encoding_to_convert, :invalid => :replace, :undef => :replace)
         end
 
         def read_lines(lines)
@@ -1056,8 +1075,9 @@ module Fluent::Plugin
             # Using freeze and slice is faster than slice!
             # See https://github.com/fluent/fluentd/pull/2527
             @buffer.freeze
-            rbuf = @buffer.slice(0, idx + 1)
-            @buffer = @buffer.slice(idx + 1, @buffer.size)
+            slice_position = idx + 1
+            rbuf = @buffer.slice(0, slice_position)
+            @buffer = @buffer.slice(slice_position, @buffer.size - slice_position)
             idx = @buffer.index(@eol)
 
             is_long_line = @max_line_size && (
@@ -1110,15 +1130,15 @@ module Fluent::Plugin
 
         attr_accessor :shutdown_timeout
 
-        def initialize(watcher, path:, read_lines_limit:, read_bytes_limit_per_second:, max_line_size: nil, log:, open_on_every_update:, from_encoding: nil, encoding: nil, metrics:, &receive_lines)
+        def initialize(watcher, path:, read_lines_limit:, read_bytes_limit_per_second:, max_line_size: nil, log:, open_on_every_update:, encoding: Encoding::ASCII_8BIT, encoding_to_convert: nil, metrics:, &receive_lines)
           @watcher = watcher
           @path = path
           @read_lines_limit = read_lines_limit
           @read_bytes_limit_per_second = read_bytes_limit_per_second
           @receive_lines = receive_lines
           @open_on_every_update = open_on_every_update
-          @fifo = FIFO.new(from_encoding || Encoding::ASCII_8BIT, encoding || Encoding::ASCII_8BIT, log, max_line_size)
-          @iobuf = ''.force_encoding('ASCII-8BIT')
+          @encoding = encoding
+          @fifo = FIFO.new(encoding, log, max_line_size, encoding_to_convert)
           @lines = []
           @io = nil
           @notify_mutex = Mutex.new
@@ -1200,6 +1220,7 @@ module Fluent::Plugin
           end
 
           with_io do |io|
+            iobuf = ''.force_encoding(@encoding)
             begin
               read_more = false
               has_skipped_line = false
@@ -1210,7 +1231,7 @@ module Fluent::Plugin
                     @start_reading_time ||= Fluent::Clock.now
                     group_watcher&.update_reading_time(@path)
 
-                    data = io.readpartial(BYTES_TO_READ, @iobuf)
+                    data = io.readpartial(BYTES_TO_READ, iobuf)
                     @eof = false
                     @number_bytes_read += data.bytesize
                     @fifo << data
@@ -1237,6 +1258,8 @@ module Fluent::Plugin
                   end
                 rescue EOFError
                   @eof = true
+                ensure
+                  iobuf.clear
                 end
               end
 

data/lib/fluent/plugin/in_tcp.rb

@@ -137,7 +137,7 @@ module Fluent::Plugin
 
             @parser.parse(msg) do |time, record|
               unless time && record
-                log.warn "pattern not matched", message: msg
+                log.on_warn { log.warn "pattern not matched", message: msg }
                 next
               end
 
@@ -187,7 +187,7 @@ module Fluent::Plugin
 
             @parser.parse(msg) do |time, record|
               unless time && record
-                log.warn "pattern not matched", message: msg
+                log.on_warn { log.warn "pattern not matched", message: msg }
                 next
               end
 

data/lib/fluent/plugin/in_udp.rb

@@ -83,7 +83,7 @@ module Fluent::Plugin
         begin
           @parser.parse(data) do |time, record|
             unless time && record
-              log.warn "pattern not matched", data: data
+              log.on_warn { log.warn "pattern not matched", data: data }
               next
             end
 

data/lib/fluent/plugin/input.rb

@@ -37,14 +37,6 @@ module Fluent
         @enable_size_metrics = false
       end
 
-      def emit_records
-        @emit_records_metrics.get
-      end
-
-      def emit_size
-        @emit_size_metrics.get
-      end
-
       def configure(conf)
         super
 

data/lib/fluent/plugin/multi_output.rb

@@ -56,22 +56,6 @@ module Fluent
         @enable_size_metrics = false
       end
 
-      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 statistics
         stats = {
           'num_errors' => @num_errors_metrics.get,
@@ -91,7 +75,7 @@ module Fluent
         super
 
         @num_errors_metrics = metrics_create(namespace: "fluentd", subsystem: "multi_output", name: "num_errors", help_text: "Number of count num errors")
-        @emit_count_metrics = metrics_create(namespace: "fluentd", subsystem: "multi_output", name: "emit_records", help_text: "Number of count emits")
+        @emit_count_metrics = metrics_create(namespace: "fluentd", subsystem: "multi_output", name: "emit_count", help_text: "Number of count emits")
         @emit_records_metrics = metrics_create(namespace: "fluentd", subsystem: "multi_output", name: "emit_records", help_text: "Number of emit records")
         @emit_size_metrics =  metrics_create(namespace: "fluentd", subsystem: "multi_output", name: "emit_size", help_text: "Total size of emit events")
         @enable_size_metrics = !!system_config.enable_size_metrics

data/lib/fluent/plugin/out_exec_filter.rb

@@ -193,8 +193,8 @@ module Fluent::Plugin
             log.warn "child process exits with error code", code: status.to_i, status: status.exitstatus, signal: status.termsig
           end
           c.mutex.synchronize do
-            (c.writeio && c.writeio.close) rescue nil
-            (c.readio && c.readio.close) rescue nil
+            c.writeio&.close rescue nil
+            c.readio&.close rescue nil
             c.pid = c.readio = c.writeio = nil
           end
         end

data/lib/fluent/plugin/out_file.rb

@@ -17,6 +17,7 @@
 require 'fileutils'
 require 'zlib'
 require 'time'
+require 'pathname'
 
 require 'fluent/plugin/output'
 require 'fluent/config/error'
@@ -29,11 +30,12 @@ module Fluent::Plugin
 
     helpers :formatter, :inject, :compat_parameters
 
-    SUPPORTED_COMPRESS = [:text, :gz, :gzip]
+    SUPPORTED_COMPRESS = [:text, :gz, :gzip, :zstd]
     SUPPORTED_COMPRESS_MAP = {
       text: nil,
       gz: :gzip,
       gzip: :gzip,
+      zstd: :zstd,
     }
 
     DEFAULT_TIMEKEY = 60 * 60 * 24
@@ -53,6 +55,8 @@ module Fluent::Plugin
     config_param :recompress, :bool, default: false
     desc "Create symlink to temporary buffered file when buffer_type is file (disabled on Windows)."
     config_param :symlink_path, :string, default: nil
+    desc "Use relative path for symlink target (default: false)"
+    config_param :symlink_path_use_relative, :bool, default: false
 
     config_section :format do
       config_set_default :@type, 'out_file'
@@ -96,7 +100,12 @@ module Fluent::Plugin
         if chunk.metadata == @latest_metadata
           sym_path = @_output_plugin_for_symlink.extract_placeholders(@_symlink_path, chunk)
           FileUtils.mkdir_p(File.dirname(sym_path), mode: @_output_plugin_for_symlink.dir_perm)
-          FileUtils.ln_sf(chunk.path, sym_path)
+          if @_output_plugin_for_symlink.symlink_path_use_relative
+            relative_path = Pathname.new(chunk.path).relative_path_from(Pathname.new(File.dirname(sym_path)))
+            FileUtils.ln_sf(relative_path, sym_path)
+          else
+            FileUtils.ln_sf(chunk.path, sym_path)
+          end
         end
         chunk
       end
@@ -184,18 +193,15 @@ module Fluent::Plugin
           @buffer.symlink_path = @symlink_path
           @buffer.output_plugin_for_symlink = self
         end
+
+        if @compress != :text && @buffer.compress != :text && @buffer.compress != @compress_method
+          raise Fluent::ConfigError, "You cannot specify different compression formats for Buffer (Buffer: #{@buffer.compress}, Self: #{@compress})"
+        end
       end
 
       @dir_perm = system_config.dir_permission || Fluent::DEFAULT_DIR_PERMISSION
       @file_perm = system_config.file_permission || Fluent::DEFAULT_FILE_PERMISSION
       @need_lock = system_config.workers > 1
-
-      # https://github.com/fluent/fluentd/issues/3569
-      @need_ruby_on_macos_workaround = false
-      if @append && Fluent.macos?
-        condition = Gem::Dependency.new('', [">= 2.7.0", "< 3.1.0"])
-        @need_ruby_on_macos_workaround = true if condition.match?('', RUBY_VERSION)
-      end
     end
 
     def multi_workers_ready?
@@ -212,17 +218,17 @@ module Fluent::Plugin
       FileUtils.mkdir_p File.dirname(path), mode: @dir_perm
 
       writer = case
-               when @compress_method.nil?
-                 method(:write_without_compression)
-               when @compress_method == :gzip
-                 if @buffer.compress != :gzip || @recompress
-                   method(:write_gzip_with_compression)
-                 else
-                   method(:write_gzip_from_gzipped_chunk)
-                 end
-               else
-                 raise "BUG: unknown compression method #{@compress_method}"
-               end
+                when @compress_method.nil?
+                  method(:write_without_compression)
+                when @compress_method != :text
+                  if @buffer.compress == :text || @recompress
+                    method(:write_with_compression).curry.call(@compress_method)
+                  else
+                    method(:write_from_compressed_chunk).curry.call(@compress_method)
+                  end
+                else
+                  raise "BUG: unknown compression method #{@compress_method}"
+                end
 
       if @append
         if @need_lock
@@ -244,26 +250,26 @@ module Fluent::Plugin
 
     def write_without_compression(path, chunk)
       File.open(path, "ab", @file_perm) do |f|
-        if @need_ruby_on_macos_workaround
-          content = chunk.read()
-          f.puts content
-        else
-          chunk.write_to(f)
-        end
+        chunk.write_to(f)
       end
     end
 
-    def write_gzip_with_compression(path, chunk)
+    def write_with_compression(type, path, chunk)
       File.open(path, "ab", @file_perm) do |f|
-        gz = Zlib::GzipWriter.new(f)
+        gz = nil
+        if type == :gzip
+          gz = Zlib::GzipWriter.new(f)
+        elsif type == :zstd
+          gz = Zstd::StreamWriter.new(f)
+        end
         chunk.write_to(gz, compressed: :text)
         gz.close
       end
     end
 
-    def write_gzip_from_gzipped_chunk(path, chunk)
+    def write_from_compressed_chunk(type, path, chunk)
       File.open(path, "ab", @file_perm) do |f|
-        chunk.write_to(f, compressed: :gzip)
+        chunk.write_to(f, compressed: type)
       end
     end
 
@@ -280,6 +286,7 @@ module Fluent::Plugin
     def compression_suffix(compress)
       case compress
       when :gzip then '.gz'
+      when :zstd then '.zstd'
       when nil then ''
       else
         raise ArgumentError, "unknown compression type #{compress}"

data/lib/fluent/plugin/out_forward/connection_manager.rb

@@ -24,7 +24,7 @@ module Fluent::Plugin
       # @param log [Logger]
       # @param secure [Boolean]
       # @param connection_factory [Proc]
-      # @param SocketCache [Fluent::ForwardOutput::SocketCache]
+      # @param socket_cache [Fluent::ForwardOutput::SocketCache]
       def initialize(log:, secure:, connection_factory:, socket_cache:)
         @log = log
         @secure = secure
@@ -36,7 +36,7 @@ module Fluent::Plugin
         @socket_cache && @socket_cache.clear
       end
 
-      # @param ack [Fluent::Plugin::ForwardOutput::AckHander::Ack|nil]
+      # @param ack [Fluent::Plugin::ForwardOutput::AckHandler::Ack|nil]
       def connect(host:, port:, hostname:, ack: nil, &block)
         if @socket_cache
           return connect_keepalive(host: host, port: port, hostname: hostname, ack: ack, &block)