fluent-plugin-natsslv 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1f1463f9973bb01f1817079c834741f4f87ece31c992b9fb26051217b64ff428
+  data.tar.gz: 5b253259fc5b7422a346c4f5ef7ce61cd741b56d8a50a4eb1d90c0d4d38e61ac
+SHA512:
+  metadata.gz: bcea4a13f1f7375aa47e3e597d70af0192cbe51f18b0a99b184c640d96f668ce71ef1cbd0cad213f45a12b8f8f980bac8d515362b377202b54c9ed6a7bf78b54
+  data.tar.gz: 3154fcf6bf137366ca5f1d1bd136656cd18494411e46d1bae7d5ffd231688c9ff5e185df1f27a4da25a46e5c0c919d49ccc1ba0ade678d86f7ae387b67e75756

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+rvm:
+  - 2.4.2
+  - 2.3.5
+  - 2.2
+  - 2.1
+
+env:
+  global:
+    GNATSD_VERSION: 1.0.4
+
+before_install:
+  - sudo rm -f /usr/local/bin/gnatsd
+  - curl -L https://github.com/nats-io/gnatsd/releases/download/v${GNATSD_VERSION}/gnatsd-v${GNATSD_VERSION}-linux-amd64.zip > /tmp/gnatsd-v${GNATSD_VERSION}-linux-amd64.zip
+  - unzip /tmp/gnatsd-v${GNATSD_VERSION}-linux-amd64.zip -d /tmp
+  - sudo mv /tmp/gnatsd-v${GNATSD_VERSION}-linux-amd64/gnatsd /usr/local/bin/gnatsd

data/COPYING

@@ -0,0 +1,13 @@
+Copyright (C) 2012 Eduardo Aceituno <achied@gmail.com> All rights reserved.
+
+   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/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,91 @@
+fluent-plugin-nats
+==================
+
+[NATS](https://github.com/derekcollison/nats) plugin for
+[fluentd](https://github.com/fluent/fluentd) Event Collector
+
+[![Build Status](https://travis-ci.org/cloudfoundry-community/fluent-plugin-nats.svg?branch=master)](https://travis-ci.org/cloudfoundry-community/fluent-plugin-nats)
+
+## Requirements
+
+| fluent-plugin-nats | Fluentd     | Ruby   |
+|--------------------|-------------|--------|
+| >= 1.0.0           | >= v0.14.20 | >= 2.1 |
+| < 1.0.0            | >= v0.12.0  | >= 1.9 |
+
+# Getting Started
+Setup the NATS input:
+
+~~~~~
+  <source>
+    @type nats
+    tag nats
+    host localhost
+    port 4222
+    user nats
+    password nats
+    queues fluent.>,fluent2.>
+    ssl false
+  </source>
+~~~~~
+
+Setup the match output:
+
+~~~~
+  <match nats.fluent.**>
+    @type stdout
+  </match>
+~~~~
+
+# Configuration
+
+## Plugin helpers
+
+* thread
+
+* See also: Fluent::Plugin::Input
+
+## Fluent::Plugin::NATSInput
+
+* **host** (string) (optional): NATS server hostname
+  * Default value: `localhost`
+* **user** (string) (optional): Username for authorized connection
+  * Default value: `nats`
+* **password** (string) (optional): Password for authorized connection
+  * Default value: `nats`
+* **port** (integer) (optional): NATS server port
+  * Default value: `4222`
+* **queues** (array) (optional): Subscribing queue names
+  * Default value: `["fluent.>"]`
+* **queue** (string) (optional):
+  * Default value: `fluent.>`
+  * Obsoleted: Use `queues` instead
+* **tag** (string) (optional): The tag prepend before queue name
+  * Default value: `nats`
+* **ssl** (bool) (optional): Enable secure SSL/TLS connection
+  * Default value: `false`
+* **max_reconnect_attempts** (integer) (optional): The max number of reconnect tries
+  * Default value: `150`
+* **reconnect_time_wait** (integer) (optional): The number of seconds to wait between reconnect tries
+  * Default value: `2`
+
+# Suitable Queues
+
+## Components
+* dea.>
+* cloudcontrollers.>
+* router.>
+* cloudcontroller.>
+* vcap.>
+* droplet.>
+* healthmanager.>
+
+## Services
+* FilesystemaaS.>
+* AtmosaaS.>
+* MongoaaS.>
+* MyaaS.>
+* Neo4jaaS.>
+* AuaaS.>
+* RMQaaS.>
+* RaaS.>

data/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.test_files  = Dir['test/plugin/*.rb']
+  test.verbose = false
+  test.warning = false
+end
+
+task :default => :test

data/fluent-plugin-nats.gemspec

@@ -0,0 +1,25 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "fluent-plugin-natsslv"
+  gem.version     = "1.1.0"
+  gem.authors     = ["Eduardo Aceituno"]
+  gem.email       = ["achied@gmail.com"]
+  gem.homepage    = "https://github.com/achied/fluent-plugin-nats"
+  gem.summary     = %q{nats plugin for fluentd, an event collector}
+  gem.description = %q{nats plugin for fluentd, an event collector}
+  gem.license     = "Apache-2.0"
+
+  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.add_dependency "eventmachine", ">= 0.12.10"
+  gem.add_dependency "fluentd", ">= 0.14.20", "< 2"
+  gem.add_dependency "nats", ">= 0.4.22"
+
+  gem.add_development_dependency "rake", ">= 0.9.2"
+  gem.add_development_dependency "test-unit", "> 3.1"
+  gem.add_development_dependency "timecop"
+end

data/lib/fluent/plugin/in_nats.rb

@@ -0,0 +1,100 @@
+require "fluent/plugin/input"
+require "nats/client"
+
+module Fluent
+  module Plugin
+    class NATSInput < Fluent::Plugin::Input
+      Fluent::Plugin.register_input("natssl", self)
+
+      helpers :thread
+
+      desc "NATS server hostname"
+      config_param :host, :string, default: "localhost"
+      desc "NATS server port"
+      config_param :port, :integer, default: 4222
+      desc "Username for authorized connection"
+      config_param :user, :string, default: "nats"
+      desc "Password for authorized connection"
+      config_param :password, :string, default: "nats", secret: true
+      desc "Subscribing queue names"
+      config_param :queues, :array, default: ["fluent.>"]
+      config_param :queue, :string, default: "fluent.>", obsoleted: "Use `queues` instead"
+      desc "The tag prepend before queue name"
+      config_param :tag, :string, default: "nats"
+      desc "Enable secure SSL/TLS connection"
+      config_param :ssl, :bool, default: false
+      desc "Ignore SSL certificate verification"
+      config_param :ignore_ssl_verification, :bool, default: false
+      desc "The max number of reconnect tries"
+      config_param :max_reconnect_attempts, :integer, default: 150
+      desc "The number of seconds to wait between reconnect tries"
+      config_param :reconnect_time_wait, :integer, default: 2
+
+      def configure(conf)
+        super
+
+        @nats_config = {
+          uri: "nats://#{@host}:#{@port}",
+          ssl: @ssl,
+          user: @user,
+          pass: @password,
+          reconnect_time_wait: @reconnect_time_wait,
+          max_reconnect_attempts: @max_reconnect_attempts,
+        }
+
+        if @ssl && @ignore_ssl_verification
+          @nats_config[:tls] = {
+            verify_peer: false
+          }
+        end
+      end
+
+      def start
+        super
+        NATS.on_error do |error|
+          log.error "Server Error:", error: error
+          # supervisor will restart worker
+          exit!
+        end
+        run_reactor_thread
+        thread_create(:nats_input_main, &method(:run))
+        log.info "listening nats on #{@uri}/#{@queue}"
+      end
+
+      def shutdown
+        @nats_conn.close
+        EM.stop if EM.reactor_running?
+        super
+      end
+
+      def run
+        EM.next_tick do
+          @nats_conn = NATS.connect(@nats_config) do
+            @queues.each do |queue|
+              @nats_conn.subscribe(queue) do |msg, _reply, sub|
+                tag = "#{@tag}.#{sub}"
+                begin
+                  message = JSON.parse(msg)
+                rescue JSON::ParserError => e
+                  log.error "Failed parsing JSON #{e.inspect}.  Passing as a normal string"
+                  message = msg
+                end
+                time = Engine.now
+                router.emit(tag, time, message || {})
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def run_reactor_thread
+        return if EM.reactor_running?
+        thread_create(:nats_input_reactor_thread) do
+          EM.run
+        end
+      end
+    end
+  end
+end

data/lib/fluent/plugin/out_nats.rb

@@ -0,0 +1,90 @@
+require "fluent/plugin/output"
+require "nats/client"
+
+module Fluent
+  module Plugin
+    class NATSOutput < Fluent::Plugin::Output
+      Fluent::Plugin.register_output('natssl', self)
+
+      helpers :formatter, :thread, :inject
+
+      DEFAULT_FORMAT_TYPE = 'json'
+
+      desc "NATS server hostname"
+      config_param :host, :string, default: "localhost"
+      desc "NATS server port"
+      config_param :port, :integer, default: 4222
+      desc "Username for authorized connection"
+      config_param :user, :string, default: "nats"
+      desc "Password for authorized connection"
+      config_param :password, :string, default: "nats", secret: true
+      desc "Enable secure SSL/TLS connection"
+      config_param :ssl, :bool, default: false
+      desc "The max number of reconnect tries"
+      config_param :max_reconnect_attempts, :integer, default: 150
+      desc "The number of seconds to wait between reconnect tries"
+      config_param :reconnect_time_wait, :integer, default: 2
+
+      config_section :format do
+        config_set_default :@type, DEFAULT_FORMAT_TYPE
+        config_set_default :add_newline, false
+      end
+
+      def multi_workers_ready?
+        true
+      end
+
+      attr_accessor :formatter
+
+      def configure(conf)
+        super
+
+        @nats_config = {
+          uri: "nats://#{@host}:#{@port}",
+          ssl: @ssl,
+          user: @user,
+          pass: @password,
+          reconnect_time_wait: @reconnect_time_wait,
+          max_reconnect_attempts: @max_reconnect_attempts,
+        }
+        @formatter = formatter_create
+      end
+
+      def start
+        super
+        thread_create(:nats_output_main, &method(:run))
+      end
+
+      def shutdown
+        EM.next_tick do
+          NATS.stop
+        end
+        super
+      end
+
+      def run
+        NATS.on_error do |error|
+          log.error "Server Error:", error: error
+          # supervisor will restart worker
+          exit!
+        end
+        NATS.start(@nats_config) do
+          log.info "nats client is running for #{@nats_config[:uri]}"
+        end
+      end
+
+      def process(tag, es)
+        es = inject_values_to_event_stream(tag, es)
+        es.each do |time,record|
+          EM.next_tick do
+            NATS.publish(tag, format(tag, time, record))
+          end
+        end
+      end
+
+      def format(tag, time, record)
+        @formatter.format(tag, time, record)
+      end
+    end
+  end
+end

data/test/nats-publish-message.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nats/client"
+require "optparse"
+require "uri"
+
+def main(argv)
+  uri = nil
+  queue = nil
+  message = nil
+  parser = OptionParser.new
+  parser.on("--uri=URI", "NATS server URI") do |value|
+    uri = URI.parse(value)
+  end
+  parser.on("--queue=QUEUE", "Queue names") do |value|
+    queue = value
+  end
+  parser.on("--message=MESSAGE", "Message JSON") do |value|
+    message = value
+  end
+  begin
+    parser.parse!
+  rescue OptionParser::ParseError => ex
+    puts ex.message
+  end
+  options = {
+    uri: uri.to_s
+  }
+  options[:user] = uri.user if uri.user
+  options[:pass] = uri.password if uri.password
+  NATS.start(options) do
+    NATS.publish(queue, message) do
+      sleep 0.5
+      NATS.stop
+    end
+  end
+end
+
+main(ARGV)

data/test/plugin/test_in_nats.rb

@@ -0,0 +1,237 @@
+require "test_helper"
+require "fluent/test/driver/input"
+require "fluent/plugin/in_nats"
+
+class NATSInputTest < Test::Unit::TestCase
+  include NATSTestHelper
+
+  CONFIG = %[
+    port 4222
+    host localhost
+    user nats
+    password nats
+  ]
+
+  def basic_queue_conf
+    CONFIG + %[
+      queues fluent.>
+    ]
+  end
+
+  def multiple_queue_conf
+    CONFIG + %[
+      queues fluent.>, fluent2.>
+    ]
+  end
+
+  def ssl_conf
+    basic_queue_conf + %[
+      ssl true
+    ]
+  end
+
+  def create_driver(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::NATSInput).configure(conf)
+  end
+
+  def setup
+    Fluent::Test.setup
+    @time = Time.parse("2011-01-02 13:14:15 UTC")
+    Timecop.freeze(@time)
+  end
+
+  def teardown
+    Timecop.return
+  end
+
+  sub_test_case "configure" do
+    test "basic" do
+      d = create_driver basic_queue_conf
+      assert_equal 4222, d.instance.port
+      assert_equal "localhost", d.instance.host
+      assert_equal "nats", d.instance.user
+      assert_equal "nats", d.instance.password
+      assert_equal ["fluent.>"], d.instance.queues
+    end
+
+    test "multiple queue" do
+      d = create_driver multiple_queue_conf
+      assert_equal 4222, d.instance.port
+      assert_equal "localhost", d.instance.host
+      assert_equal "nats", d.instance.user
+      assert_equal "nats", d.instance.password
+      assert_equal ["fluent.>", "fluent2.>"], d.instance.queues
+    end
+
+    test "basic with ssl" do
+      d = create_driver ssl_conf
+      assert_equal 4222, d.instance.port
+      assert_equal "localhost", d.instance.host
+      assert_equal "nats", d.instance.user
+      assert_equal "nats", d.instance.password
+      assert_equal ["fluent.>"], d.instance.queues
+      assert_equal true, d.instance.ssl
+    end
+  end
+
+  sub_test_case "events" do
+    test "with credentials" do
+      d = create_driver basic_queue_conf
+
+      time = @time.to_i
+
+      records = [
+        ["nats.fluent.test1", time, { "message" => "nats", "fluent_timestamp" => time }],
+        ["nats.fluent.test2", time, { "message" => "nats", "fluent_timestamp" => time }]
+      ]
+
+      uri = generate_uri(d)
+
+      run_server(uri) do
+        d.run(expect_records: records.size, timeout: 5) do
+          records.each do |tag, _time, record|
+            send(uri, tag[5..-1], record)
+          end
+        end
+        assert_equal(records, d.events)
+      end
+    end
+
+    test "without credentials" do
+      d = create_driver basic_queue_conf
+      time = @time.to_i
+
+      records = [
+        ["nats.fluent.test1", time, { "message" => "nats", "fluent_timestamp" => time }],
+        ["nats.fluent.test2", time, { "message" => "nats", "fluent_timestamp" => time }]
+      ]
+
+      uri = generate_uri(d)
+
+      run_server(uri) do
+        d.run(expect_records: records.size, timeout: 5) do
+          records.each do |tag, _time, record|
+            send(uri, tag[5..-1], record)
+          end
+        end
+        assert_equal(records, d.events)
+      end
+    end
+
+    test "multiple queues" do
+      d = create_driver multiple_queue_conf
+      time = @time.to_i
+
+      records = [
+        ["nats.fluent.test1", time, { "message" => "nats", "fluent_timestamp" => time }],
+        ["nats.fluent.test2", time, { "message" => "nats", "fluent_timestamp" => time }],
+        ["nats.fluent2.test1", time, { "message" => "nats", "fluent_timestamp" => time }],
+        ["nats.fluent2.test2", time, { "message" => "nats", "fluent_timestamp" => time }]
+      ]
+
+      uri = generate_uri(d)
+
+      run_server(uri) do
+        d.run(expect_records: records.size, timeout: 5) do
+          records.each do |tag, _time, record|
+            send(uri, tag[5..-1], record)
+          end
+        end
+        assert_equal(records, d.events)
+      end
+    end
+
+    test "without fluent timestamp" do
+      d = create_driver basic_queue_conf
+      time = Time.now.to_i
+
+      records = [
+        ["nats.fluent.test1", time, { "message" => "nats" }]
+      ]
+
+      uri = generate_uri(d)
+      run_server(uri) do
+        d.run(expect_records: records.size, timeout: 5) do
+          records.each do |tag, _time, record|
+            send(uri, tag[5..-1], record)
+          end
+        end
+        assert_equal(records, d.events)
+      end
+    end
+
+    test "arrays" do
+      d = create_driver basic_queue_conf
+      time = Time.now.to_i
+
+      records = [
+        ["nats.fluent.empty_array", time, []],
+        ["nats.fluent.string_array", time, %w(one two three)]
+      ]
+
+      uri = generate_uri(d)
+      run_server(uri) do
+        d.run(expect_records: records.size, timeout: 5) do
+          records.each do |tag, _time, record|
+            send(uri, tag[5..-1], record)
+          end
+        end
+        assert_equal(records, d.events)
+      end
+    end
+
+    test "empty publish string" do
+      d = create_driver basic_queue_conf
+      time = Time.now.to_i
+
+      records = [
+        ["nats.fluent.nil", time, {}]
+      ]
+
+      uri = generate_uri(d)
+      run_server(uri) do
+        d.run(expect_records: records.size, timeout: 5) do
+          records.each do |tag, _time, _record|
+            send(uri, tag[5..-1], nil)
+          end
+        end
+        assert_equal(records, d.events)
+      end
+    end
+
+    test "regular publish string" do
+      d = create_driver basic_queue_conf
+      time = Time.now.to_i
+
+      records = [
+        ["nats.fluent.string", time, "Lorem ipsum dolor sit amet"]
+      ]
+
+      uri = generate_uri(d)
+      run_server(uri) do
+        d.run(expect_records: records.size, timeout: 5) do
+          records.each do |tag, _time, _record|
+            send(uri, tag[5..-1], "Lorem ipsum dolor sit amet")
+          end
+        end
+        assert_equal(records, d.events)
+      end
+    end
+  end
+
+  def send(uri, tag, msg)
+    system("test/nats-publish-message.rb", "--uri", uri, "--queue", tag, "--message", msg.to_json)
+  end
+
+  def generate_uri(driver)
+    user = driver.instance.user
+    pass = driver.instance.password
+    host = driver.instance.host
+    port = driver.instance.port
+    if user && pass
+      "nats://#{user}:#{pass}@#{host}:#{port}"
+    else
+      "nats://#{host}:#{port}"
+    end
+  end
+end

data/test/plugin/test_out_nats.rb

@@ -0,0 +1,80 @@
+require "test_helper"
+require "fluent/test/driver/output"
+require "fluent/test/driver/input"
+require "fluent/plugin/out_nats"
+require "fluent/plugin/in_nats"
+require "fluent/time"
+
+class NATSOutputTest < Test::Unit::TestCase
+  include NATSTestHelper
+
+  CONFIG = %[
+    port 4222
+    host localhost
+    user nats
+    password nats
+  ]
+
+  CONFIG_INPUT = CONFIG + %[
+    queues test.>
+    tag nats
+  ]
+
+  def create_driver(conf)
+    Fluent::Test::Driver::Output.new(Fluent::Plugin::NATSOutput).configure(conf)
+  end
+
+  def create_input_driver(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::NATSInput).configure(conf)
+  end
+
+  def setup
+    Fluent::Test.setup
+    @time = Time.parse("2011-01-02 13:14:15 UTC")
+    Timecop.freeze(@time)
+  end
+
+  def teardown
+    Timecop.return
+  end
+
+  test "configuration test" do
+    d = create_driver(CONFIG)
+    assert_equal 4222, d.instance.port
+    assert_equal "localhost", d.instance.host
+    assert_equal "nats", d.instance.user
+    assert_equal "nats", d.instance.password
+  end
+
+  test "publish an event to NATS" do
+    d = create_driver(CONFIG)
+    input_driver = create_input_driver(CONFIG_INPUT)
+
+    time = Fluent::EventTime.now
+
+    uri = generate_uri(d)
+
+    run_server(uri) do
+      input_driver.run(expect_records: 1) do
+        d.run(default_tag: 'test.log') do
+          d.feed(time, {"test" => "test1"})
+        end
+      end
+    end
+    event = input_driver.events[0]
+    assert_equal(event[0], 'nats.test.log')
+    assert_equal(event[2], {"test" => "test1"})
+  end
+
+  def generate_uri(driver)
+    user = driver.instance.user
+    pass = driver.instance.password
+    host = driver.instance.host
+    port = driver.instance.port
+    if user && pass
+      "nats://#{user}:#{pass}@#{host}:#{port}"
+    else
+      "nats://#{host}:#{port}"
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+require "bundler/setup"
+require "test/unit"
+
+$LOAD_PATH.unshift(File.join(__dir__, "..", "lib"))
+$LOAD_PATH.unshift(__dir__)
+require "fluent/test"
+require "nats/client"
+require "timecop"
+
+module NATSTestHelper
+  def run_server(uri)
+    uri = URI.parse(uri)
+    unless NATS.server_running?(uri)
+      args = prepare_args(uri)
+      # We can invoke gnatsd before run test
+      pid = spawn("gnatsd", *args, out: "/dev/null", err: "/dev/null")
+      NATS.wait_for_server(uri, 10)
+    end
+    yield
+  rescue
+    raise
+  ensure
+    Process.kill(:INT, pid) if pid
+  end
+
+  def prepare_args(uri)
+    args = ["-p", uri.port.to_s]
+    args.push("--user", uri.user) if uri.user
+    args.push("--pass", uri.password) if uri.password
+    args.push(*@flags) if @flags
+    args
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: fluent-plugin-natsslv
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Eduardo Aceituno
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.20
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.20
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: nats
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.22
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.22
+- !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
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  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: nats plugin for fluentd, an event collector
+email:
+- achied@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- COPYING
+- Gemfile
+- README.md
+- Rakefile
+- fluent-plugin-nats.gemspec
+- lib/fluent/plugin/in_nats.rb
+- lib/fluent/plugin/out_nats.rb
+- test/nats-publish-message.rb
+- test/plugin/test_in_nats.rb
+- test/plugin/test_out_nats.rb
+- test/test_helper.rb
+homepage: https://github.com/achied/fluent-plugin-nats
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: nats plugin for fluentd, an event collector
+test_files: []