fluent-plugin-metricsense 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+/vendor/
+/pkg/
+/coverage/
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.rdoc

@@ -0,0 +1,25 @@
+= MetricSense - application metrics aggregation plugin for Fluentd
+
+== Example
+
+    <match metrics.**>
+        type metricsense
+    
+        # RDB backend
+        type metricsense
+        backend rdb_tsdb
+        all_segment
+        flush_interval 5m
+        remove_tag_prefix metrics
+        rdb_url mysql2://user:pass@host/mydb
+        rdb_table_prefix ms
+    
+        ## Librato Metrics backend
+        #all_segment
+        #flush_interval 5m
+        #remove_tag_prefix metrics
+        #backend librato
+        #librato_user xxxx@yyyy
+        #librato_token XYZXYZ
+    </match>
+

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+#require 'rake/testtask'
+#
+#Rake::TestTask.new(:test) do |test|
+#  test.libs << 'lib' << 'test'
+#  test.test_files = FileList['test/plugin/*.rb']
+#  test.verbose = true
+#end
+
+#task :coverage do |t|
+#  ENV['SIMPLE_COV'] = '1'
+#  Rake::Task["test"].invoke
+#end
+
+task :default => [:build]

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/fluent-plugin-metricsense.gemspec

@@ -0,0 +1,22 @@
+$:.push File.expand_path('../lib', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "fluent-plugin-metricsense"
+  s.description = "MetricSense - application metrics aggregation plugin for Fluentd"
+  s.summary     = s.description
+  s.homepage    = "https://github.com/treasure-data/fluent-plugin-metricsense"
+  s.version     = File.read("VERSION").strip
+  s.authors     = ["Sadayuki Furuhashi"]
+  s.email       = "sf@treasure-data.com"
+  s.has_rdoc    = false
+  s.require_paths = ['lib']
+  #s.platform    = Gem::Platform::RUBY
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  s.add_dependency "fluentd", "~> 0.10.6"
+  s.add_development_dependency "rake", ">= 0.8.7"
+  s.add_development_dependency 'bundler', ['>= 1.0.0']
+  s.add_development_dependency "simplecov", ">= 0.5.4"
+end

data/lib/fluent/plugin/backend/librato_backend.rb

@@ -0,0 +1,114 @@
+#
+# fluent-plugin-metricsense
+#
+# Copyright (C) 2012 Sadayuki Furuhashi
+#
+#    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.
+#
+module Fluent::MetricSenseOutput::Backends
+
+  require 'net/http'
+  require 'cgi'
+  require 'json'
+
+  class LibratoBackend < Fluent::MetricSenseOutput::Backend
+    Fluent::MetricSenseOutput::BACKENDS['librato'] = self
+
+    config_param :librato_user, :string
+    config_param :librato_token, :string
+
+    def initialize
+      super
+      @initialized_metrics = {}
+    end
+
+    def write(data)
+      http = Net::HTTP.new('metrics-api.librato.com', 443)
+      http.open_timeout = 60
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE  # FIXME verify
+      #http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.cert_store = OpenSSL::X509::Store.new
+      header = {}
+
+      begin
+        # send upto 50 entries at once
+        data.each_slice(50) {|slice|
+          req = Net::HTTP::Post.new('/v1/metrics', header)
+          req.basic_auth @librato_user, @librato_token
+
+          data = []
+          slice.each_with_index {|(tag,time,value,seg_key,seg_val),i|
+            if seg_key
+              name = "#{tag}:#{seg_key}"
+              source = seg_val
+            else
+              name = tag
+              source = nil
+            end
+            h = {
+              "name" => name,
+              "measure_time" => time,
+              "value" => value,
+            }
+            h["source"] = source.to_s if source
+            data << h
+            ensure_metric_initialized(http, name)
+          }
+          body = {"gauges"=>data}.to_json
+
+          $log.trace { "librato metrics: #{data.inspect}" }
+          req.body = body
+          req.set_content_type("application/json")
+          res = http.request(req)
+
+          # TODO error handling
+          if res.code != "200"
+            $log.warn "librato_metrics: #{res.code}: #{res.body}"
+          end
+        }
+
+      ensure
+        http.finish if http.started?
+      end
+    end
+
+    METRIC_INITIALIZE_REQUEST = [
+      "type=gauge",
+      "attributes[source_aggregate]=true",
+      "attributes[summarize_function]=sum",
+      "attributes[display_stacked]=true",
+    ].join('&')
+
+    def ensure_metric_initialized(http, name)
+      return if @initialized_metrics[name]
+
+      header = {}
+      req = Net::HTTP::Put.new("/v1/metrics/#{CGI.escape name}", header)
+      req.basic_auth @librato_user, @librato_token
+
+      $log.trace { "librato initialize metric: #{name}" }
+      req.body = METRIC_INITIALIZE_REQUEST
+      res = http.request(req)
+
+      # TODO error handling
+      if res.code !~ /20./
+        $log.warn "librato_metrics: #{res.code}: #{res.body}"
+      else
+        @initialized_metrics[name] = true
+      end
+    end
+  end
+
+end
+

data/lib/fluent/plugin/backend/rdb_tsdb_backend.rb

@@ -0,0 +1,307 @@
+#
+# fluent-plugin-metricsense
+#
+# Copyright (C) 2012 Sadayuki Furuhashi
+#
+#    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.
+#
+module Fluent::MetricSenseOutput::Backends
+
+  class RDBTSDBBackend < Fluent::MetricSenseOutput::Backend
+    include Fluent::Configurable
+
+    Fluent::MetricSenseOutput::BACKENDS['rdb_tsdb'] = self
+
+    config_param :rdb_url, :string
+    config_param :rdb_table_prefix, :string
+    config_param :rdb_read_url, :string, :default => nil
+
+    INSERT_SUPPRESS_RING_BUFFER_SIZE = 64
+
+    def initialize
+      super
+      require 'sequel'
+      @insup_ring = []
+      @insup_ring_index = 0
+    end
+
+    def configure(conf)
+      super
+
+      @rdb_read_url ||= @rdb_url
+
+      @metric_tag_table = "#{@rdb_table_prefix}_metric_tags"
+      @segment_value_table = "#{@rdb_table_prefix}_segment_values"
+      @data_table = "#{@rdb_table_prefix}_data"
+      @metric_view = "#{@rdb_table_prefix}_metrics"
+      @metric_json_view = "#{@rdb_table_prefix}_json"
+
+      #sql_standard_concat = lambda {|array| array.join(' || ') }
+      #sql_standard_surround = lambda {|expr| "'\"' || #{expr} || '\"'" }
+
+      case @rdb_url
+      when /^mysql/i
+        @sql_type = :mysql
+        @sql_autoincr_type = "INT"
+        @sql_autoincr_ref_type = "INT"
+        @sql_autoincr_suffix = " AUTO_INCREMENT"
+        @sql_value_type = "SMALLINT"
+        @sql_name_type = "VARCHAR(255)"
+        @sql_time_type = "INT"
+        @sql_insert_ignore = "INSERT IGNORE"
+        @sql_insert_returns_last_id = true
+        #@sql_concat = lambda {|array| "CONCAT(#{array.join(', ')})" }
+        #@sql_surround = lambda {|expr| "CONCAT('\"', #{expr}, '\"')" }
+      when /^postgres/i
+        @sql_type = :postgresql
+        @sql_autoincr_type = "SERIAL"
+        @sql_autoincr_ref_type = "INT"
+        @sql_autoincr_suffix = ""
+        @sql_value_type = "SMALLINT"
+        @sql_name_type = "VARCHAR(255)"
+        @sql_time_type = "INT"
+        @sql_insert_ignore = "INSERT"
+        @sql_insert_returns_last_id = false
+        #@sql_concat = sql_standard_concat
+        #@sql_surround = sql_standard_surround
+      when /^sqlite/i
+        @sql_type = :sqlite
+        @sql_autoincr_type = "INTEGER"
+        @sql_autoincr_ref_type = "INTEGER"
+        @sql_autoincr_suffix = " AUTOINCREMENT"
+        @sql_value_type = "INTEGER"
+        @sql_name_type = "TEXT"
+        @sql_time_type = "INTEGER"
+        @sql_insert_ignore = "INSERT OR IGNORE"
+        @sql_insert_returns_last_id = false
+        #@sql_concat = sql_standard_concat
+        #@sql_surround = sql_standard_surround
+      else
+        @sql_type = :unknown
+        @sql_autoincr_type = "INT"
+        @sql_autoincr_ref_type = "INT"
+        @sql_autoincr_suffix = " AUTO_INCREMENT"
+        @sql_value_type = "SMALLINT"
+        @sql_name_type = "VARCHAR(255)"
+        @sql_time_type = "INT"
+        @sql_insert_ignore = "INSERT IGNORE"
+        @sql_insert_returns_last_id = false
+        #@sql_concat = sql_standard_concat
+        #@sql_surround = sql_standard_surround
+      end
+    end
+
+    def start
+      ensure_connect do |db|
+        db.run %[
+          CREATE TABLE IF NOT EXISTS `#{@metric_tag_table}` (
+            id #{@sql_autoincr_type} PRIMARY KEY#{@sql_autoincr_suffix},
+            metric_name #{@sql_name_type} NOT NULL,
+            segment_name #{@sql_name_type} NOT NULL,
+            UNIQUE (metric_name, segment_name)
+          );]
+
+        db.run %[
+          CREATE TABLE IF NOT EXISTS `#{@segment_value_table}` (
+            id #{@sql_autoincr_type} PRIMARY KEY#{@sql_autoincr_suffix},
+            name #{@sql_name_type} NOT NULL,
+            UNIQUE (name)
+          );]
+
+        minutes = (0..59).to_a.map {|m| "m#{m} #{@sql_value_type} NOT NULL DEFAULT 0" }.join(', ')
+        db.run %[
+          CREATE TABLE IF NOT EXISTS `#{@data_table}` (
+            base_time #{@sql_time_type} NOT NULL,
+            metric_id #{@sql_autoincr_ref_type} NOT NULL,
+            segment_id #{@sql_autoincr_ref_type},
+            #{minutes},
+            PRIMARY KEY (base_time, metric_id, segment_id)
+          );]
+
+        if @sql_type == :postgresql
+          # ignore duplication error on data_table
+          db.run %[
+            CREATE OR REPLACE RULE ignore_duplicated_insert AS ON INSERT TO `#{@data_table}`
+            WHERE NEW.base_time = OLD.base_time AND NEW.metric_id = OLD.metric_id AND NEW.segment_id = OLD.segment_id
+            DO INSTEAD NOTHING;]
+        end
+
+        #minutes = (0..59).to_a.map {|m| "m#{m}" }.join(', ')
+        #db.run %[
+        #  CREATE VIEW IF NOT EXISTS `#{@metric_view}` AS
+        #  SELECT
+        #    base_time * 60 AS time,
+        #    M.metric_name AS metric_name,
+        #    CASE M.segment_name WHEN '' THEN NULL ELSE M.segment_name END AS segment_name,
+        #    S.name AS segment_value,
+        #    #{minutes}
+        #  FROM `#{@data_table}` T
+        #  LEFT JOIN `#{@metric_tag_table}` M ON T.metric_id = M.id
+        #  LEFT JOIN `#{@segment_value_table}` S ON T.segment_id = S.id;]
+
+        #minutes = (0..59).to_a.map {|m| ["m#{m}", "','"] }.flatten!
+        #minutes.pop
+        #minutes = @sql_concat.call(["'['"]+minutes+["']'"])
+        #db.run %[
+        #  CREATE VIEW IF NOT EXISTS `#{@metric_json_view}` AS
+        #  SELECT
+        #    base_time * 60 AS time,
+        #    #{@sql_surround.call("M.metric_name")} AS metric_name,
+        #    CASE WHEN M.segment_name IS NULL OR M.segment_name = '' THEN 'null' ELSE #{@sql_surround.call("M.segment_name")} END AS segment_name,
+        #    CASE WHEN S.name IS NULL OR S.name = '' THEN 'null' ELSE #{@sql_surround.call("S.name")} END AS segment_value,
+        #    #{minutes}
+        #  FROM `#{@data_table}` T
+        #  LEFT JOIN `#{@metric_tag_table}` M ON T.metric_id = M.id
+        #  LEFT JOIN `#{@segment_value_table}` S ON T.segment_id = S.id;]
+
+        reload_metric_names!(db)
+        reload_segment_names!(db)
+      end
+    end
+
+    #def shutdown
+    #end
+
+    ROW_TIME_WINDOW = 60*24
+    ROW_TIME_WINDOW_BITS = 11
+    ROW_TIME_WINDOW_MASK = (1<<ROW_TIME_WINDOW_BITS)-1
+
+    def write(data)
+      ensure_connect do |db|
+        # group by row_key (base_time,metric_id,segment_id)
+        rows = {}
+        data.each {|(tag,time,value,seg_key,seg_val)|
+          base_time = time / ROW_TIME_WINDOW
+          metric_id = get_metric_id(db, tag, seg_key)
+          segment_id = get_segment_id(db, seg_val) if seg_val
+
+          row_key = [base_time, metric_id, segment_id]
+          minutes = (rows[row_key] ||= [])
+          minutes << ((value << ROW_TIME_WINDOW_BITS) | (time % 60))
+        }
+
+        # insert rows if not exist
+        if @sql_type == :sqlite
+          # sqlite3 < 1.3.7 doesn't allow multiple rows at once
+          rows.keys.each {|row_key|
+            next if @insup_ring.include?(row_key)
+            db["#{@sql_insert_ignore} INTO `#{@data_table}` (base_time,metric_id,segment_id) VALUES (?,?,?)", *row_key].update
+            rid = @insup_ring_index = (@insup_ring_index + 1) % INSERT_SUPPRESS_RING_BUFFER_SIZE
+            @insup_ring[rid] = row_key
+          }
+        else
+          insert_sql = "#{@sql_insert_ignore} INTO `#{@data_table}` (base_time,metric_id,segment_id) VALUES " + (["(?,?,?)"] * rows.size).join(', ')
+          insert_params = [insert_sql]
+          rows.keys.each {|row_key|
+            next if @insup_ring.include?(row_key)
+            insert_params.concat(row_key)
+            rid = @insup_ring_index = (@insup_ring_index + 1) % INSERT_SUPPRESS_RING_BUFFER_SIZE
+            @insup_ring[rid] = row_key
+          }
+          db[*insert_params].update
+        end
+
+        # increment values
+        db.transaction do
+          rows.each_pair {|row_key,minutes|
+            update_sql = "UPDATE `#{@data_table}` SET "
+            update_params = [update_sql]
+
+            values_sql = []
+            minutes.each {|m|
+              value = m >> ROW_TIME_WINDOW_BITS
+              minute = m & ROW_TIME_WINDOW_MASK
+              values_sql << "m#{minute} = m#{minute} + ?"
+              update_params << value
+            }.join(', ')
+            update_sql << values_sql.join(', ') << " WHERE base_time=? AND metric_id=? AND segment_id=?"
+            update_params.concat(row_key)
+
+            db[*update_params].update
+          }
+        end
+      end
+    end
+
+    def reload_metric_names!(db)
+      map = {}
+      db.fetch("SELECT id, metric_name, segment_name FROM `#{@metric_tag_table}`") {|row|
+        key = "#{row[:metric_name]}\0#{row[:segment_name]}"
+        map[key] = row[:id]
+      }
+      @metric_names = map
+    end
+
+    def reload_segment_names!(db)
+      map = {}
+      db.fetch("SELECT id, name FROM `#{@segment_value_table}`") {|row|
+        map[row[:name]] = row[:id]
+      }
+      @segment_names = map
+    end
+
+    def get_metric_id(db, tag, seg_key)
+      key = "#{tag}\0#{seg_key}"
+      id = @metric_names[key]
+      return id if id
+
+      begin
+        id = db["INSERT INTO `#{@metric_tag_table}` (metric_name,segment_name) VALUES (?,?)", tag, seg_key||''].update
+        if @sql_insert_returns_last_id
+          @metric_names[key] = id
+          return id
+        end
+        reload_metric_names!(db)
+        return @metric_names[key]
+
+      rescue => e
+        reload_metric_names!(db)
+        id = @metric_names[key]
+        return id if id
+        raise e
+      end
+    end
+
+    def get_segment_id(db, seg_val)
+      key = seg_val ? seg_val.to_s : ''
+      id = @segment_names[key]
+      return id if id
+
+      begin
+        id = db["INSERT INTO `#{@segment_value_table}` (name) VALUES (?)", key].update
+        if @sql_insert_returns_last_id
+          @segment_names[key] = id
+          return id
+        end
+        reload_segment_names!(db)
+        return @segment_names[key]
+
+      rescue => e
+        reload_segment_names!(db)
+        id = @segment_names[key]
+        return id if id
+        raise e
+      end
+    end
+
+    def ensure_connect(&block)
+      db = Sequel.connect(@rdb_url, :max_connections=>1)
+      begin
+        block.call(db)
+      ensure
+        db.disconnect
+      end
+    end
+  end
+
+end

data/lib/fluent/plugin/backend/stdout_backend.rb

@@ -0,0 +1,35 @@
+#
+# fluent-plugin-metricsense
+#
+# Copyright (C) 2012 Sadayuki Furuhashi
+#
+#    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.
+#
+module Fluent::MetricSenseOutput::Backends
+
+  class StdoutBackend < Fluent::MetricSenseOutput::Backend
+    Fluent::MetricSenseOutput::BACKENDS['stdout'] = self
+
+    def write(data)
+      data.each {|tag,time,value,seg_key,seg_val|
+        if seg_key
+          puts "#{Time.at(time)} #{tag}: #{value}"
+        else
+          puts "#{Time.at(time)} #{tag} [#{seg_key}=#{seg_val}]: #{value}"
+        end
+      }
+    end
+  end
+
+end
+

data/lib/fluent/plugin/out_metricsense.rb

@@ -0,0 +1,162 @@
+# encoding: ascii-8bit
+#
+# fluent-plugin-metricsense
+#
+# Copyright (C) 2012 Sadayuki Furuhashi
+#
+#    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.
+#
+module Fluent
+
+  class MetricSenseOutput < Fluent::BufferedOutput
+    Fluent::Plugin.register_output('metricsense', self)
+
+    BACKENDS = {}
+
+    class Backend
+      include Configurable
+
+      def start
+      end
+
+      def shutdown
+      end
+    end
+
+    backend_dir = "#{File.dirname(__FILE__)}/backend"
+    Dir.glob("#{backend_dir}/*_backend.rb") {|e|
+      require e
+    }
+
+    config_param :segment_keys, :string, :default => nil
+    config_param :all_segment, :bool, :default => false
+    config_param :value_key, :string, :default => 'value'
+
+    config_param :backend, :string
+
+    config_param :remove_tag_prefix, :string, :default => nil
+
+    def configure(conf)
+      super
+
+      if @remove_tag_prefix
+        @remove_tag_prefix = Regexp.new('^' + Regexp.escape(@remove_tag_prefix) + "\\.?")
+      end
+
+      if conf.has_key?('all_segment') && conf['all_segment'].empty?
+        @all_segment = true
+      end
+
+      if @all_segment
+        @segment_keys = nil
+      elsif @segment_keys
+        @segment_keys = @segment_keys.strip.split(/\s*,\s*/)
+      else
+        @segment_keys = []
+      end
+
+      be = BACKENDS[@backend]
+      unless be
+        raise ConfigError, "unknown backend: #{@backend.inspect}"
+      end
+
+      @backend = be.new
+      @backend.configure(conf)
+    end
+
+    def start
+      @backend.start
+      super
+    end
+
+    def shutdown
+      super
+      @backend.shutdown
+    end
+
+    def format_stream(tag, es)
+      out = ''
+      es.each do |time,record|
+        value = record[@value_key]
+
+        fv = value.to_f
+        next if fv == 0.0
+
+        iv = fv.to_i
+        if iv.to_f == fv
+          value = iv
+        else
+          value = fv
+        end
+
+        seg_keys = @segment_keys
+        unless seg_keys
+          seg_keys = record.keys
+          seg_keys.delete(@value_key)
+        end
+
+        segs = []
+        seg_keys.each {|seg_key|
+          if seg_val = record[seg_key]
+            segs << seg_key
+            segs << seg_val
+          end
+        }
+
+        tag.sub!(@remove_tag_prefix, '') if @remove_tag_prefix
+
+        [tag, time, value, segs].to_msgpack(out)
+      end
+      out
+    end
+
+    class SumAggregator
+      def initialize
+        @value = 0
+      end
+
+      def add(value)
+        @value += value
+      end
+
+      attr_reader :value
+    end
+
+    AggregationKey = Struct.new(:tag, :time, :seg_val, :seg_key)
+
+    def write(chunk)
+      counters = {}
+
+      # select sum(value) from chunk group by tag, time/60, seg_val, seg_key
+      chunk.msgpack_each {|tag,time,value,segs|
+        time = time / 60 * 60
+
+        ak = AggregationKey.new(tag, time, nil, nil)
+        (counters[ak] ||= SumAggregator.new).add(value)
+
+        segs.each_slice(2) {|seg_key,seg_val|
+          ak = AggregationKey.new(tag, time, seg_val, seg_key)
+          (counters[ak] ||= SumAggregator.new).add(value)
+        }
+      }
+
+      data = []
+      counters.each_pair {|ak,aggr|
+        data << [ak.tag, ak.time, aggr.value, ak.seg_key, ak.seg_val]
+      }
+
+      @backend.write(data)
+    end
+  end
+
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: fluent-plugin-metricsense
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Sadayuki Furuhashi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.6
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.4
+description: MetricSense - application metrics aggregation plugin for Fluentd
+email: sf@treasure-data.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- VERSION
+- fluent-plugin-metricsense.gemspec
+- lib/fluent/plugin/backend/librato_backend.rb
+- lib/fluent/plugin/backend/rdb_tsdb_backend.rb
+- lib/fluent/plugin/backend/stdout_backend.rb
+- lib/fluent/plugin/out_metricsense.rb
+homepage: https://github.com/treasure-data/fluent-plugin-metricsense
+licenses: []
+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: MetricSense - application metrics aggregation plugin for Fluentd
+test_files: []
+has_rdoc: false