loga 1.0.0

data/spec/support/timecop_shared.rb

@@ -0,0 +1,7 @@
+require 'timecop'
+
+shared_context 'timecop', timecop: true do
+  # Allows fixed timestamps
+  before(:all) { Timecop.freeze(time_anchor) }
+  after(:all)  { Timecop.return }
+end

data/spec/unit/loga/configuration_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Loga::Configuration do
+  subject do
+    described_class.new.tap { |config| config.device = STDOUT }
+  end
+
+  describe 'initialize' do
+    subject { described_class.new }
+    context 'defaults' do
+      specify { expect(subject.host).to eq(hostname_anchor) }
+      specify { expect(subject.level).to eq(:info) }
+      specify { expect(subject.device).to eq(nil) }
+      specify { expect(subject.sync).to eq(true) }
+      specify { expect(subject.filter_parameters).to eq([]) }
+      specify { expect(subject.service_name).to eq(nil) }
+      specify { expect(subject.service_version).to eq(:git) }
+    end
+
+    context 'when hostname cannot be resolved' do
+      before do
+        allow(Socket).to receive(:gethostname).and_raise(Exception)
+      end
+
+      it 'uses a default hostname' do
+        expect(subject.host).to eq('unknown.host')
+      end
+    end
+  end
+
+  describe '#initialize!' do
+    before do
+      subject.tap do |config|
+        config.service_name    = ' hello_world_app '
+        config.service_version = " 1.0\n"
+      end
+    end
+
+    it 'initializes the formatter with stiped service name and version' do
+      expect(Loga::Formatter).to receive(:new)
+        .with(service_name: 'hello_world_app',
+              service_version: '1.0',
+              host: hostname_anchor)
+      subject.initialize!
+    end
+
+    context 'when service_version is :git' do
+      before { subject.service_version = :git }
+      it 'computes the service_version with git' do
+        subject.initialize!
+        expect(subject.service_version).to match(/\h+/)
+      end
+    end
+
+    describe 'logger' do
+      let(:logdev) { subject.logger.instance_variable_get(:@logdev) }
+
+      context 'when device is nil' do
+        before do
+          subject.device = nil
+          allow(STDERR).to receive(:write)
+        end
+        let(:error_message) { /Loga could not be initialized/ }
+        it 'uses STDERR' do
+          subject.initialize!
+          expect(logdev.dev).to eq(STDERR)
+        end
+        it 'logs an error to STDERR' do
+          expect(STDERR).to receive(:write).with(error_message)
+          subject.initialize!
+        end
+      end
+
+      {
+        debug:   0,
+        info:    1,
+        warn:    2,
+        error:   3,
+        fatal:   4,
+        unknown: 5,
+      }.each do |sym, level|
+        context "when log level is #{sym}" do
+          before { subject.level = sym }
+          it "uses log level #{sym}" do
+            subject.initialize!
+            expect(subject.logger.level).to eq(level)
+          end
+        end
+      end
+
+      context 'when sync is false' do
+        before { subject.sync = false }
+        it 'uses warn log level' do
+          subject.initialize!
+          expect(logdev.dev.sync).to eq(false)
+        end
+      end
+    end
+  end
+
+  describe '#logger' do
+    context 'when initialized' do
+      before { subject.initialize! }
+      it 'returns a logger' do
+        expect(subject.logger).to be_a(Logger)
+      end
+
+      it 'returns a tagged logger' do
+        expect(subject.logger).to respond_to(:tagged)
+      end
+    end
+
+    context 'when not initialized' do
+      specify { expect(subject.logger).to be_nil }
+    end
+  end
+
+  describe '#configure' do
+    it 'yields self' do
+      expect { |b| subject.configure(&b) }.to yield_with_args(subject)
+    end
+  end
+end

data/spec/unit/loga/event_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe Loga::Event do
+  describe 'initialize' do
+    context 'no message is passed' do
+      it 'sets message to an empty string' do
+        expect(subject.message).to eq ''
+      end
+    end
+
+    context 'message is passed' do
+      let(:message) { "stuff \xC2".force_encoding 'ASCII-8BIT' }
+      let(:subject) { described_class.new message: message }
+
+      it 'sanitizes the input to be UTF-8 convertable' do
+        expect(subject.message.to_json).to eq '"stuff ?"'
+      end
+    end
+  end
+end

data/spec/unit/loga/formatter_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe Loga::Formatter do
+  let(:service_name)    { 'loga' }
+  let(:service_version) { '725e032a' }
+  let(:host)            { 'www.example.com' }
+  let(:params) do
+    {
+      service_name:    service_name,
+      service_version: service_version,
+      host:            host,
+    }
+  end
+
+  subject { described_class.new(params) }
+
+  shared_examples 'valid GELF message' do
+    it 'includes the required fields' do
+      expect(json).to include('version'       => '1.1',
+                              'host'          => host,
+                              'short_message' => be_a(String),
+                              'timestamp'     => be_a(Float),
+                              'level'         => 6,
+                             )
+    end
+
+    it 'includes Loga additional fields' do
+      expect(json).to include('_service.name'    => service_name,
+                              '_service.version' => service_version,
+                              '_tags'            => [],
+                             )
+    end
+
+    it 'outputs the timestamp in seconds since UNIX epoch' do
+      expect(json).to include('timestamp' => time_anchor_unix)
+    end
+  end
+
+  describe '#call(severity, time, _progname, message)' do
+    subject { super().call(severity, time_anchor, nil, message) }
+
+    let(:severity) { 'INFO' }
+    let(:message)  { 'Tree house magic' }
+    let(:json)     { JSON.parse(subject) }
+
+    context 'when the message parameter is a String' do
+      it 'the short_message is that String' do
+        expect(json['short_message']).to eq(message)
+      end
+
+      include_examples 'valid GELF message'
+    end
+
+    context 'when the message parameter is a nil' do
+      let(:message) { nil }
+      it 'the short_message is empty' do
+        expect(json['short_message']).to eq('')
+      end
+
+      include_examples 'valid GELF message'
+    end
+
+    context 'when message parameter is a Hash' do
+      let(:message) { { message: 'Wooden house' } }
+
+      it 'the short_message is a String reprentation of that Hash' do
+        expect(json['short_message']).to eq('{:message=>"Wooden house"}')
+      end
+
+      include_examples 'valid GELF message'
+    end
+
+    context 'when message parameter is an Object' do
+      let(:message) { Object.new }
+
+      it 'the short_message is a String reprentation of that Object' do
+        expect(json['short_message']).to match(/#<Object:\dx\h+>/)
+      end
+
+      include_examples 'valid GELF message'
+    end
+
+    context 'when the message parameter is a Loga::Event' do
+      let(:options) { { message: 'Wooden house' } }
+      let(:message) { Loga::Event.new(options) }
+
+      include_examples 'valid GELF message'
+
+      it 'the short_message is the Event message' do
+        expect(json['short_message']).to eq(message.message)
+      end
+
+      context 'when the Event has a timestamp' do
+        let(:time)         { Time.new(2010, 12, 15, 9, 30, 5.323, '+02:00') }
+        let(:time_in_unix) { BigDecimal.new('1292398205.323') }
+        let(:options)      { { timestamp: time } }
+
+        it 'uses the Event timestamp' do
+          expect(json['timestamp']).to eq(time_in_unix)
+        end
+      end
+
+      context 'when the Event has a type' do
+        let(:options)    { { type: 'request' } }
+
+        specify { expect(json['_type']).to eq(message.type) }
+      end
+
+      context 'when the Event no type' do
+        specify { expect(json).to_not include('_type') }
+      end
+
+      context 'when the Event has an exception' do
+        let(:backtrace) { %w(a b) }
+        let(:exception) do
+          StandardError.new('Foo Error').tap { |e| e.set_backtrace backtrace }
+        end
+        let(:options)   { { exception: exception } }
+
+        specify { expect(json['_exception.klass']).to eq('StandardError') }
+        specify { expect(json['_exception.message']).to eq('Foo Error') }
+        specify { expect(json['_exception.backtrace']).to eq("a\nb") }
+
+        context 'when the backtrace is larger than 10 lines' do
+          let(:backtrace) { ('a'..'z').to_a }
+          it 'truncates the backtrace' do
+            expect(json['_exception.backtrace']).to eq("a\nb\nc\nd\ne\nf\ng\nh\ni\nj")
+          end
+        end
+      end
+
+      context 'when the Event has no exception' do
+        specify { expect(json).to_not include(/_exception.+/) }
+      end
+
+      context 'when the Event has data' do
+        let(:options) do
+          {
+            data: {
+              user_id: 1,
+              user: {
+                email: 'hello@world.com',
+                address: {
+                  postcode: 'ABCD',
+                },
+              },
+            },
+          }
+        end
+
+        specify { expect(json['_user_id']).to eq(1) }
+        specify { expect(json['_user.email']).to eq('hello@world.com') }
+        specify { expect(json['_user.address']).to eq('postcode' => 'ABCD') }
+      end
+
+      context 'when the Event data contains fiels identical to the formatter fields' do
+        let(:options) do
+          {
+            data: {
+              service: { name: 'Malicious Tags' },
+            },
+          }
+        end
+
+        include_examples 'valid GELF message'
+      end
+    end
+
+    {
+      'DEBUG'   => 7,
+      'INFO'    => 6,
+      'WARN'    => 4,
+      'ERROR'   => 3,
+      'FATAL'   => 2,
+      'UNKNOWN' => 1,
+    }.each do |ruby_severity, syslog_level|
+      context "with severity #{ruby_severity}" do
+        let(:severity) { ruby_severity }
+
+        it "maps to level #{syslog_level}" do
+          expect(json['level']).to eq(syslog_level)
+        end
+      end
+    end
+  end
+end

data/spec/unit/loga/parameter_filter_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+RSpec.describe Loga::ParameterFilter do
+  let(:filters) { [:password, /token/] }
+
+  shared_examples 'compiled filter' do
+    let(:compiled_filters) { described_class::CompiledFilter }
+
+    before do
+      allow(compiled_filters).to receive(:compile).and_call_original
+    end
+
+    it 'compiles filters only once' do
+      expect(compiled_filters).to receive(:compile).once
+      2.times { subject.filter(params) }
+    end
+  end
+
+  describe '#filter(params)' do
+    subject { described_class.new(filters) }
+
+    let(:params) do
+      {
+        password: 'password123',
+        email: 'hello@world.com',
+        token: 'ABC',
+      }
+    end
+
+    let(:result) do
+      {
+        password: '[FILTERED]',
+        email: 'hello@world.com',
+        token: '[FILTERED]',
+      }
+    end
+
+    context 'when no filters are applied' do
+      let(:filters) { [] }
+
+      it 'returns params' do
+        expect(subject.filter(params)).to match(params)
+      end
+
+      include_examples 'compiled filter'
+    end
+
+    context 'when params is shallow' do
+      it 'returns filtered params' do
+        expect(subject.filter(params)).to match(result)
+      end
+
+      include_examples 'compiled filter'
+    end
+
+    context 'when params has a nested Hash' do
+      let(:params) { { user: super() } }
+
+      it 'returns filtered params' do
+        expect(subject.filter(params)).to match(user: result)
+      end
+
+      include_examples 'compiled filter'
+    end
+
+    context 'when params has a nested Array' do
+      let(:params) { { users: [super(), super()] } }
+
+      it 'returns filtered params' do
+        expect(subject.filter(params)).to match(users: [result, result])
+      end
+
+      include_examples 'compiled filter'
+    end
+  end
+end

data/spec/unit/loga/rack/logger_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'rack/test'
+
+describe Loga::Rack::Logger do
+  let(:env)     { Rack::MockRequest.env_for('/about_us?limit=1', options) }
+  let(:options) { {} }
+  let(:app)     {  ->(_env) { [response_status, {}, ''] } }
+  let(:logger)  { double(:logger) }
+
+  subject { described_class.new(app, logger) }
+
+  before do
+    allow(logger).to receive(:info)
+    allow(logger).to receive(:error)
+  end
+
+  shared_examples 'logs the event' do |details|
+    let(:level) { details[:level] }
+
+    before do
+      allow(subject).to receive(:started_at).and_return(:timestamp)
+      allow(subject).to receive(:duration_in_ms).with(any_args).and_return(5)
+    end
+
+    it 'instantiates a Loga::Event' do
+      expect(Loga::Event).to receive(:new).with(
+        data:      {
+          request: {
+            'status'     => response_status,
+            'method'     => 'GET',
+            'path'       => '/about_us',
+            'params'     => { 'limit' => '1' },
+            'request_id' => nil,
+            'request_ip' => nil,
+            'user_agent' => nil,
+            'duration'   => 5,
+          },
+        },
+        exception: logged_exception,
+        message:   %r{^GET \/about_us\?limit=1 #{response_status} in \d+ms$},
+        timestamp: :timestamp,
+        type:      'request',
+      )
+
+      subject.call(env)
+    end
+
+    it "logs the Loga::Event with severity #{details[:level]}" do
+      expect(logger).to receive(level).with(an_instance_of(Loga::Event))
+      subject.call(env)
+    end
+  end
+
+  describe '#call(env)' do
+    let(:exception)        { StandardError.new }
+    let(:logged_exception) { nil }
+    let(:response_status)  { 200 }
+
+    context 'when an exception is raised' do
+      let(:app) {  ->(_env) { fail exception } }
+
+      it 'does not rescue the exception' do
+        expect { subject.call(env) }.to raise_error(StandardError)
+      end
+    end
+
+    context 'when an exception wrapped by ActionDispatch' do
+      let(:response_status)  { 500 }
+      let(:logged_exception) { exception }
+      let(:options)          { { 'action_dispatch.exception' => exception } }
+
+      include_examples 'logs the event', level: :error
+    end
+
+    context 'when an exception wrapped by Sinatra' do
+      let(:response_status)  { 500 }
+      let(:logged_exception) { exception }
+      let(:options)          { { 'sinatra.error' => exception } }
+
+      include_examples 'logs the event', level: :error
+    end
+
+    context 'when the exception is ActionController::RoutingError' do
+      let(:response_status) { 404 }
+      let(:exception)       { double(class: 'ActionController::RoutingError') }
+      let(:options)         { { 'action_dispatch.exception' => exception } }
+
+      include_examples 'logs the event', level: :info
+    end
+
+    context 'when no exception is raised' do
+      include_examples 'logs the event', level: :info
+    end
+
+    context 'when the logger is tagged' do
+      let(:logger) { double(:logger, tagged: true) }
+
+      before do
+        allow(subject).to receive(:call_app).with(any_args).and_return(:response)
+        allow(subject).to receive(:compute_tags).with(any_args).and_return(:tag)
+        allow(logger).to receive(:tagged).with('hello') do |&block|
+          block.call
+        end
+      end
+
+      it 'yields the app with tags' do
+        expect(logger).to receive(:tagged).with(:tag) do |&block|
+          expect(block.call).to eq(:response)
+        end
+        subject.call(env)
+      end
+    end
+  end
+end