fluent-plugin-stats-notifier 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20ebee510eb1403230e4baee3b2b302e9d5a82dd
-  data.tar.gz: 64c9831470b6871e9f7df06efeb61d7c2d14466c
+  metadata.gz: 67d26005468f638f64088219bbd2b412a526025f
+  data.tar.gz: ad90655b0724642ba1aea652fc0ba7d31a7d139e
 SHA512:
-  metadata.gz: 3f5b4655b1d325fa5bfcb018f82ccc78e01815a5a7b2e7e8d57d042e3f48a0713eb6bd3671f36967f1910401b019ab4a04b4e091b69c150c8899e3e620dfa7ab
-  data.tar.gz: 0172ea3071a0713239147954b68818b8f57ccf8505c043f51a47977930b4ac3093a5452153ae2eadaf737cb695464612b1549967c39e524dfc9d2cdaffa605d5
+  metadata.gz: 5d4dce4153badaab3416e4d7a096065379aec55397b050bae2a73fb0c96c027411fcf060263fc3914e3ecde2acc05cc9b33bc39c674912ed308f173ba115c959
+  data.tar.gz: 960d59b06a22a0779c755d41e7c8e78e8ccef9641ce4f3de6963c8ec45ee3a541195ad4ee51c14e9007ce4dac21ac962246b593142f75a110db7a56a34fd11cd

data/.travis.yml

@@ -1,6 +1,6 @@
 rvm:
-  - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.*
 gemfile:
   - Gemfile

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.0.4
+
+Enchancements:
+
+* Add `add_tag_suffix` and `remove_tag_suffix` options
+
 ## 0.0.3
 
 Enchancements

data/README.md

@@ -4,15 +4,47 @@ Fluentd plugin to calculate statistics and then thresholding
 
 ## Configuration
 
-  <store>
-    type stats_notifier
-    tag notifier
-    interval 5
-    target_key 4xx_count
-    greater_equal 4
-    compare_with max
-    store_file /path/to/store_file.dat
-  </store>
+### Example 1
+
+Get statistics on messages
+
+```
+<match foo.**>
+  type stats_notifier
+  tag notifier
+  interval 5
+  target_key 4xx_count
+  greater_equal 4
+  stats max # default
+  store_file /path/to/store_file.dat
+</match>
+```
+
+Assuming following inputs are coming:
+
+    foo.bar1: {"4xx_count":1,"foobar":2"}
+    foo.bar1: {"4xx_count":6,"foobar":2"}
+
+then this plugin emits an message because the max of `4xx_count` is greater than or equal to the specified value `4`. Output will be as following:
+
+    notifier: {"4xx_count":6.0}
+
+### Example 2
+
+Get statistics among tags
+
+```
+<match foo.**>
+  type stats_notifier
+  tag notifier
+  interval 5
+  target_key 4xx_count
+  greater_equal 4
+  aggregate all # default
+  aggregate_stats max # default
+  store_file /path/to/store_file.dat
+</match>
+```
 
 Assuming following inputs are coming:
 
@@ -23,6 +55,32 @@ then this plugin emits an message because the max of `4xx_count` is greater than
 
     notifier: {"4xx_count":6.0}
 
+### Combined Example
+
+```
+<match foo.**>
+  type stats_notifier
+  tag notifier
+  interval 5
+  target_key 4xx_count
+  greater_equal 4
+  stats max # default
+  aggregate all # default
+  aggregate_stats max # default
+  store_file /path/to/store_file.dat
+</match>
+```
+
+Assuming following inputs are coming:
+
+    foo.bar1: {"4xx_count":1,"foobar":2"}
+    foo.bar1: {"4xx_count":8,"foobar":2"}
+    foo.bar2: {"4xx_count":6,"foobar":2"}
+
+Output will be as following:
+
+    notifier: {"4xx_count":8.0}
+
 ## Parameters
 
 - target\_key (required)
@@ -49,10 +107,18 @@ then this plugin emits an message because the max of `4xx_count` is greater than
 
     A `greater than or eqaul` threshold value, that is, emit if `target_key` value >= specified value. 
 
-- compare\_with
+- stats
 
     `max`, `avg`, `min`, `sum` can be specified. Default is `max`.
 
+- aggregate\_stats
+
+    Work only with `aggregate all`. `max`, `avg`, `min`, `sum` can be specified. Default is `max`.
+
+- compare\_with 
+
+    Obsolete. Use `aggregate_stats`.
+
 - tag
 
     The output tag name. Required for `aggregate all`.
@@ -61,6 +127,18 @@ then this plugin emits an message because the max of `4xx_count` is greater than
 
     Add tag prefix for output message. Required for `aggregate tag`.
 
+- remove_tag_prefix
+
+    Remove tag prefix for output message.
+
+- add_tag_suffix
+
+    Add tag suffix for output message.
+
+- remove_tag_suffix
+
+    Remove tag suffix for output message.
+
 - aggragate
     
     Do calculation for each `tag` or `all`. The defaultis `all`.

data/fluent-plugin-stats-notifier.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "fluent-plugin-stats-notifier"
-  s.version     = "0.0.3"
+  s.version     = "0.0.4"
   s.authors     = ["Naotoshi Seo"]
   s.email       = ["sonots@gmail.com"]
   s.homepage    = "https://github.com/sonots/fluent-plugin-stats-notifier"

data/lib/fluent/plugin/out_stats_notifier.rb

@@ -2,6 +2,11 @@
 class Fluent::StatsNotifierOutput < Fluent::Output
   Fluent::Plugin.register_output('stats_notifier', self)
 
+  # To support log_level option implemented by Fluentd v0.10.43
+  unless method_defined?(:log)
+    define_method("log") { $log }
+  end
+
   def initialize
     super
     require 'pathname'
@@ -13,15 +18,19 @@ class Fluent::StatsNotifierOutput < Fluent::Output
   config_param :less_equal, :float, :default => nil
   config_param :greater_than, :float, :default => nil
   config_param :greater_equal, :float, :default => nil
-  config_param :compare_with, :string, :default => "max"
-  config_param :tag, :string
+  config_param :stats, :string, :default => "max"
+  config_param :compare_with, :string, :default => nil # Obsolete. Use aggregate_stats
+  config_param :aggregate_stats, :string, :default => "max" # Work only with aggregate :all
+  config_param :tag, :string, :default => nil
   config_param :add_tag_prefix, :string, :default => nil
   config_param :remove_tag_prefix, :string, :default => nil
+  config_param :add_tag_suffix, :string, :default => nil
+  config_param :remove_tag_suffix, :string, :default => nil
   config_param :aggregate, :string, :default => 'all'
   config_param :store_file, :string, :default => nil
 
   attr_accessor :counts
-  attr_accessor :matches
+  attr_accessor :queues
   attr_accessor :saved_duration
   attr_accessor :saved_at
   attr_accessor :last_checked
@@ -32,51 +41,57 @@ class Fluent::StatsNotifierOutput < Fluent::Output
     @interval = @interval.to_i
 
     if @less_than and @less_equal
-      raise Fluent::ConfigError, "out_stats_notiifer: Only either of `less_than` or `less_equal` can be specified."
+      raise Fluent::ConfigError, "out_stats_notifier: Only either of `less_than` or `less_equal` can be specified."
     end
     if @greater_than and @greater_equal
-      raise Fluent::ConfigError, "out_stats_notiifer: Only either of `greater_than` or `greater_equal` can be specified."
+      raise Fluent::ConfigError, "out_stats_notifier: Only either of `greater_than` or `greater_equal` can be specified."
     end
 
-    case @compare_with
+    @aggregate_stats = @compare_with if @compare_with # Support old version compatibility
+    case @aggregate_stats
     when "sum"
-      @compare_with = :sum
+      @aggregate_stats = :sum
     when "max"
-      @compare_with = :max
+      @aggregate_stats = :max
     when "min"
-      @compare_with = :min
+      @aggregate_stats = :min
     when "avg"
-      @compare_with = :avg
+      @aggregate_stats = :avg
     else
-      raise Fluent::ConfigError, "out_stats_notiifer: `compare_with` must be one of `sum`, `max`, `min`, `avg`"
+      raise Fluent::ConfigError, "out_stats_notifier: `aggregate_stats` must be one of `sum`, `max`, `min`, `avg`"
+    end
+
+    case @stats
+    when "sum"
+      @stats = :sum
+    when "max"
+      @stats = :max
+    when "min"
+      @stats = :min
+    when "avg"
+      @stats = :avg
+    else
+      raise Fluent::ConfigError, "out_stats_notifier: `stats` must be one of `sum`, `max`, `min`, `avg`"
+    end
+
+    if @tag.nil? and @add_tag_prefix.nil? and @remove_tag_prefix.nil? and @add_tag_suffix.nil? and @remove_tag_suffix.nil?
+      raise Fluent::ConfigError, "out_stats_notifier: No tag option is specified"
     end
+    @tag_proc = tag_proc
 
     case @aggregate
     when 'all'
-      raise Fluent::ConfigError, "anomalydetect: `tag` must be specified with aggregate all" if @tag.nil?
+      raise Fluent::ConfigError, "out_stats_notifier: `tag` must be specified with aggregate all" if @tag.nil?
+      @aggregate = :all
     when 'tag'
-      raise Fluent::ConfigError, "anomalydetect: `add_tag_prefix` must be specified with aggregate tag" if @add_tag_prefix.nil?
+      # raise Fluent::ConfigError, "out_stats_notifier: `add_tag_prefix` must be specified with aggregate tag" if @add_tag_prefix.nil?
+      @aggregate = :tag
     else
-      raise Fluent::ConfigError, "anomalydetect: aggregate allows tag/all"
+      raise Fluent::ConfigError, "out_stats_notifier: aggregate allows tag/all"
     end
 
-    @tag_prefix = "#{@add_tag_prefix}." if @add_tag_prefix
-    @tag_prefix_match = "#{@remove_tag_prefix}." if @remove_tag_prefix
-    @tag_proc =
-      if @tag_prefix and @tag_prefix_match
-        Proc.new {|tag| "#{@tag_prefix}#{lstrip(tag, @tag_prefix_match)}" }
-      elsif @tag_prefix_match
-        Proc.new {|tag| lstrip(tag, @tag_prefix_match) }
-      elsif @tag_prefix
-        Proc.new {|tag| "#{@tag_prefix}#{tag}" }
-      elsif @tag
-        Proc.new {|tag| @tag }
-      else
-        Proc.new {|tag| tag }
-      end
-
     @counts = {}
-    @matches = {}
+    @queues = {}
     @mutex = Mutex.new
   end
 
@@ -97,30 +112,30 @@ class Fluent::StatsNotifierOutput < Fluent::Output
   def emit(tag, es, chain)
     key = @target_key
 
-    # stats
-    count = 0; matches = {}
+    # enqueus
+    count = 0; queues = {}
     es.each do |time,record|
       if record[key]
-        # @todo: make an option for calcuation in the same tag. now only sum is supported
-        matches[key] = (matches[key] ? matches[key] + record[key] : record[key])
+        queues[key] ||= []
+        queues[key] << record[key]
       end
       count += 1
     end
 
     # thread safe merge
     @counts[tag] ||= 0
-    @matches[tag] ||= {}
+    @queues[tag] ||= {}
     @mutex.synchronize do
-      if matches[key]
-        # @todo: make an option for calcuation in the same tag. now only sum is supported
-        @matches[tag][key] = (@matches[tag][key] ? @matches[tag][key] + matches[key] : matches[key])
+      if queues[key]
+        @queues[tag][key] ||= []
+        @queues[tag][key].concat(queues[key])
       end
       @counts[tag] += count
     end
 
     chain.next
   rescue => e
-    $log.warn "#{e.class} #{e.message} #{e.backtrace.first}"
+    log.warn "#{e.class} #{e.message} #{e.backtrace.first}"
   end
 
   # thread callback
@@ -138,7 +153,7 @@ class Fluent::StatsNotifierOutput < Fluent::Output
           @last_checked = now
         end
       rescue => e
-        $log.warn "#{e.class} #{e.message} #{e.backtrace.first}"
+        log.warn "#{e.class} #{e.message} #{e.backtrace.first}"
       end
     end
   end
@@ -146,46 +161,76 @@ class Fluent::StatsNotifierOutput < Fluent::Output
   # This method is the real one to emit
   def flush_emit(step)
     time = Fluent::Engine.now
-    counts, matches, @counts, @matches = @counts, @matches, {}, {}
+    counts, queues, @counts, @queues = @counts, @queues, {}, {}
 
-    if @aggregate == 'all'
-      values = matches.values.map {|match| match[@target_key] }.compact
-      output = generate_output(values)
+    # Get statistical value among events
+    evented_queues = {}
+    queues.each do |tag, queue|
+      evented_queues[tag] ||= {}
+      evented_queues[tag][@target_key] = get_stats(queue[@target_key], @stats) if queue[@target_key]
+    end
+
+    if @aggregate == :all
+      values = evented_queues.values.map {|queue| queue[@target_key] }.compact
+      value = get_stats(values, @aggregate_stats)
+      output = generate_output(value) if value
       Fluent::Engine.emit(@tag, time, output) if output
     else # aggregate tag
-      matches.each do |tag, match|
-        values = [match[@target_key]]
-        output = generate_output(values)
+      evented_queues.each do |tag, queue|
+        value = queue[@target_key]
+        output = generate_output(value) if value
         emit_tag = @tag_proc.call(tag)
         Fluent::Engine.emit(emit_tag, time, output) if output
       end
     end
   end
 
-  def generate_output(values)
-    case @compare_with
+  def get_stats(values, method = :max)
+    case method
     when :sum
-      target_value = values.inject(:+)
+      stats = values.inject(:+)
     when :max
-      target_value = values.max
+      stats = values.max
     when :min
-      target_value = values.min
+      stats = values.min
     when :avg
-      target_value = values.inject(:+) / values.count unless values.empty?
+      stats = values.inject(:+) / values.count unless values.empty?
     end
+  end
 
-    return nil if target_value.nil?
-    return nil if target_value == 0 # ignore 0 because standby nodes receive 0 message usually
-    return nil if @less_than     and @less_than   <= target_value
-    return nil if @less_equal    and @less_equal  <  target_value
-    return nil if @greater_than  and target_value <= @greater_than
-    return nil if @greater_equal and target_value <  @greater_equal
+  def generate_output(value)
+    return nil if value == 0 # ignore 0 because standby nodes receive 0 message usually
+    return nil if @less_than     and @less_than   <= value
+    return nil if @less_equal    and @less_equal  <  value
+    return nil if @greater_than  and value <= @greater_than
+    return nil if @greater_equal and value <  @greater_equal
 
     output = {}
-    output[@target_key] = target_value
+    output[@target_key] = value
     output
   end
 
+  def tag_proc
+    rstrip = Proc.new {|str, substr| str.chomp(substr) }
+    lstrip = Proc.new {|str, substr| str.start_with?(substr) ? str[substr.size..-1] : str }
+    tag_prefix = "#{rstrip.call(@add_tag_prefix, '.')}." if @add_tag_prefix
+    tag_suffix = ".#{lstrip.call(@add_tag_suffix, '.')}" if @add_tag_suffix
+    tag_prefix_match = "#{rstrip.call(@remove_tag_prefix, '.')}." if @remove_tag_prefix
+    tag_suffix_match = ".#{lstrip.call(@remove_tag_suffix, '.')}" if @remove_tag_suffix
+    tag_fixed = @tag if @tag
+    if tag_fixed
+      Proc.new {|tag| tag_fixed }
+    elsif tag_prefix_match and tag_suffix_match
+      Proc.new {|tag| "#{tag_prefix}#{rstrip.call(lstrip.call(tag, tag_prefix_match), tag_suffix_match)}#{tag_suffix}" }
+    elsif tag_prefix_match
+      Proc.new {|tag| "#{tag_prefix}#{lstrip.call(tag, tag_prefix_match)}#{tag_suffix}" }
+    elsif tag_suffix_match
+      Proc.new {|tag| "#{tag_prefix}#{rstrip.call(tag, tag_suffix_match)}#{tag_suffix}" }
+    else
+      Proc.new {|tag| "#{tag_prefix}#{tag}#{tag_suffix}" }
+    end
+  end
+
   # Store internal status into a file
   #
   # @param [String] file_path
@@ -198,14 +243,14 @@ class Fluent::StatsNotifierOutput < Fluent::Output
         @saved_duration = @saved_at - @last_checked
         Marshal.dump({
           :counts           => @counts,
-          :matches          => @matches,
+          :queues          => @queues,
           :saved_at         => @saved_at,
           :saved_duration   => @saved_duration,
           :target_key       => @target_key,
         }, f)
       end
     rescue => e
-      $log.warn "out_stats_notifier: Can't write store_file #{e.class} #{e.message}"
+      log.warn "out_stats_notifier: Can't write store_file #{e.class} #{e.message}"
     end
   end
 
@@ -220,24 +265,27 @@ class Fluent::StatsNotifierOutput < Fluent::Output
       f.open('rb') do |f|
         stored = Marshal.load(f)
         if stored[:target_key] == @target_key
+          if stored[:queues]
+            if Fluent::Engine.now <= stored[:saved_at] + interval
+              @counts = stored[:counts]
+              @queues = stored[:queues]
+              @saved_at = stored[:saved_at]
+              @saved_duration = stored[:saved_duration]
 
-          if Fluent::Engine.now <= stored[:saved_at] + interval
-            @counts = stored[:counts]
-            @matches = stored[:matches]
-            @saved_at = stored[:saved_at]
-            @saved_duration = stored[:saved_duration]
-
-            # skip the saved duration to continue counting
-            @last_checked = Fluent::Engine.now - @saved_duration
+              # skip the saved duration to continue counting
+              @last_checked = Fluent::Engine.now - @saved_duration
+            else
+              log.warn "out_stats_notifier: stored data is outdated. ignore stored data"
+            end
           else
-            $log.warn "out_stats_notifier: stored data is outdated. ignore stored data"
+            log.warn "out_stats_notifier: stored data is incompatible. ignore stored data"
           end
         else
-          $log.warn "out_stats_notiifer: configuration param was changed. ignore stored data"
+          log.warn "out_stats_notifier: configuration param was changed. ignore stored data"
         end
       end
     rescue => e
-      $log.warn "out_stats_notifier: Can't load store_file #{e.class} #{e.message}"
+      log.warn "out_stats_notifier: Can't load store_file #{e.class} #{e.message}"
     end
   end
 

data/spec/out_stats_notifier_spec.rb

@@ -13,6 +13,7 @@ describe Fluent::StatsNotifierOutput do
   CONFIG = %[
     target_key 5xx_count
     tag foo
+    # compare_with max
   ]
   let(:tag) { 'foo.bar' }
   let(:driver) { Fluent::Test::OutputTestDriver.new(Fluent::StatsNotifierOutput, tag).configure(config) }
@@ -33,6 +34,11 @@ describe Fluent::StatsNotifierOutput do
         let(:config) { CONFIG + %[greater_than 2 \n greater_equal 3] }
         it { expect { driver }.to raise_error(Fluent::ConfigError) }
       end
+
+      context "not tag option is specified" do
+        let(:config) { %[target_key 5xx_count] }
+        it { expect { driver }.to raise_error(Fluent::ConfigError) }
+      end
     end
 
     describe 'good configuration' do
@@ -47,16 +53,16 @@ describe Fluent::StatsNotifierOutput do
     let(:time) { Time.now.to_i }
     let(:messages) do
       [
-        {"4xx_count"=>1,"5xx_count"=>2,"reqtime_max"=>6,"reqtime_min"=>1,"reqtime_avg"=>3},
-        {"4xx_count"=>2,"5xx_count"=>2,"reqtime_max"=>5,"reqtime_min"=>2,"reqtime_avg"=>2},
-        {"4xx_count"=>3,"5xx_count"=>2,"reqtime_max"=>1,"reqtime_min"=>3,"reqtime_avg"=>4},
+        {"4xx_count"=>1,"5xx_count"=>6,"reqtime_max"=>6,"reqtime_min"=>1,"reqtime_avg"=>3},
+        {"4xx_count"=>2,"5xx_count"=>6,"reqtime_max"=>5,"reqtime_min"=>2,"reqtime_avg"=>2},
+        {"4xx_count"=>3,"5xx_count"=>6,"reqtime_max"=>1,"reqtime_min"=>3,"reqtime_avg"=>4},
       ]
     end
     let(:emit) do
       driver.run { messages.each {|message| driver.emit(message, time) } }
       driver.instance.flush_emit(0)
     end
-    let(:config) { CONFIG } # 5xx_count, sum
+    let(:config) { CONFIG } # 5xx_count, max
     let(:expected) do
       {
         "5xx_count"=>6,
@@ -164,7 +170,7 @@ describe Fluent::StatsNotifierOutput do
       end
 
       context 'tag' do
-        let(:config) { CONFIG + %[aggregate tag \n add_tag_prefix add] }
+        let(:config) { %[target_key 5xx_count \n aggregate tag \n add_tag_prefix add] }
         before do
           Fluent::Engine.stub(:now).and_return(time)
           Fluent::Engine.should_receive(:emit).with("add.foo.bar1", time, {"5xx_count"=>2.0})
@@ -174,7 +180,7 @@ describe Fluent::StatsNotifierOutput do
       end
     end
 
-    context 'compare_with' do
+    context 'compare_with (obsolete)' do
       let(:emit) do
         driver.run do
           driver.emit_with_tag({"5xx_count"=>2}, time, 'foo.bar1')
@@ -284,6 +290,138 @@ describe Fluent::StatsNotifierOutput do
       end
     end
 
+    context 'aggregate_stats' do
+      let(:emit) do
+        driver.run do
+          driver.emit_with_tag({"5xx_count"=>2}, time, 'foo.bar1')
+          driver.emit_with_tag({"5xx_count"=>6}, time, 'foo.bar2')
+        end
+        driver.instance.flush_emit(0)
+      end
+
+      context 'avg' do
+        let(:config) { CONFIG + %[less_equal 4 \n aggregate_stats avg] }
+        let(:expected) do
+          {
+            "5xx_count" => 4.0
+          }
+        end
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("foo", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'sum' do
+        let(:config) { CONFIG + %[less_equal 8 \n aggregate_stats sum] }
+        let(:expected) do
+          {
+            "5xx_count" => 8.0
+          }
+        end
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("foo", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'min' do
+        let(:config) { CONFIG + %[less_equal 2 \n aggregate_stats min] }
+        let(:expected) do
+          {
+            "5xx_count" => 2.0
+          }
+        end
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("foo", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'max' do
+        let(:config) { CONFIG + %[less_equal 6 \n aggregate_stats max] }
+        let(:expected) do
+          {
+            "5xx_count" => 6.0
+          }
+        end
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("foo", time, expected)
+        end
+        it { emit }
+      end
+    end
+
+    context 'stats' do
+      let(:emit) do
+        driver.run do
+          driver.emit_with_tag({"5xx_count"=>2}, time, 'foo.bar1')
+          driver.emit_with_tag({"5xx_count"=>6}, time, 'foo.bar1')
+        end
+        driver.instance.flush_emit(0)
+      end
+
+      context 'avg' do
+        let(:config) { CONFIG + %[less_equal 4 \n stats avg] }
+        let(:expected) do
+          {
+            "5xx_count" => 4.0
+          }
+        end
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("foo", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'sum' do
+        let(:config) { CONFIG + %[less_equal 8 \n stats sum] }
+        let(:expected) do
+          {
+            "5xx_count" => 8.0
+          }
+        end
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("foo", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'min' do
+        let(:config) { CONFIG + %[less_equal 2 \n stats min] }
+        let(:expected) do
+          {
+            "5xx_count" => 2.0
+          }
+        end
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("foo", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'max' do
+        let(:config) { CONFIG + %[less_equal 6 \n stats max] }
+        let(:expected) do
+          {
+            "5xx_count" => 6.0
+          }
+        end
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("foo", time, expected)
+        end
+        it { emit }
+      end
+    end
+
     describe "store_file" do
       let(:store_file) do
         dirname = "tmp"
@@ -298,22 +436,22 @@ describe Fluent::StatsNotifierOutput do
         driver.run { messages.each {|message| driver.emit(message, time) } }
         driver.instance.shutdown
         stored_counts = driver.instance.counts
-        stored_matches = driver.instance.matches
+        stored_queues = driver.instance.queues
         stored_saved_at = driver.instance.saved_at
         stored_saved_duration = driver.instance.saved_duration
         driver.instance.counts = {}
-        driver.instance.matches = {}
+        driver.instance.queues = {}
         driver.instance.saved_at = nil
         driver.instance.saved_duration = nil
 
         driver.instance.start
         loaded_counts = driver.instance.counts
-        loaded_matches = driver.instance.matches
+        loaded_queues = driver.instance.queues
         loaded_saved_at = driver.instance.saved_at
         loaded_saved_duration = driver.instance.saved_duration
 
         loaded_counts.should == stored_counts
-        loaded_matches.should == stored_matches
+        loaded_queues.should == stored_queues
         loaded_saved_at.should == stored_saved_at
         loaded_saved_duration.should == stored_saved_duration
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-stats-notifier
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Naotoshi Seo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-02 00:00:00.000000000 Z
+date: 2014-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd