semantic_logger 3.4.1 → 4.0.0.beta1

data/test/measure_test.rb

@@ -0,0 +1,249 @@
+require_relative 'test_helper'
+
+class MeasureTest < Minitest::Test
+  describe 'Measure' do
+    before do
+      SemanticLogger.default_level   = :trace
+      SemanticLogger.backtrace_level = nil
+      @mock_logger                   = MockLogger.new
+      @appender                      = SemanticLogger.add_appender(logger: @mock_logger)
+      @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             = " #{File.basename(__FILE__)}:\d+"
+
+      # Add mock metric subscriber
+      $last_metric                   = nil
+      SemanticLogger.on_metric do |log|
+        $last_metric = log.dup
+      end
+    end
+
+    after do
+      SemanticLogger.remove_appender(@appender)
+    end
+
+    # Ensure that any log level can be measured and logged
+    SemanticLogger::LEVELS.each do |level|
+      level_char    = level.to_s.upcase[0]
+      measure_level = "measure_#{level}".to_sym
+
+      describe "##{measure_level}" do
+        it ':message' do
+          assert_equal 'result', @logger.send(measure_level, 'hello world') { 'result' } # Measure duration of the supplied block
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+        end
+
+        it ':payload' do
+          assert_equal 'result', @logger.send(measure_level, 'hello world', payload: @hash) { 'result' } # Measure duration of the supplied block
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message)
+        end
+
+        describe ':min_duration' do
+          it 'not log when faster' do
+            assert_equal 'result', @logger.send(measure_level, 'hello world', min_duration: 500) { 'result' } # Measure duration of the supplied block
+            SemanticLogger.flush
+            assert_nil @mock_logger.message
+          end
+
+          it 'log when slower' do
+            assert_equal 'result', @logger.send(measure_level, 'hello world', min_duration: 200, payload: @hash) { sleep 0.5; 'result' } # Measure duration of the supplied block
+            SemanticLogger.flush
+            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message)
+          end
+        end
+
+        it ':exception' do
+          assert_raises RuntimeError do
+            @logger.send(measure_level, 'hello world', payload: @hash) { raise RuntimeError.new('Test') } # Measure duration of the supplied block
+          end
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message)
+        end
+
+        it ':on_exception_level' do
+          assert_raises RuntimeError do
+            @logger.send(measure_level, 'hello world', payload: @hash, on_exception_level: :fatal) { raise RuntimeError.new('Test') } # Measure duration of the supplied block
+          end
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message)
+        end
+
+        it ':metric' do
+          metric_name = '/my/custom/metric'
+          assert_equal 'result', @logger.send(measure_level, 'hello world', metric: metric_name) { 'result' } # Measure duration of the supplied block
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+          assert metric_name, $last_metric.metric
+        end
+
+        it ':backtrace_level' do
+          SemanticLogger.stub(:backtrace_level_index, 0) do
+            assert_equal 'result', @logger.send(measure_level, 'hello world') { 'result' }
+            SemanticLogger.flush
+            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+          end
+        end
+      end
+
+      describe "#measure(#{level})" do
+        it ':message' do
+          assert_equal 'result', @logger.measure(level, 'hello world') { 'result' } # Measure duration of the supplied block
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+        end
+
+        it ':payload' do
+          assert_equal 'result', @logger.measure(level, 'hello world', payload: @hash) { 'result' } # Measure duration of the supplied block
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message)
+        end
+
+        describe ':min_duration' do
+          it 'not log when faster' do
+            assert_equal 'result', @logger.measure(level, 'hello world', min_duration: 500) { 'result' } # Measure duration of the supplied block
+            SemanticLogger.flush
+            assert_nil @mock_logger.message
+          end
+
+          it 'log when slower' do
+            assert_equal 'result', @logger.measure(level, 'hello world', min_duration: 200, payload: @hash) { sleep 0.5; 'result' } # Measure duration of the supplied block
+            SemanticLogger.flush
+            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message)
+          end
+        end
+
+        it ':exception' do
+          assert_raises RuntimeError do
+            @logger.measure(level, 'hello world', payload: @hash) { raise RuntimeError.new('Test') } # Measure duration of the supplied block
+          end
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message)
+        end
+
+        it ':metric' do
+          metric_name = '/my/custom/metric'
+          assert_equal 'result', @logger.measure(level, 'hello world', metric: metric_name) { 'result' } # Measure duration of the supplied block
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+          assert metric_name, $last_metric.metric
+        end
+
+        it "log #{level} info with backtrace" do
+          SemanticLogger.stub(:backtrace_level_index, 0) do
+            assert_equal 'result', @logger.measure(level, 'hello world') { 'result' }
+            SemanticLogger.flush
+            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+          end
+        end
+      end
+
+      describe "##{measure_level} named parameters" do
+        it ':message' do
+          assert_equal 'result', @logger.send(measure_level, message: 'hello world') { 'result' } # Measure duration of the supplied block
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+        end
+
+        it ':payload' do
+          assert_equal 'result', @logger.send(measure_level, message: 'hello world', payload: @hash) { 'result' } # Measure duration of the supplied block
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message)
+        end
+
+        describe ':min_duration' do
+          it 'not log when faster' do
+            assert_equal 'result', @logger.send(measure_level, message: 'hello world', min_duration: 500) { 'result' } # Measure duration of the supplied block
+            SemanticLogger.flush
+            assert_nil @mock_logger.message
+          end
+
+          it 'log when slower' do
+            assert_equal 'result', @logger.send(measure_level, message: 'hello world', min_duration: 200, payload: @hash) { sleep 0.5; 'result' } # Measure duration of the supplied block
+            SemanticLogger.flush
+            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message)
+          end
+        end
+
+        it ':exception' do
+          assert_raises RuntimeError do
+            @logger.send(measure_level, message: 'hello world', payload: @hash) { raise RuntimeError.new('Test') } # Measure duration of the supplied block
+          end
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message)
+        end
+
+        it ':on_exception_level' do
+          assert_raises RuntimeError do
+            @logger.send(measure_level, message: 'hello world', payload: @hash, on_exception_level: :fatal) { raise RuntimeError.new('Test') } # Measure duration of the supplied block
+          end
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message)
+        end
+
+        it ':metric' do
+          metric_name = '/my/custom/metric'
+          assert_equal 'result', @logger.send(measure_level, message: 'hello world', metric: metric_name) { 'result' } # Measure duration of the supplied block
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+          assert metric_name, $last_metric.metric
+        end
+
+        it ':backtrace_level' do
+          SemanticLogger.stub(:backtrace_level_index, 0) do
+            assert_equal 'result', @logger.send(measure_level, message: 'hello world') { 'result' }
+            SemanticLogger.flush
+            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+          end
+        end
+      end
+
+    end
+
+    describe 'return' do
+      it 'log when the block performs a return' do
+        assert_equal 'Good', function_with_return(@logger)
+        SemanticLogger.flush
+        assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message)
+      end
+    end
+
+    describe ':silence' do
+      it 'silences messages' do
+        SemanticLogger.default_level = :info
+        @logger.measure_info('hello world', silence: :error) do
+          @logger.warn "don't log me"
+        end
+        SemanticLogger.flush
+        assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+      end
+
+      it 'does not silence higer level messages' do
+        SemanticLogger.default_level = :info
+        first_message                = nil
+        @logger.measure_info('hello world', silence: :trace) do
+          @logger.debug('hello world', @hash) { 'Calculations' }
+          SemanticLogger.flush
+          first_message = @mock_logger.message
+        end
+        assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, first_message)
+        SemanticLogger.flush
+        # Only the last log message is kept in mock logger
+        assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message)
+      end
+    end
+
+    # Make sure that measure still logs when a block uses return to return from
+    # a function
+    def function_with_return(logger)
+      logger.measure_info('hello world', payload: @hash) do
+        return 'Good'
+      end
+      'Bad'
+    end
+
+  end
+end

data/test/semantic_logger_test.rb

@@ -0,0 +1,257 @@
+require_relative 'test_helper'
+
+class SemanticLoggerTest < Minitest::Test
+  describe SemanticLogger do
+    describe '.add_appender' do
+      before do
+        @appender = nil
+      end
+
+      after do
+        SemanticLogger.remove_appender(@appender)
+        File.delete('sample.log') if File.exist?('sample.log')
+      end
+
+      it 'adds file appender' do
+        @appender = SemanticLogger.add_appender(file_name: 'sample.log')
+        assert @appender.is_a?(SemanticLogger::Appender::File)
+        assert SemanticLogger.appenders.include?(@appender)
+        assert @appender.formatter.is_a?(SemanticLogger::Formatters::Default)
+      end
+
+      it 'adds file appender with json format' do
+        @appender = SemanticLogger.add_appender(file_name: 'sample.log', formatter: :json)
+        assert @appender.is_a?(SemanticLogger::Appender::File)
+        assert SemanticLogger.appenders.include?(@appender)
+        assert @appender.formatter.is_a?(SemanticLogger::Formatters::Json)
+      end
+
+      it 'adds stream appender' do
+        @appender = SemanticLogger.add_appender(io: STDOUT)
+        assert @appender.is_a?(SemanticLogger::Appender::File)
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds symbol appender' do
+        @appender = SemanticLogger.add_appender(appender: :wrapper, logger: Logger.new(STDOUT))
+        assert @appender.is_a?(SemanticLogger::Appender::Wrapper), -> { @appender.ai }
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds symbol appender with underscores' do
+        @appender = SemanticLogger.add_appender(appender: :new_relic)
+        assert @appender.is_a?(SemanticLogger::Appender::NewRelic), -> { @appender.ai }
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds logger wrapper appender' do
+        @appender = SemanticLogger.add_appender(logger: ::Logger.new(STDOUT))
+        assert @appender.is_a?(SemanticLogger::Appender::Wrapper)
+        assert @appender.logger.is_a?(::Logger)
+        assert SemanticLogger.appenders.include?(@appender)
+        assert @appender.formatter.is_a?(SemanticLogger::Formatters::Default)
+      end
+
+      it 'adds logger wrapper appender with color formatter' do
+        @appender = SemanticLogger.add_appender(logger: ::Logger.new(STDOUT), formatter: :color)
+        assert @appender.is_a?(SemanticLogger::Appender::Wrapper)
+        assert @appender.logger.is_a?(::Logger)
+        assert SemanticLogger.appenders.include?(@appender)
+        assert @appender.formatter.is_a?(SemanticLogger::Formatters::Color)
+      end
+
+      it 'adds appender' do
+        @appender = SemanticLogger.add_appender(appender: SemanticLogger::Appender::File.new(io: STDOUT))
+        assert @appender.is_a?(SemanticLogger::Appender::File), @appender.ai
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'fails to add invalid logger appender' do
+        assert_raises do
+          SemanticLogger.add_appender(logger: 'blah')
+        end
+      end
+    end
+
+    describe '.add_appender DEPRECATED' do
+      before do
+        @appender = nil
+      end
+
+      after do
+        SemanticLogger.remove_appender(@appender) if @appender
+        File.delete('sample.log') if File.exist?('sample.log')
+      end
+
+      it 'adds file appender' do
+        @appender = SemanticLogger.add_appender('sample.log')
+        assert @appender.is_a?(SemanticLogger::Appender::File)
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds stream appender' do
+        @appender = SemanticLogger.add_appender(STDOUT)
+        assert @appender.is_a?(SemanticLogger::Appender::File)
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds appender' do
+        @appender = SemanticLogger.add_appender(SemanticLogger::Appender::File.new(io: STDOUT))
+        assert @appender.is_a?(SemanticLogger::Appender::File), @appender.ai
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds logger wrapper appender' do
+        @appender = SemanticLogger.add_appender(::Logger.new(STDOUT))
+        assert @appender.is_a?(SemanticLogger::Appender::Wrapper)
+        assert @appender.logger.is_a?(::Logger)
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'fails to add invalid logger appender' do
+        assert_raises do
+          SemanticLogger.add_appender(logger: 'blah')
+        end
+      end
+    end
+
+    describe 'mock_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
+      end
+
+      after do
+        SemanticLogger.remove_appender(@appender)
+      end
+
+      describe '.tagged' do
+        it 'add tags to log entries' do
+          SemanticLogger.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)
+          end
+        end
+
+        it 'add embedded tags to log entries' do
+          SemanticLogger.tagged('First Level', 'tags') do
+            SemanticLogger.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)
+            end
+            assert_equal 2, SemanticLogger.tags.count, SemanticLogger.tags
+            assert_equal 'First Level', SemanticLogger.tags.first
+            assert_equal 'tags', SemanticLogger.tags.last
+          end
+        end
+      end
+
+      describe '.named_tagged' do
+        it 'logs named tags' do
+          SemanticLogger.named_tagged(tracking_number: '123456') do
+            SemanticLogger.named_tagged(even: 2, more: 'data') do
+              @logger.info('Hello world')
+              SemanticLogger.flush
+              assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \[even: 2\] \[more: data\] \[tracking_number: 123456\] LoggerTest -- Hello world/, @mock_logger.message)
+            end
+          end
+        end
+      end
+
+      describe '.fast_tag' do
+        it 'add string tag to log entries' do
+          @logger.fast_tag('12345') do
+            @logger.info('Hello world')
+            SemanticLogger.flush
+            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \[12345\] LoggerTest -- Hello world/, @mock_logger.message)
+          end
+        end
+      end
+
+      describe '.default_level' do
+        before do
+          SemanticLogger.default_level = :debug
+        end
+
+        it 'not log at a level below the global default' do
+          assert_equal :debug, SemanticLogger.default_level
+          assert_equal :debug, @logger.level
+          @logger.trace('hello world', @hash) { 'Calculations' }
+          SemanticLogger.flush
+          assert_nil @mock_logger.message
+        end
+
+        it 'log at the instance level' do
+          assert_equal :debug, SemanticLogger.default_level
+          @logger.level = :trace
+          assert_equal :trace, @logger.level
+          @logger.trace('hello world', @hash) { 'Calculations' }
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:#{@thread_name}\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
+        end
+
+        it 'not log at a level below the instance level' do
+          assert_equal :debug, SemanticLogger.default_level
+          @logger.level = :warn
+          assert_equal :warn, @logger.level
+          @logger.debug('hello world', @hash) { 'Calculations' }
+          SemanticLogger.flush
+          assert_nil @mock_logger.message
+        end
+      end
+
+      describe '.silence' do
+        before do
+          SemanticLogger.default_level = :info
+        end
+
+        it 'not log at a level below the silence level' do
+          assert_equal :info, SemanticLogger.default_level
+          assert_equal :info, @logger.level
+          @logger.silence do
+            @logger.warn('hello world', @hash) { 'Calculations' }
+            @logger.info('hello world', @hash) { 'Calculations' }
+            @logger.debug('hello world', @hash) { 'Calculations' }
+            @logger.trace('hello world', @hash) { 'Calculations' }
+          end
+          SemanticLogger.flush
+          assert_nil @mock_logger.message
+        end
+
+        it 'log at the instance level even with the silencer at a higher level' do
+          @logger.level = :trace
+          assert_equal :trace, @logger.level
+          @logger.silence do
+            @logger.trace('hello world', @hash) { 'Calculations' }
+          end
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:#{@thread_name}\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
+        end
+
+        it 'log at a silence level below the default level' do
+          assert_equal :info, SemanticLogger.default_level
+          assert_equal :info, @logger.level
+          @logger.silence(:debug) do
+            @logger.debug('hello world', @hash) { 'Calculations' }
+          end
+          SemanticLogger.flush
+          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
+        end
+      end
+
+    end
+
+  end
+end