semantic_logger 4.3.1 → 4.4.0

data/test/appender/graylog_test.rb

@@ -1,82 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Graylog
-module Appender
-  class GraylogTest < Minitest::Test
-    describe SemanticLogger::Appender::Graylog do
-      before do
-        @appender = SemanticLogger::Appender::Graylog.new(level: :info)
-        @message  = 'AppenderGraylogTest log message'
-      end
-
-      (SemanticLogger::LEVELS - %i[info warn error fatal]).each do |level|
-        it "not send :#{level} notifications to Graylog" do
-          hash = nil
-          @appender.notifier.stub(:notify!, ->(h) { hash = h }) do
-            @appender.send(level, "AppenderGraylogTest #{level} message")
-          end
-          assert_nil hash
-        end
-      end
-
-      it 'send exception notifications to Graylog with severity' do
-        hash = nil
-        exc  = nil
-        begin
-          Uh oh
-        rescue Exception => e
-          exc = e
-        end
-        @appender.notifier.stub(:notify!, ->(h) { hash = h }) do
-          @appender.error 'Reading File', exc
-        end
-        assert_equal 'Reading File', hash[:short_message]
-        assert_equal 'NameError', hash[:exception][:name]
-        assert_match 'undefined local variable or method', hash[:exception][:message]
-        assert_equal 3, hash[:level], 'Should be error level (3)'
-        assert hash[:exception][:stack_trace].first.include?(__FILE__), hash[:exception]
-      end
-
-      it 'send exception notifications to Graylog without log message' do
-        hash = nil
-        exc  = nil
-        begin
-          raise StandardError, 'Reading File'
-        rescue Exception => e
-          exc = e
-        end
-        @appender.notifier.stub(:notify!, ->(h) { hash = h }) do
-          @appender.error exc
-        end
-        assert_equal exc.message, hash[:short_message]
-        assert_equal exc.class.to_s, hash[:exception][:name]
-        assert_match exc.message, hash[:exception][:message]
-        assert_equal 3, hash[:level], 'Should be error level (3)'
-        assert hash[:exception][:stack_trace].first.include?(__FILE__), hash[:exception]
-      end
-
-      it 'send error notifications to Graylog with severity' do
-        hash = nil
-        @appender.notifier.stub(:notify!, ->(h) { hash = h }) do
-          @appender.error @message
-        end
-        assert_equal @message, hash[:short_message]
-        assert_equal 3, hash[:level]
-        refute hash[:stack_trace]
-      end
-
-      it 'send notification to Graylog with custom attributes' do
-        hash = nil
-        @appender.notifier.stub(:notify!, ->(h) { hash = h }) do
-          @appender.error @message, key1: 1, key2: 'a'
-        end
-        assert_equal @message, hash[:short_message]
-        assert_equal 3, hash[:level]
-        refute hash[:stack_trace]
-        assert payload = hash[:payload], hash
-        assert_equal 1, payload[:key1], payload
-        assert_equal 'a', payload[:key2], payload
-      end
-    end
-  end
-end

data/test/appender/honeybadger_test.rb

@@ -1,45 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Bugsnag
-module Appender
-  class HoneybadgerTest < Minitest::Test
-    describe SemanticLogger::Appender::Honeybadger do
-      before do
-        @appender                      = SemanticLogger::Appender::Honeybadger.new(level: :trace)
-        @message                       = 'AppenderHoneybadgerTest log message'
-        SemanticLogger.backtrace_level = :error
-      end
-
-      SemanticLogger::LEVELS.each do |level|
-        it "sends #{level} message" do
-          hash = nil
-          Honeybadger.stub(:notify, ->(h) { hash = h }) do
-            @appender.send(level, @message)
-          end
-          assert_equal @message, hash[:error_message]
-          assert_equal 'SemanticLogger::Appender::Honeybadger', hash[:error_class]
-
-          if %i[error fatal].include?(level)
-            assert hash.key?(:backtrace)
-          else
-            refute hash.key?(:backtrace)
-          end
-          assert_equal true, hash.key?(:context)
-          assert_equal level, hash[:context][:level]
-        end
-
-        it "sends #{level} exceptions" do
-          error     = RuntimeError.new('Oh no, Error.')
-          exception = hash = nil
-          Honeybadger.stub(:notify, ->(exc, h) { exception = exc; hash = h }) do
-            @appender.send(level, @message, error)
-          end
-
-          assert_equal error.class.to_s, exception.class.to_s
-          assert_equal error.message, exception.message
-          assert_equal @message, hash[:message], hash
-        end
-      end
-    end
-  end
-end

data/test/appender/http_test.rb

@@ -1,63 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Http
-module Appender
-  class HttpTest < Minitest::Test
-    response_mock = Struct.new(:code, :body)
-
-    describe SemanticLogger::Appender::Http do
-      before do
-        Net::HTTP.stub_any_instance(:start, true) do
-          @appender = SemanticLogger::Appender::Http.new(url: 'http://localhost:8088/path')
-        end
-        @message = 'AppenderHttpTest log message'
-      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
-          hash = JSON.parse(request.body)
-          assert_equal @message, hash['message']
-          assert_equal level.to_s, hash['level']
-          refute hash['stack_trace']
-        end
-
-        it "send #{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 'Reading File', hash['message']
-          assert 'NameError', hash['exception']['name']
-          assert 'undefined local variable or method', hash['exception']['message']
-          assert_equal level.to_s, hash['level'], 'Should be error level (3)'
-          assert hash['exception']['stack_trace'].first.include?(__FILE__), hash['exception']
-        end
-
-        it "send #{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
-          hash = JSON.parse(request.body)
-          assert_equal @message, hash['message']
-          assert_equal level.to_s, hash['level']
-          refute hash['stack_trace']
-          assert payload = hash['payload'], hash
-          assert_equal 1, payload['key1'], payload
-          assert_equal 'a', payload['key2'], payload
-        end
-      end
-    end
-  end
-end

data/test/appender/kafka_test.rb

@@ -1,35 +0,0 @@
-require_relative '../test_helper'
-
-module Appender
-  class KafkaTest < Minitest::Test
-    describe SemanticLogger::Appender::Kafka do
-      before do
-        @appender = SemanticLogger::Appender::Kafka.new(
-          seed_brokers: ['localhost:9092']
-        )
-        @message  = 'AppenderKafkaTest log message'
-      end
-
-      after do
-        @appender&.close
-      end
-
-      it 'sends log messages in JSON format' do
-        message = nil
-        options = nil
-        ::Kafka::Producer.stub_any_instance(:produce, ->(value, **opts) { message = value; options = opts }) do
-          @appender.info(@message)
-          @appender.flush
-        end
-
-        h = JSON.parse(message)
-        assert_equal 'info', h['level']
-        assert_equal @message, h['message']
-        assert_equal 'SemanticLogger::Appender::Kafka', h['name']
-        assert_equal $$, h['pid']
-
-        assert_equal 'log_messages', options[:topic]
-      end
-    end
-  end
-end

data/test/appender/mongodb_test.rb

@@ -1,104 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::MongoDB
-module Appender
-  class MongoDBTest < Minitest::Test
-    describe SemanticLogger::Appender::MongoDB do
-      before do
-        @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
-        )
-        @hash               = {tracking_number: 12_345, session_id: 'HSSKLEU@JDK767'}
-        Thread.current.name = 'thread'
-      end
-
-      after do
-        @appender&.purge_all
-      end
-
-      describe 'format logs into documents' do
-        it 'handle no arguments' do
-          @appender.debug
-          document = @appender.collection.find.first
-          assert_equal :debug, document['level']
-          assert_nil document['message']
-          assert_equal 'thread', document['thread']
-          assert document['time'].is_a?(Time)
-          assert_nil document['payload']
-          assert_equal $$, document['pid']
-          assert_equal 'test', document['host']
-          assert_equal 'test_application', document['application']
-        end
-
-        it 'handle named parameters' do
-          @appender.debug(payload: @hash)
-
-          document = @appender.collection.find.first
-          assert_equal :debug, document['level']
-          assert_nil document['message']
-          assert_equal 'thread', document['thread']
-          assert document['time'].is_a?(Time)
-          assert payload = document['payload']
-          assert_equal 12_345, payload['tracking_number'], payload
-          assert_equal 'HSSKLEU@JDK767', payload['session_id']
-          assert_equal $$, document['pid']
-          assert_equal 'test', document['host']
-          assert_equal 'test_application', document['application']
-        end
-
-        it 'handle message and payload' do
-          @appender.debug('hello world', @hash)
-
-          document = @appender.collection.find.first
-          assert_equal :debug, document['level']
-          assert_equal 'hello world', document['message']
-          assert_equal 'thread', document['thread']
-          assert document['time'].is_a?(Time)
-          assert payload = document['payload']
-          assert_equal 12_345, payload['tracking_number'], payload
-          assert_equal 'HSSKLEU@JDK767', payload['session_id']
-          assert_equal $$, document['pid']
-          assert_equal 'test', document['host']
-          assert_equal 'test_application', document['application']
-        end
-
-        it 'handle message without payload' do
-          @appender.debug('hello world')
-
-          document = @appender.collection.find.first
-          assert_equal :debug, document['level']
-          assert_equal 'hello world', document['message']
-          assert_equal 'thread', document['thread']
-          assert document['time'].is_a?(Time)
-          assert_equal $$, document['pid']
-          assert_equal 'test', document['host']
-          assert_equal 'test_application', document['application']
-        end
-      end
-
-      # Ensure that any log level can be logged
-      SemanticLogger::LEVELS.each do |level|
-        describe "##{level}" do
-          it 'logs' do
-            @appender.send(level, 'hello world -- Calculations', @hash)
-            document = @appender.collection.find.first
-            assert_equal level, document['level']
-            assert_equal 'hello world -- Calculations', document['message']
-            assert_equal 'thread', document['thread']
-            assert document['time'].is_a?(Time)
-            assert payload = document['payload']
-            assert_equal 12_345, payload['tracking_number'], payload
-            assert_equal 'HSSKLEU@JDK767', payload['session_id']
-            assert_equal $$, document['pid']
-            assert_equal 'test', document['host'], document.ai
-            assert_equal 'test_application', document['application']
-          end
-        end
-      end
-    end
-  end
-end

data/test/appender/new_relic_test.rb

@@ -1,80 +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 Appender
-  class NewRelicTest < Minitest::Test
-    describe SemanticLogger::Appender::NewRelic do
-      before do
-        @appender = SemanticLogger::Appender::NewRelic.new
-        @message  = 'AppenderNewRelicTest log message'
-      end
-
-      (SemanticLogger::LEVELS - %i[error fatal]).each do |level|
-        it "does not send :#{level} notifications to New Relic" do
-          exception = hash = nil
-          NewRelic::Agent.stub(:notice_error, ->(exc, h) { exception = exc; hash = h }) do
-            @appender.tagged('test') do
-              @appender.send(level, "AppenderNewRelicTest #{level} message")
-            end
-          end
-          assert_nil exception
-          assert_nil hash
-        end
-      end
-
-      %i[error fatal].each do |level|
-        it "sends :#{level} notifications to New Relic" do
-          exception = hash = nil
-          NewRelic::Agent.stub(:notice_error, ->(exc, h) { exception = exc; hash = h }) do
-            @appender.tagged('test') do
-              @appender.send(level, @message)
-            end
-          end
-          assert_equal 'RuntimeError', exception.class.to_s
-          assert_equal @message, exception.message
-          assert_equal ['test'], hash[:custom_params][:tags]
-          assert_nil hash[:custom_params][:duration]
-          assert hash[:custom_params][:thread], hash.inspect
-        end
-      end
-
-      it 'send notification to New Relic with custom attributes' do
-        exception = hash = nil
-        NewRelic::Agent.stub(:notice_error, ->(exc, h) { exception = exc; hash = h }) do
-          SemanticLogger.tagged('test') do
-            SemanticLogger.named_tagged(key1: 1, key2: 'a') do
-              @appender.measure_error(message: @message, payload: {key3: 4}) do
-                sleep 0.001
-              end
-            end
-          end
-        end
-        assert_equal 'RuntimeError', exception.class.to_s
-        assert_equal @message, exception.message
-        assert params = hash[:custom_params], hash
-        assert params[:duration], params
-        assert params[:thread], params
-
-        assert_equal ['test'], params[:tags], params
-
-        assert named_tags = params[:named_tags], params
-        assert_equal 1, named_tags[:key1], named_tags
-        assert_equal 'a', named_tags[:key2], named_tags
-
-        assert payload = params[:payload], params
-        assert_equal 4, payload[:key3], payload
-      end
-
-      it 'does not send metric only notifications' do
-        exception = hash = nil
-        NewRelic::Agent.stub(:notice_error, ->(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

data/test/appender/newrelic_rpm.rb

@@ -1,14 +0,0 @@
-# Mocked NewRelic::Agent used for testing
-
-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

@@ -1,47 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Sentry
-module Appender
-  class SentryTest < Minitest::Test
-    describe SemanticLogger::Appender::Sentry do
-      before do
-        @appender                      = SemanticLogger::Appender::Sentry.new(level: :trace)
-        @message                       = 'AppenderRavenTest log message'
-        SemanticLogger.backtrace_level = :error
-      end
-
-      SemanticLogger::LEVELS.each do |level|
-        it "sends #{level} message" do
-          error_message = hash = nil
-          Raven.stub(:capture_message, ->(msg, h) { error_message = msg; hash = h }) do
-            @appender.send(level, @message)
-          end
-          assert_equal @message, error_message
-          assert_equal 'SemanticLogger::Appender::Sentry', hash[:extra][:name]
-
-          if %i[error fatal].include?(level)
-            assert hash[:extra].key?(:backtrace)
-          else
-            refute hash[:extra].key?(:backtrace)
-          end
-          assert_equal true, hash.key?(:extra)
-          assert_equal level, hash[:level]
-        end
-
-        it "sends #{level} exceptions" do
-          error     = RuntimeError.new('Oh no, Error.')
-          exception = hash = nil
-          Raven.stub(:capture_exception, ->(exc, h) { exception = exc; hash = h }) do
-            @appender.send(level, @message, error)
-          end
-
-          assert_equal error.class.to_s, exception.class.to_s
-          assert_equal error.message, exception.message
-          assert_equal true, hash.key?(:extra)
-          assert_equal @message, hash[:extra][:message], hash
-          assert_equal level, hash[:level]
-        end
-      end
-    end
-  end
-end