logstash-logger-p 0.26.1

data/samples/example.crt

@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE-----
+MIICdTCCAd4CCQDLMpdv+B+sYDANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJV
+UzETMBEGA1UECBMKQ2FsaWZvcm5pYTERMA8GA1UEBxMIUGFzYWRlbmExDzANBgNV
+BAoTBkJ1dGxlcjEVMBMGA1UEAxMMRGF2aWQgQnV0bGVyMSAwHgYJKoZIhvcNAQkB
+FhFkd2J1dGxlckB1Y2xhLmVkdTAeFw0xNDA2MDkwNjIyMTZaFw0xNTA2MDkwNjIy
+MTZaMH8xCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMREwDwYDVQQH
+EwhQYXNhZGVuYTEPMA0GA1UEChMGQnV0bGVyMRUwEwYDVQQDEwxEYXZpZCBCdXRs
+ZXIxIDAeBgkqhkiG9w0BCQEWEWR3YnV0bGVyQHVjbGEuZWR1MIGfMA0GCSqGSIb3
+DQEBAQUAA4GNADCBiQKBgQDbBJ1t2m8RA72GZZ8XOUCsLI1EhRqZqWx0zYHpZbc4
+kVbfMeb5uyfpx1gd5QngZrsD0cvTf46F9z9Ng805Ns9jE5QBJxefl1b6iJ6f/Y9s
+W+WYQJgtNOcJahWWLeiBXqApPUllFI2ME/52+/umuSYVtSVAW7QmPx3YSLPpVjkQ
+3wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAKiZm6yNzRXKJ9LBLL+Nep87WPlkdFmx
+YUoEtTF8XpgMNfOdzF8DlD4FmoNz/SD7uVOk+tARUoEQFVK+iqpd3/dLDVa/pslX
+a5v6AcmgfSFUHgLvKQZNvgY50jhLdqruf8PCgVnq+4L0ItguJx/viYMxF0p0fJTG
+oGX8W4ul0W5F
+-----END CERTIFICATE-----

data/samples/example.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICWwIBAAKBgQDbBJ1t2m8RA72GZZ8XOUCsLI1EhRqZqWx0zYHpZbc4kVbfMeb5
+uyfpx1gd5QngZrsD0cvTf46F9z9Ng805Ns9jE5QBJxefl1b6iJ6f/Y9sW+WYQJgt
+NOcJahWWLeiBXqApPUllFI2ME/52+/umuSYVtSVAW7QmPx3YSLPpVjkQ3wIDAQAB
+AoGAYaFXBAchB3ahX22hU1rkJ1vcxTSIPQM3I4IQbRg4anDvRqMaESyKiD2iXAEj
+O/LPXs6Ai5EK2VDz2Pvt2ZlDLFX3GKMEChtIa2mpiQqIdoJS+42ibqfHrv3nlnTK
+OTeTcw+SbAAFTKFPJO94lGcBXhsYYW/LAFH08bVqp+Jhi1ECQQDzkz4O0eYH05Wb
+1bAwjNcjj+X6JKIRGgWYb1kkk3VyAFuD6qCEKBfS2t4nZs1yy83Ch4Bk9YmDHx1Q
+gdYCjPsLAkEA5jCwo51KqboxAz6m0pZwdiKlCav94TMdHMKTFcUE5fDoWrwzrIyH
+8rr7q7cl3culX7pUcPdKMl78Nw6/4JFF/QJARwNfrWxut0ttq+BSHOWC98BFWXeC
+tJ+0j+uuvqYrMJCAHeay47TYtUXQTQaA0X4vwA5HVafsbokMv+MKpPW7XwJAF713
+yjgDpkOMoIAKpndbe+OQz9GMKniiDQBIORuLqMdSv2Dfl3Ea6D6+i/QklJ5XHOtT
+oB7w6QcAzhDYWynAZQJAX0UF9alkX8CQq1rvsAG6zzh3bD+Udy7cU0Yonx/byZoz
+K6G/seM5YFTMVrnbY9V23aIhjJSxGWOB5fDNPG5p4w==
+-----END RSA PRIVATE KEY-----

data/samples/file.conf

@@ -0,0 +1,11 @@
+input {
+  file {
+    path => "/usr/local/var/logstash.log"
+    format => json
+  }
+}
+output {
+  stdout {
+    codec => json_lines
+  }
+}

data/samples/redis.conf

@@ -0,0 +1,12 @@
+input {
+  redis {
+    data_type => "list"
+    codec => json
+    key => "logstash"
+  }
+}
+output {
+  stdout {
+    codec => json_lines
+  }
+}

data/samples/ssl.conf

@@ -0,0 +1,15 @@
+input {
+  tcp {
+    port => 8443
+    ssl_enable => true
+    ssl_cert => "samples/example.crt"
+    ssl_key => "samples/example.key"
+    codec => json_lines
+  }
+}
+output {
+  stdout {
+    codec => json_lines
+  }
+}
+

data/samples/syslog.conf

@@ -0,0 +1,10 @@
+input {
+  syslog {
+    codec => json_lines
+  }
+}
+output {
+  stdout {
+    codec => json_lines
+  }
+}

data/samples/tcp.conf

@@ -0,0 +1,11 @@
+input {
+  tcp {
+    port => 5228
+    codec => json_lines
+  }
+}
+output {
+  stdout {
+    codec => json_lines
+  }
+}

data/samples/udp.conf

@@ -0,0 +1,11 @@
+input {
+  udp {
+    port => 5228
+    codec => json_lines
+  }
+}
+output {
+  stdout {
+    codec => json_lines
+  }
+}

data/samples/unix.conf

@@ -0,0 +1,11 @@
+input {
+  unix {
+    path => "/tmp/logstash"
+    codec => json_lines
+  }
+}
+output {
+  stdout {
+    codec => json_lines
+  }
+}

data/spec/configuration_spec.rb

@@ -0,0 +1,27 @@
+require 'logstash-logger'
+
+describe LogStashLogger do
+  describe "#configure" do
+    it 'auto initializes' do
+      config = LogStashLogger.configure
+      expect(config).to be_a LogStashLogger::Configuration
+      expect(LogStashLogger.configuration).to eq(config)
+    end
+
+    describe LogStashLogger::Configuration do
+      describe "#customize_event" do
+        it 'allows each LogStash::Event to be customized' do
+          config = LogStashLogger.configure do |config|
+            config.customize_event do |event|
+              event["test1"] = "response1"
+            end
+          end
+
+          event = LogStash::Event.new({})
+          config.customize_event_block.call(event)
+          expect(event["test1"]).to eq("response1")
+        end
+      end
+    end
+  end
+end

data/spec/constructor_spec.rb

@@ -0,0 +1,30 @@
+require 'logstash-logger'
+
+describe LogStashLogger do
+  describe '.new' do
+    it 'returns a Logger instance' do
+      expect(LogStashLogger.new(type: :stdout)).to be_a ::Logger
+    end
+
+    context 'type: :multi_logger' do
+      it "returns an instance of LogStashLogger::MultiLogger" do
+        expect(LogStashLogger.new(type: :multi_logger)).to be_a LogStashLogger::MultiLogger
+      end
+
+      it 'merges top level configuration into each logger' do
+        logger = LogStashLogger.new(type: :multi_logger, port: 1234, outputs: [ { type: :tcp  }, { type: :udp } ])
+        logger.loggers.each do |logger|
+          expect(logger.device.port).to eq(1234)
+        end
+      end
+    end
+
+    context 'logger_class: CustomLogger' do
+      class CustomLogger < Logger; end
+
+      it 'should create a logger of the specified class' do
+        expect(LogStashLogger.new(type: :stdout, :logger_class => CustomLogger)).to be_a CustomLogger
+      end
+    end
+  end
+end

data/spec/device/balancer_spec.rb

@@ -0,0 +1,31 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::Balancer do
+  include_context 'device'
+
+  # Create a Balancer writing to both STDOUT and a StringIO
+  subject { balancer_device }
+
+  describe '#write' do
+    before do
+      allow(subject.devices).to receive(:sample) { io }
+    end
+
+    it "writes to one device" do
+      expect(io).to receive(:write).once
+      expect($stdout).to_not receive(:write)
+      subject.write("log message")
+    end
+  end
+
+  describe '#flush, #close' do
+    [:flush, :close].each do |method_name|
+      it "call on all devices" do
+        subject.devices.each do |device|
+          expect(device).to receive(method_name).once
+        end
+        subject.send(method_name)
+      end
+    end
+  end
+end

data/spec/device/connectable_spec.rb

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

data/spec/device/file_spec.rb

@@ -0,0 +1,15 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::File do
+  include_context 'device'
+
+  it "writes to a file" do
+    expect(file_device.to_io).to be_a ::File
+  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/firehose_spec.rb

@@ -0,0 +1,41 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::Firehose do
+  include_context 'device'
+
+  let(:client) { double("Aws::Firehose::Client") }
+
+  before(:each) do
+    allow(Aws::Firehose::Client).to receive(:new) { client }
+  end
+
+  it "writes to a Firehose stream" do
+    response = ::Aws::Firehose::Types::PutRecordBatchOutput.new
+    response.failed_put_count = 0
+    response.request_responses = []
+    expect(client).to receive(:put_record_batch) { response }
+    firehose_device.write "foo"
+
+    expect(firehose_device).to be_connected
+    firehose_device.close!
+    expect(firehose_device).not_to be_connected
+  end
+
+  it "it puts records with recoverable errors back in the buffer" do
+    failed_record = ::Aws::Firehose::Types::PutRecordBatchResponseEntry.new
+    failed_record.error_code = "InternalFailure"
+    failed_record.error_message = "InternalFailure"
+    response = ::Aws::Firehose::Types::PutRecordBatchOutput.new
+    response.failed_put_count = 1
+    response.request_responses = [failed_record]
+
+    expect(client).to receive(:put_record_batch) { response }
+    expect(firehose_device).to receive(:write).with("foo")
+
+    firehose_device.write_one "foo"
+  end
+
+  it "defaults the Firehose stream to logstash" do
+    expect(firehose_device.stream).to eq('logstash')
+  end
+end

data/spec/device/io_spec.rb

@@ -0,0 +1,13 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::IO do
+  include_context 'device'
+
+  subject { io_device }
+
+  it "writes to the IO object" do
+    expect(subject.to_io).to eq(io)
+    expect(io).to receive(:write).once
+    subject.write("test")
+  end
+end

data/spec/device/kafka_spec.rb

@@ -0,0 +1,32 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::Kafka do
+  include_context 'device'
+
+  let(:producer) { double("Poseidon::Producer") }
+
+  before(:each) do
+    allow(Poseidon::Producer).to receive(:new) { producer }
+  end
+
+  it "writes to a Kafka topic" do
+    expect(producer).to receive(:send_messages)
+    kafka_device.write "foo"
+  end
+
+  it "defaults the Kafka hosts to ['localhost:9092']" do
+    expect(kafka_device.hosts).to eq(['localhost:9092'])
+  end
+
+  it "defaults the Kafka topic to 'logstash'" do
+    expect(kafka_device.topic).to eq('logstash')
+  end
+
+  it "defaults the Kafka producer to 'logstash-logger'" do
+    expect(kafka_device.producer).to eq('logstash-logger')
+  end
+
+  it "defaults the Kafka backoff to 1" do
+    expect(kafka_device.backoff).to eq(1)
+  end
+end

data/spec/device/kinesis_spec.rb

@@ -0,0 +1,41 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::Kinesis do
+  include_context 'device'
+
+  let(:client) { double("Aws::Kinesis::Client") }
+
+  before(:each) do
+    allow(Aws::Kinesis::Client).to receive(:new) { client }
+  end
+
+  it "writes to a Kinesis stream" do
+    response = ::Aws::Kinesis::Types::PutRecordsOutput.new
+    response.failed_record_count = 0
+    response.records = []
+    expect(client).to receive(:put_records) { response }
+    kinesis_device.write "foo"
+
+    expect(kinesis_device).to be_connected
+    kinesis_device.close!
+    expect(kinesis_device).not_to be_connected
+  end
+
+  it "it puts records with recoverable errors back in the buffer" do
+    failed_record = ::Aws::Kinesis::Types::PutRecordsResultEntry.new
+    failed_record.error_code = "ProvisionedThroughputExceededException"
+    failed_record.error_message = "ProvisionedThroughputExceededException"
+    response = ::Aws::Kinesis::Types::PutRecordsOutput.new
+    response.failed_record_count = 1
+    response.records = [failed_record]
+
+    expect(client).to receive(:put_records) { response }
+    expect(kinesis_device).to receive(:write).with("foo")
+
+    kinesis_device.write_one "foo"
+  end
+
+  it "defaults the kinesis stream to logstash" do
+    expect(kinesis_device.stream).to eq('logstash')
+  end
+end

data/spec/device/multi_delegator_spec.rb

@@ -0,0 +1,31 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::MultiDelegator do
+  include_context 'device'
+
+  # Create a MultiDelegator writing to both STDOUT and a StringIO
+  subject { multi_delegator_device }
+
+  it "writes to all outputs" do
+    expect($stdout).to receive(:write).once
+    expect(io).to receive(:write).once
+
+    subject.write("test")
+  end
+
+  describe ".new" do
+    it "merges top level configuration to each output" do
+      logger = described_class.new(
+        port: 1234,
+        outputs: [
+          { type: :udp },
+          { type: :tcp }
+        ]
+      )
+
+      logger.devices.each do |device|
+        expect(device.port).to eq(1234)
+      end
+    end
+  end
+end

data/spec/device/redis_spec.rb

@@ -0,0 +1,52 @@
+require 'logstash-logger'
+require 'redis'
+
+describe LogStashLogger::Device::Redis do
+  include_context 'device'
+
+  let(:redis) { double("Redis") }
+
+  before(:each) do
+    allow(Redis).to receive(:new) { redis }
+    allow(redis).to receive(:connect)
+  end
+
+  it "writes to a Redis list" do
+    expect(redis).to receive(:rpush)
+    redis_device.write "foo"
+  end
+
+  it "defaults the Redis list to 'logstash'" do
+    expect(redis_device.list).to eq('logstash')
+  end
+
+  describe "initializer" do
+    let(:redis_options) { { host: HOST, port: 6379 } }
+    subject { LogStashLogger::Device::Redis.new(redis_options).connect }
+
+    context "path is not blank" do
+      before do
+        redis_options[:path] = "/0"
+      end
+
+      it "sets the db" do
+        expect(Redis).to receive(:new).with(hash_including(db: 0))
+        subject
+      end
+
+    end
+
+    context "path is blank" do
+      before do
+        redis_options[:path] = ""
+      end
+
+      it "does not set the db" do
+        expect(Redis).to receive(:new).with(hash_excluding(:db))
+        subject
+      end
+    end
+
+  end
+
+end

data/spec/device/socket_spec.rb

@@ -0,0 +1,15 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::Socket do
+  include_context 'device'
+
+  it "defaults host to 0.0.0.0" do
+    expect(device_with_port.host).to eq("0.0.0.0")
+  end
+
+  context "when port is not specified" do
+    it "raises an exception" do
+      expect { described_class.new }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/device/stderr_spec.rb

@@ -0,0 +1,16 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::Stderr do
+  let(:stderr) { $stderr }
+
+  it 'writes to stderr' do
+    expect(subject.to_io).to eq stderr
+    expect(stderr).to receive(:write).once
+    subject.write("test")
+  end
+
+  it 'ignores #close' do
+    expect(stderr).not_to receive(:close)
+    subject.close
+  end
+end

data/spec/device/stdout_spec.rb

@@ -0,0 +1,31 @@
+require 'logstash-logger'
+
+describe LogStashLogger::Device::Stdout do
+  let(:stdout) { $stdout }
+
+  it "writes to $stdout" do
+    expect(subject.to_io).to eq(stdout)
+    expect(stdout).to receive(:write).once
+    subject.write("test")
+  end
+
+  it "ignores #close" do
+    expect(stdout).not_to receive(:close)
+    subject.close
+  end
+
+  context "when the default $stdout has been overridden" do
+    before { $stdout = StringIO.new }
+    after  { $stdout = STDOUT }
+
+    let(:injected_stdout) { STDOUT }
+
+    subject { described_class.new(io: injected_stdout) }
+
+    it "accepts an injectable reference to stdout" do
+      expect(subject.to_io).to eq(injected_stdout)
+      expect(injected_stdout).to receive(:write).once
+      subject.write("test")
+    end
+  end
+end