semantic_logger 4.1.1 → 4.2.0

data/test/appender/file_test.rb

@@ -7,14 +7,15 @@ module Appender
   class FileTest < Minitest::Test
     describe SemanticLogger::Appender::File do
       before do
-        SemanticLogger.default_level = :trace
-        @time                        = Time.new
-        @io                          = StringIO.new
-        @appender                    = SemanticLogger::Appender::File.new(io: @io)
-        @hash                        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
-        @hash_str                    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-        @thread_name                 = Thread.current.name
-        @file_name_reg_exp           = RUBY_VERSION.to_f <= 2.0 ? ' (mock|file_test).rb:\d+' : ' file_test.rb:\d+'
+        SemanticLogger.default_level   = :trace
+        SemanticLogger.backtrace_level = :error
+        @time                          = Time.new
+        @io                            = StringIO.new
+        @appender                      = SemanticLogger::Appender::File.new(io: @io)
+        @hash                          = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
+        @hash_str                      = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
+        @thread_name                   = Thread.current.name
+        @file_name_reg_exp             = RUBY_VERSION.to_f <= 2.0 ? ' (mock|file_test).rb:\d+' : ' file_test.rb:\d+'
       end
 
       describe 'format logs into text form' do

data/test/appender/mongodb_test.rb

@@ -8,9 +8,9 @@ module Appender
         @appender           = SemanticLogger::Appender::MongoDB.new(
           uri:             'mongodb://127.0.0.1:27017/test',
           collection_size: 10*1024**2, # 10MB
-          host:            'test',
-          application:     'test_application',
-          level:           :trace
+          host:        'test',
+          application: 'test_application',
+          level:       :trace
         )
         @hash               = {tracking_number: 12345, session_id: 'HSSKLEU@JDK767'}
         Thread.current.name = 'thread'

data/test/appender/newrelic_rpm.rb

@@ -4,5 +4,11 @@ module NewRelic
   module Agent
     def self.notice_error(message, hash)
     end
+
+    def self.record_metric(name, secoonds)
+    end
+
+    def self.increment_metric(name, count=1)
+    end
   end
 end

data/test/appender/sentry_test.rb

@@ -37,7 +37,9 @@ module Appender
 
           assert_equal error.class.to_s, exception.class.to_s
           assert_equal error.message, exception.message
-          assert_equal @message, hash[:message], hash
+          assert_equal true, hash.has_key?(:extra)
+          assert_equal @message, hash[:extra][:message], hash
+          assert_equal level, hash[:level]
         end
       end
 

data/test/appender/wrapper_test.rb

@@ -4,6 +4,35 @@ require_relative '../test_helper'
 #
 module Appender
   class WrapperTest < Minitest::Test
+    # Looks like a standard Ruby Logger or Rails Logger
+    # Except that it stores the last logged entry in the instance variable: message
+    class MockLogger
+      attr_accessor :message
+
+      Logger::Severity.constants.each do |level|
+        class_eval <<-EOT, __FILE__, __LINE__
+        def #{level.downcase}(message = nil, progname = nil)
+          if message
+            self.message = message
+          elsif block_given?
+            self.message = yield
+          else
+            self.message = progname
+          end
+          self.message
+        end
+
+        def #{level}?
+          @true
+        end
+        EOT
+      end
+
+      def flush
+        true
+      end
+    end
+
     describe SemanticLogger::Appender::Wrapper do
       before do
         SemanticLogger.default_level   = :trace

data/test/concerns/compatibility_test.rb

@@ -1,113 +1,117 @@
 require_relative '../test_helper'
 
-# Unit Test for SemanticLogger::Logger
-class CompatibilityTest < Minitest::Test
+class TestLogger < 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[CompatibilityTest]
-      @thread_name                   = Thread.current.name
-    end
-
-    after do
-      SemanticLogger.remove_appender(@appender)
-    end
+    include InMemoryAppenderHelper
 
     it '#add' do
-      @logger.add(Logger::INFO, 'hello world', 'progname') { 'Data' }
-      SemanticLogger.flush
-      assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] CompatibilityTest -- hello world -- Data -- \"progname\"/, @mock_logger.message)
+      logger.add(Logger::INFO, 'hello world', 'progname') { 'Data' }
+
+      assert log = log_message
+      assert_equal 'hello world -- progname -- Data', log.message
+      assert_equal :info, log.level
     end
 
     it '#log' do
-      @logger.log(Logger::FATAL, 'hello world', 'progname') { 'Data' }
-      SemanticLogger.flush
-      assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:#{@thread_name}\] CompatibilityTest -- hello world -- Data -- \"progname\"/, @mock_logger.message)
+      logger.log(Logger::FATAL, 'hello world', 'progname') { 'Data' }
+
+      assert log = log_message
+      assert_equal 'hello world -- progname -- Data', log.message
+      assert_equal :fatal, log.level
     end
 
     it '#unknown' do
-      @logger.unknown('hello world') { 'Data' }
-      SemanticLogger.flush
-      assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ E \[\d+:#{@thread_name}\] CompatibilityTest -- hello world -- Data/, @mock_logger.message)
+      logger.unknown('hello world') { 'Data' }
+
+      assert log = log_message
+      assert_equal 'hello world -- Data', log.message
+      assert_equal :error, log.level
+      assert_equal 'TestLogger', log.name
     end
 
     it '#unknown? as error?' do
       SemanticLogger.default_level = :error
-      assert @logger.unknown?
+      assert logger.unknown?
+      logger.log(Logger::UNKNOWN, 'hello world', 'progname') { 'Data' }
+
+      assert log = log_message
+      assert_equal 'hello world -- progname -- Data', log.message
+      assert_equal :error, log.level
     end
 
     it '#unknown? as error? when false' do
       SemanticLogger.default_level = :fatal
-      refute @logger.unknown?
+      refute logger.unknown?
+      logger.log(Logger::UNKNOWN, 'hello world', 'progname') { 'Data' }
+
+      refute log_message
     end
 
     it '#silence_logger' do
-      @logger.silence_logger do
-        @logger.info 'hello world'
+      logger.silence_logger do
+        logger.info 'hello world'
       end
-      SemanticLogger.flush
-      refute @mock_logger.message
+      refute log_message
     end
 
     it '#<< as info' do
-      @logger << 'hello world'
-      SemanticLogger.flush
-      assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] CompatibilityTest -- hello world/, @mock_logger.message)
+      logger << 'hello world'
+
+      assert log = log_message
+      assert_equal 'hello world', log.message
+      assert_equal :info, log.level
     end
 
     it '#progname= as #name=' do
-      assert_equal 'CompatibilityTest', @logger.name
-      @logger.progname = 'NewTest'
-      assert_equal 'NewTest', @logger.name
+      assert_equal 'TestLogger', logger.name
+      logger.progname = 'NewTest'
+      assert_equal 'NewTest', logger.name
     end
 
     it '#progname as #name' do
-      assert_equal 'CompatibilityTest', @logger.name
-      assert_equal 'CompatibilityTest', @logger.progname
+      assert_equal 'TestLogger', logger.name
+      assert_equal 'TestLogger', logger.progname
     end
 
     it '#sev_threshold= as #level=' do
-      assert_equal :trace, @logger.level
-      @logger.sev_threshold = Logger::DEBUG
-      assert_equal :debug, @logger.level
+      assert_equal :trace, logger.level
+      logger.sev_threshold = Logger::DEBUG
+      assert_equal :debug, logger.level
     end
 
     it '#sev_threshold as #level' do
-      assert_equal :trace, @logger.level
-      assert_equal :trace, @logger.sev_threshold
+      assert_equal :trace, logger.level
+      assert_equal :trace, logger.sev_threshold
     end
 
     it '#formatter NOOP' do
-      assert_nil @logger.formatter
-      @logger.formatter = 'blah'
-      assert_equal 'blah', @logger.formatter
+      assert_nil logger.formatter
+      logger.formatter = 'blah'
+      assert_equal 'blah', logger.formatter
     end
 
     it '#datetime_format NOOP' do
-      assert_nil @logger.datetime_format
-      @logger.datetime_format = 'blah'
-      assert_equal 'blah', @logger.datetime_format
+      assert_nil logger.datetime_format
+      logger.datetime_format = 'blah'
+      assert_equal 'blah', logger.datetime_format
     end
 
     it '#close NOOP' do
-      @logger.close
-      @logger.info('hello world') { 'Data' }
-      SemanticLogger.flush
-      assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] CompatibilityTest -- hello world -- Data/, @mock_logger.message)
+      logger.close
+      logger.info('hello world')
+
+      assert log = log_message
+      assert_equal 'hello world', log.message
+      assert_equal :info, log.level
     end
 
     it '#reopen NOOP' do
-      @logger.reopen
-      @logger.info('hello world') { 'Data' }
-      SemanticLogger.flush
-      assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] CompatibilityTest -- hello world -- Data/, @mock_logger.message)
+      logger.reopen
+      logger.info('hello world')
+
+      assert log = log_message
+      assert_equal 'hello world', log.message
+      assert_equal :info, log.level
     end
 
   end

data/test/debug_as_trace_logger_test.rb

@@ -1,95 +1,80 @@
 require_relative 'test_helper'
 
-# Unit Test for SemanticLogger::Logger
 class DebugAsTraceLoggerTest < Minitest::Test
   describe SemanticLogger::Logger do
-    # Test each filter
-    [nil, /\ADebugAsTraceLoggerTest/, Proc.new { |l| (/\AExclude/ =~ l.message).nil? }].each do |filter|
-      describe "filter: #{filter.class.name}" do
-        before do
-          # Use a mock logger that just keeps the last logged entry in an instance
-          # variable
-          SemanticLogger.default_level = :trace
-          @mock_logger                 = MockLogger.new
-          appender                     = SemanticLogger.add_appender(logger: @mock_logger)
-          appender.filter              = filter
+    describe '.level?' do
+      let :logger do
+        SemanticLogger::DebugAsTraceLogger.new('TestLogger')
+      end
 
-          # Use this test's class name as the application name in the log output
-          @logger                      = SemanticLogger::DebugAsTraceLogger.new(DebugAsTraceLoggerTest)
-          @hash                        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
-          @hash_str                    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-          assert_equal [], @logger.tags
-        end
+      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
 
-        after do
-          # Remove all appenders
-          SemanticLogger.appenders.each { |appender| SemanticLogger.remove_appender(appender) }
-        end
+      it 'return false for debug? with global :debug level' do
+        SemanticLogger.default_level = :debug
+        assert_equal :debug, logger.level, logger
+        assert logger.info?, logger.inspect
+        refute logger.debug?, logger.inspect
+        refute logger.trace?, logger.inspect
+      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 true for debug? with global :info level' do
+        SemanticLogger.default_level = :info
+        assert_equal :info, logger.level, logger.inspect
+        refute logger.debug?, logger.inspect
+        refute logger.trace?, logger.inspect
+      end
 
-          it 'return false for debug? with global :debug level' do
-            SemanticLogger.default_level = :debug
-            assert_equal :debug, @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
+        refute logger.debug?, logger.inspect
+        refute 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 true for debug? with instance :info level' do
+        logger.level = :info
+        assert_equal :info, logger.level, logger.inspect
+        refute logger.debug?, logger.inspect
+        refute logger.trace?, logger.inspect
+      end
+    end
 
-          it 'return false for debug? with instance :debug level' do
-            @logger.level = :debug
-            assert_equal :debug, @logger.level, @logger.inspect
-            assert_equal false, @logger.debug?, @logger.inspect
-            assert_equal false, @logger.trace?, @logger.inspect
-          end
+    describe 'log' do
+      include InMemoryAppenderHelper
 
-          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
+      let :logger do
+        SemanticLogger::DebugAsTraceLogger.new('TestLogger')
+      end
 
-        it 'not log trace when level is debug' do
-          @logger.level = :debug
-          @logger.trace('hello world', @hash) { 'Calculations' }
-          SemanticLogger.flush
-          assert_nil @mock_logger.message
-        end
+      it 'not log trace when level is debug' do
+        logger.level = :debug
+        logger.trace('hello world', payload) { 'Calculations' }
+        refute log_message
+      end
 
-        it 'not log debug when level is debug' do
-          @logger.level = :debug
-          @logger.debug('hello world', @hash) { 'Calculations' }
-          SemanticLogger.flush
-          assert_nil @mock_logger.message
-        end
+      it 'not log debug when level is debug' do
+        logger.level = :debug
+        logger.debug('hello world', payload) { 'Calculations' }
+        refute log_message
+      end
 
-        it 'map trace to debug' do
-          @logger.level = :trace
-          @logger.debug('hello world', @hash) { 'Calculations' }
-          SemanticLogger.flush
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] DebugAsTraceLoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
-        end
+      it 'map debug to trace' do
+        logger.level = :trace
+        logger.debug('hello world')
+        assert log = log_message
+        assert_equal :trace, log.level
+      end
 
-        it 'log trace as trace' do
-          @logger.level = :trace
-          @logger.trace('hello world', @hash) { 'Calculations' }
-          SemanticLogger.flush
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:.+\] DebugAsTraceLoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
-        end
+      it 'log trace as trace' do
+        logger.level = :trace
+        logger.trace('hello world', payload) { 'Calculations' }
+        assert log = log_message
+        assert_equal :trace, log.level
       end
     end
 

data/test/formatters/one_line_test.rb

@@ -0,0 +1,61 @@
+require_relative '../test_helper'
+
+module SemanticLogger
+  module Formatters
+    class DefaultTest < Minitest::Test
+      describe Default do
+        let(:log_time) do
+          Time.utc(2017, 1, 14, 8, 32, 5.375276)
+        end
+
+        let(:level) do
+          :debug
+        end
+
+        let(:log) do
+          log      = SemanticLogger::Log.new('DefaultTest', level)
+          log.time = log_time
+          log
+        end
+
+        let(:set_exception) do
+          begin
+            raise 'Oh no'
+          rescue Exception => exc
+            log.exception = exc
+          end
+        end
+
+        let(:formatter) do
+          formatter = SemanticLogger::Formatters::OneLine.new
+          # Does not use the logger instance for formatting purposes
+          formatter.call(log, nil)
+          formatter
+        end
+
+        describe 'message' do
+          it 'logs message' do
+            log.message = "Hello \nWorld\n"
+            assert_equal "-- Hello World", formatter.message
+          end
+
+          it 'skips empty message' do
+            refute formatter.message
+          end
+        end
+
+        describe 'exception' do
+          it 'logs exception' do
+            set_exception
+            assert_equal '-- Exception: RuntimeError: Oh no', formatter.exception
+          end
+
+          it 'skips nil exception' do
+            refute formatter.exception
+          end
+        end
+
+      end
+    end
+  end
+end