fluentd-hubspot 0.14.14.1

data/test/plugin/test_parser_syslog.rb

@@ -0,0 +1,242 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser'
+
+class SyslogParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+    @parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::SyslogParser)
+    @expected = {
+      'host'    => '192.168.0.1',
+      'ident'   => 'fluentd',
+      'pid'     => '11111',
+      'message' => '[error] Syslog test'
+    }
+  end
+
+  def test_parse
+    @parser.configure({})
+    @parser.instance.parse('Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected, record)
+    }
+    assert_equal(Fluent::Plugin::SyslogParser::REGEXP, @parser.instance.patterns['format'])
+    assert_equal("%b %d %H:%M:%S", @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_with_time_format
+    @parser.configure('time_format' => '%b %d %M:%S:%H')
+    @parser.instance.parse('Feb 28 00:00:12 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected, record)
+    }
+    assert_equal('%b %d %M:%S:%H', @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_with_priority
+    @parser.configure('with_priority' => true)
+    @parser.instance.parse('<6>Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected.merge('pri' => 6), record)
+    }
+    assert_equal(Fluent::Plugin::SyslogParser::REGEXP_WITH_PRI, @parser.instance.patterns['format'])
+    assert_equal("%b %d %H:%M:%S", @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_without_colon
+    @parser.configure({})
+    @parser.instance.parse('Feb 28 12:00:00 192.168.0.1 fluentd[11111] [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected, record)
+    }
+    assert_equal(Fluent::Plugin::SyslogParser::REGEXP, @parser.instance.patterns['format'])
+    assert_equal("%b %d %H:%M:%S", @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_with_keep_time_key
+    @parser.configure(
+                      'time_format' => '%b %d %M:%S:%H',
+                      'keep_time_key'=>'true',
+                      )
+    text = 'Feb 28 00:00:12 192.168.0.1 fluentd[11111]: [error] Syslog test'
+    @parser.instance.parse(text) do |time, record|
+      assert_equal "Feb 28 00:00:12", record['time']
+    end
+  end
+
+  class TestRFC5424Regexp < self
+    def test_parse_with_rfc5424_message
+      @parser.configure(
+                        'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
+                        'message_format' => 'rfc5424',
+                        )
+      text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - 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 "-", record["pid"]
+        assert_equal "-", record["msgid"]
+        assert_equal "-", record["extradata"]
+        assert_equal "Hi, from Fluentd!", record["message"]
+      end
+    end
+
+    def test_parse_with_rfc5424_message_without_time_format
+      @parser.configure(
+                        'message_format' => 'rfc5424',
+                        )
+      text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - 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 "-", record["pid"]
+        assert_equal "-", record["msgid"]
+        assert_equal "-", record["extradata"]
+        assert_equal "Hi, from Fluentd!", record["message"]
+      end
+    end
+
+    def test_parse_with_rfc5424_structured_message
+      @parser.configure(
+                        'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
+                        'message_format' => 'rfc5424',
+                        )
+      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"]
+      end
+    end
+  end
+
+  class TestAutoRegexp < self
+    def test_auto_with_legacy_syslog_message
+      @parser.configure(
+                        'time_format' => '%b %d %M:%S:%H',
+                        'mseeage_format' => 'auto',
+                        )
+      text = 'Feb 28 00:00:12 192.168.0.1 fluentd[11111]: [error] Syslog test'
+      @parser.instance.parse(text) do |time, record|
+        assert_equal(event_time("Feb 28 00:00:12", format: '%b %d %M:%S:%H'), time)
+        assert_equal(@expected, record)
+      end
+    end
+
+    def test_auto_with_legacy_syslog_priority_message
+      @parser.configure(
+                        'time_format' => '%b %d %M:%S:%H',
+                        'with_priority' => true,
+                        'mseeage_format' => 'auto',
+                        )
+      text = '<6>Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test'
+      @parser.instance.parse(text) do |time, record|
+        assert_equal(event_time("Feb 28 12:00:00", format: '%b %d %M:%S:%H'), time)
+        assert_equal(@expected.merge('pri' => 6), record)
+      end
+    end
+
+    def test_parse_with_rfc5424_message
+      @parser.configure(
+                        'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
+                        'message_format' => 'auto',
+                        )
+      text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - 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 "-", record["pid"]
+        assert_equal "-", record["msgid"]
+        assert_equal "-", record["extradata"]
+        assert_equal "Hi, from Fluentd!", record["message"]
+      end
+    end
+
+    def test_parse_with_rfc5424_structured_message
+      @parser.configure(
+                        'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
+                        'message_format' => 'auto',
+                        )
+      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"]
+      end
+    end
+
+    def test_parse_with_both_message_type
+      @parser.configure(
+        'time_format' => '%b %d %M:%S:%H',
+        'rfc5424_time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
+        'message_format' => 'auto',
+      )
+      text = 'Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test'
+      @parser.instance.parse(text) do |time, record|
+        assert_equal(event_time("Feb 28 12:00:00", format: '%b %d %M:%S:%H'), time)
+        assert_equal(@expected, record)
+      end
+      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"]
+      end
+      text = 'Feb 28 12:00:02 192.168.0.1 fluentd[11111]: [error] Syslog test'
+      @parser.instance.parse(text) do |time, record|
+        assert_equal(event_time("Feb 28 12:00:02", format: '%b %d %M:%S:%H'), time)
+        assert_equal(@expected, record)
+      end
+      text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - 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 "-", record["pid"]
+        assert_equal "-", record["msgid"]
+        assert_equal "-", record["extradata"]
+        assert_equal "Hi, from Fluentd!", record["message"]
+      end
+    end
+
+    def test_parse_with_both_message_type_and_priority
+      @parser.configure(
+                        'time_format' => '%b %d %M:%S:%H',
+                        'rfc5424_time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
+                        'with_priority' => true,
+                        'message_format' => 'auto',
+                        )
+      text = '<6>Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test'
+      @parser.instance.parse(text) do |time, record|
+        assert_equal(event_time("Feb 28 12:00:00", format: '%b %d %M:%S:%H'), time)
+        assert_equal(@expected.merge('pri' => 6), record)
+      end
+      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"]
+      end
+      text = '<16>Feb 28 12:00:02 192.168.0.1 fluentd[11111]: [error] Syslog test'
+      @parser.instance.parse(text) do |time, record|
+        assert_equal(event_time("Feb 28 12:00:02", format: '%b %d %M:%S:%H'), time)
+        assert_equal(@expected.merge('pri' => 16), record)
+      end
+      text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - 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 "-", record["pid"]
+        assert_equal "-", record["msgid"]
+        assert_equal "-", record["extradata"]
+        assert_equal "Hi, from Fluentd!", record["message"]
+      end
+    end
+  end
+end

data/test/plugin/test_parser_tsv.rb

@@ -0,0 +1,122 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser_tsv'
+
+class TSVParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  def create_driver(conf={})
+    Fluent::Test::Driver::Parser.new(Fluent::TextParser::TSVParser).configure(conf)
+  end
+
+  data('array param' => '["a","b"]', 'string param' => 'a,b')
+  def test_config_params(param)
+    d = create_driver(
+      'keys' => param,
+    )
+
+    assert_equal "\t", d.instance.delimiter
+
+    d = create_driver(
+      'keys' => param,
+      'delimiter' => ',',
+    )
+
+    assert_equal ['a', 'b'], d.instance.keys
+    assert_equal ",", d.instance.delimiter
+  end
+
+  data('array param' => '["time","a","b"]', 'string param' => 'time,a,b')
+  def test_parse(param)
+    d = create_driver('keys' => param, 'time_key' => 'time')
+    d.instance.parse("2013/02/28 12:00:00\t192.168.0.1\t111") { |time, record|
+      assert_equal(event_time('2013/02/28 12:00:00', format: '%Y/%m/%d %H:%M:%S'), time)
+      assert_equal({
+          'a' => '192.168.0.1',
+          'b' => '111',
+        }, record)
+    }
+  end
+
+  def test_parse_with_time
+    time_at_start = Time.now.to_i
+
+    d = create_driver('keys' => 'a,b')
+    d.instance.parse("192.168.0.1\t111") { |time, record|
+      assert time && time >= time_at_start, "parser puts current time without time input"
+      assert_equal({
+          'a' => '192.168.0.1',
+          'b' => '111',
+        }, record)
+    }
+
+    d = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    d.configure('keys' => 'a,b', 'time_key' => 'time', 'estimate_current_event' => 'no')
+    d.instance.parse("192.168.0.1\t111") { |time, record|
+      assert_equal({
+                     'a' => '192.168.0.1',
+                     'b' => '111',
+                   }, record)
+      assert_nil time, "parser returns nil w/o time and if configured so"
+    }
+  end
+
+  data(
+    'left blank column' => ["\t@\t@", {"1" => "","2" => "@","3" => "@"}],
+    'center blank column' => ["@\t\t@", {"1" => "@","2" => "","3" => "@"}],
+    'right blank column' => ["@\t@\t", {"1" => "@","2" => "@","3" => ""}],
+    '2 right blank columns' => ["@\t\t", {"1" => "@","2" => "","3" => ""}],
+    'left blank columns' => ["\t\t@", {"1" => "","2" => "","3" => "@"}],
+    'all blank columns' => ["\t\t", {"1" => "","2" => "","3" => ""}])
+  def test_black_column(data)
+    line, expected = data
+
+    d = create_driver('keys' => '1,2,3')
+    d.instance.parse(line) { |time, record|
+      assert_equal(expected, record)
+    }
+  end
+
+  def test_parse_with_keep_time_key
+    d = create_driver(
+      'keys'=>'time',
+      'time_key'=>'time',
+      'time_format'=>"%d/%b/%Y:%H:%M:%S %z",
+      'keep_time_key'=>'true',
+    )
+    text = '28/Feb/2013:12:00:00 +0900'
+    d.instance.parse(text) do |time, record|
+      assert_equal text, record['time']
+    end
+  end
+
+  data('array param' => '["a","b","c","d","e","f"]', 'string param' => 'a,b,c,d,e,f')
+  def test_parse_with_null_value_pattern(param)
+    d = create_driver(
+      'keys'=>param,
+      'null_value_pattern'=>'^(-|null|NULL)$'
+    )
+    d.instance.parse("-\tnull\tNULL\t\t--\tnuLL") do |time, record|
+      assert_nil record['a']
+      assert_nil record['b']
+      assert_nil record['c']
+      assert_equal record['d'], ''
+      assert_equal record['e'], '--'
+      assert_equal record['f'], 'nuLL'
+    end
+  end
+
+  data('array param' => '["a","b"]', 'string param' => 'a,b')
+  def test_parse_with_null_empty_string(param)
+    d = create_driver(
+      'keys'=>param,
+      'null_empty_string'=>true
+    )
+    d.instance.parse("\t ") do |time, record|
+      assert_nil record['a']
+      assert_equal record['b'], ' '
+    end
+  end
+end

data/test/plugin/test_storage.rb

@@ -0,0 +1,167 @@
+require_relative '../helper'
+require 'fluent/plugin/storage'
+require 'fluent/plugin/base'
+
+class DummyPlugin < Fluent::Plugin::TestBase
+end
+
+class BareStorage < Fluent::Plugin::Storage
+  Fluent::Plugin.register_storage('bare', self)
+end
+
+class BasicStorage < Fluent::Plugin::Storage
+  Fluent::Plugin.register_storage('example', self)
+
+  attr_reader :data, :saved
+
+  def initialize
+    super
+    @data = @saved = nil
+  end
+  def load
+    @data = {}
+  end
+  def save
+    @saved = @data.dup
+  end
+  def get(key)
+    @data[key]
+  end
+  def fetch(key, defval)
+    @data.fetch(key, defval)
+  end
+  def put(key, value)
+    @data[key] = value
+  end
+  def delete(key)
+    @data.delete(key)
+  end
+  def update(key, &block)
+    @data[key] = block.call(@data[key])
+  end
+  def close
+    @data = {}
+    super
+  end
+  def terminate
+    @saved = {}
+    super
+  end
+end
+
+class StorageTest < Test::Unit::TestCase
+  sub_test_case 'BareStorage' do
+    setup do
+      plugin = DummyPlugin.new
+      @s = BareStorage.new
+      @s.configure(config_element())
+      @s.owner = plugin
+    end
+
+    test 'is configured with plugin information and system config' do
+      plugin = DummyPlugin.new
+      plugin.system_config_override({'process_name' => 'mytest'})
+      plugin.configure(config_element('ROOT', '', {'@id' => '1'}))
+      s = BareStorage.new
+      s.configure(config_element())
+      s.owner = plugin
+
+      assert_equal 'mytest', s.owner.system_config.process_name
+      assert_equal '1', s.instance_eval{ @_plugin_id }
+      assert_equal true, s.instance_eval{ @_plugin_id_configured }
+    end
+
+    test 'does NOT have features for high-performance/high-consistent storages' do
+      assert_equal false, @s.persistent_always?
+      assert_equal false, @s.synchronized?
+    end
+
+    test 'does have default values which is conservative for almost all users' do
+      assert_equal false, @s.persistent
+      assert_equal true, @s.autosave
+      assert_equal 10,   @s.autosave_interval
+      assert_equal true, @s.save_at_shutdown
+    end
+
+    test 'load/save doesn NOT anything: just as memory storage' do
+      assert_nothing_raised{ @s.load }
+      assert_nothing_raised{ @s.save }
+    end
+
+    test 'all operations are not defined yet' do
+      assert_raise NotImplementedError do
+        @s.get('key')
+      end
+      assert_raise NotImplementedError do
+        @s.fetch('key', 'value')
+      end
+      assert_raise NotImplementedError do
+        @s.put('key', 'value')
+      end
+      assert_raise NotImplementedError do
+        @s.delete('key')
+      end
+      assert_raise NotImplementedError do
+        @s.update('key'){ |v| v + '2' }
+      end
+    end
+  end
+
+  sub_test_case 'ExampleStorage' do
+    setup do
+      plugin = DummyPlugin.new
+      plugin.configure(config_element('ROOT', '', {'@id' => '1'}))
+      @s = BasicStorage.new
+      @s.configure(config_element())
+      @s.owner = plugin
+    end
+
+    test 'load/save works well as plugin internal state operations' do
+      plugin = DummyPlugin.new
+      plugin.configure(config_element('ROOT', '', {'@id' => '0'}))
+      s = BasicStorage.new
+      s.owner = plugin
+
+      assert_nothing_raised{ s.load }
+      assert s.data
+      assert_nil s.saved
+
+      assert_nothing_raised{ s.save }
+      assert s.saved
+      assert{ s.data == s.saved }
+      assert{ s.data.object_id != s.saved.object_id }
+    end
+
+    test 'all operations work well' do
+      @s.load
+
+      assert_nil @s.get('key')
+      assert_equal 'value', @s.fetch('key', 'value')
+      assert_nil @s.get('key')
+
+      assert_equal 'value', @s.put('key', 'value')
+      assert_equal 'value', @s.get('key')
+
+      assert_equal 'valuevalue', @s.update('key'){|v| v * 2 }
+
+      assert_equal 'valuevalue', @s.delete('key')
+    end
+
+    test 'close and terminate work to operate internal states' do
+      @s.load
+      @s.put('k1', 'v1')
+      @s.put('k2', 'v2')
+      assert_equal 2, @s.data.size
+      @s.save
+      assert_equal @s.data.size, @s.saved.size
+
+      assert_nothing_raised{ @s.close }
+      assert @s.data.empty?
+      assert !@s.saved.empty?
+
+      assert_nothing_raised{ @s.terminate }
+      assert @s.data.empty?
+      assert @s.saved.empty?
+    end
+  end
+end