fluentd 0.14.7-x86-mingw32 → 0.14.10-x86-mingw32

data/test/plugin/test_in_monitor_agent.rb

@@ -30,6 +30,7 @@ class MonitorAgentInputTest < Test::Unit::TestCase
     assert_equal(24220, d.instance.port)
     assert_equal(nil, d.instance.tag)
     assert_equal(60, d.instance.emit_interval)
+    assert_true d.instance.include_config
   end
 
   sub_test_case "collect plugin information" do
@@ -90,48 +91,37 @@ EOC
       assert_equal("output", d.instance.plugin_category(error_label.outputs.first))
     end
 
-    test "get_monitor_info" do
+    data(:with_config_yes => true,
+         :with_config_no => false)
+    test "get_monitor_info" do |with_config|
       d = create_driver
       test_label = @ra.labels['@test']
       error_label = @ra.labels['@ERROR']
       input_info = {
-        "config" => {
-          "@id"   => "test_in",
-          "@type" => "test_in"
-        },
         "output_plugin"  => false,
         "plugin_category"=> "input",
         "plugin_id"      => "test_in",
         "retry_count"    => nil,
         "type"           => "test_in"
       }
+      input_info.merge!("config" => {"@id" => "test_in", "@type" => "test_in"}) if with_config
       filter_info = {
-        "config" => {
-          "@id"   => "test_filter",
-          "@type" => "test_filter"
-        },
         "output_plugin"   => false,
         "plugin_category" => "filter",
         "plugin_id"       => "test_filter",
         "retry_count"     => nil,
         "type"            => "test_filter"
       }
+      filter_info.merge!("config" => {"@id" => "test_filter", "@type" => "test_filter"}) if with_config
       output_info = {
-        "config" => {
-          "@id"   => "test_out",
-          "@type" => "test_out"
-        },
         "output_plugin"   => true,
         "plugin_category" => "output",
         "plugin_id"       => "test_out",
         "retry_count"     => 0,
         "type"            => "test_out"
       }
+      output_info.merge!("config" => {"@id" => "test_out", "@type" => "test_out"}) if with_config
       error_label_info = {
-        "config" => {
-          "@id"=>"null",
-          "@type" => "null"
-        },
         "buffer_queue_length" => 0,
         "buffer_total_queued_size" => 0,
         "output_plugin"   => true,
@@ -140,10 +130,12 @@ EOC
         "retry_count"     => 0,
         "type"            => "null"
       }
-      assert_equal(input_info, d.instance.get_monitor_info(@ra.inputs.first))
-      assert_equal(filter_info, d.instance.get_monitor_info(@ra.filters.first))
-      assert_equal(output_info, d.instance.get_monitor_info(test_label.outputs.first))
-      assert_equal(error_label_info, d.instance.get_monitor_info(error_label.outputs.first))
+      error_label_info.merge!("config" => {"@id"=>"null", "@type" => "null"}) if with_config
+      opts = {with_config: with_config}
+      assert_equal(input_info, d.instance.get_monitor_info(@ra.inputs.first, opts))
+      assert_equal(filter_info, d.instance.get_monitor_info(@ra.filters.first, opts))
+      assert_equal(output_info, d.instance.get_monitor_info(test_label.outputs.first, opts))
+      assert_equal(error_label_info, d.instance.get_monitor_info(error_label.outputs.first, opts))
     end
 
     test "fluentd opts" do
@@ -207,7 +199,7 @@ EOC
 
   def get(uri, header = {})
     url = URI.parse(uri)
-    req = Net::HTTP::Get.new(url.path, header)
+    req = Net::HTTP::Get.new(url, header)
     unless header.has_key?('Content-Type')
       header['Content-Type'] = 'application/octet-stream'
     end
@@ -258,6 +250,8 @@ EOC
       @ra = Fluent::RootAgent.new(log: $log)
       stub(Fluent::Engine).root_agent { @ra }
       @ra = configure_ra(@ra, conf)
+      # store Supervisor instance to avoid collected by GC
+      @supervisor = Fluent::Supervisor.new(Fluent::Supervisor.default_options)
     end
 
     test "/api/plugins" do
@@ -280,36 +274,36 @@ plugin_id:test_filter\tplugin_category:filter\ttype:test_filter\toutput_plugin:f
       assert_equal(expected_test_filter_response, test_filter)
     end
 
-    test "/api/plugins.json" do
+    data(:include_config_yes => [true, "include_config yes"],
+         :include_config_no => [false, "include_config no"])
+    test "/api/plugins.json" do |(with_config, include_conf)|
+
       d = create_driver("
   @type monitor_agent
   bind '127.0.0.1'
   port #{@port}
   tag monitor
+  #{include_conf}
 ")
       d.instance.start
-      expected_test_in_response =
-        {"config" => {
-          "@id"   => "test_in",
-          "@type" => "test_in"
-        },
+      expected_test_in_response = {
         "output_plugin"   => false,
         "plugin_category" => "input",
         "plugin_id"       => "test_in",
         "retry_count"     => nil,
-        "type"            => "test_in"}
-      expected_null_response =
-        {"config" => {
-          "@id"   => "null",
-          "@type" => "null"
-        },
+        "type"            => "test_in"
+      }
+      expected_test_in_response.merge!("config" => {"@id" => "test_in", "@type" => "test_in"}) if with_config
+      expected_null_response = {
         "buffer_queue_length" => 0,
         "buffer_total_queued_size" => 0,
         "output_plugin"   => true,
         "plugin_category" => "output",
         "plugin_id"       => "null",
         "retry_count"     => 0,
-        "type"            => "null"}
+        "type"            => "null"
+      }
+      expected_null_response.merge!("config" => {"@id" => "null", "@type" => "null"}) if with_config
       response = JSON.parse(get("http://127.0.0.1:#{@port}/api/plugins.json"))
       test_in_response = response["plugins"][0]
       null_response = response["plugins"][5]
@@ -317,6 +311,42 @@ plugin_id:test_filter\tplugin_category:filter\ttype:test_filter\toutput_plugin:f
       assert_equal(expected_null_response, null_response)
     end
 
+    data(:with_config_yes => [true, "?with_config=yes"],
+         :with_config_no => [false, "?with_config=no"])
+    test "/api/plugins.json with query parameter. query parameter is preferred than include_config" do |(with_config, query_param)|
+
+      d = create_driver("
+  @type monitor_agent
+  bind '127.0.0.1'
+  port #{@port}
+  tag monitor
+")
+      d.instance.start
+      expected_test_in_response = {
+        "output_plugin"   => false,
+        "plugin_category" => "input",
+        "plugin_id"       => "test_in",
+        "retry_count"     => nil,
+        "type"            => "test_in"
+      }
+      expected_test_in_response.merge!("config" => {"@id" => "test_in", "@type" => "test_in"}) if with_config
+      expected_null_response = {
+        "buffer_queue_length" => 0,
+        "buffer_total_queued_size" => 0,
+        "output_plugin"   => true,
+        "plugin_category" => "output",
+        "plugin_id"       => "null",
+        "retry_count"     => 0,
+        "type"            => "null"
+      }
+      expected_null_response.merge!("config" => {"@id" => "null", "@type" => "null"}) if with_config
+      response = JSON.parse(get("http://127.0.0.1:#{@port}/api/plugins.json#{query_param}"))
+      test_in_response = response["plugins"][0]
+      null_response = response["plugins"][5]
+      assert_equal(expected_test_in_response, test_in_response)
+      assert_equal(expected_null_response, null_response)
+    end
+
     test "/api/config" do
       d = create_driver("
   @type monitor_agent

data/test/plugin/test_in_syslog.rb

@@ -176,7 +176,41 @@ class SyslogInputTest < Test::Unit::TestCase
     end
 
     assert(d.events.size > 0)
-    compare_test_result(d.events, tests, host)
+    compare_test_result(d.events, tests, {host: host})
+  end
+
+  def test_msg_size_with_include_priority
+    d = create_driver([CONFIG, 'priority_key priority'].join("\n"))
+    tests = create_test_case
+
+    priority = 'info'
+    d.run(expect_emits: 2) do
+      u = UDPSocket.new
+      u.connect('127.0.0.1', PORT)
+      tests.each {|test|
+        u.send(test['msg'], 0)
+      }
+    end
+
+    assert(d.events.size > 0)
+    compare_test_result(d.events, tests, {priority: priority})
+  end
+
+  def test_msg_size_with_include_facility
+    d = create_driver([CONFIG, 'facility_key facility'].join("\n"))
+    tests = create_test_case
+
+    facility = 'kern'
+    d.run(expect_emits: 2) do
+      u = UDPSocket.new
+      u.connect('127.0.0.1', PORT)
+      tests.each {|test|
+        u.send(test['msg'], 0)
+      }
+    end
+
+    assert(d.events.size > 0)
+    compare_test_result(d.events, tests, {facility: facility})
   end
 
   def create_test_case(large_message: false)
@@ -195,11 +229,13 @@ class SyslogInputTest < Test::Unit::TestCase
     end
   end
 
-  def compare_test_result(events, tests, host = nil)
+  def compare_test_result(events, tests, options = {})
     events.each_index { |i|
       assert_equal('syslog.kern.info', events[i][0]) # <6> means kern.info
       assert_equal(tests[i]['expected'], events[i][2]['message'])
-      assert_equal(host, events[i][2]['source_host']) if host
+      assert_equal(options[:host], events[i][2]['source_host']) if options[:host]
+      assert_equal(options[:priority], events[i][2]['priority']) if options[:priority]
+      assert_equal(options[:facility], events[i][2]['facility']) if options[:facility]
     }
   end
 end

data/test/plugin/test_in_tcp.rb

@@ -1,20 +1,8 @@
 require_relative '../helper'
-require 'fluent/test'
+require 'fluent/test/driver/input'
 require 'fluent/plugin/in_tcp'
 
 class TcpInputTest < Test::Unit::TestCase
-  class << self
-    def startup
-      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
-      @server = ServerEngine::SocketManager::Server.open(socket_manager_path)
-      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
-    end
-
-    def shutdown
-      @server.close
-    end
-  end
-
   def setup
     Fluent::Test.setup
   end
@@ -34,69 +22,97 @@ class TcpInputTest < Test::Unit::TestCase
   ]
 
   def create_driver(conf)
-    Fluent::Test::InputTestDriver.new(Fluent::TcpInput).configure(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::TcpInput).configure(conf)
   end
 
-  def test_configure
-    configs = {'127.0.0.1' => CONFIG}
-    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+  def create_tcp_socket(host, port, &block)
+    if block_given?
+      TCPSocket.open(host, port, &block)
+    else
+      TCPSocket.open(host, port)
+    end
+  end
+
+
+  data(
+    'ipv4' => [CONFIG, '127.0.0.1', :ipv4],
+    'ipv6' => [IPv6_CONFIG, '::1', :ipv6],
+  )
+  test 'configure' do |data|
+    conf, bind, protocol = data
+    omit "IPv6 is not supported on this environment" if protocol == :ipv6 && !ipv6_enabled?
 
-    configs.each_pair { |k, v|
-      d = create_driver(v)
-      assert_equal PORT, d.instance.port
-      assert_equal k, d.instance.bind
-      assert_equal "\n", d.instance.delimiter
-    }
+    d = create_driver(conf)
+    assert_equal PORT, d.instance.port
+    assert_equal bind, d.instance.bind
+    assert_equal "\n", d.instance.delimiter
   end
 
-  {
-    'none' => [
-      {'msg' => "tcptest1\n", 'expected' => 'tcptest1'},
-      {'msg' => "tcptest2\n", 'expected' => 'tcptest2'},
-    ],
-    'json' => [
-      {'msg' => {'k' => 123, 'message' => 'tcptest1'}.to_json + "\n", 'expected' => 'tcptest1'},
-      {'msg' => {'k' => 'tcptest2', 'message' => 456}.to_json + "\n", 'expected' => 456},
-    ]
-  }.each { |format, test_cases|
-    define_method("test_msg_size_#{format}") do
-      d = create_driver(BASE_CONFIG + "format #{format}")
-      tests = test_cases
+  test_case_data = {
+    'none' => {
+      'format' => 'none',
+      'payloads' => [ "tcptest1\n", "tcptest2\n" ],
+      'expecteds' => [
+        {'message' => 'tcptest1'},
+        {'message' => 'tcptest2'},
+      ],
+    },
+    'json' => {
+      'format' => 'json',
+      'payloads' => [
+        {'k' => 123, 'message' => 'tcptest1'}.to_json + "\n",
+        {'k' => 'tcptest2', 'message' => 456}.to_json + "\n",
+      ],
+      'expecteds' => [
+        {'k' => 123, 'message' => 'tcptest1'},
+        {'k' => 'tcptest2', 'message' => 456}
+      ],
+    },
+  }
+
+  data(test_case_data)
+  test 'test_msg_size' do |data|
+    format = data['format']
+    payloads = data['payloads']
+    expecteds = data['expecteds']
 
-      d.run do
-        tests.each {|test|
-          TCPSocket.open('127.0.0.1', PORT) do |s|
-            s.send(test['msg'], 0)
-          end
-        }
-        sleep 1
+    d = create_driver(BASE_CONFIG + "format #{format}")
+    d.run(expect_records: 2) do
+      payloads.each do |payload|
+        create_tcp_socket('127.0.0.1', PORT) do |sock|
+          sock.send(payload, 0)
+        end
       end
+    end
 
-      compare_test_result(d.emits, tests)
+    assert_equal 2, d.events.size
+    expecteds.each_with_index do |expected_record, i|
+      assert_equal "tcp", d.events[i][0]
+      assert d.events[i][1].is_a?(Fluent::EventTime)
+      assert_equal expected_record, d.events[i][2]
     end
+  end
 
-    define_method("test_msg_size_with_same_connection_#{format}") do
-      d = create_driver(BASE_CONFIG + "format #{format}")
-      tests = test_cases
+  data(test_case_data)
+  test 'test data in a connection' do |data|
+    format = data['format']
+    payloads = data['payloads']
+    expecteds = data['expecteds']
 
-      d.run do
-        TCPSocket.open('127.0.0.1', PORT) do |s|
-          tests.each {|test|
-            s.send(test['msg'], 0)
-          }
+    d = create_driver(BASE_CONFIG + "format #{format}")
+    d.run(expect_records: 2) do
+      create_tcp_socket('127.0.0.1', PORT) do |sock|
+        payloads.each do |payload|
+          sock.send(payload, 0)
         end
-        sleep 1
       end
-
-      compare_test_result(d.emits, tests)
     end
-  }
 
-  def compare_test_result(emits, tests)
-    assert_equal(2, emits.size)
-    emits.each_index {|i|
-      assert_equal(tests[i]['expected'], emits[i][2]['message'])
-      assert(emits[i][1].is_a?(Fluent::EventTime))
-    }
+    assert_equal 2, d.events.size
+    expecteds.each_with_index do |expected_record, i|
+      assert_equal "tcp", d.events[i][0]
+      assert d.events[i][1].is_a?(Fluent::EventTime)
+      assert_equal expected_record, d.events[i][2]
+    end
   end
 end

data/test/plugin/test_in_udp.rb

@@ -1,20 +1,8 @@
 require_relative '../helper'
-require 'fluent/test'
+require 'fluent/test/driver/input'
 require 'fluent/plugin/in_udp'
 
 class UdpInputTest < Test::Unit::TestCase
-  class << self
-    def startup
-      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
-      @server = ServerEngine::SocketManager::Server.open(socket_manager_path)
-      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
-    end
-
-    def shutdown
-      @server.close
-    end
-  end
-
   def setup
     Fluent::Test.setup
   end
@@ -34,88 +22,121 @@ class UdpInputTest < Test::Unit::TestCase
   !
 
   def create_driver(conf)
-    Fluent::Test::InputTestDriver.new(Fluent::UdpInput).configure(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::UdpInput).configure(conf)
   end
 
-  def test_configure
-    configs = {'127.0.0.1' => CONFIG}
-    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+  def create_udp_socket(host, port)
+    u = if IPAddr.new(IPSocket.getaddress(host)).ipv4?
+          UDPSocket.new(Socket::AF_INET)
+        else
+          UDPSocket.new(Socket::AF_INET6)
+        end
+    u.connect(host, port)
+    if block_given?
+      begin
+        yield u
+      ensure
+        u.close rescue nil
+      end
+    else
+      u
+    end
+  end
 
-    configs.each_pair { |k, v|
-      d = create_driver(v)
-      assert_equal PORT, d.instance.port
-      assert_equal k, d.instance.bind
-      assert_equal 4096, d.instance.body_size_limit
-    }
+  data(
+    'ipv4' => [CONFIG, '127.0.0.1', :ipv4],
+    'ipv6' => [IPv6_CONFIG, '::1', :ipv6],
+  )
+  test 'configure' do |data|
+    conf, bind, protocol = data
+    omit "IPv6 is not supported on this environment" if protocol == :ipv6 && !ipv6_enabled?
+
+    d = create_driver(conf)
+    assert_equal PORT, d.instance.port
+    assert_equal bind, d.instance.bind
+    assert_equal 4096, d.instance.body_size_limit
   end
 
-  def test_time_format
-    configs = {'127.0.0.1' => CONFIG}
-    configs.merge!('::1' => IPv6_CONFIG) if ipv6_enabled?
+  data(
+    'ipv4' => [CONFIG, '127.0.0.1', :ipv4],
+    'ipv6' => [IPv6_CONFIG, '::1', :ipv6],
+  )
+  test 'time_format' do |data|
+    conf, bind, protocol = data
+    omit "IPv6 is not supported on this environment" if protocol == :ipv6 && !ipv6_enabled?
 
-    configs.each_pair { |k, v|
-      d = create_driver(v)
+    d = create_driver(conf)
 
-      tests = [
-        {'msg' => '[Sep 11 00:00:00] localhost logger: foo', 'expected' => Fluent::EventTime.from_time(Time.strptime('Sep 11 00:00:00', '%b %d %H:%M:%S'))},
-        {'msg' => '[Sep  1 00:00:00] localhost logger: foo', 'expected' => Fluent::EventTime.from_time(Time.strptime('Sep  1 00:00:00', '%b  %d %H:%M:%S'))},
-      ]
+    tests = [
+      {'msg' => '[Sep 11 00:00:00] localhost logger: foo', 'expected' => event_time('Sep 11 00:00:00', format: '%b %d %H:%M:%S')},
+      {'msg' => '[Sep  1 00:00:00] localhost logger: foo', 'expected' => event_time('Sep  1 00:00:00', format: '%b  %d %H:%M:%S')},
+    ]
 
-      d.run do
-        u = Fluent::SocketUtil.create_udp_socket(k)
-        u.connect(k, PORT)
-        tests.each {|test|
+    d.run(expect_records: 2) do
+      create_udp_socket(bind, PORT) do |u|
+        tests.each do |test|
           u.send(test['msg'], 0)
-        }
-        u.close
-        sleep 1
+        end
       end
+    end
 
-      emits = d.emits
-      emits.each_index {|i|
-        assert_equal_event_time(tests[i]['expected'], emits[i][1])
-      }
-    }
-
+    events = d.events
+    tests.each_with_index do |t, i|
+      assert_equal_event_time(t['expected'], events[i][1])
+    end
   end
 
-  {
-    'none' => [
-      {'msg' => "tcptest1\n", 'expected' => 'tcptest1'},
-      {'msg' => "tcptest2\n", 'expected' => 'tcptest2'},
-    ],
-    'json' => [
-      {'msg' => {'k' => 123, 'message' => 'tcptest1'}.to_json + "\n", 'expected' => 'tcptest1'},
-      {'msg' => {'k' => 'tcptest2', 'message' => 456}.to_json + "\n", 'expected' => 456},
-    ],
-    '/^\\[(?<time>[^\\]]*)\\] (?<message>.*)/' => [
-      {'msg' => '[Sep 10 00:00:00] localhost: ' + 'x' * 100 + "\n", 'expected' => 'localhost: ' + 'x' * 100},
-      {'msg' => '[Sep 10 00:00:00] localhost: ' + 'x' * 1024 + "\n", 'expected' => 'localhost: ' + 'x' * 1024},
-    ]
-  }.each { |format, test_cases|
-    define_method("test_msg_size_#{format[0] == '/' ? 'regexp' : format}") do
-      d = create_driver(BASE_CONFIG + "format #{format}")
-      tests = test_cases
-
-      d.run do
-        u = UDPSocket.new
-        u.connect('127.0.0.1', PORT)
-        tests.each { |test|
-          u.send(test['msg'], 0)
-        }
-        u.close
-        sleep 1
+  data(
+    'none' => {
+      'format' => 'none',
+      'payloads' => ["tcptest1\n", "tcptest2\n"],
+      'expecteds' => [
+        {"message" => "tcptest1"},
+        {"message" => "tcptest2"},
+      ],
+    },
+    'json' => {
+      'format' => 'json',
+      'payloads' => [
+        {'k' => 123, 'message' => 'tcptest1'}.to_json + "\n",
+        {'k' => 'tcptest2', 'message' => 456}.to_json + "\n",
+      ],
+      'expecteds' => [
+        {'k' => 123, 'message' => 'tcptest1'},
+        {'k' => 'tcptest2', 'message' => 456},
+      ],
+    },
+    'regexp' => {
+      'format' => '/^\\[(?<time>[^\\]]*)\\] (?<message>.*)/',
+      'payloads' => [
+        '[Sep 10 00:00:00] localhost: ' + 'x' * 100 + "\n",
+        '[Sep 10 00:00:00] localhost: ' + 'x' * 1024 + "\n"
+      ],
+      'expecteds' => [
+        {"message" => 'localhost: ' + 'x' * 100},
+        {"message" => 'localhost: ' + 'x' * 1024},
+      ],
+    },
+  )
+  test 'message size with format' do |data|
+    format = data['format']
+    payloads = data['payloads']
+    expecteds = data['expecteds']
+
+    d = create_driver(BASE_CONFIG + "format #{format}")
+    d.run(expect_records: 2) do
+      create_udp_socket('127.0.0.1', PORT) do |u|
+        payloads.each do |payload|
+          u.send(payload, 0)
+        end
       end
-
-      compare_test_result(d.emits, tests)
     end
-  }
 
-  def compare_test_result(emits, tests)
-    assert_equal(2, emits.size)
-    emits.each_index {|i|
-      assert_equal(tests[i]['expected'], emits[i][2]['message'])
-      assert(emits[i][1].is_a?(Fluent::EventTime))
-    }
+    assert_equal 2, d.events.size
+    expecteds.each_with_index do |expected_record, i|
+      assert_equal "udp", d.events[i][0]
+      assert d.events[i][1].is_a?(Fluent::EventTime)
+      assert_equal expected_record, d.events[i][2]
+    end
   end
 end