semantic_logger 2.16.0 → 2.17.0

data/test/appender_bugsnag_test.rb

@@ -1,60 +0,0 @@
-require_relative 'test_helper'
-
-# Unit Test for SemanticLogger::Appender::Bugsnag
-#
-class AppenderBugsnagTest < Minitest::Test
-  describe SemanticLogger::Appender::Bugsnag do
-    before do
-      @appender = SemanticLogger::Appender::Bugsnag.new(:warn)
-      @message  = 'AppenderBugsnagTest log message'
-    end
-
-    (SemanticLogger::LEVELS - [:warn, :error]).each do |level|
-      it "not send :#{level} notifications to Bugsnag" do
-        message = hash = nil
-        Bugsnag.stub(:notify, -> msg, h { message = msg; hash = h }) do
-          @appender.send(level, "AppenderBugsnagTest #{level.to_s} message")
-        end
-        assert_nil message
-        assert_nil hash
-      end
-    end
-
-    it "send error notifications to Bugsnag with severity" do
-      message = hash = nil
-      Bugsnag.stub(:notify, -> msg, h { message = msg; hash = h }) do
-        @appender.error @message
-      end
-      assert_equal RuntimeError.new(@message), message
-      assert_equal 'error', hash[:severity]
-    end
-
-    it 'send warn notifications to Bugsnag replace warn severity with warning' do
-      message = hash = nil
-      Bugsnag.stub(:notify, -> msg, h { message = msg; hash = h }) do
-        @appender.warn @message
-      end
-      assert_equal RuntimeError.new(@message), message
-      assert_equal 'warning', hash[:severity]
-    end
-
-    it 'send notification to Bugsnag with custom attributes' do
-      message = hash = nil
-      Bugsnag.stub(:notify, -> msg, h { message = msg; hash = h }) do
-        @appender.error @message, {key1: 1, key2: 'a'}
-      end
-      assert_equal RuntimeError.new(@message), message
-      assert_equal(1, hash[:key1], hash)
-      assert_equal('a', hash[:key2], hash)
-    end
-
-    it 'send notification to Bugsnag with exception' do
-      message = hash = nil
-      error   = RuntimeError.new('Hello World')
-      Bugsnag.stub(:notify, -> msg, h { message = msg; hash = h }) do
-        @appender.error error
-      end
-      assert_equal error, message
-    end
-  end
-end

data/test/appender_file_test.rb

@@ -1,77 +0,0 @@
-require_relative 'test_helper'
-require 'stringio'
-
-# Unit Test for SemanticLogger::Appender::File
-#
-class AppenderFileTest < 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)
-      @hash                        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
-      @hash_str                    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-      @thread_name                 = Thread.current.name
-    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 "handle exception only" do
-        @appender.debug StandardError.new("StandardError")
-        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- #<StandardError: StandardError> -- Exception: StandardError: StandardError\n\n/, @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} information" 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
-
-    describe "custom formatter" do
-      before do
-        @appender = SemanticLogger::Appender::File.new(@io) do |log|
-          tags = log.tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if log.tags && (log.tags.size > 0)
-
-          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 ? " (#{'%.1f' % log.duration}ms)" : ''
-
-          "#{SemanticLogger::Appender::Base.formatted_time(log.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

data/test/appender_mongodb_test.rb

@@ -1,103 +0,0 @@
-require_relative 'test_helper'
-
-# Unit Test for SemanticLogger::Appender::MongoDB
-#
-class AppenderMongoDBTest < Minitest::Test
-  describe SemanticLogger::Appender::MongoDB do
-    before do
-      @db                 = Mongo::Connection.new['test']
-      @appender           = SemanticLogger::Appender::MongoDB.new(
-        db:              @db,
-        collection_size: 10*1024**2, # 10MB
-        host_name:       'test',
-        application:     'test_application',
-        level:           :trace
-      )
-      @hash               = {tracking_number: 12345, session_id: 'HSSKLEU@JDK767'}
-      Thread.current.name = 'thread'
-    end
-
-    after do
-      @appender.purge_all if @appender
-    end
-
-    describe "format logs into documents" do
-
-      it "handle nil name, message and hash" do
-        @appender.debug
-        document = @appender.collection.find_one
-        assert_equal :debug, document['level']
-        assert_equal nil, document['message']
-        assert_equal 'thread', document['thread_name']
-        assert document['time'].is_a?(Time)
-        assert_equal nil, document['payload']
-        assert_equal $$, document['pid']
-        assert_equal 'test', document['host_name']
-        assert_equal 'test_application', document['application']
-      end
-
-      it "handle nil message and payload" do
-        @appender.debug(@hash)
-
-        document = @appender.collection.find_one
-        assert_equal :debug, document['level']
-        assert_equal @hash.inspect, document['message']
-        assert_equal 'thread', document['thread_name']
-        assert document['time'].is_a?(Time)
-        assert_nil document['payload']
-        assert_equal $$, document['pid']
-        assert_equal 'test', document['host_name']
-        assert_equal 'test_application', document['application']
-      end
-
-      it "handle message and payload" do
-        @appender.debug('hello world', @hash)
-
-        document = @appender.collection.find_one
-        assert_equal :debug, document['level']
-        assert_equal 'hello world', document['message']
-        assert_equal 'thread', document['thread_name']
-        assert document['time'].is_a?(Time)
-        assert_equal({"tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
-        assert_equal $$, document['pid']
-        assert_equal 'test', document['host_name']
-        assert_equal 'test_application', document['application']
-      end
-
-      it "handle message without payload" do
-        log = SemanticLogger::Base::Log.new(:debug)
-        @appender.debug('hello world')
-
-        document = @appender.collection.find_one
-        assert_equal :debug, document['level']
-        assert_equal 'hello world', document['message']
-        assert_equal 'thread', document['thread_name']
-        assert document['time'].is_a?(Time)
-        assert_equal nil, document['payload']
-        assert_equal $$, document['pid']
-        assert_equal 'test', document['host_name']
-        assert_equal 'test_application', document['application']
-      end
-    end
-
-    describe "for each log level" do
-      # Ensure that any log level can be logged
-      SemanticLogger::LEVELS.each do |level|
-        it "log #{level} information" do
-          @appender.send(level, 'hello world -- Calculations', @hash)
-          document = @appender.collection.find_one
-          assert_equal level, document['level']
-          assert_equal 'hello world -- Calculations', document['message']
-          assert_equal 'thread', document['thread_name']
-          assert document['time'].is_a?(Time)
-          assert_equal({"tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
-          assert_equal $$, document['pid']
-          assert_equal 'test', document['host_name']
-          assert_equal 'test_application', document['application']
-        end
-      end
-
-    end
-
-  end
-end

data/test/appender_new_relic_test.rb

@@ -1,83 +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
-#
-class AppenderNewRelicTest < Minitest::Test
-  describe SemanticLogger::Appender::NewRelic do
-
-    before do
-      @appender           = SemanticLogger::Appender::NewRelic.new(:error)
-      @message            = 'AppenderNewRelicTest log message'
-      @multi_line_message = <<-EOSTR
-
-
-      first non-blank line
-      second non-blank line
-
-      third non-blank line
-
-      EOSTR
-    end
-
-    (SemanticLogger::LEVELS - [:error, :fatal]).each do |level|
-      it "not send :#{level.to_s} notifications to New Relic" do
-        message = hash = nil
-        NewRelic::Agent.stub(:notice_error, -> msg, h { message = msg; hash = h }) do
-          @appender.tagged('test') do
-            @appender.send(level, "AppenderNewRelicTest #{level.to_s} message")
-          end
-        end
-        assert_nil message
-        assert_nil hash
-      end
-    end
-
-    [:error, :fatal].each do |level|
-      it "send :#{level.to_s} notifications to New Relic" do
-        message = hash = nil
-        NewRelic::Agent.stub(:notice_error, -> msg, h { message = msg; hash = h }) do
-          @appender.tagged('test') do
-            @appender.send(level, @message)
-          end
-        end
-        assert_equal @message, message
-        assert_equal ['test'], hash[:custom_params][:tags]
-        assert_equal "SemanticLogger::Appender::NewRelic/#{@message}", hash[:metric]
-        assert_nil hash[:custom_params][:duration]
-        assert hash[:custom_params][:thread_name], hash.inspect
-      end
-    end
-
-    it 'send notification to New Relic with custom attributes' do
-      message = hash = nil
-      NewRelic::Agent.stub(:notice_error, -> msg, h { message = msg; hash = h }) do
-        @appender.tagged('test') do
-          @appender.with_payload({key1: 1, key2: 'a'}) do
-            @appender.benchmark(:error, @message) do
-              sleep 0.001
-            end
-          end
-        end
-      end
-      assert_equal @message, message
-      assert_equal ['test'], hash[:custom_params][:tags], hash
-      assert_equal "SemanticLogger::Appender::NewRelic/#{@message}", hash[:metric]
-      assert_equal({key1: 1, key2: 'a'}, hash[:custom_params][:payload], hash)
-      assert hash[:custom_params][:duration], hash
-      assert hash[:custom_params][:thread_name], hash
-    end
-
-    it 'use the first non-blank line for a multi-line message' do
-      message = hash = nil
-      NewRelic::Agent.stub(:notice_error, -> msg, h { message = msg; hash = h }) do
-        @appender.tagged('test') do
-          @appender.error @multi_line_message
-        end
-      end
-      assert_equal 'first non-blank line', message
-    end
-
-  end
-end

data/test/appender_splunk_test.rb

@@ -1,47 +0,0 @@
-require_relative 'test_helper'
-
-# Unit Test for SemanticLogger::Appender::Splunk
-#
-class AppenderSplunkTest < Minitest::Test
-  describe SemanticLogger::Appender::Splunk do
-
-    describe '#parse_options' do
-      describe 'argument errors' do
-        it 'raise argument error for missing username' do
-          error = assert_raises ArgumentError do
-            SemanticLogger::Appender::Splunk.new({})
-          end
-
-          assert_equal 'Must supply a username.', error.message
-        end
-
-        it 'raise argument error for missing password' do
-          error = assert_raises ArgumentError do
-            SemanticLogger::Appender::Splunk.new(username: 'username')
-          end
-
-          assert_equal 'Must supply a password.', error.message
-        end
-      end
-
-      describe 'set default values' do
-        it 'have default values' do
-          appender = Splunk.stub(:connect, Splunk::Service.new({})) do
-            Splunk::Service.stub_any_instance(:indexes, {}) do
-              SemanticLogger::Appender::Splunk.new(username: 'username', password: 'password')
-            end
-          end
-          config   = appender.config
-          # Default host
-          assert_equal 'localhost', config[:host]
-          # Default port
-          assert_equal 8089, config[:port]
-          # Default scheme
-          assert_equal :https, config[:scheme]
-          #Default index
-          assert_equal 'main', appender.index
-        end
-      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
-#
-class AppenderSyslogTest < 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(server: 'tcp://localhost:88888', level: :debug)
-          syslog_appender.remote_syslog.stub(:write, Proc.new { |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(server: '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.to_s} 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