alephant-logger-json 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 312008a258504317188c1b14bd2671bbe8c1cb57
-  data.tar.gz: 28bc444b2bb9b8001a56416c0c80860ceec0525c
+  metadata.gz: 6716c8a5d3446d582752238b022fe71cb1af5574
+  data.tar.gz: eddc2df5fa9deb630a92fecc546d575bbf62ea64
 SHA512:
-  metadata.gz: 224caa6384c612f490e1a64a4c697224ae65f8b3faf8309c976172d22873d25be6f76c3362d19cb637cbb0817e5549c09fe8d232513f9e6631ab7366dbcf98b9
-  data.tar.gz: 7fc9d04d683e3e6dde99604e1b25eb559240b36503f59f3220323fc6940bfaf38edcbe28c23a14298f426cdc31e8c5309510d2733efed50f38509be9f5a17393
+  metadata.gz: 36f9a992d64486a1152cc6ef974e4e634d78dee69e5918b7eee6382fcd052280ec86e2db677926bb2851369f2a950a0895c8847c530d16fe685030321eed9bf9
+  data.tar.gz: 573d6232f79aa04207fb8eb7c1525cc5004ec7728a9c8aa2638798addc1596b6af58c5a703e430571ddc5459c0fd803c7956f7a2a033853b07cc65a4f2cdcbca

data/README.md

@@ -51,7 +51,7 @@ There are two methods available to help you:
 
 When using tracing, you'll need to provide a binding context as the first argument to your log level method calls.
 
-This is to resolve issues with lambda's scope availability. See `Kernal#binding` for more details. 
+This is to resolve issues with lambda's scope availability. See `Kernal#binding` for more details.
 
 Example usage:
 
@@ -63,6 +63,37 @@ If no `binding` is provided then tracing is ignored and the logger falls back to
 
 > Note: you can hide the binding necessity behind an abstraction layer if you prefer
 
+### Logging Levels
+
+The logger includes an option to define a desired logging level. Only log levels that are equal to or higher than the desired level will be logged.
+The logger defaults to the _lowest_ level `0` i.e. `:debug` when a desired level is undefined.
+
+Example
+
+```ruby
+# Hierarchical Log levels
+# 0 => debug
+# 1 => info
+# 2 => warn
+# 3 => error
+
+# When Default level :debug
+json_logger = Alephant::Logger::JSON.new("path/to/logfile.log")
+
+# Log all levels >= 0
+json_logger.info "This will log"
+
+# When log level is defined
+json_logger = Alephant::Logger::JSON.new("path/to/logfile.log", level: :info)
+
+# log all levels >= 1
+
+json_logger.debug "This will NOT log"
+json_logger.info "This will log"
+```
+
+> Note: The logger expects the desired level to be defined as a Symbol, String or Integer type.
+
 ## Contributing
 
 1. Fork it ( https://github.com/BBC-News/alephant-logger-json/fork )

data/lib/alephant/logger/json/version.rb

@@ -1,7 +1,7 @@
 module Alephant
   module Logger
     class JSON
-      VERSION = '0.4.0'.freeze
+      VERSION = '0.5.0'.freeze
     end
   end
 end

data/lib/alephant/logger/json.rb

@@ -1,5 +1,6 @@
-require_relative './dynamic_binding.rb'
 require 'json'
+require_relative 'dynamic_binding'
+require_relative 'levels_controller'
 
 module Alephant
   module Logger
@@ -8,10 +9,11 @@ module Alephant
         @log_file          = File.open(log_path, 'a+')
         @log_file.sync     = true
         @nesting           = options.fetch(:nesting, false)
+        @write_level       = options.fetch(:level, :debug)
         self.class.session = -> { 'n/a' } unless self.class.session?
       end
 
-      [:debug, :info, :warn, :error].each do |level|
+      LevelsController::LEVELS.each do |level|
         define_method(level) do |b = nil, hash|
           return if hash.is_a? String
 
@@ -23,7 +25,7 @@ module Alephant
 
           hash = flatten_values_to_s(h) unless @nesting
 
-          write(hash)
+          write(hash) if writeable?(level)
         end
       end
 
@@ -41,6 +43,13 @@ module Alephant
         @log_file.write(::JSON.generate(hash) + "\n")
       end
 
+      def writeable?(message_level)
+        LevelsController.should_log?(
+          message_level: message_level,
+          desired_level: @write_level
+        )
+      end
+
       def flatten_values_to_s(hash)
         Hash[hash.map { |k, v| [k, v.to_s] }]
       end

data/lib/alephant/logger/json_to_io.rb

@@ -9,6 +9,7 @@ module Alephant
       def initialize(output, options = {})
         @output            = output
         @nesting           = options.fetch(:nesting, false)
+        @write_level       = options.fetch(:level, :debug)
         self.class.session = -> { 'n/a' } unless self.class.session?
       end
 

data/lib/alephant/logger/levels_controller.rb

@@ -0,0 +1,41 @@
+module Alephant
+  module Logger
+    class LevelsController
+      LEVELS = %i(debug info warn error).freeze
+
+      class << self
+        def should_log?(message_level:, desired_level:)
+          message_level_index = level_index(message_level)
+
+          return false unless message_level_index
+
+          message_level_index >= desired_level_index(desired_level)
+        end
+
+        private
+
+        def desired_level_index(desired_level)
+          case desired_level
+          when Symbol then level_index_with_default(desired_level)
+          when String then level_index_with_default(desired_level.to_sym)
+          when Integer then desired_level
+          else
+            raise(
+              ArgumentError,
+              'wrong type of argument: expected Integer, Symbol or String. '\
+              "got #{desired_level.class}"
+            )
+          end
+        end
+
+        def level_index_with_default(desired_level)
+          level_index(desired_level) || 0
+        end
+
+        def level_index(level)
+          LEVELS.index(level)
+        end
+      end
+    end
+  end
+end

data/spec/alephant/logger/json_spec.rb

@@ -1,137 +1,123 @@
 require 'date'
 require 'spec_helper'
 require 'alephant/logger/json'
+require 'alephant/logger/levels_controller'
+require_relative 'support/json_shared_examples'
 
 describe Alephant::Logger::JSON do
-  subject { described_class.new(log_path) }
-
   let(:fn)       { -> { 'foo' } }
   let(:log_path) { '/log/path.log' }
-  let(:log_file) { instance_double File }
+  let(:log_output_obj) { instance_double(File) }
+  let(:msg) { :write }
 
   before do
-    allow(File).to receive(:open) { log_file }
-    allow(log_file).to receive :sync=
+    allow(File).to receive(:open) { log_output_obj }
+    allow(log_output_obj).to receive :sync=
   end
 
-  shared_examples 'JSON logging' do
-    let(:log_hash) do
-      { 'foo' => 'bar', 'baz' => 'quux' }
-    end
+  logging_levels = Alephant::Logger::LevelsController::LEVELS
 
-    it 'writes JSON dump of hash to log with corresponding level key' do
-      allow(Time).to receive(:now).and_return('foobar')
+  logging_levels.each_with_index do |level, i|
+    describe "##{level}" do
+      let(:level) { level }
+      let(:log_hash) { { 'foo' => 'bar', 'baz' => 'quux' } }
 
-      expect(log_file).to receive(:write) do |json_dump|
-        h = { 'timestamp' => 'foobar', 'uuid' => 'n/a', 'level' => level }
-        expect(JSON.parse(json_dump)).to eq h.merge log_hash
-      end
+      context 'when write level is specified' do
+        subject(:logger) do
+          described_class.new(log_path, level: write_level)
+        end
 
-      subject.send(level, log_hash)
-    end
+        context 'when message level is same as write level' do
+          context 'Symbol' do
+            let(:write_level) { level }
 
-    it 'automatically includes a timestamp' do
-      expect(log_file).to receive(:write) do |json_dump|
-        t = JSON.parse(json_dump)['timestamp']
-        expect { DateTime.parse(t) }.to_not raise_error
-      end
+            it_behaves_like 'a JSON log writer'
 
-      subject.send(level, log_hash)
-    end
+            it_behaves_like 'nested JSON message flattened to strings'
 
-    it 'outputs the timestamp first' do
-      expect(log_file).to receive(:write) do |json_dump|
-        h = JSON.parse(json_dump)
-        expect(h.first[0].to_sym).to be :timestamp
-      end
+            it_behaves_like 'gracefully fails with string message'
+          end
 
-      subject.send(level, log_hash)
-    end
+          context 'String' do
+            let(:write_level) { level.to_s }
 
-    it 'displays a default session value if a custom function is not provided' do
-      expect(log_file).to receive(:write) do |json_dump|
-        h = JSON.parse(json_dump)
-        expect(h['uuid']).to eq 'n/a'
-      end
+            it_behaves_like 'a JSON log writer'
 
-      subject.send(level, log_hash)
-    end
+            it_behaves_like 'nested JSON message flattened to strings'
 
-    it 'displays a custom session value when provided a user defined function' do
-      expect(log_file).to receive(:write) do |json_dump|
-        h = JSON.parse(json_dump)
-        expect(h['uuid']).to eq 'foo'
-      end
+            it_behaves_like 'gracefully fails with string message'
+          end
 
-      described_class.session = fn
-      subject.send(level, binding, log_hash)
-      described_class.session = -> { 'n/a' }
-    end
+          context 'Integer' do
+            let(:write_level) { logging_levels.index(level) }
 
-    it 'provides a static method for checking if a session has been set' do
-      described_class.session = fn
-      expect(described_class.session?).to eq 'instance-variable'
+            it_behaves_like 'a JSON log writer'
 
-      described_class.send(:remove_instance_variable, :@session)
-      expect(described_class.session?).to eq nil
-    end
-  end
+            it_behaves_like 'nested JSON message flattened to strings'
 
-  shared_context 'nested log hash' do
-    let(:log_hash) do
-      { 'nest' => nest }
-    end
+            it_behaves_like 'gracefully fails with string message'
+          end
+        end
 
-    let(:nest) { { 'bird' => 'eggs' } }
-  end
+        context 'when message level is lower than write level' do
+          context 'Integer' do
+            let(:write_level) { logging_levels.index(level) + 1 }
 
-  shared_examples 'nests flattened to strings' do
-    include_context 'nested log hash'
+            it_behaves_like 'a JSON log non writer'
 
-    specify do
-      expect(log_file).to receive(:write) do |json_dump|
-        expect(JSON.parse(json_dump)['nest']).to eq nest.to_s
-      end
+            it_behaves_like 'gracefully fails with string message'
+          end
+        end
 
-      subject.send(level, log_hash)
-    end
-  end
+        context 'when message level is higher than write level' do
+          let(:write_level_index) do
+            i > 0 ? logging_levels.index(level) - 1 : 0
+          end
 
-  shared_examples 'nesting allowed' do
-    include_context 'nested log hash'
+          context 'Symbol' do
+            let(:write_level) { logging_levels[write_level_index] }
 
-    specify do
-      expect(log_file).to receive(:write) do |json_dump|
-        expect(JSON.parse(json_dump)).to eq log_hash
-      end
+            it_behaves_like 'a JSON log writer'
 
-      subject.send(level, log_hash)
-    end
-  end
+            it_behaves_like 'nested JSON message flattened to strings'
 
-  shared_examples 'gracefully fail with string arg' do
-    let(:log_message) { 'Unable to connect to server' }
+            it_behaves_like 'gracefully fails with string message'
+          end
 
-    specify { expect(log_file).not_to receive(:write) }
-    specify do
-      expect { subject.debug log_message }.not_to raise_error
-    end
-  end
+          context 'String' do
+            let(:write_level) { logging_levels[write_level_index].to_s }
 
-  %w(debug info warn error).each do |level|
-    describe "##{level}" do
-      let(:level) { level }
+            it_behaves_like 'a JSON log writer'
 
-      it_behaves_like 'JSON logging'
+            it_behaves_like 'nested JSON message flattened to strings'
 
-      it_behaves_like 'nests flattened to strings'
+            it_behaves_like 'gracefully fails with string message'
+          end
 
-      it_behaves_like 'gracefully fail with string arg'
+          context 'Integer' do
+            let(:write_level) { write_level_index }
 
-      context 'with nesting allowed' do
-        subject do
-          described_class.new(log_path, nesting: true)
+            it_behaves_like 'a JSON log writer'
+
+            it_behaves_like 'nested JSON message flattened to strings'
+
+            it_behaves_like 'gracefully fails with string message'
+          end
         end
+      end
+
+      context 'when write level is not specified' do
+        subject(:logger) { described_class.new(log_path) }
+
+        it_behaves_like 'a JSON log writer'
+
+        it_behaves_like 'nested JSON message flattened to strings'
+
+        it_behaves_like 'gracefully fails with string message'
+      end
+
+      context 'with nesting allowed' do
+        subject(:logger) { described_class.new(log_path, nesting: true) }
 
         it_behaves_like 'nesting allowed'
       end

data/spec/alephant/logger/json_to_io_spec.rb

@@ -1,129 +1,116 @@
 require 'date'
 require 'spec_helper'
 require 'alephant/logger/json_to_io'
+require_relative 'support/json_shared_examples'
 
 describe Alephant::Logger::JSONtoIO do
-  subject { described_class.new(logger_io) }
+  let(:fn) { -> { 'foo' } }
+  let(:log_output_obj) { spy }
+  let(:msg) { :puts }
 
-  let(:fn)        { -> { 'foo' } }
-  let(:logger_io) { spy }
+  logging_levels = Alephant::Logger::LevelsController::LEVELS
 
-  shared_examples 'JSON logging' do
-    let(:log_hash) do
-      { 'foo' => 'bar', 'baz' => 'quux' }
-    end
+  logging_levels.each_with_index do |level, i|
+    describe "##{level}" do
+      let(:level) { level }
+      let(:log_hash) { { 'foo' => 'bar', 'baz' => 'quux' } }
 
-    it 'writes JSON dump of hash to log with corresponding level key' do
-      allow(Time).to receive(:now).and_return('foobar')
+      context 'when write level is specified' do
+        subject(:logger) do
+          described_class.new(log_output_obj, level: write_level)
+        end
 
-      expect(logger_io).to receive(:puts) do |json_dump|
-        h = { 'timestamp' => 'foobar', 'uuid' => 'n/a', 'level' => level }
-        expect(JSON.parse(json_dump)).to eq h.merge log_hash
-      end
+        context 'when message level is same as write level' do
+          context 'Symbol' do
+            let(:write_level) { level }
 
-      subject.public_send(level, log_hash)
-    end
+            it_behaves_like 'a JSON log writer'
 
-    it 'automatically includes a timestamp' do
-      expect(logger_io).to receive(:puts) do |json_dump|
-        t = JSON.parse(json_dump)['timestamp']
-        expect { DateTime.parse(t) }.to_not raise_error
-      end
+            it_behaves_like 'nested JSON message flattened to strings'
 
-      subject.public_send(level, log_hash)
-    end
+            it_behaves_like 'gracefully fails with string message'
+          end
 
-    it 'outputs the timestamp first' do
-      expect(logger_io).to receive(:puts) do |json_dump|
-        h = JSON.parse(json_dump)
-        expect(h.first[0].to_sym).to be :timestamp
-      end
+          context 'String' do
+            let(:write_level) { level.to_s }
 
-      subject.public_send(level, log_hash)
-    end
+            it_behaves_like 'a JSON log writer'
 
-    it 'displays a default session value if a custom function is not provided' do
-      expect(logger_io).to receive(:puts) do |json_dump|
-        h = JSON.parse(json_dump)
-        expect(h['uuid']).to eq 'n/a'
-      end
+            it_behaves_like 'nested JSON message flattened to strings'
 
-      subject.public_send(level, log_hash)
-    end
+            it_behaves_like 'gracefully fails with string message'
+          end
 
-    it 'displays a custom session value when provided a user defined function' do
-      expect(logger_io).to receive(:puts) do |json_dump|
-        h = JSON.parse(json_dump)
-        expect(h['uuid']).to eq 'foo'
-      end
+          context 'Integer' do
+            let(:write_level) { logging_levels.index(level) }
 
-      described_class.session = fn
-      subject.send(level, binding, log_hash)
-      described_class.session = -> { 'n/a' }
-    end
+            it_behaves_like 'a JSON log writer'
 
-    it 'provides a static method for checking if a session has been set' do
-      described_class.session = fn
-      expect(described_class.session?).to eq 'instance-variable'
+            it_behaves_like 'nested JSON message flattened to strings'
 
-      described_class.send(:remove_instance_variable, :@session)
-      expect(described_class.session?).to eq nil
-    end
-  end
+            it_behaves_like 'gracefully fails with string message'
+          end
+        end
 
-  shared_context 'nested log hash' do
-    let(:log_hash) do
-      { 'nest' => nest }
-    end
+        context 'when message level is lower than write level' do
+          context 'Integer' do
+            let(:write_level) { logging_levels.index(level) + 1 }
 
-    let(:nest) { { 'bird' => 'eggs' } }
-  end
+            it_behaves_like 'a JSON log non writer'
 
-  shared_examples 'nests flattened to strings' do
-    include_context 'nested log hash'
+            it_behaves_like 'gracefully fails with string message'
+          end
+        end
 
-    specify do
-      expect(logger_io).to receive(:puts) do |json_dump|
-        expect(JSON.parse(json_dump)['nest']).to eq nest.to_s
-      end
+        context 'when message level is higher than write level' do
+          let(:write_level_index) do
+            i > 0 ? logging_levels.index(level) - 1 : 0
+          end
 
-      subject.public_send(level, log_hash)
-    end
-  end
+          context 'Symbol' do
+            let(:write_level) { logging_levels[write_level_index] }
 
-  shared_examples 'nesting allowed' do
-    include_context 'nested log hash'
+            it_behaves_like 'a JSON log writer'
 
-    specify do
-      expect(logger_io).to receive(:puts) do |json_dump|
-        expect(JSON.parse(json_dump)).to eq log_hash
-      end
+            it_behaves_like 'nested JSON message flattened to strings'
 
-      subject.public_send(level, log_hash)
-    end
-  end
+            it_behaves_like 'gracefully fails with string message'
+          end
 
-  shared_examples 'gracefully fail with string arg' do
-    let(:log_message) { 'Unable to connect to server' }
+          context 'String' do
+            let(:write_level) { logging_levels[write_level_index].to_s }
 
-    specify { expect(logger_io).not_to receive(:puts) }
-    specify do
-      expect { subject.debug log_message }.not_to raise_error
-    end
-  end
+            it_behaves_like 'a JSON log writer'
 
-  %w(debug info warn error).each do |level|
-    describe "##{level}" do
-      let(:level) { level }
+            it_behaves_like 'nested JSON message flattened to strings'
 
-      it_behaves_like 'JSON logging'
+            it_behaves_like 'gracefully fails with string message'
+          end
 
-      it_behaves_like 'nests flattened to strings'
+          context 'Symbol' do
+            let(:write_level) { write_level_index }
 
-      it_behaves_like 'gracefully fail with string arg'
+            it_behaves_like 'a JSON log writer'
+
+            it_behaves_like 'nested JSON message flattened to strings'
+
+            it_behaves_like 'gracefully fails with string message'
+          end
+        end
+      end
+
+      context 'when write level is not specified' do
+        subject(:logger) { described_class.new(log_output_obj) }
+
+        it_behaves_like 'a JSON log writer'
+
+        it_behaves_like 'nested JSON message flattened to strings'
+
+        it_behaves_like 'gracefully fails with string message'
+      end
 
       context 'with nesting allowed' do
-        subject { described_class.new(logger_io, nesting: true) }
+        subject(:logger) { described_class.new(log_output_obj, nesting: true) }
 
         it_behaves_like 'nesting allowed'
       end

data/spec/alephant/logger/levels_controller_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+require 'alephant/logger/levels_controller'
+require_relative 'support/levels_controller_shared_examples'
+
+RSpec.describe Alephant::Logger::LevelsController do
+  describe '.should_log?' do
+    subject(:loggable?) do
+      described_class.should_log?(
+        message_level: message_level,
+        desired_level: desired_level
+      )
+    end
+
+    describe 'Message level' do
+      let(:message_level) { :info }
+
+      context 'when message level is higher than desired level' do
+        context 'Symbol' do
+          let(:desired_level) { :debug }
+
+          it_behaves_like 'a loggable level'
+        end
+
+        context 'String' do
+          let(:desired_level) { 'debug' }
+
+          it_behaves_like 'a loggable level'
+        end
+
+        context 'Integer' do
+          let(:desired_level) { 0 }
+
+          it_behaves_like 'a loggable level'
+
+          context 'when out of range' do
+            let(:desired_level) { -200 }
+
+            it_behaves_like 'a loggable level'
+          end
+        end
+      end
+
+      context 'when message level is lower than desired level' do
+        context 'Symbol' do
+          let(:desired_level) { :warn }
+
+          it_behaves_like 'a non loggable level'
+        end
+
+        context 'String' do
+          let(:desired_level) { 'warn' }
+
+          it_behaves_like 'a non loggable level'
+        end
+
+        context 'Integer' do
+          let(:desired_level) { 3 }
+
+          it_behaves_like 'a non loggable level'
+
+          context 'when out of range' do
+            let(:desired_level) { 100 }
+
+            it_behaves_like 'a non loggable level'
+          end
+        end
+      end
+
+      context 'when message level is equal to desired level' do
+        context 'Symbol' do
+          let(:desired_level) { message_level }
+
+          it_behaves_like 'a loggable level'
+        end
+
+        context 'String' do
+          let(:desired_level) { message_level.to_s }
+
+          it_behaves_like 'a loggable level'
+        end
+
+        context 'Integer' do
+          let(:desired_level) { 1 }
+
+          it_behaves_like 'a loggable level'
+        end
+      end
+
+      context 'when message level is invalid' do
+        let(:desired_level) { :debug }
+
+        context 'when message level is not in LEVELS' do
+          let(:message_level) { :foobar }
+
+          it_behaves_like 'a non loggable level'
+        end
+
+        context 'when message level is nil' do
+          let(:message_level) { nil }
+
+          it_behaves_like 'a non loggable level'
+        end
+      end
+    end
+
+    describe 'Desired level' do
+      context 'when desired level is not in LEVELS' do
+        let(:message_level) { :error }
+        let(:desired_level) { :foobar }
+
+        it 'defaults to debug' do
+          expect(loggable?).to be(true)
+        end
+      end
+
+      context 'when desired level is an unsupported type' do
+        context 'Hash' do
+          let(:message_level) { :error }
+          let(:desired_level) { {} }
+
+          it 'raises an argument error' do
+            expect { loggable? }.to raise_error(
+              ArgumentError,
+              'wrong type of argument: expected Integer, '\
+              'Symbol or String. got Hash'
+            )
+          end
+        end
+
+        context 'Nil' do
+          let(:message_level) { :error }
+          let(:desired_level) { nil }
+
+          it 'raises an argument error' do
+            expect { loggable? }.to raise_error(
+              ArgumentError,
+              'wrong type of argument: expected Integer, '\
+              'Symbol or String. got NilClass'
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/spec/alephant/logger/support/json_shared_examples.rb

@@ -0,0 +1,119 @@
+shared_examples 'a JSON log writer' do
+  let(:log_hash) do
+    { 'foo' => 'bar', 'baz' => 'quux' }
+  end
+
+  it 'writes JSON dump of hash to log with corresponding level key' do
+    allow(Time).to receive(:now).and_return('foobar')
+
+    expect(log_output_obj).to receive(msg) do |json_dump|
+      h = { 'timestamp' => 'foobar', 'uuid' => 'n/a', 'level' => level.to_s }
+      expect(JSON.parse(json_dump)).to eq(h.merge(log_hash))
+    end
+
+    logger.send(level, log_hash)
+  end
+
+  it 'automatically includes a timestamp' do
+    expect(log_output_obj).to receive(msg) do |json_dump|
+      t = JSON.parse(json_dump)['timestamp']
+      expect { DateTime.parse(t) }.not_to raise_error
+    end
+
+    logger.send(level, log_hash)
+  end
+
+  it 'outputs the timestamp first' do
+    expect(log_output_obj).to receive(msg) do |json_dump|
+      h = JSON.parse(json_dump)
+      expect(h.first[0].to_sym).to be(:timestamp)
+    end
+
+    logger.send(level, log_hash)
+  end
+
+  context 'when a session is set' do
+    it 'provides a static reader method' do
+      described_class.session = fn
+      expect(described_class.session?).to eq('instance-variable')
+
+      described_class.send(:remove_instance_variable, :@session)
+      expect(described_class.session?).to be(nil)
+    end
+  end
+
+  context 'when a user defined function is provided' do
+    it 'displays a custom session value' do
+      expect(log_output_obj).to receive(msg) do |json_dump|
+        h = JSON.parse(json_dump)
+        expect(h['uuid']).to eq('foo')
+      end
+
+      described_class.session = fn
+      logger.send(level, binding, log_hash)
+      described_class.session = -> { 'n/a' }
+    end
+  end
+
+  context 'when a user defined function is not provided' do
+    it 'displays a default session value' do
+      expect(log_output_obj).to receive(msg) do |json_dump|
+        h = JSON.parse(json_dump)
+        expect(h['uuid']).to eq('n/a')
+      end
+
+      logger.send(level, log_hash)
+    end
+  end
+end
+
+shared_examples 'a JSON log non writer' do
+  before do
+    allow(Time).to receive(:now).and_return('foobar')
+    logger.send(level, log_hash)
+  end
+
+  it 'does not write' do
+    expect(log_output_obj).not_to receive(msg)
+  end
+end
+
+shared_context 'nested log hash' do
+  let(:log_hash) { { 'nest' => nest } }
+
+  let(:nest) { { 'bird' => 'eggs' } }
+end
+
+shared_examples 'nested JSON message flattened to strings' do
+  include_context 'nested log hash'
+
+  specify do
+    expect(log_output_obj).to receive(msg) do |json_dump|
+      expect(JSON.parse(json_dump)['nest']).to eq(nest.to_s)
+    end
+
+    logger.send(level, log_hash)
+  end
+end
+
+shared_examples 'nesting allowed' do
+  include_context 'nested log hash'
+
+  specify do
+    expect(log_output_obj).to receive(msg) do |json_dump|
+      expect(JSON.parse(json_dump)).to eq(log_hash)
+    end
+
+    logger.send(level, log_hash)
+  end
+end
+
+shared_examples 'gracefully fails with string message' do
+  let(:log_message) { 'Unable to connect to server' }
+
+  specify { expect(log_output_obj).not_to receive(msg) }
+
+  specify do
+    expect { logger.debug(log_message) }.not_to raise_error
+  end
+end

data/spec/alephant/logger/support/levels_controller_shared_examples.rb

@@ -0,0 +1,11 @@
+shared_examples 'a loggable level' do
+  it 'returns true' do
+    expect(loggable?).to be(true)
+  end
+end
+
+shared_examples 'a non loggable level' do
+  it 'returns false' do
+    expect(loggable?).to be(false)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alephant-logger-json
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Dan Arnould
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-23 00:00:00.000000000 Z
+date: 2017-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -112,8 +112,12 @@ files:
 - lib/alephant/logger/json.rb
 - lib/alephant/logger/json/version.rb
 - lib/alephant/logger/json_to_io.rb
+- lib/alephant/logger/levels_controller.rb
 - spec/alephant/logger/json_spec.rb
 - spec/alephant/logger/json_to_io_spec.rb
+- spec/alephant/logger/levels_controller_spec.rb
+- spec/alephant/logger/support/json_shared_examples.rb
+- spec/alephant/logger/support/levels_controller_shared_examples.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses:
@@ -135,11 +139,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: alephant-logger driver enabling structured logging in JSON
 test_files:
 - spec/alephant/logger/json_spec.rb
 - spec/alephant/logger/json_to_io_spec.rb
+- spec/alephant/logger/levels_controller_spec.rb
+- spec/alephant/logger/support/json_shared_examples.rb
+- spec/alephant/logger/support/levels_controller_shared_examples.rb
 - spec/spec_helper.rb