logstash-logger 1.0.0 → 1.1.0

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

@@ -8,9 +8,32 @@ module LogStashLogger
     # rather than persistent HTTP connections for efficiency.
     class HTTP < Connectable
 
+      # Request body formats, with the Content-Type sent by default for each.
+      FORMATS = {
+        json_array: "application/json",
+        ndjson: "application/x-ndjson",
+      }.freeze
+
+      DEFAULT_FORMAT = :json_array
+
+      # Statuses that reject the content of the request. Sending the same
+      # records again can never succeed, so the rejected records are found and
+      # dropped. Every other error status is retried.
+      CONTENT_REJECTED_STATUSES = [
+        400, # Bad Request: the body is malformed
+        413, # Content Too Large: the body is over the collector's size limit
+        415, # Unsupported Media Type: the collector does not accept this content type
+        422, # Unprocessable Content: the body is well-formed but cannot be processed
+      ].freeze
+
       def initialize(opts)
         super
         @url = URI(opts[:url])
+        @format = (opts[:format] || DEFAULT_FORMAT).to_sym
+        unless FORMATS.key?(@format)
+          raise ArgumentError, "Unknown HTTP body format: #{@format.inspect} (expected one of #{FORMATS.keys.map(&:inspect).join(', ')})"
+        end
+        @content_type = opts[:content_type] || FORMATS[@format]
       end
 
       def connect
@@ -22,10 +45,58 @@ module LogStashLogger
       end
 
       def write_batch(messages, _group = nil)
-        # Logstash HTTP input expects JSON array instead of lines of JSON
-        body = "[#{messages.join(',')}]"
-        resp = Net::HTTP.post @url, body, {"Content-Type" => "application/json"}
-        raise resp.message if Net::HTTPError === resp
+        messages = messages.map(&:to_s)
+        resp = post(messages)
+        return if resp.is_a?(Net::HTTPSuccess)
+        raise upload_error(resp) unless content_rejected?(resp)
+        deliver_one_at_a_time(messages, resp)
+      end
+
+      private
+
+      def post(messages)
+        body = @format == :ndjson ? ndjson_body(messages) : json_array_body(messages)
+        Net::HTTP.post @url, body, {"Content-Type" => @content_type}
+      end
+
+      # The collector rejected the content of the batch. Send the records one
+      # at a time and drop only the ones that are still rejected, so one bad
+      # record does not hold back, or take down, the rest.
+      def deliver_one_at_a_time(messages, batch_resp)
+        return drop(messages.first, batch_resp) if messages.size == 1
+
+        messages.each do |message|
+          resp = post([message])
+          next if resp.is_a?(Net::HTTPSuccess)
+
+          if content_rejected?(resp)
+            drop(message, resp)
+          else
+            raise upload_error(resp)
+          end
+        end
+      end
+
+      def content_rejected?(resp)
+        CONTENT_REJECTED_STATUSES.include?(resp.code.to_i)
+      end
+
+      def drop(message, resp)
+        log_warning("dropping a record of #{message.bytesize} bytes that the collector rejected: HTTP #{resp.code} #{resp.message}")
+      end
+
+      def upload_error(resp)
+        RuntimeError.new("HTTP log upload failed: #{resp.code} #{resp.message}").tap { |e| log_error(e) }
+      end
+
+      # Logstash HTTP input expects a JSON array instead of lines of JSON
+      def json_array_body(messages)
+        "[#{messages.join(',')}]"
+      end
+
+      # Newline-delimited JSON: one event per line, each ending with a newline
+      def ndjson_body(messages)
+        messages.map { |m| m.end_with?("\n") ? m : "#{m}\n" }.join
       end
 
     end

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

@@ -47,6 +47,10 @@ module LogStashLogger
       attr_reader :topic, :brokers, :cert_bundle, :kafka_tls_configurator,
         :client_id
 
+      # Errors that will recur on every retry of the same records. Looked up by
+      # name at rescue time, because ruby-kafka is only required in #initialize.
+      NOT_RETRYABLE_ERRORS = %w[MessageSizeTooLarge RecordListTooLarge BufferOverflow].freeze
+
       def initialize(opts = {}, kafka_tls_configurator = TLSConfiguration)
         require 'ruby-kafka'
         super(opts)
@@ -81,10 +85,33 @@ module LogStashLogger
         write_messages_to_broker_and_deliver do |producer|
           messages.each {|msg| producer.produce(msg, topic: topic) }
         end
+      rescue => e
+        raise if retryable_error?(e)
+        deliver_one_at_a_time(messages, topic)
       end
 
       private
 
+      # One record the broker or client will never accept fails the whole batch.
+      # Send the records one at a time and drop only the ones that are still
+      # rejected. Retryable errors raise, so the buffer retries the batch.
+      def deliver_one_at_a_time(messages, topic)
+        messages.each do |message|
+          begin
+            write_one(message, topic)
+          rescue => e
+            raise if retryable_error?(e)
+            log_warning("dropping a record of #{message.to_s.bytesize} bytes that Kafka rejected: #{e.class}")
+          end
+        end
+      end
+
+      def retryable_error?(error)
+        NOT_RETRYABLE_ERRORS.none? do |name|
+          ::Kafka.const_defined?(name) && error.is_a?(::Kafka.const_get(name))
+        end
+      end
+
       def write_messages_to_broker_and_deliver(&block)
         with_connection do
           kproducer = producer

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

@@ -14,9 +14,18 @@ module LogStashLogger
         "ServiceUnavailable",
         "Throttling",
         "RequestExpired",
-        "ProvisionedThroughputExceededException"
+        "ProvisionedThroughputExceededException",
+        "InternalFailure"
       ].freeze
 
+      # https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html
+      # Records count the partition key. 1 MiB is the default and smallest
+      # per-stream maximum; raise it with aws_max_record_bytes if the stream
+      # is configured for larger records.
+      def self.max_records; 500; end
+      def self.max_record_bytes; 1_048_576; end
+      def self.max_request_bytes; 10_485_760; end
+
       def transform_message(message)
         {
           data: message,

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

@@ -1,4 +1,5 @@
 require 'openssl'
+require 'ipaddr'
 
 module LogStashLogger
   module Device
@@ -13,11 +14,16 @@ module LogStashLogger
         @use_ssl = !!(@ssl_certificate || opts[:ssl_context])
         @use_ssl = opts[:ssl_enable] if opts.has_key? :ssl_enable
         @verify_hostname = opts.fetch(:verify_hostname, true)
+        validate_ssl_certificate! if use_ssl? && @ssl_certificate && !@ssl_context
       end
 
+      # The TLS context used for the connection. Without an operator-supplied
+      # :ssl_context, the server certificate is always verified: against the
+      # :ssl_certificate file when one is given, otherwise against the system
+      # trust store.
       def ssl_context
         return unless use_ssl?
-        @ssl_context || certificate_context
+        @ssl_context || certificate_context || default_context
       end
 
       def use_ssl?
@@ -49,20 +55,60 @@ module LogStashLogger
       end
 
       def ssl_io
-        ssl_context ?
-          OpenSSL::SSL::SSLSocket.new(tcp_io, ssl_context) :
-          OpenSSL::SSL::SSLSocket.new(tcp_io)
+        socket = tcp_io
+        begin
+          OpenSSL::SSL::SSLSocket.new(socket, ssl_context).tap do |ssl|
+            # Closing the TLS socket also closes the TCP socket underneath it
+            ssl.sync_close = true
+            # SNI is only sent for DNS names, never for IP addresses
+            ssl.hostname = hostname unless ip_address?(hostname)
+          end
+        rescue StandardError
+          socket.close rescue nil
+          raise
+        end
       end
 
+      # Trusts the certificate (or CA bundle) in the :ssl_certificate file, in
+      # addition to the system trust store.
       def certificate_context
         return unless @ssl_certificate
-        @certificate_context ||= OpenSSL::SSL::SSLContext.new.tap do |ctx|
-          ctx.set_params(cert: @ssl_certificate)
+        @certificate_context ||= verifying_context(ca_file: @ssl_certificate)
+      end
+
+      # Used when TLS is enabled without an :ssl_context or :ssl_certificate.
+      def default_context
+        @default_context ||= verifying_context
+      end
+
+      def verifying_context(params = {})
+        OpenSSL::SSL::SSLContext.new.tap do |ctx|
+          # VERIFY_PEER, hostname verification and the system certificate store
+          ctx.set_params(params)
+          # Honour an explicit verify_hostname: false
+          ctx.verify_hostname = !!@verify_hostname
         end
       end
 
+      def validate_ssl_certificate!
+        path = @ssl_certificate.to_s
+        unless ::File.file?(path) && ::File.readable?(path)
+          raise ArgumentError, "ssl_certificate must be a readable certificate file: #{path.inspect}"
+        end
+        OpenSSL::X509::Certificate.new(::File.read(path))
+      rescue OpenSSL::X509::CertificateError => e
+        raise ArgumentError, "ssl_certificate #{path.inspect} is not a PEM or DER certificate: #{e.message}"
+      end
+
+      def ip_address?(name)
+        IPAddr.new(name.to_s)
+        true
+      rescue IPAddr::Error
+        false
+      end
+
       def verify_hostname?
-        return false unless ssl_context
+        return false unless use_ssl?
         !! @verify_hostname
       end
 

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

@@ -11,6 +11,7 @@ module LogStashLogger
 
     class Base < ::Logger::Formatter
       FAILED_TO_FORMAT_MSG = 'Failed to format log event'
+      FAILED_TO_FORMAT_TAG = '_logstashlogger_format_failure'
       attr_accessor :error_logger
       include ::LogStashLogger::TaggedLogging::Formatter
 
@@ -20,16 +21,43 @@ module LogStashLogger
         super()
       end
 
-      def call(severity, time, _progname, message)
+      def call(severity, time, progname, message)
         event = build_event(message, severity, time)
-        format_event(event) unless event.cancelled?
+        frame_event(event, progname) unless event.cancelled?
       rescue StandardError => e
         log_error(e)
-        FAILED_TO_FORMAT_MSG
+        fallback_event(severity, time, progname, e)
       end
 
       private
 
+      # Wraps a built event in this formatter's record framing. Formatters that
+      # add a header or trailer override this; the fallback below goes through
+      # the same framing.
+      def frame_event(event, _progname)
+        format_event(event)
+      end
+
+      # When a record cannot be built or serialized, emit a well-formed
+      # placeholder in this formatter's own framing instead, so the failure never
+      # changes how a collector splits the stream into records. Returns nil
+      # (which devices drop) if even the placeholder cannot be formatted.
+      def fallback_event(severity, time, progname, error)
+        event = LogStash::Event.new(
+          '@timestamp'.freeze => time.is_a?(Time) ? time : Time.now,
+          'message'.freeze => FAILED_TO_FORMAT_MSG,
+          'severity'.freeze => severity.to_s,
+          'host'.freeze => HOST,
+          'tags'.freeze => [FAILED_TO_FORMAT_TAG],
+          'error'.freeze => error.class.name
+        )
+        event.timestamp = event.timestamp.iso8601(3) if event.timestamp.is_a?(Time)
+        frame_event(event, progname)
+      rescue StandardError => e
+        log_error(e)
+        nil
+      end
+
       def build_event(message, severity, time)
         data = message
         if data.is_a?(String) && data.start_with?('{'.freeze)
@@ -51,6 +79,9 @@ module LogStashLogger
                         event_data['source'.freeze] = value
                       when :type, 'type'
                         event_data['type'.freeze] = value
+                      when :'@timestamp', '@timestamp'
+                        # Keep the logger time unless the value is a usable time
+                        event_data['@timestamp'.freeze] = usable_time(value) || time
                       else
                         event_data[key] = value
                       end
@@ -87,6 +118,16 @@ module LogStashLogger
         event
       end
 
+      # LogStash::Event runs String timestamps through Time.parse, which raises
+      # for text that is not a time. Keep every other value exactly as given.
+      def usable_time(value)
+        return value unless value.is_a?(String)
+        Time.parse(value)
+        value
+      rescue ArgumentError, RangeError
+        nil
+      end
+
       def force_utf8_encoding(event)
         original_message = event.instance_variable_get(:@data)['message']
         event.message = original_message.dup.force_encoding(Encoding::UTF_8).scrub

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

@@ -1,21 +1,18 @@
 module LogStashLogger
   module Formatter
     class CeeSyslog < Cee
-      def call(severity, time, progname, message)
-        @progname = progname
-        super
-      end
-
       private
 
-      def build_facility(host)
-        facility = host['hostname'.freeze].dup
-        facility << " #{@progname}" if @progname
-        facility
+      def frame_event(event, progname)
+        "#{build_header(progname)}:#{format_event(event)}\n"
       end
 
-      def format_event(event)
-        "#{build_facility(event["host".freeze])}:#{super}\n"
+      # The header names this process, never a value taken from the logged
+      # content, and always stays on one line.
+      def build_header(progname)
+        header = HOST['hostname'.freeze].to_s.dup
+        header << " #{progname}" if progname
+        header.gsub(/[[:cntrl:]]/, ' '.freeze)
       end
     end
   end

data/lib/logstash-logger/version.rb

@@ -1,3 +1,3 @@
 module LogStashLogger
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/logstash-logger.gemspec

@@ -26,11 +26,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'aws-sdk-kinesis'
   gem.add_development_dependency 'aws-sdk-firehose'
 
-  if defined?(JRUBY_VERSION)
-    gem.add_development_dependency 'SyslogLogger'
-  else
-    gem.add_development_dependency 'syslog'
-  end
+  gem.add_development_dependency 'syslog', '>= 0.4'
 
   gem.add_development_dependency 'rspec', '>= 3'
   gem.add_development_dependency 'rake'
@@ -43,5 +39,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rubocop-rake'
   gem.add_development_dependency 'rubocop-rspec'
 
-  gem.required_ruby_version = '>= 3.2'
+  gem.required_ruby_version = '>= 3.3'
 end

data/spec/device/aws_stream_limits_spec.rb

@@ -0,0 +1,219 @@
+require 'logstash-logger'
+require 'logger'
+
+# Stub AWS clients that record every request and can be told to fail.
+class FakeKinesisClient
+  attr_reader :requests
+
+  def initialize(fail_requests: [])
+    @requests = []
+    @fail_requests = fail_requests
+  end
+
+  def put_records(params)
+    @requests << params[:records].map { |r| r[:data] }
+    raise Seahorse::Client::NetworkingError.new(StandardError.new('connection reset')) if @fail_requests.include?(@requests.size)
+    entries = params[:records].map { Aws::Kinesis::Types::PutRecordsResultEntry.new(sequence_number: '1', shard_id: 's') }
+    Aws::Kinesis::Types::PutRecordsOutput.new(failed_record_count: 0, records: entries)
+  end
+end
+
+class FakeFirehoseClient
+  attr_reader :requests
+
+  def initialize
+    @requests = []
+  end
+
+  def put_record_batch(params)
+    @requests << params[:records].map { |r| r[:data] }
+    entries = params[:records].map { Aws::Firehose::Types::PutRecordBatchResponseEntry.new(record_id: '1') }
+    Aws::Firehose::Types::PutRecordBatchOutput.new(failed_put_count: 0, request_responses: entries)
+  end
+end
+
+describe 'AWS outputs and service limits' do
+  let(:error_log) { StringIO.new }
+  let(:common) do
+    { sync: false, buffer_max_interval: 3600, buffer_flush_at_exit: false,
+      aws_region: 'us-east-1', error_logger: ::Logger.new(error_log) }
+  end
+  let(:small) { (1..5).map { |i| %({"n":#{i}}) } }
+
+  def pending_count(device)
+    device.instance_variable_get(:@buffer_state)[:pending_count]
+  end
+
+  describe LogStashLogger::Device::Kinesis do
+    let(:client) { FakeKinesisClient.new }
+    let(:device) { LogStashLogger::Device.new(common.merge(type: :kinesis)) }
+
+    before { allow(Aws::Kinesis::Client).to receive(:new) { client } }
+
+    it 'drops only a record over the per-record limit' do
+      device.write_batch(small + ['x' * 1_048_576])
+      expect(client.requests).to eq([small])
+      expect(error_log.string).to match(/dropping a record of 1048612 bytes: over the 1048576-byte limit/)
+    end
+
+    it 'accepts larger records when aws_max_record_bytes is raised' do
+      big = 'x' * 2_000_000
+      device = LogStashLogger::Device.new(common.merge(type: :kinesis, aws_max_record_bytes: 10_485_760))
+      device.write_batch([big])
+      expect(client.requests).to eq([[big]])
+    end
+
+    it 'splits more than 500 records into several requests' do
+      messages = (1..600).map(&:to_s)
+      device.write_batch(messages)
+      expect(client.requests.map(&:size)).to eq([500, 100])
+    end
+
+    it 'splits requests that would go over the request-size limit' do
+      messages = Array.new(12) { 'x' * 1_000_000 }
+      device.write_batch(messages)
+      expect(client.requests.map(&:size)).to eq([10, 2])
+    end
+
+    it 'sends records that are not Strings as text' do
+      device.write_batch([123, :sym])
+      expect(client.requests).to eq([['123', 'sym']])
+    end
+
+    context 'when a request fails' do
+      let(:client) { FakeKinesisClient.new(fail_requests: [1]) }
+
+      it 'keeps the records for the next flush instead of treating them as delivered' do
+        small.each { |m| device.write(m) }
+        expect { device.buffer_flush(force: true) }.not_to raise_error
+        expect(pending_count(device)).to eq(small.size)
+        expect(error_log.string).to include('5 records will be retried on the next flush')
+      end
+
+      it 'drops them when drop_messages_on_flush_error is set' do
+        device = LogStashLogger::Device.new(common.merge(type: :kinesis, drop_messages_on_flush_error: true))
+        small.each { |m| device.write(m) }
+        device.buffer_flush(force: true)
+        expect(pending_count(device)).to eq(0)
+        expect(error_log.string).to include('dropping 5 records after a failed request')
+      end
+    end
+
+    context 'when a later request fails' do
+      let(:client) { FakeKinesisClient.new(fail_requests: [2]) }
+
+      it 'retries only the records that were not sent' do
+        device.write_batch((1..600).map(&:to_s))
+        expect(pending_count(device)).to eq(100)
+      end
+    end
+
+    it 'delivers the rest of a buffered batch around an oversized record' do
+      small.each { |m| device.write(m) }
+      device.write('x' * 2_000_000)
+      device.buffer_flush(force: true)
+      expect(client.requests).to eq([small])
+      expect(pending_count(device)).to eq(0)
+    end
+  end
+
+  describe LogStashLogger::Device::Firehose do
+    let(:client) { FakeFirehoseClient.new }
+    let(:device) { LogStashLogger::Device.new(common.merge(type: :firehose)) }
+
+    before { allow(Aws::Firehose::Client).to receive(:new) { client } }
+
+    it 'drops only a record over the 1,000 KiB limit' do
+      device.write_batch(small + ['x' * 1_024_001])
+      expect(client.requests).to eq([small])
+    end
+
+    it 'splits requests at 4 MB' do
+      device.write_batch(Array.new(5) { 'x' * 1_000_000 })
+      expect(client.requests.map(&:size)).to eq([4, 1])
+    end
+  end
+end
+
+# Throttles every record of the first `throttled` requests, then accepts all.
+class ThrottlingKinesisClient
+  attr_reader :requests
+
+  def initialize(throttled:, code: 'ProvisionedThroughputExceededException')
+    @requests = []
+    @throttled = throttled
+    @code = code
+  end
+
+  def put_records(params)
+    @requests << params[:records].map { |r| r[:data] }
+    if @requests.size <= @throttled
+      entries = params[:records].map { Aws::Kinesis::Types::PutRecordsResultEntry.new(error_code: @code, error_message: 'slow down') }
+      Aws::Kinesis::Types::PutRecordsOutput.new(failed_record_count: entries.size, records: entries)
+    else
+      entries = params[:records].map { Aws::Kinesis::Types::PutRecordsResultEntry.new(sequence_number: '1', shard_id: 's') }
+      Aws::Kinesis::Types::PutRecordsOutput.new(failed_record_count: 0, records: entries)
+    end
+  end
+
+  def delivered
+    @requests.drop(@throttled).flatten
+  end
+end
+
+describe LogStashLogger::Device::Kinesis, 'when records are throttled' do
+  let(:error_log) { StringIO.new }
+  let(:client) { ThrottlingKinesisClient.new(throttled: 1) }
+  let(:records) { (1..50).map(&:to_s) }
+
+  before { allow(Aws::Kinesis::Client).to receive(:new) { client } }
+
+  def device(**opts)
+    LogStashLogger::Device.new({ type: :kinesis, aws_region: 'us-east-1', sync: false, buffer_max_interval: 0.2,
+                                 buffer_flush_at_exit: false, error_logger: ::Logger.new(error_log) }.merge(opts))
+  end
+
+  # These flushes run on the buffer's background timer thread, so poll until
+  # the block returns true, giving up after `timeout` seconds. The example's
+  # own expectations then report what went wrong if it never does.
+  def wait_until(timeout: 5)
+    deadline = Time.now + timeout
+    sleep 0.05 until yield || Time.now > deadline
+  end
+
+  it 'retries a full throttled batch on the timer thread without losing it or stopping the timer' do
+    dev = device
+    timer = dev.instance_variable_get(:@flush_timer_thread)
+    records.each { |r| dev.write(r) }
+
+    wait_until { client.delivered.size == records.size }
+
+    expect(client.delivered).to match_array(records)
+    expect(dev.instance_variable_get(:@buffer_state)[:pending_count]).to eq(0)
+    expect(dev.instance_variable_get(:@buffer_state)[:outgoing_count]).to eq(0)
+    expect(timer).to be_alive
+    expect(error_log.string).to include('50 records will be retried on the next flush (ProvisionedThroughputExceededException: 50)')
+    expect(error_log.string).not_to include('Buffer Full')
+  end
+
+  it 'does not block logging when drop_messages_on_full_buffer is false' do
+    dev = device(drop_messages_on_full_buffer: false)
+    records.each { |r| dev.write(r) }
+    wait_until { client.delivered.size == records.size }
+
+    writer = Thread.new { dev.write('after') }
+    expect(writer.join(2)).not_to be_nil
+    expect(client.delivered).to match_array(records)
+  end
+
+  context 'with InternalFailure' do
+    let(:client) { ThrottlingKinesisClient.new(throttled: 1, code: 'InternalFailure') }
+
+    it 'retries the records' do
+      dev = device
+      records.first(3).each { |r| dev.write(r) }
+      wait_until { client.delivered.size == 3 }
+      expect(client.delivered).to match_array(records.first(3))
+    end
+  end
+end

data/spec/device/connectable_spec.rb

@@ -72,3 +72,54 @@ describe LogStashLogger::Device::Connectable do
     end
   end
 end
+
+describe LogStashLogger::Device::Connectable, 'max_record_bytes' do
+  let(:error_log) { StringIO.new }
+
+  def device(**opts)
+    LogStashLogger::Device.new({ type: :udp, port: 5228, sync: false, buffer_max_interval: 3600,
+                                 buffer_flush_at_exit: false, error_logger: ::Logger.new(error_log) }.merge(opts))
+  end
+
+  def pending(dev)
+    dev.instance_variable_get(:@buffer_state)[:pending_items][nil]
+  end
+
+  it 'is off by default' do
+    dev = device
+    dev.write('x' * 2_000_000)
+    expect(pending(dev).size).to eq(1)
+  end
+
+  it 'drops only records over the limit, logging the size but not the content' do
+    dev = device(max_record_bytes: 100)
+    dev.write('small')
+    dev.write('secret' * 50)
+    expect(pending(dev)).to eq(['small'])
+    expect(error_log.string).to include('dropping a record of 300 bytes: over max_record_bytes (100)')
+    expect(error_log.string).not_to include('secret')
+  end
+
+  it 'measures records that are not Strings' do
+    dev = device(max_record_bytes: 2)
+    dev.write(123)
+    expect(pending(dev)).to be_empty
+  end
+
+  it 'accepts a String value, as URI query options arrive' do
+    dev = LogStashLogger::Device.new(uri: 'udp://localhost:5228?max_record_bytes=100', buffer_flush_at_exit: false,
+                                     error_logger: ::Logger.new(error_log))
+    dev.write('x' * 101)
+    expect(pending(dev)).to be_empty
+  end
+
+  it 'rejects a value that is not a positive number' do
+    expect { device(max_record_bytes: 'lots') }.to raise_error(ArgumentError)
+    expect { device(max_record_bytes: 0) }.to raise_error(ArgumentError, /positive/)
+  end
+
+  it 'is not forwarded to the Redis client' do
+    expect(::Redis).to receive(:new).with(hash_excluding(:max_record_bytes)).and_return(double('redis'))
+    LogStashLogger::Device.new(type: :redis, max_record_bytes: 100, buffer_flush_at_exit: false).connect
+  end
+end

data/spec/device/firehose_spec.rb

@@ -30,9 +30,12 @@ describe LogStashLogger::Device::Firehose do
     response.request_responses = [failed_record]
 
     expect(client).to receive(:put_record_batch) { response }
-    expect(firehose_device).to receive(:write).with("foo")
+    expect(firehose_device).not_to receive(:write)
 
     firehose_device.write_one "foo"
+    state = firehose_device.instance_variable_get(:@buffer_state)
+    expect(state[:pending_items][nil]).to eq(["foo"])
+    expect(state[:pending_count]).to eq(1)
   end
 
   it "defaults the Firehose stream to logstash" do