semantic_logger 2.21.0 → 3.0.0

data/lib/semantic_logger/base.rb

@@ -328,18 +328,23 @@ module SemanticLogger
       end
 
       # Add caller stack trace
-      backtrace =
-        if index >= SemanticLogger.backtrace_level_index
-          trace = caller
-          # Remove call to this internal method
-          trace.shift(1)
-          trace
-        end
+      backtrace = extract_backtrace if index >= SemanticLogger.backtrace_level_index
 
       struct = Log.new(level, Thread.current.name, name, message, payload, Time.now, nil, tags, index, exception, nil, backtrace)
       log(struct) if include_message?(struct)
     end
 
+    SELF_PATTERN = File.join('lib', 'semantic_logger')
+
+    # Extract the callers backtrace leaving out Semantic Logger
+    def extract_backtrace
+      stack = caller
+      while (first = stack.first) && first.include?(SELF_PATTERN)
+        stack.shift
+      end
+      stack
+    end
+
     # Measure the supplied block and log the message
     def benchmark_internal(level, index, message, params)
       start     = Time.now
@@ -408,15 +413,7 @@ module SemanticLogger
         elsif duration >= min_duration
           # Only log if the block took longer than 'min_duration' to complete
           # Add caller stack trace
-          backtrace =
-            if index >= SemanticLogger.backtrace_level_index
-              trace = caller
-              # Remove call to this internal method
-              trace.shift
-              # Ruby 1.9 has additional stack entry for parent that calls this method
-              trace.shift if RUBY_VERSION.to_f <= 2.0
-              trace
-            end
+          backtrace = extract_backtrace if index >= SemanticLogger.backtrace_level_index
 
           struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, nil, metric, backtrace)
           log(struct) if include_message?(struct)

data/lib/semantic_logger/log.rb

@@ -64,6 +64,19 @@ module SemanticLogger
       end
     end
 
+    # Returns [String] the exception backtrace including all of the child / caused by exceptions
+    def backtrace_to_s
+      trace = ''
+      each_exception do |exception, i|
+        if i == 0
+          trace = (exception.backtrace || []).join("\n")
+        else
+          trace << "\nCause: #{exception.class.name}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}"
+        end
+      end
+      trace
+    end
+
     # Returns [String] duration of the log entry as a string
     # Returns nil if their is no duration
     # Java time precision does not include microseconds
@@ -89,7 +102,7 @@ module SemanticLogger
       elsif seconds >= 60.0 # 1 minute
         Time.at(seconds).strftime('%-Mm %-Ss')
       elsif seconds >= 1.0 # 1 second
-        Time.at(seconds).strftime('%-Ss %Lms')
+        "#{'%.3f' % seconds}s"
       else
         duration_to_s
       end
@@ -104,18 +117,26 @@ module SemanticLogger
     # Example:
     #    18934:thread 23 test_logging.rb:51
     def process_info(thread_name_length = 30)
-      file, line = file_name_and_line
+      file, line = file_name_and_line(true)
       file_name  = " #{file}:#{line}" if file
 
       "#{$$}:#{"%.#{thread_name_length}s" % thread_name}#{file_name}"
     end
 
+    CALLER_REGEXP = /^(.*):(\d+).*/
+
+    # Extract the filename and line number from the last entry in the supplied backtrace
+    def extract_file_and_line(stack, short_name = false)
+      match = CALLER_REGEXP.match(stack.first)
+      [short_name ? File.basename(match[1]) : match[1], match[2].to_i]
+    end
+
     # Returns [String, String] the file_name and line_number from the backtrace supplied
     # in either the backtrace or exception
-    def file_name_and_line
+    def file_name_and_line(short_name = false)
       if backtrace || (exception && exception.backtrace)
-        stacktrace = backtrace || exception.backtrace
-        stacktrace[0].split('/').last.split(':')[0..1] if stacktrace && stacktrace.size > 0
+        stack = backtrace || exception.backtrace
+        extract_file_and_line(stack, short_name) if stack && stack.size > 0
       end
     end
 
@@ -148,6 +169,65 @@ module SemanticLogger
       end
     end
 
+    # Returns [Hash] representation of this log entry
+    def to_h
+      # Header
+      h          = {
+        host:        SemanticLogger.host,
+        application: SemanticLogger.application,
+        name:        name,
+        pid:         $$,
+        thread:      thread_name,
+        time:        time,
+        level:       level,
+        level_index: level_index,
+      }
+      file, line = file_name_and_line
+      if file
+        h[:file] = file
+        h[:line] = line.to_i
+      end
+
+      # Tags
+      h[:tags] = tags if tags && (tags.size > 0)
+
+      # Duration
+      if duration
+        h[:duration_ms] = duration
+        h[:duration]    = duration_human
+      end
+
+      # Log message
+      h[:message] = cleansed_message if message
+
+      # Payload
+      if payload
+        if payload.is_a?(Hash)
+          h.merge!(payload)
+        else
+          h[:payload] = payload
+        end
+      end
+
+      # Exceptions
+      if exception
+        root = h
+        each_exception do |exception, i|
+          name       = i == 0 ? :exception : :cause
+          root[name] = {
+            name:        exception.class.name,
+            message:     exception.message,
+            stack_trace: exception.backtrace
+          }
+          root       = root[name]
+        end
+      end
+
+      # Metric
+      h[:metric] = metric if metric
+      h
+    end
+
   end
 
 end

data/lib/semantic_logger/logger.rb

@@ -227,7 +227,7 @@ module SemanticLogger
         begin
           subscriber.call(log_struct)
         rescue Exception => exc
-          logger.error 'Exception calling subscriber', exc
+          logger.error 'Exception calling metrics subscriber', exc
         end
       end
     end

data/lib/semantic_logger/semantic_logger.rb

@@ -1,4 +1,6 @@
 require 'concurrent'
+require 'socket'
+
 module SemanticLogger
   # Logging levels in order of most detailed to most severe
   LEVELS = [:trace, :debug, :info, :warn, :error, :fatal]
@@ -47,6 +49,28 @@ module SemanticLogger
     @@backtrace_level_index
   end
 
+  # Returns [String] name of this host for logging purposes
+  # Note: Not all appenders use `host`
+  def self.host
+    @@host ||= Socket.gethostname
+  end
+
+  # Override the default host name
+  def self.host=(host)
+    @@host = host
+  end
+
+  # Returns [String] name of this application for logging purposes
+  # Note: Not all appenders use `application`
+  def self.application
+    @@application ||= 'Semantic Logger'
+  end
+
+  # Override the default application
+  def self.application=(application)
+    @@application = application
+  end
+
   # Add a new logging appender as a new destination for all log messages
   # emitted from Semantic Logger
   #

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = '2.21.0'
+  VERSION = '3.0.0'
 end

data/test/appender/bugsnag_test.rb

@@ -5,61 +5,59 @@ module Appender
   class BugsnagTest < Minitest::Test
     describe SemanticLogger::Appender::Bugsnag do
       before do
-        @appender = SemanticLogger::Appender::Bugsnag.new(:warn)
+        @appender = SemanticLogger::Appender::Bugsnag.new(:info)
         @message  = 'AppenderBugsnagTest log message'
       end
 
       (SemanticLogger::LEVELS - [:warn, :error]).each do |level|
-        it "not send :#{level} notifications to Bugsnag" do
+        it "sends #{level} message" do
           exception = hash = nil
           Bugsnag.stub(:notify, -> exc, h { exception = exc; hash = h }) do
-            @appender.send(level, "AppenderBugsnagTest #{level.to_s} message")
+            @appender.send(level, @message)
+          end
+          if [:trace, :debug].include?(level)
+            assert_equal nil, exception
+            assert_equal nil, hash
+          else
+            assert_equal 'RuntimeError', exception.class.to_s
+            assert_equal @message, exception.message
+            assert_equal level.to_s, hash[:severity]
           end
-          assert_nil exception
-          assert_nil hash
-        end
-      end
-
-      it 'send error notifications to Bugsnag with severity' do
-        exception = hash = nil
-        Bugsnag.stub(:notify, -> exc, h { exception = exc; hash = h }) do
-          @appender.error @message
         end
-        assert_equal 'RuntimeError', exception.class.to_s
-        assert_equal @message, exception.message
-        assert_equal 'error', hash[:severity]
-      end
 
-      it 'send warn notifications to Bugsnag replace warn severity with warning' do
-        exception = hash = nil
-        Bugsnag.stub(:notify, -> exc, h { exception = exc; hash = h }) do
-          @appender.warn @message
+        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 [:trace, :debug].include?(level)
+            assert_equal nil, exception
+            assert_equal nil, hash
+          else
+            assert_equal 'RuntimeError', exception.class.to_s
+            assert_equal @message, exception.message
+            assert_equal 1, hash[:key1], hash
+            assert_equal 'a', hash[:key2], hash
+          end
         end
-        assert_equal 'RuntimeError', exception.class.to_s
-        assert_equal @message, exception.message
-        assert_equal 'warning', hash[:severity]
-      end
 
-      it 'send notification to Bugsnag with custom attributes' do
-        exception = hash = nil
-        Bugsnag.stub(:notify, -> exc, h { exception = exc; hash = h }) do
-          @appender.error @message, {key1: 1, key2: 'a'}
+        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 [:trace, :debug].include?(level)
+            assert_equal nil, exception
+            assert_equal 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
-        assert_equal 'RuntimeError', exception.class.to_s
-        assert_equal @message, exception.message
-        assert_equal(1, hash[:key1], hash)
-        assert_equal('a', hash[:key2], hash)
       end
 
-      it 'send notification to Bugsnag with exception' do
-        error     = RuntimeError.new('Hello World')
-        exception = hash = nil
-        Bugsnag.stub(:notify, -> exc, h { exception = exc; hash = h }) do
-          @appender.error error
-        end
-        assert_equal error.class.to_s, exception.class.to_s
-        assert_equal error.message, exception.message
-      end
     end
   end
 end

data/test/appender/graylog_test.rb

@@ -0,0 +1,63 @@
+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 - [: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.to_s} 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 'Reading File', hash[:short_message]
+        assert 'NameError', hash[:exception][:name]
+        assert '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 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_equal(1, hash[:key1], hash)
+        assert_equal('a', hash[:key2], hash)
+      end
+    end
+  end
+end

data/test/appender/http_test.rb

@@ -0,0 +1,61 @@
+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
+        @appender = SemanticLogger::Appender::Http.new(url: 'http://localhost:8088/path')
+        @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_equal 1, hash['key1'], hash
+          assert_equal 'a', hash['key2'], hash
+        end
+
+      end
+    end
+  end
+end