sm-fluent-plugin-sql 0.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2fc5710a69b577a42c8c49f8b37584d41686ed33
+  data.tar.gz: 2b647c14bdafa9428ec5a90cc3e70bc9118ea74b
+SHA512:
+  metadata.gz: 6c8ff37a4cc11bba7a6955d4f6cb93aa0c40cbf158b1590083ccbf45ffc5b0eb964eacbbb919cc9498545ed8401711f0c7e39a0f2d95999fd25a7335be806243
+  data.tar.gz: ffc73333259e9a7a941c7b321327ac9f8a1d8716b2b9480bcced6630526b922c70d791e288ca023bd2a885f1382a6922b24dc129347499865b4a42945bb210c8

data/.travis.yml

@@ -0,0 +1,4 @@
+sudo: false
+
+before_install:
+  - gem install bundler

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1,148 @@
+# SQL input plugin for [Fluentd](http://fluentd.org) event collector
+
+## Overview
+
+This SQL plugin has two parts:
+
+1. SQL **input** plugin reads records from RDBMSes periodically. An example use case would be getting "diffs" of a table (based on the "updated_at" field).
+2. SQL **output** plugin that writes records into RDBMes. An example use case would be aggregating server/app/sensor logs into RDBMS systems.
+
+## Installation
+
+    $ fluent-gem install fluent-plugin-sql --no-document
+    $ fluent-gem install pg --no-document # for postgresql
+
+You should install actual RDBMS driver gem together. `pg` gem for postgresql adapter or `mysql2` gem for `mysql2` adapter. Other adapters supported by [ActiveRecord](https://github.com/rails/rails/tree/master/activerecord) should work.
+
+We recommend that mysql2 gem is higher than `0.3.12` and pg gem is higher than `0.16.0`.
+
+## Input: How It Works
+
+This plugin runs following SQL periodically:
+
+SELECT * FROM *table* WHERE *update\_column* > *last\_update\_column\_value* ORDER BY *update_column* ASC LIMIT 500
+
+What you need to configure is *update\_column*. The column should be an incremental column (such as AUTO\_ INCREMENT primary key) so that this plugin reads newly INSERTed rows. Alternatively, you can use a column incremented every time when you update the row (such as `last_updated_at` column) so that this plugin reads the UPDATEd rows as well.
+If you omit to set *update\_column* parameter, it uses primary key.
+
+It stores last selected rows to a file (named *state\_file*) to not forget the last row when Fluentd restarts.
+
+## Input: Configuration
+
+    <source>
+      @type sql
+
+      host rdb_host
+      database rdb_database
+      adapter mysql2_or_postgresql_or_etc
+      username myusername
+      password mypassword
+
+      tag_prefix my.rdb  # optional, but recommended
+
+      select_interval 60s  # optional
+      select_limit 500     # optional
+
+      state_file /var/run/fluentd/sql_state
+
+      <table>
+        table table1
+        tag table1  # optional
+        update_column update_col1
+        time_column time_col2  # optional
+      </table>
+
+      <table>
+        table table2
+        tag table2  # optional
+        update_column updated_at
+        time_column updated_at  # optional
+      </table>
+
+      # detects all tables instead of <table> sections
+      #all_tables
+    </source>
+
+* **host** RDBMS host
+* **port** RDBMS port
+* **database** RDBMS database name
+* **adapter** RDBMS driver name. You should install corresponding gem before start (mysql2 gem for mysql2 adapter, pg gem for postgresql adapter, etc.)
+* **username** RDBMS login user name
+* **password** RDBMS login password
+* **tag_prefix** prefix of tags of events. actual tag will be this\_tag\_prefix.tables\_tag (optional)
+* **select_interval** interval to run SQLs (optional)
+* **select_limit** LIMIT of number of rows for each SQL (optional)
+* **state_file** path to a file to store last rows
+* **all_tables** reads all tables instead of configuring each tables in \<table\> sections
+
+\<table\> sections:
+
+* **tag** tag name of events (optional; default value is table name)
+* **table** RDBM table name
+* **update_column**: see above description
+* **time_column** (optional): if this option is set, this plugin uses this column's value as the the event's time. Otherwise it uses current time.
+* **primary_key** (optional): if you want to get data from the table which doesn't have primary key like PostgreSQL's View, set this parameter.
+
+## Input: Limitation
+
+You should make sure target tables have index (and/or partitions) on the *update\_column*. Otherwise SELECT causes full table scan and serious performance problem.
+
+You can't replicate DELETEd rows.
+
+## Output: How It Works
+
+This plugin takes advantage of ActiveRecord underneath. For `host`, `port`, `database`, `adapter`, `username`, `password`, `socket` parameters, you can think of ActiveRecord's equivalent parameters.
+
+## Output: Configuration
+
+    <match my.rdb.*>
+      @type sql
+      host rdb_host
+      port 3306
+      database rdb_database
+      adapter mysql2_or_postgresql_or_etc
+      username myusername
+      password mypassword
+      socket path_to_socket
+      remove_tag_prefix my.rdb # optional, dual of tag_prefix in in_sql
+
+      <table>
+        table table1
+        column_mapping 'timestamp:created_at,fluentdata1:dbcol1,fluentdata2:dbcol2,fluentdata3:dbcol3'
+        # This is the default table because it has no "pattern" argument in <table>
+        # The logic is such that if all non-default <table> blocks
+        # do not match, the default one is chosen.
+        # The default table is required.
+      </table>
+
+      <table hello.*> # You can pass the same pattern you use in match statements.
+        table table2
+        # This is the non-default table. It is chosen if the tag matches the pattern
+        # AFTER remove_tag_prefix is applied to the incoming event. For example, if
+        # the message comes in with the tag my.rdb.hello.world, "remove_tag_prefix my.rdb"
+        # makes it "hello.world", which gets matched here because of "pattern hello.*".
+      </table>
+      
+      <table hello.world>
+        table table3
+        # This is the second non-default table. You can have as many non-default tables
+        # as you wish. One caveat: non-default tables are matched top-to-bottom and
+        # the events go into the first table it matches to. Hence, this particular table
+        # never gets any data, since the above "hello.*" subsumes "hello.world".
+      </table>
+    </match>
+
+* **host** RDBMS host
+* **port** RDBMS port
+* **database** RDBMS database name
+* **adapter** RDBMS driver name. You should install corresponding gem before start (mysql2 gem for mysql2 adapter, pg gem for postgresql adapter, etc.)
+* **username** RDBMS login user name
+* **password** RDBMS login password
+* **socket** RDBMS socket path
+* **remove_tag_prefix** remove the given prefix from the events. See "tag_prefix" in "Input: Configuration". (optional)
+
+\<table\> sections:
+
+* **table** RDBM table name
+* **column_mapping**: [Required] Record to table schema mapping. The format is consists of `from:to` or `key` values are separated by `,`. For example, if set 'item_id:id,item_text:data,updated_at' to **column_mapping**, `item_id` field of record is stored into `id` column and `updated_at` field of record is stored into `updated_at` column.
+* **<table pattern>**: the pattern to which the incoming event's tag (after it goes through `remove_tag_prefix`, if given). The patterns should follow the same syntax as [that of <match>](http://docs.fluentd.org/articles/config-file#match-pattern-how-you-control-the-event-flow-inside-fluentd). **Exactly one <table> element must NOT have this parameter so that it becomes the default table to store data**.

data/Rakefile

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

data/VERSION

@@ -0,0 +1 @@
+0.5.1

data/fluent-plugin-sql.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+$:.push File.expand_path('../lib', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "sm-fluent-plugin-sql"
+  gem.description = "SQL input/output plugin for Fluentd event collector"
+  gem.homepage    = "https://github.com/frsyuki/fluent-plugin-sql"
+  gem.summary     = gem.description
+  gem.version     = File.read("VERSION").strip
+  gem.authors     = ["Sadayuki Furuhashi"]
+  gem.email       = "frsyuki@gmail.com"
+  gem.has_rdoc    = false
+  #gem.platform    = Gem::Platform::RUBY
+  gem.files       = `git ls-files`.split("\n")
+  gem.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ['lib']
+  gem.license = "Apache-2.0"
+
+  gem.add_dependency "fluentd", [">= 0.12.17", "< 2"]
+  gem.add_dependency 'activerecord', "~> 4.2"
+  gem.add_dependency 'activerecord-import', "~> 0.7"
+  gem.add_development_dependency "rake", ">= 0.9.2"
+end

data/lib/fluent/plugin/in_sql.rb

@@ -0,0 +1,312 @@
+#
+# Fluent
+#
+# Copyright (C) 2013 FURUHASHI Sadayuki
+#
+#    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
+
+  require 'active_record'
+
+  class SQLInput < Input
+    Plugin.register_input('sql', self)
+
+    # For fluentd v0.12.16 or earlier
+    class << self
+      unless method_defined?(:desc)
+        def desc(description)
+        end
+      end
+    end
+
+    desc 'RDBMS host'
+    config_param :host, :string
+    desc 'RDBMS port'
+    config_param :port, :integer, :default => nil
+    desc 'RDBMS driver name.'
+    config_param :adapter, :string
+    desc 'RDBMS database name'
+    config_param :database, :string
+    desc 'RDBMS login user name'
+    config_param :username, :string, :default => nil
+    desc 'RDBMS login password'
+    config_param :password, :string, :default => nil, :secret => true
+    desc 'RDBMS socket path'
+    config_param :socket, :string, :default => nil
+
+    desc 'path to a file to store last rows'
+    config_param :state_file, :string, :default => nil
+    desc 'prefix of tags of events. actual tag will be this_tag_prefix.tables_tag (optional)'
+    config_param :tag_prefix, :string, :default => nil
+    desc 'interval to run SQLs (optional)'
+    config_param :select_interval, :time, :default => 60
+    desc 'limit of number of rows for each SQL(optional)'
+    config_param :select_limit, :time, :default => 500
+
+    unless method_defined?(:log)
+      define_method(:log) { $log }
+    end
+
+    class TableElement
+      include Configurable
+
+      config_param :table, :string
+      config_param :tag, :string, :default => nil
+      config_param :update_column, :string, :default => nil
+      config_param :time_column, :string, :default => nil
+      config_param :primary_key, :string, :default => nil
+
+      def configure(conf)
+        super
+      end
+
+      def init(tag_prefix, base_model, router)
+        @router = router
+        @tag = "#{tag_prefix}.#{@tag}" if tag_prefix
+
+        # creates a model for this table
+        table_name = @table
+        primary_key = @primary_key
+        @model = Class.new(base_model) do
+          self.table_name = table_name
+          self.inheritance_column = '_never_use_'
+          self.primary_key = primary_key if primary_key
+
+          #self.include_root_in_json = false
+
+          def read_attribute_for_serialization(n)
+            v = send(n)
+            if v.respond_to?(:to_msgpack)
+              v
+            else
+              v.to_s
+            end
+          end
+        end
+
+        # ActiveRecord requires model class to have a name.
+        class_name = table_name.singularize.camelize
+        base_model.const_set(class_name, @model)
+
+        # Sets model_name otherwise ActiveRecord causes errors
+        model_name = ActiveModel::Name.new(@model, nil, class_name)
+        @model.define_singleton_method(:model_name) { model_name }
+
+        # if update_column is not set, here uses primary key
+        unless @update_column
+          pk = @model.columns_hash[@model.primary_key]
+          unless pk
+            raise "Composite primary key is not supported. Set update_column parameter to <table> section."
+          end
+          @update_column = pk.name
+        end
+      end
+
+      # emits next records and returns the last record of emitted records
+      def emit_next_records(last_record, limit)
+        relation = @model
+        if last_record && last_update_value = last_record[@update_column]
+          relation = relation.where("#{@update_column} > ?", last_update_value)
+        end
+        relation = relation.order("#{@update_column} ASC")
+        relation = relation.limit(limit) if limit > 0
+
+        now = Engine.now
+
+        me = MultiEventStream.new
+        relation.each do |obj|
+          record = obj.serializable_hash rescue nil
+          if record
+            if @time_column && tv = obj.read_attribute(@time_column)
+              if tv.is_a?(Time)
+                time = tv.to_i
+              else
+                time = Time.parse(tv.to_s).to_i rescue now
+              end
+            else
+              time = now
+            end
+            me.add(time, record)
+            last_record = record
+          end
+        end
+
+        last_record = last_record.dup if last_record  # some plugin rewrites record :(
+        @router.emit_stream(@tag, me)
+
+        return last_record
+      end
+    end
+
+    def configure(conf)
+      super
+
+      unless @state_file
+        $log.warn "'state_file PATH' parameter is not set to a 'sql' source."
+        $log.warn "this parameter is highly recommended to save the last rows to resume tailing."
+      end
+
+      @tables = conf.elements.select {|e|
+        e.name == 'table'
+      }.map {|e|
+        te = TableElement.new
+        te.configure(e)
+        te
+      }
+
+      if config['all_tables']
+        @all_tables = true
+      end
+    end
+
+    SKIP_TABLE_REGEXP = /\Aschema_migrations\Z/i
+
+    def start
+      @state_store = @state_file.nil? ? MemoryStateStore.new : StateStore.new(@state_file)
+
+      config = {
+        :adapter => @adapter,
+        :host => @host,
+        :port => @port,
+        :database => @database,
+        :username => @username,
+        :password => @password,
+        :socket => @socket,
+      }
+
+      # creates subclass of ActiveRecord::Base so that it can have different
+      # database configuration from ActiveRecord::Base.
+      @base_model = Class.new(ActiveRecord::Base) do
+        # base model doesn't have corresponding phisical table
+        self.abstract_class = true
+      end
+
+      # ActiveRecord requires the base_model to have a name. Here sets name
+      # of an anonymous class by assigning it to a constant. In Ruby, class has
+      # a name of a constant assigned first
+      SQLInput.const_set("BaseModel_#{rand(1 << 31)}", @base_model)
+
+      # Now base_model can have independent configuration from ActiveRecord::Base
+      @base_model.establish_connection(config)
+
+      if @all_tables
+        # get list of tables from the database
+        @tables = @base_model.connection.tables.map do |table_name|
+          if table_name.match(SKIP_TABLE_REGEXP)
+            # some tables such as "schema_migrations" should be ignored
+            nil
+          else
+            te = TableElement.new
+            te.configure({
+              'table' => table_name,
+              'tag' => table_name,
+              'update_column' => nil,
+            })
+            te
+          end
+        end.compact
+      end
+
+      # ignore tables if TableElement#init failed
+      @tables.reject! do |te|
+        begin
+          te.init(@tag_prefix, @base_model, router)
+          log.info "Selecting '#{te.table}' table"
+          false
+        rescue => e
+          log.warn "Can't handle '#{te.table}' table. Ignoring.", :error => e.message, :error_class => e.class
+          log.warn_backtrace e.backtrace
+          true
+        end
+      end
+
+      @stop_flag = false
+      @thread = Thread.new(&method(:thread_main))
+    end
+
+    def shutdown
+      @stop_flag = true
+      $log.debug "Waiting for thread to finish"
+      @thread.join
+    end
+
+    def thread_main
+      until @stop_flag
+        sleep @select_interval
+
+        begin
+          conn = @base_model.connection
+          conn.active? || conn.reconnect!
+        rescue => e
+          log.warn "can't connect to database. Reconnect at next try"
+          next
+        end
+
+        @tables.each do |t|
+          begin
+            last_record = @state_store.last_records[t.table]
+            @state_store.last_records[t.table] = t.emit_next_records(last_record, @select_limit)
+            @state_store.update!
+          rescue => e
+            log.error "unexpected error", :error => e.message, :error_class => e.class
+            log.error_backtrace e.backtrace
+          end
+        end
+      end
+    end
+
+    class StateStore
+      def initialize(path)
+        require 'yaml'
+
+        @path = path
+        if File.exists?(@path)
+          @data = YAML.load_file(@path)
+          if @data == false || @data == []
+            # this happens if an users created an empty file accidentally
+            @data = {}
+          elsif !@data.is_a?(Hash)
+            raise "state_file on #{@path.inspect} is invalid"
+          end
+        else
+          @data = {}
+        end
+      end
+
+      def last_records
+        @data['last_records'] ||= {}
+      end
+
+      def update!
+        File.open(@path, 'w') {|f|
+          f.write YAML.dump(@data)
+        }
+      end
+    end
+
+    class MemoryStateStore
+      def initialize
+        @data = {}
+      end
+
+      def last_records
+        @data['last_records'] ||= {}
+      end
+
+      def update!
+      end
+    end
+  end
+
+end

data/lib/fluent/plugin/out_sql.rb

@@ -0,0 +1,251 @@
+module Fluent
+  class SQLOutput < BufferedOutput
+    Plugin.register_output('sql', self)
+
+    include SetTimeKeyMixin
+    include SetTagKeyMixin
+
+    # For fluentd v0.12.16 or earlier
+    class << self
+      unless method_defined?(:desc)
+        def desc(description)
+        end
+      end
+    end
+
+    desc 'RDBMS host'
+    config_param :host, :string
+    desc 'RDBMS port'
+    config_param :port, :integer, :default => nil
+    desc 'RDBMS driver name.'
+    config_param :adapter, :string
+    desc 'RDBMS login user name'
+    config_param :username, :string, :default => nil
+    desc 'RDBMS login password'
+    config_param :password, :string, :default => nil, :secret => true
+    desc 'RDBMS database name'
+    config_param :database, :string
+    desc 'RDBMS socket path'
+    config_param :socket, :string, :default => nil
+    desc 'remove the given prefix from the events'
+    config_param :remove_tag_prefix, :string, :default => nil
+
+    attr_accessor :tables
+
+    unless method_defined?(:log)
+      define_method(:log) { $log }
+    end
+
+    # TODO: Merge SQLInput's TableElement
+    class TableElement
+      include Configurable
+
+      config_param :table, :string
+      config_param :column_mapping, :string
+      config_param :num_retries, :integer, :default => 5
+
+      attr_reader :model
+      attr_reader :pattern
+
+      def initialize(pattern, log)
+        super()
+        @pattern = MatchPattern.create(pattern)
+        @log = log
+      end
+
+      def configure(conf)
+        super
+
+        @mapping = parse_column_mapping(@column_mapping)
+        @format_proc = Proc.new { |record|
+          new_record = {}
+          @mapping.each { |k, c|
+            new_record[c] = record[k]
+          }
+          new_record
+        }
+      end
+
+      def init(base_model)
+        # See SQLInput for more details of following code
+        table_name = @table
+        @model = Class.new(base_model) do
+          self.table_name = table_name
+          self.inheritance_column = '_never_use_output_'
+        end
+
+        class_name = table_name.singularize.camelize
+        base_model.const_set(class_name, @model)
+        model_name = ActiveModel::Name.new(@model, nil, class_name)
+        @model.define_singleton_method(:model_name) { model_name }
+
+        # TODO: check column_names and table schema
+        # @model.column_names
+      end
+
+      def import(chunk)
+        records = []
+        chunk.msgpack_each { |tag, time, data|
+          begin
+            # format process should be moved to emit / format after supports error stream.
+            records << @model.new(@format_proc.call(data))
+          rescue => e
+            args = {:error => e.message, :error_class => e.class, :table => @table, :record => Yajl.dump(data)}
+            @log.warn "Failed to create the model. Ignore a record:", args
+          end
+        }
+        begin
+          @model.import(records)
+        rescue ActiveRecord::StatementInvalid, ActiveRecord::ThrowResult, ActiveRecord::Import::MissingColumnError => e
+          # ignore other exceptions to use Fluentd retry mechanizm
+          @log.warn "Got deterministic error. Fallback to one-by-one import", :error => e.message, :error_class => e.class
+          one_by_one_import(records)
+        end
+      end
+
+      def one_by_one_import(records)
+        records.each { |record|
+          retries = 0
+          begin
+            @model.import([record])
+          rescue ActiveRecord::StatementInvalid, ActiveRecord::ThrowResult, ActiveRecord::Import::MissingColumnError => e
+            @log.error "Got deterministic error again. Dump a record", :error => e.message, :error_class => e.class, :record => record
+          rescue => e
+            retries += 1
+            if retries > @num_retries
+              @log.error "Can't recover undeterministic error. Dump a record", :error => e.message, :error_class => e.class, :record => record
+              next
+            end
+
+            @log.warn "Failed to import a record: retry number = #{retries}", :error  => e.message, :error_class => e.class
+            sleep 0.5
+            retry
+          end
+        }
+      end
+
+      private
+
+      def parse_column_mapping(column_mapping_conf)
+        mapping = {}
+        column_mapping_conf.split(',').each { |column_map|
+          key, column = column_map.strip.split(':', 2)
+          column = key if column.nil?
+          mapping[key] = column
+        }
+        mapping
+      end
+    end
+
+    def initialize
+      super
+      require 'active_record'
+      require 'activerecord-import'
+    end
+
+    def configure(conf)
+      super
+
+      if remove_tag_prefix = conf['remove_tag_prefix']
+        @remove_tag_prefix = Regexp.new('^' + Regexp.escape(remove_tag_prefix))
+      end
+
+      @tables = []
+      @default_table = nil
+      conf.elements.select { |e|
+        e.name == 'table'
+      }.each { |e|
+        te = TableElement.new(e.arg, log)
+        te.configure(e)
+        if e.arg.empty?
+          $log.warn "Detect duplicate default table definition" if @default_table
+          @default_table = te
+        else
+          @tables << te
+        end
+      }
+      @only_default = @tables.empty?
+
+      if @default_table.nil?
+        raise ConfigError, "There is no default table. <table> is required in sql output"
+      end
+    end
+
+    def start
+      super
+
+      config = {
+        :adapter => @adapter,
+        :host => @host,
+        :port => @port,
+        :database => @database,
+        :username => @username,
+        :password => @password,
+        :socket => @socket,
+      }
+
+      @base_model = Class.new(ActiveRecord::Base) do
+        self.abstract_class = true
+      end
+
+      SQLOutput.const_set("BaseModel_#{rand(1 << 31)}", @base_model)
+      @base_model.establish_connection(config)
+
+      # ignore tables if TableElement#init failed
+      @tables.reject! do |te|
+        init_table(te, @base_model)
+      end
+      init_table(@default_table, @base_model)
+    end
+
+    def shutdown
+      super
+    end
+
+    def emit(tag, es, chain)
+      if @only_default
+        super(tag, es, chain)
+      else
+        super(tag, es, chain, format_tag(tag))
+      end
+    end
+
+    def format(tag, time, record)
+      [tag, time, record].to_msgpack
+    end
+
+    def write(chunk)
+      conn = @base_model.connection
+      conn.active? || conn.reconnect!
+
+      @tables.each { |table|
+        if table.pattern.match(chunk.key)
+          return table.import(chunk)
+        end
+      }
+      @default_table.import(chunk)
+    end
+
+    private
+
+    def init_table(te, base_model)
+      begin
+        te.init(base_model)
+        log.info "Selecting '#{te.table}' table"
+        false
+      rescue => e
+        log.warn "Can't handle '#{te.table}' table. Ignoring.", :error => e.message, :error_class => e.class
+        log.warn_backtrace e.backtrace
+        true
+      end
+    end
+
+    def format_tag(tag)
+      if @remove_tag_prefix
+        tag.gsub(@remove_tag_prefix, '')
+      else
+        tag
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: sm-fluent-plugin-sql
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+platform: ruby
+authors:
+- Sadayuki Furuhashi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.17
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.17
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord-import
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+description: SQL input/output plugin for Fluentd event collector
+email: frsyuki@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- VERSION
+- fluent-plugin-sql.gemspec
+- lib/fluent/plugin/in_sql.rb
+- lib/fluent/plugin/out_sql.rb
+homepage: https://github.com/frsyuki/fluent-plugin-sql
+licenses:
+- Apache-2.0
+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.4.8
+signing_key: 
+specification_version: 4
+summary: SQL input/output plugin for Fluentd event collector
+test_files: []