fluent-plugin-derive 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 51798346dc27a15ff0a23c51c4926e146c3af789
+  data.tar.gz: 16dc81bbc0e36994303602b7becc18ccf8091ff0
+SHA512:
+  metadata.gz: d2a1c43275e27ea1e9a270c6dc35aba23fa89ffd200b6d23099920188ba8deb5e4528e74e767be24ff9cc3de82b911f4c492f4d813c578c2a5a69d16685ac411
+  data.tar.gz: c13f6fede3c12711518daeb96131062032876e5a2528bf0acc6fc976a5ccf445866c509067ea771b45d8a6da67c45b40174498913ff753a114a6d544d81b3a95

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format documentation

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+gemfile:
+  - Gemfile

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fluent-plugin-derive.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Nobuhiro Nikushi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# fluent-plugin-derive
+
+Calculate per second value for the increasing/decreasing value between the last and the current, like derive in RRDTool.
+
+For example, imagine interface counter values that are inputted by SNMP polling, What we want to know is essentially the bps not the raw value. By this plug-in, the last inputted values of the specific keys and time are cached, and the per second rate for each key are culculated and re-emitted when the next record is inputted.
+
+Note that Fluentd does not guarantee the order of arrival of messages, it may not be able to calculate accurately if the messages which are tagged with same name are inputted at short intervals. So DO NOT USE this plugin in that case.
+
+I am using the derive plugin in combination with [fluent-plugin-snmp](https://github.com/iij/fluent-plugin-snmp).
+
+## Configuration
+
+### Example 1
+
+    <match foo.bar.**>
+      type derive
+      add_tag_prefix derive
+      key1 foo_count
+      key2 bar_count
+    </match>
+
+Assuming following inputs are coming:
+
+    2013-12-19 20:01:00 +0900 foo.bar: {"foo_count":  100, "bar_count":  200}
+    2013-12-19 20:02:00 +0900 foo.bar: {"foo_count":  700, "bar_count": 1400}
+    2013-12-19 20:03:10 +0900 foo.bar: {"foo_count":  700, "bar_count": 1470}
+    2013-12-19 20:04:10 +0900 foo.bar: {"foo_count": 1300, "bar_count":  870}
+
+then output becomes as below:
+
+    2013-12-19 20:01:00 +0900 derive.foo.bar: {"foo_count": nil, "bar_count": nil}
+    2013-12-19 20:02:00 +0900 derive.foo.bar: {"foo_count":  10, "bar_count":  20}
+    2013-12-19 20:03:10 +0900 derive.foo.bar: {"foo_count":   0, "bar_count":   1}
+    2013-12-19 20:04:10 +0900 derive.foo.bar: {"foo_count":  10, "bar_count": -10}
+
+Cacled as a per sec rate. See below how calced.
+
+    (700/100)/(20:02:00 - 20:01:00)  => 10
+
+### Example 2
+
+    <match foo.bar.**>
+      type derive
+      add_tag_prefix derive
+      key1 foo_count *1000
+      key2 bar_count *1000
+    </match>
+
+Assuming following inputs are coming:
+
+    2013-12-19 20:01:00 +0900 foo.bar: {"foo_count":  100, "bar_count":  200}
+    2013-12-19 20:02:00 +0900 foo.bar: {"foo_count":  700, "bar_count": 1400}
+    2013-12-19 20:03:10 +0900 foo.bar: {"foo_count":  700, "bar_count": 1470}
+    2013-12-19 20:04:10 +0900 foo.bar: {"foo_count": 1300, "bar_count":  870}
+
+then output becomes as below:
+
+    2013-12-19 20:01:00 +0900 derive.foo.bar: {"foo_count":   nil, "bar_count":    nil}
+    2013-12-19 20:02:00 +0900 derive.foo.bar: {"foo_count": 10000, "bar_count":  20000}
+    2013-12-19 20:03:10 +0900 derive.foo.bar: {"foo_count":     0, "bar_count":   1000}
+    2013-12-19 20:04:10 +0900 derive.foo.bar: {"foo_count": 10000, "bar_count": -10000}
+
+## Paramteres
+* key[1-20] [Adjustment]
+
+A pair of a field name of the input record, and to be calculated. key1 or key_pattern is required. `Adjustment` is optional.
+
+Use `Adjustment` like follow:
+
+    key1 foo_count *3600000 => output the rate as K/h
+    key1 foo_count *8       => shift unit (e.g. Byteps to bps)
+    key1 foo_count /1000    => shift unit (e.g. M to K)
+
+* key_pattern [Adjustment]
+
+A pair of a regular expression to specify field names of the input record, and to be calculated. key1 or key_pattern is required. `Adjustment` is optional.
+
+* tag
+
+The output tag name
+
+* add_tag_prefix
+
+Add tag prefix for output message
+
+* remove_tag_prefix
+
+Remove tag prefix for output message
+
+* min
+
+Define the expected range value. If min and/or max are specified any value outside the defined range will be truncated.
+
+* max
+
+Define the expected range value. If min and/or max are specified any value outside the defined range will be truncated.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/fluent-plugin-derive.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "fluent-plugin-derive"
+  spec.version       = "0.0.1"
+  spec.authors       = ["Nobuhiro Nikushi"]
+  spec.email         = ["deneb.ge@gmail.com"]
+  spec.description   = spec.summary
+  spec.summary       = "fluentd plugin to derive rate"
+  spec.homepage      = "https://github.com/niku4i/fluent-plugin-derive"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "fluentd"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/fluent/plugin/out_derive.rb

@@ -0,0 +1,175 @@
+class Fluent::DeriveOutput < Fluent::Output
+  Fluent::Plugin.register_output('derive', self)
+
+  KEY_MAX_NUM = 20
+  (1..KEY_MAX_NUM).each {|i| config_param "key#{i}".to_sym, :string, :default => nil }
+  config_param :key_pattern, :string, :default => nil
+  config_param :tag, :string, :default => nil
+  config_param :add_tag_prefix, :string, :default => nil
+  config_param :remove_tag_prefix, :string, :default => nil
+  config_param :min, :integer, :default => nil
+  config_param :max, :integer, :default => nil
+
+  # for test
+  attr_reader :key_pattern
+  attr_reader :key_pattern_adjustment
+  attr_reader :keys
+  attr_reader :prev
+
+  def configure(conf)
+    super
+
+    if @key_pattern
+      key_pattern, @key_pattern_adjustment = @key_pattern.split(/ +/, 2)
+      @key_pattern_adjustment = parse_adjustment(@key_pattern_adjustment)
+      @key_pattern = Regexp.compile(key_pattern)
+    else
+      @keys = {}
+      (1..KEY_MAX_NUM).each do |i|
+        next unless conf["key#{i}"] 
+        key, adjustment = conf["key#{i}"].split(/ +/, 2)
+        adjustment = parse_adjustment(adjustment)
+        @keys[key] = adjustment
+      end
+    end
+    raise Fluent::ConfigError, "Either of `key_pattern` or `key1` must be specified" if (@key_pattern.nil? and @keys.empty?)
+
+    raise Fluent::ConfigError, "Either of `tag`, `add_tag_prefix`, or `remove_tag_prefix` must be specified" if (@tag.nil? and @add_tag_prefix.nil? and @remove_tag_prefix.nil?)
+    @tag_prefix = "#{@add_tag_prefix}." if @add_tag_prefix
+    @tag_prefix_match = "#{@remove_tag_prefix}." if @remove_tag_prefix
+    @tag_proc =
+      if @tag
+        Proc.new {|tag| @tag }
+      elsif @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}" }
+      else
+        Proc.new {|tag| tag }
+      end
+
+    raise Fluent::ConfigError, "`max` must be greater than `min`" if (@min && @max && @min >= @max)
+
+    @prev = {}
+    @mutex = Mutex.new
+  rescue => e
+    raise Fluent::ConfigError, "#{e.class} #{e.message} #{e.backtrace.first}"
+  end
+
+  def start
+    super
+  end
+
+  def shutdown
+    super
+  end
+
+  def emit(tag, es, chain)
+    emit_tag = @tag_proc.call(tag)
+
+    if @key_pattern
+      es.each do |time, record|
+        record.each do |key, value|
+          next unless key =~ @key_pattern
+          value = value.to_i
+          prev_time, prev_value = get_prev_value(tag, key)
+          unless prev_time && prev_value
+            save_to_prev(time, tag, key, value)
+            record[key] = nil
+            next
+          end
+          # adjustment
+          rate = calc_rate(tag, key, value, prev_value, time, prev_time, @key_pattern_adjustment)
+          rate = truncate_min(rate, @min) if @min
+          rate = truncate_max(rate, @max) if @max
+          # Set new value
+          record[key] = rate
+          save_to_prev(time, tag, key, value)
+        end
+        Fluent::Engine.emit(emit_tag, time, record)
+      end
+    else #keys
+      es.each do |time, record|
+        @keys.each do |key, adjustment|
+          next unless  value = record[key]
+          value = value.to_i
+          prev_time, prev_value = get_prev_value(tag, key)
+          unless prev_time && prev_value
+            save_to_prev(time, tag, key, value)
+            record[key] = nil
+            next
+          end
+          # adjustment
+          rate = calc_rate(tag, key, value, prev_value, time, prev_time, adjustment)
+          rate = truncate_min(rate, @min) if @min
+          rate = truncate_max(rate, @max) if @max
+          # Set new value
+          record[key] = rate
+          save_to_prev(time, tag, key, value)
+        end
+        Fluent::Engine.emit(emit_tag, time, record)
+      end
+    end
+
+    chain.next
+  rescue => e
+    $log.warn e.message
+    $log.warn e.backtrace.join(', ')
+  end
+
+  # @return [Array] time, value
+  def get_prev_value(tag, key)
+    @prev["#{tag}:#{key}"] || []
+  end
+
+  def save_to_prev(time, tag, key, value)
+    @mutex.synchronize { @prev["#{tag}:#{key}"] = [time, value] }
+  end
+
+  private
+
+  def lstrip(string, substring)
+    string.index(substring) == 0 ? string[substring.size..-1] : string
+  end
+
+  def parse_adjustment(str)
+    case str
+    when /^\*(\d+)$/
+      ['*', $1.to_i]
+    when /^\/(\d+)$/
+      ['/', $1.to_i]
+    else
+      nil
+    end
+  end
+
+  def calc_rate(tag, key, cur_value, prev_value, cur_time, prev_time, adjustment = nil)
+    if cur_time - prev_time <= 0
+      $log.warn "Could not calculate the rate. multiple input less than one second or minus delta of seconds on tag=#{tag}, key=#{key}"
+      return nil
+    end
+    rate = (cur_value - prev_value)/(cur_time - prev_time)
+    if adjustment && adjustment[0] == '*'
+      rate * adjustment[1]
+    elsif adjustment && adjustment[0] == '/'
+      rate / adjustment[1]
+    else
+      rate
+    end
+  end
+
+  def truncate_min(value, min)
+    return nil unless value
+    (value < min) ? min : value
+  end
+
+  def truncate_max(value, max)
+    return nil unless value
+    (value > max) ? max : value
+  end
+
+
+end
+

data/spec/out_derive_bench.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+require_relative 'spec_helper'
+
+# setup
+Fluent::Test.setup
+config = %[
+  remove_tag_prefix foo
+  add_tag_prefix hoge
+  key1 foooooo_baaaaaa_count *1000
+  key2 hogeeee_fugaaaa_count *1500
+  min 0
+  max 1000000000
+]
+
+time = Time.now.to_i
+tag = 'foo.bar'
+driver = Fluent::Test::OutputTestDriver.new(Fluent::DeriveOutput, tag).configure(config)
+
+# bench
+require 'benchmark'
+message = "2013/01/13T07:02:11.124202 INFO GET /ping"
+n = 100000
+Benchmark.bm(7) do |x|
+  x.report { driver.run { n.times do |i|
+    time = time + i*60
+    driver.emit({'foooooo_baaaaaa_count' => 1234, 'hogeeee_fugaaaa_count' => 5000, 'unmached_keeeeee' => "abvc" }, time)
+  end
+  } }
+end
+
+# key_pattern without adjustment
+#              user     system      total        real
+#                        2.920000   0.030000   2.950000 (  3.466375)
+#
+# key_pattern with adjustment
+#              user     system      total        real
+#                        3.000000   0.040000   3.040000 (  3.550168)
+#
+# key1 without adjustment and key2 without adjustment
+#              user     system      total        real
+#                        2.520000   0.030000   2.550000 (  3.058561)
+#
+# key1 with adjustment and key2 with adjustment
+#              user     system      total        real
+#                        2.630000   0.030000   2.660000 (  3.180860)
+#
+# key1 with adjustment, key2 with adjustment, min and max
+#              user     system      total        real
+#                        2.650000   0.040000   2.690000 (  3.188757)

data/spec/out_derive_spec.rb

@@ -0,0 +1,289 @@
+# encoding: UTF-8
+require_relative 'spec_helper'
+
+describe Fluent::DeriveOutput do
+  before { Fluent::Test.setup }
+  let(:tag) { 'counter.host1' }
+  let(:driver) { Fluent::Test::OutputTestDriver.new(Fluent::DeriveOutput, tag).configure(config) }
+
+  describe 'test configure' do
+    describe 'bad configuration' do
+      context 'none of key_pattern or key1 are included' do
+        let(:config) { "" }
+        it { expect { driver }.to raise_error(Fluent::ConfigError) }
+      end
+      context 'none of tag, add_tag_prefix, or remove_tag_prefix are included' do
+        let(:config) { "key1 foo" }
+      end
+      context 'min greater than max' do
+        let(:config) {%[
+          tag rate
+          key1 foo_count
+          min 1
+          max 0
+        ]}
+        it { expect { driver }.to raise_error(Fluent::ConfigError) }
+      end
+      context 'min == max' do
+        let(:config) {%[
+          tag rate
+          key1 foo_count
+          min 1
+          max 1
+        ]}
+        it { expect { driver }.to raise_error(Fluent::ConfigError) }
+      end
+    end
+
+    describe 'good configuration' do
+      subject { driver.instance }
+      
+      context "check default" do
+        let(:config) { %[
+          tag rate
+          key1 foo
+        ] }
+        its(:tag) { should eq "rate" }
+        its(:add_tag_prefix) { should be_nil }
+        its(:remove_tag_prefix) { should be_nil }
+        its(:min) { should be_nil }
+        its(:max) { should be_nil }
+      end
+
+      context "key_pattern" do
+        let(:config) {%[
+          tag rate
+          key_pattern _count$
+        ]}
+        it { subject.key_pattern.should == Regexp.compile("_count$") }
+      end
+
+      context "key_pattern_adjustment" do
+        let(:config) {%[
+          tag rate
+          key_pattern _count$ *1000
+        ]}
+        it { subject.key_pattern_adjustment.should eq ['*', 1000] }
+      end
+
+      context "keys" do
+        let(:config) {%[
+          tag rate
+          key1 foo_count
+          key2 bar_count
+        ]}
+        it { subject.keys["foo_count"].should be_nil }
+        it { subject.keys["bar_count"].should be_nil }
+      end
+
+      context "keys adjustment" do
+        let(:config) {%[
+          tag rate
+          key1 foo_count *1000
+          key2 bar_count /1000
+        ]}
+        it { subject.keys["foo_count"].should eq ['*', 1000] }
+        it { subject.keys["bar_count"].should eq ['/', 1000] }
+      end
+
+      context 'min < max' do
+        let(:config) {%[
+          tag rate
+          key1 foo_count
+          min 0
+          max 1
+        ]}
+        it { expect { driver }.not_to raise_error(Fluent::ConfigError) }
+      end
+ 
+    end
+  end
+
+  describe 'test emit' do
+    let(:time) { Time.now.to_i }
+
+    context 'keys' do
+
+      context 'normal' do
+        let(:config) { %[
+          tag rate
+          key1 foo_count
+          key2 bar_count
+        ]}
+        before do
+          driver.run { 
+            driver.emit({'foo_count'=> 100, 'bar_count' =>200, 'other_key' => 'abc'}, time) 
+            driver.emit({'foo_count'=> 700, 'bar_count' =>1400}, time + 60) 
+            driver.emit({'foo_count'=> 700, 'bar_count' =>800}, time + 120) 
+          }
+        end
+        it {
+          driver.emits[0].should == ['rate', time, {'foo_count' => nil, 'bar_count' => nil, 'other_key' => 'abc'}]
+          driver.emits[1].should == ['rate', time + 60, {'foo_count' => 10, 'bar_count' => 20}]
+          driver.emits[2].should == ['rate', time + 120, {'foo_count' => 0, 'bar_count' => -10}]
+          driver.instance.prev.should == {"#{tag}:foo_count"=>[time+120, 700], "#{tag}:bar_count"=>[time+120, 800]}
+        }
+      end
+
+      context 'multiple records in same time' do
+        let(:config) { %[
+          tag rate
+          key1 foo_count
+          key2 bar_count
+        ]}
+        before do
+          driver.run { 
+            driver.emit({'foo_count'=> 100, 'bar_count' =>200}, time) 
+            driver.emit({'foo_count'=> 100, 'bar_count' =>200}, time) 
+          }
+        end
+        it {
+          driver.emits[1].should == ['rate', time, {'foo_count' => nil, 'bar_count' => nil}]
+        }
+      end
+
+      context 'adjustment' do
+        let(:config) { %[ 
+          tag rate
+          key1 foo_count
+          key2 bar_count
+          key3 baz_count *1000
+        ]}
+        before do
+          driver.run {
+            driver.emit({'foo_count'=> 100, 'bar_count' =>200, 'baz_count' => 300}, time) 
+            driver.emit({'foo_count'=> 700, 'bar_count' =>1400, 'baz_count' => 900}, time + 60) 
+          }
+        end
+        it {
+          driver.emits[0].should == ['rate', time, {'foo_count' => nil, 'bar_count' => nil, 'baz_count' => nil}]
+          driver.emits[1].should == ['rate', time + 60, {'foo_count' => 10, 'bar_count' => 20, 'baz_count' => 10000}]
+        }
+      end
+
+      context 'min/max' do
+        let(:config) { %[ 
+          tag rate
+          key1 foo_count
+          key2 bar_count *1000000
+          min 0
+          max 1000
+        ]}
+        before do
+          driver.run {
+            driver.emit({'foo_count'=> 100, 'bar_count'=>0}, time) 
+            driver.emit({'foo_count'=> 0,   'bar_count'=>6000}, time + 60) 
+          }
+        end
+        it {
+          driver.emits[1].should == ['rate', time + 60, {'foo_count' => 0, 'bar_count' => 1000}]
+        }
+      end
+
+      context 'add_tag_prefix' do
+        let(:config) {%[
+          add_tag_prefix rate
+          key1 foo_count
+          key2 bar_count
+        ]}
+        before do
+          driver.run { 
+            driver.emit({'foo_count'=> 100, 'bar_count' =>200, 'other_key' => 'abc'}, time) 
+          }
+        end
+        it { driver.emits[0][0].should == "rate.#{tag}" }
+      end
+
+      context 'remove_tag_prefix' do
+        let(:config) {%[
+          remove_tag_prefix counter
+          key1 foo_count
+          key2 bar_count
+        ]}
+        before do
+          driver.run { 
+            driver.emit({'foo_count'=> 100, 'bar_count' =>200, 'other_key' => 'abc'}, time) 
+          }
+        end
+        it { driver.emits[0][0].should == 'host1' }
+      end
+    end
+
+    context 'key_pattern' do
+
+      context 'normal' do
+        let(:config) { %[
+          tag rate
+          key_pattern .*_count$
+        ]}
+        before do
+          driver.run { 
+            driver.emit({'foo_count'=> 100, 'bar_count' =>200, 'other_key' => 'abc'}, time) 
+            driver.emit({'foo_count'=> 700, 'bar_count' =>1400}, time + 60) 
+            driver.emit({'foo_count'=> 700, 'bar_count' =>800}, time + 120) 
+          }
+        end
+        it {
+          driver.emits[0].should == ['rate', time, {'foo_count' => nil, 'bar_count' => nil, 'other_key' => 'abc'}]
+          driver.emits[1].should == ['rate', time + 60, {'foo_count' => 10, 'bar_count' => 20}]
+          driver.emits[2].should == ['rate', time + 120, {'foo_count' => 0, 'bar_count' => -10}]
+          driver.instance.prev.should == {"#{tag}:foo_count"=>[time+120, 700], "#{tag}:bar_count"=>[time+120, 800]}
+        }
+      end
+
+      context 'multiple records in same time' do
+        let(:config) { %[
+          tag rate
+          key_pattern .*_count$
+        ]}
+        before do
+          driver.run { 
+            driver.emit({'foo_count'=> 100, 'bar_count' =>200}, time) 
+            driver.emit({'foo_count'=> 100, 'bar_count' =>200}, time) 
+          }
+        end
+        it {
+          driver.emits[1].should == ['rate', time, {'foo_count' => nil, 'bar_count' => nil}]
+        }
+      end
+
+      context 'adjustment' do
+        let(:config) { %[ 
+          tag rate
+          key_pattern .*_count$ /10
+        ]}
+        before do
+          driver.run {
+            driver.emit({'foo_count'=> 100, 'bar_count' =>200, 'baz_count' => 300}, time) 
+            driver.emit({'foo_count'=> 700, 'bar_count' =>1400, 'baz_count' => 900}, time + 60) 
+          }
+        end
+        it {
+          driver.emits[0].should == ['rate', time, {'foo_count' => nil, 'bar_count' => nil, 'baz_count' => nil}]
+          driver.emits[1].should == ['rate', time + 60, {'foo_count' => 1, 'bar_count' => 2, 'baz_count' => 1}]
+        }
+      end
+
+      context 'min/max' do
+        let(:config) { %[ 
+          tag rate
+          key_pattern .*_count$ *10000
+          min 0
+          max 1000
+        ]}
+        before do
+          driver.run {
+            driver.emit({'foo_count'=> 100, 'bar_count'=>0}, time) 
+            driver.emit({'foo_count'=> 0,   'bar_count'=>6000}, time + 60) 
+          }
+        end
+        it {
+          driver.emits[1].should == ['rate', time + 60, {'foo_count' => 0, 'bar_count' => 1000}]
+        }
+      end
+
+
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :test)
+Bundler.require(:default, :test)
+
+require 'fluent/test'
+require 'rspec'
+
+$TESTING=true
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'fluent/plugin/out_derive'
+

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: fluent-plugin-derive
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nobuhiro Nikushi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- deneb.ge@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- fluent-plugin-derive.gemspec
+- lib/fluent/plugin/out_derive.rb
+- spec/out_derive_bench.rb
+- spec/out_derive_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/niku4i/fluent-plugin-derive
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: fluentd plugin to derive rate
+test_files:
+- spec/out_derive_bench.rb
+- spec/out_derive_spec.rb
+- spec/spec_helper.rb