fluent-plugin-grepcounter 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96a67e39368ff883543e1999186e185e8ad6159f
-  data.tar.gz: 8e4ff3eb1e5d9660ddd08a04bedbbcebf5098f14
+  metadata.gz: bddb5d5327eec9e655863fc3cb7c6df468ebf818
+  data.tar.gz: c5d37235947a78bdf39cb45819434f2ae0357b06
 SHA512:
-  metadata.gz: 5fb377c61e7318b2efa53d1cc76de6831d982736df5755d17b49bbcc9b869e24cdff3d28afbdbdfa21db99c960bcb3cd65083fde8a9c934030157d3b39c7558b
-  data.tar.gz: 323bdaf536cba05342c8b395599bf1235937a3cbbcb383da0a6a801d79d6a6f803e5f223b122012e9f9595049ae9d4d6a3645a3480d90e3f455fc49e4e7c3698
+  metadata.gz: 978c44205ca7867084429682d76be4c380fee8c2fc2b34e32d8855cb78c8da232c4da6430dbd0b5b98c2209c6a4a19afcdd1dbddb1e05743c08da5065b9a5f74
+  data.tar.gz: d20233e52d1732422756df141fd456401b14a31621652fa2052ca7b45e6beff327b2ea7d1e0b17d01a678e779fee3afb35667164afc647bfcc1db36ee8a41f2d

data/CHANGELOG.md

@@ -1,4 +1,10 @@
-## 0.1.3 (20130617)
+## 0.2.0 (2013/09/26)
+
+Features
+
+  - less_than, less_equal, greater_than, greater_equal
+
+## 0.1.3 (2013/06/17)
 
 Features
 

data/Gemfile

@@ -1,4 +1,3 @@
 source "http://rubygems.org"
 
-gem 'simplecov', git: 'https://github.com/colszowka/simplecov.git'
 gemspec

data/README.md

@@ -1,4 +1,4 @@
-# fluent-plugin-grepcounter [![Build Status](https://secure.travis-ci.org/sonots/fluent-plugin-grepcounter.png?branch=master)](http://travis-ci.org/sonots/fluent-plugin-grepcounter) [![Dependency Status](https://gemnasium.com/sonots/fluent-plugin-grepcounter.png)](https://gemnasium.com/sonots/fluent-plugin-grepcounter) [![Coverage Status](https://coveralls.io/repos/sonots/fluent-plugin-grepcounter/badge.png?branch=master)](https://coveralls.io/r/sonots/fluent-plugin-grepcounter)
+# fluent-plugin-grepcounter [![Build Status](https://secure.travis-ci.org/sonots/fluent-plugin-grepcounter.png?branch=master)](http://travis-ci.org/sonots/fluent-plugin-grepcounter) [![Dependency Status](https://gemnasium.com/sonots/fluent-plugin-grepcounter.png)](https://gemnasium.com/sonots/fluent-plugin-grepcounter)
 
 Fluentd plugin to count the number of matched messages.
 
@@ -74,20 +74,28 @@ Then, output bocomes as belows (indented). You can see the `message` field is jo
 
 - threshold
 
-    The threshold number to emit
+    The threshold number to emit. Emit if `count` value >= specified value.
 
-- comparator
+- comparator (obsolete from 0.2.0. Use greater\_equal or less\_equal instead)
 
     The comparation operator for the threshold (either of `>=` or `<=`). Default is `>=`, i.e., emit if count >= threshold. 
     NOTE: 0 count message will not be emitted even if `<=` is specified because standby nodes receive no message usually.
 
-- output\_with\_joined\_delimiter
+- less\_than (from 0.2.0)
+
+    A `less than` threshold value, that is, emit if `count` value < specified value.
+
+- less\_equal (from 0.2.0)
+
+    A `less than or eqaul` threshold value, that is, emit if `count` value <= specified value.
+
+- greater\_than (from 0.2.0)
 
-    Join the output message array field with the specified delimiter to make the output message be a string. 
+    A `greater than` threshold value, that is, emit if `count` value > specified value. 
 
-- aggregate
+- greater\_equal (from 0.2.0)
 
-    Count by each `tag` or `all`. The default value is `tag`. 
+    A `greater than or eqaul` threshold value, that is, emit if `count` value >= specified value. Same with `threshold` option.
 
 - output\_tag
 
@@ -97,11 +105,19 @@ Then, output bocomes as belows (indented). You can see the `message` field is jo
 
     Add tag prefix for output message
 
+- output\_with\_joined\_delimiter
+
+    Output matched messages after `join`ed with the specified delimiter.
+
 - replace\_invalid\_sequence
 
     Replace invalid byte sequence in UTF-8 with '?' character if `true`
 
-## ChaangeLog
+- store\_file
+
+    Store internal count data into a file of the given path on shutdown, and load on statring. 
+
+## ChangeLog
 
 See [CHANGELOG.md](CHANGELOG.md) for details.
 

data/fluent-plugin-grepcounter.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "fluent-plugin-grepcounter"
-  s.version     = "0.1.4"
+  s.version     = "0.2.0"
   s.authors     = ["Naotoshi SEO"]
   s.email       = ["sonots@gmail.com"]
   s.homepage    = "https://github.com/sonots/fluent-plugin-grepcounter"
@@ -21,6 +21,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec"
   s.add_development_dependency "pry"
-  s.add_development_dependency 'coveralls'
+  s.add_development_dependency "pry-nav"
   # s.add_development_dependency "delorean"
 end

data/lib/fluent/plugin/out_grepcounter.rb

@@ -2,19 +2,32 @@
 class Fluent::GrepCounterOutput < Fluent::Output
   Fluent::Plugin.register_output('grepcounter', self)
 
+  def initialize
+    super
+    require 'pathname'
+  end
+
   config_param :input_key, :string
   config_param :regexp, :string, :default => nil
   config_param :count_interval, :time, :default => 5
   config_param :exclude, :string, :default => nil
-  config_param :threshold, :integer, :default => 1
-  config_param :comparator, :string, :default => '>='
+  config_param :threshold, :integer, :default => nil # obsolete
+  config_param :comparator, :string, :default => '>=' # obsolete
+  config_param :less_than, :float, :default => nil
+  config_param :less_equal, :float, :default => nil
+  config_param :greater_than, :float, :default => nil
+  config_param :greater_equal, :float, :default => nil
   config_param :output_tag, :string, :default => nil
   config_param :add_tag_prefix, :string, :default => 'count'
   config_param :output_with_joined_delimiter, :string, :default => nil
   config_param :aggregate, :string, :default => 'tag'
   config_param :replace_invalid_sequence, :bool, :default => false
+  config_param :store_file, :string, :default => nil
 
+  attr_accessor :counts
   attr_accessor :matches
+  attr_accessor :saved_duration
+  attr_accessor :saved_at
   attr_accessor :last_checked
 
   def configure(conf)
@@ -24,12 +37,25 @@ class Fluent::GrepCounterOutput < Fluent::Output
     @input_key = @input_key.to_s
     @regexp = Regexp.compile(@regexp) if @regexp
     @exclude = Regexp.compile(@exclude) if @exclude
-    @threshold = @threshold.to_i
+
+    @threshold = @threshold.to_i if @threshold
 
     unless ['>=', '<='].include?(@comparator)
       raise Fluent::ConfigError, "grepcounter: comparator allows >=, <="
     end
 
+    # to support obsolete options
+    if @threshold.nil? and @less_than.nil? and @less_equal.nil? and @greater_than.nil? and @greater_equal.nil?
+      @threshold = 1
+    end
+    if @threshold and @comparator
+      if @comparator == '>='
+        @greater_equal = @threshold
+      else
+        @less_equal = @threshold
+      end
+    end
+
     unless ['tag', 'all'].include?(@aggregate)
       raise Fluent::ConfigError, "grepcounter: aggregate allows tag/all"
     end
@@ -41,6 +67,13 @@ class Fluent::GrepCounterOutput < Fluent::Output
       # raise Fluent::ConfigError, "grepcounter: add_tag_prefix must be specified with aggregate tag" if @add_tag_prefix.nil?
     end
 
+    if @store_file
+      f = Pathname.new(@store_file)
+      if (f.exist? && !f.writable_real?) || (!f.exist? && !f.parent.writable_real?)
+        raise Fluent::ConfigError, "#{@store_file} is not writable"
+      end
+    end
+
     @matches = {}
     @counts  = {}
     @mutex = Mutex.new
@@ -48,6 +81,7 @@ class Fluent::GrepCounterOutput < Fluent::Output
 
   def start
     super
+    load_status(@store_file, @count_interval) if @store_file
     @watcher = Thread.new(&method(:watcher))
   end
 
@@ -55,6 +89,7 @@ class Fluent::GrepCounterOutput < Fluent::Output
     super
     @watcher.terminate
     @watcher.join
+    save_status(@store_file) if @store_file
   end
 
   # Called when new line comes. This method actually does not emit
@@ -83,7 +118,7 @@ class Fluent::GrepCounterOutput < Fluent::Output
   # thread callback
   def watcher
     # instance variable, and public accessable, for test
-    @last_checked = Fluent::Engine.now
+    @last_checked ||= Fluent::Engine.now
     while true
       sleep 0.5
       begin
@@ -125,7 +160,10 @@ class Fluent::GrepCounterOutput < Fluent::Output
   def generate_output(count, matches, tag = nil)
     return nil if count.nil?
     return nil if count == 0 # ignore 0 because standby nodes receive no message usually
-    return nil unless eval("#{count} #{@comparator} #{@threshold}")
+    return nil if @less_than     and @less_than   <= count
+    return nil if @less_equal    and @less_equal  <  count
+    return nil if @greater_than  and count <= @greater_than
+    return nil if @greater_equal and count <  @greater_equal
     output = {}
     output['count'] = count
     output['message'] = @output_with_joined_delimiter.nil? ? matches : matches.join(@output_with_joined_delimiter)
@@ -157,4 +195,61 @@ class Fluent::GrepCounterOutput < Fluent::Output
     temporal_encoding = (original_encoding == Encoding::UTF_8 ? Encoding::UTF_16BE : Encoding::UTF_8)
     string.encode(temporal_encoding, original_encoding, replace_options).encode(original_encoding)
   end
+
+  # Store internal status into a file
+  #
+  # @param [String] file_path
+  def save_status(file_path)
+    begin
+      Pathname.new(file_path).open('wb') do |f|
+        @saved_at = Fluent::Engine.now
+        @saved_duration = @saved_at - @last_checked
+        Marshal.dump({
+          :counts           => @counts,
+          :matches          => @matches,
+          :saved_at         => @saved_at,
+          :saved_duration   => @saved_duration,
+          :regexp           => @regexp,
+          :exclude          => @exclude,
+          :input_key        => @input_key,
+        }, f)
+      end
+    rescue => e
+      $log.warn "out_grepcounter: Can't write store_file #{e.class} #{e.message}"
+    end
+  end
+
+  # Load internal status from a file
+  #
+  # @param [String] file_path
+  # @param [Interger] count_interval
+  def load_status(file_path, count_interval)
+    return unless (f = Pathname.new(file_path)).exist?
+    begin
+      f.open('rb') do |f|
+        stored = Marshal.load(f)
+        if stored[:regexp] == @regexp and
+          stored[:exclude] == @exclude and
+          stored[:input_key]  == @input_key
+
+          if Fluent::Engine.now <= stored[:saved_at] + count_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
+          else
+            $log.warn "out_grepcounter: stored data is outdated. ignore stored data"
+          end
+        else
+          $log.warn "out_grepcounter: configuration param was changed. ignore stored data"
+        end
+      end
+    rescue => e
+      $log.warn "out_grepcounter: Can't load store_file #{e.class} #{e.message}"
+    end
+  end
+
 end

data/spec/out_grepcounter_spec.rb

@@ -24,29 +24,17 @@ describe Fluent::GrepCounterOutput do
       end
 
       context 'invalid aggregate' do
-        let(:config) do
-          CONFIG + %[
-          aggregate foo
-          ]
-        end
+        let(:config) { CONFIG + %[aggregate foo] }
         it { expect { driver }.to raise_error(Fluent::ConfigError) }
       end
 
       context 'no tag for aggregate all' do
-        let(:config) do
-          CONFIG + %[
-          aggregate all
-          ]
-        end
+        let(:config) { CONFIG + %[aggregate all] }
         it { expect { driver }.to raise_error(Fluent::ConfigError) }
       end
 
       context 'invalid comparator' do
-        let(:config) do
-          CONFIG + %[
-          comparator foo
-          ]
-        end
+        let(:config) { CONFIG + %[comparator foo] }
         it { expect { driver }.to raise_error(Fluent::ConfigError) }
       end
     end
@@ -82,20 +70,25 @@ describe Fluent::GrepCounterOutput do
       driver.run { messages.each {|message| driver.emit({'message' => message}, time) } }
       driver.instance.flush_emit(0)
     end
-
-    context 'count_interval' do
-      pending
+    let(:expected) do
+      {
+        "count"=>4,
+        "message"=>[
+          "2013/01/13T07:02:11.124202 INFO GET /ping",
+          "2013/01/13T07:02:13.232645 WARN POST /auth",
+          "2013/01/13T07:02:21.542145 WARN GET /favicon.ico",
+          "2013/01/13T07:02:43.632145 WARN POST /login",
+        ],
+        "input_tag" => tag,
+        "input_tag_last" => tag.split('.').last,
+      }
     end
 
     context 'default' do
       let(:config) { CONFIG }
       before do
         Fluent::Engine.stub(:now).and_return(time)
-        Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, {"count"=>4,
-          "message"=>["2013/01/13T07:02:11.124202 INFO GET /ping","2013/01/13T07:02:13.232645 WARN POST /auth","2013/01/13T07:02:21.542145 WARN GET /favicon.ico","2013/01/13T07:02:43.632145 WARN POST /login"],
-          "input_tag" => tag,
-          "input_tag_last" => tag.split('.').last,
-        })
+        Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected)
       end
       it { emit }
     end
@@ -104,198 +97,258 @@ describe Fluent::GrepCounterOutput do
       let(:config) { CONFIG + %[ regexp WARN ] }
       before do
         Fluent::Engine.stub(:now).and_return(time)
-        Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, {"count"=>3,
-          "message"=>["2013/01/13T07:02:13.232645 WARN POST /auth","2013/01/13T07:02:21.542145 WARN GET /favicon.ico","2013/01/13T07:02:43.632145 WARN POST /login"],
-          "input_tag" => tag,
-          "input_tag_last" => tag.split('.').last,
-        })
+        Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected.merge({
+          "count"=>3,
+          "message"=>[
+            "2013/01/13T07:02:13.232645 WARN POST /auth",
+            "2013/01/13T07:02:21.542145 WARN GET /favicon.ico",
+            "2013/01/13T07:02:43.632145 WARN POST /login"
+          ],
+        }))
       end
       it { emit }
     end
 
     context 'exclude' do
-      let(:config) do
-        CONFIG + %[
-          regexp WARN
-          exclude favicon
-        ]
-      end
+      let(:config) { CONFIG + %[regexp WARN \n exclude favicon] }
       before do
         Fluent::Engine.stub(:now).and_return(time)
-        Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, {"count"=>2,
-          "message"=>["2013/01/13T07:02:13.232645 WARN POST /auth","2013/01/13T07:02:43.632145 WARN POST /login"],
-          "input_tag" => tag,
-          "input_tag_last" => tag.split('.').last,
-        })
+        Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected.merge({
+          "count"=>2,
+          "message"=>[
+            "2013/01/13T07:02:13.232645 WARN POST /auth",
+            "2013/01/13T07:02:43.632145 WARN POST /login"
+          ],
+        }))
       end
       it { emit }
     end
 
-    context 'threshold (hit)' do
-      let(:config) do
-        CONFIG + %[
-          regexp WARN
-          threshold 3
-        ]
+    context "threshold and comparator" do
+      context '>= threshold' do
+        let(:config) { CONFIG + %[threshold 4] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected)
+        end
+        it { emit }
       end
-      before do
-        Fluent::Engine.stub(:now).and_return(time)
-        Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, {"count"=>3,
-          "message"=>["2013/01/13T07:02:13.232645 WARN POST /auth","2013/01/13T07:02:21.542145 WARN GET /favicon.ico","2013/01/13T07:02:43.632145 WARN POST /login"],
-          "input_tag" => tag,
-          "input_tag_last" => tag.split('.').last,
-        })
+
+      context 'not >= threshold' do
+        let(:config) { CONFIG + %[threshold 5] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_not_receive(:emit)
+        end
+        it { emit }
+      end
+
+      context '<= threshold' do
+        let(:config) { CONFIG + %[threshold 4 \n comparator <=] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'not <= threshold' do
+        let(:config) { CONFIG + %[threshold 3 \n comparator <=] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_not_receive(:emit)
+        end
+        it { emit }
       end
-      it { emit }
     end
 
-    context 'threshold (miss)' do
-      let(:config) do
-        CONFIG + %[
-          regexp WARN
-          threshold 4
-        ]
+    context "less|greater_than|equal" do
+      context 'greater_equal' do
+        let(:config) { CONFIG + %[greater_equal 4] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected)
+        end
+        it { emit }
       end
-      before do
-        Fluent::Engine.stub(:now).and_return(time)
-        Fluent::Engine.should_not_receive(:emit)
+
+      context 'not greater_equal' do
+        let(:config) { CONFIG + %[greater_equal 5] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_not_receive(:emit)
+        end
+        it { emit }
+      end
+
+      context 'greater_than' do
+        let(:config) { CONFIG + %[greater_than 3] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'not greater_than' do
+        let(:config) { CONFIG + %[greater_than 4] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_not_receive(:emit)
+        end
+        it { emit }
+      end
+
+      context 'less_equal' do
+        let(:config) { CONFIG + %[less_equal 4] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'not less_equal' do
+        let(:config) { CONFIG + %[less_equal 3] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_not_receive(:emit)
+        end
+        it { emit }
+      end
+
+      context 'less_than' do
+        let(:config) { CONFIG + %[less_than 5] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'not less_than' do
+        let(:config) { CONFIG + %[less_than 4] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_not_receive(:emit)
+        end
+        it { emit }
+      end
+
+      context 'between' do
+        let(:config) { CONFIG + %[greater_than 1 \n less_than 5] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected)
+        end
+        it { emit }
+      end
+
+      context 'not between' do
+        let(:config) { CONFIG + %[greater_than 1 \n less_than 4] }
+        before do
+          Fluent::Engine.stub(:now).and_return(time)
+          Fluent::Engine.should_not_receive(:emit)
+        end
+        it { emit }
       end
-      it { emit }
     end
 
     context 'output_tag' do
-      let(:config) do
-        CONFIG + %[
-          regexp WARN
-          output_tag foo
-        ]
-      end
+      let(:config) { CONFIG + %[output_tag foo] }
       before do
         Fluent::Engine.stub(:now).and_return(time)
-        Fluent::Engine.should_receive(:emit).with("foo", time, {"count"=>3,
-          "message"=>["2013/01/13T07:02:13.232645 WARN POST /auth","2013/01/13T07:02:21.542145 WARN GET /favicon.ico","2013/01/13T07:02:43.632145 WARN POST /login"],
-          "input_tag" => tag,
-          "input_tag_last" => tag.split('.').last,
-        })
+        Fluent::Engine.should_receive(:emit).with("foo", time, expected)
       end
       it { emit }
     end
 
     context 'add_tag_prefix' do
-      let(:config) do
-        CONFIG + %[
-          regexp WARN
-          add_tag_prefix foo
-        ]
-      end
+      let(:config) { CONFIG + %[add_tag_prefix foo] }
       before do
         Fluent::Engine.stub(:now).and_return(time)
-        Fluent::Engine.should_receive(:emit).with("foo.#{tag}", time, {"count"=>3,
-          "message"=>["2013/01/13T07:02:13.232645 WARN POST /auth","2013/01/13T07:02:21.542145 WARN GET /favicon.ico","2013/01/13T07:02:43.632145 WARN POST /login"],
-          "input_tag" => tag,
-          "input_tag_last" => tag.split('.').last,
-        })
+        Fluent::Engine.should_receive(:emit).with("foo.#{tag}", time, expected)
       end
       it { emit }
     end
 
     context 'output_with_joined_delimiter' do
-      let(:config) do
-        # \\n shall be \n in config file
-        CONFIG + %[
-          regexp WARN
-          output_with_joined_delimiter \\n
-        ]
-      end
+      # \\n shall be \n in config file
+      let(:config) { CONFIG + %[output_with_joined_delimiter \\n] }
       before do
         Fluent::Engine.stub(:now).and_return(time)
-        Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, {"count"=>3, 
-          "message"=>"2013/01/13T07:02:13.232645 WARN POST /auth\\n2013/01/13T07:02:21.542145 WARN GET /favicon.ico\\n2013/01/13T07:02:43.632145 WARN POST /login",
-          "input_tag" => tag,
-          "input_tag_last" => tag.split('.').last,
-        })
+        message = expected["message"].join('\n')
+        Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, expected.merge("message" => message))
       end
       it { emit }
     end
 
     context 'aggregate all' do
+      let(:messages) { ['foobar', 'foobar'] }
       let(:emit) do
         driver.run { messages.each {|message| driver.emit_with_tag({'message' => message}, time, 'foo.bar') } }
         driver.run { messages.each {|message| driver.emit_with_tag({'message' => message}, time, 'foo.bar2') } }
         driver.instance.flush_emit(0)
       end
-
-      let(:config) do
-        CONFIG + %[
-          regexp WARN
-          aggregate all
-          output_tag count
-        ]
+      let(:expected) do
+        {
+          "count"=>messages.size*2,
+          "message"=>messages*2,
+        }
       end
+
+      let(:config) { CONFIG + %[aggregate all \n output_tag count] }
       before do
         Fluent::Engine.stub(:now).and_return(time)
-        Fluent::Engine.should_receive(:emit).with("count", time, {"count"=>3*2,
-          "message"=>["2013/01/13T07:02:13.232645 WARN POST /auth","2013/01/13T07:02:21.542145 WARN GET /favicon.ico","2013/01/13T07:02:43.632145 WARN POST /login"]*2,
-        })
+        Fluent::Engine.should_receive(:emit).with("count", time, expected)
       end
       it { emit }
     end
 
     context 'replace_invalid_sequence' do
-      let(:config) do
-        CONFIG + %[
-          regexp WARN
-          replace_invalid_sequence true
-        ]
-      end
-      let(:messages) do
-        [
-          "\xff".force_encoding('UTF-8'),
-        ]
-      end
+      let(:config) { CONFIG + %[regexp WARN \n replace_invalid_sequence true] }
+      let(:messages) { [ "\xff".force_encoding('UTF-8') ] }
       before do
         Fluent::Engine.stub(:now).and_return(time)
       end
-      it { expect { emit }.not_to raise_error(ArgumentError) }
+      it { expect { emit }.not_to raise_error }
     end
 
-    describe "comparator <=" do
-      context 'threshold (hit)' do
-        let(:config) do
-          CONFIG + %[
-          regexp WARN
-          threshold 3
-          comparator <=
-          ]
-        end
-        before do
-          Fluent::Engine.stub(:now).and_return(time)
-          Fluent::Engine.should_receive(:emit).with("count.#{tag}", time, {"count"=>3,
-            "message"=>["2013/01/13T07:02:13.232645 WARN POST /auth","2013/01/13T07:02:21.542145 WARN GET /favicon.ico","2013/01/13T07:02:43.632145 WARN POST /login"],
-            "input_tag" => tag,
-            "input_tag_last" => tag.split('.').last,
-          })
-        end
-        it { emit }
+    describe "store_file" do
+      let(:store_file) do
+        dirname = "tmp"
+        Dir.mkdir dirname unless Dir.exist? dirname
+        filename = "#{dirname}/test.dat"
+        File.unlink filename if File.exist? filename
+        filename
       end
 
-      context 'threshold (miss)' do
-        let(:config) do
-          CONFIG + %[
-          regexp WARN
-          threshold 2
-          comparator <=
-          ]
-        end
-        before do
-          Fluent::Engine.stub(:now).and_return(time)
-          Fluent::Engine.should_not_receive(:emit)
-        end
-        it { emit }
+      let(:config) { CONFIG + %[store_file #{store_file}] }
+
+      it 'stored_data and loaded_data should equal' do
+        driver.run { messages.each {|message| driver.emit({'message' => message}, time) } }
+        driver.instance.shutdown
+        stored_counts = driver.instance.counts
+        stored_matches = driver.instance.matches
+        stored_saved_at = driver.instance.saved_at
+        stored_saved_duration = driver.instance.saved_duration
+        driver.instance.counts = {}
+        driver.instance.matches = {}
+        driver.instance.saved_at = nil
+        driver.instance.saved_duration = nil
+
+        driver.instance.start
+        loaded_counts = driver.instance.counts
+        loaded_matches = driver.instance.matches
+        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_saved_at.should == stored_saved_at
+        loaded_saved_duration.should == stored_saved_duration
       end
     end
+
   end
 end
-
-
-

data/spec/spec_helper.rb

@@ -4,9 +4,6 @@ require 'bundler'
 Bundler.setup(:default, :test)
 Bundler.require(:default, :test)
 
-require 'coveralls'
-Coveralls.wear!
-
 require 'fluent/test'
 require 'rspec'
 require 'pry'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-grepcounter
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Naotoshi SEO
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-17 00:00:00.000000000 Z
+date: 2013-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fluentd
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: pry-nav
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -120,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: fluent-plugin-grepcounter
-rubygems_version: 2.0.2
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Count the number of matched messages