semantic_logger 2.16.0 → 2.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d4e0a0bfded65004b557ad08aa6729d70387841
-  data.tar.gz: 9c8f8584584afb4d29c71467f09ab0d87c61fd4e
+  metadata.gz: 6d01095b46462b1fc9ea2b2d918a372bda406cd8
+  data.tar.gz: d6e2b86770aaaa606727efa5090028ffd0e6bcb5
 SHA512:
-  metadata.gz: 5dea37b7135aba5a357aa012ff879345d521a5cc25d45f26b14c1292ab2716c644ebfd29b6ed7eaca6aba109c1b945501c43698a9a7c20c9919c85eb8cfeaa12
-  data.tar.gz: a061d2c0989485fc5cba5dafc5d96d9d39376805c3d509046c05a46e0dc1c8be4d17d728be939d3cd94315971be1817b95da8baa0b2e223adc156d4de14bdbfc
+  metadata.gz: 0ec5d70d0147dba2cb7c63a1981de782a215036adbf469c48d2cb04a1c66a59b055fbf0627214464f0d12199679b69b2ddcd62fc93bf6017311a1cda730e5f90
+  data.tar.gz: 84d8f9e36d3ca6d04849e765a6cab837a281bdbcb625d4afebdecbe9d0d30bf86ac0f9153726bb9a726f702d8b22f4551ad782e2c25f285b89ff3bb17b9f0a0b

data/README.md

@@ -1,5 +1,5 @@
 # semantic_logger
-![](https://img.shields.io/gem/v/semantic_logger.svg) ![](https://img.shields.io/travis/rocketjob/semantic_logger.svg) ![](https://img.shields.io/gem/dt/semantic_logger.svg) ![](https://img.shields.io/badge/status-production%20ready-blue.svg)
+[![Gem Version](https://img.shields.io/gem/v/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![Build Status](https://travis-ci.org/rocketjob/semantic_logger.svg?branch=master)](https://travis-ci.org/rocketjob/semantic_logger) [![Downloads](https://img.shields.io/gem/dt/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg) [![Gitter chat](https://img.shields.io/badge/IRC%20(gitter)-Support-brightgreen.svg)](https://gitter.im/rocketjob/rocketjob)
 
 Low latency, high throughput, enterprise-scale logging system for Ruby
 
@@ -56,6 +56,20 @@ and are therefore not automatically included by this gem:
 
     gem install semantic_logger
 
+To configure a stand-alone application for Semantic Logger:
+
+```ruby
+require 'semantic_logger'
+
+# Set the global default log level
+SemanticLogger.default_level = :trace
+
+# Log to a file, and use the colorized formatter
+SemanticLogger.add_appender('development.log', &SemanticLogger::Appender::Base.colorized_formatter)
+```
+
+If running rails, see: [Semantic Logger Rails](http://rocketjob.github.io/semantic_logger/rails.html)
+
 ## Author
 
 [Reid Morrison](https://github.com/reidmorrison)

data/lib/semantic_logger/appender/base.rb

@@ -35,12 +35,20 @@ module SemanticLogger
           tags = log.tags.collect { |tag| "[#{tag}]" }.join(' ') + ' ' if log.tags && (log.tags.size > 0)
 
           message = log.message.to_s.dup
-          message << ' -- ' << log.payload.inspect unless log.payload.nil? || log.payload.empty?
+          message << ' -- ' << log.payload.inspect unless log.payload.nil? || (log.payload.respond_to?(:empty?) && log.payload.empty?)
           message << ' -- Exception: ' << "#{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[0..0].upcase} [#{$$}:#{'%.50s' % log.thread_name}] #{tags}#{duration_str}#{log.name} -- #{message}"
+          file_name =
+            if log.backtrace || log.exception
+              backtrace  = log.backtrace || log.exception.backtrace
+              location   = backtrace[0].split('/').last
+              file, line = location.split(':')
+              " #{file}:#{line}"
+            end
+
+          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{log.level.to_s[0..0].upcase} [#{$$}:#{'%.50s' % log.thread_name}#{file_name}] #{tags}#{duration_str}#{log.name} -- #{message}"
         end
       end
 
@@ -55,7 +63,7 @@ module SemanticLogger
           tags   = log.tags.collect { |tag| "[#{colors::CYAN}#{tag}#{colors::CLEAR}]" }.join(' ') + ' ' if log.tags && (log.tags.size > 0)
 
           message = log.message.to_s.dup
-          unless log.payload.nil? || log.payload.empty?
+          unless log.payload.nil? || (log.payload.respond_to?(:empty?) && log.payload.empty?)
             payload = log.payload
             payload = (defined?(AwesomePrint) && payload.respond_to?(:ai)) ? payload.ai(multiline: false) : payload.inspect
             message << ' -- ' << payload
@@ -78,7 +86,15 @@ module SemanticLogger
               colors::RED
             end
 
-          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{level_color}#{colors::BOLD}#{log.level.to_s[0..0].upcase}#{colors::CLEAR} [#{$$}:#{'%.30s' % log.thread_name}] #{tags}#{duration_str}#{level_color}#{log.name}#{colors::CLEAR} -- #{message}"
+          file_name =
+            if log.backtrace || log.exception
+              backtrace = log.backtrace || log.exception.backtrace
+              location = backtrace[0].split('/').last
+              file, line = location.split(':')
+              " #{level_color}#{file}:#{line}#{colors::CLEAR}"
+            end
+
+          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{level_color}#{colors::BOLD}#{log.level.to_s[0..0].upcase}#{colors::CLEAR} [#{$$}:#{'%.30s' % log.thread_name}#{file_name}] #{tags}#{duration_str}#{level_color}#{log.name}#{colors::CLEAR} -- #{message}"
         end
       end
 
@@ -128,13 +144,13 @@ module SemanticLogger
         # Return the Time as a formatted string
         # JRuby only supports time in ms
         def self.formatted_time(time)
-          "#{time.strftime("%Y-%m-%d %H:%M:%S")}.#{"%03d" % (time.usec/1000)}"
+          "#{time.strftime('%Y-%m-%d %H:%M:%S')}.#{'%03d' % (time.usec/1000)}"
         end
       else
         # Return the Time as a formatted string
         # Ruby MRI supports micro seconds
         def self.formatted_time(time)
-          "#{time.strftime("%Y-%m-%d %H:%M:%S")}.#{"%06d" % (time.usec)}"
+          "#{time.strftime('%Y-%m-%d %H:%M:%S')}.#{'%06d' % (time.usec)}"
         end
       end
 

data/lib/semantic_logger/appender/bugsnag.rb

@@ -48,6 +48,8 @@ class SemanticLogger::Appender::Bugsnag < SemanticLogger::Appender::Base
   #   Default: :error
   #   Note: Not recommended to set the log level to :info, :debug, or :trace as that would flood Bugsnag with Error notices
   def initialize(level = :error, &block)
+    # Replace the Bugsnag logger so that we can identify its log messages and not forward them to Bugsnag
+    Bugsnag.configure { |config| config.logger = SemanticLogger[Bugsnag] }
     super(level, &block)
   end
 
@@ -55,6 +57,7 @@ class SemanticLogger::Appender::Bugsnag < SemanticLogger::Appender::Base
   def default_formatter
     proc do |log|
       h = {severity: log_level(log), tags: log.tags, class: log.name}
+      h[:message] = log.message if log.exception
       h.merge!(log.payload) if log.payload
       h
     end
@@ -63,22 +66,32 @@ class SemanticLogger::Appender::Bugsnag < SemanticLogger::Appender::Base
   # Send an error notification to Bugsnag
   def log(log)
     # Only log if level is warn, or error.
-    # We don't want to send fatal as those are already captured by Bugsnag.
-    return false if (level_index > (log.level_index || 0)) || !include_message?(log)
-    return false if log.level == :fatal
-    # Ignore logs coming from Bugsnag itself
-    return false if log.message.to_s.include?(Bugsnag::LOG_PREFIX)
-
+    return false if (level_index > (log.level_index || 0)) ||
+      # We don't want to send fatal as those are already captured by Bugsnag.
+      (log.level == :fatal) ||
+      # Ignore logs coming from Bugsnag itself
+      (log.name == 'Bugsnag') ||
+      # Filtered out?
+      !include_message?(log)
+
+    # Send error messages as Runtime exceptions
+    exception =
+      if log.exception
+        log.exception
+      else
+        error = RuntimeError.new(log.message)
+        error.set_backtrace(log.backtrace) if log.backtrace
+        error
+      end
     # For more documentation on the Bugsnag.notify method see:
     # https://bugsnag.com/docs/notifiers/ruby#sending-handled-exceptions
-    Bugsnag.notify(log.exception || RuntimeError.new(log.message), formatter.call(log))
+    Bugsnag.notify(exception, formatter.call(log))
     true
   end
 
   private
 
   def log_level(log)
-    return 'warning' if log.level == :warn
-    log.level.to_s
+    log.level == :warn ? 'warning' : log.level.to_s
   end
 end

data/lib/semantic_logger/appender/mongodb.rb

@@ -28,6 +28,9 @@ module SemanticLogger
     #      message:     'Invalid value',
     #      stack_trace: []
     #    }
+    #    # When a backtrace is captured
+    #    file_name: 'my_class.rb'
+    #    line_number: 42
     #
     class MongoDB < SemanticLogger::Appender::Base
       attr_reader :db, :collection_name, :collection
@@ -155,11 +158,20 @@ module SemanticLogger
           document[:duration]    = log.duration if log.duration
           document[:tags]        = log.tags if log.tags && (log.tags.size > 0)
           document[:payload]     = log.payload if log.payload
-          document[:exception]   = {
-            name:        log.exception.class.name,
-            message:     log.exception.message,
-            stack_trace: log.exception.backtrace
-          } if log.exception
+          if log.exception
+            document[:exception] = {
+              name:        log.exception.class.name,
+              message:     log.exception.message,
+              stack_trace: log.exception.backtrace
+            }
+          end
+          if log.backtrace || log.exception
+            backtrace              = log.backtrace || log.exception.backtrace
+            location               = backtrace[0].split('/').last
+            file, line             = location.split(':')
+            document[:file_name]   = file
+            document[:line_number] = line.to_i
+          end
           document
         end
       end

data/lib/semantic_logger/appender/new_relic.rb

@@ -59,34 +59,23 @@ sleep 10
 require 'newrelic_rpm'
 
 class SemanticLogger::Appender::NewRelic < SemanticLogger::Appender::Base
-
   # Allow the level for this appender to be overwritten
   #   Default: :error
   #   Note: Not recommended to set the log level to :info, :debug, or :trace as that would flood NewRelic with Error notices
   def initialize(level=:error, &block)
-    # Pass on the level and custom formatter if supplied
     super(level, &block)
   end
 
-  # The application may send a multiline string to the appender... use the first non-blank line as a shorter message.
-  def self.first_non_empty_line(string)
-    string.strip.split("\n").first.to_s
-  end
-
   # Returns [Hash] of parameters to send to New Relic.
   def default_formatter
     Proc.new do |log|
-      short_message = self.class.first_non_empty_line(log.message)
-      metric        = log.metric || "#{log.name}/#{short_message}"
-
       custom_params            = {thread_name: log.thread_name}
-      # Only show the message under custom attributes if the error message uses an exception or shortened message (first non-empty line).
-      custom_params[:message]  = log.message if log.message && (log.exception || log.message != short_message)
       custom_params[:duration] = "#{log.duration} ms" if log.duration
       custom_params[:payload]  = log.payload if log.payload
       custom_params[:tags]     = log.tags if log.tags && (log.tags.size > 0)
+      custom_params[:message]  = log.message if log.exception
 
-      {metric: metric, custom_params: custom_params}
+      {metric: log.metric, custom_params: custom_params}
     end
   end
 
@@ -95,10 +84,19 @@ class SemanticLogger::Appender::NewRelic < SemanticLogger::Appender::Base
     # Ensure minimum log level is met, and check filter
     return false if (level_index > (log.level_index || 0)) || !include_message?(log)
 
+    # Send error messages as Runtime exceptions
+    exception =
+      if log.exception
+        log.exception
+      else
+        error = RuntimeError.new(log.message)
+        error.set_backtrace(log.backtrace) if log.backtrace
+        error
+      end
     # For more documentation on the NewRelic::Agent.notice_error method see:
     # http://rubydoc.info/github/newrelic/rpm/NewRelic/Agent#notice_error-instance_method
     # and https://docs.newrelic.com/docs/ruby/ruby-agent-api
-    NewRelic::Agent.notice_error(log.exception || self.class.first_non_empty_line(log.message), formatter.call(log))
+    NewRelic::Agent.notice_error(exception, formatter.call(log))
     true
   end
 

data/lib/semantic_logger/base.rb

@@ -314,7 +314,10 @@ module SemanticLogger
     #
     # metric [Object]
     #   Object supplied when benchmark_x was called
-    Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric)
+    #
+    # backtrace [Array<String>]
+    #   The backtrace captured at source when the log level >= SemanticLogger.backtrace_level
+    Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric, :backtrace)
 
     # Whether to log the supplied message based on the current filter if any
     def include_message?(struct)
@@ -329,14 +332,18 @@ module SemanticLogger
 
     # Log message at the specified level
     def log_internal(level, index, message=nil, payload=nil, exception=nil, &block)
+      # Detect exception being logged
       if exception.nil? && payload.nil? && message.kind_of?(Exception)
         exception = message
         message   = exception.inspect
-      elsif exception.nil? && payload && payload.is_a?(Exception)
+      elsif exception.nil? && payload && payload.respond_to?(:backtrace) && payload.respond_to?(:message)
+        # Under JRuby a java exception is not a Ruby Exception
+        #   Java::JavaLang::ClassCastException.new.is_a?(Exception) => false
         exception = payload
         payload   = nil
       end
 
+      # Add result of block as message or payload if not nil
       if block && (result = block.call)
         if result.is_a?(String)
           message = message.nil? ? result : "#{message} -- #{result}"
@@ -351,13 +358,24 @@ module SemanticLogger
       if self.payload
         payload = payload.nil? ? self.payload : self.payload.merge(payload)
       end
-      struct = Log.new(level, Thread.current.name, name, message, payload, Time.now, nil, tags, index, exception)
+
+      # Add caller stack trace
+      backtrace =
+        if !exception && (index >= SemanticLogger.backtrace_level_index)
+          trace = caller
+          # Remove call to this internal method
+          trace.shift(1)
+          trace
+        end
+
+      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
 
     # Measure the supplied block and log the message
     def benchmark_internal(level, index, message, params, &block)
-      start = Time.now
+      start     = Time.now
+      exception = nil
       begin
         if block
           result    =
@@ -394,6 +412,7 @@ module SemanticLogger
         end
         if exception
           logged_exception = exception
+          backtrace        = nil
           case log_exception
           when :full
             # On exception change the log level
@@ -409,16 +428,29 @@ module SemanticLogger
             end
             message          = "#{message} -- Exception: #{exception.class}: #{exception.message}"
             logged_exception = nil
+            backtrace        = exception.backtrace
           else
             # Log the message with its duration but leave out the exception that was raised
             logged_exception = nil
+            backtrace        = exception.backtrace
           end
-          struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, logged_exception, metric)
+          struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, logged_exception, metric, backtrace)
           log(struct) if include_message?(struct)
           raise exception
         elsif duration >= min_duration
           # Only log if the block took longer than 'min_duration' to complete
-          struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, nil, metric)
+          # 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
+
+          struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, nil, metric, backtrace)
           log(struct) if include_message?(struct)
         end
       end

data/lib/semantic_logger/semantic_logger.rb

@@ -20,6 +20,33 @@ module SemanticLogger
     @@default_level
   end
 
+  # Sets the level at which backtraces should be captured
+  # for every log message.
+  #
+  # By enabling backtrace capture the filename and line number of where
+  # message was logged can be written to the log file. Additionally, the backtrace
+  # can be forwarded to error management services such as Bugsnag.
+  #
+  # Warning:
+  #   Capturing backtraces is very expensive and should not be done all
+  #   the time. It is recommended to run it at :error level in production.
+  def self.backtrace_level=(level)
+    @@backtrace_level       = level
+    # For performance reasons pre-calculate the level index
+    @@backtrace_level_index = level.nil? ? 65535 : level_to_index(level)
+  end
+
+  # Returns the current backtrace level
+  def self.backtrace_level
+    @@backtrace_level
+  end
+
+  # Returns the current backtrace level index
+  # For internal use only
+  def self.backtrace_level_index #:nodoc
+    @@backtrace_level_index
+  end
+
   # Add a new logging appender as a new destination for all log messages
   # emitted from Semantic Logger
   #
@@ -263,6 +290,8 @@ module SemanticLogger
   end
 
   # Initial default Level for all new instances of SemanticLogger::Logger
-  @@default_level       = :info
-  @@default_level_index = level_to_index(@@default_level)
+  @@default_level         = :info
+  @@default_level_index   = level_to_index(@@default_level)
+  @@backtrace_level       = :error
+  @@backtrace_level_index = level_to_index(@@backtrace_level)
 end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = '2.16.0'
+  VERSION = '2.17.0'
 end

data/test/appender/bugsnag_test.rb

@@ -0,0 +1,65 @@
+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(:warn)
+        @message  = 'AppenderBugsnagTest log message'
+      end
+
+      (SemanticLogger::LEVELS - [:warn, :error]).each do |level|
+        it "not send :#{level} notifications to Bugsnag" do
+          exception = hash = nil
+          Bugsnag.stub(:notify, -> exc, h { exception = exc; hash = h }) do
+            @appender.send(level, "AppenderBugsnagTest #{level.to_s} message")
+          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
+        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'}
+        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