logstash-logger-yajl 0.27.0

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

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