log-courier 1.3 → 1.6.pre.40.g3efb33c

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 645bd508ce891c3fb1fd69c4a414758fdc55c867
-  data.tar.gz: c4b14fb6f9cc1b75ac2c886d0162b543246ef5c5
+  metadata.gz: 3d3903076cfa365c6fc3b3732c4990d84b7dcb13
+  data.tar.gz: 391ef46aae7fa0d1da6719a8fa6913b61fa4d6e9
 SHA512:
-  metadata.gz: 2f512338b7e7a11fff7293a9006ef5a924596f5b7f40863e5f12a68297588e1969628aa6b3730b30bac9464071d9da63186aac9c460bfbe8f92219f42f6731e2
-  data.tar.gz: 736be3625601a89409beee281f432e6450af0a76aa040eb916e848512cfcb195b8bd6b0c6ef013e0a0757fe5237f35acdf9bd273ffe34a9c765e5f81ac4ab841
+  metadata.gz: db9e733ccac3f49b2a16658ebe60783e1249831f1bfb3225520ac6d325e6a99e4aa33c419276cb27ceb4598720bbf7caea8b65eb5a9f56d7fc35386d8655c6ab
+  data.tar.gz: a1be65639cbd57b7c0c1e503d122d1498bcb70c90cb015b9e74cbf7a6d756932c2019e2b381977711c8840f5f5fff30d508f8c57cd8b6c5984ac4f5dc7cd4254

data/lib/log-courier/client.rb

@@ -25,6 +25,7 @@ require 'zlib'
 class NativeException; end
 
 module LogCourier
+  class TimeoutError < StandardError; end
   class ShutdownSignal < StandardError; end
   class ProtocolError < StandardError; end
 
@@ -77,12 +78,14 @@ module LogCourier
         lines = @sequence_len - @last_sequence
         @last_sequence = sequence
         @payload = nil
+        @events = []
         return lines, true
       end
 
       lines = sequence - @last_sequence
       @last_sequence = sequence
       @payload = nil
+      @events.shift(lines)
       return lines, false
     end
   end
@@ -92,15 +95,26 @@ module LogCourier
     def initialize(options = {})
       @options = {
         logger:       nil,
+        transport:    'tls',
         spool_size:   1024,
-        idle_timeout: 5
+        idle_timeout: 5,
+        port:         nil,
+        addresses:    [],
       }.merge!(options)
 
       @logger = @options[:logger]
-      @logger['plugin'] = 'output/courier'
+      @logger['plugin'] = 'output/courier' unless @logger.nil?
 
-      require 'log-courier/client_tls'
-      @client = ClientTls.new(@options)
+      case @options[:transport]
+      when 'tcp', 'tls'
+        require 'log-courier/client_tcp'
+        @client = ClientTcp.new(@options)
+      else
+        fail 'output/courier: \'transport\' must be tcp or tls'
+      end
+
+      fail 'output/courier: \'addresses\' must contain at least one address' if @options[:addresses].empty?
+      fail 'output/courier: \'addresses\' only supports a single address at this time' if @options[:addresses].length > 1
 
       @event_queue = EventQueue.new @options[:spool_size]
       @pending_payloads = {}
@@ -115,6 +129,16 @@ module LogCourier
         run_spooler
       end
 
+      # TODO: Make these configurable?
+      @keepalive_timeout = 1800
+      @network_timeout = 30
+
+      # TODO: Make pending payload max configurable?
+      @max_pending_payloads = 100
+
+      @retry_payload = nil
+      @received_payloads = Queue.new
+
       @pending_ping = false
 
       # Start the IO thread
@@ -130,11 +154,17 @@ module LogCourier
       return
     end
 
-    def shutdown
-      # Raise a shutdown signal in the spooler and wait for it
-      @spooler_thread.raise ShutdownSignal
-      @io_thread.raise ShutdownSignal
-      @spooler_thread.join
+    def shutdown(force=false)
+      if force
+        # Raise a shutdown signal in the spooler and wait for it
+        @spooler_thread.raise ShutdownSignal
+        @spooler_thread.join
+        @io_thread.raise ShutdownSignal
+      else
+        @event_queue.push nil
+        @spooler_thread.join
+        @io_control << ['!', nil]
+      end
       @io_thread.join
       return @pending_payloads.length == 0
     end
@@ -150,7 +180,13 @@ module LogCourier
         begin
           loop do
             event = @event_queue.pop next_flush - Time.now.to_i
+
+            if event.nil?
+              raise ShutdownSignal
+            end
+
             spooled.push(event)
+
             break if spooled.length >= @options[:spool_size]
           end
         rescue TimeoutError
@@ -158,12 +194,19 @@ module LogCourier
           next if spooled.length == 0
         end
 
+        if spooled.length >= @options[:spool_size]
+          @logger.debug 'Flushing full spool', :events => spooled.length unless @logger.nil?
+        else
+          @logger.debug 'Flushing spool due to timeout', :events => spooled.length unless @logger.nil?
+        end
+
         # Pass through to io_control but only if we're ready to send
         @send_mutex.synchronize do
-          @send_cond.wait(@send_mutex) unless @send_ready
+          @send_cond.wait(@send_mutex) until @send_ready
           @send_ready = false
-          @io_control << ['E', spooled]
         end
+
+        @io_control << ['E', spooled]
       end
       return
     rescue ShutdownSignal
@@ -171,118 +214,17 @@ module LogCourier
     end
 
     def run_io
-      # TODO: Make keepalive configurable?
-      @keepalive_timeout = 1800
-
-      # TODO: Make pending payload max configurable?
-      max_pending_payloads = 100
-
-      retry_payload = nil
-
-      can_send = true
-
       loop do
         # Reconnect loop
         @client.connect @io_control
 
-        reset_keepalive
+        @timeout = Time.now.to_i + @keepalive_timeout
 
-        # Capture send exceptions
-        begin
-          # IO loop
-          loop do
-            catch :keepalive do
-              begin
-                action = @io_control.pop @keepalive_next - Time.now.to_i
-
-                # Process the action
-                case action[0]
-                when 'S'
-                  # If we're flushing through the pending, pick from there
-                  unless retry_payload.nil?
-                    # Regenerate data if we need to
-                    retry_payload.data = buffer_jdat_data(retry_payload.events, retry_payload.nonce) if retry_payload.data == nil
-
-                    # Send and move onto next
-                    @client.send 'JDAT', retry_payload.data
-
-                    retry_payload = retry_payload.next
-                    throw :keepalive
-                  end
-
-                  # Ready to send, allow spooler to pass us something
-                  @send_mutex.synchronize do
-                    @send_ready = true
-                    @send_cond.signal
-                  end
-
-                  can_send = true
-                when 'E'
-                  # If we have too many pending payloads, pause the IO
-                  if @pending_payloads.length + 1 >= max_pending_payloads
-                    @client.pause_send
-                  end
-
-                  # Received some events - send them
-                  send_jdat action[1]
-
-                  # The send action will trigger another "S" if we have more send buffer
-                  can_send = false
-                when 'R'
-                  # Received a message
-                  signature, message = action[1..2]
-                  case signature
-                  when 'PONG'
-                    process_pong message
-                  when 'ACKN'
-                    process_ackn message
-                  else
-                    # Unknown message - only listener is allowed to respond with a "????" message
-                    # TODO: What should we do? Just ignore for now and let timeouts conquer
-                  end
-                when 'F'
-                  # Reconnect, an error occurred
-                  break
-                end
-              rescue TimeoutError
-                # Keepalive timeout hit, send a PING unless we were awaiting a PONG
-                if @pending_ping
-                  # Timed out, break into reconnect
-                  fail TimeoutError
-                end
-
-                # Is send full? can_send will be false if so
-                # We should've started receiving ACK by now so time out
-                fail TimeoutError unless can_send
-
-                # Send PING
-                send_ping
-
-                # We may have filled send buffer
-                can_send = false
-              end
-            end
-
-            # Reset keepalive timeout
-            reset_keepalive
-          end
-        rescue ProtocolError => e
-          # Reconnect required due to a protocol error
-          @logger.warn 'Protocol error', :error => e.message unless @logger.nil?
-        rescue TimeoutError
-          # Reconnect due to timeout
-          @logger.warn 'Timeout occurred' unless @logger.nil?
-        rescue ShutdownSignal
-          # Shutdown, break out
-          break
-        rescue StandardError, NativeException => e
-          # Unknown error occurred
-          @logger.warn e, :hint => 'Unknown error' unless @logger.nil?
-        end
+        run_io_loop
 
         # Disconnect and retry payloads
         @client.disconnect
-        retry_payload = @first_payload
+        @retry_payload = @first_payload
 
         # TODO: Make reconnect time configurable?
         sleep 5
@@ -290,11 +232,164 @@ module LogCourier
 
       @client.disconnect
       return
+    rescue ShutdownSignal
+      # Ensure disconnected
+      @client.disconnect
     end
 
-    def reset_keepalive
-      @keepalive_next = Time.now.to_i + @keepalive_timeout
-      return
+    def run_io_loop()
+      io_stop = false
+      can_send = false
+
+      # IO loop
+      loop do
+        begin
+          action = @io_control.pop @timeout - Time.now.to_i
+
+          # Process the action
+          case action[0]
+          when 'S'
+            # If we're flushing through the pending, pick from there
+            unless @retry_payload.nil?
+              @logger.debug 'Send is ready, retrying previous payload' unless @logger.nil?
+
+              # Regenerate data if we need to
+              @retry_payload.generate if @retry_payload.payload.nil?
+
+              # Send and move onto next
+              @client.send 'JDAT', @retry_payload.payload
+
+              @retry_payload = @retry_payload.next
+
+              # If first send, exit idle mode
+              if @retry_payload == @first_payload
+                @timeout = Time.now.to_i + @network_timeout
+              end
+              next
+            end
+
+            # Ready to send, allow spooler to pass us something if we don't
+            # have something already
+            if @received_payloads.length != 0
+              @logger.debug 'Send is ready, using events from backlog' unless @logger.nil?
+              send_payload @received_payloads.pop()
+            else
+              @logger.debug 'Send is ready, requesting events' unless @logger.nil?
+
+              can_send = true
+
+              @send_mutex.synchronize do
+                @send_ready = true
+                @send_cond.signal
+              end
+            end
+          when 'E'
+            # Were we expecting a payload? Store it if not
+            if can_send
+              @logger.debug 'Sending events', :events => action[1].length unless @logger.nil?
+              send_payload action[1]
+              can_send = false
+            else
+              @logger.debug 'Events received when not ready; saved to backlog' unless @logger.nil?
+              @received_payloads.push action[1]
+            end
+          when 'R'
+            # Received a message
+            signature, message = action[1..2]
+            case signature
+            when 'PONG'
+              process_pong message
+            when 'ACKN'
+              process_ackn message
+            else
+              # Unknown message - only listener is allowed to respond with a "????" message
+              # TODO: What should we do? Just ignore for now and let timeouts conquer
+            end
+
+            # Any pending payloads left?
+            if @pending_payloads.length == 0
+              # Handle shutdown
+              if io_stop
+                raise ShutdownSignal
+              end
+
+              # Enter idle mode
+              @timeout = Time.now.to_i + @keepalive_timeout
+            else
+              # Set network timeout
+              @timeout = Time.now.to_i + @network_timeout
+            end
+          when 'F'
+            # Reconnect, an error occurred
+            break
+          when '!'
+            @logger.debug 'Shutdown request received' unless @logger.nil?
+
+            # Shutdown request received
+            if @pending_payloads.length == 0
+              raise ShutdownSignal
+            end
+
+            @logger.debug 'Delaying shutdown due to pending payloads', :payloads => @pending_payloads.length unless @logger.nil?
+
+            io_stop = true
+
+            # Stop spooler sending
+            can_send = false
+            @send_mutex.synchronize do
+              @send_ready = false
+            end
+          end
+        rescue TimeoutError
+          if @pending_payloads != 0
+            # Network timeout
+            fail TimeoutError
+          end
+
+          # Keepalive timeout hit, send a PING unless we were awaiting a PONG
+          if @pending_ping
+            # Timed out, break into reconnect
+            fail TimeoutError
+          end
+
+          # Stop spooler sending
+          can_send = false
+          @send_mutex.synchronize do
+            @send_ready = false
+          end
+
+          # Send PING
+          send_ping
+
+          @timeout = Time.now.to_i + @network_timeout
+        end
+      end
+    rescue ProtocolError => e
+      # Reconnect required due to a protocol error
+      @logger.warn 'Protocol error', :error => e.message unless @logger.nil?
+    rescue TimeoutError
+      # Reconnect due to timeout
+      @logger.warn 'Timeout occurred' unless @logger.nil?
+    rescue ShutdownSignal => e
+      raise
+    rescue StandardError, NativeException => e
+      # Unknown error occurred
+      @logger.warn e, :hint => 'Unknown error' unless @logger.nil?
+    end
+
+    def send_payload(payload)
+      # If we have too many pending payloads, pause the IO
+      if @pending_payloads.length + 1 >= @max_pending_payloads
+        @client.pause_send
+      end
+
+      # Received some events - send them
+      send_jdat payload
+
+      # Leave idle mode if this is the first payload after idle
+      if @pending_payloads.length == 1
+        @timeout = Time.now.to_i + @network_timeout
+      end
     end
 
     def generate_nonce
@@ -345,7 +440,7 @@ module LogCourier
       fail ProtocolError, "ACKN message size invalid (#{message.length})" if message.length != 20
 
       # Grab nonce
-      nonce, sequence = message.unpack('A16N')
+      nonce, sequence = message.unpack('a16N')
 
       if !@logger.nil? && @logger.debug?
         nonce_str = nonce.each_byte.map do |b|

data/lib/log-courier/{client_tls.rb → client_tcp.rb}

@@ -23,16 +23,15 @@ require 'thread'
 
 module LogCourier
   # TLS transport implementation
-  class ClientTls
+  class ClientTcp
     def initialize(options = {})
       @options = {
         logger:             nil,
-        port:               nil,
-        addresses:          [],
+        transport:         'tls',
         ssl_ca:             nil,
         ssl_certificate:    nil,
         ssl_key:            nil,
-        ssl_key_passphrase: nil
+        ssl_key_passphrase: nil,
       }.merge!(options)
 
       @logger = @options[:logger]
@@ -41,14 +40,13 @@ module LogCourier
         fail "output/courier: '#{k}' is required" if @options[k].nil?
       end
 
-      fail 'output/courier: \'addresses\' must contain at least one address' if @options[:addresses].empty?
-
-      c = 0
-      [:ssl_certificate, :ssl_key].each do
-        c += 1
+      if @options[:transport] == 'tls'
+        c = 0
+        [:ssl_certificate, :ssl_key].each do
+          c += 1
+        end
+        fail 'output/courier: \'ssl_certificate\' and \'ssl_key\' must be specified together' if c == 1
       end
-
-      fail 'output/courier: \'ssl_certificate\' and \'ssl_key\' must be specified together' if c == 1
     end
 
     def connect(io_control)
@@ -67,10 +65,16 @@ module LogCourier
       @send_paused = false
 
       @send_thread = Thread.new do
-        run_send io_control
+        begin
+          run_send io_control
+        rescue ShutdownSignal
+        end
       end
       @recv_thread = Thread.new do
-        run_recv io_control
+        begin
+          run_recv io_control
+        rescue ShutdownSignal
+        end
       end
       return
     end
@@ -139,14 +143,18 @@ module LogCourier
         end
       end
       return
-    rescue OpenSSL::SSL::SSLError, IOError, Errno::ECONNRESET => e
+    rescue OpenSSL::SSL::SSLError => e
       @logger.warn 'SSL write error', :error => e.message unless @logger.nil?
       io_control << ['F']
       return
-    rescue ShutdownSignal
+    rescue IOError, Errno::ECONNRESET => e
+      @logger.warn 'Write error', :error => e.message unless @logger.nil?
+      io_control << ['F']
       return
+    rescue ShutdownSignal
+      raise
     rescue StandardError, NativeException => e
-      @logger.warn e, :hint => 'Unknown SSL write error' unless @logger.nil?
+      @logger.warn e, :hint => 'Unknown write error' unless @logger.nil?
       io_control << ['F']
       return
     end
@@ -174,18 +182,22 @@ module LogCourier
         io_control << ['R', signature, message]
       end
       return
-    rescue OpenSSL::SSL::SSLError, IOError, Errno::ECONNRESET => e
+    rescue OpenSSL::SSL::SSLError => e
       @logger.warn 'SSL read error', :error => e.message unless @logger.nil?
       io_control << ['F']
       return
+    rescue IOError, Errno::ECONNRESET => e
+      @logger.warn 'Read error', :error => e.message unless @logger.nil?
+      io_control << ['F']
+      return
     rescue EOFError
       @logger.warn 'Connection closed by server' unless @logger.nil?
       io_control << ['F']
       return
     rescue ShutdownSignal
-      return
-    rescue => e
-      @logger.warn e, :hint => 'Unknown SSL read error' unless @logger.nil?
+      raise
+    rescue StandardError, NativeException => e
+      @logger.warn e, :hint => 'Unknown read error' unless @logger.nil?
       io_control << ['F']
       return
     end
@@ -200,24 +212,37 @@ module LogCourier
       begin
         tcp_socket = TCPSocket.new(address, port)
 
-        ssl = OpenSSL::SSL::SSLContext.new
-
-        unless @options[:ssl_certificate].nil?
-          ssl.cert = OpenSSL::X509::Certificate.new(File.read(@options[:ssl_certificate]))
-          ssl.key = OpenSSL::PKey::RSA.new(File.read(@options[:ssl_key]), @options[:ssl_key_passphrase])
-        end
+        if @options[:transport] == 'tls'
+          ssl = OpenSSL::SSL::SSLContext.new
+
+          # Disable SSLv2 and SSLv3
+          # Call set_params first to ensure options attribute is there (hmmmm?)
+          ssl.set_params
+          # Modify the default options to ensure SSLv2 and SSLv3 is disabled
+          # This retains any beneficial options set by default in the current Ruby implementation
+          ssl.options |= OpenSSL::SSL::OP_NO_SSLv2 if defined?(OpenSSL::SSL::OP_NO_SSLv2)
+          ssl.options |= OpenSSL::SSL::OP_NO_SSLv3 if defined?(OpenSSL::SSL::OP_NO_SSLv3)
+
+          # Set the certificate file
+          unless @options[:ssl_certificate].nil?
+            ssl.cert = OpenSSL::X509::Certificate.new(File.read(@options[:ssl_certificate]))
+            ssl.key = OpenSSL::PKey::RSA.new(File.read(@options[:ssl_key]), @options[:ssl_key_passphrase])
+          end
 
-        cert_store = OpenSSL::X509::Store.new
-        cert_store.add_file(@options[:ssl_ca])
-        ssl.cert_store = cert_store
-        ssl.verify_mode = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+          cert_store = OpenSSL::X509::Store.new
+          cert_store.add_file(@options[:ssl_ca])
+          ssl.cert_store = cert_store
+          ssl.verify_mode = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
 
-        @ssl_client = OpenSSL::SSL::SSLSocket.new(tcp_socket)
+          @ssl_client = OpenSSL::SSL::SSLSocket.new(tcp_socket)
 
-        socket = @ssl_client.connect
+          socket = @ssl_client.connect
 
-        # Verify certificate
-        socket.post_connection_check(address)
+          # Verify certificate
+          socket.post_connection_check(address)
+        else
+          socket = tcp_socket.connect
+        end
 
         # Add extra logging data now we're connected
         @logger['address'] = address

data/lib/log-courier/event_queue.rb

@@ -135,14 +135,18 @@ module LogCourier
     # Returns +true+ if the queue is empty.
     #
     def empty?
-      @que.empty?
+      @mutex.synchronize do
+        return @que.empty?
+      end
     end
 
     #
     # Removes all objects from the queue.
     #
     def clear
-      @que.clear
+      @mutex.synchronize do
+        @que.clear
+      end
       self
     end
 
@@ -150,7 +154,9 @@ module LogCourier
     # Returns the length of the queue.
     #
     def length
-      @que.length
+      @mutex.synchronize do
+        return @que.length
+      end
     end
 
     #
@@ -162,7 +168,9 @@ module LogCourier
     # Returns the number of threads waiting on the queue.
     #
     def num_waiting
-      @num_waiting + @num_enqueue_waiting
+      @mutex.synchronize do
+        return @num_waiting + @num_enqueue_waiting
+      end
     end
 
     private

data/lib/log-courier/server.rb

@@ -36,11 +36,11 @@ module LogCourier
     def initialize(options = {})
       @options = {
         logger:    nil,
-        transport: 'tls'
+        transport: 'tls',
       }.merge!(options)
 
       @logger = @options[:logger]
-      @logger['plugin'] = 'input/courier'
+      @logger['plugin'] = 'input/courier' unless @logger.nil?
 
       case @options[:transport]
       when 'tcp', 'tls'
@@ -59,7 +59,7 @@ module LogCourier
 
       # Load the json adapter
       @json_adapter = MultiJson.adapter.instance
-      @json_options = { raw: true, use_bigdecimal: true }
+      @json_options = { raw: true }
     end
 
     def run(&block)
@@ -191,7 +191,7 @@ module LogCourier
           # Full pipeline, partial ack
           # NOTE: comm.send can raise a Timeout::Error of its own
           @logger.debug 'Partially acknowledging message', :nonce => nonce_str.join, :sequence => sequence if !@logger.nil? && @logger.debug?
-          comm.send 'ACKN', [nonce, sequence].pack('A*N')
+          comm.send 'ACKN', [nonce, sequence].pack('a*N')
           ack_timeout = Time.now.to_i + 5
           retry
         end

data/lib/log-courier/server_tcp.rb

@@ -87,6 +87,16 @@ module LogCourier
 
         if @options[:transport] == 'tls'
           ssl = OpenSSL::SSL::SSLContext.new
+
+          # Disable SSLv2 and SSLv3
+          # Call set_params first to ensure options attribute is there (hmmmm?)
+          ssl.set_params
+          # Modify the default options to ensure SSLv2 and SSLv3 is disabled
+          # This retains any beneficial options set by default in the current Ruby implementation
+          ssl.options |= OpenSSL::SSL::OP_NO_SSLv2 if defined?(OpenSSL::SSL::OP_NO_SSLv2)
+          ssl.options |= OpenSSL::SSL::OP_NO_SSLv3 if defined?(OpenSSL::SSL::OP_NO_SSLv3)
+
+          # Set the certificate file
           ssl.cert = OpenSSL::X509::Certificate.new(File.read(@options[:ssl_certificate]))
           ssl.key = OpenSSL::PKey::RSA.new(File.read(@options[:ssl_key]), @options[:ssl_key_passphrase])
 
@@ -134,7 +144,7 @@ module LogCourier
           client = @server.accept
         rescue EOFError, OpenSSL::SSL::SSLError, IOError => e
           # Accept failure or other issue
-          @logger.warn 'Connection failed to accept', :error => e.message, :peer => @tcp_server.peer unless @logger.nil
+          @logger.warn 'Connection failed to accept', :error => e.message, :peer => @tcp_server.peer unless @logger.nil?
           client.close rescue nil unless client.nil?
           next
         end
@@ -254,10 +264,14 @@ module LogCourier
         @logger.info 'Connection closed', :peer => @peer unless @logger.nil?
       end
       return
-    rescue OpenSSL::SSL::SSLError, IOError, Errno::ECONNRESET => e
+    rescue OpenSSL::SSL::SSLError => e
       # Read errors, only action is to shutdown which we'll do in ensure
       @logger.warn 'SSL error, connection aborted', :error => e.message, :peer => @peer unless @logger.nil?
       return
+    rescue IOError, Errno::ECONNRESET => e
+      # Read errors, only action is to shutdown which we'll do in ensure
+      @logger.warn 'Connection aborted', :error => e.message, :peer => @peer unless @logger.nil?
+      return
     rescue ProtocolError => e
       # Connection abort request due to a protocol error
       @logger.warn 'Protocol error, connection aborted', :error => e.message, :peer => @peer unless @logger.nil?

data/lib/log-courier/server_zmq.rb

@@ -85,7 +85,7 @@ module LogCourier
 
         bind = 'tcp://' + @options[:address] + (@options[:port] == 0 ? ':*' : ':' + @options[:port].to_s)
         rc = @socket.bind(bind)
-        fail 'failed to bind at ' + bind + ': ' + rZMQ::Util.error_string unless ZMQ::Util.resultcode_ok?(rc)
+        fail 'failed to bind at ' + bind + ': ' + ZMQ::Util.error_string unless ZMQ::Util.resultcode_ok?(rc)
 
         # Lookup port number that was allocated in case it was set to 0
         endpoint = ''
@@ -273,8 +273,12 @@ module LogCourier
           }
         end
 
-        # Existing thread, throw on the queue, if not enough room drop the message
-        index['']['client'].push data, 0
+        # Existing thread, throw on the queue, if not enough room (timeout) drop the message
+        begin
+          index['']['client'].push data, 0
+        rescue LogCourier::TimeoutError
+          # TODO: Log a warning about this?
+        end
       end
       return
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: log-courier
 version: !ruby/object:Gem::Version
-  version: '1.3'
+  version: 1.6.pre.40.g3efb33c
 platform: ruby
 authors:
 - Jason Woods
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-02 00:00:00.000000000 Z
+date: 2015-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cabin
@@ -60,7 +60,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/log-courier/client.rb
-- lib/log-courier/client_tls.rb
+- lib/log-courier/client_tcp.rb
 - lib/log-courier/event_queue.rb
 - lib/log-courier/server.rb
 - lib/log-courier/server_tcp.rb
@@ -81,9 +81,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: nowarning
 rubygems_version: 2.4.2