semantic_logger 3.4.1 → 4.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1be5c6c00e649ac6ae78e3e9e29737aa615e6ae
-  data.tar.gz: db7f64e434f93a22cc8f2ae66fe1e0b7d79d9cdc
+  metadata.gz: 0753c0265adc4668e64539c5014d6ea98a9f5659
+  data.tar.gz: 4af0ca018bd158bccc8506985c84f8e29dad6d1f
 SHA512:
-  metadata.gz: 9dc57b3e2722e32478cc33c514cb1ce9c6e00b564da8dcfcae5731fbb9b704c8e05f8baf59d415294555f1c27f934c1823c7dc220ffabc5345afc656f6d1c30a
-  data.tar.gz: aca9d4715197ff06ce760a1725b199447dd9fabff90df4c6aded226b6cd1ce5913482c0f7d53c19647e1b65167f86b814f1a067cf0369c96eb4817c6a5361559
+  metadata.gz: eba4d620e6930c556912f8fc089326d3dbfca5bc8224e2949487509c70a37f332580ce96c78d06ae1249a15169930395a1697a012c687b2bbcf6aa58ce4d6138
+  data.tar.gz: 0206b4fedff5b5850d9f8541588263643f8a21a7c732a3845a12c6f4f94272ddc2042a613159fe8030e9f3855740d7461dc10885b24cbf2bd8071ce613361651

data/README.md

@@ -50,6 +50,16 @@ and are therefore not automatically included by this gem:
 - Syslog Appender to a remote syslogng server over TCP or UDP: gem 'net_tcp_client'
 - Splunk Appender: gem 'splunk-sdk-ruby'
 
+## V4 Upgrade notes
+
+The following changes need to be made when upgrading to V4:
+- Ruby V2.1 / JRuby V9.1 is now the minimum runtime version.
+- Replace calls to Logger#with_payload with SemanticLogger.named_tagged.
+- Replace calls to Logger#payload with SemanticLogger.named_tags.
+- Appenders now write payload data in a seperate :payload tag instead of mixing them.
+  directly into the root elements to avoid name clashes.
+- MongoDB Appender requires Mongo Ruby Client V2 or greater.
+
 ## Install
 
     gem install semantic_logger

data/Rakefile

@@ -15,14 +15,10 @@ task publish: :gem do
   system "rm semantic_logger-#{SemanticLogger::VERSION}.gem"
 end
 
-desc 'Run Test Suite'
-task :test do
-  Rake::TestTask.new(:functional) do |t|
-    t.test_files = FileList['test/**/*_test.rb']
-    t.verbose    = true
-  end
-
-  Rake::Task['functional'].invoke
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = false
 end
 
 task default: :test

data/lib/semantic_logger.rb

@@ -5,44 +5,15 @@ require 'semantic_logger/semantic_logger'
 # @formatter:off
 module SemanticLogger
   autoload :AnsiColors,         'semantic_logger/ansi_colors'
+  autoload :Appender,           'semantic_logger/appender'
   autoload :Base,               'semantic_logger/base'
   autoload :DebugAsTraceLogger, 'semantic_logger/debug_as_trace_logger'
   autoload :Log,                'semantic_logger/log'
   autoload :Logger,             'semantic_logger/logger'
   autoload :Loggable,           'semantic_logger/loggable'
+  autoload :Processor,          'semantic_logger/processor'
   autoload :Subscriber,         'semantic_logger/subscriber'
 
-  module Appender
-    # DEPRECATED, use SemanticLogger::AnsiColors
-    AnsiColors = SemanticLogger::AnsiColors
-
-    # DEPRECATED: use SemanticLogger::Formatters::Color.new
-    def self.colorized_formatter
-      SemanticLogger::Formatters::Color.new
-    end
-
-    # DEPRECATED: use SemanticLogger::Formatters::Json.new
-    def self.json_formatter
-      SemanticLogger::Formatters::Json.new
-    end
-
-    autoload :Bugsnag,          'semantic_logger/appender/bugsnag'
-    autoload :Elasticsearch,    'semantic_logger/appender/elasticsearch'
-    autoload :File,             'semantic_logger/appender/file'
-    autoload :Graylog,          'semantic_logger/appender/graylog'
-    autoload :Honeybadger,      'semantic_logger/appender/honeybadger'
-    autoload :Sentry,           'semantic_logger/appender/sentry'
-    autoload :Http,             'semantic_logger/appender/http'
-    autoload :MongoDB,          'semantic_logger/appender/mongodb'
-    autoload :NewRelic,         'semantic_logger/appender/new_relic'
-    autoload :Splunk,           'semantic_logger/appender/splunk'
-    autoload :SplunkHttp,       'semantic_logger/appender/splunk_http'
-    autoload :Syslog,           'semantic_logger/appender/syslog'
-    autoload :Tcp,              'semantic_logger/appender/tcp'
-    autoload :Udp,              'semantic_logger/appender/udp'
-    autoload :Wrapper,          'semantic_logger/appender/wrapper'
-  end
-
   module Concerns
     autoload :Compatibility,    'semantic_logger/concerns/compatibility'
   end

data/lib/semantic_logger/appender.rb

@@ -0,0 +1,76 @@
+module SemanticLogger
+  module Appender
+    # @formatter:off
+    autoload :Bugsnag,          'semantic_logger/appender/bugsnag'
+    autoload :Elasticsearch,    'semantic_logger/appender/elasticsearch'
+    autoload :File,             'semantic_logger/appender/file'
+    autoload :Graylog,          'semantic_logger/appender/graylog'
+    autoload :Honeybadger,      'semantic_logger/appender/honeybadger'
+    autoload :Sentry,           'semantic_logger/appender/sentry'
+    autoload :Http,             'semantic_logger/appender/http'
+    autoload :MongoDB,          'semantic_logger/appender/mongodb'
+    autoload :NewRelic,         'semantic_logger/appender/new_relic'
+    autoload :Splunk,           'semantic_logger/appender/splunk'
+    autoload :SplunkHttp,       'semantic_logger/appender/splunk_http'
+    autoload :Syslog,           'semantic_logger/appender/syslog'
+    autoload :Tcp,              'semantic_logger/appender/tcp'
+    autoload :Udp,              'semantic_logger/appender/udp'
+    autoload :Wrapper,          'semantic_logger/appender/wrapper'
+    # @formatter:on
+
+    # DEPRECATED, use SemanticLogger::AnsiColors
+    AnsiColors = SemanticLogger::AnsiColors
+
+    # DEPRECATED: use SemanticLogger::Formatters::Color.new
+    def self.colorized_formatter
+      SemanticLogger::Formatters::Color.new
+    end
+
+    # DEPRECATED: use SemanticLogger::Formatters::Json.new
+    def self.json_formatter
+      SemanticLogger::Formatters::Json.new
+    end
+
+    # Returns [SemanticLogger::Subscriber] appender for the supplied options
+    def self.create(options, &block)
+      if options[:io] || options[:file_name]
+        SemanticLogger::Appender::File.new(options, &block)
+      elsif appender = options.delete(:appender)
+        if appender.is_a?(Symbol)
+          constantize_symbol(appender).new(options)
+        elsif appender.is_a?(Subscriber)
+          appender
+        else
+          raise(ArgumentError, "Parameter :appender must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
+        end
+      elsif options[:logger]
+        SemanticLogger::Appender::Wrapper.new(options, &block)
+      end
+    end
+
+    def self.constantize_symbol(symbol, namespace = 'SemanticLogger::Appender')
+      klass = "#{namespace}::#{camelize(symbol.to_s)}"
+      begin
+        if RUBY_VERSION.to_i >= 2
+          Object.const_get(klass)
+        else
+          klass.split('::').inject(Object) { |o, name| o.const_get(name) }
+        end
+      rescue NameError
+        raise(ArgumentError, "Could not convert symbol: #{symbol} to a class in: #{namespace}. Looking for: #{klass}")
+      end
+    end
+
+    private
+
+    # Borrow from Rails, when not running Rails
+    def self.camelize(term)
+      string = term.to_s
+      string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+      string.gsub!('/'.freeze, '::'.freeze)
+      string
+    end
+
+  end
+end

data/lib/semantic_logger/appender/bugsnag.rb

@@ -27,18 +27,13 @@ class SemanticLogger::Appender::Bugsnag < SemanticLogger::Subscriber
   #     regular expression. All other messages will be ignored.
   #     Proc: Only include log messages where the supplied Proc returns true
   #           The Proc must return true or false.
-  def initialize(options = {}, &block)
-    # Backward compatibility
-    options             = {level: options} unless options.is_a?(Hash)
-    options             = options.dup
-    options[:level]     = :error unless options.has_key?(:level)
-
-    raise 'Bugsnag only supports :info, :warn, or :error log levels' unless [:info, :warn, :error].include?(options[:level])
+  def initialize(level: :error, formatter: nil, filter: nil, host: SemanticLogger.host, application: SemanticLogger.application, &block)
+    raise 'Bugsnag only supports :info, :warn, or :error log levels' unless [:info, :warn, :error].include?(level)
 
     # 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(options, &block)
+    super(level: level, formatter: formatter, filter: filter, host: host, application: application, &block)
   end
 
   # Returns [Hash] of parameters to send to Bugsnag.

data/lib/semantic_logger/appender/file.rb

@@ -38,7 +38,7 @@ module SemanticLogger
       #    SemanticLogger.add_appender(io: STDOUT, formatter: :color)
       #
       #    # And log to a file at the same time
-      #    SemanticLogger::Logger.add_appender(file_name: 'application.log', formatter: :color)
+      #    SemanticLogger.add_appender(file_name: 'application.log', formatter: :color)
       #
       #    logger = SemanticLogger['test']
       #    logger.info 'Hello World'

data/lib/semantic_logger/appender/honeybadger.rb

@@ -50,7 +50,7 @@ class SemanticLogger::Appender::Honeybadger < SemanticLogger::Subscriber
       context.delete(:exception)
       Honeybadger.notify(log.exception, context)
     else
-      message = {
+      message             = {
         error_class:   context.delete(:name),
         error_message: context.delete(:message),
         context:       context

data/lib/semantic_logger/appender/http.rb

@@ -199,7 +199,7 @@ class SemanticLogger::Appender::Http < SemanticLogger::Subscriber
       true
     else
       # Failures are logged to the global semantic logger failsafe logger (Usually stderr or file)
-      SemanticLogger::Logger.logger.error("Bad HTTP response from: #{url} code: #{response.code}, #{response.body}")
+      SemanticLogger::Processor.logger.error("Bad HTTP response from: #{url} code: #{response.code}, #{response.body}")
       false
     end
   end

data/lib/semantic_logger/appender/mongodb.rb

@@ -2,7 +2,7 @@ require 'socket'
 begin
   require 'mongo'
 rescue LoadError
-  raise 'Gem mongo is required for logging to MongoDB. Please add the gem "mongo" to your Gemfile.'
+  raise 'Gem mongo is required for logging to MongoDB. Please add the gem "mongo" v2.0 or greater to your Gemfile.'
 end
 
 module SemanticLogger
@@ -49,14 +49,15 @@ module SemanticLogger
     #   # Log some messages
     #   logger.info 'This message is written to mongo as a document'
     class MongoDB < SemanticLogger::Subscriber
-      attr_reader :db, :collection_name, :collection
-      attr_accessor :write_concern
+      attr_reader :client, :collection
 
       # Create a MongoDB Appender instance
       #
       # Parameters:
-      #   db: [Mongo::Database]
-      #     The MongoDB database connection to use, not the database name
+      #   uri: [String]
+      #     Mongo connection string.
+      #     Example:
+      #       mongodb://127.0.0.1:27017/test
       #
       #   collection_name: [String]
       #     Name of the collection to store log data in
@@ -78,6 +79,7 @@ module SemanticLogger
       #
       #   collection_max: [Integer]
       #     Maximum number of log entries that the capped collection will hold.
+      #     Default: no max limit
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
       #     Override the log level for this appender.
@@ -101,28 +103,30 @@ module SemanticLogger
       #   application: [String]
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
-      def initialize(options = {}, &block)
-        options          = options.dup
-        @db              = options.delete(:db) || raise('Missing mandatory parameter :db')
-        @collection_name = options.delete(:collection_name) || 'semantic_logger'
-        @write_concern   = options.delete(:write_concern) || 0
+      def initialize(uri:, collection_name: 'semantic_logger', write_concern: 0, collection_size: 1024**3, collection_max: nil,
+        level: nil, formatter: nil, filter: nil, host: SemanticLogger.host, application: SemanticLogger.application, &block)
+        @client          = Mongo::Client.new(uri, logger: SemanticLogger::Processor.logger.clone)
+        @collection_name = collection_name
+        @options         = {
+          capped: true,
+          size:   collection_size,
+          write:  {w: write_concern}
+        }
+        @options[:max]   = collection_max if collection_max
 
-        # Create a collection that will hold the lesser of 1GB space or 10K documents
-        @collection_size = options.delete(:collection_size) || 1024**3
-        @collection_max  = options.delete(:collection_max)
+        reopen
 
         # Create the collection and necessary indexes
         create_indexes
 
         # Set the log level and formatter
-        super(options, &block)
-        reopen
+        super(level: level, formatter: formatter, filter: filter, host: host, application: application, &block)
       end
 
       # After forking an active process call #reopen to re-open
       # open the handles to resources
       def reopen
-        @collection = db[@collection_name]
+        @collection = client[@collection_name, @options]
       end
 
       # Create the required capped collection.
@@ -136,10 +140,14 @@ module SemanticLogger
       #
       # Creates an index based on tags to support faster searches.
       def create_indexes
-        options       = {capped: true, size: @collection_size}
-        options[:max] = @collection_max if @collection_max
-        db.create_collection(collection_name, options)
-        db[@collection_name].ensure_index('tags')
+        # Create Capped collection
+        begin
+          @collection.create
+        rescue Mongo::Error::OperationFailure
+          # Already exists
+        end
+
+        @collection.indexes.create_one({tags: 1})
       end
 
       # Purge all data from the capped collection by dropping the collection
@@ -147,22 +155,16 @@ module SemanticLogger
       # Also useful when the size of the capped collection needs to be changed
       def purge_all
         collection.drop
-        @collection = nil
+        reopen
         create_indexes
       end
 
-      # Flush all pending logs to disk.
-      #  Waits for all sent documents to be written to disk
-      def flush
-        db.get_last_error
-      end
-
       # Log the message to MongoDB
       def log(log)
         return false unless should_log?(log)
 
         # Insert log entry into Mongo
-        collection.insert(formatter.call(log, self), w: @write_concern)
+        collection.insert_one(formatter.call(log, self))
         true
       end
 

data/lib/semantic_logger/appender/sentry.rb

@@ -51,10 +51,10 @@ class SemanticLogger::Appender::Sentry < SemanticLogger::Subscriber
       context.delete(:exception)
       Raven.capture_exception(log.exception, context)
     else
-      message = {
+      message             = {
         error_class:   context.delete(:name),
         error_message: context.delete(:message),
-        extra: context
+        extra:         context
       }
       message[:backtrace] = log.backtrace if log.backtrace
       Raven.capture_message(message[:error_message], message)

data/lib/semantic_logger/appender/splunk_http.rb

@@ -65,10 +65,10 @@ class SemanticLogger::Appender::SplunkHttp < SemanticLogger::Appender::Http
   #     Proc: Only include log messages where the supplied Proc returns true
   #           The Proc must return true or false.
   def initialize(options, &block)
-    options             = options.dup
-    @source_type        = options.delete(:source_type)
-    @index              = options.delete(:index)
-    token               = options.delete(:token)
+    options      = options.dup
+    @source_type = options.delete(:source_type)
+    @index       = options.delete(:index)
+    token        = options.delete(:token)
     raise(ArgumentError, 'Missing mandatory parameter :token') unless token
 
     # Splunk supports HTTP Compression, enable by default

data/lib/semantic_logger/appender/syslog.rb

@@ -66,7 +66,7 @@ module SemanticLogger
       #     Only used with the TCP protocol.
       #     Specify custom parameters to pass into Net::TCPClient.new
       #     For a list of options see the net_tcp_client documentation:
-      #       https://www.omniref.com/ruby/gems/net_tcp_client/1.0.0/symbols/Net::TCPClient/initialize
+      #       https://github.com/rocketjob/net_tcp_client/blob/master/lib/net/tcp_client/tcp_client.rb
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
       #     Override the log level for this appender.
@@ -196,7 +196,7 @@ module SemanticLogger
           ::Syslog.open(application, @options, @facility)
         when :tcp
           # Use the local logger for @remote_syslog so errors with the remote logger can be recorded locally.
-          @tcp_client_options[:logger] = SemanticLogger::Logger.logger
+          @tcp_client_options[:logger] = SemanticLogger::Processor.logger.clone
           @remote_syslog               = Net::TCPClient.new(@tcp_client_options)
         when :udp
           @remote_syslog = UDPSocket.new

data/lib/semantic_logger/appender/tcp.rb

@@ -182,12 +182,13 @@ module SemanticLogger
       #     connect_retry_count:    5
       #   )
       def initialize(options = {}, &block)
-        @options                           = options.dup
-        @separator                         = @options.delete(:separator) || "\n"
+        @tcp_client                = nil
+        @options                   = options.dup
+        @separator                 = @options.delete(:separator) || "\n"
 
         # Use the internal logger so that errors with remote logging are only written locally.
-        Net::TCPClient.logger              = SemanticLogger::Logger.logger.dup
-        Net::TCPClient.logger.name         = 'Net::TCPClient'
+        Net::TCPClient.logger      = SemanticLogger::Processor.logger.clone
+        Net::TCPClient.logger.name = 'Net::TCPClient'
 
         options = extract_subscriber_options!(@options)
         super(options, &block)
@@ -205,7 +206,10 @@ module SemanticLogger
       def log(log)
         return false unless should_log?(log)
 
-        @tcp_client.retry_on_connection_failure { @tcp_client.write("#{formatter.call(log, self)}#{separator}") }
+        message = formatter.call(log, self)
+        @tcp_client.retry_on_connection_failure do
+          @tcp_client.write("#{message}#{separator}")
+        end
         true
       end
 

data/lib/semantic_logger/appender/udp.rb

@@ -58,6 +58,7 @@ module SemanticLogger
       #     server:   'server:3300'
       #   )
       def initialize(options = {}, &block)
+        @socket    = nil
         options    = options.dup
         @server    = options.delete(:server)
         @udp_flags = options.delete(:udp_flags) || 0

data/lib/semantic_logger/base.rb

@@ -4,8 +4,6 @@
 #
 #   Implements common behavior such as log level, default text formatter etc
 #
-#   Note: Do not create instances of this class directly
-#
 module SemanticLogger
   class Base
     # Class name to be logged
@@ -116,8 +114,33 @@ module SemanticLogger
       end
     end
 
+    # Backward compatibility
     alias_method :benchmark, :measure
 
+    # Log a thread backtrace
+    def backtrace(thread: Thread.current, level: :warn, message: 'Backtrace:', payload: nil, metric: nil, metric_amount: 1)
+      log       = Log.new(name, level)
+      backtrace =
+        if thread == Thread.current
+          self.class.cleanse_backtrace
+        else
+          log.thread_name = thread.name
+          log.tags        = thread[:semantic_logger_tags].clone
+          log.named_tags  = thread[:semantic_logger_named_tags].clone
+          thread.backtrace
+        end
+      # TODO: Keep backtrace instead of transforming into a text message at this point
+      # Maybe log_backtrace: true
+      if backtrace
+        message += "\n"
+        message << backtrace.join("\n")
+      end
+
+      if log.assign(message: message, backtrace: backtrace, payload: payload, metric: metric, metric_amount: metric_amount) && should_log?(log)
+        self.log(log)
+      end
+    end
+
     # :nodoc:
     def tagged(*tags, &block)
       SemanticLogger.tagged(*tags, &block)
@@ -151,33 +174,16 @@ module SemanticLogger
       SemanticLogger.fast_tag(tag, &block)
     end
 
-    # Thread specific context information to be logged with every log entry
-    #
-    # Add a payload to all log calls on This Thread within the supplied block
-    #
-    #   logger.with_payload(tracking_number: 12345) do
-    #     logger.debug('Hello World')
-    #   end
-    #
-    # If a log call already includes a pyload, this payload will be merged with
-    # the supplied payload, with the supplied payload taking precedence
-    #
-    #   logger.with_payload(tracking_number: 12345) do
-    #     logger.debug('Hello World', result: 'blah')
-    #   end
+    # :nodoc:
     def with_payload(payload)
-      current_payload                          = self.payload
-      Thread.current[:semantic_logger_payload] = current_payload ? current_payload.merge(payload) : payload
-      yield
-    ensure
-      Thread.current[:semantic_logger_payload] = current_payload
+      warn '#with_payload is deprecated, use SemanticLogger.named_tagged'
+      SemanticLogger.named_tagged(payload)
     end
 
-    # Returns [Hash] payload to be added to every log entry in the current scope
-    # on this thread.
-    # Returns nil if no payload is currently set
+    # :nodoc:
     def payload
-      Thread.current[:semantic_logger_payload]
+      warn '#payload is deprecated, use SemanticLogger.named_tags'
+      SemanticLogger.named_tags
     end
 
     protected
@@ -206,9 +212,8 @@ module SemanticLogger
     #    regular expression. All other messages will be ignored
     #    Proc: Only include log messages where the supplied Proc returns true
     #          The Proc must return true or false
-    def initialize(klass, level=nil, filter=nil)
-      # Support filtering all messages to this logger using a Regular Expression
-      # or Proc
+    def initialize(klass, level = nil, filter = nil)
+      # Support filtering all messages to this logger using a Regular Expression or Proc
       raise ':filter must be a Regexp or Proc' unless filter.nil? || filter.is_a?(Regexp) || filter.is_a?(Proc)
 
       @filter = filter.is_a?(Regexp) ? filter.freeze : filter
@@ -247,78 +252,31 @@ module SemanticLogger
     end
 
     # Log message at the specified level
-    def log_internal(level, index, message=nil, payload=nil, exception=nil)
-      # Exception being logged?
-      # Under JRuby a java exception is not a Ruby Exception
-      #   Java::JavaLang::ClassCastException.new.is_a?(Exception) => false
-      if exception.nil? && payload.nil? && message.respond_to?(:backtrace) && message.respond_to?(:message)
-        exception = message
-        message   = nil
-      elsif exception.nil? && payload && payload.respond_to?(:backtrace) && payload.respond_to?(:message)
-        exception = payload
-        payload   = nil
-      end
-
-      # Add result of block as message or payload if not nil
-      if block_given? && (result = yield)
-        if result.is_a?(String)
-          message = message.nil? ? result : "#{message} -- #{result}"
-        elsif message.nil? && result.is_a?(Hash)
-          message = result
-        elsif payload && payload.respond_to?(:merge)
-          payload.merge(result)
+    def log_internal(level, index, message = nil, payload = nil, exception = nil, &block)
+      log        = Log.new(name, level, index)
+      should_log =
+        if payload.nil? && exception.nil? && message.is_a?(Hash)
+          log.assign(message)
         else
-          payload = result
+          log.assign_positional(message, payload, exception, &block)
         end
-      end
 
-      # Add scoped payload
-      if self.payload
-        payload = payload.nil? ? self.payload : self.payload.merge(payload)
-      end
-
-      # Add caller stack trace
-      backtrace = extract_backtrace if index >= SemanticLogger.backtrace_level_index
-
-      log = Log.new(level, Thread.current.name, name, message, payload, Time.now, nil, tags, index, exception, nil, backtrace)
-
-      # Logging Hash only?
-      # logger.info(name: 'value')
-      if payload.nil? && exception.nil? && message.is_a?(Hash)
-        payload           = message.dup
-        min_duration      = payload.delete(:min_duration) || 0.0
-        log.exception     = payload.delete(:exception)
-        log.message       = payload.delete(:message)
-        log.metric        = payload.delete(:metric)
-        log.metric_amount = payload.delete(:metric_amount) || 1
-        if duration = payload.delete(:duration)
-          return false if duration <= min_duration
-          log.duration = duration
-        end
-        log.payload = payload if payload.size > 0
-      end
-
-      self.log(log) if include_message?(log)
-    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
+      self.log(log) if should_log && include_message?(log)
     end
 
     # Measure the supplied block and log the message
     def measure_internal(level, index, message, params)
-      start     = Time.now
       exception = nil
+      result    = nil
+      # Single parameter is a hash
+      if params.empty? && message.is_a?(Hash)
+        params  = message
+        message = nil
+      end
+      start = Time.now
       begin
         if block_given?
-          result    =
+          result =
             if silence_level = params[:silence]
               # In case someone accidentally sets `silence: true` instead of `silence: :error`
               silence_level = :error if silence_level == true
@@ -326,65 +284,40 @@ module SemanticLogger
             else
               yield(params)
             end
-          exception = params[:exception]
-          result
         end
       rescue Exception => exc
         exception = exc
       ensure
-        end_time           = Time.now
-        # Extract options after block completes so that block can modify any of the options
-        log_exception      = params[:log_exception] || :partial
-        on_exception_level = params[:on_exception_level]
-        min_duration       = params[:min_duration] || 0.0
-        payload            = params[:payload]
-        metric             = params[:metric]
-        duration           =
+        # Must use ensure block otherwise a `return` in the yield above will skip the log entry
+        log       = Log.new(name, level, index)
+        exception ||= params[:exception]
+        message   = params[:message] if params[:message]
+        duration  =
           if block_given?
-            1000.0 * (end_time - start)
+            1000.0 * (Time.now - start)
           else
             params[:duration] || raise('Mandatory block missing when :duration option is not supplied')
           end
 
-        # Add scoped payload
-        if self.payload
-          payload = payload.nil? ? self.payload : self.payload.merge(payload)
-        end
-        if exception
-          logged_exception = exception
-          backtrace        = nil
-          case log_exception
-          when :full
-            # On exception change the log level
-            if on_exception_level
-              level = on_exception_level
-              index = SemanticLogger.level_to_index(level)
-            end
-          when :partial
-            # On exception change the log level
-            if on_exception_level
-              level = on_exception_level
-              index = SemanticLogger.level_to_index(level)
-            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
-          log = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, logged_exception, metric, backtrace)
-          self.log(log) if include_message?(log)
-          raise exception
-        elsif duration >= min_duration
-          # Only log if the block took longer than 'min_duration' to complete
-          # Add caller stack trace
-          backtrace = extract_backtrace if index >= SemanticLogger.backtrace_level_index
-
-          log = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, nil, metric, backtrace)
-          self.log(log) if include_message?(log)
-        end
+        # Extract options after block completes so that block can modify any of the options
+        payload   = params[:payload]
+
+        should_log = log.assign(
+          message:            message,
+          payload:            payload,
+          min_duration:       params[:min_duration] || 0.0,
+          exception:          exception,
+          metric:             params[:metric],
+          metric_amount:      1,
+          duration:           duration,
+          backtrace:          nil,
+          log_exception:      params[:log_exception] || :partial,
+          on_exception_level: params[:on_exception_level]
+        )
+
+        self.log(log) if should_log && include_message?(log)
+        raise exception if exception
+        result
       end
     end