logstash-logger-p 0.26.1

data/spec/device/tcp_spec.rb

@@ -0,0 +1,120 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::TCP do
+  include_context 'device'
+
+  let(:tcp_socket) { double('TCPSocket') }
+  let(:ssl_socket) { double('SSLSocket') }
+
+  before(:each) do
+    allow(TCPSocket).to receive(:new) { tcp_socket }
+    allow(tcp_socket).to receive(:sync=)
+
+    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_tcp_device).to receive(:warn)
+  end
+
+  context "when not using SSL" do
+    it "writes to a TCP socket" do
+      expect(tcp_socket).to receive(:write)
+      tcp_device.write('test')
+    end
+
+    it "returns false for #use_ssl?" do
+      expect(tcp_device.use_ssl?).to be_falsey
+    end
+
+    it "exposes the TCP socket via #io" do
+      expect(tcp_device.io).to eq tcp_socket
+    end
+  end
+
+  context "when using SSL" do
+    it "writes to an SSL TCP socket" do
+      expect(ssl_socket).to receive(:write)
+      ssl_tcp_device.write('test')
+    end
+
+    it "returns true for #use_ssl?" do
+      expect(ssl_tcp_device.use_ssl?).to be_truthy
+    end
+
+    it "exposes the SSL socket via #io" do
+      expect(ssl_tcp_device.io).to eq ssl_socket
+    end
+
+    context 'hostname validation' do
+      let(:ssl_context) { double('test_ssl_context', verify_mode: OpenSSL::SSL::VERIFY_PEER) }
+      let(:ssl_tcp_options) { { type: :tcp, port: port, sync: true, ssl_context: ssl_context } }
+
+      context 'is enabled by default' do
+        let(:ssl_tcp_device) { LogStashLogger::Device.new(ssl_tcp_options) }
+
+        it 'validates' do
+          expect(ssl_tcp_device.send(:verify_hostname?)).to be_truthy
+          expect(ssl_socket).to receive(:post_connection_check).with HOST
+          ssl_tcp_device.connect
+        end
+      end
+
+      context 'is disabled explicitly' do
+        let(:ssl_tcp_device) { LogStashLogger::Device.new(ssl_tcp_options.merge(verify_hostname: false)) }
+
+        it 'does not validate' do
+          expect(ssl_tcp_device.send(:verify_hostname?)).to be_falsey
+          expect(ssl_socket).not_to receive(:post_connection_check)
+          ssl_tcp_device.connect
+        end
+      end
+
+      context 'is implicitly enabled by providing a hostname' do
+        let(:hostname) { 'www.example.com' }
+        let(:ssl_tcp_device) { LogStashLogger::Device.new(ssl_tcp_options.merge(verify_hostname: hostname)) }
+
+        it 'validates with supplied hostname' do
+          expect(ssl_socket).to receive(:post_connection_check).with hostname
+          ssl_tcp_device.connect
+        end
+      end
+    end
+
+    context 'with a provided SSL context' do
+      let(:ssl_context) { double('test_ssl_context', verify_mode: OpenSSL::SSL::VERIFY_PEER) }
+      let(:ssl_tcp_device) { LogStashLogger::Device.new(type: :tcp, port: port, sync: true, ssl_context: ssl_context) }
+
+      it 'creates the socket using that context' do
+        expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, ssl_context)
+        ssl_tcp_device.connect
+      end
+
+      it 'implicitly sets @use_ssl to true' do
+        expect(ssl_tcp_device.use_ssl?).to be_truthy
+      end
+
+      context 'and :ssl_enable explicitly set to false' do
+        let(:ssl_tcp_device) { LogStashLogger::Device.new(type: :tcp, port: port, sync: true, ssl_enable: false, ssl_context: ssl_context) }
+
+        it 'explicitly sets @use_ssl to false' do
+          expect(ssl_tcp_device.use_ssl?).to be_falsey
+        end
+      end
+    end
+
+    context 'without a provided SSL context' do
+      it 'ssl_context returns nil' do
+        expect(ssl_tcp_device.ssl_context).to be_nil
+      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') }
+
+      it 'implicitly uses a context with the configured certificate' do
+        expect(ssl_tcp_device.ssl_context.cert).to eq('/path/to/cert.pem')
+      end
+    end
+  end
+
+end

data/spec/device/udp_spec.rb

@@ -0,0 +1,9 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::UDP do
+  include_context 'device'
+
+  it "writes to a UDP socket" do
+    expect(udp_device.to_io).to be_a UDPSocket
+  end
+end

data/spec/device/unix_spec.rb

@@ -0,0 +1,23 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::Unix do
+  include_context 'device'
+
+  let(:unix_socket) { double("UNIXSocket") }
+
+  before(:each) do
+    allow(::UNIXSocket).to receive(:new) { unix_socket }
+    allow(unix_socket).to receive(:sync=)
+  end
+
+  it "writes to a local unix socket" do
+    expect(unix_socket).to receive(:write)
+    unix_device.write('foo')
+  end
+
+  context "when path is not specified" do
+    it "raises an exception" do
+      expect { described_class.new }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/device_spec.rb

@@ -0,0 +1,97 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device do
+  include_context 'device'
+
+  context "when port is specified" do
+    it "defaults type to UDP" do
+      expect(device_with_port).to be_a LogStashLogger::Device::UDP
+    end
+  end
+
+  context "when passing in configuration" do
+    let(:configuration) { {type: :udp, port: port} }
+
+    subject(:new_device) { described_class.new(configuration) }
+
+    it "does not mutate the passed configuration" do
+      expect{ new_device }.to_not change { configuration }
+      expect( new_device ).to be_a LogStashLogger::Device::UDP
+    end
+  end
+
+  context "when configuration type is a String" do
+    let(:configuration) { {type: "udp", port: port} }
+
+    subject(:new_device) { described_class.new(configuration) }
+
+    it "it correctly recognizes the device type" do
+      expect(new_device).to be_a LogStashLogger::Device::UDP
+    end
+  end
+
+  describe ".parse_uri_config" do
+    subject(:parse_uri_config) { described_class.parse_uri_config(uri_config) }
+
+    context "when uri_config is valid" do
+      let(:uri_config) { udp_uri_config }
+      it { is_expected.to eq({type: 'udp', host: 'localhost', port: 5228, path: ''}) }
+    end
+
+    context "when uri is invalid" do
+      let(:uri_config) { invalid_uri_config }
+      specify { expect { parse_uri_config }.to raise_error(URI::InvalidURIError) }
+    end
+  end
+
+  describe "Parsing URI configurations" do
+    subject(:new_device) { described_class.new(uri_config) }
+
+    context "when URI config is udp" do
+      let(:uri_config) { udp_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::UDP }
+    end
+
+    context "when URI config is tcp" do
+      let(:uri_config) { tcp_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::TCP }
+    end
+
+    context "when URI config is unix" do
+      let(:uri_config) { unix_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::Unix }
+    end
+
+    context "when URI config is file" do
+      let(:uri_config) { file_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::File }
+    end
+
+    context "when URI config is redis" do
+      let(:uri_config) { redis_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::Redis }
+      context "list specified" do
+        let(:uri_config) { redis_uri_config.merge({list: 'mylist'}) }
+        it 'is expected to have the list option set' do
+          expect(new_device.list).to eq('mylist')
+        end
+      end
+    end
+
+    context "when URI config is kafka" do
+      let(:uri_config) { kafka_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::Kafka }
+    end
+
+    context "when URI config is stdout" do
+      let(:uri_config) { stdout_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::Stdout }
+    end
+
+    context 'when URI config is stderr' do
+      let(:uri_config) { stderr_uri_config }
+      it { is_expected.to be_a LogStashLogger::Device::Stderr }
+    end
+  end
+
+end

data/spec/formatter/base_spec.rb

@@ -0,0 +1,125 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Formatter::Base do
+  include_context "formatter"
+
+  describe "#call" do
+    context "when event is not cancelled" do
+      it "returns a formatted message" do
+        expect(subject).to receive(:format_event).once.with(instance_of(LogStash::Event)).and_call_original
+        expect(subject.call(severity, time, progname, message)).to be_a(LogStash::Event)
+      end
+    end
+
+    context "when event is cancelled" do
+      before(:each) do
+        LogStashLogger.configure do |config|
+          config.customize_event(&:cancel)
+        end
+      end
+
+      it "returns `nil`" do
+        expect(subject).not_to receive(:format_event)
+        expect(subject.call(severity, time, progname, message)).to be_nil
+      end
+    end
+  end
+
+  describe "#build_event" do
+    let(:event) { formatted_message }
+
+    describe "message type" do
+      context "string" do
+        it "puts the message into the message field" do
+          expect(event['message']).to eq(message)
+        end
+      end
+
+      context "JSON string" do
+        let(:message) do
+          { message: 'test', foo: 'bar' }.to_json
+        end
+
+        it "parses the JSON and merges into the event" do
+          expect(event['message']).to eq('test')
+          expect(event['foo']).to eq('bar')
+        end
+      end
+
+      context "hash" do
+        let(:message) do
+          { 'message' => 'test', 'foo' => 'bar' }
+        end
+
+        it "merges into the event" do
+          expect(event['message']).to eq('test')
+          expect(event['foo']).to eq('bar')
+        end
+      end
+
+      context "LogStash::Event" do
+        let(:message) { LogStash::Event.new("message" => "foo") }
+
+        it "returns a clone of the original event" do
+          expect(event['message']).to eq("foo")
+          expect(event).to_not equal(message)
+        end
+      end
+
+      context "fallback" do
+        let(:message) { [1, 2, 3] }
+
+        it "calls inspect" do
+          expect(event['message']).to eq(message.inspect)
+        end
+      end
+    end
+
+    describe "extra fields on the event" do
+      it "adds severity" do
+        expect(event['severity']).to eq(severity)
+      end
+
+      it "adds host" do
+        expect(event['host']).to eq(hostname)
+      end
+    end
+
+    describe "timestamp" do
+      it "ensures time is in ISO8601 format" do
+        expect(event.timestamp).to eq(time.iso8601(3))
+      end
+    end
+
+    describe "long messages" do
+
+      context "message field is present" do
+        let(:message) { long_message }
+
+        it "truncates long messages when max_message_size is set" do
+          LogStashLogger.configure do |config|
+            config.max_message_size = 2000
+          end
+
+          expect(event['message'].size).to eq(2000)
+        end
+      end
+
+      context "event without message field" do
+        let(:message) do
+          { 'test_field' => 'test', 'foo' => 'bar' }
+        end
+
+        it "still works" do
+          LogStashLogger.configure do |config|
+            config.max_message_size = 2000
+          end
+
+          expect(event['message']).to eq(nil)
+          expect(event['test_field']).to eq('test')
+          expect(event['foo']).to eq('bar')
+        end
+      end
+    end
+  end
+end

data/spec/formatter/cee_spec.rb

@@ -0,0 +1,15 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Formatter::Cee do
+  include_context "formatter"
+
+  it "outputs in CEE format" do
+    expect(formatted_message).to match(/\A@cee:/)
+  end
+
+  it "serializes the LogStash::Event data as JSON" do
+    json_data = formatted_message[/\A@cee:\s?(.*)\z/, 1]
+    json_message = JSON.parse(json_data)
+    expect(json_message["message"]).to eq(message)
+  end
+end

data/spec/formatter/cee_syslog_spec.rb

@@ -0,0 +1,43 @@
+require 'logstash-logger'
+
+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
+
+    it "outputs a facility before the @cee" do
+      expect(formatted_message).to match(/\A#{facility}:@cee:/)
+    end
+
+    it "serializes the LogStash::Event data as JSON" do
+      json_data = formatted_message[/\A#{facility}:@cee:\s?(.*)\Z/, 1]
+      json_message = JSON.parse(json_data)
+      expect(json_message["message"]).to eq(message)
+    end
+  end
+
+  describe "#build_facility" do
+    let(:host) { Socket.gethostname }
+
+    before do
+      formatted_message
+    end
+
+    it "includes hostname and progname" do
+      expect(subject.send(:build_facility, host)).to match(/\A#{host}\s#{progname}\z/)
+    end
+
+    context "without progname" do
+      let(:progname) { nil }
+
+      it "only includes hostname" do
+        expect(subject.send(:build_facility, host)).to match(/\A#{host}\z/)
+      end
+    end
+  end
+end

data/spec/formatter/json_lines_spec.rb

@@ -0,0 +1,14 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Formatter::JsonLines do
+  include_context "formatter"
+
+  it "outputs in JSON format" do
+    json_message = JSON.parse(formatted_message)
+    expect(json_message["message"]).to eq(message)
+  end
+
+  it "terminates with a line break" do
+    expect(formatted_message[-1]).to eq("\n")
+  end
+end

data/spec/formatter/json_spec.rb

@@ -0,0 +1,10 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Formatter::Json do
+  include_context "formatter"
+
+  it "outputs in JSON format" do
+    json_message = JSON.parse(formatted_message)
+    expect(json_message["message"]).to eq(message)
+  end
+end

data/spec/formatter/logstash_event_spec.rb

@@ -0,0 +1,10 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Formatter::LogStashEvent do
+  include_context "formatter"
+
+  it "outputs a LogStash::Event" do
+    expect(formatted_message).to be_a LogStash::Event
+    expect(formatted_message["message"]).to eq(message)
+  end
+end

data/spec/formatter_spec.rb

@@ -0,0 +1,79 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Formatter do
+  describe "#new" do
+    context "built in formatters" do
+      it "returns a new JsonLines formatter" do
+        expect(described_class.new(:json_lines)).to be_a LogStashLogger::Formatter::JsonLines
+      end
+
+      it "returns a new Json formatter" do
+        expect(described_class.new(:json)).to be_a LogStashLogger::Formatter::Json
+      end
+
+      it "returns a new Cee formatter" do
+        expect(described_class.new(:cee)).to be_a LogStashLogger::Formatter::Cee
+      end
+
+      it "returns a new CeeSyslog formatter" do
+        expect(described_class.new(:cee_syslog)).to be_a LogStashLogger::Formatter::CeeSyslog
+      end
+
+      it "returns a new LogStashEvent formatter" do
+        expect(described_class.new(:logstash_event)).to be_a LogStashLogger::Formatter::LogStashEvent
+      end
+    end
+
+    context "custom formatter" do
+      subject { described_class.new(formatter) }
+
+      context "formatter class" do
+        let(:formatter) { ::Logger::Formatter }
+
+        it "returns a new instance of the class" do
+          expect(subject).to be_a formatter
+        end
+      end
+
+      context "formatter instance" do
+        let(:formatter) { ::Logger::Formatter.new }
+
+        it "returns the same formatter instance" do
+          expect(subject).to eql(formatter)
+        end
+
+        it "supports tagged logging" do
+          expect(subject).to be_a ::LogStashLogger::TaggedLogging::Formatter
+        end
+      end
+
+      context "formatter proc" do
+        let(:formatter) do
+          proc { |severity, time, progname, msg| msg }
+        end
+
+        it "returns the same formatter proc" do
+          expect(subject).to eql(formatter)
+        end
+
+        it "supports tagged logging" do
+          expect(subject).to be_a ::LogStashLogger::TaggedLogging::Formatter
+        end
+      end
+
+      context "formatter lambda" do
+        let(:formatter) do
+          ->(severity, time, progname, msg) { msg }
+        end
+
+        it "returns the same formatter lambda" do
+          expect(subject).to eql(formatter)
+        end
+
+        it "supports tagged logging" do
+          expect(subject).to be_a ::LogStashLogger::TaggedLogging::Formatter
+        end
+      end
+    end
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,128 @@
+require 'logstash-logger'
+
+describe LogStashLogger do
+  include_context 'logger'
+
+  let! :listener do
+    case connection_type
+    when :tcp
+      TCPServer.new(port)
+    when :udp
+      UDPSocket.new.tap {|socket| socket.bind(host, port)}
+    end
+  end
+
+  # The TCP socket written to by the TCP logstash listener server
+  let(:tcp_client) { listener.accept }
+
+  # The logstash event to log
+  let(:logstash_event) do
+    LogStash::Event.new.tap do |event|
+      event['message'] = 'test'
+      event['severity'] = 'INFO'
+    end
+  end
+
+  # The raw input received by the logstash listener
+  let :listener_input do
+    case connection_type
+    when :tcp then tcp_client.readline
+    when :udp then listener.recvfrom(8192)[0]
+    end
+  end
+
+  # The logstash event received by the listener
+  let(:listener_event) { LogStash::Event.new(JSON.parse listener_input) }
+
+  #before(:each) do
+    # Sync socket writes so we can receive them in the listener immediately
+    #@socket = logdev.instance_variable_get(:@dev).send(:connect)
+    #@socket.sync = true
+  #end
+
+  after(:each) do
+    listener.close
+  end
+
+  # The socket that the logger is writing to
+  #let(:socket) { @socket }
+
+  it 'uses a LogStashLogger::Device as the log device' do
+    expect(logdev).to be_a Logger::LogDevice
+    expect(logdev.instance_variable_get(:@dev)).to be_a LogStashLogger::Device::Base
+  end
+
+  it 'takes a string message as input and writes a logstash event' do
+    message = 'test'
+    logger.info(message)
+
+    expect(listener_event['severity']).to eql('INFO')
+    expect(listener_event['message']).to eq(message)
+    expect(listener_event['host']).to eq(hostname)
+  end
+
+  it 'takes a logstash-formatted json string as input and writes out a logstash event' do
+    logger.info(logstash_event.to_json)
+
+    expect(listener_event['message']).to eq(logstash_event['message'])
+    expect(listener_event['host']).to eq(hostname)
+  end
+
+  it 'takes a LogStash::Event as input and writes it out intact' do
+    logger.warn(logstash_event)
+
+    expect(listener_event['message']).to eq(logstash_event['message'])
+    expect(listener_event['severity']).to eq(logstash_event['severity'])
+    expect(listener_event['@timestamp'].iso8601).to eq(logstash_event.timestamp.iso8601)
+    expect(listener_event['host']).to eq(hostname)
+  end
+
+  it 'takes a data hash as input and writes out a logstash event' do
+    data = {
+      'message' => 'test',
+      'severity' => 'INFO',
+      'foo' => 'bar'
+    }
+
+    logger.info(data.dup)
+
+    expect(listener_event['message']).to eq(data["message"])
+    expect(listener_event['severity']).to eq(data['severity'])
+    expect(listener_event['foo']).to eq(data['foo'])
+    expect(listener_event['host']).to eq(hostname)
+    expect(listener_event['@timestamp']).to_not be_nil
+  end
+
+  it 'takes any object as input and writes a logstash event' do
+    message = Time.now
+
+    logger.info(message)
+
+    expect(listener_event['message']).to eq(message.inspect)
+    expect(listener_event['host']).to eq(hostname)
+    expect(listener_event['severity']).to eq('INFO')
+  end
+
+  it 'allows event to be customized via configuration' do
+    LogStashLogger.configure do |config|
+      config.customize_event do |event|
+        event["test1"] = "response1"
+      end
+    end
+
+    logger.info("test")
+
+    expect(listener_event["test1"]).to eq("response1")
+  end
+
+  describe 'customize_event on instance' do
+    let!(:customize_event) { ->(event){ event['custom'] = 'custom' } }
+    let!(:logger) { LogStashLogger.new(host: host, port: port, type: connection_type, sync: true, customize_event: customize_event)}
+
+    specify 'logger produce messages with custom field' do
+      logger.info('test')
+      expect(listener_event['custom']).to eq('custom')
+    end
+  end
+
+end