semantic_logger 4.3.1 → 4.4.0

data/test/appender/bugsnag_test.rb

@@ -1,81 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Bugsnag
-module Appender
-  class BugsnagTest < Minitest::Test
-    describe SemanticLogger::Appender::Bugsnag do
-      before do
-        @appender = SemanticLogger::Appender::Bugsnag.new(level: :info)
-        @message  = 'AppenderBugsnagTest log message'
-      end
-
-      SemanticLogger::LEVELS.each do |level|
-        it "sends #{level} message" do
-          bugsnag_level =
-            case level
-            when :warn
-              'warning'
-            when :fatal
-              'error'
-            else
-              level.to_s
-            end
-          exception     = hash = nil
-          Bugsnag.stub(:notify, ->(exc, h) { exception = exc; hash = h }) do
-            @appender.send(level, @message)
-          end
-          if %i[trace debug].include?(level)
-            assert_nil exception
-            assert_nil hash
-          else
-            assert_equal 'RuntimeError', exception.class.to_s
-            assert_equal @message, exception.message
-            assert_equal bugsnag_level.to_s, hash[:severity]
-          end
-        end
-
-        it "sends #{level} custom attributes" do
-          exception = hash = nil
-          Bugsnag.stub(:notify, ->(exc, h) { exception = exc; hash = h }) do
-            @appender.send(level, @message, key1: 1, key2: 'a')
-          end
-          if %i[trace debug].include?(level)
-            assert_nil exception
-            assert_nil hash
-          else
-            assert_equal 'RuntimeError', exception.class.to_s
-            assert_equal @message, exception.message
-            assert payload = hash[:payload], hash
-            assert_equal 1, payload[:key1], payload
-            assert_equal 'a', payload[:key2], payload
-          end
-        end
-
-        it "sends #{level} exceptions" do
-          error     = RuntimeError.new('Hello World')
-          exception = hash = nil
-          Bugsnag.stub(:notify, ->(exc, h) { exception = exc; hash = h }) do
-            @appender.send(level, @message, error)
-          end
-          if %i[trace debug].include?(level)
-            assert_nil exception
-            assert_nil hash
-          else
-            assert_equal error.class.to_s, exception.class.to_s
-            assert_equal error.message, exception.message
-            assert_equal @message, hash[:message], hash
-          end
-        end
-
-        it 'does not send metric only notifications' do
-          exception = hash = nil
-          Bugsnag.stub(:notify, ->(exc, h) { exception = exc; hash = h }) do
-            @appender.debug metric: 'my/custom/metric', payload: {hello: :world}
-          end
-          assert_nil exception
-          assert_nil hash
-        end
-      end
-    end
-  end
-end

data/test/appender/elasticsearch_http_test.rb

@@ -1,74 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Elasticsearch
-module Appender
-  class ElasticsearchHttpTest < Minitest::Test
-    response_mock = Struct.new(:code, :body)
-
-    describe SemanticLogger::Appender::ElasticsearchHttp do
-      before do
-        Net::HTTP.stub_any_instance(:start, true) do
-          @appender = SemanticLogger::Appender::ElasticsearchHttp.new(
-            url: 'http://localhost:9200'
-          )
-        end
-        @message = 'AppenderElasticsearchTest log message'
-      end
-
-      it 'logs to daily indexes' do
-        index = nil
-        @appender.stub(:post, ->(_json, ind) { index = ind }) do
-          @appender.info @message
-        end
-        assert_equal "/semantic_logger-#{Time.now.utc.strftime('%Y.%m.%d')}/log", index
-      end
-
-      SemanticLogger::LEVELS.each do |level|
-        it "send #{level}" do
-          request = nil
-          @appender.http.stub(:request, ->(r) { request = r; response_mock.new('200', 'ok') }) do
-            @appender.send(level, @message)
-          end
-          message = JSON.parse(request.body)
-          assert_equal @message, message['message']
-          assert_equal level.to_s, message['level']
-          refute message['exception']
-        end
-
-        it "sends #{level} exceptions" do
-          exc = nil
-          begin
-            Uh oh
-          rescue Exception => e
-            exc = e
-          end
-          request = nil
-          @appender.http.stub(:request, ->(r) { request = r; response_mock.new('200', 'ok') }) do
-            @appender.send(level, 'Reading File', exc)
-          end
-          hash = JSON.parse(request.body)
-          assert_equal 'Reading File', hash['message'], hash
-          assert exception = hash['exception']
-          assert_equal 'NameError', exception['name']
-          assert_match 'undefined local variable or method', exception['message']
-          assert_equal level.to_s, hash['level']
-          assert exception['stack_trace'].first.include?(__FILE__), exception
-        end
-
-        it "sends #{level} custom attributes" do
-          request = nil
-          @appender.http.stub(:request, ->(r) { request = r; response_mock.new('200', 'ok') }) do
-            @appender.send(level, @message, key1: 1, key2: 'a')
-          end
-          message = JSON.parse(request.body)
-          assert_equal @message, message['message']
-          assert_equal level.to_s, message['level']
-          refute message['stack_trace']
-          assert payload = message['payload'], message
-          assert_equal 1, payload['key1'], message
-          assert_equal 'a', payload['key2'], message
-        end
-      end
-    end
-  end
-end

data/test/appender/elasticsearch_test.rb

@@ -1,248 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Elasticsearch
-module Appender
-  class ElasticsearchTest < Minitest::Test
-    describe SemanticLogger::Appender::Elasticsearch do
-      describe 'providing a url' do
-        let :appender do
-          if ENV['ELASTICSEARCH']
-            SemanticLogger::Appender::Elasticsearch.new(url: 'http://localhost:9200')
-          else
-            Elasticsearch::Transport::Client.stub_any_instance(:bulk, true) do
-              SemanticLogger::Appender::Elasticsearch.new(url: 'http://localhost:9200')
-            end
-          end
-        end
-
-        let :log_message do
-          'AppenderElasticsearchTest log message'
-        end
-
-        let :log do
-          log         = SemanticLogger::Log.new('User', :info)
-          log.message = log_message
-          log
-        end
-
-        let :exception do
-          exc = nil
-          begin
-            Uh oh
-          rescue Exception => e
-            exc = e
-          end
-          exc
-        end
-
-        after do
-          appender.close
-        end
-
-        describe 'synchronous' do
-          it 'logs to daily indexes' do
-            bulk_index = nil
-            appender.stub(:write_to_elasticsearch, ->(messages) { bulk_index = messages.first }) do
-              appender.info log_message
-            end
-            index = bulk_index['index']['_index']
-            assert_equal "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}", index
-          end
-
-          it 'logs message' do
-            request = stub_client { appender.log(log) }
-
-            assert hash = request[:body][1]
-            assert_equal log_message, hash[:message]
-          end
-
-          it 'logs level' do
-            request = stub_client { appender.log(log) }
-
-            assert hash = request[:body][1]
-            assert_equal :info, hash[:level]
-          end
-
-          it 'logs exception' do
-            log.exception = exception
-            request       = stub_client { appender.log(log) }
-
-            assert hash = request[:body][1]
-            assert exception = hash[:exception]
-            assert_equal 'NameError', exception[:name]
-            assert_match 'undefined local variable or method', exception[:message]
-            assert exception[:stack_trace].first.include?(__FILE__), exception
-          end
-
-          it 'logs payload' do
-            h           = {key1: 1, key2: 'a'}
-            log.payload = h
-            request     = stub_client { appender.log(log) }
-
-            assert hash = request[:body][1]
-            refute hash[:stack_trace]
-            assert_equal h, hash[:payload], hash
-          end
-        end
-
-        describe 'async batch' do
-          it 'logs message' do
-            request = stub_client { appender.batch([log]) }
-
-            assert hash = request[:body][1]
-            assert_equal log_message, hash[:message]
-            assert_equal :info, hash[:level]
-          end
-
-          let :logs do
-            Array.new(3) do |i|
-              l         = log.dup
-              l.message = "hello world#{i + 1}"
-              l
-            end
-          end
-
-          it 'logs multiple messages' do
-            request = stub_client { appender.batch(logs) }
-
-            assert body = request[:body]
-            assert_equal 6, body.size, body
-
-            index = "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}"
-            assert_equal index, body[0]['index']['_index']
-            assert_equal 'hello world1', body[1][:message]
-            assert_equal index, body[2]['index']['_index']
-            assert_equal 'hello world2', body[3][:message]
-            assert_equal index, body[4]['index']['_index']
-            assert_equal 'hello world3', body[5][:message]
-          end
-        end
-
-        def stub_client(&block)
-          request = nil
-          appender.client.stub(:bulk, ->(r) { request = r; {'status' => 201} }, &block)
-          request
-        end
-      end
-
-      describe 'elasticsearch parameters' do
-        let :appender do
-          Elasticsearch::Transport::Client.stub_any_instance(:bulk, true) do
-            SemanticLogger::Appender::Elasticsearch.new(
-              hosts: [{host: 'localhost', port: 9200}]
-            )
-          end
-        end
-
-        let :log_message do
-          'AppenderElasticsearchTest log message'
-        end
-
-        let :log do
-          log         = SemanticLogger::Log.new('User', :info)
-          log.message = log_message
-          log
-        end
-
-        let :exception do
-          exc = nil
-          begin
-            Uh oh
-          rescue Exception => e
-            exc = e
-          end
-          exc
-        end
-
-        after do
-          appender.close
-        end
-
-        describe 'synchronous' do
-          it 'logs to daily indexes' do
-            bulk_index = nil
-            appender.stub(:write_to_elasticsearch, ->(messages) { bulk_index = messages.first }) do
-              appender.info log_message
-            end
-            index = bulk_index['index']['_index']
-            assert_equal "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}", index
-          end
-
-          it 'logs message' do
-            request = stub_client { appender.log(log) }
-
-            assert hash = request[:body][1]
-            assert_equal log_message, hash[:message]
-          end
-
-          it 'logs level' do
-            request = stub_client { appender.log(log) }
-
-            assert hash = request[:body][1]
-            assert_equal :info, hash[:level]
-          end
-
-          it 'logs exception' do
-            log.exception = exception
-            request       = stub_client { appender.log(log) }
-
-            assert hash = request[:body][1]
-            assert exception = hash[:exception]
-            assert_equal 'NameError', exception[:name]
-            assert_match 'undefined local variable or method', exception[:message]
-            assert exception[:stack_trace].first.include?(__FILE__), exception
-          end
-
-          it 'logs payload' do
-            h           = {key1: 1, key2: 'a'}
-            log.payload = h
-            request     = stub_client { appender.log(log) }
-
-            assert hash = request[:body][1]
-            refute hash[:stack_trace]
-            assert_equal h, hash[:payload], hash
-          end
-        end
-
-        describe 'async batch' do
-          it 'logs message' do
-            request = stub_client { appender.batch([log]) }
-
-            assert hash = request[:body][1]
-            assert_equal log_message, hash[:message]
-            assert_equal :info, hash[:level]
-          end
-
-          let :logs do
-            Array.new(3) do |i|
-              l         = log.dup
-              l.message = "hello world#{i + 1}"
-              l
-            end
-          end
-
-          it 'logs multiple messages' do
-            request = stub_client { appender.batch(logs) }
-
-            assert body = request[:body]
-            assert_equal 6, body.size, body
-
-            index = "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}"
-            assert_equal index, body[0]['index']['_index']
-            assert_equal 'hello world1', body[1][:message]
-            assert_equal index, body[2]['index']['_index']
-            assert_equal 'hello world2', body[3][:message]
-            assert_equal index, body[4]['index']['_index']
-            assert_equal 'hello world3', body[5][:message]
-          end
-        end
-
-        def stub_client(&block)
-          request = nil
-          appender.client.stub(:bulk, ->(r) { request = r; {'status' => 201} }, &block)
-          request
-        end
-      end
-    end
-  end
-end

data/test/appender/file_test.rb

@@ -1,120 +0,0 @@
-require_relative '../test_helper'
-require 'stringio'
-
-# Unit Test for SemanticLogger::Appender::File
-#
-module Appender
-  class FileTest < Minitest::Test
-    describe SemanticLogger::Appender::File do
-      before do
-        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: 12_345}
-        @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
-        it 'handle no message or payload' do
-          @appender.debug
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File\n/, @io.string)
-        end
-
-        it 'handle message' do
-          @appender.debug 'hello world'
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world\n/, @io.string)
-        end
-
-        it 'handle message and payload' do
-          @appender.debug 'hello world', @hash
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string)
-        end
-
-        it 'handle message, payload, and exception' do
-          @appender.debug 'hello world', @hash, StandardError.new('StandardError')
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str} -- Exception: StandardError: StandardError\n\n/, @io.string)
-        end
-
-        it 'logs exception with nil backtrace' do
-          @appender.debug StandardError.new('StandardError')
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- Exception: StandardError: StandardError\n\n/, @io.string)
-        end
-
-        it 'handle nested exception' do
-          begin
-            raise StandardError, 'FirstError'
-          rescue Exception
-            begin
-              raise StandardError, 'SecondError'
-            rescue Exception => e2
-              @appender.debug e2
-            end
-          end
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name} file_test.rb:\d+\] SemanticLogger::Appender::File -- Exception: StandardError: SecondError\n/, @io.string)
-          assert_match(/^Cause: StandardError: FirstError\n/, @io.string) if Exception.instance_methods.include?(:cause)
-        end
-
-        it 'logs exception with empty backtrace' do
-          exc = StandardError.new('StandardError')
-          exc.set_backtrace([])
-          @appender.debug exc
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- Exception: StandardError: StandardError\n\n/, @io.string)
-        end
-
-        it 'ignores metric only messages' do
-          @appender.debug metric: 'my/custom/metric'
-          assert_equal '', @io.string
-        end
-
-        it 'ignores metric only messages with payload' do
-          @appender.debug metric: 'my/custom/metric', payload: {hello: :world}
-          assert_equal '', @io.string
-        end
-      end
-
-      describe 'for each log level' do
-        # Ensure that any log level can be logged
-        SemanticLogger::LEVELS.each do |level|
-          it "log #{level} with file_name" do
-            SemanticLogger.stub(:backtrace_level_index, 0) do
-              @appender.send(level, 'hello world', @hash)
-              assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}#{@file_name_reg_exp}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string)
-            end
-          end
-
-          it "log #{level} without file_name" do
-            SemanticLogger.stub(:backtrace_level_index, 100) do
-              @appender.send(level, 'hello world', @hash)
-              assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string)
-            end
-          end
-        end
-      end
-
-      describe 'custom formatter' do
-        before do
-          @appender = SemanticLogger::Appender::File.new(io: @io) do |log|
-            tags = log.tags.collect { |tag| "[#{tag}]" }.join(' ') + ' ' if log.tags&.size&.positive?
-
-            message = log.message.to_s
-            message << ' -- ' << log.payload.inspect if log.payload
-            message << ' -- ' << "#{log.exception.class}: #{log.exception.message}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
-
-            duration_str = log.duration ? " (#{format('%.1f', log.duration)}ms)" : ''
-
-            "#{log.formatted_time} #{log.level.to_s.upcase} [#{$$}:#{log.thread_name}] #{tags}#{log.name} -- #{message}#{duration_str}"
-          end
-        end
-
-        it 'format using formatter' do
-          @appender.debug
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ DEBUG \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- \n/, @io.string)
-        end
-      end
-    end
-  end
-end