logstash-logger 0.15.2 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df9a6bdcc6c820482f78f45ca8df59d79e710326
-  data.tar.gz: 3970d44262a720e4e4a7ebae6d26429d437f8f7b
+  metadata.gz: c7f6fe8282858937026c5c9747835e68bd16390f
+  data.tar.gz: 8de048a5dab4c3a46e1f74fd7b192cc7e82ac58f
 SHA512:
-  metadata.gz: 656fab36ad7b8165f2f3266250f1ed5e9c804c2e0de86e5d742b70eff3a4340022968e9cd94c6aa3fb632674e581b0e59464f8f2b0785824e9d32ab2b717b4af
-  data.tar.gz: f0831f1e72cd7e1c604fcdf8519cf5cf6f31f60ad57fab6c69adbe5e14fe307eb315a60172c08cdfb7dd2bb7390bcd7d080d7c127b31ac944a2638136ff6b609
+  metadata.gz: c6e11150819e39e4ffb061160e332570a8d461974b88d6a933b6a9370c26bccde71a4f53942ddfc29b12e40f2f952df659c291a682dabd7a1a9f944430e02d37
+  data.tar.gz: 62077f3594cf26f2e92af9576bbd392e6059f7c141f5acc7d61e6ea850491f37eaaf642138d343c7b9d22436f8608ca3b9b3163941e9db0b7ce562dc4bae918a

data/.gitignore

@@ -18,3 +18,4 @@ test/version_tmp
 tmp
 .idea/
 log/
+.ruby-version

data/.travis.yml

@@ -2,16 +2,34 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1
-  - 2.2
+  - 2.1.9
+  - 2.2.5
+  - 2.3.1
   - jruby-19mode
-  - rbx-2
+  - jruby-9.0.5.0
+  - rbx-3.9
 gemfile:
   - gemfiles/rails_3.2.gemfile
   - gemfiles/rails_4.0.gemfile
   - gemfiles/rails_4.1.gemfile
   - gemfiles/rails_4.2.gemfile
+  - gemfiles/rails_5.0.gemfile
 matrix:
+  exclude:
+    - rvm: 1.9.3
+      gemfile: gemfiles/rails_5.0.gemfile
+    - rvm: jruby-19mode
+      gemfile: gemfiles/rails_5.0.gemfile
+    - rvm: 2.0.0
+      gemfile: gemfiles/rails_5.0.gemfile
+    - rvm: 2.1.9
+      gemfile: gemfiles/rails_5.0.gemfile
+    - rvm: 2.2.5
+      gemfile: gemfiles/rails_3.2.gemfile
+    - rvm: 2.3.1
+      gemfile: gemfiles/rails_3.2.gemfile
   allow_failures:
-    - rbx-2
+    -rvm: rbx-3.9
 sudo: false
+cache: bundler
+

data/Appraisals

@@ -13,3 +13,7 @@ end
 appraise "rails-4.2" do
   gem "rails", "~> 4.2.0"
 end
+
+appraise "rails-5.0" do
+  gem "rails", "~> 5.0.0"
+end

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 0.16.0
+
+This release is focused on improving the reliability of LogStashLogger.
+Connectable log devices are now less likely to block or
+raise an exception, which avoids impacting the operation of the program. There was
+also a fix to avoid leaking connections.
+
+- Allow log messages to be dropped. [#81](https://github.com/dwbutler/logstash-logger/pull/81)
+- Provide `max_message_size` option. [#80](https://github.com/dwbutler/logstash-logger/pull/80)
+- Unify error logging. [#82](https://github.com/dwbutler/logstash-logger/pull/82)
+- Drop message when there is an unrecoverable error. [#83](https://github.com/dwbutler/logstash-logger/pull/83)
+- Safely close connection when reconnecting. [#84](https://github.com/dwbutler/logstash-logger/pull/84)
+
 ## 0.15.2
 - Fixes Windows support. [#64](https://github.com/dwbutler/logstash-logger/issues/64)
 

data/README.md

@@ -162,6 +162,9 @@ input {
 }
 ```
 
+File and Redis inputs should use the `json` codec instead. For more information
+read the [Logstash docs](https://www.elastic.co/guide/en/logstash/current/plugins-codecs-json_lines.html).
+
 See the [samples](https://github.com/dwbutler/logstash-logger/tree/master/samples) directory for more configuration samples.
 
 ## SSL
@@ -237,16 +240,20 @@ This configuration would result in the following output.
 
 ## Buffering / Automatic Retries
 
-Log messages are buffered internally, and automatically re-sent if there is a connection problem.
+For devices that establish a connection to a remote service, log messages are buffered internally
+and automatically re-sent if there is a connection problem.
 Outputs that support batch writing (Redis and Kafka) will write log messages in bulk from the
 buffer. This functionality is implemented using
 [Stud::Buffer](https://github.com/jordansissel/ruby-stud/blob/master/lib/stud/buffer.rb).
 You can configure its behavior by passing the following options to LogStashLogger:
 
-    :buffer_max_items - Max number of items to buffer before flushing. Defaults to 50.
-    :buffer_max_interval - Max number of seconds to wait between flushes. Defaults to 5.
+* :buffer_max_items - Max number of items to buffer before flushing. Defaults to 50.
+* :buffer_max_interval - Max number of seconds to wait between flushes. Defaults to 5.
+* :drop_messages_on_flush_error - Drop messages when there is a flush error. Defaults to false.
+* :drop_messages_on_full_buffer - Drop messages when the buffer is full.
+  Defaults to true.
 
-You can turn this behavior off by setting `buffer_max_items` to `1` or `sync` to `true`.
+You can turn buffering off by setting `buffer_max_items` to `1` or `sync` to `true`.
 
 Please be aware of the following caveats to this behavior:
 
@@ -259,19 +266,29 @@ Please be aware of the following caveats to this behavior:
    immediately. In my testing, it took Ruby about 4 seconds to notice the receiving end was down
    and start raising exceptions. Since logstash listeners over TCP/UDP do not acknowledge received
    messages, it's not possible to know which log messages to re-send.
- * If your output source is unavailable long enough, writing to the log will block until it is
-   available again. This could make your application unresponsive.
+ * If your output source is unavailable long enough, the buffer will fill up
+   and messages will be dropped.
  * If your application suddenly terminates (for example, by SIGKILL or a power outage), the whole
    buffer will be lost.
 
-You can make message loss and application blockage less likely by increasing `buffer_max_items`
+By default, messages are discarded when the buffer gets full. This can happen
+if the output source is down for too long.
+You can make message loss less likely by increasing `buffer_max_items`
 (so that more events can be held in the buffer), and increasing `buffer_max_interval` (to wait
 longer between flushes). This will increase memory pressure on your application as log messages
 accumulate in the buffer, so make sure you have allocated enough memory to your process.
 
+## Error handling
+
+If an exception occurs while writing a message to the device, the exception is
+logged using an internal logger. By default, this logs to $stderr. You can
+change the error logger by setting `LogStashLogger.configuration.default_error_logger`, or by passsing
+your own logger object in the `:error_logger` configuration key when
+instantiating a LogStashLogger.
+
 ## Rails Integration
 
-Verified to work with both Rails 3 and 4.
+Verified to work with both Rails 3, 4, and 5.
 
 By default, every Rails log message will be written to logstash in `LogStash::Event` JSON format.
 
@@ -304,11 +321,20 @@ config.logstash.uri = ENV['LOGSTASH_URI']
 # they will all share the same formatter.
 config.logstash.formatter = :json_lines
 
+# Optional, the logger to log writing errors to. Defaults to logging to $stderr
+config.logstash.error_logger = Logger.new($stderr)
+
 # Optional, max number of items to buffer before flushing. Defaults to 50
 config.logstash.buffer_max_items = 50
 
 # Optional, max number of seconds to wait between flushes. Defaults to 5
 config.logstash.buffer_max_interval = 5
+
+# Optional, drop message when a connection error occurs. Defaults to false
+config.logstash.drop_messages_on_flush_error = false
+
+# Optional, drop messages when the buffer is full. Defaults to true
+config.logstash.drop_messages_on_full_buffer = true
 ```
 
 #### UDP
@@ -510,9 +536,9 @@ end
 
 Verified to work with:
 
-* MRI Ruby 1.9.3, 2.0.x, 2.1.x, 2.2.x
-* JRuby 1.7+
-* Rubinius 2.2+
+* MRI Ruby 1.9.3, 2.0, 2.1, 2.2, 2.3
+* JRuby 1.7, 9.0
+* Rubinius
 
 Ruby 1.8.7 is not supported.
 
@@ -556,6 +582,16 @@ If you're using UDP output and writing to a logstash listener, you are most like
 of the logstash listener. There is no known fix at this time. See [#43](https://github.com/dwbutler/logstash-logger/issues/43)
 for more information.
 
+### Errno::EMSGSIZE - Message too long
+A known drawback of using UDP is its limit on total message size. To workaround
+this issue, you will have to truncate the message by setting the max message size:
+
+```ruby
+LogStashLogger.configure do |config|
+  config.max_message_size = 2000
+end
+```
+
 ## Breaking changes
 
 ### Version 0.5+
@@ -594,6 +630,7 @@ logger = LogStashLogger.new('localhost', 5228, :tcp)
 * [Nikita Vorobei](https://github.com/Nikita-V)
 * [fireboy1919](https://github.com/fireboy1919)
 * [Mike Gunderloy](https://github.com/ffmike)
+* [Vitaly Gorodetsky](https://github.com/vitalis)
 
 ## Contributing
 

data/gemfiles/rails_5.0.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "codecov", :require => false, :group => :test
+gem "rails", "~> 5.0.0"
+
+gemspec :path => "../"

data/lib/logstash-logger/configuration.rb

@@ -10,9 +10,12 @@ module LogStashLogger
 
   class Configuration
     attr_accessor :customize_event_block
+    attr_accessor :max_message_size
+    attr_accessor :default_error_logger
 
     def initialize(*args)
       @customize_event_block = nil
+      @default_error_logger = Logger.new($stderr)
 
       yield self if block_given?
       self

data/lib/logstash-logger/device/balancer.rb

@@ -6,7 +6,7 @@ module LogStashLogger
       def initialize(opts)
         @io = self
         @devices = create_devices(opts[:outputs])
-        self.class.delegate_to_all(:close, :flush)
+        self.class.delegate_to_all(:close, :close!, :flush)
         self.class.delegate_to_one(:write)
       end
 

data/lib/logstash-logger/device/base.rb

@@ -3,9 +3,11 @@ module LogStashLogger
     class Base
       attr_reader :io
       attr_accessor :sync
+      attr_accessor :error_logger
 
       def initialize(opts={})
         @sync = opts[:sync]
+        @error_logger = opts.fetch(:error_logger, LogStashLogger.configuration.default_error_logger)
       end
 
       def to_io
@@ -13,20 +15,61 @@ module LogStashLogger
       end
 
       def write(message)
+        write_one(message)
+      end
+
+      def write_one(message)
         @io.write(message)
+      rescue => e
+        if unrecoverable_error?(e)
+          log_error(e)
+          log_warning("unrecoverable error, aborting write")
+        else
+          raise
+        end
+      end
+
+      def write_batch(messages, group = nil)
+        messages.each do |message|
+          write_one(message)
+        end
+      end
+
+      def write_batch(messages, group = nil)
+        messages.each do |message|
+          @io.write(message)
+        end
       end
 
       def flush
         @io && @io.flush
       end
 
-      def close
-        @io && @io.close
+      def close(opts = {})
+        close!
       rescue => e
-        warn "#{self.class} - #{e.class} - #{e.message}"
+        log_error(e)
+      end
+
+      def close!
+        @io && @io.close
       ensure
         @io = nil
       end
+
+      def unrecoverable_error?(e)
+        e.is_a?(JSON::GeneratorError)
+      end
+
+      private
+
+      def log_error(e)
+        error_logger.error "[#{self.class}] #{e.class} - #{e.message}"
+      end
+
+      def log_warning(message)
+        error_logger.warn("[#{self.class}] #{message}")
+      end
     end
   end
 end

data/lib/logstash-logger/device/connectable.rb

@@ -16,33 +16,69 @@ module LogStashLogger
           warn "The :batch_timeout option is deprecated. Please use :buffer_max_interval instead"
         end
 
+        @buffer_group = nil
         @buffer_max_items = opts[:batch_events] || opts[:buffer_max_items]
         @buffer_max_interval = opts[:batch_timeout] || opts[:buffer_max_interval]
+        @drop_messages_on_flush_error = 
+          if opts.key?(:drop_messages_on_flush_error)
+            opts.delete(:drop_messages_on_flush_error)
+          else
+            false
+          end
 
-        buffer_initialize max_items: @buffer_max_items, max_interval: @buffer_max_interval
+        @drop_messages_on_full_buffer =
+          if opts.key?(:drop_messages_on_full_buffer)
+            opts.delete(:drop_messages_on_full_buffer)
+          else
+            true
+          end
+
+        reset_buffer
       end
 
       def write(message)
-        buffer_receive message
+        buffer_receive message, @buffer_group
         buffer_flush(force: true) if @sync
+      rescue
       end
 
       def flush(*args)
         if args.empty?
           buffer_flush
         else
-          write_batch(args[0])
+          messages, group = *args
+          write_batch(messages, group)
         end
+      rescue
+        if @drop_messages_on_flush_error
+          reset_buffer
+        else
+          cancel_flush
+        end
+        raise
       end
 
-      def close
-        buffer_flush(final: true)
+      def on_flush_error(e)
+        raise e
+      end
+
+      def on_full_buffer_receive(args)
+        if @drop_messages_on_full_buffer
+          reset_buffer
+        end
+      end
+
+      def close(opts = {})
+        if opts.fetch(:flush, true)
+          buffer_flush(final: true)
+        end
+
         super
       end
 
       def to_io
         with_connection do
-          @io
+          super
         end
       end
 
@@ -50,11 +86,15 @@ module LogStashLogger
         !!@io
       end
 
-      def write_batch(messages)
+      def write_one(message)
         with_connection do
-          messages.each do |message|
-            @io.write(message)
-          end
+          super
+        end
+      end
+
+      def write_batch(messages, group = nil)
+        with_connection do
+          super
         end
       end
 
@@ -64,7 +104,7 @@ module LogStashLogger
       end
 
       def reconnect
-        @io = nil
+        close(flush: false)
         connect
       end
 
@@ -73,10 +113,41 @@ module LogStashLogger
         connect unless connected?
         yield
       rescue => e
-        warn "#{self.class} - #{e.class} - #{e.message}"
-        @io = nil
+        log_error(e)
+        close(flush: false)
         raise
       end
+
+      private
+
+      def reset_buffer
+        buffer_initialize max_items: @buffer_max_items, max_interval: @buffer_max_interval
+        @buffer_state[:timer] = Thread.new do
+          loop do
+            sleep(@buffer_config[:max_interval])
+            begin
+              buffer_flush(:force => true)
+            rescue
+            end
+          end
+        end
+      end
+
+      def buffer_clear_outgoing
+        @buffer_state[:outgoing_items] = Hash.new { |h, k| h[k] = [] }
+        @buffer_state[:outgoing_count] = 0
+      end
+
+      def cancel_flush
+        @buffer_state[:flush_mutex].lock rescue false
+        @buffer_state[:outgoing_items].each do |group, items|
+          @buffer_state[:pending_items][group].concat items
+        end
+        @buffer_state[:pending_count] += @buffer_state[:outgoing_count]
+        buffer_clear_outgoing
+      ensure
+        @buffer_state[:flush_mutex].unlock rescue false
+      end
     end
   end
 end

data/lib/logstash-logger/device/kafka.rb

@@ -20,59 +20,38 @@ module LogStashLogger
         @topic = opts[:path] || DEFAULT_TOPIC
         @producer = opts[:producer] || DEFAULT_PRODUCER
         @backoff = opts[:backoff] || DEFAULT_BACKOFF
+        @buffer_group = @topic
       end
 
       def connect
         @io = ::Poseidon::Producer.new(@hosts, @producer)
       end
 
-      def reconnect
-        @io.close
-        connect
-      end
-
       def with_connection
-        connect unless @io
+        connect unless connected?
         yield
       rescue ::Poseidon::Errors::ChecksumError, Poseidon::Errors::UnableToFetchMetadata => e
-        warn "#{self.class} - #{e.class} -> reconnect/retry"
+        log_error(e)
+        log_warning("reconnect/retry")
         sleep backoff if backoff
         reconnect
         retry
       rescue => e
-        warn "#{self.class} - #{e.class} - #{e.message} -> giving up"
-        @io = nil
+        log_error(e)
+        log_warning("giving up")
+        close(flush: false)
       end
 
-      def write(message)
-        buffer_receive Poseidon::MessageToSend.new(@topic, message)
-        buffer_flush(force: true) if @sync
-      end
-
-      def write_batch(messages)
+      def write_batch(messages, topic = nil)
+        topic ||= @topic
         with_connection do
-          @io.send_messages messages
+          @io.send_messages messages.map { |message| Poseidon::MessageToSend.new(topic, message) }
         end
       end
 
-      def close
-        buffer_flush(final: true)
-        @io && @io.close
-      rescue => e
-        warn "#{self.class} - #{e.class} - #{e.message}"
-      ensure
-        @io = nil
+      def write_one(message, topic = nil)
+        write_batch([message], topic)
       end
-
-      def flush(*args)
-        if args.empty?
-          buffer_flush
-        else
-          messages = *args.first
-          write_batch(messages)
-        end
-      end
-
     end
   end
 end

data/lib/logstash-logger/device/multi_delegator.rb

@@ -11,7 +11,7 @@ module LogStashLogger
       def initialize(opts)
         @io = self
         @devices = create_devices(opts[:outputs])
-        self.class.delegate(:write, :close, :flush)
+        self.class.delegate(:write, :close, :close!, :flush)
       end
 
       private

data/lib/logstash-logger/device/redis.rb

@@ -10,6 +10,7 @@ module LogStashLogger
       def initialize(opts)
         super
         @list = opts.delete(:list) || DEFAULT_LIST
+        @buffer_group = @list
 
         normalize_path(opts)
 
@@ -22,49 +23,37 @@ module LogStashLogger
 
       def reconnect
         @io.client.reconnect
+      rescue => e
+        log_error(e)
       end
 
       def with_connection
-        connect unless @io
+        connect unless connected?
         yield
       rescue ::Redis::InheritedError
         reconnect
         retry
       rescue => e
-        warn "#{self.class} - #{e.class} - #{e.message}"
-        @io = nil
+        log_error(e)
+        close(flush: false)
         raise
       end
 
-      def write(message)
-        buffer_receive message, @list
-        buffer_flush(force: true) if @sync
-      end
-
       def write_batch(messages, list = nil)
+        list ||= @list
         with_connection do
           @io.rpush(list, messages)
         end
       end
 
-      def close
-        buffer_flush(final: true)
-        @io && @io.quit
-      rescue => e
-        warn "#{self.class} - #{e.class} - #{e.message}"
-      ensure
-        @io = nil
+      def write_one(message, list = nil)
+        write_batch(message, list)
       end
 
-      def flush(*args)
-        if args.empty?
-          buffer_flush
-        else
-          messages, list = *args
-          write_batch(messages, list)
-        end
+      def close!
+        @io && @io.quit
       end
-      
+
       private
 
       def normalize_path(opts)

data/lib/logstash-logger/device/socket.rb

@@ -12,6 +12,10 @@ module LogStashLogger
         @port = opts[:port] || fail(ArgumentError, "Port is required")
         @host = opts[:host] || DEFAULT_HOST
       end
+
+      def unrecoverable_error?(e)
+        e.is_a?(Errno::EMSGSIZE) || super
+      end
     end
   end
 end

data/lib/logstash-logger/device/stderr.rb

@@ -5,7 +5,7 @@ module LogStashLogger
         super({io: $stderr}.merge(opts))
       end
 
-      def close
+      def close!
         # no-op
       end
     end

data/lib/logstash-logger/device/stdout.rb

@@ -5,7 +5,7 @@ module LogStashLogger
         super({io: $stdout}.merge(opts))
       end
 
-      def close
+      def close!
         # no-op
         # Calling $stdout.close would be a bad idea
       end

data/lib/logstash-logger/formatter/base.rb

@@ -44,6 +44,10 @@ module LogStashLogger
         if event.timestamp.is_a?(Time)
           event.timestamp = event.timestamp.iso8601(3)
         end
+
+        if LogStashLogger.configuration.max_message_size
+          event['message'.freeze] = event['message'.freeze].byteslice(0, LogStashLogger.configuration.max_message_size)
+        end
         
         event
       end

data/lib/logstash-logger/version.rb

@@ -1,3 +1,3 @@
 module LogStashLogger
-  VERSION = "0.15.2"
+  VERSION = "0.16.0"
 end

data/logstash-logger.gemspec

@@ -22,13 +22,20 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency 'stud'
 
   gem.add_development_dependency 'rails'
+  if RUBY_VERSION < '2'
+    gem.add_development_dependency 'mime-types', '< 3'
+  end
   gem.add_development_dependency 'redis'
   gem.add_development_dependency 'poseidon'
 
-  if RUBY_VERSION < '2'
+  if RUBY_VERSION < '2' || defined?(JRUBY_VERSION)
     gem.add_development_dependency 'SyslogLogger'
   end
 
+  if RUBY_VERSION < '2'
+    gem.add_development_dependency 'json', '~> 1.8'
+  end
+
   gem.add_development_dependency 'rspec', '>= 3'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'pry'

data/samples/redis.conf

@@ -1,7 +1,7 @@
 input {
   redis {
     data_type => "list"
-    codec => json_lines
+    codec => json
     key => "logstash"
   }
 }

data/spec/device/connectable_spec.rb

@@ -0,0 +1,74 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::Connectable do
+  include_context 'device'
+
+  let(:io) { double("IO") }
+
+  subject { udp_device }
+
+  describe "#reconnect" do
+    context "with active IO connection" do
+      before do
+        subject.instance_variable_set(:@io, io)
+      end
+
+      it "closes the connection" do
+        expect(io).to receive(:close).once
+        subject.reconnect
+      end
+    end
+
+    context "with no active IO connection" do
+      before do
+        subject.instance_variable_set(:@io, nil)
+      end
+
+      it "does nothing" do
+        expect(io).to_not receive(:close)
+        subject.reconnect
+      end
+    end
+  end
+
+  describe "#with_connection" do
+    context "on exception" do
+      before do
+        allow(subject).to receive(:connected?) { raise(StandardError) }
+        allow(subject).to receive(:warn)
+      end
+
+      context "with active IO connection" do
+        before do
+          subject.instance_variable_set(:@io, io)
+        end
+
+        it "closes the connection" do
+          expect(io).to receive(:close).once
+
+          expect {
+            subject.with_connection do |connection|
+              connection
+            end
+          }.to raise_error(StandardError)
+        end
+      end
+
+      context "with no active IO connection" do
+        before do
+          subject.instance_variable_set(:@io, nil)
+        end
+
+        it "does nothing" do
+          expect(io).to_not receive(:close)
+
+          expect {
+            subject.with_connection do |connection|
+              connection
+            end
+          }.to raise_error(StandardError)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logstash-logger
 version: !ruby/object:Gem::Version
-  version: 0.15.2
+  version: 0.16.0
 platform: ruby
 authors:
 - David Butler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-06 00:00:00.000000000 Z
+date: 2016-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logstash-event
@@ -170,6 +170,7 @@ files:
 - gemfiles/rails_4.0.gemfile
 - gemfiles/rails_4.1.gemfile
 - gemfiles/rails_4.2.gemfile
+- gemfiles/rails_5.0.gemfile
 - lib/logstash-logger.rb
 - lib/logstash-logger/configuration.rb
 - lib/logstash-logger/device.rb
@@ -211,6 +212,7 @@ files:
 - samples/unix.conf
 - spec/configuration_spec.rb
 - spec/device/balancer_spec.rb
+- spec/device/connectable_spec.rb
 - spec/device/file_spec.rb
 - spec/device/io_spec.rb
 - spec/device/kafka_spec.rb
@@ -256,13 +258,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: LogStash Logger for ruby
 test_files:
 - spec/configuration_spec.rb
 - spec/device/balancer_spec.rb
+- spec/device/connectable_spec.rb
 - spec/device/file_spec.rb
 - spec/device/io_spec.rb
 - spec/device/kafka_spec.rb