fluent-plugin-map 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9a767a49eb9d5a861f7099c43c12c5d2332217b
-  data.tar.gz: 1f268279fc54424d6d849b251fb62af7f7cf4597
+  metadata.gz: 246617171836e1abe17ac43a1ded20f5b1aad8bc
+  data.tar.gz: '05190f0f3356ed013af121d2e93c9511556b3684'
 SHA512:
-  metadata.gz: a849d3e55b45cf60b2fa6e921542f2b4e8dd495848a2083811c280fdcdc9a3239decc4c0a2c7bb4b8afa36bc663415aeef9e9cd52c7c3b13fefa5440d9f8dfaf
-  data.tar.gz: 35c18e0c45eb386e3830d596ebe949f80694919b24202883f412adb78d2abe64cf336cc58a2970c1a3f4ded636b7b4c52de301279bad3bcd15a04b50d8063a3a
+  metadata.gz: bc9b78138641d44a4a4d45ba6c101b64163a2749cd8e0328cec4e78117e1038e515dbfa87734a689e769c9ab769c5a4da67847916547354a23d459450a8ddb23
+  data.tar.gz: b7ecca39e249641bfc25cfaee8b106ee5087773087d0d5f984b9419a7aa98941bdf134c5c5e8a2226432e545a61c4dc0cbfa8d50ab359a1e61f73e89115a272f

data/.travis.yml

@@ -1,9 +1,12 @@
 language: ruby
+before_install:
+  - gem update bundler
+
 rvm:
   - 2.1
   - 2.2
-before_install:
-  - gem update bundler
+  - 2.3.3
+  - 2.4.0
 gemfile:
-  - gemfiles/fluentd_0_10.gemfile
-  - gemfiles/fluentd_0_12.gemfile
+  - gemfiles/fluentd_0_14.gemfile
+  - Gemfile

data/Appraisals

@@ -1,11 +1,3 @@
-appraise "fluentd-0-10" do
-  gem "fluentd", "~>0.10.0"
-end
-
-appraise "fluentd-0-12" do
-  gem "fluentd", "~>0.12.0"
-end
-
 appraise "fluentd-0-14" do
   gem "fluentd", "~>0.14.0"
 end

data/README.markdown

@@ -4,6 +4,14 @@
 
 fluent-plugin-map(out\_map) is the non-buffered plugin that can convert an event log to different event log(s)
 
+
+## Requirements
+
+| fluent-plugin-map  | fluentd | ruby |
+|-------------------|---------|------|
+| >= 0.2.0 | >= v0.14.0 | >= 2.1 |
+|  < 0.2.0 | >= v0.12.0 | >= 1.9 |
+
 ## MapFilter
 
 ### Example

data/fluent-plugin-map.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "fluent-plugin-map"
-  s.version     = "0.1.3"
+  s.version     = "0.2.0"
   s.authors     = ["Kohei Tomita", "Hiroshi Hatake", "Kenji Okomoto"]
   s.email       = ["tommy.fmale@gmail.com", "cosmo0920.oucc@gmail.com", "okkez000@gmail.com"]
   s.homepage    = "https://github.com/fluent-plugins-nursery/fluent-plugin-map"
@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.license       = "Apache-2.0"
 
   s.add_development_dependency "rake"
-  s.add_development_dependency "fluentd", ["< 0.14.0"]
+  s.add_development_dependency "fluentd", [">= 0.14.0", "< 2"]
   s.add_development_dependency "test-unit", "~> 3.1"
   s.add_development_dependency "appraisal"
 end

data/lib/fluent/plugin/filter_map.rb

@@ -14,16 +14,16 @@
 #    limitations under the License.
 #
 
-require 'fluent/filter'
+require 'fluent/plugin/filter'
 require 'fluent/plugin/map_support'
 require 'fluent/plugin/map_config_param'
 require 'fluent/plugin/parse_map_mixin'
 
-module Fluent
-  class MapFilter < Fluent::Filter
+module Fluent::Plugin
+  class MapFilter < Fluent::Plugin::Filter
     Fluent::Plugin.register_filter('map', self)
 
-    include Fluent::MapConfigParam
+    include Fluent::Plugin::MapConfigParam
     include Fluent::ParseMap::Mixin
 
     def configure(conf)
@@ -31,7 +31,7 @@ module Fluent
       @format = determine_format()
       configure_format()
       @map = create_map(conf)
-      @map_support = Fluent::MapSupport.new(@map, self)
+      @map_support = Fluent::Plugin::MapSupport.new(@map, self)
     end
 
     def determine_format()

data/lib/fluent/plugin/map_config_param.rb

@@ -15,16 +15,18 @@
 #
 
 module Fluent
-  module MapConfigParam
-    def self.included(klass)
-      klass.instance_eval {
-        config_param :map, :string, :default => nil
-        config_param :time, :string, :default => nil
-        config_param :record, :string, :default => nil
-        config_param :multi, :bool, :default => false
-        config_param :timeout, :time, :default => 1
-        config_param :format, :string, :default => nil
-      }
+  module Plugin
+    module MapConfigParam
+      def self.included(klass)
+        klass.instance_eval {
+          config_param :map, :string, :default => nil
+          config_param :time, :string, :default => nil
+          config_param :record, :string, :default => nil
+          config_param :multi, :bool, :default => false
+          config_param :timeout, :time, :default => 1
+          config_param :format, :string, :default => nil
+        }
+      end
     end
   end
 end

data/lib/fluent/plugin/map_support.rb

@@ -15,98 +15,100 @@
 #
 
 module Fluent
-  class MapSupport
-    def initialize(map, plugin)
-      @map = map
-      @plugin = plugin
-      if defined?(Fluent::Filter) and plugin.is_a?(Fluent::Filter)
-        singleton_class.module_eval(<<-CODE)
+  module Plugin
+    class MapSupport
+      def initialize(map, plugin)
+        @map = map
+        @plugin = plugin
+        if plugin.is_a?(Fluent::Plugin::Filter)
+          singleton_class.module_eval(<<-CODE)
           def map_func(time, record)
             #{@map}
           end
         CODE
-        class << self
-          alias_method :generate_tuples, :generate_tuples_filter
-          alias_method :do_map, :do_map_filter
-        end
-      elsif plugin.is_a?(Fluent::Output)
-        singleton_class.module_eval(<<-CODE)
+          class << self
+            alias_method :generate_tuples, :generate_tuples_filter
+            alias_method :do_map, :do_map_filter
+          end
+        elsif plugin.is_a?(Fluent::Plugin::Output)
+          singleton_class.module_eval(<<-CODE)
           def map_func(tag, time, record)
             #{@map}
           end
         CODE
-        class << self
-          alias_method :generate_tuples, :generate_tuples_output
-          alias_method :do_map, :do_map_output
+          class << self
+            alias_method :generate_tuples, :generate_tuples_output
+            alias_method :do_map, :do_map_output
+          end
         end
       end
-    end
 
-    def do_map(tag, es)
-      # This method will be overwritten in #initailize.
-    end
+      def do_map(tag, es)
+        # This method will be overwritten in #initailize.
+      end
 
-    def do_map_filter(tag, es)
-      tuples = generate_tuples(tag, es)
+      def do_map_filter(tag, es)
+        tuples = generate_tuples(tag, es)
 
-      tag_output_es = Hash.new{|h, key| h[key] = Fluent::MultiEventStream.new}
-      tuples.each do |time, record|
-        if time == nil || record == nil
-          raise SyntaxError.new
+        tag_output_es = Hash.new{|h, key| h[key] = Fluent::MultiEventStream.new}
+        tuples.each do |time, record|
+          if time == nil || record == nil
+            raise SyntaxError.new
+          end
+          tag_output_es[tag].add(time, record)
+          @plugin.log.trace { [tag, time, record].inspect }
         end
-        tag_output_es[tag].add(time, record)
-        @plugin.log.trace { [tag, time, record].inspect }
+        tag_output_es
       end
-      tag_output_es
-    end
 
-    def do_map_output(tag, es)
-      tuples = generate_tuples(tag, es)
+      def do_map_output(tag, es)
+        tuples = generate_tuples(tag, es)
 
-      tag_output_es = Hash.new{|h, key| h[key] = Fluent::MultiEventStream.new}
-      tuples.each do |tag, time, record|
-        if time == nil || record == nil
-          raise SyntaxError.new
+        tag_output_es = Hash.new{|h, key| h[key] = Fluent::MultiEventStream.new}
+        tuples.each do |tag, time, record|
+          if time == nil || record == nil
+            raise SyntaxError.new
+          end
+          tag_output_es[tag].add(time, record)
+          @plugin.log.trace { [tag, time, record].inspect }
         end
-        tag_output_es[tag].add(time, record)
-        @plugin.log.trace { [tag, time, record].inspect }
+        tag_output_es
       end
-      tag_output_es
-    end
-
-    def generate_tuples
-      # This method will be overwritten in #initailize.
-    end
 
-    def generate_tuples_filter(tag, es)
-      tuples = []
-      es.each {|time, record|
-        timeout_block do
-          new_tuple = map_func(time, record)
-          tuples.concat new_tuple
-        end
-      }
-      tuples
-    end
+      def generate_tuples
+        # This method will be overwritten in #initailize.
+      end
 
-    def generate_tuples_output(tag, es)
-      tuples = []
-      es.each {|time, record|
-        timeout_block do
-          new_tuple = map_func(tag, time, record)
-          tuples.concat new_tuple
-        end
-      }
-      tuples
-    end
+      def generate_tuples_filter(tag, es)
+        tuples = []
+        es.each {|time, record|
+          timeout_block do
+            new_tuple = map_func(time, record)
+            tuples.concat new_tuple
+          end
+        }
+        tuples
+      end
 
-    def timeout_block
-      begin
-        Timeout.timeout(@plugin.timeout){
-          yield
+      def generate_tuples_output(tag, es)
+        tuples = []
+        es.each {|time, record|
+          timeout_block do
+            new_tuple = map_func(tag, time, record)
+            tuples.concat new_tuple
+          end
         }
-      rescue Timeout::Error
-        @plugin.log.error {"Timeout: #{Time.at(time)} #{tag} #{record.inspect}"}
+        tuples
+      end
+
+      def timeout_block
+        begin
+          Timeout.timeout(@plugin.timeout){
+            yield
+          }
+        rescue Timeout::Error
+          @plugin.log.error {"Timeout: #{Time.at(time)} #{tag} #{record.inspect}"}
+        end
       end
     end
   end

data/lib/fluent/plugin/out_map.rb

@@ -14,36 +14,30 @@
 #    limitations under the License.
 #
 
-require 'fluent/output'
+require 'fluent/plugin/output'
 require 'fluent/plugin/map_support'
 require 'fluent/plugin/map_config_param'
 require 'fluent/plugin/parse_map_mixin'
 
-module Fluent
-  class MapOutput < Fluent::Output
+module Fluent::Plugin
+  class MapOutput < Fluent::Plugin::Output
     Fluent::Plugin.register_output('map', self)
 
-    include Fluent::MapConfigParam
-    include Fluent::ParseMap::Mixin
-
-    # Define `router` method of v0.12 to support v0.10 or earlier
-    unless method_defined?(:router)
-      define_method("router") { Fluent::Engine }
-    end
+    helpers :event_emitter
 
-    unless method_defined?(:log)
-      define_method("log") { $log }
-    end
+    include Fluent::Plugin::MapConfigParam
+    include Fluent::ParseMap::Mixin
 
     config_param :key, :string, :default => nil #deprecated
     config_param :tag, :string, :default => nil
 
     def configure(conf)
+      log.warn "out_map is now deprecated. It will be removed in a future release. Please consider to use filter_map."
       super
       @format = determine_format()
       configure_format()
       @map = create_map(conf)
-      @map_support = Fluent::MapSupport.new(@map, self)
+      @map_support = Fluent::Plugin::MapSupport.new(@map, self)
     end
 
     def determine_format()
@@ -84,16 +78,14 @@ module Fluent
       end
     end
 
-    def emit(tag, es, chain)
+    def process(tag, es)
       begin
         tag_output_es = @map_support.do_map(tag, es)
         tag_output_es.each_pair do |tag, output_es|
           router.emit_stream(tag, output_es)
         end
-        chain.next
         tag_output_es
       rescue SyntaxError => e
-        chain.next
         log.error "map command is syntax error: #{@map}"
         e #for test
       end

data/test/helper.rb

@@ -23,4 +23,4 @@ unless ENV.has_key?('VERBOSE')
 end
 
 require "fluent/plugin/out_map"
-require "fluent/plugin/filter_map" if defined?(Fluent::Filter)
+require "fluent/plugin/filter_map"

data/test/plugin/test_filter_map.rb

@@ -1,23 +1,25 @@
 require 'helper'
+require 'fluent/test/driver/filter'
+require 'fluent/test/helpers'
+include Fluent::Test::Helpers
 
 class MapFilterTest < Test::Unit::TestCase
   def setup
-    omit "Use Fluentd v0.12 or later" unless defined?(Fluent::Filter)
     Fluent::Test.setup
   end
 
   CONFIG = %[
-    map [time, record]
+    map ([time, record])
     multi false
   ]
 
-  def create_driver(conf = CONFIG, tag='test.input')
-    Fluent::Test::FilterTestDriver.new(Fluent::MapFilter, tag).configure(conf)
+  def create_driver(conf = CONFIG)
+    Fluent::Test::Driver::Filter.new(Fluent::Plugin::MapFilter).configure(conf)
   end
 
   def test_syntax_error
     tag = "tag"
-    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     #map is syntax error
@@ -25,20 +27,20 @@ class MapFilterTest < Test::Unit::TestCase
       map time.
     ]
     assert_raise SyntaxError do
-      create_driver(syntax_error_config, tag)
+      create_driver(syntax_error_config)
     end
   end
 
   def test_syntax_error2
     tag = "tag"
-    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     #map output lligal format
     syntax_error_config = %[
       map time
     ]
-    d1 = create_driver(syntax_error_config, tag)
+    d1 = create_driver(syntax_error_config)
     es = Fluent::OneEventStream.new(time, record)
     e =  d1.instance.filter_stream(tag, es)
     assert e.kind_of?(SyntaxError)
@@ -46,19 +48,19 @@ class MapFilterTest < Test::Unit::TestCase
 
   def test_tag_convert_using_time_record
     tag = 'tag.raw'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     d1 = create_driver %[
       time time
       record record
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    filtered = d1.filtered_as_array
+    filtered = d1.filtered
     assert_equal 1, filtered.length
-    assert_equal ["tag.raw", time, record], filtered[0]
+    assert_equal [time, record], filtered[0]
   end
 
   #deprected specification test
@@ -70,25 +72,23 @@ class MapFilterTest < Test::Unit::TestCase
     assert_raise(Fluent::ConfigError){
       create_driver %[
         record record
-      ], tag
+      ]
     }
   end
 
   def test_config_error_record
-    tag = "tag"
-    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    time = event_time('2012-10-10 10:10:10')
 
     #require record
     assert_raise(Fluent::ConfigError){
       create_driver %[
         time time
-      ], tag
+      ]
     }
   end
 
   def test_config_error_multi
-    tag = "tag"
-    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     #require time
@@ -97,13 +97,12 @@ class MapFilterTest < Test::Unit::TestCase
         time time
         record record
         multi true
-      ], tag
+      ]
     }
   end
 
   def test_config_error_sleep
-    tag = 'tag'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     assert_raise(SyntaxError) {
@@ -112,7 +111,7 @@ class MapFilterTest < Test::Unit::TestCase
         time sleep 10
         record record
         timeout 1s
-      ], tag
+      ]
     }
   end
 
@@ -123,60 +122,57 @@ class MapFilterTest < Test::Unit::TestCase
 
   def test_convert_format_map
     tag = 'tag.raw'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code1' => '300', 'code2' => '400'}
 
     d1 = create_driver %[
       format map
-      map [[time, record["code1"]], [time, record["code2"]]]
+      map ([[time, record["code1"]], [time, record["code2"]]])
       multi true
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    filtered = d1.filtered_as_array
+    filtered = d1.filtered
     assert_equal 2, filtered.length
-    assert_equal tag, d1.tag # tag shouldn't be changed
-    assert_equal ["tag.raw", time, record["code1"]], filtered[0]
-    assert_equal ["tag.raw", time, record["code2"]], filtered[1]
+    assert_equal [time, record["code1"]], filtered[0]
+    assert_equal [time, record["code2"]], filtered[1]
   end
 
   def test_tag_convert_format_record
     tag = 'tag.raw'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     d1 = create_driver %[
       format record
       time time
       record record
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    filtered = d1.filtered_as_array
+    filtered = d1.filtered
     assert_equal 1, filtered.length
-    assert_equal tag, d1.tag # tag shouldn't be changed
-    assert_equal ["tag.raw", time, record], filtered[0]
+    assert_equal [time, record], filtered[0]
   end
 
   def test_convert_format_multimap
     tag = 'tag.raw'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time =  event_time('2012-10-10 10:10:10')
     record = {'code1' => '300', 'code2' => '400'}
 
     d1 = create_driver %[
       format multimap
-      mmap1 [time, record["code1"]]
-      mmap2 [time, record["code2"]]
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+      mmap1 ([time, record["code1"]])
+      mmap2 ([time, record["code2"]])
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    filtered = d1.filtered_as_array
+    filtered = d1.filtered
     assert_equal 2, filtered.length
-    assert_equal tag, d1.tag # tag shouldn't be changed
-    assert_equal ["tag.raw", time, record["code1"]], filtered[0]
-    assert_equal ["tag.raw", time, record["code2"]], filtered[1]
+    assert_equal [time, record["code1"]], filtered[0]
+    assert_equal [time, record["code2"]], filtered[1]
   end
 end

data/test/plugin/test_out_map.rb

@@ -1,4 +1,5 @@
 require 'helper'
+require 'fluent/test/driver/output'
 
 class MapOutputTest < Test::Unit::TestCase
   def setup
@@ -10,47 +11,47 @@ class MapOutputTest < Test::Unit::TestCase
     multi false
   ]
 
-  def create_driver(conf = CONFIG, tag='test.input')
-    Fluent::Test::OutputTestDriver.new(Fluent::MapOutput, tag).configure(conf)
+  def create_driver(conf = CONFIG)
+    Fluent::Test::Driver::Output.new(Fluent::Plugin::MapOutput).configure(conf)
   end
 
   def test_tag_convert
     tag = 'tag'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     d1 = create_driver %[
-      map ["newtag", time, record]
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+      map (["newtag", time, record])
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    emits = d1.emits
-    assert_equal 1, emits.length
-    assert_equal ["newtag", time, record], emits[0]
+    events = d1.events
+    assert_equal 1, events.length
+    assert_equal ["newtag", time, record], events[0]
   end
 
   def test_convert_multi_tag
     tag = 'tag'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     d1 = create_driver %[
-      map [["tag1", time, record], ["tag2", time, record]]
+      map ([["tag1", time, record], ["tag2", time, record]])
       multi true
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    emits = d1.emits
-    assert_equal 2, emits.length
-    assert_equal ["tag1", time, record], emits[0]
-    assert_equal ["tag2", time, record], emits[1]
+    events = d1.events
+    assert_equal 2, events.length
+    assert_equal ["tag1", time, record], events[0]
+    assert_equal ["tag2", time, record], events[1]
   end
 
   def test_syntax_error
     tag = "tag"
-    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     #map is syntax error
@@ -58,66 +59,65 @@ class MapOutputTest < Test::Unit::TestCase
       map tag.
     ]
     assert_raise SyntaxError do
-      d1 = create_driver(syntax_error_config, tag)
+      create_driver(syntax_error_config)
     end
   end
 
   def test_syntax_error2
     tag = "tag"
-    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     #map output lligal format
     syntax_error_config = %[
       map tag
     ]
-    d1 = create_driver(syntax_error_config, tag)
+    d1 = create_driver(syntax_error_config)
     es = Fluent::OneEventStream.new(time, record)
-    chain = Fluent::Test::TestOutputChain.new
-    e =  d1.instance.emit(tag, es, chain)
+    e =  d1.instance.process(tag, es)
     assert e.kind_of?(SyntaxError)
   end
 
   def test_tag_convert_using_tag_time_record
     tag = 'tag'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     d1 = create_driver %[
-      tag "newtag"
+      tag ("newtag")
       time time
       record record
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    emits = d1.emits
-    assert_equal 1, emits.length
-    assert_equal ["newtag", time, record], emits[0]
+    events = d1.events
+    assert_equal 1, events.length
+    assert_equal ["newtag", time, record], events[0]
   end
 
   #deprected specification test
   def test_tag_convert_using_key_time_record
     tag = 'tag'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     d1 = create_driver %[
-      key "newtag"
+      key ("newtag")
       time time
       record record
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    emits = d1.emits
-    assert_equal 1, emits.length
-    assert_equal ["newtag", time, record], emits[0]
+    events = d1.events
+    assert_equal 1, events.length
+    assert_equal ["newtag", time, record], events[0]
   end
 
   def test_config_error_tag
     tag = "tag"
-    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     #require time
@@ -125,7 +125,7 @@ class MapOutputTest < Test::Unit::TestCase
       create_driver %[
         time time
         record record
-      ], tag
+      ]
     }
   end
 
@@ -138,7 +138,7 @@ class MapOutputTest < Test::Unit::TestCase
       create_driver %[
         tag "newtag"
         record record
-      ], tag
+      ]
     }
   end
 
@@ -149,40 +149,40 @@ class MapOutputTest < Test::Unit::TestCase
     #require record
     assert_raise(Fluent::ConfigError){
       create_driver %[
-        tag "newtag"
+        tag ("newtag")
         time time
-      ], tag
+      ]
     }
   end
 
   def test_config_error_multi
     tag = "tag"
-    time = Time.local(2012, 10, 10, 10, 10, 0).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     #require time
     assert_raise(Fluent::ConfigError){
       create_driver %[
-        tag "newtag"
+        tag ("newtag")
         time time
         record record
         multi true
-      ], tag
+      ]
     }
   end
 
   def test_config_error_sleep
     tag = 'tag'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     assert_raise(SyntaxError) {
       create_driver %[
-        key "newtag"
+        key ("newtag")
         time sleep 10
         record record
         timeout 1s
-      ], tag
+      ]
     }
   end
 
@@ -193,58 +193,58 @@ class MapOutputTest < Test::Unit::TestCase
 
   def test_convert_format_map
     tag = 'tag'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code1' => '300', 'code2' => '400'}
 
     d1 = create_driver %[
       format map
-      map [["tag1", time, record["code1"]], ["tag2", time, record["code2"]]]
+      map ([["tag1", time, record["code1"]], ["tag2", time, record["code2"]]])
       multi true
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    emits = d1.emits
-    assert_equal 2, emits.length
-    assert_equal ["tag1", time, record["code1"]], emits[0]
-    assert_equal ["tag2", time, record["code2"]], emits[1]
+    events = d1.events
+    assert_equal 2, events.length
+    assert_equal ["tag1", time, record["code1"]], events[0]
+    assert_equal ["tag2", time, record["code2"]], events[1]
   end
 
   def test_tag_convert_format_record
     tag = 'tag'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code' => '300'}
 
     d1 = create_driver %[
       format record
-      tag "newtag"
+      tag ("newtag")
       time time
       record record
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    emits = d1.emits
-    assert_equal 1, emits.length
-    assert_equal ["newtag", time, record], emits[0]
+    events = d1.events
+    assert_equal 1, events.length
+    assert_equal ["newtag", time, record], events[0]
   end
 
   def test_convert_format_multimap
     tag = 'tag'
-    time = Time.local(2012, 10, 10, 10, 10, 10).to_i
+    time = event_time('2012-10-10 10:10:10')
     record = {'code1' => '300', 'code2' => '400'}
 
     d1 = create_driver %[
       format multimap
-      mmap1 ["tag1", time, record["code1"]]
-      mmap2 ["tag2", time, record["code2"]]
-    ], tag
-    d1.run do
-      d1.emit(record, time)
+      mmap1 (["tag1", time, record["code1"]])
+      mmap2 (["tag2", time, record["code2"]])
+    ]
+    d1.run(default_tag: tag) do
+      d1.feed(time, record)
     end
-    emits = d1.emits
-    assert_equal 2, emits.length
-    assert_equal ["tag1", time, record["code1"]], emits[0]
-    assert_equal ["tag2", time, record["code2"]], emits[1]
+    events = d1.events
+    assert_equal 2, events.length
+    assert_equal ["tag1", time, record["code1"]], events[0]
+    assert_equal ["tag2", time, record["code2"]], events[1]
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-map
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Kohei Tomita
@@ -30,16 +30,22 @@ dependencies:
   name: fluentd
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.14.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.14.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -86,8 +92,6 @@ files:
 - README.markdown
 - Rakefile
 - fluent-plugin-map.gemspec
-- gemfiles/fluentd_0_10.gemfile
-- gemfiles/fluentd_0_12.gemfile
 - gemfiles/fluentd_0_14.gemfile
 - lib/fluent/plugin/filter_map.rb
 - lib/fluent/plugin/map_config_param.rb

data/gemfiles/fluentd_0_10.gemfile

@@ -1,7 +0,0 @@
-# This file was generated by Appraisal
-
-source "http://rubygems.org"
-
-gem "fluentd", "~>0.10.0"
-
-gemspec :path => "../"

data/gemfiles/fluentd_0_12.gemfile

@@ -1,7 +0,0 @@
-# This file was generated by Appraisal
-
-source "http://rubygems.org"
-
-gem "fluentd", "~>0.12.0"
-
-gemspec :path => "../"