fluent-plugin-cassandra-driver 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc1aec631bec8512c572f9c7b4eef5a2cfcb0a96
+  data.tar.gz: e64678e60780982ad114a504cf55e69735bdd1dc
+SHA512:
+  metadata.gz: 552915e4023e251d06f2d8b645a9e495a136a1d7953a34687467271c9c4e6670f5f66ad555abec6af7ba779a3162cc913afddba4894962447189477a7536d7f2
+  data.tar.gz: 22d47d1a6592b80938db0d192cc1a96aeeeb79c4c99f25be54a6646e2a4387bf80e39a78579abde35b38b2f81739f830f02ba6871fbb83c401e0f368d5918fbc

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format documentation
+--backtrace
+--default_path spec

data/.simplecov

@@ -0,0 +1,5 @@
+# configure code coverage
+SimpleCov.start do
+  # exclude directories and files
+  add_filter "/spec/"
+end

data/Gemfile

@@ -0,0 +1,12 @@
+source 'http://rubygems.org'
+
+gem 'fluentd', '>=0.12.29'
+gem 'cassandra-driver', '>=3.0.3'
+
+group :development, :test do
+  gem 'rdoc', '>=3.12'
+  gem 'bundler', '>=1.0.0'
+  gem 'jeweler', '>=1.8.4'
+  gem 'rspec', '>=0'
+  gem 'simplecov'
+end

data/LICENSE.txt

@@ -0,0 +1,29 @@
+Copyright © 2016 by Yaroslav Lukyanov (c_sharp@mail.ru)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+ * Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,39 @@
+# Cassandra plugin for Fluentd
+
+Cassandra output plugin for Fluentd.
+
+Implemented using the Datastax Ruby Driver for Apache Cassandra gem and targets [CQL3](https://docs.datastax.com/en/cql/3.3/)
+and Cassandra 1.2 - 3.x
+
+# Installation
+
+via RubyGems
+
+    fluent-gem install fluent-plugin-cassandra-driver
+
+# Quick Start
+
+## Cassandra Configuration
+    # create keyspace (via CQL)
+      CREATE KEYSPACE \"metrics\" WITH strategy_class='org.apache.cassandra.locator.SimpleStrategy' AND strategy_options:replication_factor=1;
+
+    # create table (column family)
+      CREATE TABLE logs (id varchar, ts bigint, payload text, PRIMARY KEY (id, ts)) WITH CLUSTERING ORDER BY (ts DESC);
+
+    # NOTE: schema definition should match that specified in the Fluentd.conf configuration file (see below)
+
+## Fluentd.conf Configuration
+    <match cassandra.**>
+      type cassandra_driver      # fluent output plugin file name (sans fluent_plugin_ prefix)
+      hosts 127.0.0.1            # comma delimited string of hosts
+      keyspace metrics           # cassandra keyspace
+      columnfamily logs          # cassandra column family
+      ttl 60                     # cassandra ttl *optional => default is 0*
+      schema                     # cassandra column family schema *hash where keys => column names and values => data types* for example: {:id => :string}
+      data_keys                  # comma delimited string of the fluentd hash's keys
+      pop_data_keys              # keep or pop key/values from the fluentd hash when storing it as json
+    </match>
+    
+# Tests
+
+TODO

data/Rakefile

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+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 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = 'fluent-plugin-cassandra-driver'
+  gem.homepage = 'https://github.com/CSharpRU/fluent-plugin-cassandra-driver'
+  gem.license = 'BSD-3-Clause'
+  gem.summary = 'Fluent output plugin for Cassandra'
+  gem.description = 'Fluent output plugin for Cassandra via Datastax Ruby Driver for Apache Cassandra'
+  gem.email = 'c_sharp@mail.ru'
+  gem.authors = ['Yaroslav Lukyanov']
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "fluent-plugin-cassandra-cql #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# Get spec rake tasks working in RSpec 2.0
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/fluent-plugin-cassandra-driver.gemspec

@@ -0,0 +1,71 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: fluent-plugin-cassandra-driver 0.0.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "fluent-plugin-cassandra-driver".freeze
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Yaroslav Lukyanov".freeze]
+  s.date = "2016-11-10"
+  s.description = "Fluent output plugin for Cassandra via Datastax Ruby Driver for Apache Cassandra".freeze
+  s.email = "c_sharp@mail.ru".freeze
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".rspec",
+    ".simplecov",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "fluent-plugin-cassandra-driver.gemspec",
+    "lib/fluent/plugin/out_cassandra_driver.rb",
+    "spec/cassandra_cql_output_spec.rb",
+    "spec/spec.opts",
+    "spec/spec_helper.rb",
+    "spec/support/helpers.rb"
+  ]
+  s.homepage = "https://github.com/CSharpRU/fluent-plugin-cassandra-driver".freeze
+  s.licenses = ["BSD-3-Clause".freeze]
+  s.rubygems_version = "2.6.8".freeze
+  s.summary = "Fluent output plugin for Cassandra".freeze
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<fluentd>.freeze, [">= 0.12.29"])
+      s.add_runtime_dependency(%q<cassandra-driver>.freeze, [">= 3.0.3"])
+      s.add_development_dependency(%q<rdoc>.freeze, [">= 3.12"])
+      s.add_development_dependency(%q<bundler>.freeze, [">= 1.0.0"])
+      s.add_development_dependency(%q<jeweler>.freeze, [">= 1.8.4"])
+      s.add_development_dependency(%q<rspec>.freeze, [">= 0"])
+      s.add_development_dependency(%q<simplecov>.freeze, [">= 0"])
+    else
+      s.add_dependency(%q<fluentd>.freeze, [">= 0.12.29"])
+      s.add_dependency(%q<cassandra-driver>.freeze, [">= 3.0.3"])
+      s.add_dependency(%q<rdoc>.freeze, [">= 3.12"])
+      s.add_dependency(%q<bundler>.freeze, [">= 1.0.0"])
+      s.add_dependency(%q<jeweler>.freeze, [">= 1.8.4"])
+      s.add_dependency(%q<rspec>.freeze, [">= 0"])
+      s.add_dependency(%q<simplecov>.freeze, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<fluentd>.freeze, [">= 0.12.29"])
+    s.add_dependency(%q<cassandra-driver>.freeze, [">= 3.0.3"])
+    s.add_dependency(%q<rdoc>.freeze, [">= 3.12"])
+    s.add_dependency(%q<bundler>.freeze, [">= 1.0.0"])
+    s.add_dependency(%q<jeweler>.freeze, [">= 1.8.4"])
+    s.add_dependency(%q<rspec>.freeze, [">= 0"])
+    s.add_dependency(%q<simplecov>.freeze, [">= 0"])
+  end
+end
+

data/lib/fluent/plugin/out_cassandra_driver.rb

@@ -0,0 +1,109 @@
+require 'cassandra'
+require 'msgpack'
+require 'json'
+
+module Fluent
+  class CassandraCqlOutput < BufferedOutput
+    Fluent::Plugin.register_output('cassandra_driver', self)
+
+    config_param :hosts, :string
+    config_param :keyspace, :string
+    config_param :columnfamily, :string
+    config_param :ttl, :integer, :default => 0
+    config_param :schema, :string
+    config_param :data_keys, :string
+
+    # remove keys from the fluentd json event as they're processed
+    # for individual columns?
+    config_param :pop_data_keys, :bool, :default => true
+
+    def session
+      @session ||= get_session(self.hosts, self.keyspace)
+    end
+
+    def configure(conf)
+      super
+
+      # perform validations
+      raise ConfigError, "'Hosts' is required by Cassandra output (ex: localhost, 127.0.0.1, ec2-54-242-141-252.compute-1.amazonaws.com" if self.hosts.nil?
+      raise ConfigError, "'Keyspace' is required by Cassandra output (ex: FluentdLoggers)" if self.keyspace.nil?
+      raise ConfigError, "'ColumnFamily' is required by Cassandra output (ex: events)" if self.columnfamily.nil?
+      raise ConfigError, "'Schema' is required by Cassandra output (ex: id,ts,payload)" if self.schema.nil?
+      raise ConfigError, "'Schema' must contain at least two column names (ex: id,ts,payload)" if self.schema.split(',').count < 2
+      raise ConfigError, "'DataKeys' is required by Cassandra output (ex: tag,created_at,data)" if self.data_keys.nil?
+
+      # convert schema from string to hash
+      # NOTE: ok to use eval b/c this isn't this isn't a user
+      #       supplied string
+      self.schema = eval(self.schema)
+
+      # convert data keys from string to array
+      self.data_keys = self.data_keys.split(',')
+
+      # split hosts to array
+      self.hosts = self.hosts.split(',')
+    end
+
+    def start
+      super
+      session
+    end
+
+    def shutdown
+      super
+      @session.close if @session
+    end
+
+    def format(tag, time, record)
+      record.to_msgpack
+    end
+
+    def write(chunk)
+      chunk.msgpack_each { |record|
+        values = build_insert_values_string(self.schema.keys, self.data_keys, record, self.pop_data_keys)
+
+        cql = "INSERT INTO #{self.columnfamily} (#{self.schema.keys.join(',')}) VALUES (#{values}) USING TTL #{self.ttl}"
+
+        @session.execute(cql)
+      }
+    end
+
+    private
+
+    def get_session(hosts, keyspace)
+      cluster = ::Cassandra.cluster(hosts: hosts)
+
+      cluster.connect(keyspace)
+    end
+
+    def build_insert_values_string(schema_keys, data_keys, record, pop_data_keys)
+      values = data_keys.map.with_index do |key, index|
+        if pop_data_keys
+          self.schema[schema_keys[index]] == :string ? "'#{record.delete(key)}'" : record.delete(key)
+        else
+          self.schema[schema_keys[index]] == :string ? "'#{record[key]}'" : record[key]
+        end
+      end
+
+      # if we have one more schema key than data keys,
+      # we can then infer that we should store the event
+      # as a string representation of the corresponding
+      # json object in the last schema column
+      if schema_keys.count == data_keys.count + 1
+        values << if record.count > 0
+                    "'#{record.to_json}'"
+                  else
+                    # by this point, the extra schema column has been
+                    # added to insert cql statement, so we must put
+                    # something in it
+                    # TODO: detect this scenario earlier and don't
+                    #       specify the column name/value at all
+                    #       when constructing the cql stmt
+                    "''"
+                  end
+      end
+
+      values.join(',')
+    end
+  end
+end

data/spec/cassandra_cql_output_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+Fluent::Test.setup
+
+SPEC_COLUMN_FAMILY = "spec_events"
+DATA_KEYS = "tag,time"
+
+CONFIG = %[
+  host 127.0.0.1
+  port 9160
+  keyspace FluentdLoggers
+  columnfamily #{SPEC_COLUMN_FAMILY}
+  ttl 0
+  schema {:id => :string, :ts => :bigint, :payload => :string}
+  data_keys #{DATA_KEYS}
+  pop_data_keys true
+]
+
+describe Fluent::CassandraCqlOutput do
+  include Helpers
+
+  let(:driver) { Fluent::Test::BufferedOutputTestDriver.new(Fluent::CassandraCqlOutput, 'test') }
+
+  after(:each) do
+    d = Fluent::Test::BufferedOutputTestDriver.new(Fluent::CassandraCqlOutput, 'test')
+    d.configure(CONFIG)
+    d.instance.session.execute("TRUNCATE #{SPEC_COLUMN_FAMILY}")
+  end
+
+  def set_config_value(config, config_name, value)
+    search_text = config.split("\n").map {|text| text if text.strip!.to_s.start_with? config_name.to_s}.compact![0]
+    config.gsub(search_text, "#{config_name} #{value}")
+  end
+
+  context 'configuring' do
+
+    it 'should be properly configured' do
+      driver.configure(CONFIG)
+      driver.tag.should eq('test')
+      driver.instance.host.should eq('127.0.0.1')
+      driver.instance.port.should eq(9160)
+      driver.instance.keyspace.should eq('FluentdLoggers')
+      driver.instance.columnfamily.should eq(SPEC_COLUMN_FAMILY)
+      driver.instance.ttl.should eq(0)
+    end
+
+    it 'should configure ttl' do
+      ttl = 20
+      driver.configure(set_config_value(CONFIG, :ttl, ttl))
+      driver.instance.ttl.should eq(ttl)
+    end
+
+    describe 'exceptions' do
+      it 'should raise an exception if host is not configured' do
+        expect { driver.configure(CONFIG.gsub("host", "invalid_config_name")) }.to raise_error Fluent::ConfigError
+      end
+
+      it 'should raise an exception if port is not configured' do
+        expect { driver.configure(CONFIG.gsub("port", "invalid_config_name")) }.to raise_error Fluent::ConfigError
+      end
+
+      it 'should raise an exception if keyspace is not configured' do
+        expect { driver.configure(CONFIG.gsub("keyspace", "invalid_config_name")) }.to raise_error Fluent::ConfigError
+      end
+
+      it 'should raise an exception if columnfamily is not configured' do
+        expect { driver.configure(CONFIG.gsub("columnfamily", "invalid_config_name")) }.to raise_error Fluent::ConfigError
+      end
+    end
+
+  end # context configuring
+
+  context 'logging' do
+
+    it 'should start' do
+      driver.configure(CONFIG)
+      driver.instance.start
+    end
+
+    it 'should shutdown' do
+      driver.configure(CONFIG)
+      driver.instance.start
+      driver.instance.shutdown
+    end
+
+    it 'should format' do
+      driver.configure(CONFIG)
+      time = Time.now.to_i
+      record = {'tag' => 'test', 'time' => time, 'a' => 1}
+
+      driver.emit(record)
+      driver.expect_format(record.to_msgpack)
+      driver.run
+    end
+
+    context 'writing' do
+      context 'as json' do
+
+        describe 'pop no data keys' do
+          it 'should store json in last column' do
+            driver.configure(set_config_value(CONFIG, :pop_data_keys, false))
+            write(driver, SPEC_COLUMN_FAMILY, false)
+          end
+        end
+
+        describe 'pop some data keys' do
+          it 'should store json in last last column' do
+            driver.configure(set_config_value(CONFIG, :pop_data_keys, true))
+            write(driver, SPEC_COLUMN_FAMILY, false)
+          end
+        end
+
+        describe 'pop all data keys' do
+          it 'should store empty string in last column' do
+            driver.configure(CONFIG)
+            write(driver, SPEC_COLUMN_FAMILY, true)
+          end
+        end
+
+      end # context as json
+
+      context 'as columns' do # no need to test popping of keys b/c it makes no difference
+
+        it 'should write' do
+          config = set_config_value(CONFIG, :data_keys, DATA_KEYS + ',a')
+          config = set_config_value(CONFIG, :pop_data_keys, false)
+          driver.configure(config)
+          write(driver, SPEC_COLUMN_FAMILY, false)
+        end
+
+      end # context as columns  
+
+      it 'should not locate event after ttl has expired' do
+        time = Time.now.to_i
+        tag = "ttl_test"
+        ttl = 1 # set ttl to 1 second
+
+        driver.configure(set_config_value(CONFIG, :ttl, ttl))
+        driver.emit({'tag' => tag, 'time' => time, 'a' => 1})
+        driver.run
+
+        # verify record... should return in less than one sec if hitting
+        #                  cassandra running on localhost
+        events = driver.instance.session.execute("SELECT * FROM #{SPEC_COLUMN_FAMILY} where ts = #{time}")
+        events.rows.should eq(1)
+
+        # now, sleep long enough for the event to be expired from cassandra
+        sleep(ttl + 1)
+
+        # re-query and verify that no events were returned
+        events = driver.instance.session.execute("SELECT * FROM #{SPEC_COLUMN_FAMILY} where ts = #{time}")
+        events.rows.should eq(0)
+      end
+
+    end # context writing
+
+  end # context logging
+
+end # CassandraOutput

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--format

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'simplecov'
+require 'rspec'
+require 'fluent/test'
+
+# require the library files
+Dir["./lib/**/*.rb"].each {|f| require f}
+
+# require the shared example files
+Dir["./spec/support/**/*.rb"].each {|f| require f}

data/spec/support/helpers.rb

@@ -0,0 +1,56 @@
+module Helpers
+  
+  def write(driver, column_family_name, tag_and_time_only)
+    tag1 = "test1"
+    tag2 = "test2"
+    time1 = Time.now.to_i
+    time2 = Time.now.to_i + 2
+
+    record1 = {'tag' => tag1, 'time' => time1}
+    record2 = {'tag' => tag2, 'time' => time2}
+
+    unless tag_and_time_only
+      record1.merge!({'a' => 10, 'b' => 'Tesla'})
+      record2.merge!({'a' => 20, 'b' => 'Edison'})
+    end
+
+    # store both records in an array
+    records = [record1, record2]
+
+    driver.emit(records[0])
+    driver.emit(records[1])
+    driver.run # persists to cassandra
+
+    # query cassandra to verify data was correctly persisted
+    row_num = records.count # non-zero based index
+    events = driver.instance.session.execute("SELECT * FROM #{column_family_name}")
+    events.rows.should eq(records.count)
+    events.fetch do | event | # events should be sorted desc by tag, then time
+      row_num -= 1 # zero-based index
+
+      record = records[row_num]
+      db_hash = event.to_hash
+
+      # need to take in account that we've popped both tag and time
+      # from the payload data when we saved it
+      if driver.instance.pop_data_keys
+        db_hash['id'].should eq(record.delete('tag'))
+        db_hash['ts'].should eq(record.delete('time'))
+      else
+        db_hash['id'].should eq(record['tag'])
+        db_hash['ts'].should eq(record['time'])
+      end
+
+      if driver.instance.schema.keys.count == driver.instance.data_keys.count + 1 # store as json
+        if record.count > 0
+          db_hash['payload'].should eq(record.to_json)
+        else
+          db_hash['payload'].should eq('')
+        end
+      else
+        db_hash['payload'].should eq(record[record.keys[db_hash.keys.index('payload')]])
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: fluent-plugin-cassandra-driver
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yaroslav Lukyanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-10 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.29
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.29
+- !ruby/object:Gem::Dependency
+  name: cassandra-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+- !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'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: Fluent output plugin for Cassandra via Datastax Ruby Driver for Apache
+  Cassandra
+email: c_sharp@mail.ru
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".rspec"
+- ".simplecov"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- fluent-plugin-cassandra-driver.gemspec
+- lib/fluent/plugin/out_cassandra_driver.rb
+- spec/cassandra_cql_output_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/support/helpers.rb
+homepage: https://github.com/CSharpRU/fluent-plugin-cassandra-driver
+licenses:
+- BSD-3-Clause
+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.6.8
+signing_key: 
+specification_version: 4
+summary: Fluent output plugin for Cassandra
+test_files: []