fluent-plugin-numeric-monitor 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 399b0a9e1c2a2713f6dc0dc21a8d1616360a8cf5
-  data.tar.gz: 57e6d8d5940c160d17bc849a91183ef15769a5fc
+  metadata.gz: bb1a673d18f2f34ac4c1e892ea7e8778f7c508f9
+  data.tar.gz: 9873ee3b9e42431e1c489bd621f77fbf7dbd45d9
 SHA512:
-  metadata.gz: c885c3d3226f88d886848788894a3f11fe09caa56c054531f63c4fcfd21b11babea8ef72f7dca7430240b2c07d54c978ab39a3ab7607e17a9c081d5289b194ea
-  data.tar.gz: 4aca09f32e8fcae71c9003df93048f43cdb5817eaaf9d33dc1828ea031a96818aa9db761cffdbe9271721e3dbc6243c8dfa087b225a8ffb0d74d4d06f6dfb207
+  metadata.gz: e1194eebc1ed7de25de69d12b68d1cf5932c407149c75deb258cbc0e7fc32175c0087fe1dd641442218165a50677959dc3e84b8fcda2bd593bb91096625a5273
+  data.tar.gz: 5350d5ce64be10f5ed3b4ce4a37891bcea1c9b2a1627b6a4224f5e1f688fc8aa265443bd4f220fcec6ac21edb3f10b4096422513ad8079e62992cd3e546ea349

data/.travis.yml

@@ -1,7 +1,6 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.0.0
   - 2.1.8
   - 2.2.4
   - 2.3.0

data/fluent-plugin-numeric-monitor.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |gem|
   gem.name          = "fluent-plugin-numeric-monitor"
-  gem.version       = "0.2.0"
+  gem.version       = "1.0.0"
   gem.authors       = ["TAGOMORI Satoshi"]
   gem.email         = ["tagomoris@gmail.com"]
   gem.description   = %q{Fluentd plugin to calculate min/max/avg/Xpercentile values, and emit these data as message}
@@ -16,5 +16,5 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency "rake"
   gem.add_development_dependency "test-unit"
-  gem.add_runtime_dependency "fluentd", "< 0.14.0"
+  gem.add_runtime_dependency "fluentd", ">= 0.14.0"
 end

data/lib/fluent/plugin/out_numeric_monitor.rb

@@ -1,77 +1,54 @@
-class Fluent::NumericMonitorOutput < Fluent::Output
-  Fluent::Plugin.register_output('numeric_monitor', self)
+require 'fluent/plugin/output'
 
-  # Define `log` method for v0.10.42 or earlier
-  unless method_defined?(:log)
-    define_method("log") { $log }
-  end
+class Fluent::Plugin::NumericMonitorOutput < Fluent::Plugin::Output
+  Fluent::Plugin.register_output('numeric_monitor', self)
 
-  # Define `router` method of v0.12 to support v0.10.57 or earlier
-  unless method_defined?(:router)
-    define_method("router") { Fluent::Engine }
-  end
+  helpers :event_emitter, :timer
 
   EMIT_STREAM_RECORDS = 100
 
-  config_param :count_interval, :time, default: 60,
-               desc: 'The interval time to monitor in seconds.'
-  config_param :unit, default: nil do |value|
-    case value
-    when 'minute' then 60
-    when 'hour' then 3600
-    when 'day' then 86400
-    else
-      raise Fluent::ConfigError, "unit must be one of minute/hour/day"
-    end
-  end
-  config_param :tag, :string, default: 'monitor',
-               desc: 'The output tag.'
-  config_param :tag_prefix, :string, default: nil,
-               desc: <<-DESC
-The prefix string which will be added to the input tag.
-output_per_tag yes must be specified together.
-DESC
+  config_param :count_interval, :time, default: 60, desc: 'The interval time to monitor in seconds.'
+  config_param :unit, :enum, list: [:minute, :hour, :day], default: nil
+  config_param :tag, :string, default: 'monitor', desc: 'The output tag.'
+  config_param :aggregate, :enum, list: [:tag, :all], default: :tag, desc: "Calculate input events per tags, or all events"
 
   config_param :output_per_tag, :bool, default: false,
-               desc: <<-DESC
-Emit for each input tag.
-tag_prefix must be specified together.
-DESC
-  config_param :aggregate, default: 'tag',
-               desc: 'Calculate in each input tag separetely, or all records in a mass.' do |val|
-    case val
-    when 'tag' then :tag
-    when 'all' then :all
-    else
-      raise Fluent::ConfigError, "aggregate MUST be one of 'tag' or 'all'"
-    end
-  end
-  config_param :input_tag_remove_prefix, :string, default: nil,
-               desc: 'The prefix string which will be removed from the input tag.'
-  config_param :monitor_key, :string,
-               desc: 'The key to monitor in the event record.'
+               desc: 'Produce monitor result per input tags.'
+
+  config_param :monitor_key, :string, desc: 'The key to monitor in the event record.'
   config_param :output_key_prefix, :string, default: nil,
                desc: 'The prefix string which will be added to the output key.'
-  config_param :percentiles, default: nil,
+  config_param :percentiles, :array, value_type: :integer, default: nil,
                desc: 'Activate the percentile monitoring. ' \
-                     'Must be specified between 1 and 99 by integer separeted by , (comma).' do |val|
-    values = val.split(",").map(&:to_i)
-    if values.select{|i| i < 1 or i > 99 }.size > 0
-      raise Fluent::ConfigError, "percentiles MUST be specified between 1 and 99 by integer"
-    end
-    values
-  end
+                     'Must be specified between 1 and 99 by integer separeted by , (comma).'
 
   config_param :samples_limit, :integer, default: 1000000,
                desc: 'The limit number of sampling.'
-  config_param :interval, :float, default: 0.5
+
+  config_param :tag_prefix, :string, default: nil,
+               desc: 'The prefix string to be added to input tags. Use with "output_per_tag yes".',
+               deprecated: "Use @label routing instead."
+  config_param :input_tag_remove_prefix, :string, default: nil,
+               desc: 'The prefix string which will be removed from the input tag.',
+               deprecated: 'Use @label routing instead.'
+
 
   attr_accessor :count, :last_checked
 
   def configure(conf)
+    label_routing_specified = conf.has_key?('@label')
+
     super
 
-    @count_interval = @unit if @unit
+    if @unit
+      @count_interval = case @unit
+                        when :minute then 60
+                        when :hour then 3600
+                        when :day then 86400
+                        else
+                          raise "unknown unit: #{@unit}"
+                        end
+    end
 
     if @input_tag_remove_prefix
       @removed_prefix_string = @input_tag_remove_prefix + '.'
@@ -83,10 +60,14 @@ DESC
       @key_prefix_string = @output_key_prefix + '_'
     end
 
-    if (@output_per_tag || @tag_prefix) && (!@output_per_tag || !@tag_prefix)
-      raise Fluent::ConfigError, 'Specify both of output_per_tag and tag_prefix'
+    if @output_per_tag && (!label_routing_specified && !@tag_prefix)
+      raise Fluent::ConfigError, "specify @label to route output events into other <label> sections."
+    end
+    if @output_per_tag && @tag_prefix
+      @tag_prefix_string = @tag_prefix + '.'
+    else
+      @tag_prefix_string = nil
     end
-    @tag_prefix_string = @tag_prefix + '.' if @output_per_tag
 
     @count = count_initialized
     @mutex = Mutex.new
@@ -94,29 +75,12 @@ DESC
 
   def start
     super
-    start_watch
-  end
 
-  def shutdown
-    super
-    @watcher.terminate
-    @watcher.join
-  end
-
-  def start_watch
-    # for internal, or tests
-    @watcher = Thread.new(&method(:watch))
-  end
-
-  def watch
     @last_checked = Fluent::Engine.now
-    while true
-      sleep @interval
-      if Fluent::Engine.now - @last_checked >= @count_interval
-        now = Fluent::Engine.now
-        flush_emit
-        @last_checked = now
-      end
+    timer_execute(:out_numeric_counter_watcher, @count_interval) do
+      now = Fluent::Engine.now
+      flush_emit
+      @last_checked = now
     end
   end
 
@@ -239,7 +203,7 @@ DESC
     end
   end
 
-  def emit(tag, es, chain)
+  def process(tag, es)
     min = nil
     max = nil
     sum = 0
@@ -270,7 +234,5 @@ DESC
       end
     end
     countups(tag, min, max, sum, num, sample)
-
-    chain.next
   end
 end

data/test/plugin/test_out_numeric_monitor.rb

@@ -1,4 +1,5 @@
 require 'helper'
+require 'fluent/test/driver/output'
 
 class NumericMonitorOutputTest < Test::Unit::TestCase
   def setup
@@ -13,29 +14,57 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
     percentiles 80,90
   ]
 
-  def create_driver(conf = CONFIG, tag='test.input')
-    Fluent::Test::OutputTestDriver.new(Fluent::NumericMonitorOutput, tag).configure(conf)
+  def create_driver(conf = CONFIG)
+    Fluent::Test::Driver::Output.new(Fluent::Plugin::NumericMonitorOutput).configure(conf)
   end
 
   def test_configure
     assert_raise(Fluent::ConfigError) {
-      d = create_driver('')
+      create_driver('')
     }
     assert_raise(Fluent::ConfigError) {
-      d = create_driver CONFIG + %[
+      create_driver CONFIG + %[
         output_per_tag true
       ]
     }
-    assert_raise(Fluent::ConfigError) {
-      d = create_driver CONFIG + %[
-        tag_prefix prefix
+    assert_nothing_raised {
+      create_driver CONFIG + %[
+        output_per_tag true
+        @label yay
       ]
     }
-    #TODO
+    d = create_driver(CONFIG)
+    assert_equal(60, d.instance.count_interval)
+    assert_equal(:minute, d.instance.unit)
+    assert_equal("monitor.test", d.instance.tag)
+    assert_nil(d.instance.tag_prefix)
+    assert_false(d.instance.output_per_tag)
+    assert_equal(:tag, d.instance.aggregate)
+    assert_equal("test", d.instance.input_tag_remove_prefix)
+    assert_equal("field1", d.instance.monitor_key)
+    assert_equal([80, 90], d.instance.percentiles)
   end
 
-  def test_count_initialized
-    #TODO
+  sub_test_case "#count_initialized" do
+    test "aggregate all" do
+      d = create_driver(CONFIG + %[aggregate all])
+      all = {"all" => {min: nil, max: nil, sum: nil, num: 0, sample: []}}
+      assert_equal(all, d.instance.count_initialized)
+    end
+
+    test "default" do
+      d = create_driver(CONFIG)
+      assert_equal({}, d.instance.count_initialized)
+    end
+
+    test "with keys" do
+      d = create_driver(CONFIG)
+      tag1 = "tag1"
+      tag2 = "tag2"
+      expected = {tag1 => {min: nil, max: nil, sum: nil, num: 0, sample: []},
+                 tag2 => {min: nil, max: nil, sum: nil, num: 0, sample: []}}
+      assert_equal(expected, d.instance.count_initialized([tag1, tag2]))
+    end
   end
 
   def test_countups
@@ -54,19 +83,19 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
   end
 
   def test_emit
-    d1 = create_driver(CONFIG, 'test.tag1')
-    d1.run do
+    d1 = create_driver(CONFIG)
+    d1.run(default_tag: 'test.tag1') do
       10.times do
-        d1.emit({'field1' => 0})
-        d1.emit({'field1' => '1'})
-        d1.emit({'field1' => 2})
-        d1.emit({'field1' => '3'})
-        d1.emit({'field1' => 4})
-        d1.emit({'field1' => 5})
-        d1.emit({'field1' => 6})
-        d1.emit({'field1' => 7})
-        d1.emit({'field1' => 8})
-        d1.emit({'field1' => 9})
+        d1.feed({'field1' => 0})
+        d1.feed({'field1' => '1'})
+        d1.feed({'field1' => 2})
+        d1.feed({'field1' => '3'})
+        d1.feed({'field1' => 4})
+        d1.feed({'field1' => 5})
+        d1.feed({'field1' => 6})
+        d1.feed({'field1' => 7})
+        d1.feed({'field1' => 8})
+        d1.feed({'field1' => 9})
       end
     end
     r1 = d1.instance.flush
@@ -87,20 +116,20 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
       aggregate all
       monitor_key field1
       percentiles 80,90
-    ], 'test.tag1')
+    ])
 
-    d1.run do
+    d1.run(default_tag: 'test.tag1') do
       10.times do
-        d1.emit({'field1' => 0})
-        d1.emit({'field1' => '1'})
-        d1.emit({'field1' => 2})
-        d1.emit({'field1' => '3'})
-        d1.emit({'field1' => 4})
-        d1.emit({'field1' => 5})
-        d1.emit({'field1' => 6})
-        d1.emit({'field1' => 7})
-        d1.emit({'field1' => 8})
-        d1.emit({'field1' => 9})
+        d1.feed({'field1' => 0})
+        d1.feed({'field1' => '1'})
+        d1.feed({'field1' => 2})
+        d1.feed({'field1' => '3'})
+        d1.feed({'field1' => 4})
+        d1.feed({'field1' => 5})
+        d1.feed({'field1' => 6})
+        d1.feed({'field1' => 7})
+        d1.feed({'field1' => 8})
+        d1.feed({'field1' => 9})
       end
     end
     r1 = d1.instance.flush
@@ -118,11 +147,11 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
       unit minute
       tag testmonitor
       monitor_key x1
-    ], 'test')
-    d.run do
-      d.emit({'x1' => 1})
-      d.emit({'x1' => 2})
-      d.emit({'x1' => 3})
+    ])
+    d.run(default_tag: 'test') do
+      d.feed({'x1' => 1})
+      d.feed({'x1' => 2})
+      d.feed({'x1' => 3})
     end
     r = d.instance.flush
     assert_equal 1, r['test_min']
@@ -137,27 +166,28 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
       aggregate tag
       output_per_tag true
       tag_prefix tag_prefix
-    ], 'tag')
-    d.run do
-      d.tag = 'tag1'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
-      d.tag = 'tag2'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
+    ])
+    time = Time.now.to_i
+    d.run(default_tag: 'tag') do
+      tag1 = 'tag1'
+      d.feed(tag1, time, {'field1' => 1})
+      d.feed(tag1, time, {'field1' => 2})
+      d.feed(tag1, time, {'field1' => 3})
+      tag2 = 'tag2'
+      d.feed(tag2, time, {'field1' => 1})
+      d.feed(tag2, time, {'field1' => 2})
+      d.feed(tag2, time, {'field1' => 3})
+      d.instance.flush_emit
     end
-    d.instance.flush_emit
-    assert_equal 2, d.emits.size
-    tag, r = d.emits[0][0], d.emits[0][2]
+    assert_equal 2, d.events.size
+    tag, r = d.events[0][0], d.events[0][2]
     assert_equal 'tag_prefix.tag1', tag
     assert_equal 1, r['min']
     assert_equal 3, r['max']
     assert_equal 2, r['avg']
     assert_equal 6, r['sum']
     assert_equal 3, r['num']
-    tag, r = d.emits[1][0], d.emits[1][2]
+    tag, r = d.events[1][0], d.events[1][2]
     assert_equal 'tag_prefix.tag2', tag
     assert_equal 1, r['min']
     assert_equal 3, r['max']
@@ -169,20 +199,21 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
       aggregate tag
       output_per_tag false
       tag output_tag
-    ], 'tag')
-    d.run do
-      d.tag = 'tag1'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
-      d.tag = 'tag2'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
+    ])
+    time = Time.now.to_i
+    d.run(default_tag: 'tag') do
+      tag1 = 'tag1'
+      d.feed(tag1, time, {'field1' => 1})
+      d.feed(tag1, time, {'field1' => 2})
+      d.feed(tag1, time, {'field1' => 3})
+      tag2 = 'tag2'
+      d.feed(tag2, time, {'field1' => 1})
+      d.feed(tag2, time, {'field1' => 2})
+      d.feed(tag2, time, {'field1' => 3})
+      d.instance.flush_emit
     end
-    d.instance.flush_emit
-    assert_equal 1, d.emits.size
-    tag, r = d.emits[0][0], d.emits[0][2]
+    assert_equal 1, d.events.size
+    tag, r = d.events[0][0], d.events[0][2]
     assert_equal 'output_tag', tag
     assert_equal 1, r['tag1_min']
     assert_equal 3, r['tag1_max']
@@ -199,21 +230,22 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
       aggregate all
       output_per_tag true
       tag_prefix tag_prefix
-    ], 'tag')
-    d.run do
-      d.tag = 'tag1'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
-      d.tag = 'tag2'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
+    ])
+    time = Time.now.to_i
+    d.run(default_tag: 'tag') do
+      tag1 = 'tag1'
+      d.feed(tag1, time, {'field1' => 1})
+      d.feed(tag1, time, {'field1' => 2})
+      d.feed(tag1, time, {'field1' => 3})
+      tag2 = 'tag2'
+      d.feed(tag2, time, {'field1' => 1})
+      d.feed(tag2, time, {'field1' => 2})
+      d.feed(tag2, time, {'field1' => 3})
+      d.instance.flush_emit
     end
-    d.instance.flush_emit
-    assert_equal 1, d.emits.size
-    tag = d.emits[0][0]
-    r = d.emits[0][2]
+    assert_equal 1, d.events.size
+    tag = d.events[0][0]
+    r = d.events[0][2]
     assert_equal 'tag_prefix.all', tag
     assert_equal 1, r['min']
     assert_equal 3, r['max']
@@ -225,21 +257,22 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
       aggregate all
       output_per_tag false
       tag output_tag
-    ], 'tag')
-    d.run do
-      d.tag = 'tag1'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
-      d.tag = 'tag2'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
+    ])
+    time = Time.now.to_i
+    d.run(default_tag: 'tag') do
+      tag1 = 'tag1'
+      d.feed(tag1, time, {'field1' => 1})
+      d.feed(tag1, time, {'field1' => 2})
+      d.feed(tag1, time, {'field1' => 3})
+      tag2 = 'tag2'
+      d.feed(tag2, time, {'field1' => 1})
+      d.feed(tag2, time, {'field1' => 2})
+      d.feed(tag2, time, {'field1' => 3})
+      d.instance.flush_emit
     end
-    d.instance.flush_emit
-    assert_equal 1, d.emits.size
-    tag = d.emits[0][0]
-    r = d.emits[0][2]
+    assert_equal 1, d.events.size
+    tag = d.events[0][0]
+    r = d.events[0][2]
     assert_equal 'output_tag', tag
     assert_equal 1, r['min']
     assert_equal 3, r['max']
@@ -254,27 +287,28 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
       output_per_tag true
       tag_prefix tag_prefix
       output_key_prefix key_prefix
-    ], 'tag')
-    d.run do
-      d.tag = 'tag1'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
-      d.tag = 'tag2'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
+    ])
+    time = Time.now.to_i
+    d.run(default_tag: 'tag') do
+      tag1 = 'tag1'
+      d.feed(tag1, time, {'field1' => 1})
+      d.feed(tag1, time, {'field1' => 2})
+      d.feed(tag1, time, {'field1' => 3})
+      tag2 = 'tag2'
+      d.feed(tag2, time, {'field1' => 1})
+      d.feed(tag2, time, {'field1' => 2})
+      d.feed(tag2, time, {'field1' => 3})
+      d.instance.flush_emit
     end
-    d.instance.flush_emit
-    assert_equal 2, d.emits.size
-    tag, r = d.emits[0][0], d.emits[0][2]
+    assert_equal 2, d.events.size
+    tag, r = d.events[0][0], d.events[0][2]
     assert_equal 'tag_prefix.tag1', tag
     assert_equal 1, r['key_prefix_min']
     assert_equal 3, r['key_prefix_max']
     assert_equal 2, r['key_prefix_avg']
     assert_equal 6, r['key_prefix_sum']
     assert_equal 3, r['key_prefix_num']
-    tag, r = d.emits[1][0], d.emits[1][2]
+    tag, r = d.events[1][0], d.events[1][2]
     assert_equal 'tag_prefix.tag2', tag
     assert_equal 1, r['key_prefix_min']
     assert_equal 3, r['key_prefix_max']
@@ -287,20 +321,21 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
       output_per_tag false
       tag output_tag
       output_key_prefix key_prefix
-    ], 'tag')
-    d.run do
-      d.tag = 'tag1'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
-      d.tag = 'tag2'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
+    ])
+    time = Time.now.to_i
+    d.run(default_tag: 'tag') do
+      tag1 = 'tag1'
+      d.feed(tag1, time, {'field1' => 1})
+      d.feed(tag1, time, {'field1' => 2})
+      d.feed(tag1, time, {'field1' => 3})
+      tag2 = 'tag2'
+      d.feed(tag2, time, {'field1' => 1})
+      d.feed(tag2, time, {'field1' => 2})
+      d.feed(tag2, time, {'field1' => 3})
+      d.instance.flush_emit
     end
-    d.instance.flush_emit
-    assert_equal 1, d.emits.size
-    tag, r = d.emits[0][0], d.emits[0][2]
+    assert_equal 1, d.events.size
+    tag, r = d.events[0][0], d.events[0][2]
     assert_equal 'output_tag', tag
     assert_equal 1, r['key_prefix_tag1_min']
     assert_equal 3, r['key_prefix_tag1_max']
@@ -318,21 +353,22 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
       output_per_tag true
       tag_prefix tag_prefix
       output_key_prefix key_prefix
-    ], 'tag')
-    d.run do
-      d.tag = 'tag1'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
-      d.tag = 'tag2'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
+    ])
+    time = Time.now.to_i
+    d.run(default_tag: 'tag1') do
+      tag1 = 'tag1'
+      d.feed(tag1, time, {'field1' => 1})
+      d.feed(tag1, time, {'field1' => 2})
+      d.feed(tag1, time, {'field1' => 3})
+      tag2 = 'tag2'
+      d.feed(tag2, time, {'field1' => 1})
+      d.feed(tag2, time, {'field1' => 2})
+      d.feed(tag2, time, {'field1' => 3})
+      d.instance.flush_emit
     end
-    d.instance.flush_emit
-    assert_equal 1, d.emits.size
-    tag = d.emits[0][0]
-    r = d.emits[0][2]
+    assert_equal 1, d.events.size
+    tag = d.events[0][0]
+    r = d.events[0][2]
     assert_equal 'tag_prefix.all', tag
     assert_equal 1, r['key_prefix_min']
     assert_equal 3, r['key_prefix_max']
@@ -345,21 +381,22 @@ class NumericMonitorOutputTest < Test::Unit::TestCase
       output_per_tag false
       tag output_tag
       output_key_prefix key_prefix
-    ], 'tag')
-    d.run do
-      d.tag = 'tag1'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
-      d.tag = 'tag2'
-      d.emit({'field1' => 1})
-      d.emit({'field1' => 2})
-      d.emit({'field1' => 3})
+    ])
+    time = Time.now.to_i
+    d.run(default_tag: 'tag') do
+      tag1 = 'tag1'
+      d.feed(tag1, time, {'field1' => 1})
+      d.feed(tag1, time, {'field1' => 2})
+      d.feed(tag1, time, {'field1' => 3})
+      tag2 = 'tag2'
+      d.feed(tag2, time, {'field1' => 1})
+      d.feed(tag2, time, {'field1' => 2})
+      d.feed(tag2, time, {'field1' => 3})
+      d.instance.flush_emit
     end
-    d.instance.flush_emit
-    assert_equal 1, d.emits.size
-    tag = d.emits[0][0]
-    r = d.emits[0][2]
+    assert_equal 1, d.events.size
+    tag = d.events[0][0]
+    r = d.events[0][2]
     assert_equal 'output_tag', tag
     assert_equal 1, r['key_prefix_min']
     assert_equal 3, r['key_prefix_max']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-numeric-monitor
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - TAGOMORI Satoshi
@@ -42,14 +42,14 @@ dependencies:
   name: fluentd
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.14.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.14.0
 description: Fluentd plugin to calculate min/max/avg/Xpercentile values, and emit