loga 1.4.0 → 2.0.0

data/spec/unit/loga/configuration_spec.rb

@@ -1,68 +1,183 @@
 require 'spec_helper'
 
 describe Loga::Configuration do
-  subject do
-    described_class.new.tap { |config| config.device = STDOUT }
+  let(:options) do
+    { service_name: 'hello_world_app' }
   end
 
+  subject { described_class.new(options) }
+
   describe 'initialize' do
-    subject { described_class.new }
+    let(:framework_exceptions) do
+      %w(
+        ActionController::RoutingError
+        ActiveRecord::RecordNotFound
+        Sinatra::NotFound
+      )
+    end
+
+    before do
+      allow(Loga::ServiceVersionStrategies).to receive(:call).and_return('unknown.sha')
+    end
+
     context 'defaults' do
+      specify { expect(subject.device).to eq(STDOUT) }
+      specify { expect(subject.filter_exceptions).to eq(framework_exceptions) }
+      specify { expect(subject.filter_parameters).to eq([]) }
+      specify { expect(subject.format).to eq(:simple) }
       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.service_name).to eq('hello_world_app') }
+      specify { expect(subject.service_version).to eq('unknown.sha') }
       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) }
+      specify { expect(subject.tags).to eq([]) }
     end
 
-    context 'when hostname cannot be resolved' do
-      before do
-        allow(Socket).to receive(:gethostname).and_raise(Exception)
+    describe 'device' do
+      context 'when initialized with nil' do
+        let(:options) { super().merge(device: nil) }
+
+        it 'raises an error' do
+          expect { described_class.new(options) }
+            .to raise_error(Loga::ConfigurationError, 'Device cannot be blank')
+        end
       end
+    end
 
-      it 'uses a default hostname' do
-        expect(subject.host).to eq('unknown.host')
+    describe 'hostname' do
+      context 'when hostname cannot be resolved' do
+        before do
+          allow(Socket).to receive(:gethostname).and_raise(SystemCallError, 'Something')
+        end
+
+        it 'uses a default hostname' do
+          expect(subject.host).to eq('unknown.host')
+        end
       end
     end
-  end
 
-  describe '#initialize!' do
-    before do
-      subject.tap do |config|
-        config.service_name    = ' hello_world_app '
-        config.service_version = " 1.0\n"
+    describe 'service_name' do
+      context 'when service name is missing' do
+        let(:options) do
+          { service_: 'hello_world_app' }
+        end
+
+        it 'raises an error' do
+          expect { subject }.to raise_error(Loga::ConfigurationError,
+                                            'Service name cannot be blank')
+        end
       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!
+    describe 'service_version' do
+      context 'when service version is missing' do
+        it 'uses a service version strategy' do
+          expect(subject.service_version).to eq('unknown.sha')
+        end
+      end
+      context 'when initialized via user options' do
+        let(:options) { super().merge(service_version: 'v3.0.1') }
+
+        it 'sets the service version' do
+          expect(subject.service_version).to eq('v3.0.1')
+        end
+      end
     end
 
-    describe 'logger' do
-      let(:logdev) { subject.logger.instance_variable_get(:@logdev) }
+    describe 'format' do
+      context 'when initialized via user options' do
+        let(:options) { super().merge(format: :gelf) }
 
-      context 'when device is nil' do
+        it 'sets the format' do
+          expect(subject.format).to eq(:gelf)
+        end
+      end
+
+      context 'when initialized via ENV' do
         before do
-          subject.device = nil
-          allow(STDERR).to receive(:write)
+          allow(ENV).to receive(:[]).with('LOGA_FORMAT').and_return('gelf')
         end
-        let(:error_message) { /Loga could not be initialized/ }
-        it 'uses STDERR' do
-          subject.initialize!
-          expect(logdev.dev).to eq(STDERR)
+
+        it 'sets the format' do
+          expect(subject.format).to eq(:gelf)
         end
-        it 'logs an error to STDERR' do
-          expect(STDERR).to receive(:write).with(error_message)
-          subject.initialize!
+      end
+
+      context 'when initialized via framework options' do
+        subject { described_class.new(options, framework_options) }
+        let(:framework_options) { { format: :gelf } }
+
+        it 'sets the format' do
+          expect(subject.format).to eq(:gelf)
         end
       end
 
+      context 'when initialized with user options and ENV' do
+        let(:options) { super().merge(format: :gelf) }
+
+        before do
+          allow(ENV).to receive(:[]).with('LOGA_FORMAT').and_return('simple')
+        end
+
+        it 'prefers user option' do
+          expect(subject.format).to eq(:gelf)
+        end
+      end
+
+      context 'when initialized with ENV and framework options' do
+        subject { described_class.new(options, framework_options) }
+        let(:framework_options) { { format: :gelf } }
+
+        before do
+          allow(ENV).to receive(:[]).with('LOGA_FORMAT').and_return('simple')
+        end
+
+        it 'prefers env' do
+          expect(subject.format).to eq(:simple)
+        end
+      end
+    end
+
+    describe 'formatter' do
+      context 'when format is :gelf' do
+        let(:options) do
+          super().merge(
+            format: :gelf,
+            service_name: ' hello_world_app ',
+            service_version_strategies: ['1.0'],
+          )
+        end
+        let(:formatter) { subject.logger.formatter }
+
+        it 'uses the GELF formatter' do
+          expect(subject.logger.formatter).to be_a(Loga::Formatter)
+        end
+
+        it 'strips the service name' do
+          expect(formatter.instance_variable_get(:@service_name)).to eq('hello_world_app')
+        end
+      end
+
+      context 'when format is :simple' do
+        let(:options) { super().merge(format: :simple) }
+
+        it 'uses the SimpleFormatter' do
+          expect(subject.logger.formatter).to be_a(ActiveSupport::Logger::SimpleFormatter)
+        end
+      end
+
+      context 'when the ActiveSupport::VERSION is unsupported' do
+        it 'raises an error' do
+          stub_const('ActiveSupport::VERSION::MAJOR', 1)
+          expect { described_class.new(options) }
+            .to raise_error(Loga::ConfigurationError, 'ActiveSupport 1 is unsupported')
+        end
+      end
+    end
+
+    describe 'logger' do
+      let(:logdev) { subject.logger.instance_variable_get(:@logdev) }
+
       {
         debug:   0,
         info:    1,
@@ -72,44 +187,35 @@ describe Loga::Configuration do
         unknown: 5,
       }.each do |sym, level|
         context "when log level is #{sym}" do
-          before { subject.level = sym }
+          let(:options) { super().merge(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 }
+        let(:options) { super().merge(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
+    describe '#structured?' do
+      context 'when format is :simple' do
+        let(:options) { super().merge(format: :simple) }
 
-      it 'returns a tagged logger' do
-        expect(subject.logger).to respond_to(:tagged)
+        specify { expect(subject.structured?).to eql(false) }
       end
-    end
 
-    context 'when not initialized' do
-      specify { expect(subject.logger).to be_nil }
-    end
-  end
+      context 'when format is :gelf' do
+        let(:options) { super().merge(format: :gelf) }
 
-  describe '#configure' do
-    it 'yields self' do
-      expect { |b| subject.configure(&b) }.to yield_with_args(subject)
+        specify { expect(subject.structured?).to eql(true) }
+      end
     end
   end
 end

data/spec/unit/loga/event_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe Loga::Event do
+RSpec.describe Loga::Event, timecop: true do
   describe 'initialize' do
     context 'no message is passed' do
       it 'sets message to an empty string' do
@@ -17,4 +17,34 @@ RSpec.describe Loga::Event do
       end
     end
   end
+
+  describe '#to_s' do
+    let(:opts) { { message: 'Hello World', timestamp: Time.now } }
+    subject { described_class.new(opts) }
+
+    context 'when exception' do
+      let(:exception) do
+        instance_double(StandardError, to_s: 'Some Message', backtrace: ['file'])
+      end
+      let(:opts) { super().merge(exception: exception) }
+      it 'outputs the message with exception' do
+        expect(subject.to_s)
+          .to eql("#{time_anchor.iso8601(3)} Hello World\nSome Message\nfile")
+      end
+    end
+
+    context 'when no exception' do
+      it 'outputs the message' do
+        expect(subject.to_s).to eql("#{time_anchor.iso8601(3)} Hello World")
+      end
+    end
+  end
+
+  describe '#inspect' do
+    subject { described_class.new message: 'Hey Siri', timestamp: Time.now }
+
+    it 'aliases to to_s' do
+      expect(subject.to_s).to eql(subject.inspect)
+    end
+  end
 end

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

@@ -5,14 +5,22 @@ 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) }
+  let(:logger)  { instance_double(Logger, info: nil, error: nil) }
+  let(:tags)    { [] }
+
+  let(:configuration) do
+    instance_double(
+      Loga::Configuration,
+      filter_exceptions: %w(ActionController::RoutingError),
+      filter_parameters: [],
+      logger: logger,
+      tags: tags,
+    )
+  end
 
-  subject { described_class.new(app, logger) }
+  subject { described_class.new(app) }
 
-  before do
-    allow(logger).to receive(:info)
-    allow(logger).to receive(:error)
-  end
+  before { Loga.instance_variable_set(:@configuration, configuration) }
 
   shared_examples 'logs the event' do |details|
     let(:level) { details[:level] }
@@ -103,11 +111,15 @@ describe Loga::Rack::Logger do
         end
       end
 
-      it 'yields the app with tags' do
-        expect(logger).to receive(:tagged).with(:tag) do |&block|
-          expect(block.call).to eq(:response)
+      context 'when tags are present' do
+        let(:tags) { [:foo] }
+
+        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
-        subject.call(env)
       end
     end
   end

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

@@ -6,13 +6,23 @@ describe Loga::Rack::Request do
   let(:env)       { Rack::MockRequest.env_for(full_path, options) }
 
   let(:action_controller_class) do
-    ApplicationController = Class.new do
+    Class.new do
+      def self.name
+        'ApplicationController'
+      end
+
       def action_name
         'index'
       end
     end
   end
 
+  let(:config) { instance_double Loga::Configuration, filter_parameters: [:password] }
+
+  before do
+    allow(Loga).to receive(:configuration).and_return(config)
+  end
+
   subject { described_class.new(env) }
 
   describe '#uuid' do
@@ -34,35 +44,24 @@ describe Loga::Rack::Request do
     end
   end
 
-  describe '#action_controller_instance' do
-    let(:action_controller_instance) { action_controller_class.new }
-
-    context 'when ACTION_CONTROLLER_INSTANCE is present' do
+  describe '#controller_action_name' do
+    context 'when available' do
       let(:options) do
-        { 'action_controller.instance' => action_controller_instance }
+        { 'action_controller.instance' => action_controller_class.new }
       end
-      it 'returns the instance' do
-        expect(subject.action_controller_instance).to eq(action_controller_instance)
+
+      it 'returns the namespaced controller name with the action_name' do
+        expect(subject.controller_action_name).to eq('ApplicationController#index')
       end
     end
 
-    context 'when ACTION_DISPATCH_REQUEST_ID blank' do
+    context 'when missing' do
       it 'returns nil' do
-        expect(subject.action_controller_instance).to be_nil
+        expect(subject.controller_action_name).to be_nil
       end
     end
   end
 
-  describe '#action_controller' do
-    let(:options) do
-      { 'action_controller.instance' => action_controller_class.new }
-    end
-
-    it 'returns the controller with the action_name' do
-      expect(subject.action_controller).to eq('ApplicationController#index')
-    end
-  end
-
   describe '#request_id' do
     let(:action_dispatch_request_id) { 'ABCD' }
     let(:options) do
@@ -84,8 +83,6 @@ describe Loga::Rack::Request do
   end
 
   describe '#filtered_full_path' do
-    let(:config) { double :config, filter_parameters: [:password] }
-
     let(:path)         { '/hello' }
     let(:query)        { { 'password' => 123, 'color' => 'red' }  }
     let(:query_string) { Rack::Utils.build_query(query) }
@@ -93,10 +90,6 @@ describe Loga::Rack::Request do
 
     let(:options) { { 'loga.request.original_path' => path } }
 
-    before do
-      allow(Loga).to receive(:configuration).and_return(config)
-    end
-
     context 'request with sensitive parameters' do
       it 'returns the path with sensitive parameters filtered' do
         expect(subject.filtered_full_path).to eq('/hello?password=[FILTERED]&color=red')