fluent-plugin-mongokpi 0.0.0

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/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,14 @@
+Copyright (c) 2013- Hatayama Hideharu
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

data/README.md

@@ -0,0 +1,30 @@
+# Fluent::Plugin::Mongokpi
+
+Fluent BufferedOutput plugin: counting chunk, inserting counts to make kpi count on MongoDB
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'fluent-plugin-mongokpi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fluent-plugin-mongokpi
+
+## Usage
+
+    m(_ _)m
+
+## 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,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test
+

data/fluent-plugin-mongokpi.gemspec

@@ -0,0 +1,26 @@
+# 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-mongokpi"
+  spec.version       = "0.0.0"
+  spec.authors       = ["Hatayama Hideharu"]
+  spec.email         = ["h.hiddy@gmail.com"]
+  spec.description   = %q{Fluent BufferedOutput plugin: counting chunk, inserting counts to make kpi count on MongoDB}
+  spec.summary       = spec.description
+  spec.homepage      = "https://bitbucket.org/hidepiy/fluent-plugin-mongokpi"
+  spec.license       = "APLv2"
+
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_runtime_dependency "fluentd"
+  spec.add_dependency "mongo", "1.9.2"
+  spec.add_dependency "bson_ext", "1.9.2"
+end
+

data/lib/fluent/plugin/out_mongokpi.rb

@@ -0,0 +1,358 @@
+module Fluent
+  class MongoKpiOutput < Fluent::BufferedOutput
+    # Register plugin first. NAME is the name of this plugin
+    # which is used in the configuration file.
+    Plugin.register_output('mongokpi', self)
+    
+    # Mongo client settings
+    config_param :address,    :string, :default => 'localhost:27017'
+    config_param :db,         :string, :default => 'kpidb'
+    config_param :collection, :string, :default => 'kpiColyyyymmdd'
+    # Mongo connection options
+    config_param :write_concern,    :integer, :default => nil
+    config_param :name,             :string,  :default => nil
+    config_param :read,             :string,  :default => nil
+    config_param :refresh_mode,     :string,  :default => nil
+    config_param :refresh_interval, :integer, :default => nil
+    # collection options
+    config_param :capped_size, :integer, :default => 0
+    config_param :capped_max,  :integer, :default => 0
+    # KPI count options
+    config_param :time_key,    :string, :default => nil
+    config_param :time_format, :string, :default => nil
+    config_param :count_key,   :string, :default => 'none'
+    config_param :count_name,  :string, :default => 'count'
+    # access count options
+    config_param :kpi_type, :string, :default => nil # use 'access' for activating access count.
+    config_param :responseThreshold, :integer, :default => 1000000
+    config_param :f_code,          :string, :default => 'code'
+    config_param :f_response_time, :string, :default => 'response_time'
+
+    
+    attr_reader :collections_opts, :connection_opts
+
+    def initialize
+      super
+      require 'date'
+      require 'mongo'
+      require 'msgpack'
+    end
+
+    # This method is called before starting.
+    # 'conf' is a Hash that includes configuration parameters.
+    # If the configuration is invalid, raise Fluent::ConfigError.
+    def configure(conf)
+      super
+      @connection_opts = {}
+      @connection_opts[:w] = @write_concern unless @write_concern.nil?
+      @connection_opts[:name] = @name unless @name.nil?
+      @connection_opts[:read] = @read unless @read.nil?
+      @connection_opts[:refresh_mode] = @refresh_mode unless @refresh_mode.nil?
+      @connection_opts[:refresh_interval] = @refresh_interval unless @refresh_interval.nil?
+      @collections_opts = {}
+      if @capped_size > 0
+        @collections_opts[:capped] = true
+        @collections_opts[:size] = Config.size_value(conf['capped_size'])
+        @collections_opts[:max] = Config.size_value(conf['capped_max']) if @capped_max
+      else
+        @collections_opts[:capped] = false
+      end
+    end
+
+    # This method is called when starting.
+    # Open sockets or files here.
+    def start
+      super
+      @client = get_client(@address, @connection_opts)
+    end
+    
+    # This method is called when shutting down.
+    # Shutdown the thread and close sockets or files here.
+    def shutdown
+      @client.db.connection.close
+      super
+    end
+
+    # This method is called when an event is reached.
+    # Convert event to a raw string.
+    #def format(tag, time, record)
+    #  [tag, time, record].to_json + "\n"
+    #end
+    ## optionally, you can use to_msgpack to serialize the object.
+    #def format(tag, time, record)
+    #  [tag, time, record].to_msgpack
+    #end
+    def format(tag, time, record)
+      [tag, time, record].to_msgpack
+    end
+
+    # This method is called every flush interval. write the buffer chunk to files or databases here.
+    # 'chunk' is a buffer chunk that includes multiple formatted events.
+    # You can use 'data = chunk.read' to get all events and 'chunk.open {|io| ... }' to get IO object.
+    #def write(chunk)
+    #  data = chunk.read
+    #  print data
+    #end
+    ## optionally, you can use chunk.msgpack_each to deserialize objects.
+    #def write(chunk)
+    #  chunk.msgpack_each {|(tag,time,record)|
+    #  }
+    #end
+    def write(chunk)
+      doc_hash = get_insert_doc_hash(@kpi_type, chunk, @time_key, @time_format, @count_key, @count_name)
+      insert(@kpi_type, @collection, @count_key, @count_name, doc_hash)
+    end
+    
+    def get_client(address, connection_opts)
+      begin
+        if address.include?(',')
+          return Mongo::MongoReplicaSetClient.new(address.split(','), connection_opts)
+        else
+          host_port = address.split(':', 2)
+          return Mongo::MongoClient.new(host_port[0], host_port[1], collections_opts)
+        end
+      rescue Mongo::ConnectionFailure => e
+        $log.fatal "Failed to connect to 'mongod'. Please restart 'fluentd' after 'mongod' started: #{e}"
+        exit!
+      rescue Mongo::OperationFailure => e
+        $log.fatal "Operation failed. Probably, 'mongod' needs an authentication: #{e}"
+        exit!
+      end
+    end
+    
+    def get_collection(collection_name, yyyymmdd)
+      converted_collection_name = convert_collection_name(collection_name, yyyymmdd)
+      if @current_collection.nil? || @current_collection.name != converted_collection_name
+        $log.info "Start using collection: #{converted_collection_name}"
+        @current_collection = get_collection_from_db(@client, @db, converted_collection_name, @collections_opts)
+      end
+      return @current_collection
+    end
+    
+    def convert_collection_name(collection_name, yyyymmdd) 
+      return collection_name.sub('yyyymmdd', yyyymmdd)
+    end
+
+    def get_collection_from_db(client, db_name, collection_name, collections_opts)
+      return client.db(db_name).collection(collection_name, @collections_opts)
+    end
+    
+    def get_insert_doc_hash(kpi_type, chunk, time_key, time_format, count_key, count_name)
+      hash_counter = {}
+      chunk.msgpack_each { |tag, time, record|
+        $log.debug record
+        tmp_time = time_key.nil? ? Time.at(time)
+                                 : time_format.nil? ? DateTime.parse(record[time_key])
+                                                    : DateTime.strptime(record[time_key], time_format)
+        # with count_key
+        if 'none' != count_key
+          count_key_value = ''
+          count_key.split(',').each { |x| count_key_value += record[x].to_s }
+          key_str = count_key_value + tmp_time.strftime('%Y%m%d%H%M')
+          doc = hash_counter.key?(key_str) ? hash_counter[key_str]
+                  : get_doc(kpi_type, count_key, count_key_value, count_name, tmp_time)
+          hash_counter[key_str] = count_up(kpi_type, doc, record, count_name, tmp_time)
+        end
+        # total
+        total_key_str = 'total' + tmp_time.strftime('%Y%m%d%H%M')
+        total = hash_counter.key?(total_key_str) ? hash_counter[total_key_str]
+                  : get_doc(kpi_type, count_key, 'total', count_name, tmp_time)
+        hash_counter[total_key_str] = count_up(kpi_type, total, record, count_name, tmp_time)
+      }
+      return hash_counter
+    end
+    
+    def get_doc(kpi_type, count_key, count_key_value, count_name, time)
+      doc = {}
+      doc[count_key] = count_key_value
+      doc['yyyymmdd'] = time.strftime('%Y%m%d')
+      doc['hh'] = time.strftime('%H')
+      doc['mm'] = time.strftime('%M')
+      doc[count_name] = 0
+      if 'access' == kpi_type
+        doc['countOver'] = 0
+        doc['count1xx'] = 0
+        doc['count2xx'] = 0
+        doc['count3xx'] = 0
+        doc['count4xx'] = 0
+        doc['count5xx'] = 0
+        doc['responseTimeAve'] = 0
+        doc['responseTimeMax'] = 0
+        doc['responseTimeMin'] = 100000000.00
+        doc['responseTimeSum'] = 0
+        doc['qpsAve'] = 0
+        doc['qpsMax'] = 0
+        doc['qpsMin'] = 100000000
+        doc['okRatio'] = 0.00
+        doc['counter'] = Array.new(60, 0)
+      end
+      return doc
+    end
+    
+    def count_up(kpi_type, doc, record, count_name, time)
+      doc[count_name] += 1
+      if 'access' == kpi_type
+        response_time = record.key?(@f_response_time) ? record[@f_response_time].to_i : 0
+        if response_time > @responseThreshold
+          doc['countOver'] += 1
+        end
+        case record[@f_code].to_i / 100
+          when 1 then doc['count1xx'] += 1
+          when 2 then doc['count2xx'] += 1
+          when 3 then doc['count3xx'] += 1
+          when 4 then doc['count4xx'] += 1
+          when 5 then doc['count5xx'] += 1
+        end
+        if doc['responseTimeMax'] < response_time
+          doc['responseTimeMax'] = response_time
+        end
+        if doc['responseTimeMin'] > response_time
+          doc['responseTimeMin'] = response_time
+        end
+        doc['responseTimeSum'] += response_time
+        doc['counter'][time.strftime('%S').to_i] += 1
+      end
+      return doc
+    end
+    
+    def insert(kpi_type, collection_name, count_key, count_name, doc_hash)
+      begin
+        doc_hash.each { |key, doc|
+          $log.debug doc
+          collection = get_collection(collection_name, doc['yyyymmdd'])
+          # 2.5 or less
+          # http://stackoverflow.com/questions/8508663/calculate-max-value-in-an-atomic-findandmodify-operation
+          # TODO improve for Mongo 2.6
+          # $min, $max field update operators
+          # https://jira.mongodb.org/browse/SERVER-1534
+          # https://jira.mongodb.org/browse/DOCS-2012
+          if 'access' == kpi_type
+            collection.update(
+              {'_id' => key, count_key => doc[count_key],
+                'yyyymmdd' => doc['yyyymmdd'], 'hh' => doc['hh'], 'mm' => doc['mm']},
+              {'$setOnInsert' => {'counter' => Array.new(60, 0)}},
+              {:upsert => true}
+            )
+            collection.update(
+              {'_id' => key, count_key => doc[count_key],
+                'yyyymmdd' => doc['yyyymmdd'], 'hh' => doc['hh'], 'mm' => doc['mm']},
+              {'$inc' => {
+                count_name => doc[count_name],
+                'countOver' => doc['countOver'],
+                'count1xx' => doc['count1xx'],
+                'count2xx' => doc['count2xx'],
+                'count3xx' => doc['count3xx'],
+                'count4xx' => doc['count4xx'],
+                'count5xx' => doc['count5xx'],
+                'responseTimeSum' => doc['responseTimeSum'],
+                'counter.0' => doc['counter'][0],
+                'counter.1' => doc['counter'][1],
+                'counter.2' => doc['counter'][2],
+                'counter.3' => doc['counter'][3],
+                'counter.4' => doc['counter'][4],
+                'counter.5' => doc['counter'][5],
+                'counter.6' => doc['counter'][6],
+                'counter.7' => doc['counter'][7],
+                'counter.8' => doc['counter'][8],
+                'counter.9' => doc['counter'][9],
+                'counter.10' => doc['counter'][10],
+                'counter.11' => doc['counter'][11],
+                'counter.12' => doc['counter'][12],
+                'counter.13' => doc['counter'][13],
+                'counter.14' => doc['counter'][14],
+                'counter.15' => doc['counter'][15],
+                'counter.16' => doc['counter'][16],
+                'counter.17' => doc['counter'][17],
+                'counter.18' => doc['counter'][18],
+                'counter.19' => doc['counter'][19],
+                'counter.20' => doc['counter'][20],
+                'counter.21' => doc['counter'][21],
+                'counter.22' => doc['counter'][22],
+                'counter.23' => doc['counter'][23],
+                'counter.24' => doc['counter'][24],
+                'counter.25' => doc['counter'][25],
+                'counter.26' => doc['counter'][26],
+                'counter.27' => doc['counter'][27],
+                'counter.28' => doc['counter'][28],
+                'counter.29' => doc['counter'][29],
+                'counter.30' => doc['counter'][30],
+                'counter.31' => doc['counter'][31],
+                'counter.32' => doc['counter'][32],
+                'counter.33' => doc['counter'][33],
+                'counter.34' => doc['counter'][34],
+                'counter.35' => doc['counter'][35],
+                'counter.36' => doc['counter'][36],
+                'counter.37' => doc['counter'][37],
+                'counter.38' => doc['counter'][38],
+                'counter.39' => doc['counter'][39],
+                'counter.40' => doc['counter'][40],
+                'counter.41' => doc['counter'][41],
+                'counter.42' => doc['counter'][42],
+                'counter.43' => doc['counter'][43],
+                'counter.44' => doc['counter'][44],
+                'counter.45' => doc['counter'][45],
+                'counter.46' => doc['counter'][46],
+                'counter.47' => doc['counter'][47],
+                'counter.48' => doc['counter'][48],
+                'counter.49' => doc['counter'][49],
+                'counter.50' => doc['counter'][50],
+                'counter.51' => doc['counter'][51],
+                'counter.52' => doc['counter'][52],
+                'counter.53' => doc['counter'][53],
+                'counter.54' => doc['counter'][54],
+                'counter.55' => doc['counter'][55],
+                'counter.56' => doc['counter'][56],
+                'counter.57' => doc['counter'][57],
+                'counter.58' => doc['counter'][58],
+                'counter.59' => doc['counter'][59]
+              }},
+              {:upsert => true}
+            )
+            updated_doc_array = collection.find({'_id' => key}).to_a
+            $log.debug updated_doc_array
+            continue if updated_doc_array.nil?
+            updated_doc = updated_doc_array[0]
+            response_time_ave = updated_doc['responseTimeSum'] / doc[count_name]
+            if !updated_doc['responseTimeMax'].nil? && updated_doc['responseTimeMax'] > doc['responseTimeMax']
+              response_time_max = updated_doc['responseTimeMax']
+            else
+              response_time_max = doc['responseTimeMax']
+            end
+            if !updated_doc['responseTimeMin'].nil? && updated_doc['responseTimeMin'] < doc['responseTimeMin']
+              response_time_min = updated_doc['responseTimeMin']
+            else
+              response_time_min = doc['responseTimeMin']
+            end
+            qps_ave = (updated_doc['counter'].inject(0.0){|r,i| r+=i } / updated_doc['counter'].size).round
+            qps_max = updated_doc['counter'].max
+            qps_min = updated_doc['counter'].min
+            ok_ratio = ((updated_doc[count_name] - updated_doc['countOver']).to_f / updated_doc[count_name]).round(4)
+            collection.update(
+              {'_id' => key, count_key => doc[count_key],
+                'yyyymmdd' => doc['yyyymmdd'], 'hh' => doc['hh'], 'mm' => doc['mm']},
+              { '$set' => {
+              'responseTimeAve' => response_time_ave,
+              'responseTimeMax' => response_time_max,
+              'responseTimeMin' => response_time_min,
+              'qpsAve' => qps_ave,
+              'qpsMax' => qps_max,
+              'qpsMin' => qps_min,
+              'okRatio' => ok_ratio
+              }}
+            )
+          else
+            collection.update(
+              {'_id' => key, count_key => doc[count_key],
+                'yyyymmdd' => doc['yyyymmdd'], 'hh' => doc['hh'], 'mm' => doc['mm']},
+              {'$inc' => {count_name => doc[count_name]}},
+              {:upsert => true}
+            )
+          end
+        }
+      rescue Mongo::OperationFailure => e
+        raise e
+      end
+    end
+  end
+end
+

data/test/fluent/plugin/out_mongokpi_test.rb

@@ -0,0 +1,90 @@
+require 'helper'
+
+class DataCounterOutputTest < Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  DEFAULT_CONFIG = %[
+  ]
+
+  DEFAULT_TAG = 'default_tag'
+
+  def create_driver(conf = DEFAULT_CONFIG, tag = DEFAULT_TAG)
+    Fluent::Test::BufferedOutputTestDriver.new(Fluent::MongoKpiOutput, tag).configure(conf)
+  end
+
+  def test_configure_default
+    d = create_driver
+    assert_equal 'localhost:27017', d.instance.address
+    assert_equal 'kpidb', d.instance.db
+    assert_equal nil, d.instance.connection_opts[:w]
+    assert_equal nil, d.instance.connection_opts[:name]
+    assert_equal nil, d.instance.connection_opts[:name]
+    assert_equal nil, d.instance.connection_opts[:read]
+    assert_equal nil, d.instance.connection_opts[:refresh_mode]
+    assert_equal nil, d.instance.connection_opts[:refresh_interval]
+    assert_equal false, d.instance.collections_opts[:capped]
+    assert_equal nil, d.instance.collections_opts[:size]
+    assert_equal nil, d.instance.collections_opts[:max]
+  end
+
+  def test_configure
+    d = create_driver(DEFAULT_CONFIG + %[
+      address 49.212.133.23:27019
+      db testdb
+      collection testColyyyymmdd
+      write_concern 1
+      name testreplica
+      read secondary
+      refresh_mode sync
+      refresh_interval 1000
+      capped_size 100
+      capped_max 200
+    ])
+    assert_equal '49.212.133.23:27019', d.instance.address
+    assert_equal 'testdb', d.instance.db
+    assert_equal 'testColyyyymmdd', d.instance.collection
+    assert_equal 1, d.instance.connection_opts[:w]
+    assert_equal 'testreplica', d.instance.connection_opts[:name]
+    assert_equal 'secondary', d.instance.connection_opts[:read]
+    assert_equal 'sync', d.instance.connection_opts[:refresh_mode]
+    assert_equal 1000, d.instance.connection_opts[:refresh_interval]
+    assert_equal true, d.instance.collections_opts[:capped]
+    assert_equal 100, d.instance.collections_opts[:size]
+    assert_equal 200, d.instance.collections_opts[:max]
+  end
+
+  def test_format
+    d = create_driver
+    time = Time.parse("2112-09-03 01:23:45 UTC").to_i
+    d.emit({"gerogero" => "Let's get Rocking!", "site" => "yapoo"}, time)
+    d.emit({"gerogero" => "Let's get Rocking!", "site" => "geegero"}, time)
+    d.expect_format "\x93\xABdefault_tag\xCF\x00\x00\x00\x01\f[\xC8\xA1\x82\xA8gerogero\xB2Let's get Rocking!\xA4site\xA5yapoo\x93\xABdefault_tag\xCF\x00\x00\x00\x01\f[\xC8\xA1\x82\xA8gerogero\xB2Let's get Rocking!\xA4site\xA7geegero"
+    # d.run
+
+    # time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    # d.emit({"a"=>1}, time)
+    # d.emit({"a"=>2}, time)
+
+    # d.expect_format %[2011-01-02T13:14:15Z\ttest\t{"a":1}\n]
+    # d.expect_format %[2011-01-02T13:14:15Z\ttest\t{"a":2}\n]
+
+    # d.run
+  end
+
+  def test_write
+    d = create_driver
+
+    # time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    # d.emit({"a"=>1}, time)
+    # d.emit({"a"=>2}, time)
+
+    # ### FileOutput#write returns path
+    # path = d.run
+    # expect_path = "#{TMP_DIR}/out_file_test._0.log.gz"
+    # assert_equal expect_path, path
+  end
+end
+
+

data/test/helper.rb

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'fluent/test'
+unless ENV.has_key?('VERBOSE')
+  nulllogger = Object.new
+  nulllogger.instance_eval {|obj|
+    def method_missing(method, *args)
+      # pass
+    end
+  }
+  $log = nulllogger
+end
+
+require 'fluent/plugin/out_mongokpi'
+
+class Test::Unit::TestCase
+end
+

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: fluent-plugin-mongokpi
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Hatayama Hideharu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.9.2
+description: ! 'Fluent BufferedOutput plugin: counting chunk, inserting counts to
+  make kpi count on MongoDB'
+email:
+- h.hiddy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- fluent-plugin-mongokpi.gemspec
+- lib/fluent/plugin/out_mongokpi.rb
+- test/fluent/plugin/out_mongokpi_test.rb
+- test/helper.rb
+homepage: https://bitbucket.org/hidepiy/fluent-plugin-mongokpi
+licenses:
+- APLv2
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ! 'Fluent BufferedOutput plugin: counting chunk, inserting counts to make
+  kpi count on MongoDB'
+test_files:
+- test/fluent/plugin/out_mongokpi_test.rb
+- test/helper.rb