fluent-plugin-sampling-filter 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8938823efb7b0fc5c35a84a5a5f76b75d532358
-  data.tar.gz: edf5a0bebb0bd60e188a8916754e5feef53fc218
+  metadata.gz: 4bb5bf2e2842f56be230defcabebf6574271d6c6
+  data.tar.gz: 54962ccbd36c5c0d502e7bbb0e79fc45748c545d
 SHA512:
-  metadata.gz: 86bc4dde59d152e2da88370b06b5c3e98e440c906bd1d853e2a02aa37a69e4da83debd5886496c5691c30351963fe52a14d07e6403dc5b1765434b4e306cfdba
-  data.tar.gz: d8a156be0aa4293aa857105c29405cb515b1155aa6a1f5e63646dd58774168fe070c7039274bea197165d54bb206bf3bd594436cc41a001a2a8bb54d3864975e
+  metadata.gz: ccd41752621ecfa648e8e2427517fb68c19e9a0b1ea8e0569c81145b82e15d971e6aab52debd2bcdf458e6fff2c4eb71b2e3d3b0448cfc9b21ec512a4bbb2d0e
+  data.tar.gz: 8dcc45ffd1bec441e39882accb4fde2e0290ff183e669f67b26efa96e95c8b61957279f9cff89f05049469d946517092b97c1ebfc06767fe1d07a766409dfae8

data/.travis.yml

@@ -1,7 +1,6 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.0.0
   - 2.1
   - 2.2
   - 2.3.0

data/fluent-plugin-sampling-filter.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |gem|
   gem.name          = "fluent-plugin-sampling-filter"
-  gem.version       = "0.2.1"
+  gem.version       = "1.0.0"
   gem.authors       = ["TAGOMORI Satoshi"]
   gem.email         = ["tagomoris@gmail.com"]
   gem.description   = %q{fluentd plugin to pickup sample data from matched massages}
@@ -17,5 +17,5 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency "rake"
   gem.add_runtime_dependency "test-unit", "~> 3.1.0"
-  gem.add_runtime_dependency "fluentd", [">= 0.12.0", "< 0.14.0"]
+  gem.add_runtime_dependency "fluentd", [">= 0.14.12", "< 2"]
 end

data/lib/fluent/plugin/filter_sampling.rb

@@ -1,62 +1,56 @@
-class Fluent::SamplingFilter < Fluent::Filter
+require 'fluent/plugin/filter'
+require 'fluent/clock'
+
+class Fluent::Plugin::SamplingFilter < Fluent::Plugin::Filter
   Fluent::Plugin.register_filter('sampling_filter', self)
 
   config_param :interval, :integer
-  config_param :sample_unit, :string, default: 'tag'
+  config_param :sample_unit, :enum, list: [:tag, :all], default: :tag
   config_param :minimum_rate_per_min, :integer, default: nil
 
   def configure(conf)
     super
 
-    @sample_unit = case @sample_unit
-                   when 'tag'
-                     :tag
-                   when 'all'
-                     :all
-                   else
-                     raise Fluent::ConfigError, "sample_unit allows only 'tag' or 'all'"
-                   end
     @counts = {}
     @resets = {} if @minimum_rate_per_min
   end
 
-  def filter_stream(tag, es)
-    t = if @sample_unit == :all
-          'all'
-        else
-          tag
-        end
-
-    new_es = Fluent::MultiEventStream.new
+  # Access to @counts SHOULD be protected by mutex, with a heavy penalty.
+  # Code below is not thread safe, but @counts (counter for sampling rate) is not
+  # so serious value (and probably will not be broken...),
+  # then i let here as it is now.
 
-    # Access to @counts SHOULD be protected by mutex, with a heavy penalty.
-    # Code below is not thread safe, but @counts (counter for sampling rate) is not
-    # so serious value (and probably will not be broken...),
-    # then i let here as it is now.
+  def filter(tag, _time, record)
+    t = @sample_unit == :all ? 'all' : tag
     if @minimum_rate_per_min
-      unless @resets[t]
-        @resets[t] = Fluent::Engine.now + (60 - rand(30))
-      end
-      if Fluent::Engine.now > @resets[t]
-        @resets[t] = Fluent::Engine.now + 60
-        @counts[t] = 0
-      end
-      es.each do |time,record|
-        c = (@counts[t] = @counts.fetch(t, 0) + 1)
-        if c < @minimum_rate_per_min or c % @interval == 0
-          new_es.add(time, record.dup)
-        end
-      end
+      filter_with_minimum_rate(t, record)
+    else
+      filter_simple(t, record)
+    end
+  end
+
+  def filter_simple(t, record)
+    c = (@counts[t] = @counts.fetch(t, 0) + 1)
+    # reset only just before @counts[t] is to be bignum from fixnum
+    @counts[t] = 0 if c > 0x6fffffff
+    if c % @interval == 0
+      record
+    else
+      nil
+    end
+  end
+
+  def filter_with_minimum_rate(t, record)
+    @resets[t] ||= Fluent::Clock.now + (60 - rand(30))
+    if Fluent::Clock.now > @resets[t]
+      @resets[t] = Fluent::Clock.now + 60
+      @counts[t] = 0
+    end
+    c = (@counts[t] = @counts.fetch(t, 0) + 1)
+    if c < @minimum_rate_per_min || c % @interval == 0
+      record.dup
     else
-      es.each do |time,record|
-        c = (@counts[t] = @counts.fetch(t, 0) + 1)
-        if c % @interval == 0
-          new_es.add(time, record.dup)
-          # reset only just before @counts[t] is to be bignum from fixnum
-          @counts[t] = 0 if c > 0x6fffffff
-        end
-      end
+      nil
     end
-    new_es
   end
 end

data/lib/fluent/plugin/out_sampling_filter.rb

@@ -1,36 +1,31 @@
-class Fluent::SamplingFilterOutput < Fluent::Output
+require 'fluent/plugin/output'
+require 'fluent/clock'
+
+class Fluent::Plugin::SamplingFilterOutput < Fluent::Plugin::Output
   Fluent::Plugin.register_output('sampling_filter', self)
 
-  config_param :interval, :integer
-  config_param :sample_unit, :string, :default => 'tag'
-  config_param :remove_prefix, :string, :default => nil
-  config_param :add_prefix, :string, :default => 'sampled'
-  config_param :minimum_rate_per_min, :integer, :default => nil
+  helpers :event_emitter
 
-  # Define `log` method for v0.10.42 or earlier
-  unless method_defined?(:log)
-    define_method("log") { $log }
-  end
+  config_param :interval, :integer
+  config_param :sample_unit, :enum, list: [:tag, :all], default: :tag
+  config_param :remove_prefix, :string, default: nil
+  config_param :add_prefix, :string, default: 'sampled'
+  config_param :minimum_rate_per_min, :integer, default: nil
 
   def configure(conf)
     super
 
+    log.warn "sampling_filter output plugin is deprecated. use sampling_filter filter plugin instead with <label> routing."
+
     if @remove_prefix
       @removed_prefix_string = @remove_prefix + '.'
       @removed_length = @removed_prefix_string.length
     elsif @add_prefix.empty?
       raise Fluent::ConfigError, "either of 'add_prefix' or 'remove_prefix' must be specified"
     end
+    @added_prefix_string = nil
     @added_prefix_string = @add_prefix + '.' unless @add_prefix.empty?
 
-    @sample_unit = case @sample_unit
-                   when 'tag'
-                     :tag
-                   when 'all'
-                     :all
-                   else
-                     raise Fluent::ConfigError, "sample_unit allows only 'tag' or 'all'"
-                   end
     @counts = {}
     @resets = {} if @minimum_rate_per_min
   end
@@ -51,7 +46,7 @@ class Fluent::SamplingFilterOutput < Fluent::Output
     }
   end
 
-  def emit(tag, es, chain)
+  def process(tag, es)
     t = if @sample_unit == :all
           'all'
         else
@@ -65,11 +60,9 @@ class Fluent::SamplingFilterOutput < Fluent::Output
     # so serious value (and probably will not be broken...),
     # then i let here as it is now.
     if @minimum_rate_per_min
-      unless @resets[t]
-        @resets[t] = Fluent::Engine.now + (60 - rand(30))
-      end
-      if Fluent::Engine.now > @resets[t]
-        @resets[t] = Fluent::Engine.now + 60
+      @resets[t] ||= Fluent::Clock.now + (60 - rand(30))
+      if Fluent::Clock.now > @resets[t]
+        @resets[t] = Fluent::Clock.now + 60
         @counts[t] = 0
       end
       es.each do |time,record|
@@ -90,7 +83,5 @@ class Fluent::SamplingFilterOutput < Fluent::Output
     end
 
     emit_sampled(tag, pairs)
-
-    chain.next
   end
 end

data/test/plugin/test_filter_sampling.rb

@@ -1,4 +1,5 @@
 require 'helper'
+require 'fluent/test/driver/filter'
 
 class SamplingFilterTest < Test::Unit::TestCase
   def setup
@@ -10,13 +11,13 @@ class SamplingFilterTest < Test::Unit::TestCase
     sample_unit tag
   ]
 
-  def create_driver(conf=CONFIG,tag='test')
-    Fluent::Test::FilterTestDriver.new(Fluent::SamplingFilter, tag).configure(conf)
+  def create_driver(conf=CONFIG)
+    Fluent::Test::Driver::Filter.new(Fluent::Plugin::SamplingFilter).configure(conf)
   end
 
   def test_configure
     assert_raise(Fluent::ConfigError) {
-      d = create_driver('')
+      create_driver('')
     }
     d = create_driver %[
       interval 5
@@ -34,54 +35,52 @@ class SamplingFilterTest < Test::Unit::TestCase
   end
 
   def test_filter
-    d1 = create_driver(CONFIG, 'input.hoge1')
+    d1 = create_driver(CONFIG)
     time = Time.parse("2012-01-02 13:14:15").to_i
-    d1.run do
-      d1.filter({'field1' => 'record1', 'field2' => 1})
-      d1.filter({'field1' => 'record2', 'field2' => 2})
-      d1.filter({'field1' => 'record3', 'field2' => 3})
-      d1.filter({'field1' => 'record4', 'field2' => 4})
-      d1.filter({'field1' => 'record5', 'field2' => 5})
-      d1.filter({'field1' => 'record6', 'field2' => 6})
-      d1.filter({'field1' => 'record7', 'field2' => 7})
-      d1.filter({'field1' => 'record8', 'field2' => 8})
-      d1.filter({'field1' => 'record9', 'field2' => 9})
-      d1.filter({'field1' => 'record10', 'field2' => 10})
-      d1.filter({'field1' => 'record11', 'field2' => 11})
-      d1.filter({'field1' => 'record12', 'field2' => 12})
+    d1.run(default_tag: 'input.hoge1') do
+      d1.feed({'field1' => 'record1', 'field2' => 1})
+      d1.feed({'field1' => 'record2', 'field2' => 2})
+      d1.feed({'field1' => 'record3', 'field2' => 3})
+      d1.feed({'field1' => 'record4', 'field2' => 4})
+      d1.feed({'field1' => 'record5', 'field2' => 5})
+      d1.feed({'field1' => 'record6', 'field2' => 6})
+      d1.feed({'field1' => 'record7', 'field2' => 7})
+      d1.feed({'field1' => 'record8', 'field2' => 8})
+      d1.feed({'field1' => 'record9', 'field2' => 9})
+      d1.feed({'field1' => 'record10', 'field2' => 10})
+      d1.feed({'field1' => 'record11', 'field2' => 11})
+      d1.feed({'field1' => 'record12', 'field2' => 12})
     end
-    filtered = d1.filtered_as_array
+    filtered = d1.filtered
     assert_equal 1, filtered.length
-    assert_equal 'input.hoge1', filtered[0][0] # tag
-    assert_equal 'record10', filtered[0][2]['field1']
-    assert_equal 10, filtered[0][2]['field2']
+    assert_equal 'record10', filtered[0][1]['field1']
+    assert_equal 10, filtered[0][1]['field2']
 
     d2 = create_driver(%[
       interval 3
-    ], 'input.hoge2')
+    ])
     time = Time.parse("2012-01-02 13:14:15").to_i
-    d2.run do
-      d2.filter({'field1' => 'record1', 'field2' => 1})
-      d2.filter({'field1' => 'record2', 'field2' => 2})
-      d2.filter({'field1' => 'record3', 'field2' => 3})
-      d2.filter({'field1' => 'record4', 'field2' => 4})
-      d2.filter({'field1' => 'record5', 'field2' => 5})
-      d2.filter({'field1' => 'record6', 'field2' => 6})
-      d2.filter({'field1' => 'record7', 'field2' => 7})
-      d2.filter({'field1' => 'record8', 'field2' => 8})
-      d2.filter({'field1' => 'record9', 'field2' => 9})
-      d2.filter({'field1' => 'record10', 'field2' => 10})
-      d2.filter({'field1' => 'record11', 'field2' => 11})
-      d2.filter({'field1' => 'record12', 'field2' => 12})
+    d2.run(default_tag: 'input.hoge2') do
+      d2.feed({'field1' => 'record1', 'field2' => 1})
+      d2.feed({'field1' => 'record2', 'field2' => 2})
+      d2.feed({'field1' => 'record3', 'field2' => 3})
+      d2.feed({'field1' => 'record4', 'field2' => 4})
+      d2.feed({'field1' => 'record5', 'field2' => 5})
+      d2.feed({'field1' => 'record6', 'field2' => 6})
+      d2.feed({'field1' => 'record7', 'field2' => 7})
+      d2.feed({'field1' => 'record8', 'field2' => 8})
+      d2.feed({'field1' => 'record9', 'field2' => 9})
+      d2.feed({'field1' => 'record10', 'field2' => 10})
+      d2.feed({'field1' => 'record11', 'field2' => 11})
+      d2.feed({'field1' => 'record12', 'field2' => 12})
     end
-    filtered = d2.filtered_as_array
+    filtered = d2.filtered
     assert_equal 4, filtered.length
-    assert_equal 'input.hoge2', filtered[0][0] # tag
 
-    assert_equal 'record3', filtered[0][2]['field1']
-    assert_equal 'record6', filtered[1][2]['field1']
-    assert_equal 'record9', filtered[2][2]['field1']
-    assert_equal 'record12', filtered[3][2]['field1']
+    assert_equal 'record3', filtered[0][1]['field1']
+    assert_equal 'record6', filtered[1][1]['field1']
+    assert_equal 'record9', filtered[2][1]['field1']
+    assert_equal 'record12', filtered[3][1]['field1']
   end
 
   def test_filter_minimum_rate
@@ -90,21 +89,20 @@ interval 10
 sample_unit tag
 minimum_rate_per_min 100
 ]
-    d = create_driver(config, 'input.hoge3')
+    d = create_driver(config)
     time = Time.parse("2012-01-02 13:14:15").to_i
-    d.run do
+    d.run(default_tag: 'input.hoge3') do
       (1..100).each do |t|
-        d.filter({'times' => t, 'data' => 'x'})
+        d.feed(time, {'times' => t, 'data' => 'x'})
       end
       (101..130).each do |t|
-        d.filter({'times' => t, 'data' => 'y'})
+        d.feed(time, {'times' => t, 'data' => 'y'})
       end
     end
-    filtered = d.filtered_as_array
+    filtered = d.filtered
     assert_equal 103, filtered.length
-    assert_equal 'input.hoge3', filtered[0][0]
-    assert_equal ((1..100).map(&:to_i) + [110, 120, 130]), filtered.map{|t,time,r| r['times']}
-    assert_equal (['x']*100 + ['y']*3), filtered.map{|t,time,r| r['data']}
+    assert_equal ((1..100).map(&:to_i) + [110, 120, 130]), filtered.map{|_time,r| r['times']}
+    assert_equal (['x']*100 + ['y']*3), filtered.map{|_time,r| r['data']}
   end
 
   def test_filter_minimum_rate_expire
@@ -113,17 +111,16 @@ interval 10
 sample_unit tag
 minimum_rate_per_min 10
 ]
-    d = create_driver(config, 'input.hoge4')
+    d = create_driver(config)
     time = Time.parse("2012-01-02 13:14:15").to_i
-    d.run do
+    d.run(default_tag: 'input.hoge4') do
       (1..30).each do |t|
-        d.filter({'times' => t, 'data' => 'x'})
+        d.feed(time, {'times' => t, 'data' => 'x'})
       end
     end
-    filtered = d.filtered_as_array
+    filtered = d.filtered
     assert_equal 12, filtered.length
-    assert_equal 'input.hoge4', filtered[0][0]
-    assert_equal ((1..10).map(&:to_i)+[20,30]), filtered.map{|t,time,r| r['times']}
-    assert_equal (['x']*12), filtered.map{|t,time,r| r['data']}
+    assert_equal ((1..10).map(&:to_i)+[20,30]), filtered.map{|_time,r| r['times']}
+    assert_equal (['x']*12), filtered.map{|_time,r| r['data']}
   end
 end

data/test/plugin/test_out_sampling_filter.rb

@@ -1,10 +1,11 @@
 require 'helper'
+require 'fluent/test/driver/output'
 
 class SamplingFilterOutputTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
   end
-  
+
   CONFIG = %[
     interval 10
     sample_unit tag
@@ -12,13 +13,13 @@ class SamplingFilterOutputTest < Test::Unit::TestCase
     add_prefix sampled
   ]
 
-  def create_driver(conf=CONFIG,tag='test')
-    Fluent::Test::OutputTestDriver.new(Fluent::SamplingFilterOutput, tag).configure(conf)
+  def create_driver(conf=CONFIG)
+    Fluent::Test::Driver::Output.new(Fluent::Plugin::SamplingFilterOutput).configure(conf)
   end
 
   def test_configure
     assert_raise(Fluent::ConfigError) {
-      d = create_driver('')
+      create_driver('')
     }
     d = create_driver %[
       interval 5
@@ -33,7 +34,7 @@ class SamplingFilterOutputTest < Test::Unit::TestCase
       interval 1000
       sample_unit all
       remove_prefix test
-      add_prefix output      
+      add_prefix output
     ]
     assert_equal 1000, d.instance.interval
     assert_equal :all, d.instance.sample_unit
@@ -42,54 +43,54 @@ class SamplingFilterOutputTest < Test::Unit::TestCase
   end
 
   def test_emit
-    d1 = create_driver(CONFIG, 'input.hoge1')
+    d1 = create_driver(CONFIG)
     time = Time.parse("2012-01-02 13:14:15").to_i
-    d1.run do
-      d1.emit({'field1' => 'record1', 'field2' => 1})
-      d1.emit({'field1' => 'record2', 'field2' => 2})
-      d1.emit({'field1' => 'record3', 'field2' => 3})
-      d1.emit({'field1' => 'record4', 'field2' => 4})
-      d1.emit({'field1' => 'record5', 'field2' => 5})
-      d1.emit({'field1' => 'record6', 'field2' => 6})
-      d1.emit({'field1' => 'record7', 'field2' => 7})
-      d1.emit({'field1' => 'record8', 'field2' => 8})
-      d1.emit({'field1' => 'record9', 'field2' => 9})
-      d1.emit({'field1' => 'record10', 'field2' => 10})
-      d1.emit({'field1' => 'record11', 'field2' => 11})
-      d1.emit({'field1' => 'record12', 'field2' => 12})
+    d1.run(default_tag: 'input.hoge1') do
+      d1.feed(time, {'field1' => 'record1', 'field2' => 1})
+      d1.feed(time, {'field1' => 'record2', 'field2' => 2})
+      d1.feed(time, {'field1' => 'record3', 'field2' => 3})
+      d1.feed(time, {'field1' => 'record4', 'field2' => 4})
+      d1.feed(time, {'field1' => 'record5', 'field2' => 5})
+      d1.feed(time, {'field1' => 'record6', 'field2' => 6})
+      d1.feed(time, {'field1' => 'record7', 'field2' => 7})
+      d1.feed(time, {'field1' => 'record8', 'field2' => 8})
+      d1.feed(time, {'field1' => 'record9', 'field2' => 9})
+      d1.feed(time, {'field1' => 'record10', 'field2' => 10})
+      d1.feed(time, {'field1' => 'record11', 'field2' => 11})
+      d1.feed(time, {'field1' => 'record12', 'field2' => 12})
     end
-    emits = d1.emits
-    assert_equal 1, emits.length
-    assert_equal 'sampled.hoge1', emits[0][0] # tag
-    assert_equal 'record10', emits[0][2]['field1']
-    assert_equal 10, emits[0][2]['field2']
+    events = d1.events
+    assert_equal 1, events.length
+    assert_equal 'sampled.hoge1', events[0][0] # tag
+    assert_equal 'record10', events[0][2]['field1']
+    assert_equal 10, events[0][2]['field2']
 
     d2 = create_driver(%[
       interval 3
-    ], 'input.hoge2')
+    ])
     time = Time.parse("2012-01-02 13:14:15").to_i
-    d2.run do
-      d2.emit({'field1' => 'record1', 'field2' => 1})
-      d2.emit({'field1' => 'record2', 'field2' => 2})
-      d2.emit({'field1' => 'record3', 'field2' => 3})
-      d2.emit({'field1' => 'record4', 'field2' => 4})
-      d2.emit({'field1' => 'record5', 'field2' => 5})
-      d2.emit({'field1' => 'record6', 'field2' => 6})
-      d2.emit({'field1' => 'record7', 'field2' => 7})
-      d2.emit({'field1' => 'record8', 'field2' => 8})
-      d2.emit({'field1' => 'record9', 'field2' => 9})
-      d2.emit({'field1' => 'record10', 'field2' => 10})
-      d2.emit({'field1' => 'record11', 'field2' => 11})
-      d2.emit({'field1' => 'record12', 'field2' => 12})
+    d2.run(default_tag: 'input.hoge2') do
+      d2.feed(time, {'field1' => 'record1', 'field2' => 1})
+      d2.feed(time, {'field1' => 'record2', 'field2' => 2})
+      d2.feed(time, {'field1' => 'record3', 'field2' => 3})
+      d2.feed(time, {'field1' => 'record4', 'field2' => 4})
+      d2.feed(time, {'field1' => 'record5', 'field2' => 5})
+      d2.feed(time, {'field1' => 'record6', 'field2' => 6})
+      d2.feed(time, {'field1' => 'record7', 'field2' => 7})
+      d2.feed(time, {'field1' => 'record8', 'field2' => 8})
+      d2.feed(time, {'field1' => 'record9', 'field2' => 9})
+      d2.feed(time, {'field1' => 'record10', 'field2' => 10})
+      d2.feed(time, {'field1' => 'record11', 'field2' => 11})
+      d2.feed(time, {'field1' => 'record12', 'field2' => 12})
     end
-    emits = d2.emits
-    assert_equal 4, emits.length
-    assert_equal 'sampled.input.hoge2', emits[0][0] # tag
+    events = d2.events
+    assert_equal 4, events.length
+    assert_equal 'sampled.input.hoge2', events[0][0] # tag
 
-    assert_equal 'record3', emits[0][2]['field1']
-    assert_equal 'record6', emits[1][2]['field1']
-    assert_equal 'record9', emits[2][2]['field1']
-    assert_equal 'record12', emits[3][2]['field1']
+    assert_equal 'record3', events[0][2]['field1']
+    assert_equal 'record6', events[1][2]['field1']
+    assert_equal 'record9', events[2][2]['field1']
+    assert_equal 'record12', events[3][2]['field1']
   end
 
   def test_minimum_rate
@@ -99,21 +100,21 @@ sample_unit tag
 remove_prefix input
 minimum_rate_per_min 100
 ]
-    d = create_driver(config, 'input.hoge3')
+    d = create_driver(config)
     time = Time.parse("2012-01-02 13:14:15").to_i
-    d.run do
+    d.run(default_tag: 'input.hoge3') do
       (1..100).each do |t|
-        d.emit({'times' => t, 'data' => 'x'})
+        d.feed(time, {'times' => t, 'data' => 'x'})
       end
       (101..130).each do |t|
-        d.emit({'times' => t, 'data' => 'y'})
+        d.feed(time, {'times' => t, 'data' => 'y'})
       end
     end
-    emits = d.emits
-    assert_equal 103, emits.length
-    assert_equal 'sampled.hoge3', emits[0][0]
-    assert_equal ((1..100).map(&:to_i) + [110, 120, 130]), emits.map{|t,time,r| r['times']}
-    assert_equal (['x']*100 + ['y']*3), emits.map{|t,time,r| r['data']}
+    events = d.events
+    assert_equal 103, events.length
+    assert_equal 'sampled.hoge3', events[0][0]
+    assert_equal ((1..100).map(&:to_i) + [110, 120, 130]), events.map{|_tag,_time,r| r['times']}
+    assert_equal (['x']*100 + ['y']*3), events.map{|_tag,_time,r| r['data']}
 
   end
   def test_minimum_rate_expire
@@ -126,39 +127,39 @@ sample_unit tag
 remove_prefix input
 minimum_rate_per_min 10
 ]
-    d = create_driver(config, 'input.hoge4')
+    d = create_driver(config)
     time = Time.parse("2012-01-02 13:14:15").to_i
-    d.run do
+    d.run(default_tag: 'input.hoge4') do
       (1..100).each do |t|
-        d.emit({'times' => t, 'data' => 'x'})
+        d.feed(time, {'times' => t, 'data' => 'x'})
       end
       sleep 60
       (101..130).each do |t|
-        d.emit({'times' => t, 'data' => 'y'})
+        d.feed(time+60, {'times' => t, 'data' => 'y'})
       end
     end
-    emits = d.emits
-    # assert_equal (19 + 12), emits.length
-    assert_equal 'sampled.hoge4', emits[0][0]
-    assert_equal ((1..10).map(&:to_i)+[20,30,40,50,60,70,80,90,100]+(101..110).map(&:to_i)+[120,130]), emits.map{|t,time,r| r['times']}
-    assert_equal (['x']*19 + ['y']*12), emits.map{|t,time,r| r['data']}
+    events = d.events
+    # assert_equal (19 + 12), events.length
+    assert_equal 'sampled.hoge4', events[0][0]
+    assert_equal ((1..10).map(&:to_i)+[20,30,40,50,60,70,80,90,100]+(101..110).map(&:to_i)+[120,130]), events.map{|_tag,_time,r| r['times']}
+    assert_equal (['x']*19 + ['y']*12), events.map{|_tag,_time,r| r['data']}
   end
 
   def test_without_add_prefix_but_remove_prefix
     config = %[
 interval 10
-add_prefix  # empty
+add_prefix
 remove_prefix input
 ]
-    d = create_driver(config, 'input.hoge3')
+    d = create_driver(config)
     time = Time.parse("2012-01-02 13:14:15").to_i
-    d.run do
+    d.run(default_tag: 'input.hoge3') do
       (1..100).each do |t|
-        d.emit({'times' => t, 'data' => 'x'})
+        d.feed(time, {'times' => t, 'data' => 'x'})
       end
     end
-    emits = d.emits
-    assert_equal 10, emits.length
-    assert_equal 'hoge3', emits[0][0]
+    events = d.events
+    assert_equal 10, events.length
+    assert_equal 'hoge3', events[0][0]
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-sampling-filter
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
 platform: ruby
 authors:
 - TAGOMORI Satoshi
@@ -44,20 +44,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 0.14.12
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 0.14.12
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: '2'
 description: fluentd plugin to pickup sample data from matched massages
 email:
 - tagomoris@gmail.com