semantic_logger 4.1.1 → 4.2.0

data/test/formatters/signalfx_test.rb

@@ -0,0 +1,200 @@
+require_relative '../test_helper'
+require 'net/http'
+
+module SemanticLogger
+  module Formatters
+    class SignalfxTest < Minitest::Test
+      describe SemanticLogger::Formatters::Signalfx do
+        let :average_metric_name do
+          'Application.average'
+        end
+
+        let :counter_metric_name do
+          'Application.counter'
+        end
+
+        let :log do
+          metric     = '/user/login'
+          log        = SemanticLogger::Log.new('User', :debug)
+          log.metric = metric
+          log
+        end
+
+        let :logs do
+          3.times.collect do |i|
+            l        = log.dup
+            l.metric = "/user/login#{i+1}"
+            l
+          end
+        end
+
+        let :same_logs do
+          3.times.collect do |i|
+            l        = log.dup
+            l.metric = "/user/login"
+            l
+          end
+        end
+
+        let :dimensions do
+          {action: 'hit', user: 'jbloggs', state: 'FL'}
+        end
+
+        let :all_dimensions do
+          dims        = dimensions.merge(
+            host:        SemanticLogger.host,
+            application: SemanticLogger.application,
+            environment: 'test'
+          )
+          string_keys = {}
+          dims.each_pair { |k, v| string_keys[k.to_s] = v }
+          string_keys
+        end
+
+        let :appender do
+          Net::HTTP.stub_any_instance(:start, true) do
+            SemanticLogger::Metric::Signalfx.new(token: 'TEST')
+          end
+        end
+
+        let :formatter do
+          appender.formatter
+        end
+
+        describe 'format single log' do
+          let :result do
+            JSON.parse(formatter.call(log, appender))
+          end
+
+          it 'send counter metric when there is no duration' do
+            hash = result
+            assert counters = hash['counter'], hash
+            assert counter = counters.first, hash
+            assert_equal counter_metric_name, counter['metric'], counter
+            assert_equal 1, counter['value'], counter
+            assert_equal (log.time.to_i * 1_000).to_i, counter['timestamp'], counter
+            assert counter.has_key?('dimensions')
+          end
+
+          it 'send gauge metric when log includes duration' do
+            log.duration = 1234
+            hash         = result
+            assert counters = hash['gauge'], hash
+            assert counter = counters.first, hash
+            assert_equal average_metric_name, counter['metric'], counter
+            assert_equal 1234, counter['value'], counter
+            assert_equal (log.time.to_i * 1_000).to_i, counter['timestamp'], counter
+            assert counter.has_key?('dimensions')
+          end
+
+          it 'also sends counter metric when gauge metric is sent' do
+            log.duration = 1234
+            hash         = result
+            assert counters = hash['counter'], hash
+            assert counter = counters.first, hash
+            assert_equal counter_metric_name, counter['metric'], counter
+            assert_equal 1, counter['value'], counter
+            assert_equal (log.time.to_i * 1_000).to_i, counter['timestamp'], counter
+            assert counter.has_key?('dimensions')
+          end
+
+          it 'only forwards whitelisted dimensions from named_tags' do
+            log.named_tags       = {user_id: 47, tracking_number: 7474, session_id: 'hsdhngsd'}
+            formatter.dimensions = [:user_id, :application]
+            hash                 = result
+            assert counters = hash['counter'], hash
+            assert counter = counters.first, hash
+            assert_equal({'class' => 'user', 'action' => 'login', 'environment' => 'test', 'user_id' => '47', 'host' => SemanticLogger.host, 'application' => SemanticLogger.application}, counter['dimensions'], counter)
+          end
+
+          it 'raises exception with both a whitelist and blacklist' do
+            assert_raises ArgumentError do
+              SemanticLogger::Formatters::Signalfx.new(token: 'TEST', dimensions: [:user_id], exclude_dimensions: [:tracking_number])
+            end
+          end
+
+          it 'send custom counter metric when there is no duration' do
+            log.metric     = 'Filter/count'
+            log.dimensions = dimensions
+            hash           = result
+
+            assert counters = hash['counter'], hash
+            assert counter = counters.first, hash
+            assert_equal 'Filter.count', counter['metric'], counter
+            assert_equal 1, counter['value'], counter
+            assert_equal (log.time.to_i * 1_000).to_i, counter['timestamp'], counter
+            assert_equal all_dimensions, counter['dimensions']
+          end
+        end
+
+        describe 'format batch logs' do
+          let :result do
+            JSON.parse(formatter.batch(logs, appender))
+          end
+
+          it 'send metrics' do
+            hash = result
+
+            assert counters = hash['counter'], hash
+            assert_equal 3, counters.size
+            assert_equal counter_metric_name, counters[0]['metric']
+            assert_equal 1, counters[0]['value']
+            assert_equal counter_metric_name, counters[1]['metric']
+            assert_equal counter_metric_name, counters[2]['metric']
+          end
+
+          it 'sends gauge metrics' do
+            logs.each { |log| log.duration = 3.5 }
+            hash = result
+            assert gauges = hash['gauge'], hash
+            assert_equal 3, gauges.size
+            assert_equal average_metric_name, gauges[0]['metric']
+            assert_equal 3.5, gauges[0]['value']
+            assert_equal average_metric_name, gauges[1]['metric']
+            assert_equal average_metric_name, gauges[2]['metric']
+          end
+
+          describe 'send custom' do
+            let :logs do
+              3.times.collect do |i|
+                l            = log.dup
+                l.metric     = 'Filter/count'
+                l.dimensions = dimensions
+                l
+              end
+            end
+
+            it 'counter metric when there is no duration' do
+              hash = result
+
+              assert counters = hash['counter'], hash
+              assert counter = counters.first, hash
+              assert_equal 'Filter.count', counter['metric'], counter
+              assert_equal 3, counter['value'], counter
+              assert_equal (log.time.to_i * 1_000).to_i, counter['timestamp'], counter
+              assert_equal all_dimensions, counter['dimensions']
+            end
+          end
+
+        end
+
+        describe 'format batch logs with aggregation' do
+          let :result do
+            JSON.parse(formatter.batch(same_logs, appender))
+          end
+
+          it 'sends counter metrics' do
+            hash = result
+
+            assert counters = hash['counter'], hash
+            assert_equal 1, counters.size
+            assert_equal counter_metric_name, counters[0]['metric']
+            assert_equal 3, counters[0]['value']
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/test/formatters_test.rb

@@ -0,0 +1,36 @@
+require_relative 'test_helper'
+
+class FormattersTest < Minitest::Test
+  describe SemanticLogger::Formatters do
+    describe '.factory' do
+      let :log do
+        SemanticLogger::Log.new('Test', :info)
+      end
+
+      let :appender do
+        SemanticLogger::Appender::File.new(io: STDOUT)
+      end
+
+      it 'from a symbol' do
+        assert formatter = SemanticLogger::Formatters.factory(:raw)
+        assert formatter.is_a?(SemanticLogger::Formatters::Raw)
+        assert_equal 'Test', formatter.call(log, appender)[:name]
+      end
+
+      it 'from a Hash (Symbol with options)' do
+        assert formatter = SemanticLogger::Formatters.factory(raw: {time_format: "%Y%m%d"})
+        assert formatter.is_a?(SemanticLogger::Formatters::Raw)
+        assert result = formatter.call(log, appender)
+        assert_equal 'Test', result[:name]
+        assert_equal Time.now.strftime("%Y%m%d"), result[:time]
+      end
+
+      it 'from block' do
+        my_formatter = -> log, appender { log.name }
+        assert formatter = SemanticLogger::Formatters.factory(my_formatter)
+        assert formatter.is_a?(Proc)
+        assert_equal 'Test', formatter.call(log, appender)
+      end
+    end
+  end
+end

data/test/in_memory_appender.rb

@@ -0,0 +1,9 @@
+# Store in memory the last log message received.
+class InMemoryAppender < SemanticLogger::Subscriber
+  attr_accessor :message
+
+  def log(log)
+    self.message = log
+  end
+end
+

data/test/in_memory_appender_helper.rb

@@ -0,0 +1,43 @@
+require 'minitest/shared_description'
+
+InMemoryAppenderHelper = shared_description do
+  let :log_message do
+    SemanticLogger.flush
+    appender.message
+  end
+
+  let :appender do
+    InMemoryAppender.new
+  end
+
+  let :thread_name do
+    Thread.current.name
+  end
+
+  let :payload do
+    {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
+  end
+
+  let :logger do
+    SemanticLogger['TestLogger']
+  end
+
+  let :appender_options do
+    {appender: appender}
+  end
+
+  let :added_appender do
+    SemanticLogger.add_appender(appender_options)
+  end
+
+  before do
+    SemanticLogger.default_level   = :trace
+    SemanticLogger.backtrace_level = :trace
+    SemanticLogger.flush
+    added_appender
+  end
+
+  after do
+    SemanticLogger.appenders.each { |appender| SemanticLogger.remove_appender(appender) }
+  end
+end

data/test/in_memory_batch_appender.rb

@@ -0,0 +1,9 @@
+# Store in memory the last log message received.
+class InMemoryBatchAppender < SemanticLogger::Subscriber
+  attr_accessor :message
+
+  def batch(logs)
+    self.message = logs
+  end
+end
+

data/test/in_memory_metrics_appender.rb

@@ -0,0 +1,14 @@
+# Store in memory the last log message received.
+class InMemoryMetricsAppender < SemanticLogger::Subscriber
+  attr_accessor :message
+
+  def log(log)
+    self.message = log
+  end
+
+  # Only forward log entries that contain metrics.
+  def should_log?(log)
+    log.metric && meets_log_level?(log) && !filtered?(log)
+  end
+end
+

data/test/loggable_test.rb

@@ -73,43 +73,28 @@ class AppenderFileTest < Minitest::Test
     end
 
     describe 'logger' do
-      before do
-        @time                        = Time.new
-        @io                          = StringIO.new
-        @appender                    = SemanticLogger::Appender::File.new(io: @io)
-        SemanticLogger.default_level = :trace
-        @mock_logger                 = MockLogger.new
-        @appender                    = SemanticLogger.add_appender(logger: @mock_logger)
-        @hash                        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
-        @hash_str                    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-        @thread_name                 = Thread.current.name
-      end
-
-      after do
-        SemanticLogger.remove_appender(@appender)
-      end
+      include InMemoryAppenderHelper
 
       describe 'for each log level' do
         # Ensure that any log level can be logged
         SemanticLogger::LEVELS.each do |level|
-          it "log #{level} information with class attribute" do
-            SemanticLogger.stub(:backtrace_level_index, 0) do
-              SemanticLogger.stub(:appenders, [@appender]) do
-                TestAttribute.logger.send(level, "hello #{level}", @hash)
-                SemanticLogger.flush
-                assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name} loggable_test.rb:\d+\] TestAttribute -- hello #{level} -- #{@hash_str}/, @mock_logger.message)
-              end
-            end
+          it "logs #{level} information with class attribute" do
+            TestAttribute.logger.send(level, "hello #{level}", payload)
+
+            assert log = log_message
+            assert_equal "hello #{level}", log.message
+            assert_equal level, log.level
+            assert_equal 'TestAttribute', log.name
+            assert_equal payload, log.payload
           end
 
           it "log #{level} information with instance attribute" do
-            SemanticLogger.stub(:backtrace_level_index, 0) do
-              SemanticLogger.stub(:appenders, [@appender]) do
-                TestAttribute.new.logger.send(level, "hello #{level}", @hash)
-                SemanticLogger.flush
-                assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name} loggable_test.rb:\d+\] TestAttribute -- hello #{level} -- #{@hash_str}/, @mock_logger.message)
-              end
-            end
+            TestAttribute.new.logger.send(level, "hello #{level}", payload)
+            assert log = log_message
+            assert_equal "hello #{level}", log.message
+            assert_equal level, log.level
+            assert_equal 'TestAttribute', log.name
+            assert_equal payload, log.payload
           end
         end
       end

data/test/logger_test.rb

@@ -3,174 +3,210 @@ require_relative 'test_helper'
 # Unit Test for SemanticLogger::Logger
 class LoggerTest < Minitest::Test
   describe SemanticLogger::Logger do
-    before do
-      # Use a mock logger that just keeps the last logged entry in an instance
-      # variable
-      SemanticLogger.default_level   = :trace
-      SemanticLogger.backtrace_level = nil
-      @mock_logger                   = MockLogger.new
-      @appender                      = SemanticLogger.add_appender(logger: @mock_logger)
-
-      # Use this test's class name as the application name in the log output
-      @logger                        = SemanticLogger[LoggerTest]
-      @hash                          = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
-      @hash_str                      = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-      @thread_name                   = Thread.current.name
-      @file_name_reg_exp             = ' logger_test.rb:\d+'
-
-      assert_equal [], SemanticLogger.tags
-      assert_equal 65535, SemanticLogger.backtrace_level_index
-    end
+    include InMemoryAppenderHelper
 
-    after do
-      SemanticLogger.remove_appender(@appender)
+    let :dimensions do
+      {action: 'hit', user: 'jbloggs', state: 'FL'}
     end
 
     # Ensure that any log level can be logged
     SemanticLogger::LEVELS.each do |level|
-      level_char = level.to_s.upcase[0]
 
       describe "##{level}" do
         describe 'positional parameter' do
           it 'logs message' do
-            @logger.send(level, 'hello world')
-            SemanticLogger.flush
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- hello world/, @mock_logger.message)
+            logger.send(level, 'hello world')
+
+            assert log = log_message
+            assert_equal 'hello world', log.message
           end
 
           it 'adds message from block' do
-            @logger.send(level, 'hello world') { 'Calculations' }
-            SemanticLogger.flush
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- hello world -- Calculations/, @mock_logger.message)
+            logger.send(level, 'hello world') { 'Calculations' }
+
+            assert log = log_message
+            assert_equal 'hello world -- Calculations', log.message
           end
 
           it 'logs message and payload' do
-            hash     = {tracking_number: '123456', even: 2, more: 'data'}
-            hash_str = hash.inspect.sub('{', '\{').sub('}', '\}')
-            @logger.send(level, 'Hello world', hash)
-            SemanticLogger.flush
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message)
-          end
+            logger.send(level, 'hello world', payload)
 
-          it 'does not log an empty payload' do
-            hash = {}
-            @logger.send(level, 'Hello world', hash)
-            SemanticLogger.flush
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- Hello world/, @mock_logger.message)
+            assert log = log_message
+            assert_equal 'hello world', log.message
+            assert_equal payload, log.payload
           end
 
           it 'logs with backtrace' do
             SemanticLogger.stub(:backtrace_level_index, 0) do
-              @logger.send(level, 'hello world', @hash) { 'Calculations' }
-              SemanticLogger.flush
-              assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
+              logger.send(level, 'hello world', payload) { 'Calculations' }
+
+              assert log = log_message
+              assert_equal 'hello world -- Calculations', log.message
+              assert_equal payload, log.payload
+              assert log.backtrace
+              assert log.backtrace.size > 0, log.backtrace
             end
           end
 
           it 'logs with backtrace and exception' do
             SemanticLogger.stub(:backtrace_level_index, 0) do
               exc = RuntimeError.new('Test')
-              @logger.send(level, 'hello world', exc)
-              SemanticLogger.flush
-              assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] LoggerTest -- hello world -- Exception: RuntimeError: Test/, @mock_logger.message)
+              logger.send(level, 'hello world', exc)
+
+              assert log = log_message
+              assert_equal 'hello world', log.message
+              assert log.backtrace
+              assert log.backtrace.size > 0, log.backtrace
+
+              assert log.exception
+              refute log.exception.backtrace
+              assert_equal 'RuntimeError', log.exception.class.name
             end
           end
         end
 
-        describe 'named parameters' do
+        describe 'keyword arguments' do
           it 'logs message' do
-            @logger.send(level, message: 'Hello world')
-            SemanticLogger.flush
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- Hello world/, @mock_logger.message)
+            logger.send(level, message: 'hello world')
+
+            assert log = log_message
+            assert_equal 'hello world', log.message
           end
 
           it 'logs payload and message' do
-            @logger.send(level, message: 'Hello world', payload: {tracking_number: '123456', even: 2, more: 'data'})
-            hash = {tracking_number: '123456', even: 2, more: 'data'}
-            SemanticLogger.flush
-            hash_str = hash.inspect.sub('{', '\{').sub('}', '\}')
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message)
+            logger.send(level, message: 'hello world', payload: payload)
+
+            assert log = log_message
+            assert_equal 'hello world', log.message
+            assert_equal payload, log.payload
           end
 
           it 'logs payload and message from block' do
-            @logger.send(level) { {message: 'Hello world', payload: {tracking_number: '123456', even: 2, more: 'data'}} }
-            hash = {tracking_number: '123456', even: 2, more: 'data'}
-            SemanticLogger.flush
-            hash_str = hash.inspect.sub('{', '\{').sub('}', '\}')
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message)
+            logger.send(level) { {message: 'hello world', payload: payload} }
+
+            assert log = log_message
+            assert_equal 'hello world', log.message
+            assert_equal payload, log.payload
           end
 
           it 'logs payload only' do
-            hash = {tracking_number: '123456', even: 2, more: 'data'}
-            @logger.send(level, payload: hash)
-            SemanticLogger.flush
-            hash_str = hash.inspect.sub('{', '\{').sub('}', '\}')
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- #{hash_str}/, @mock_logger.message)
+            logger.send(level, payload: payload)
+
+            assert log = log_message
+            refute log.message
+            assert_equal payload, log.payload
           end
 
           it 'logs duration' do
-            @logger.send(level, duration: 123.44, message: 'Hello world', payload: {tracking_number: '123456', even: 2, more: 'data'})
-            hash = {tracking_number: '123456', even: 2, more: 'data'}
-            SemanticLogger.flush
-            hash_str       = hash.inspect.sub('{', '\{').sub('}', '\}')
-            duration_match = SemanticLogger::Formatters::Base::PRECISION == 3 ? '\(123ms\)' : '\(123\.4ms\)'
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] #{duration_match} LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message)
+            logger.send(level, duration: 123.44, message: 'hello world', payload: payload)
+
+            assert log = log_message
+            assert_equal 'hello world', log.message
+            assert_equal payload, log.payload
+            assert_equal 123.44, log.duration
           end
 
           it 'does not log when below min_duration' do
-            @logger.send(level, min_duration: 200, duration: 123.45, message: 'Hello world', payload: {tracking_number: '123456', even: 2, more: 'data'})
-            SemanticLogger.flush
-            assert_nil @mock_logger.message
+            logger.send(level, min_duration: 200, duration: 123.45, message: 'hello world', payload: {tracking_number: '123456', even: 2, more: 'data'})
+
+            refute log_message
           end
 
           it 'logs metric' do
-            # Add mock metric subscriber
-            $last_metric = nil
-            SemanticLogger.on_metric do |log|
-              $last_metric = log.dup
+            metric_name = '/my/custom/metric'
+            logger.send(level, metric: metric_name, duration: 123.44, message: 'hello world', payload: payload)
+
+            assert log = log_message
+            assert_equal 'hello world', log.message
+            assert_equal payload, log.payload
+            assert_equal 123.44, log.duration
+            assert_equal metric_name, log.metric
+          end
+
+          describe 'metrics appender' do
+            let :appender do
+              InMemoryMetricsAppender.new
             end
 
-            metric_name = '/my/custom/metric'
-            @logger.send(level, metric: metric_name, duration: 123.44, message: 'Hello world', payload: {tracking_number: '123456', even: 2, more: 'data'})
-            hash = {tracking_number: '123456', even: 2, more: 'data'}
-            SemanticLogger.flush
-            hash_str       = hash.inspect.sub('{', '\{').sub('}', '\}')
-            duration_match = SemanticLogger::Formatters::Base::PRECISION == 3 ? '\(123ms\)' : '\(123\.4ms\)'
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] #{duration_match} LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message)
-            assert metric_name, $last_metric.metric
+            it 'logs metric only events' do
+              metric_name = '/my/custom/metric'
+              logger.send(level, metric: metric_name, dimensions: dimensions)
+
+              assert log = log_message
+              assert_equal metric_name, log.metric
+              assert_equal dimensions, log.dimensions
+              refute log.message
+            end
           end
 
+          it 'for compatibility handles random payload logged as keyword arguments' do
+            logger.send(level, payload)
+
+            assert log = log_message
+            refute log.message
+            refute log.exception
+            refute log.metric
+            assert_equal payload, log.payload
+          end
         end
 
         describe '#filter' do
-          it 'Proc' do
-            @appender.filter = Proc.new { |l| (/\AExclude/ =~ l.message).nil? }
-            @logger.send(level, 'Exclude this log message', @hash) { 'Calculations' }
-            SemanticLogger.flush
-            assert_nil @mock_logger.message
+          describe 'at the appender level' do
+            it 'Proc' do
+              appender.filter = -> log { (/\AExclude/ =~ log.message).nil? }
+              logger.send(level, 'Exclude this log message', @hash) { 'Calculations' }
+
+              refute log_message
+            end
+
+            it 'RegExp' do
+              filter          = /\ALogger/
+              appender.filter = -> log { (/\AExclude/ =~ log.message).nil? }
+              logger.send(level, 'Exclude this log message', @hash) { 'Calculations' }
+
+              refute log_message
+            end
           end
 
-          it 'RegExp' do
-            filter           = /\ALogger/
-            @appender.filter = filter
-            logger           = SemanticLogger::Logger.new('NotLogger', :trace, filter)
-            logger.send(level, 'Ignore all log messages from this class', @hash) { 'Calculations' }
-            SemanticLogger.flush
-            assert_nil @mock_logger.message
+          describe 'at the logger level' do
+            it 'Proc' do
+              logger.filter = -> log { (/\AExclude/ =~ log.message).nil? }
+              logger.send(level, 'Exclude this log message', @hash) { 'Calculations' }
+
+              refute log_message
+            end
+
+            it 'RegExp' do
+              filter        = /\ALogger/
+              logger.filter = -> log { (/\AExclude/ =~ log.message).nil? }
+              logger.send(level, 'Exclude this log message', @hash) { 'Calculations' }
+
+              refute log_message
+            end
           end
+
         end
       end
     end
 
+    describe 'when level is too high' do
+      it 'does not log' do
+        SemanticLogger.default_level = :error
+        logger.info('Exclude this log message')
+
+        refute log_message
+      end
+    end
+
     describe 'Compatibility' do
       # Ensure that any log level can be logged
       Logger::Severity.constants.each do |level|
         it "log Ruby logger #{level} info" do
-          @logger.level = Logger::Severity.const_get(level)
+          logger.level = Logger::Severity.const_get(level)
           if level.to_s == 'UNKNOWN'
-            assert_equal Logger::Severity.const_get('ERROR')+1, @logger.send(:level_index)
+            assert_equal Logger::Severity.const_get('ERROR')+1, logger.send(:level_index)
           else
-            assert_equal Logger::Severity.const_get(level)+1, @logger.send(:level_index)
+            assert_equal Logger::Severity.const_get(level)+1, logger.send(:level_index)
           end
         end
       end
@@ -179,68 +215,76 @@ class LoggerTest < Minitest::Test
     describe '#level?' do
       it 'return true for debug? with :trace level' do
         SemanticLogger.default_level = :trace
-        assert_equal :trace, @logger.level
-        assert_equal true, @logger.debug?
-        assert_equal true, @logger.trace?
+        assert_equal :trace, logger.level
+        assert_equal true, logger.debug?
+        assert_equal true, logger.trace?
       end
 
       it 'return false for debug? with global :debug level' do
         SemanticLogger.default_level = :debug
-        assert_equal :debug, @logger.level, @logger.inspect
-        assert_equal true, @logger.debug?, @logger.inspect
-        assert_equal false, @logger.trace?, @logger.inspect
+        assert_equal :debug, logger.level, logger.inspect
+        assert_equal true, logger.debug?, logger.inspect
+        assert_equal false, logger.trace?, logger.inspect
       end
 
       it 'return true for debug? with global :info level' do
         SemanticLogger.default_level = :info
-        assert_equal :info, @logger.level, @logger.inspect
-        assert_equal false, @logger.debug?, @logger.inspect
-        assert_equal false, @logger.trace?, @logger.inspect
+        assert_equal :info, logger.level, logger.inspect
+        assert_equal false, logger.debug?, logger.inspect
+        assert_equal false, logger.trace?, logger.inspect
       end
 
       it 'return false for debug? with instance :debug level' do
-        @logger.level = :debug
-        assert_equal :debug, @logger.level, @logger.inspect
-        assert_equal true, @logger.debug?, @logger.inspect
-        assert_equal false, @logger.trace?, @logger.inspect
+        logger.level = :debug
+        assert_equal :debug, logger.level, logger.inspect
+        assert_equal true, logger.debug?, logger.inspect
+        assert_equal false, logger.trace?, logger.inspect
       end
 
       it 'return true for debug? with instance :info level' do
-        @logger.level = :info
-        assert_equal :info, @logger.level, @logger.inspect
-        assert_equal false, @logger.debug?, @logger.inspect
-        assert_equal false, @logger.trace?, @logger.inspect
+        logger.level = :info
+        assert_equal :info, logger.level, logger.inspect
+        assert_equal false, logger.debug?, logger.inspect
+        assert_equal false, logger.trace?, logger.inspect
       end
     end
 
     describe '.tagged' do
+      it 'sets global defaults' do
+        assert_equal [], SemanticLogger.tags
+        assert_equal 0, SemanticLogger.backtrace_level_index
+      end
+
       it 'add tags to log entries' do
-        @logger.tagged('12345', 'DJHSFK') do
-          @logger.info('Hello world')
-          SemanticLogger.flush
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \[12345\] \[DJHSFK\] LoggerTest -- Hello world/, @mock_logger.message)
+        logger.tagged('12345', 'DJHSFK') do
+          logger.info('hello world')
+
+          assert log = log_message
+          assert_equal 'hello world', log.message
+          assert_equal %w(12345 DJHSFK), log.tags
         end
       end
 
       it 'add embedded tags to log entries' do
-        @logger.tagged('First Level', 'tags') do
-          @logger.tagged('Second Level') do
-            @logger.info('Hello world')
-            SemanticLogger.flush
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \[First Level\] \[tags\] \[Second Level\] LoggerTest -- Hello world/, @mock_logger.message)
+        logger.tagged('First Level', 'tags') do
+          logger.tagged('Second Level') do
+            assert_equal ['First Level', 'tags', 'Second Level'], logger.tags
+            logger.info('hello world')
+
+            assert log = log_message
+            assert_equal 'hello world', log.message
+            assert_equal ['First Level', 'tags', 'Second Level'], log.tags
           end
-          assert_equal 2, @logger.tags.count, @logger.tags
-          assert_equal 'First Level', @logger.tags.first
-          assert_equal 'tags', @logger.tags.last
+          assert_equal ['First Level', 'tags'], logger.tags
         end
       end
 
       it 'also supports named tagging' do
-        @logger.tagged(level1: 1) do
+        logger.tagged(level1: 1) do
           assert_equal({level1: 1}, SemanticLogger.named_tags)
-          @logger.tagged(level2: 2, more: 'data') do
+          logger.tagged(level2: 2, more: 'data') do
             assert_equal({level1: 1, level2: 2, more: 'data'}, SemanticLogger.named_tags)
-            @logger.tagged(level3: 3) do
+            logger.tagged(level3: 3) do
               assert_equal({level1: 1, level2: 2, more: 'data', level3: 3}, SemanticLogger.named_tags)
             end
           end
@@ -248,10 +292,12 @@ class LoggerTest < Minitest::Test
       end
 
       it 'is compatible with rails logging that uses arrays and nils' do
-        @logger.tagged('', ['12345', 'DJHSFK'], nil) do
-          @logger.info('Hello world')
-          SemanticLogger.flush
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \[12345\] \[DJHSFK\] LoggerTest -- Hello world/, @mock_logger.message)
+        logger.tagged('', ['12345', 'DJHSFK'], nil) do
+          logger.info('hello world')
+
+          assert log = log_message
+          assert_equal 'hello world', log.message
+          assert_equal %w(12345 DJHSFK), log.tags
         end
       end
     end