semantic_logger 4.3.1 → 4.4.0

data/test/metric/new_relic_test.rb

@@ -1,35 +0,0 @@
-# So that the NewRelic appender will load the mock
-$LOAD_PATH.unshift File.dirname(__FILE__)
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::NewRelic
-module Metric
-  class NewRelicTest < Minitest::Test
-    describe SemanticLogger::Appender::NewRelic do
-      before do
-        @appender = SemanticLogger::Metric::NewRelic.new
-        @message  = 'AppenderNewRelicTest log message'
-      end
-
-      it 'logs counter metric' do
-        name = amount = nil
-        NewRelic::Agent.stub(:increment_metric, ->(name_, amount_) { name = name_, amount = amount_ }) do
-          @appender.info(message: @message, metric: 'User/authenticated')
-        end
-        assert_equal 'Custom/User/authenticated', name.first
-        assert_equal 1, amount
-      end
-
-      it 'logs duration metric' do
-        name = duration = nil
-        NewRelic::Agent.stub(:record_metric, ->(name_, duration_) { name = name_, duration = duration_ }) do
-          @appender.measure_info(message: @message, metric: 'User/authenticate') do
-            sleep 0.001
-          end
-        end
-        assert_equal 'Custom/User/authenticate', name.first
-        assert duration
-      end
-    end
-  end
-end

data/test/metric/signalfx_test.rb

@@ -1,77 +0,0 @@
-require_relative '../test_helper'
-
-module Appender
-  class SignalfxTest < Minitest::Test
-    describe SemanticLogger::Metric::Signalfx do
-      before do
-        @metric     = '/user/login'
-        @log        = SemanticLogger::Log.new('User', :debug)
-        @log.metric = @metric
-      end
-
-      let :appender do
-        if ENV['SIGNALFX_TOKEN']
-          SemanticLogger::Metric::Signalfx.new(token: ENV['SIGNALFX_TOKEN'])
-        else
-          Net::HTTP.stub_any_instance(:start, true) do
-            @appender = SemanticLogger::Metric::Signalfx.new(token: 'TEST')
-          end
-        end
-      end
-
-      describe 'log message' do
-        let :response do
-          # Do not stub if the token is available in the environment
-          if ENV['SIGNALFX_TOKEN']
-            appender.log(@log)
-          else
-            response_mock = Struct.new(:code, :body)
-            request       = nil
-            appender.http.stub(:request, ->(r) { request = r; response_mock.new('200', 'ok') }) do
-              appender.log(@log)
-            end
-          end
-        end
-
-        it 'send counter metric when there is no duration' do
-          assert response
-        end
-
-        it 'send custom counter metric when there is no duration' do
-          @log.metric     = 'Filter/count'
-          @log.dimensions = {action: 'hit', user: 'jbloggs', state: 'FL'}
-          assert response
-        end
-
-        it 'send gauge metric when log includes duration' do
-          @log.duration = 1234
-          assert response
-        end
-
-        it 'whitelists dimensions' do
-          @log.named_tags               = {user_id: 47, application: 'sample', tracking_number: 7474, session_id: 'hsdhngsd'}
-          appender.formatter.dimensions = %i[user_id application]
-          assert response
-        end
-      end
-
-      describe 'should_log?' do
-        it 'logs metric only metric' do
-          assert appender.should_log?(@log)
-        end
-
-        it 'not logs when no metric' do
-          @log.message = 'blah'
-          @log.metric  = nil
-          refute appender.should_log?(@log)
-        end
-
-        it 'logs metric only metric with dimensions' do
-          @log.metric     = 'Filter/count'
-          @log.dimensions = {action: 'hit', user: 'jbloggs', state: 'FL'}
-          assert appender.should_log?(@log)
-        end
-      end
-    end
-  end
-end

data/test/semantic_logger_test.rb

@@ -1,303 +0,0 @@
-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), @appender.formatter.inspect
-      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
-      include InMemoryAppenderHelper
-
-      describe '.tagged' do
-        it 'add tags to log entries' do
-          SemanticLogger.tagged('12345', 'DJHSFK') do
-            logger.info('Hello world')
-
-            assert log = log_message
-            assert_equal %w[12345 DJHSFK], log.tags
-          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')
-
-              assert log = log_message
-              assert_equal ['First Level', 'tags', 'Second Level'], log.tags
-            end
-            assert_equal 2, SemanticLogger.tags.count, SemanticLogger.tags
-            assert_equal 'First Level', SemanticLogger.tags.first
-            assert_equal 'tags', SemanticLogger.tags.last
-          end
-        end
-
-        it 'also supports named tagging' do
-          SemanticLogger.tagged(level1: 1) do
-            assert_equal({level1: 1}, SemanticLogger.named_tags)
-            SemanticLogger.tagged(level2: 2, more: 'data') do
-              assert_equal({level1: 1, level2: 2, more: 'data'}, SemanticLogger.named_tags)
-              SemanticLogger.tagged(level3: 3) do
-                assert_equal({level1: 1, level2: 2, more: 'data', level3: 3}, SemanticLogger.named_tags)
-              end
-            end
-          end
-        end
-      end
-
-      describe '.named_tags' do
-        it 'returns named tags in creation order' do
-          SemanticLogger.named_tagged(level1: 1) do
-            assert_equal({level1: 1}, SemanticLogger.named_tags)
-            SemanticLogger.named_tagged(level2: 2, more: 'data') do
-              assert_equal({level1: 1, level2: 2, more: 'data'}, SemanticLogger.named_tags)
-              SemanticLogger.named_tagged(level3: 3) do
-                assert_equal({level1: 1, level2: 2, more: 'data', level3: 3}, SemanticLogger.named_tags)
-              end
-            end
-          end
-        end
-      end
-
-      describe '.named_tagged' do
-        it 'logs named tags in creation order' do
-          SemanticLogger.named_tagged(level1: 1) do
-            SemanticLogger.named_tagged(level2: 2, more: 'data') do
-              SemanticLogger.named_tagged(level3: 3) do
-                logger.info('Hello world')
-
-                assert log = log_message
-                assert_equal({level1: 1, level2: 2, more: 'data', level3: 3}, log.named_tags)
-              end
-            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')
-
-            assert log = log_message
-            assert_equal %w[12345], log.tags
-          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')
-
-          refute log_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')
-
-          assert log = log_message
-          assert_equal :trace, log.level
-          assert_equal 'hello world', log.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')
-
-          refute log_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')
-            logger.info('hello world')
-            logger.debug('hello world')
-            logger.trace('hello world')
-          end
-
-          refute log_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')
-          end
-
-          assert log = log_message
-          assert_equal :trace, log.level
-          assert_equal 'hello world', log.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')
-          end
-
-          assert log = log_message
-          assert_equal :debug, log.level
-          assert_equal 'hello world', log.message
-        end
-      end
-
-      describe '.on_log' do
-        before do
-          SemanticLogger.default_level = :info
-        end
-
-        after do
-          SemanticLogger::Processor.instance.appender.log_subscribers = nil
-        end
-
-        it 'registers a log listener' do
-          SemanticLogger.on_log do |log|
-            log.set_context(:custom_info, 'test')
-          end
-
-          assert_equal :info, SemanticLogger.default_level
-          assert_equal :info, logger.level
-          logger.silence(:debug) do
-            logger.debug('hello world')
-          end
-
-          assert log = log_message
-          assert_equal :debug, log.level
-          assert_equal 'hello world', log.message
-          assert_equal 'test', log.context[:custom_info]
-        end
-      end
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,31 +0,0 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-
-# Configure Rails Environment
-ENV['RAILS_ENV'] = 'test'
-
-require 'minitest/autorun'
-require 'minitest/reporters'
-require 'minitest/stub_any_instance'
-require 'semantic_logger'
-# require 'logger'
-require_relative 'in_memory_appender'
-require_relative 'in_memory_batch_appender'
-require_relative 'in_memory_metrics_appender'
-require_relative 'in_memory_appender_helper'
-require 'awesome_print'
-
-# Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
-class Minitest::Test
-  # Use AwesomePrint to display diffs
-  define_method :mu_pp, &:awesome_inspect
-
-  # Use AwesomePrint to display messages
-  def message(msg = nil, ending = nil)
-    proc {
-      msg            = msg.call.chomp('.') if Proc === msg
-      custom_message = "#{msg.ai}.\n" unless msg.nil? || msg.to_s.empty?
-      "#{custom_message}#{yield}#{ending || '.'}"
-    }
-  end
-end