fluentd 1.14.4-x64-mingw-ucrt

data/test/test_logger_initializer.rb

@@ -0,0 +1,46 @@
+require_relative 'helper'
+require 'fluent/supervisor'
+require 'fileutils'
+
+class LoggerInitializerTest < ::Test::Unit::TestCase
+  TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/tmp/logger_initializer#{ENV['TEST_ENV_NUMBER']}")
+
+  teardown do
+    begin
+      FileUtils.rm_rf(TMP_DIR)
+    rescue => _
+    end
+  end
+
+  test 'when path is given' do
+    path = File.join(TMP_DIR, 'fluent_with_path.log')
+
+    assert_false File.exist?(TMP_DIR)
+    logger = Fluent::Supervisor::LoggerInitializer.new(path, Fluent::Log::LEVEL_DEBUG, nil, nil, {})
+    mock.proxy(File).chmod(0o777, TMP_DIR).never
+
+    assert_nothing_raised do
+      logger.init(:supervisor, 0)
+    end
+
+    assert_true File.exist?(TMP_DIR)
+  end
+
+  test 'apply_options with log_dir_perm' do
+    omit "NTFS doesn't support UNIX like permissions" if Fluent.windows?
+
+    path = File.join(TMP_DIR, 'fluent_with_path.log')
+
+    assert_false File.exist?(TMP_DIR)
+    logger = Fluent::Supervisor::LoggerInitializer.new(path, Fluent::Log::LEVEL_DEBUG, nil, nil, {})
+    mock.proxy(File).chmod(0o777, TMP_DIR).once
+
+    assert_nothing_raised do
+      logger.init(:supervisor, 0)
+    end
+
+    logger.apply_options(log_dir_perm: 0o777)
+    assert_true File.exist?(TMP_DIR)
+    assert_equal 0o777, (File.stat(TMP_DIR).mode & 0xFFF)
+  end
+end

data/test/test_match.rb

@@ -0,0 +1,148 @@
+require_relative 'helper'
+require 'fluent/match'
+
+class MatchTest < Test::Unit::TestCase
+  include Fluent
+
+  def test_simple
+    assert_glob_match('a', 'a')
+    assert_glob_match('a.b', 'a.b')
+    assert_glob_not_match('a', 'b')
+    assert_glob_not_match('a.b', 'aab')
+  end
+
+  def test_wildcard
+    assert_glob_match('a*', 'a')
+    assert_glob_match('a*', 'ab')
+    assert_glob_match('a*', 'abc')
+
+    assert_glob_match('*a', 'a')
+    assert_glob_match('*a', 'ba')
+    assert_glob_match('*a', 'cba')
+
+    assert_glob_match('*a*', 'a')
+    assert_glob_match('*a*', 'ba')
+    assert_glob_match('*a*', 'ac')
+    assert_glob_match('*a*', 'bac')
+
+    assert_glob_not_match('a*', 'a.b')
+    assert_glob_not_match('a*', 'ab.c')
+    assert_glob_not_match('a*', 'ba')
+    assert_glob_not_match('*a', 'ab')
+
+    assert_glob_match('a.*', 'a.b')
+    assert_glob_match('a.*', 'a.c')
+    assert_glob_not_match('a.*', 'ab')
+
+    assert_glob_match('a.*.c', 'a.b.c')
+    assert_glob_match('a.*.c', 'a.c.c')
+    assert_glob_not_match('a.*.c', 'a.c')
+  end
+
+  def test_recursive_wildcard
+    assert_glob_match('a.**', 'a')
+    assert_glob_not_match('a.**', 'ab')
+    assert_glob_not_match('a.**', 'abc')
+    assert_glob_match('a.**', 'a.b')
+    assert_glob_not_match('a.**', 'ab.c')
+    assert_glob_not_match('a.**', 'ab.d.e')
+
+    assert_glob_match('a**', 'a')
+    assert_glob_match('a**', 'ab')
+    assert_glob_match('a**', 'abc')
+    assert_glob_match('a**', 'a.b')
+    assert_glob_match('a**', 'ab.c')
+    assert_glob_match('a**', 'ab.d.e')
+
+    assert_glob_match('**.a', 'a')
+    assert_glob_not_match('**.a', 'ba')
+    assert_glob_not_match('**.a', 'c.ba')
+    assert_glob_match('**.a', 'b.a')
+    assert_glob_match('**.a', 'cb.a')
+    assert_glob_match('**.a', 'd.e.a')
+
+    assert_glob_match('**a', 'a')
+    assert_glob_match('**a', 'ba')
+    assert_glob_match('**a', 'c.ba')
+    assert_glob_match('**a', 'b.a')
+    assert_glob_match('**a', 'cb.a')
+    assert_glob_match('**a', 'd.e.a')
+  end
+
+  def test_or
+    assert_glob_match('a.{b,c}', 'a.b')
+    assert_glob_match('a.{b,c}', 'a.c')
+    assert_glob_not_match('a.{b,c}', 'a.d')
+
+    assert_glob_match('a.{b,c}.**', 'a.b')
+    assert_glob_match('a.{b,c}.**', 'a.c')
+    assert_glob_not_match('a.{b,c}.**', 'a.d')
+    assert_glob_not_match('a.{b,c}.**', 'a.cd')
+
+    assert_glob_match('a.{b.**,c}', 'a.b')
+    assert_glob_match('a.{b.**,c}', 'a.b.c')
+    assert_glob_match('a.{b.**,c}', 'a.c')
+    assert_glob_not_match('a.{b.**,c}', 'a.c.d')
+  end
+
+  def test_multi_pattern_or
+    assert_or_match('a.b a.c', 'a.b')
+    assert_or_match('a.b a.c', 'a.c')
+    assert_or_not_match('a.b a.c', 'a.d')
+
+    assert_or_match('a.b.** a.c.**', 'a.b')
+    assert_or_match('a.b.** a.c.**', 'a.c')
+    assert_or_not_match('a.b.** a.c.**', 'a.d')
+    assert_or_not_match('a.b.** a.c.**', 'a.cd')
+
+    assert_or_match('a.b.** a.c', 'a.b')
+    assert_or_match('a.b.** a.c', 'a.b.c')
+    assert_or_match('a.b.** a.c', 'a.c')
+    assert_or_not_match('a.b.** a.c', 'a.c.d')
+  end
+
+  def test_regex_pattern
+    assert_glob_match('/a/', 'a')
+    assert_glob_not_match('/a/', 'abc')
+    assert_glob_match('/a.*/', 'abc')
+    assert_glob_not_match('/b.*/', 'abc')
+    assert_glob_match('/a\..*/', 'a.b.c')
+    assert_glob_not_match('/(?!a\.).*/', 'a.b.c')
+    assert_glob_not_match('/a\..*/', 'b.b.c')
+    assert_glob_match('/(?!a\.).*/', 'b.b.c')
+  end
+
+  #def test_character_class
+  #  assert_match('[a]', 'a')
+  #  assert_match('[ab]', 'a')
+  #  assert_match('[ab]', 'b')
+  #  assert_not_match('[ab]', 'c')
+  #
+  #  assert_match('[a-b]', 'a')
+  #  assert_match('[a-b]', 'a')
+  #  assert_match('[a-b]', 'b')
+  #  assert_not_match('[a-b]', 'c')
+  #
+  #  assert_match('[a-b0-9]', 'a')
+  #  assert_match('[a-b0-9]', '0')
+  #  assert_not_match('[a-b0-9]', 'c')
+  #end
+
+  def assert_glob_match(pat, str)
+    assert_true GlobMatchPattern.new(pat).match(str)
+    assert_true EventRouter::Rule.new(pat, nil).match?(str)
+  end
+
+  def assert_glob_not_match(pat, str)
+    assert_false GlobMatchPattern.new(pat).match(str)
+    assert_false EventRouter::Rule.new(pat, nil).match?(str)
+  end
+
+  def assert_or_match(pats, str)
+    assert_true EventRouter::Rule.new(pats, nil).match?(str)
+  end
+
+  def assert_or_not_match(pats, str)
+    assert_false EventRouter::Rule.new(pats, nil).match?(str)
+  end
+end

data/test/test_mixin.rb

@@ -0,0 +1,351 @@
+require_relative 'helper'
+require 'fluent/mixin'
+require 'fluent/env'
+require 'fluent/plugin'
+require 'fluent/config'
+require 'fluent/test'
+require 'timecop'
+
+module MixinTest
+  module Utils
+    def setup
+      super
+      Fluent::Test.setup
+      @time = Time.utc(1,2,3,4,5,2010,nil,nil,nil,nil)
+      Timecop.freeze(@time)
+    end
+
+    def teardown
+      super
+      Timecop.return
+      GC.start
+    end
+
+    module Checker
+      extend self
+      def format_check(tag, time, record); end
+    end
+
+    @@num = 0
+
+    def create_register_output_name
+      @@num += 1
+      "mixin_text_#{@@num}"
+    end
+
+    def format_check(hash, tagname = 'test')
+      mock(Checker).format_check(tagname, @time.to_i, hash)
+    end
+
+    def create_driver(include_klass, conf = '', tag = "test", &block)
+      register_output_name = create_register_output_name
+      include_klasses = [include_klass].flatten
+
+      klass = Class.new(Fluent::BufferedOutput) {
+        include_klasses.each {|k| include k }
+
+        Fluent::Plugin.register_output(register_output_name, self)
+        def format(tag, time, record)
+          Checker.format_check(tag, time, record)
+          [tag, time, record].to_msgpack
+        end
+
+        def write(chunk); end
+      }
+
+      if block
+        Utils.const_set("MixinTestClass#{@@num}", klass)
+        klass.module_eval(&block)
+      end
+
+      Fluent::Test::BufferedOutputTestDriver.new(klass, tag) {
+      }.configure("type #{register_output_name}" + conf)
+    end
+  end
+
+  class SetTagKeyMixinText < Test::Unit::TestCase
+    include Utils
+
+    def test_tag_key_default
+      format_check({
+        'a' => 1
+      })
+
+      d = create_driver(Fluent::SetTagKeyMixin, %[
+      ])
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    def test_include_tag_key_true
+      format_check({
+        'tag' => 'test',
+        'a' => 1
+      })
+
+      d = create_driver(Fluent::SetTagKeyMixin, %[
+      include_tag_key true
+      ])
+
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    def test_include_tag_key_false
+      format_check({
+        'a' => 1
+      })
+
+      d = create_driver(Fluent::SetTagKeyMixin, %[
+      include_tag_key false
+      ])
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    def test_tag_key_set
+      format_check({
+        'tag_key_changed' => 'test',
+        'a' => 1
+      })
+
+      d = create_driver(Fluent::SetTagKeyMixin, %[
+      include_tag_key true
+      tag_key tag_key_changed
+      ])
+
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    sub_test_case "mixin" do
+      data(
+        'true' => true,
+        'false' => false)
+      test 'include_tag_key' do |param|
+        d = create_driver(Fluent::SetTagKeyMixin) {
+          config_set_default :include_tag_key, param
+        }
+
+        assert_equal(param, d.instance.include_tag_key)
+      end
+    end
+  end
+
+  class SetTimeKeyMixinText < Test::Unit::TestCase
+    include Utils
+
+    def test_time_key_default
+      format_check({
+        'a' => 1
+      })
+
+      d = create_driver(Fluent::SetTimeKeyMixin, %[
+      ])
+
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    def test_include_time_key_true
+      format_check({
+        'time' => "2010-05-04T03:02:01Z",
+        'a' => 1
+      })
+
+      d = create_driver(Fluent::SetTimeKeyMixin, %[
+      include_time_key true
+      ])
+
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    def test_time_format
+      format_check({
+        'time' => "20100504",
+        'a' => 1
+      })
+
+      d = create_driver(Fluent::SetTimeKeyMixin, %[
+      include_time_key true
+      time_format %Y%m%d
+      ])
+
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    def test_timezone_1
+      format_check({
+        'time' => "2010-05-03T17:02:01-10:00",
+        'a' => 1
+      })
+
+      d = create_driver(Fluent::SetTimeKeyMixin, %[
+      include_time_key true
+      timezone Pacific/Honolulu
+      ])
+
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    def test_timezone_2
+      format_check({
+        'time' => "2010-05-04T08:32:01+05:30",
+        'a' => 1
+      })
+
+      d = create_driver(Fluent::SetTimeKeyMixin, %[
+      include_time_key true
+      timezone +05:30
+      ])
+
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    def test_timezone_invalid
+      assert_raise(Fluent::ConfigError) do
+        create_driver(Fluent::SetTimeKeyMixin, %[
+        include_time_key true
+        timezone Invalid/Invalid
+        ])
+      end
+    end
+
+    sub_test_case "mixin" do
+      data(
+        'true' => true,
+        'false' => false)
+      test 'include_time_key' do |param|
+        d = create_driver(Fluent::SetTimeKeyMixin) {
+          config_set_default :include_time_key, param
+        }
+
+        assert_equal(param, d.instance.include_time_key)
+      end
+    end
+  end
+
+  class HandleTagMixinTest < Test::Unit::TestCase
+    include Utils
+
+    def test_add_tag_prefix
+      format_check({
+        'a' => 1
+      }, 'tag_prefix.test')
+      format_check({
+        'a' => 2
+      }, 'tag_prefix.test')
+
+      d = create_driver(Fluent::HandleTagNameMixin, %[
+        add_tag_prefix tag_prefix.
+        include_tag_key true
+      ])
+
+      d.emit({'a' => 1})
+      d.emit({'a' => 2})
+      d.run
+    end
+
+    def test_add_tag_suffix
+      format_check({
+        'a' => 1
+      }, 'test.test_suffix')
+      format_check({
+        'a' => 2
+      }, 'test.test_suffix')
+
+      d = create_driver(Fluent::HandleTagNameMixin, %[
+        add_tag_suffix .test_suffix
+        include_tag_key true
+      ])
+
+      d.emit({'a' => 1})
+      d.emit({'a' => 2})
+      d.run
+    end
+
+    def test_remove_tag_prefix
+      format_check({
+        'a' => 1
+      }, 'test')
+      format_check({
+        'a' => 2
+      }, 'test')
+
+      d = create_driver(Fluent::HandleTagNameMixin, %[
+        remove_tag_prefix te
+        include_tag_key true
+      ], "tetest")
+
+      d.emit({'a' => 1})
+      d.emit({'a' => 2})
+      d.run
+    end
+
+    def test_remove_tag_suffix
+      format_check({
+        'a' => 1
+      }, 'test')
+      format_check({
+        'a' => 2
+      }, 'test')
+
+      d = create_driver(Fluent::HandleTagNameMixin, %[
+        remove_tag_suffix st
+        include_tag_key true
+      ], "testst")
+
+      d.emit({'a' => 1})
+      d.emit({'a' => 2})
+      d.run
+    end
+
+    def test_mix_tag_handle
+      format_check({
+        'a' => 1
+      }, 'prefix.t')
+
+      d = create_driver(Fluent::HandleTagNameMixin, %[
+        remove_tag_prefix tes
+        add_tag_prefix prefix.
+      ])
+
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    def test_with_set_tag_key_mixin
+      format_check({
+        'tag' => 'tag_prefix.test',
+        'a' => 1
+      }, 'tag_prefix.test')
+
+      d = create_driver([Fluent::SetTagKeyMixin, Fluent::HandleTagNameMixin], %[
+        add_tag_prefix tag_prefix.
+        include_tag_key true
+      ])
+
+      d.emit({'a' => 1})
+      d.run
+    end
+
+    def test_with_set_tag_key_mixin_include_order_reverse
+      format_check({
+        'tag' => 'tag_prefix.test',
+        'a' => 1
+      }, 'tag_prefix.test')
+
+      d = create_driver([Fluent::HandleTagNameMixin, Fluent::SetTagKeyMixin], %[
+        add_tag_prefix tag_prefix.
+        include_tag_key true
+      ])
+
+      d.emit({'a' => 1})
+      d.run
+    end
+  end
+end

data/test/test_msgpack_factory.rb

@@ -0,0 +1,18 @@
+require_relative 'helper'
+require 'fluent/msgpack_factory'
+
+class MessagePackFactoryTest < Test::Unit::TestCase
+  test 'call log.warn only once' do
+    klass = Class.new do
+      include Fluent::MessagePackFactory::Mixin
+    end
+
+    mp = klass.new
+
+    mock.proxy($log).warn(anything).once
+
+    assert mp.msgpack_factory
+    assert mp.msgpack_factory
+    assert mp.msgpack_factory
+  end
+end

data/test/test_oj_options.rb

@@ -0,0 +1,55 @@
+require_relative 'helper'
+require 'fluent/test'
+require 'fluent/oj_options'
+
+class OjOptionsTest < ::Test::Unit::TestCase
+  begin
+    require 'oj'
+    @@oj_is_avaibale = true
+  rescue LoadError
+    @@oj_is_avaibale = false
+  end
+
+  setup do
+    @orig_env = {}
+    ENV.each do |key, value|
+      @orig_env[key] = value if key.start_with?("FLUENT_OJ_OPTION_")
+    end
+  end
+
+  teardown do
+    ENV.delete_if { |key| key.start_with?("FLUENT_OJ_OPTION_") }
+    @orig_env.each { |key, value| ENV[key] = value }
+  end
+
+  test "available?" do
+    assert_equal(@@oj_is_avaibale, Fluent::OjOptions.available?)
+  end
+
+  sub_test_case "set by environment variable" do
+    test "when no env vars set, returns default options" do
+      ENV.delete_if { |key| key.start_with?("FLUENT_OJ_OPTION_") }
+      defaults = Fluent::OjOptions::DEFAULTS
+      assert_equal(defaults, Fluent::OjOptions.load_env)
+      assert_equal(defaults, Oj.default_options.slice(*defaults.keys)) if @@oj_is_avaibale
+    end
+
+    test "valid env var passed with valid value, default is overridden" do
+      ENV["FLUENT_OJ_OPTION_BIGDECIMAL_LOAD"] = ":bigdecimal"
+      assert_equal(:bigdecimal, Fluent::OjOptions.load_env[:bigdecimal_load])
+      assert_equal(:bigdecimal, Oj.default_options[:bigdecimal_load]) if @@oj_is_avaibale
+    end
+
+    test "valid env var passed with invalid value, default is not overriden" do
+      ENV["FLUENT_OJ_OPTION_BIGDECIMAL_LOAD"] = ":conor"
+      assert_equal(:float, Fluent::OjOptions.load_env[:bigdecimal_load])
+      assert_equal(:float, Oj.default_options[:bigdecimal_load]) if @@oj_is_avaibale
+    end
+
+    test "invalid env var passed, nothing done with it" do
+      ENV["FLUENT_OJ_OPTION_CONOR"] = ":conor"
+      assert_equal(nil, Fluent::OjOptions.load_env[:conor])
+      assert_equal(nil, Oj.default_options[:conor]) if @@oj_is_avaibale
+    end
+  end
+end