logstash-logger 0.26.1 → 1.1.0

data/spec/device/tcp_spec.rb

@@ -1,4 +1,5 @@
 require 'logstash-logger'
+require_relative '../support/tls_helper'
 
 describe LogStashLogger::Device::TCP do
   include_context 'device'
@@ -13,6 +14,9 @@ describe LogStashLogger::Device::TCP do
     allow(OpenSSL::SSL::SSLSocket).to receive(:new) { ssl_socket }
     allow(ssl_socket).to receive(:connect)
     allow(ssl_socket).to receive(:post_connection_check)
+    allow(ssl_socket).to receive(:sync_close=)
+    allow(ssl_socket).to receive(:hostname=)
+    allow(tcp_socket).to receive(:close)
     allow(ssl_tcp_device).to receive(:warn)
   end
 
@@ -103,16 +107,101 @@ describe LogStashLogger::Device::TCP do
     end
 
     context 'without a provided SSL context' do
-      it 'ssl_context returns nil' do
-        expect(ssl_tcp_device.ssl_context).to be_nil
+      it 'uses a context that verifies the server certificate' do
+        ctx = ssl_tcp_device.ssl_context
+        expect(ctx).to be_a(OpenSSL::SSL::SSLContext)
+        expect(ctx.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
+        expect(ctx.verify_hostname).to be true
+        expect(ctx.cert_store).not_to be_nil
+      end
+
+      it 'creates the socket with that context' do
+        expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, ssl_tcp_device.ssl_context)
+        ssl_tcp_device.connect
+      end
+
+      it 'verifies the hostname after connecting' do
+        expect(ssl_socket).to receive(:post_connection_check).with(HOST)
+        ssl_tcp_device.connect
+      end
+
+      context 'with verify_hostname: false' do
+        let(:ssl_tcp_device) { LogStashLogger::Device.new(type: :tcp, port: port, ssl_enable: true, sync: true, verify_hostname: false) }
+
+        it 'still verifies the certificate chain' do
+          expect(ssl_tcp_device.ssl_context.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
+        end
+
+        it 'does not verify the hostname' do
+          expect(ssl_tcp_device.ssl_context.verify_hostname).to be false
+          expect(ssl_socket).not_to receive(:post_connection_check)
+          ssl_tcp_device.connect
+        end
+      end
+    end
+
+    context 'server name indication' do
+      it 'is sent for a DNS hostname' do
+        device = LogStashLogger::Device.new(type: :tcp, host: 'logstash.example.com', port: port, ssl_enable: true, sync: true)
+        expect(ssl_socket).to receive(:hostname=).with('logstash.example.com')
+        device.connect
+      end
+
+      it 'is not sent for an IP address' do
+        expect(ssl_socket).not_to receive(:hostname=)
+        ssl_tcp_device.connect
+      end
+    end
+
+    it 'closes the TCP socket together with the SSL socket' do
+      expect(ssl_socket).to receive(:sync_close=).with(true)
+      ssl_tcp_device.connect
+    end
+
+    context 'when the SSL socket cannot be created' do
+      before do
+        allow(OpenSSL::SSL::SSLSocket).to receive(:new).and_raise(OpenSSL::SSL::SSLError, 'boom')
+      end
+
+      it 'closes the TCP socket it opened' do
+        expect(tcp_socket).to receive(:close).once
+        expect { ssl_tcp_device.connect }.to raise_error(OpenSSL::SSL::SSLError)
       end
     end
 
     context 'only providing a certificate file' do
-      let(:ssl_tcp_device) { LogStashLogger::Device.new(type: :tcp, port: port, ssl_enable: true, sync: true, ssl_certificate: '/path/to/cert.pem') }
+      let(:cert_file) { TLSHelper.cert_file(TLSHelper.self_signed.first) }
+      let(:ssl_tcp_device) { LogStashLogger::Device.new(type: :tcp, port: port, ssl_enable: true, sync: true, ssl_certificate: cert_file.path) }
+
+      after { cert_file.close! }
+
+      it 'trusts that certificate and verifies the server against it' do
+        ctx = ssl_tcp_device.ssl_context
+        expect(ctx.ca_file).to eq(cert_file.path)
+        expect(ctx.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
+        expect(ctx.verify_hostname).to be true
+      end
+
+      it 'enables SSL implicitly' do
+        device = LogStashLogger::Device.new(type: :tcp, port: port, sync: true, ssl_certificate: cert_file.path)
+        expect(device.use_ssl?).to be_truthy
+      end
+
+      it 'rejects a missing file' do
+        expect {
+          LogStashLogger::Device.new(type: :tcp, port: port, sync: true, ssl_certificate: '/nonexistent/cert.pem')
+        }.to raise_error(ArgumentError, /readable certificate file/)
+      end
 
-      it 'implicitly uses a context with the configured certificate' do
-        expect(ssl_tcp_device.ssl_context.cert).to eq('/path/to/cert.pem')
+      it 'rejects a file that is not a certificate' do
+        not_a_cert = Tempfile.new('not-a-cert')
+        not_a_cert.write('hello')
+        not_a_cert.flush
+        expect {
+          LogStashLogger::Device.new(type: :tcp, port: port, sync: true, ssl_certificate: not_a_cert.path)
+        }.to raise_error(ArgumentError, /not a PEM or DER certificate/)
+      ensure
+        not_a_cert.close!
       end
     end
   end

data/spec/device/tcp_tls_integration_spec.rb

@@ -0,0 +1,91 @@
+require 'logstash-logger'
+require 'logger'
+require 'socket'
+require_relative '../support/tls_helper'
+
+# Real TLS handshakes against a loopback server that presents a throwaway
+# self-signed certificate. Nothing leaves 127.0.0.1.
+describe LogStashLogger::Device::TCP, 'TLS verification against a real server' do
+  before(:all) do
+    @cert, @key = TLSHelper.self_signed(dns: ['localhost'], ips: [])
+    @cert_file = TLSHelper.cert_file(@cert)
+  end
+
+  after(:all) { @cert_file.close! }
+
+  let(:received) { Queue.new }
+  let(:server) do
+    tcp = TCPServer.new('127.0.0.1', 0)
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.cert = @cert
+    ctx.key = @key
+    OpenSSL::SSL::SSLServer.new(tcp, ctx)
+  end
+  let(:port) { server.to_io.addr[1] }
+
+  before do
+    srv = server
+    q = received
+    @server_thread = Thread.new do
+      loop do
+        begin
+          client = srv.accept
+          q << client.gets
+          client.close
+        rescue OpenSSL::SSL::SSLError, IOError, SystemCallError
+          # A rejected handshake is expected in several examples
+          break if srv.to_io.closed?
+        end
+      end
+    end
+  end
+
+  after do
+    server.close rescue nil
+    @server_thread.kill
+    @server_thread.join(1)
+  end
+
+  def device(**opts)
+    LogStashLogger::Device.new(
+      { type: :tcp, port: port, sync: true, buffer_flush_at_exit: false,
+        error_logger: ::Logger.new(IO::NULL) }.merge(opts)
+    )
+  end
+
+  def deliver(dev)
+    dev.connect
+    dev.io.write(%({"message":"hello"}\n))
+    dev.io.flush
+    line = received.pop(timeout: 5)
+    dev.close!
+    line
+  end
+
+  it 'refuses a self-signed certificate when only ssl_enable is set' do
+    expect { device(host: 'localhost', ssl_enable: true).connect }
+      .to raise_error(OpenSSL::SSL::SSLError)
+  end
+
+  it 'delivers when the certificate is trusted through ssl_certificate' do
+    expect(deliver(device(host: 'localhost', ssl_certificate: @cert_file.path)))
+      .to eq(%({"message":"hello"}\n))
+  end
+
+  it 'refuses a certificate whose name does not match the host' do
+    expect { device(host: '127.0.0.1', ssl_certificate: @cert_file.path).connect }
+      .to raise_error(OpenSSL::SSL::SSLError)
+  end
+
+  it 'checks the name given in verify_hostname when connecting by IP' do
+    dev = device(host: '127.0.0.1', ssl_certificate: @cert_file.path, verify_hostname: 'localhost')
+    expect(deliver(dev)).to eq(%({"message":"hello"}\n))
+  end
+
+  it 'still allows an explicit VERIFY_NONE context as an opt-out' do
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    dev = device(host: '127.0.0.1', ssl_context: ctx, verify_hostname: false)
+    expect(deliver(dev)).to eq(%({"message":"hello"}\n))
+  end
+end

data/spec/device_spec.rb

@@ -38,6 +38,19 @@ describe LogStashLogger::Device do
       it { is_expected.to eq({type: 'udp', host: 'localhost', port: 5228, path: ''}) }
     end
 
+    context "when uri includes buffer_max_items" do
+      let(:uri_config) { {uri: "udp://localhost:5228?buffer_max_items=75"} }
+      it do
+        expect(parse_uri_config).to eq({
+          type: 'udp',
+          host: 'localhost',
+          port: 5228,
+          path: '',
+          buffer_max_items: 75,
+        })
+      end
+    end
+
     context "when uri is invalid" do
       let(:uri_config) { invalid_uri_config }
       specify { expect { parse_uri_config }.to raise_error(URI::InvalidURIError) }

data/spec/formatter/base_spec.rb

@@ -23,6 +23,87 @@ describe LogStashLogger::Formatter::Base do
         expect(subject.call(severity, time, progname, message)).to be_nil
       end
     end
+
+    context "when building the event raises" do
+      before do
+        allow(subject).to receive(:error_logger).and_return(Logger.new(IO::NULL))
+        allow(subject).to receive(:build_event).and_raise(ArgumentError, 'boom')
+      end
+
+      it "logs an exception" do
+        expect(subject).to receive(:log_error).and_call_original
+        subject.call(severity, time, progname, message)
+      end
+
+      it "returns a well-formed placeholder event instead of a bare string" do
+        event = subject.call(severity, time, progname, message)
+        expect(event).to be_a(LogStash::Event)
+        expect(event['message']).to eq(LogStashLogger::Formatter::Base::FAILED_TO_FORMAT_MSG)
+        expect(event['tags']).to eq([LogStashLogger::Formatter::Base::FAILED_TO_FORMAT_TAG])
+        expect(event['error']).to eq('ArgumentError')
+        expect(event['severity']).to eq(severity)
+        expect(event['@timestamp']).to eq(time.iso8601(3))
+      end
+    end
+
+    context "when even the placeholder cannot be formatted" do
+      before do
+        allow(subject).to receive(:error_logger).and_return(Logger.new(IO::NULL))
+        allow(subject).to receive(:format_event).and_raise(ArgumentError, 'boom')
+      end
+
+      it "returns nil, which devices drop" do
+        expect(subject.call(severity, time, progname, message)).to be_nil
+      end
+    end
+
+    context "when logged content carries an @timestamp that is not a time" do
+      let(:message) { '{"message":"hello","@timestamp":"not-a-time"}' }
+
+      it "keeps the logger time and formats the record normally" do
+        event = subject.call(severity, time, progname, message)
+        expect(event['message']).to eq('hello')
+        expect(event['@timestamp']).to eq(time.iso8601(3))
+      end
+    end
+
+    context "when logged content carries a valid @timestamp" do
+      let(:message) { '{"message":"hello","@timestamp":"2001-01-01T00:00:00Z"}' }
+
+      it "keeps it" do
+        event = subject.call(severity, time, progname, message)
+        expect(event['@timestamp']).to start_with('2001-01-01T00:00:00')
+      end
+    end
+  end
+
+  describe '#force_utf8_encoding' do
+    let(:message) { "foo x\xc3x".force_encoding('ASCII-8BIT').freeze }
+    let(:event) { LogStash::Event.new("message" => message) }
+
+    it 'returns the same event' do
+      expect(subject.send(:force_utf8_encoding, event)).to eq(event)
+    end
+
+    it 'forces the event message to UTF-8 encoding' do
+      subject.send(:force_utf8_encoding, event)
+      updated_event_data = event.instance_variable_get(:@data)
+      expect(updated_event_data['message'].encoding.name).to eq('UTF-8')
+    end
+
+    context 'frozen message string' do
+      let(:message) { "foo x\xc3x".dup.force_encoding('ASCII-8BIT').freeze }
+
+      it 'returns the same event' do
+        expect(subject.send(:force_utf8_encoding, event)).to eq(event)
+      end
+
+      it 'forces the event message to UTF-8 encoding' do
+        subject.send(:force_utf8_encoding, event)
+        updated_event_data = event.instance_variable_get(:@data)
+        expect(updated_event_data['message'].encoding.name).to eq('UTF-8')
+      end
+    end
   end
 
   describe "#build_event" do
@@ -81,7 +162,7 @@ describe LogStashLogger::Formatter::Base do
       end
 
       it "adds host" do
-        expect(event['host']).to eq(hostname)
+        expect(event['host']['hostname']).to eq(hostname)
       end
     end
 

data/spec/formatter/cee_syslog_spec.rb

@@ -1,43 +1,95 @@
 require 'logstash-logger'
+require_relative '../support/unserializable_value'
 
 describe LogStashLogger::Formatter::CeeSyslog do
   include_context "formatter"
 
-  describe "#call" do
-    let(:facility) { "facility" }
-
-    before do
-      allow(subject).to receive(:build_facility).and_return(facility)
-    end
+  before { subject.error_logger = Logger.new(IO::NULL) }
 
-    it "outputs a facility before the @cee" do
-      expect(formatted_message).to match(/\A#{facility}:@cee:/)
+  describe "#call" do
+    it "outputs this host and the progname before the @cee" do
+      expect(formatted_message).to start_with("#{hostname} #{progname}:@cee:")
     end
 
     it "serializes the LogStash::Event data as JSON" do
-      json_data = formatted_message[/\A#{facility}:@cee:\s?(.*)\Z/, 1]
+      json_data = formatted_message[/\A[^:]*:@cee:\s?(.*)\Z/, 1]
       json_message = JSON.parse(json_data)
       expect(json_message["message"]).to eq(message)
     end
+
+    it "ends the record with exactly one newline" do
+      expect(formatted_message.count("\n")).to eq(1)
+      expect(formatted_message).to end_with("\n")
+    end
+
+    context "without progname" do
+      let(:progname) { nil }
+
+      it "only includes the hostname" do
+        expect(formatted_message).to start_with("#{hostname}:@cee:")
+      end
+    end
   end
 
-  describe "#build_facility" do
-    let(:host) { Socket.gethostname }
+  describe "header" do
+    context "when logged content sets host.hostname" do
+      let(:message) { %q({"message":"hi","host":{"hostname":"web1\n<13>Jan  1 00:00:00 otherhost app: forged"}}) }
+
+      it "uses this process's hostname, not the logged one" do
+        expect(formatted_message).to start_with("#{hostname} #{progname}:@cee:")
+      end
+
+      it "cannot start a second record" do
+        expect(formatted_message.count("\n")).to eq(1)
+        expect(formatted_message).to end_with("\n")
+      end
+    end
+
+    context "when logged content sets host to a String" do
+      let(:message) { %q({"message":"hi","host":"web1"}) }
 
-    before do
-      formatted_message
+      it "formats the record normally" do
+        expect(formatted_message).to start_with("#{hostname} #{progname}:@cee:")
+        expect(JSON.parse(formatted_message[/@cee:(.*)\Z/, 1])['host']).to eq('web1')
+      end
     end
 
-    it "includes hostname and progname" do
-      expect(subject.send(:build_facility, host)).to match(/\A#{host}\s#{progname}\z/)
+    context "when the progname contains control characters" do
+      let(:progname) { "app\n<13>forged" }
+
+      it "keeps the header on one line" do
+        expect(formatted_message.count("\n")).to eq(1)
+        expect(formatted_message).to start_with("#{hostname} app <13>forged:@cee:")
+      end
     end
 
-    context "without progname" do
-      let(:progname) { nil }
+    context "when a log call is made while another record is being built" do
+      let(:formatter) { subject }
+      let(:message) do
+        f = formatter
+        Object.new.tap do |obj|
+          obj.define_singleton_method(:inspect) do
+            f.call('INFO', Time.now, 'inner', 'nested')
+            'outer message'
+          end
+        end
+      end
 
-      it "only includes hostname" do
-        expect(subject.send(:build_facility, host)).to match(/\A#{host}\z/)
+      it "uses the outer call's progname in the outer header" do
+        expect(subject.call(severity, time, 'outer', message)).to start_with("#{hostname} outer:@cee:")
       end
     end
   end
+
+  describe "when the record cannot be serialized" do
+    let(:message) { { 'message' => 'x', 'n' => UnserializableValue.new } }
+
+    it "emits a placeholder in the same CEE/syslog framing" do
+      expect(formatted_message).to start_with("#{hostname} #{progname}:@cee:")
+      expect(formatted_message.count("\n")).to eq(1)
+      data = JSON.parse(formatted_message[/@cee:(.*)\Z/, 1])
+      expect(data['message']).to eq(LogStashLogger::Formatter::Base::FAILED_TO_FORMAT_MSG)
+      expect(data['tags']).to eq([LogStashLogger::Formatter::Base::FAILED_TO_FORMAT_TAG])
+    end
+  end
 end

data/spec/formatter/framing_spec.rb

@@ -0,0 +1,58 @@
+require 'logstash-logger'
+require_relative '../support/unserializable_value'
+require 'logger'
+require 'net/http'
+
+# A record that cannot be formatted must not change how its neighbours are
+# framed on the wire.
+describe 'Record framing when a record cannot be formatted' do
+  let(:failing) { { 'message' => 'x', 'n' => UnserializableValue.new } }
+  let(:bad_timestamp) { %q({"message":"y","@timestamp":"not-a-time"}) }
+
+  before do
+    LogStashLogger.configure { |c| c.default_error_logger = ::Logger.new(IO::NULL) }
+  end
+
+  after { LogStashLogger.configure { |c| c.default_error_logger = ::Logger.new($stderr) } }
+
+  it 'keeps every line of a json_lines stream parseable' do
+    io = StringIO.new
+    logger = LogStashLogger.new(type: :io, io: io, sync: true)
+    logger.info(failing)
+    logger.info(bad_timestamp)
+    logger.info('next record')
+
+    lines = io.string.lines
+    expect(lines.size).to eq(3)
+    parsed = lines.map { |l| JSON.parse(l) }
+    expect(parsed[0]['tags']).to eq([LogStashLogger::Formatter::Base::FAILED_TO_FORMAT_TAG])
+    expect(parsed[1]['message']).to eq('y')
+    expect(parsed[2]['message']).to eq('next record')
+  end
+
+  it 'keeps every record of a cee_syslog stream on its own line' do
+    io = StringIO.new
+    logger = LogStashLogger.new(type: :io, io: io, sync: true, formatter: :cee_syslog)
+    logger.info(failing)
+    logger.info(%q({"message":"z","host":{"hostname":"web1\n<13>forged"}}))
+    logger.info('next record')
+
+    lines = io.string.lines
+    expect(lines.size).to eq(3)
+    lines.each { |l| expect(l).to start_with("#{Socket.gethostname}:@cee:") }
+  end
+
+  it 'keeps an HTTP batch a valid JSON array' do
+    formatter = LogStashLogger::Formatter.new(:json_lines)
+    messages = [failing, 'next record'].map { |m| formatter.call('INFO', Time.now, nil, m) }
+    device = LogStashLogger::Device.new(type: :http, url: 'http://localhost', sync: true)
+    body = nil
+    allow(Net::HTTP).to receive(:post) { |_url, b, _h| body = b; Net::HTTPOK.new('1.1', '200', 'OK') }
+
+    device.write_batch(messages)
+
+    batch = JSON.parse(body)
+    expect(batch.size).to eq(2)
+    expect(batch[1]['message']).to eq('next record')
+  end
+end

data/spec/formatter/json_lines_spec.rb

@@ -1,4 +1,5 @@
 require 'logstash-logger'
+require_relative '../support/unserializable_value'
 
 describe LogStashLogger::Formatter::JsonLines do
   include_context "formatter"
@@ -11,4 +12,44 @@ describe LogStashLogger::Formatter::JsonLines do
   it "terminates with a line break" do
     expect(formatted_message[-1]).to eq("\n")
   end
+
+  context 'encoding error is raised' do
+    let(:message) { "foo x\xc3x".force_encoding('ASCII-8BIT') }
+
+    before do
+      allow(subject).to receive(:error_logger).and_return(Logger.new('/dev/null'))
+    end
+
+    it 'logs the error' do
+      expect(subject).to receive(:log_error)
+      formatted_message
+    end
+
+    it 'forces the message encoding to utf8' do
+      expect(subject).to receive(:force_utf8_encoding)
+      formatted_message
+    end
+
+    it "outputs in JSON format with message encoding updated to utf8" do
+      json_message = JSON.parse(formatted_message)
+      expect(json_message["message"]).to eq(message.force_encoding(Encoding::UTF_8).scrub)
+    end
+  end
+
+  context 'when the record cannot be serialized' do
+    let(:message) { { 'message' => 'x', 'n' => UnserializableValue.new } }
+
+    before do
+      allow(subject).to receive(:error_logger).and_return(Logger.new(IO::NULL))
+    end
+
+    it 'emits a JSON placeholder line instead of a bare string' do
+      expect(formatted_message).to end_with("\n")
+      expect(formatted_message.count("\n")).to eq(1)
+      data = JSON.parse(formatted_message)
+      expect(data['message']).to eq(LogStashLogger::Formatter::Base::FAILED_TO_FORMAT_MSG)
+      expect(data['tags']).to eq([LogStashLogger::Formatter::Base::FAILED_TO_FORMAT_TAG])
+      expect(data['error']).to eq('JSON::GeneratorError')
+    end
+  end
 end

data/spec/formatter/json_spec.rb

@@ -7,4 +7,53 @@ describe LogStashLogger::Formatter::Json do
     json_message = JSON.parse(formatted_message)
     expect(json_message["message"]).to eq(message)
   end
+
+  context 'encoding error is raised' do
+    let(:message) { "foo x\xc3x".force_encoding('ASCII-8BIT') }
+
+    before do
+      allow(subject).to receive(:error_logger).and_return(Logger.new('/dev/null'))
+    end
+
+    it 'logs the error' do
+      expect(subject).to receive(:log_error)
+      formatted_message
+    end
+
+    it 'forces the message encoding to utf8' do
+      expect(subject).to receive(:force_utf8_encoding)
+      formatted_message
+    end
+
+    it "outputs in JSON format with message encoding updated to utf8" do
+      json_message = JSON.parse(formatted_message)
+      expect(json_message["message"]).to eq(message.force_encoding(Encoding::UTF_8).scrub)
+    end
+  end
+
+  context "timestamp ordering" do
+    let(:message) { { message: 'test', foo: 'bar' } }
+
+    it "places @timestamp first in JSON output" do
+      timestamp_index = formatted_message.index('"@timestamp"')
+      message_index = formatted_message.index('"message"')
+
+      expect(timestamp_index).not_to be_nil
+      expect(message_index).not_to be_nil
+      expect(timestamp_index).to be < message_index
+    end
+  end
+
+  context "key ordering" do
+    let(:message) { { foo: 'bar', baz: 'qux' } }
+
+    it "preserves custom field order in JSON output" do
+      foo_index = formatted_message.index('"foo"')
+      baz_index = formatted_message.index('"baz"')
+
+      expect(foo_index).not_to be_nil
+      expect(baz_index).not_to be_nil
+      expect(foo_index).to be < baz_index
+    end
+  end
 end

data/spec/formatter_spec.rb

@@ -35,6 +35,23 @@ describe LogStashLogger::Formatter do
         end
       end
 
+      context "formatter class that accepts customize_event keyword arg in initializer" do
+        let(:formatter) do
+          Class.new do
+            def initialize(customize_event: nil)
+            end
+
+            def call
+            end
+          end
+        end
+
+        it "returns a new instance of the class" do
+          expect(formatter).to receive(:new).with(hash_including(:customize_event)).and_call_original
+          expect(subject).to be_a formatter
+        end
+      end
+
       context "formatter instance" do
         let(:formatter) { ::Logger::Formatter.new }
 
@@ -49,7 +66,7 @@ describe LogStashLogger::Formatter do
 
       context "formatter proc" do
         let(:formatter) do
-          proc { |severity, time, progname, msg| msg }
+          proc { |_severity, _time, _progname, msg| msg }
         end
 
         it "returns the same formatter proc" do
@@ -63,7 +80,7 @@ describe LogStashLogger::Formatter do
 
       context "formatter lambda" do
         let(:formatter) do
-          ->(severity, time, progname, msg) { msg }
+          ->(_severity, _time, _progname, msg) { msg }
         end
 
         it "returns the same formatter lambda" do