semantic_logger 4.3.1 → 4.4.0

data/test/appender/splunk_http_test.rb

@@ -1,79 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::SplunkHttp
-module Appender
-  class SplunkHttpTest < Minitest::Test
-    response_mock = Struct.new(:code, :body)
-
-    describe SemanticLogger::Appender::SplunkHttp do
-      before do
-        Net::HTTP.stub_any_instance(:start, true) do
-          @appender = SemanticLogger::Appender::SplunkHttp.new(
-            url:   'http://localhost:8088/path',
-            token: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
-          )
-        end
-        @message = 'AppenderSplunkHttpTest 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
-          body    = decompress_data(request.body)
-          message = JSON.parse(body)
-          assert_equal @message, message['event']['message']
-          assert_equal level.to_s, message['event']['level']
-          refute message['event']['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
-          body = decompress_data(request.body)
-          hash = JSON.parse(body)
-          assert 'Reading File', hash['message']
-          assert exception = hash['event']['exception']
-          assert 'NameError', exception['name']
-          assert 'undefined local variable or method', exception['message']
-          assert_equal level.to_s, hash['event']['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
-          body    = decompress_data(request.body)
-          message = JSON.parse(body)
-          assert event = message['event'], message.ai
-          assert_equal @message, event['message']
-          assert_equal level.to_s, event['level']
-          refute event['stack_trace']
-          assert payload = event['payload'], event
-          assert_equal(1, payload['key1'], message)
-          assert_equal('a', payload['key2'], message)
-        end
-      end
-
-      def decompress_data(data)
-        str = StringIO.new(data)
-        gz  = Zlib::GzipReader.new(str)
-        raw = gz.read
-        gz.close
-        raw
-      end
-    end
-  end
-end

data/test/appender/splunk_test.rb

@@ -1,83 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Splunk
-#
-module Appender
-  class SplunkTest < Minitest::Test
-    class Mock
-      attr_accessor :message, :event
-
-      def submit(message, event)
-        self.message = message
-        self.event   = event
-      end
-    end
-
-    describe SemanticLogger::Appender::Splunk do
-      before do
-        SemanticLogger::Appender::Splunk.stub_any_instance(:reopen, nil) do
-          @appender = SemanticLogger::Appender::Splunk.new
-        end
-        @message = 'AppenderSplunkTest log message'
-      end
-
-      SemanticLogger::LEVELS.each do |level|
-        it "send #{level}" do
-          mock = Mock.new
-          @appender.stub(:service_index, mock) do
-            @appender.send(level, @message)
-          end
-          assert_equal @message, mock.message
-          assert_equal level, mock.event[:event][:level]
-          refute mock.event[:event][:exception]
-        end
-
-        it "sends #{level} exceptions" do
-          exc = nil
-          begin
-            Uh oh
-          rescue Exception => e
-            exc = e
-          end
-
-          mock = Mock.new
-          @appender.stub(:service_index, mock) do
-            @appender.send(level, @message, exc)
-          end
-          assert_equal @message, mock.message
-
-          assert exception = mock.event[:event][:exception]
-          assert 'NameError', exception[:name]
-          assert 'undefined local variable or method', exception[:message]
-          assert_equal level, mock.event[:event][:level]
-          assert exception[:stack_trace].first.include?(__FILE__), exception
-        end
-
-        it "sends #{level} custom attributes" do
-          mock = Mock.new
-          @appender.stub(:service_index, mock) do
-            @appender.send(level, @message, key1: 1, key2: 'a')
-          end
-          assert_equal @message, mock.message
-
-          assert event = mock.event[:event], mock.event.ai
-          assert_equal level, event[:level]
-          refute event[:stack_trace]
-          assert payload = event[:payload]
-          assert_equal(1, payload[:key1], payload)
-          assert_equal('a', payload[:key2], payload)
-        end
-      end
-
-      it 'does not send :trace notifications to Splunk when set to :error' do
-        mock            = Mock.new
-        @appender.level = :error
-        @appender.stub(:service_index, mock) do
-          @appender.trace('AppenderSplunkTest trace message')
-        end
-        assert_nil mock.event
-        assert_nil mock.message
-      end
-    end
-  end
-end

data/test/appender/syslog_test.rb

@@ -1,61 +0,0 @@
-require_relative '../test_helper'
-require 'net/tcp_client'
-
-# Unit Test for SemanticLogger::Appender::Syslog
-#
-module Appender
-  class SyslogTest < Minitest::Test
-    describe SemanticLogger::Appender::Syslog do
-      it 'handle local syslog' do
-        message = nil
-        Syslog.stub(:open, nil) do
-          Syslog.stub(:log, ->(_level, msg) { message = msg }) do
-            syslog_appender = SemanticLogger::Appender::Syslog.new(level: :debug)
-            syslog_appender.debug 'AppenderSyslogTest log message'
-          end
-        end
-        assert_match(/D (.*?) SemanticLogger::Appender::Syslog -- AppenderSyslogTest log message/, message)
-      end
-
-      it 'handle remote syslog over TCP' do
-        message = nil
-        Net::TCPClient.stub_any_instance(:closed?, false) do
-          Net::TCPClient.stub_any_instance(:connect, nil) do
-            syslog_appender = SemanticLogger::Appender::Syslog.new(url: 'tcp://localhost:88888', level: :debug)
-            syslog_appender.remote_syslog.stub(:write, proc { |data| message = data }) do
-              syslog_appender.debug 'AppenderSyslogTest log message'
-            end
-          end
-        end
-        assert_match(/<70>(.*?)SemanticLogger::Appender::Syslog -- AppenderSyslogTest log message\r\n/, message)
-      end
-
-      it 'handle remote syslog over UDP' do
-        message         = nil
-        syslog_appender = SemanticLogger::Appender::Syslog.new(url: 'udp://localhost:88888', level: :debug)
-        UDPSocket.stub_any_instance(:send, ->(msg, _num, _host, _port) { message = msg }) do
-          syslog_appender.debug 'AppenderSyslogTest log message'
-        end
-        assert_match(/<70>(.*?)SemanticLogger::Appender::Syslog -- AppenderSyslogTest log message/, message)
-      end
-
-      # Should be able to log each level.
-      SemanticLogger::LEVELS.each do |level|
-        it "log #{level} information" do
-          Syslog.stub(:open, nil) do
-            Syslog.stub(:log, nil) do
-              syslog_appender = SemanticLogger::Appender::Syslog.new
-              syslog_appender.send(level, "AppenderSyslogTest #{level} message")
-            end
-          end
-        end
-      end
-
-      it 'allow logging with %' do
-        message         = 'AppenderSyslogTest %test'
-        syslog_appender = SemanticLogger::Appender::Syslog.new
-        syslog_appender.debug(message)
-      end
-    end
-  end
-end

data/test/appender/tcp_test.rb

@@ -1,66 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Tcp
-module Appender
-  class TcpTest < Minitest::Test
-    describe SemanticLogger::Appender::Tcp do
-      before do
-        Net::TCPClient.stub_any_instance(:connect, true) do
-          @appender = SemanticLogger::Appender::Tcp.new(server: 'localhost:8088')
-        end
-        @appender.tcp_client.instance_eval do
-          def retry_on_connection_failure
-            yield
-          end
-        end
-        @message = 'AppenderTcpTest log message'
-      end
-
-      SemanticLogger::LEVELS.each do |level|
-        it "send #{level}" do
-          data = nil
-          @appender.tcp_client.stub(:write, ->(d) { data = d }) do
-            @appender.send(level, @message)
-          end
-          hash = JSON.parse(data)
-          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
-          data = nil
-          @appender.tcp_client.stub(:write, ->(d) { data = d }) do
-            @appender.send(level, 'Reading File', exc)
-          end
-          hash = JSON.parse(data)
-          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
-          data = nil
-          @appender.tcp_client.stub(:write, ->(d) { data = d }) do
-            @appender.send(level, @message, key1: 1, key2: 'a')
-          end
-          hash = JSON.parse(data)
-          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/udp_test.rb

@@ -1,59 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Tcp
-module Appender
-  class UdpTest < Minitest::Test
-    describe SemanticLogger::Appender::Udp do
-      before do
-        @appender = SemanticLogger::Appender::Udp.new(server: 'localhost:8088')
-        @message  = 'AppenderUdpTest log message'
-      end
-
-      SemanticLogger::LEVELS.each do |level|
-        it "send #{level}" do
-          data = nil
-          @appender.socket.stub(:send, ->(d, _flags) { data = d }) do
-            @appender.send(level, @message)
-          end
-          hash = JSON.parse(data)
-          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
-          data = nil
-          @appender.socket.stub(:send, ->(d, _flags) { data = d }) do
-            @appender.send(level, 'Reading File', exc)
-          end
-          hash = JSON.parse(data)
-          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
-          data = nil
-          @appender.socket.stub(:send, ->(d, _flags) { data = d }) do
-            @appender.send(level, @message, key1: 1, key2: 'a')
-          end
-          hash = JSON.parse(data)
-          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/wrapper_test.rb

@@ -1,95 +0,0 @@
-require_relative '../test_helper'
-
-# Unit Test for SemanticLogger::Appender::Wrapper
-#
-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
-        SemanticLogger.backtrace_level = :trace
-
-        @time              = Time.new
-        @mock_logger       = MockLogger.new
-        @appender          = SemanticLogger::Appender::Wrapper.new(logger: @mock_logger)
-        @hash              = {session_id: 'HSSKLEU@JDK767', tracking_number: 12_345}
-        @hash_str          = @hash.inspect.sub('{', '\\{').sub('}', '\\}')
-        @thread_name       = Thread.current.name
-        @file_name_reg_exp = ' wrapper_test.rb:\d+'
-      end
-
-      describe 'format logs into text form' do
-        it 'logs blank data' do
-          @appender.debug
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}#{@file_name_reg_exp}\] SemanticLogger::Appender::Wrapper/, @mock_logger.message)
-        end
-
-        it 'logs message' do
-          @appender.debug('hello world')
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}#{@file_name_reg_exp}\] SemanticLogger::Appender::Wrapper -- hello world/, @mock_logger.message)
-        end
-
-        it 'logs message and payload' do
-          @appender.debug('hello world', @hash)
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}#{@file_name_reg_exp}\] SemanticLogger::Appender::Wrapper -- hello world -- #{@hash_str}/, @mock_logger.message)
-        end
-
-        it 'logs named parameters' do
-          @appender.debug(message: 'hello world', payload: @hash)
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}#{@file_name_reg_exp}\] SemanticLogger::Appender::Wrapper -- hello world -- #{@hash_str}/, @mock_logger.message)
-        end
-      end
-
-      describe 'for each log level' do
-        before do
-          @appender = SemanticLogger.add_appender(logger: @mock_logger)
-          @logger   = SemanticLogger[WrapperTest]
-        end
-
-        after do
-          SemanticLogger.remove_appender(@appender)
-        end
-
-        # Ensure that any log level can be logged
-        Logger::Severity.constants.each do |level|
-          it "log #{level.downcase.to_sym}" do
-            level_char = level[0].upcase
-            level_char = 'E' if level_char == 'U'
-            @logger.send(level.downcase.to_sym, 'hello world', @hash)
-            SemanticLogger.flush
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] Appender::WrapperTest -- hello world -- #{@hash_str}/, @mock_logger.message)
-          end
-        end
-      end
-    end
-  end
-end