fluentd 1.9.1-x64-mingw32 → 1.9.2-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f21baedc030fb756b14e72fabb65059322c86f07537c3328175eb982061ce80
-  data.tar.gz: b4a596b4cf6704dd752cff7d19af6618b3ab40c627d052a067174514b21157be
+  metadata.gz: 976b5918a9761704f4c808761a5988c6f95f1b86e6fd7f7fa68f68f5de4b64ce
+  data.tar.gz: 37a6608a19b50fc7d4815df34fb9321edfd48547d32513a0c631d297580ca71b
 SHA512:
-  metadata.gz: ce0465ee776348e12636d3b003f9a54a2da7c1d643117bae037af882c4511cfe036c0145c314dcfa542ed47715c891db268acd35dab9c99053f6ebc8d32a476e
-  data.tar.gz: '009d91ce4bd655b67e51fc93f7df5de59d82fc880bf9b5930dbcd904ada392d35aa833abf08a8211a35289994871d733ea6d5862232884abe6676a23b83ff4f4'
+  metadata.gz: ce2d17a96d496d47848082e7ed980b3c8bd111d071ff256f9788db0d2c13fb41da543eeee39cd3764b6b18d16a53039a49968f5797264be7dcf3b8d472a24aa2
+  data.tar.gz: 0b86f77306d5b5b79d75d56d013eabf81e0714446a9b8cdf814b66893e4baea1004866060c45d0b2ef1914bf852f7592cde72eba15446d2e881f839e989c7039

data/.travis.yml

@@ -45,6 +45,9 @@ branches:
   only:
     - master
 
+before_install:
+  - gem update --system=3.1.2
+
 sudo: false
 dist: trusty # for TLSv1.2 support
 

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # v1.9
 
+## Release v1.9.2 - 2020/02/13
+
+### Enhancement
+
+* in_tail: Add `pos_file_compaction_interval` parameter for auto compaction
+  https://github.com/fluent/fluentd/pull/2805
+* command: Use given encoding when RUBYOPT has `-E`
+  https://github.com/fluent/fluentd/pull/2814
+
+### Bug fix
+
+* command: Accept RUBYOPT with two or more options
+  https://github.com/fluent/fluentd/pull/2807
+* command: Fix infinite loop bug when RUBYOPT is invalid
+  https://github.com/fluent/fluentd/pull/2813
+* log: serverengine's log should be formatted with the same format of fluentd
+  https://github.com/fluent/fluentd/pull/2812
+* in_http: Fix `NoMethodError` when `OPTIONS` request doesn't have 'Origin' header
+  https://github.com/fluent/fluentd/pull/2823
+* parser_syslog: Improved for parsing RFC5424 structured data in `parser_syslog`
+  https://github.com/fluent/fluentd/pull/2816
+
 ## Release v1.9.1 - 2020/01/31
 
 ### Enhancement

data/lib/fluent/plugin/in_http.rb

@@ -526,14 +526,20 @@ module Fluent::Plugin
       end
 
       def include_cors_allow_origin
+        if @origin.nil?
+          return false
+        end
+
         if @cors_allow_origins.include?(@origin)
           return true
         end
         filtered_cors_allow_origins = @cors_allow_origins.select {|origin| origin != ""}
-        return filtered_cors_allow_origins.find do |origin|
-          (start_str,end_str) = origin.split("*",2)
-          @origin.start_with?(start_str) and @origin.end_with?(end_str)
-        end != nil
+        r = filtered_cors_allow_origins.find do |origin|
+          (start_str, end_str) = origin.split("*", 2)
+          @origin.start_with?(start_str) && @origin.end_with?(end_str)
+        end
+
+        !r.nil?
       end
     end
   end

data/lib/fluent/plugin/in_tail.rb

@@ -71,6 +71,8 @@ module Fluent::Plugin
     config_param :rotate_wait, :time, default: 5
     desc 'Fluentd will record the position it last read into this file.'
     config_param :pos_file, :string, default: nil
+    desc 'The cleanup interval of pos file'
+    config_param :pos_file_compaction_interval, :integer, default: nil
     desc 'Start to read the logs from the head of file, not bottom.'
     config_param :read_from_head, :bool, default: false
     # When the program deletes log file and re-creates log file with same filename after passed refresh_interval,
@@ -211,7 +213,14 @@ module Fluent::Plugin
         FileUtils.mkdir_p(pos_file_dir) unless Dir.exist?(pos_file_dir)
         @pf_file = File.open(@pos_file, File::RDWR|File::CREAT|File::BINARY, @file_perm)
         @pf_file.sync = true
-        @pf = PositionFile.parse(@pf_file)
+        @pf = PositionFile.load(@pf_file, logger: log)
+
+        if @pos_file_compaction_interval
+          timer_execute(:in_tail_refresh_compact_pos_file, @pos_file_compaction_interval) do
+            log.info('Clean up the pos file')
+            @pf.try_compact
+          end
+        end
       end
 
       refresh_watchers unless @skip_refresh_on_startup

data/lib/fluent/plugin/in_tail/position_file.rb

@@ -14,7 +14,7 @@
 #    limitations under the License.
 #
 
-require 'fluent/plugin/in_tail'
+require 'fluent/plugin/input'
 
 module Fluent::Plugin
   class TailInput < Fluent::Plugin::Input
@@ -23,10 +23,17 @@ module Fluent::Plugin
       POSITION_FILE_ENTRY_REGEX = /^([^\t]+)\t([0-9a-fA-F]+)\t([0-9a-fA-F]+)/.freeze
       POSITION_FILE_ENTRY_FORMAT = "%s\t%016x\t%016x\n".freeze
 
-      def initialize(file, file_mutex, map)
+      def self.load(file, logger:)
+        pf = new(file, logger: logger)
+        pf.load
+        pf
+      end
+
+      def initialize(file, logger: nil)
         @file = file
-        @file_mutex = file_mutex
-        @map = map
+        @logger = logger
+        @file_mutex = Mutex.new
+        @map = {}
       end
 
       def [](path)
@@ -48,56 +55,89 @@ module Fluent::Plugin
         end
       end
 
-      def self.parse(file)
-        compact(file)
+      def load
+        compact
 
-        file_mutex = Mutex.new
         map = {}
-        file.pos = 0
-        file.each_line {|line|
-          m = POSITION_FILE_ENTRY_REGEX.match(line)
-          unless m
-            $log.warn "Unparsable line in pos_file: #{line}"
-            next
+        @file_mutex.synchronize do
+          @file.pos = 0
+
+          @file.each_line do |line|
+            m = POSITION_FILE_ENTRY_REGEX.match(line)
+            next if m.nil?
+
+            path = m[1]
+            pos = m[2].to_i(16)
+            ino = m[3].to_i(16)
+            seek = @file.pos - line.bytesize + path.bytesize + 1
+            map[path] = FilePositionEntry.new(@file, @file_mutex, seek, pos, ino)
           end
-          path = m[1]
-          pos = m[2].to_i(16)
-          ino = m[3].to_i(16)
-          seek = file.pos - line.bytesize + path.bytesize + 1
-          map[path] = FilePositionEntry.new(file, file_mutex, seek, pos, ino)
-        }
-        new(file, file_mutex, map)
+        end
+
+        @map = map
+      end
+
+      # This method is similer to #compact but it tries to get less lock to avoid a lock contention
+      def try_compact
+        last_modified = nil
+        size = nil
+
+        @file_mutex.synchronize do
+          last_modified = @file.mtime
+          size = @file.size
+        end
+
+        entries = fetch_compacted_entries
+
+        @file_mutex.synchronize do
+          if last_modified == @file.mtime && size == @file.size
+            @file.pos = 0
+            @file.truncate(0)
+            @file.write(entries.join)
+          else
+            # skip
+          end
+        end
+      end
+
+      private
+
+      def compact
+        @file_mutex.synchronize do
+          entries = fetch_compacted_entries
+
+          @file.pos = 0
+          @file.truncate(0)
+          @file.write(entries.join)
+        end
       end
 
-      # Clean up unwatched file entries
-      def self.compact(file)
-        existent_entries = {}
-        file.pos = 0
-        file.each_line do |line|
+      def fetch_compacted_entries
+        entries = {}
+
+        @file.pos = 0
+        @file.each_line do |line|
           m = POSITION_FILE_ENTRY_REGEX.match(line)
-          unless m
-            $log.warn "Unparsable line in pos_file: #{line}"
+          if m.nil?
+            @logger.warn "Unparsable line in pos_file: #{line}" if @logger
             next
           end
+
           path = m[1]
           pos = m[2].to_i(16)
           ino = m[3].to_i(16)
-
           if pos == UNWATCHED_POSITION
-            next
-          end
+            @logger.debug "Remove unwatched line from pos_file: #{line}" if @logger
+          else
+            if entries.include?(path)
+              @logger.warn("#{path} already exists. use latest one: deleted #{entries[path]}") if @logger
+            end
 
-          if existent_entries.include?(path)
-            $log.warn("#{path} already exists. use latest one: deleted #{existent_entries[path]}")
+            entries[path] = (POSITION_FILE_ENTRY_FORMAT % [path, pos, ino])
           end
-
-          # 32bit inode converted to 64bit at this phase
-          existent_entries[path] = (POSITION_FILE_ENTRY_FORMAT % [path, pos, ino])
         end
 
-        file.pos = 0
-        file.truncate(0)
-        file.write(existent_entries.values.join)
+        entries.values
       end
     end
 

data/lib/fluent/plugin/parser_syslog.rb

@@ -27,8 +27,15 @@ module Fluent
       REGEXP = /^(?<time>[^ ]*\s*[^ ]* [^ ]*) (?<host>[^ ]*) (?<ident>[^ :\[]*)(?:\[(?<pid>[0-9]+)\])?(?:[^\:]*\:)? *(?<message>.*)$/
       # From in_syslog default pattern
       REGEXP_WITH_PRI = /^\<(?<pri>[0-9]+)\>(?<time>[^ ]* {1,2}[^ ]* [^ ]*) (?<host>[^ ]*) (?<ident>[^ :\[]*)(?:\[(?<pid>[0-9]+)\])?(?:[^\:]*\:)? *(?<message>.*)$/
-      REGEXP_RFC5424 = /\A(?<time>[^ ]+) (?<host>[!-~]{1,255}) (?<ident>[!-~]{1,48}) (?<pid>[!-~]{1,128}) (?<msgid>[!-~]{1,32}) (?<extradata>(?:\-|\[(.*)\]))(?: (?<message>.+))?\z/m
-      REGEXP_RFC5424_WITH_PRI = /\A\<(?<pri>[0-9]{1,3})\>[1-9]\d{0,2} (?<time>[^ ]+) (?<host>[!-~]{1,255}) (?<ident>[!-~]{1,48}) (?<pid>[!-~]{1,128}) (?<msgid>[!-~]{1,32}) (?<extradata>(?:\-|\[(.*)\]))(?: (?<message>.+))?\z/m
+      REGEXP_RFC5424 = <<~'EOS'.chomp
+        (?<time>[^ ]+) (?<host>[!-~]{1,255}) (?<ident>[!-~]{1,48}) (?<pid>[!-~]{1,128}) (?<msgid>[!-~]{1,32}) (?<extradata>(?:\-|(?:\[.*?(?<!\\)\])+))(?: (?<message>.+))?
+      EOS
+      REGEXP_RFC5424_NO_PRI = Regexp.new(<<~'EOS'.chomp % REGEXP_RFC5424, Regexp::MULTILINE)
+        \A%s\z
+      EOS
+      REGEXP_RFC5424_WITH_PRI = Regexp.new(<<~'EOS'.chomp % REGEXP_RFC5424, Regexp::MULTILINE)
+        \A<(?<pri>[0-9]{1,3})\>[1-9]\d{0,2} %s\z
+      EOS
       REGEXP_DETECT_RFC5424 = /^\<.*\>[1-9]\d{0,2}/
 
       config_set_default :time_format, "%b %d %H:%M:%S"
@@ -73,7 +80,7 @@ module Fluent
                     end
                     @time_format = @rfc5424_time_format unless conf.has_key?('time_format')
                     @support_rfc5424_without_subseconds = true
-                    @with_priority ? REGEXP_RFC5424_WITH_PRI : REGEXP_RFC5424
+                    @with_priority ? REGEXP_RFC5424_WITH_PRI : REGEXP_RFC5424_NO_PRI
                   when :auto
                     class << self
                       alias_method :parse, :parse_auto
@@ -96,7 +103,7 @@ module Fluent
 
       def parse_auto(text, &block)
         if REGEXP_DETECT_RFC5424.match(text)
-          @regexp = @with_priority ? REGEXP_RFC5424_WITH_PRI : REGEXP_RFC5424
+          @regexp = @with_priority ? REGEXP_RFC5424_WITH_PRI : REGEXP_RFC5424_NO_PRI
           @time_parser = @time_parser_rfc5424
           @support_rfc5424_without_subseconds = true
           parse_plain(text, &block)

data/lib/fluent/supervisor.rb

@@ -15,6 +15,7 @@
 #
 
 require 'fileutils'
+require 'open3'
 
 require 'fluent/config'
 require 'fluent/counter'
@@ -315,6 +316,7 @@ module Fluent
       )
       # this #init sets initialized logger to $log
       logger_initializer.init(:supervisor, 0)
+      logger_initializer.apply_options(format: params['log_format'], time_format: params['log_time_format'])
       logger = $log
 
       command_sender = Fluent.windows? ? "pipe" : "signal"
@@ -659,13 +661,7 @@ module Fluent
       Process.setproctitle("supervisor:#{@system_config.process_name}") if @system_config.process_name
       $log.info "starting fluentd-#{Fluent::VERSION}", pid: Process.pid, ruby: RUBY_VERSION
 
-      rubyopt = ENV["RUBYOPT"]
-      fluentd_spawn_cmd = [ServerEngine.ruby_bin_path, "-Eascii-8bit:ascii-8bit"]
-      fluentd_spawn_cmd << rubyopt if rubyopt
-      fluentd_spawn_cmd << $0
-      fluentd_spawn_cmd += $fluentdargv
-      fluentd_spawn_cmd << "--under-supervisor"
-
+      fluentd_spawn_cmd = build_spawn_command
       $log.info "spawn command to main: ", cmdline: fluentd_spawn_cmd
 
       params = {
@@ -689,6 +685,8 @@ module Fluent
         'rpc_endpoint' => @system_config.rpc_endpoint,
         'enable_get_dump' => @system_config.enable_get_dump,
         'counter_server' => @system_config.counter_server,
+        'log_format' => @system_config.log.format,
+        'log_time_format' => @system_config.log.time_format,
       }
 
       se = ServerEngine.create(ServerModule, WorkerModule){
@@ -872,5 +870,37 @@ module Fluent
       system_config.overwrite_variables(**opt)
       system_config
     end
+
+    RUBY_ENCODING_OPTIONS_REGEX = %r{\A(-E|--encoding=|--internal-encoding=|--external-encoding=)}.freeze
+
+    def build_spawn_command
+      fluentd_spawn_cmd = [ServerEngine.ruby_bin_path]
+
+      rubyopt = ENV['RUBYOPT']
+      if rubyopt
+        encodes, others = rubyopt.split(' ').partition { |e| e.match?(RUBY_ENCODING_OPTIONS_REGEX) }
+        fluentd_spawn_cmd.concat(others)
+
+        adopted_encodes = encodes.empty? ? ['-Eascii-8bit:ascii-8bit'] : encodes
+        fluentd_spawn_cmd.concat(adopted_encodes)
+      else
+        fluentd_spawn_cmd << '-Eascii-8bit:ascii-8bit'
+      end
+
+      # Adding `-h` so that it can avoid ruby's command blocking
+      # e.g. `ruby -Eascii-8bit:ascii-8bit` will block. but `ruby -Eascii-8bit:ascii-8bit -h` won't.
+      cmd = fluentd_spawn_cmd.join(' ')
+      _, e, s = Open3.capture3("#{cmd} -h")
+      if s.exitstatus != 0
+        $log.error('Invalid option is passed to RUBYOPT', command: cmd, error: e)
+        exit s.exitstatus
+      end
+
+      fluentd_spawn_cmd << $0
+      fluentd_spawn_cmd += $fluentdargv
+      fluentd_spawn_cmd << '--under-supervisor'
+
+      fluentd_spawn_cmd
+    end
   end
 end

data/lib/fluent/version.rb

@@ -16,6 +16,6 @@
 
 module Fluent
 
-  VERSION = '1.9.1'
+  VERSION = '1.9.2'
 
 end

data/test/command/test_fluentd.rb

@@ -47,16 +47,14 @@ class TestFluentdCommand < ::Test::Unit::TestCase
 
   def create_cmdline(conf_path, *fluentd_options)
     cmd_path = File.expand_path(File.dirname(__FILE__) + "../../../bin/fluentd")
-    ["bundle", "exec", "ruby", cmd_path, "-c", conf_path, *fluentd_options]
+    ["bundle", "exec", cmd_path, "-c", conf_path, *fluentd_options]
   end
 
-  def execute_command(cmdline, chdir=TMP_DIR)
+  def execute_command(cmdline, chdir=TMP_DIR, env = {})
     null_stream = File.open(File::NULL, 'w')
     gemfile_path = File.expand_path(File.dirname(__FILE__) + "../../../Gemfile")
 
-    env = {
-      "BUNDLE_GEMFILE" => gemfile_path,
-    }
+    env = { "BUNDLE_GEMFILE" => gemfile_path }.merge(env)
     cmdname = cmdline.shift
     arg0 = "testing-fluentd"
     # p(here: "executing process", env: env, cmdname: cmdname, arg0: arg0, args: cmdline)
@@ -81,12 +79,12 @@ class TestFluentdCommand < ::Test::Unit::TestCase
     null_stream.close rescue nil
   end
 
-  def assert_log_matches(cmdline, *pattern_list, patterns_not_match: [], timeout: 10)
+  def assert_log_matches(cmdline, *pattern_list, patterns_not_match: [], timeout: 10, env: {})
     matched = false
     assert_error_msg = "matched correctly"
     stdio_buf = ""
     begin
-      execute_command(cmdline) do |pid, stdout|
+      execute_command(cmdline, TMP_DIR, env) do |pid, stdout|
         begin
           waiting(timeout) do
             while process_exist?(pid) && !matched
@@ -285,7 +283,7 @@ CONF
 
       assert_fluentd_fails_to_start(
         create_cmdline(conf_path),
-        "non directory entry exists:#{@root_path} (Fluent::InvalidRootDirectory)",
+        "non directory entry exists:#{@root_path}",
       )
     end
   end
@@ -780,6 +778,82 @@ CONF
       )
     end
 
+    test "multiple values are set to RUBYOPT" do
+      conf = <<CONF
+<source>
+  @type dummy
+  tag dummy
+</source>
+<match>
+  @type null
+</match>
+CONF
+      conf_path = create_conf_file('rubyopt_test.conf', conf)
+      assert_log_matches(
+        create_cmdline(conf_path),
+        '#0 fluentd worker is now running worker=0',
+        patterns_not_match: ['(LoadError)'],
+        env: { 'RUBYOPT' => '-rtest-unit -rbundler/setup' },
+      )
+    end
+
+    data(
+      '-E' => '-Eutf-8',
+      '-encoding' => '--encoding=utf-8',
+      '-external-encoding' => '--external-encoding=utf-8',
+      '-internal-encoding' => '--internal-encoding=utf-8',
+    )
+    test "-E option is set to RUBYOPT3" do |opt|
+      conf = <<CONF
+<source>
+  @type dummy
+  tag dummy
+</source>
+<match>
+  @type null
+</match>
+CONF
+      conf_path = create_conf_file('rubyopt_test.conf', conf)
+      assert_log_matches(
+        create_cmdline(conf_path),
+        *opt.split(' '),
+        patterns_not_match: ['-Eascii-8bit:ascii-8bit'],
+        env: { 'RUBYOPT' => opt },
+      )
+    end
+
+        test "without RUBYOPT" do
+      conf = <<CONF
+<source>
+  @type dummy
+  tag dummy
+</source>
+<match>
+  @type null
+</match>
+CONF
+      conf_path = create_conf_file('rubyopt_test.conf', conf)
+      assert_log_matches(create_cmdline(conf_path), '-Eascii-8bit:ascii-8bit')
+    end
+
+    test 'invalid values are set to RUBYOPT' do
+      conf = <<CONF
+<source>
+  @type dummy
+  tag dummy
+</source>
+<match>
+  @type null
+</match>
+CONF
+      conf_path = create_conf_file('rubyopt_invalid_test.conf', conf)
+      assert_log_matches(
+        create_cmdline(conf_path),
+        'Invalid option is passed to RUBYOPT',
+        env: { 'RUBYOPT' => 'a' },
+      )
+    end
+
     test 'success to start workers when file buffer is configured in non-workers way only for specific worker' do
       conf = <<CONF
 <system>

data/test/plugin/in_tail/test_position_file.rb

@@ -1,9 +1,17 @@
 require_relative '../../helper'
 require 'fluent/plugin/in_tail/position_file'
 
+require 'fileutils'
+require 'tempfile'
+
 class IntailPositionFileTest < Test::Unit::TestCase
   setup do
-    @file = StringIO.new(+'')
+    @file = Tempfile.new('intail_position_file_test')
+  end
+
+  teardown do
+    @file.close rescue nil
+    @file.unlink rescue nil
   end
 
   UNWATCHED_STR = '%016x' % Fluent::Plugin::TailInput::PositionFile::UNWATCHED_POSITION
@@ -19,10 +27,21 @@ class IntailPositionFileTest < Test::Unit::TestCase
     f.seek(0)
   end
 
-  sub_test_case '.compact' do
+  test '.load' do
+    write_data(@file, TEST_CONTENT)
+    Fluent::Plugin::TailInput::PositionFile.load(@file, logger: $log)
+
+    @file.seek(0)
+    lines = @file.readlines
+    assert_equal 2, lines.size
+    assert_equal "valid_path\t0000000000000002\t0000000000000001\n", lines[0]
+    assert_equal "inode23bit\t0000000000000000\t0000000000000000\n", lines[1]
+  end
+
+  sub_test_case '#try_compact' do
     test 'compact invalid and convert 32 bit inode value' do
       write_data(@file, TEST_CONTENT)
-      Fluent::Plugin::TailInput::PositionFile.compact(@file)
+      Fluent::Plugin::TailInput::PositionFile.new(@file, logger: $log).try_compact
 
       @file.seek(0)
       lines = @file.readlines
@@ -36,29 +55,59 @@ class IntailPositionFileTest < Test::Unit::TestCase
         valid_path\t0000000000000002\t0000000000000001
         valid_path\t0000000000000003\t0000000000000004
       EOF
-      Fluent::Plugin::TailInput::PositionFile.compact(@file)
+      Fluent::Plugin::TailInput::PositionFile.new(@file, logger: $log).try_compact
 
       @file.seek(0)
       lines = @file.readlines
       assert_equal "valid_path\t0000000000000003\t0000000000000004\n", lines[0]
     end
+
+    test 'does not change when the file is changed' do
+      write_data(@file, TEST_CONTENT)
+      pf = Fluent::Plugin::TailInput::PositionFile.new(@file, logger: $log)
+
+      mock.proxy(pf).fetch_compacted_entries do |r|
+        @file.write("unwatched\t#{UNWATCHED_STR}\t0000000000000000\n")
+        r
+      end
+
+      pf.try_compact
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal 5, lines.size
+    end
   end
 
-  test '.parse' do
-    write_data(@file, TEST_CONTENT)
-    Fluent::Plugin::TailInput::PositionFile.parse(@file)
+  sub_test_case '#load' do
+    test 'compact invalid and convert 32 bit inode value' do
+      write_data(@file, TEST_CONTENT)
+      Fluent::Plugin::TailInput::PositionFile.load(@file, logger: $log)
 
-    @file.seek(0)
-    lines = @file.readlines
-    assert_equal 2, lines.size
-    assert_equal "valid_path\t0000000000000002\t0000000000000001\n", lines[0]
-    assert_equal "inode23bit\t0000000000000000\t0000000000000000\n", lines[1]
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal 2, lines.size
+      assert_equal "valid_path\t0000000000000002\t0000000000000001\n", lines[0]
+      assert_equal "inode23bit\t0000000000000000\t0000000000000000\n", lines[1]
+    end
+
+    test 'compact data if duplicated line' do
+      write_data(@file, <<~EOF)
+        valid_path\t0000000000000002\t0000000000000001
+        valid_path\t0000000000000003\t0000000000000004
+      EOF
+      Fluent::Plugin::TailInput::PositionFile.new(@file, logger: $log).load
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal "valid_path\t0000000000000003\t0000000000000004\n", lines[0]
+    end
   end
 
   sub_test_case '#[]' do
     test 'return entry' do
       write_data(@file, TEST_CONTENT)
-      pf = Fluent::Plugin::TailInput::PositionFile.parse(@file)
+      pf = Fluent::Plugin::TailInput::PositionFile.load(@file, logger: $log)
 
       f = pf['valid_path']
       assert_equal Fluent::Plugin::TailInput::FilePositionEntry, f.class
@@ -82,7 +131,7 @@ class IntailPositionFileTest < Test::Unit::TestCase
 
     test 'does not change other value position if other entry try to write' do
       write_data(@file, TEST_CONTENT)
-      pf = Fluent::Plugin::TailInput::PositionFile.parse(@file)
+      pf = Fluent::Plugin::TailInput::PositionFile.load(@file, logger: $log)
 
       f = pf['nonexist_path']
       assert_equal 0, f.read_inode
@@ -103,7 +152,7 @@ class IntailPositionFileTest < Test::Unit::TestCase
   sub_test_case '#unwatch' do
     test 'deletes entry by path' do
       write_data(@file, TEST_CONTENT)
-      pf = Fluent::Plugin::TailInput::PositionFile.parse(@file)
+      pf = Fluent::Plugin::TailInput::PositionFile.load(@file, logger: $log)
       p1 = pf['valid_path']
       assert_equal Fluent::Plugin::TailInput::FilePositionEntry, p1.class
 

data/test/plugin/test_in_tail.rb

@@ -1088,7 +1088,7 @@ class TailInputTest < Test::Unit::TestCase
     plugin = create_driver(EX_CONFIG, false).instance
     sio = StringIO.new
     plugin.instance_eval do
-      @pf = Fluent::Plugin::TailInput::PositionFile.parse(sio)
+      @pf = Fluent::Plugin::TailInput::PositionFile.load(sio, logger: $log)
       @loop = Coolio::Loop.new
     end
 

data/test/plugin/test_parser_syslog.rb

@@ -237,7 +237,7 @@ class SyslogParserTest < ::Test::Unit::TestCase
         assert_equal "-", record["extradata"]
         assert_equal "Hi, from Fluentd!", record["message"]
       end
-      assert_equal(Fluent::Plugin::SyslogParser::REGEXP_RFC5424,
+      assert_equal(Fluent::Plugin::SyslogParser::REGEXP_RFC5424_NO_PRI,
                    @parser.instance.patterns['format'])
     end
 
@@ -254,7 +254,7 @@ class SyslogParserTest < ::Test::Unit::TestCase
         assert_equal "-", record["extradata"]
         assert_nil record["message"]
       end
-      assert_equal(Fluent::Plugin::SyslogParser::REGEXP_RFC5424,
+      assert_equal(Fluent::Plugin::SyslogParser::REGEXP_RFC5424_NO_PRI,
                    @parser.instance.patterns['format'])
     end
 
@@ -294,14 +294,14 @@ class SyslogParserTest < ::Test::Unit::TestCase
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
                         )
-      text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"] Hi, from Fluentd!'
+      text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"] [Hi] from Fluentd!'
       @parser.instance.parse(text) do |time, record|
         assert_equal(event_time("2017-02-06T13:14:15.003Z", format: '%Y-%m-%dT%H:%M:%S.%L%z'), time)
         assert_equal "11111", record["pid"]
         assert_equal "ID24224", record["msgid"]
         assert_equal "[exampleSDID@20224 iut=\"3\" eventSource=\"Application\" eventID=\"11211\"]",
                      record["extradata"]
-        assert_equal "Hi, from Fluentd!", record["message"]
+        assert_equal "[Hi] from Fluentd!", record["message"]
       end
     end
 
@@ -328,14 +328,14 @@ class SyslogParserTest < ::Test::Unit::TestCase
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
                         )
-      text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"] Hi, from Fluentd]!'
+      text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"] [Hi] from Fluentd]!'
       @parser.instance.parse(text) do |time, record|
         assert_equal(event_time("2017-02-06T13:14:15.003Z", format: '%Y-%m-%dT%H:%M:%S.%L%z'), time)
         assert_equal "11111", record["pid"]
         assert_equal "ID24224", record["msgid"]
         assert_equal "[exampleSDID@20224 iut=\"3\" eventSource=\"Application\" eventID=\"11211\"]",
                      record["extradata"]
-        assert_equal "Hi, from Fluentd]!", record["message"]
+        assert_equal "[Hi] from Fluentd]!", record["message"]
       end
     end
 

data/test/test_supervisor.rb

@@ -235,6 +235,33 @@ class SupervisorTest < ::Test::Unit::TestCase
     Timecop.return
   end
 
+  def test_load_config_for_logger
+    tmp_dir = "#{TMP_DIR}/dir/test_load_config_log.conf"
+    conf_info_str = %[
+<system>
+  <log>
+    format json
+    time_format %FT%T.%L%z
+  </log>
+</system>
+]
+    write_config tmp_dir, conf_info_str
+    params = {
+      'use_v1_config' => true,
+      'conf_encoding' => 'utf8',
+      'log_level' => Fluent::Log::LEVEL_INFO,
+      'log_path' => 'test/tmp/supervisor/log',
+
+      'workers' => 1,
+      'log_format' => :json,
+      'log_time_format' => '%FT%T.%L%z',
+    }
+
+    r = Fluent::Supervisor.load_config(tmp_dir, params)
+    assert_equal :json, r[:logger].format
+    assert_equal '%FT%T.%L%z', r[:logger].time_format
+  end
+
   def test_load_config_for_daemonize
     tmp_dir = "#{TMP_DIR}/dir/test_load_config.conf"
     conf_info_str = %[

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluentd
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.9.2
 platform: x64-mingw32
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-31 00:00:00.000000000 Z
+date: 2020-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack