semantic_logger 4.3.1 → 4.4.0

data/test/logger_test.rb

@@ -1,334 +0,0 @@
-require_relative 'test_helper'
-
-# Unit Test for SemanticLogger::Logger
-class LoggerTest < Minitest::Test
-  describe SemanticLogger::Logger do
-    include InMemoryAppenderHelper
-
-    let :dimensions do
-      {action: 'hit', user: 'jbloggs', state: 'FL'}
-    end
-
-    # Complex filters
-    module ComplexFilter
-      def self.call(log)
-        (/\AExclude/ =~ log.message).nil?
-      end
-    end
-
-    # Ensure that any log level can be logged
-    SemanticLogger::LEVELS.each do |level|
-      describe "##{level}" do
-        describe 'positional parameter' do
-          it 'logs message' do
-            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' }
-
-            assert log = log_message
-            assert_equal 'hello world -- Calculations', log.message
-          end
-
-          it 'logs message and payload' do
-            logger.send(level, 'hello world', payload)
-
-            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', 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.positive?, 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)
-
-              assert log = log_message
-              assert_equal 'hello world', log.message
-              assert log.backtrace
-              assert log.backtrace.size.positive?, log.backtrace
-
-              assert log.exception
-              refute log.exception.backtrace
-              assert_equal 'RuntimeError', log.exception.class.name
-            end
-          end
-        end
-
-        describe 'keyword arguments' do
-          it 'logs message' do
-            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: 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: payload} }
-
-            assert log = log_message
-            assert_equal 'hello world', log.message
-            assert_equal payload, log.payload
-          end
-
-          it 'logs payload from block' do
-            logger.send(level) { {'test_key1' => 'hello world', 'test_key2' => payload} }
-
-            assert log = log_message
-            assert_equal log.payload, 'test_key1' => 'hello world', 'test_key2' => payload
-          end
-
-          it 'logs payload only' do
-            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: 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'})
-
-            refute log_message
-          end
-
-          it 'logs metric' do
-            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
-
-            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
-          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 'Module' do
-              appender.filter = ComplexFilter
-              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
-
-          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 'Module' do
-              logger.filter = ComplexFilter
-              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)
-          if level.to_s == 'UNKNOWN'
-            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)
-          end
-        end
-      end
-    end
-
-    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?
-      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
-      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
-      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
-      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
-      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')
-
-          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
-            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 ['First Level', 'tags'], logger.tags
-        end
-      end
-
-      it 'also supports named tagging' do
-        logger.tagged(level1: 1) do
-          assert_equal({level1: 1}, SemanticLogger.named_tags)
-          assert_equal({level1: 1}, logger.named_tags)
-          logger.tagged(level2: 2, more: 'data') do
-            assert_equal({level1: 1, level2: 2, more: 'data'}, SemanticLogger.named_tags)
-            assert_equal({level1: 1, level2: 2, more: 'data'}, logger.named_tags)
-            logger.tagged(level3: 3) do
-              assert_equal({level1: 1, level2: 2, more: 'data', level3: 3}, SemanticLogger.named_tags)
-              assert_equal({level1: 1, level2: 2, more: 'data', level3: 3}, logger.named_tags)
-            end
-          end
-        end
-      end
-
-      it 'is compatible with rails logging that uses arrays and nils' do
-        logger.tagged('', %w[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
-  end
-end

data/test/measure_test.rb

@@ -1,346 +0,0 @@
-require_relative 'test_helper'
-
-class MeasureTest < Minitest::Test
-  describe 'Measure' do
-    include InMemoryAppenderHelper
-
-    # Ensure that any log level can be measured and logged
-    SemanticLogger::LEVELS.each do |level|
-      measure_level = "measure_#{level}".to_sym
-
-      describe "##{measure_level}" do
-        it ':message' do
-          assert_equal 'result', logger.send(measure_level, 'hello world') { 'result' }
-
-          assert log = log_message
-          assert_equal 'hello world', log.message
-        end
-
-        it ':level' do
-          assert_equal 'result', logger.send(measure_level, 'hello world') { 'result' }
-
-          assert log = log_message
-          assert_equal level, log.level
-        end
-
-        it ':payload' do
-          assert_equal 'result', logger.send(measure_level, 'hello world', payload: payload) { 'result' }
-
-          assert log = log_message
-          assert_equal payload, log.payload
-        end
-
-        describe ':min_duration' do
-          it 'not log when faster' do
-            assert_equal 'result', logger.send(measure_level, 'hello world', min_duration: 2000) { 'result' }
-            refute log_message
-          end
-
-          it 'log when slower' do
-            assert_equal 'result', logger.send(measure_level, 'hello world', min_duration: 200, payload: payload) { sleep 0.5; 'result' }
-
-            assert log = log_message
-            assert_equal 'hello world', log.message
-          end
-        end
-
-        it ':exception' do
-          assert_raises RuntimeError do
-            logger.send(measure_level, 'hello world', payload: payload) { raise 'Test' }
-          end
-
-          assert log = log_message
-          refute log.exception
-          assert_equal 'hello world -- Exception: RuntimeError: Test', log.message
-          assert_equal level, log.level
-        end
-
-        it ':on_exception_level' do
-          assert_raises RuntimeError do
-            logger.measure(level, 'hello world', payload: payload, on_exception_level: :fatal) { raise 'Test' }
-          end
-
-          assert log = log_message
-          refute log.exception
-          assert_equal 'hello world -- Exception: RuntimeError: Test', log.message
-          assert_equal :fatal, log.level
-        end
-
-        describe 'log_exception' do
-          it 'default' do
-            assert_raises RuntimeError do
-              logger.send(measure_level, 'hello world') { raise 'Test' }
-            end
-
-            assert log = log_message
-            refute log.exception
-            assert_equal 'hello world -- Exception: RuntimeError: Test', log.message
-          end
-
-          it ':full' do
-            assert_raises RuntimeError do
-              logger.send(measure_level, 'hello world', log_exception: :full) { raise 'Test' }
-            end
-
-            assert log = log_message
-            assert log.exception.is_a?(RuntimeError)
-            assert log.exception.backtrace
-            assert_equal level, log.level
-            assert_equal 'hello world', log.message
-          end
-
-          it ':partial' do
-            assert_raises RuntimeError do
-              logger.send(measure_level, 'hello world', log_exception: :partial) { raise 'Test' }
-            end
-
-            assert log = log_message
-            refute log.exception
-            assert_equal 'hello world -- Exception: RuntimeError: Test', log.message
-          end
-
-          it ':none' do
-            assert_raises RuntimeError do
-              logger.send(measure_level, 'hello world', log_exception: :none) { raise 'Test' }
-            end
-
-            assert log = log_message
-            refute log.exception
-            assert_equal 'hello world', log.message
-          end
-        end
-
-        it ':metric' do
-          metric_name = '/my/custom/metric'
-          assert_equal 'result', logger.send(measure_level, 'hello world', metric: metric_name) { 'result' }
-
-          assert log = log_message
-          assert_equal metric_name, log.metric
-        end
-
-        it ':backtrace_level' do
-          SemanticLogger.stub(:backtrace_level_index, 0) do
-            assert_equal 'result', logger.send(measure_level, 'hello world') { 'result' }
-
-            assert log = log_message
-            assert log.backtrace
-            assert log.backtrace.size.positive?
-
-            # Extract file name and line number from backtrace
-            h = log.to_h
-            assert_match /measure_test.rb/, h[:file], h
-            assert h[:line].is_a?(Integer)
-          end
-        end
-      end
-
-      describe "#measure(#{level})" do
-        it ':message' do
-          assert_equal 'result', logger.measure(level, 'hello world') { 'result' }
-
-          assert log = log_message
-          assert_equal 'hello world', log.message
-        end
-
-        it ':level' do
-          assert_equal 'result', logger.measure(level, 'hello world') { 'result' }
-
-          assert log = log_message
-          assert_equal level, log.level
-        end
-
-        it ':payload' do
-          assert_equal 'result', logger.measure(level, 'hello world', payload: payload) { 'result' }
-
-          assert log = log_message
-          assert_equal payload, log.payload
-        end
-
-        describe ':min_duration' do
-          it 'not log when faster' do
-            assert_equal 'result', logger.measure(level, 'hello world', min_duration: 2000) { 'result' }
-            refute log_message
-          end
-
-          it 'log when slower' do
-            assert_equal 'result', logger.measure(level, 'hello world', min_duration: 200, payload: payload) { sleep 0.5; 'result' }
-            assert log = log_message
-            assert_equal 'hello world', log.message
-          end
-        end
-
-        it ':exception' do
-          assert_raises RuntimeError do
-            logger.measure(level, 'hello world', payload: payload) { raise 'Test' }
-          end
-
-          assert log = log_message
-          refute log.exception
-          assert_equal 'hello world -- Exception: RuntimeError: Test', log.message
-          assert_equal level, log.level
-        end
-
-        it ':on_exception_level' do
-          assert_raises RuntimeError do
-            logger.measure(level, 'hello world', payload: payload, on_exception_level: :fatal) { raise 'Test' }
-          end
-
-          assert log = log_message
-          refute log.exception
-          assert_equal 'hello world -- Exception: RuntimeError: Test', log.message
-          assert_equal :fatal, log.level
-        end
-
-        it ':metric' do
-          metric_name = '/my/custom/metric'
-          assert_equal 'result', logger.measure(level, 'hello world', metric: metric_name) { 'result' }
-
-          assert log = log_message
-          assert_equal metric_name, log.metric
-        end
-
-        it ':backtrace_level' do
-          SemanticLogger.stub(:backtrace_level_index, 0) do
-            assert_equal 'result', logger.measure(level, 'hello world') { 'result' }
-
-            assert log = log_message
-            assert log.backtrace
-            assert log.backtrace.size.positive?
-
-            # Extract file name and line number from backtrace
-            h = log.to_h
-            assert_match /measure_test.rb/, h[:file], h
-            assert h[:line].is_a?(Integer)
-          end
-        end
-      end
-
-      describe "##{measure_level} keyword arguments" do
-        it ':message' do
-          assert_equal 'result', logger.send(measure_level, message: 'hello world') { 'result' }
-
-          assert log = log_message
-          assert_equal 'hello world', log.message
-        end
-
-        it ':level' do
-          assert_equal 'result', logger.send(measure_level, message: 'hello world') { 'result' }
-
-          assert log = log_message
-          assert_equal level, log.level
-        end
-
-        it ':payload' do
-          assert_equal 'result', logger.send(measure_level, message: 'hello world', payload: payload) { 'result' }
-
-          assert log = log_message
-          assert_equal payload, log.payload
-        end
-
-        describe ':min_duration' do
-          it 'not log when faster' do
-            assert_equal 'result', logger.send(measure_level, message: 'hello world', min_duration: 2000) { 'result' }
-            refute log_message
-          end
-
-          it 'log when slower' do
-            assert_equal 'result', logger.send(measure_level, message: 'hello world', min_duration: 200, payload: payload) { sleep 0.5; 'result' }
-
-            assert log = log_message
-            assert_equal 'hello world', log.message
-          end
-        end
-
-        it ':exception' do
-          assert_raises RuntimeError do
-            logger.send(measure_level, message: 'hello world', payload: payload) { raise 'Test' }
-          end
-
-          assert log = log_message
-          refute log.exception
-          assert_equal 'hello world -- Exception: RuntimeError: Test', log.message
-          assert_equal level, log.level
-        end
-
-        it ':on_exception_level' do
-          assert_raises RuntimeError do
-            logger.send(measure_level, message: 'hello world', payload: payload, on_exception_level: :fatal) { raise 'Test' }
-          end
-
-          assert log = log_message
-          refute log.exception
-          assert_equal 'hello world -- Exception: RuntimeError: Test', log.message
-          assert_equal :fatal, log.level
-        end
-
-        it ':metric' do
-          metric_name = '/my/custom/metric'
-          assert_equal 'result', logger.send(measure_level, message: 'hello world', metric: metric_name) { 'result' }
-
-          assert log = log_message
-          assert_equal metric_name, log.metric
-        end
-
-        it ':backtrace_level' do
-          SemanticLogger.stub(:backtrace_level_index, 0) do
-            assert_equal 'result', logger.send(measure_level, message: 'hello world') { 'result' }
-
-            assert log = log_message
-            assert log.backtrace
-            assert log.backtrace.size.positive?
-
-            # Extract file name and line number from backtrace
-            h = log.to_h
-            assert_match /measure_test.rb/, h[:file], h
-            assert h[:line].is_a?(Integer)
-          end
-        end
-      end
-    end
-
-    describe 'return' do
-      it 'log when the block performs a return' do
-        assert_equal 'Good', function_with_return(logger)
-
-        assert log = log_message
-        assert_equal 'hello world', log.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
-
-        assert log = log_message
-        assert_equal 'hello world', log.message
-      end
-
-      it 'does not silence higher level messages' do
-        SemanticLogger.default_level = :info
-        first                        = nil
-        logger.measure_info('hello world', silence: :trace) do
-          logger.debug('hello world', payload) { 'Calculations' }
-          first = log_message
-        end
-        assert_equal 'hello world -- Calculations', first.message
-        assert_equal payload, first.payload
-
-        SemanticLogger.flush
-        assert log = appender.message
-        assert_equal 'hello world', log.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: payload) do
-        return 'Good'
-      end
-      'Bad'
-    end
-  end
-end