semantic_logger 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7010f9d28a473c9cd0c9fb9d52608216bad68043
-  data.tar.gz: 052152f47b9eb211a26c47a2bbbff8742f497449
+  metadata.gz: efbdb066c354033b8f3e16d20855e5cd41a9ca14
+  data.tar.gz: cbbf43104fc6fc965f0aceb66c1aa39e83927779
 SHA512:
-  metadata.gz: 17d21c7f8bc35b93e52074cfac26bb0c350c989b589a8fb4a096c43a71148b4e245ace66ef36c8af9693355dc3741623896afb48bc2a01473b062a3ee1b6111a
-  data.tar.gz: 43eaa8a554e95b8936e4a595593977e30a98b849dcaa9d419762420a0f3edcd03d9f1f923cdeda2897b48332c1b5bcd89a9500f1df181d57283e56c11cc296ac
+  metadata.gz: 973c536da77a0c8346c039a2564aa7d01b70b4e5ff859e0d7c45eb5c956affa41e052302d87ef7483c72cf7b2868d73ccc3a6280edc9d78f2aae3d8adfa93db0
+  data.tar.gz: 13e0efe329c732223cb76e12289a934c556830d424b9881e52dcd8023f76b0a8e9c8c17734fa2f1f822d67ee673945fe5c0da3aeb6be6c70cd15489baf9fb4ba

data/README.md

@@ -65,7 +65,7 @@ require 'semantic_logger'
 SemanticLogger.default_level = :trace
 
 # Log to a file, and use the colorized formatter
-SemanticLogger.add_appender(file: 'development.log', formatter: :color)
+SemanticLogger.add_appender(file_name: 'development.log', formatter: :color)
 ```
 
 If running rails, see: [Semantic Logger Rails](http://rocketjob.github.io/semantic_logger/rails.html)

data/lib/semantic_logger.rb

@@ -17,6 +17,7 @@ module SemanticLogger
     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 :Http,             'semantic_logger/appender/http'
     autoload :MongoDB,          'semantic_logger/appender/mongodb'
     autoload :NewRelic,         'semantic_logger/appender/new_relic'

data/lib/semantic_logger/appender/bugsnag.rb

@@ -52,12 +52,9 @@ class SemanticLogger::Appender::Bugsnag < SemanticLogger::Appender::Base
 
   # Send an error notification to Bugsnag
   def log(log)
-    # Only log if level is warn, or error.
-    return false if (level_index > (log.level_index || 0)) ||
-      # Ignore logs coming from Bugsnag itself
-      (log.name == 'Bugsnag') ||
-      # Filtered out?
-      !include_message?(log)
+    return false unless should_log?(log)
+    # Ignore logs coming from Bugsnag itself
+    return false if log.name == 'Bugsnag'
 
     # Send error messages as Runtime exceptions
     exception =

data/lib/semantic_logger/appender/elasticsearch.rb

@@ -47,8 +47,7 @@ class SemanticLogger::Appender::Elasticsearch < SemanticLogger::Appender::Http
 
   # Log to the index for today
   def log(log)
-    return false if (level_index > (log.level_index || 0)) ||
-      !include_message?(log) # Filtered out?
+    return false unless should_log?(log)
 
     post(formatter.call(log, self), "#{index}-#{log.time.strftime('%Y.%m.%d')}/#{type}")
   end

data/lib/semantic_logger/appender/file.rb

@@ -109,8 +109,7 @@ module SemanticLogger
       #  trace entries are mapped to debug since :trace is not supported by the
       #  Ruby or Rails Loggers
       def log(log)
-        # Ensure minimum log level is met, and check filter
-        return false if (level_index > (log.level_index || 0)) || !include_message?(log)
+        return false unless should_log?(log)
 
         # Since only one appender thread will be writing to the file at a time
         # it is not necessary to protect access to the file with a semaphore

data/lib/semantic_logger/appender/graylog.rb

@@ -112,8 +112,7 @@ class SemanticLogger::Appender::Graylog < SemanticLogger::Appender::Base
 
   # Forward log messages
   def log(log)
-    return false if (level_index > (log.level_index || 0)) ||
-      !include_message?(log) # Filtered out?
+    return false unless should_log?(log)
 
     @notifier.notify!(formatter.call(log, self))
     true

data/lib/semantic_logger/appender/honeybadger.rb

@@ -0,0 +1,56 @@
+begin
+  require 'honeybadger'
+rescue LoadError
+  raise 'Gem honeybadger is required for logging purposes. Please add the gem "honeybadger" to your Gemfile.'
+end
+
+# Send log messages to honeybadger
+#
+# Example:
+#   SemanticLogger.add_appender(appender: :honeybadger)
+#
+class SemanticLogger::Appender::Honeybadger < SemanticLogger::Appender::Base
+  # Create Appender
+  #
+  # Parameters
+  #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+  #     Override the log level for this appender.
+  #     Default: :error
+  #
+  #   formatter: [Object|Proc]
+  #     An instance of a class that implements #call, or a Proc to be used to format
+  #     the output from this appender
+  #     Default: Use the built-in formatter (See: #call)
+  #
+  #   filter: [Regexp|Proc]
+  #     RegExp: Only include log messages where the class name matches the supplied.
+  #     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)
+    options  = {level: options} unless options.is_a?(Hash)
+    @options = options.dup
+    level    = @options.delete(:level) || :error
+
+    super(level, &block)
+  end
+
+  # Send an error notification to honeybadger
+  def log(log)
+    return false unless should_log?(log)
+
+    if log.exception
+      Honeybadger.notify(log.exception, log.to_h)
+    else
+      message = {
+        error_class:   log.name,
+        error_message: log.message,
+        backtrace:     log.backtrace,
+        context:       log.to_h,
+      }
+      Honeybadger.notify(message)
+    end
+    true
+  end
+
+end

data/lib/semantic_logger/appender/http.rb

@@ -16,7 +16,8 @@ require 'json'
 #     url:      'http://localhost:8088/path'
 #   )
 class SemanticLogger::Appender::Http < SemanticLogger::Appender::Base
-  attr_accessor :username, :application, :host, :compress, :header
+  attr_accessor :username, :application, :host, :compress, :header,
+    :open_timeout, :read_timeout, :continue_timeout
   attr_reader :http, :url, :server, :port, :path, :ssl_options
 
   # Create HTTP(S) log appender
@@ -67,15 +68,28 @@ class SemanticLogger::Appender::Http < SemanticLogger::Appender::Base
   #     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.
+  #
+  #   open_timeout: [Float]
+  #     Default: 2.0
+  #
+  #   read_timeout: [Float]
+  #     Default: 1.0
+  #
+  #   continue_timeout: [Float]
+  #     Default: 1.0
   def initialize(options, &block)
-    options      = options.dup
-    @url         = options.delete(:url)
-    @ssl_options = options.delete(:ssl)
-    @username    = options.delete(:username)
-    @password    = options.delete(:password)
-    @application = options.delete(:application) || 'Semantic Logger'
-    @host        = options.delete(:host) || SemanticLogger.host
-    @compress    = options.delete(:compress) || false
+    options           = options.dup
+    @url              = options.delete(:url)
+    @ssl_options      = options.delete(:ssl)
+    @username         = options.delete(:username)
+    @password         = options.delete(:password)
+    @application      = options.delete(:application) || 'Semantic Logger'
+    @host             = options.delete(:host) || SemanticLogger.host
+    @compress         = options.delete(:compress) || false
+    @open_timeout     = options.delete(:open_timeout) || 2.0
+    @read_timeout     = options.delete(:read_timeout) || 1.0
+    @continue_timeout = options.delete(:continue_timeout) || 1.0
+
     unless options.has_key?(:formatter)
       options[:formatter] = block || (respond_to?(:call) ? self : SemanticLogger::Formatters::Json.new)
     end
@@ -109,12 +123,16 @@ class SemanticLogger::Appender::Http < SemanticLogger::Appender::Base
   def reopen
     # On Ruby v2.0 and greater, Net::HTTP.new uses a persistent connection if the server allows it
     @http = @ssl_options ? Net::HTTP.new(server, port, @ssl_options) : Net::HTTP.new(server, port)
+
+    @http.open_timeout     = @open_timeout
+    @http.read_timeout     = @read_timeout
+    @http.continue_timeout = @continue_timeout
   end
 
   # Forward log messages to HTTP Server
   def log(log)
-    return false if (level_index > (log.level_index || 0)) ||
-      !include_message?(log) # Filtered out?
+    return false unless should_log?(log)
+
     post(formatter.call(log, self))
   end
 
@@ -158,7 +176,7 @@ class SemanticLogger::Appender::Http < SemanticLogger::Appender::Base
       true
     else
       # Failures are logged to the global semantic logger failsafe logger (Usually stderr or file)
-      SemanticLogger::Logger.logger.error("Bad HTTP response code: #{response.code}, #{response.body}")
+      SemanticLogger::Logger.logger.error("Bad HTTP response from: #{url} code: #{response.code}, #{response.body}")
       false
     end
   end

data/lib/semantic_logger/appender/mongodb.rb

@@ -171,8 +171,7 @@ module SemanticLogger
 
       # Log the message to MongoDB
       def log(log)
-        # Ensure minimum log level is met, and check filter
-        return false if (level_index > (log.level_index || 0)) || !include_message?(log)
+        return false unless should_log?(log)
 
         # Insert log entry into Mongo
         collection.insert(formatter.call(log, self), w: @write_concern)

data/lib/semantic_logger/appender/new_relic.rb

@@ -47,8 +47,7 @@ class SemanticLogger::Appender::NewRelic < SemanticLogger::Appender::Base
 
   # Send an error notification to New Relic
   def log(log)
-    # Ensure minimum log level is met, and check filter
-    return false if (level_index > (log.level_index || 0)) || !include_message?(log)
+    return false unless should_log?(log)
 
     # Send error messages as Runtime exceptions
     exception =

data/lib/semantic_logger/appender/splunk.rb

@@ -4,61 +4,121 @@ rescue LoadError
   raise 'Gem splunk-sdk-ruby is required for logging to Splunk. Please add the gem "splunk-sdk-ruby" to your Gemfile.'
 end
 
-# Note: This appender is Deprecated. Use: SemanticLogger::Appender::SplunkHttp
+# Splunk log appender.
+#
+# Use the official splunk gem to log messages to Splunk.
+#
+# Example
+#   SemanticLogger.add_appender(
+#     appender: :splunk,
+#     username: 'username',
+#     password: 'password',
+#     host:     'localhost',
+#     port:     8089,
+#     scheme:   :https,
+#     index:    'main'
+#   )
 class SemanticLogger::Appender::Splunk < SemanticLogger::Appender::Base
   attr_reader :config, :index, :service, :service_index
 
-  # DEPRECATED, Please use SemanticLogger::Appender::SplunkHttp
-  def initialize(options, level=:error, &block)
-    Kernel.warn('Splunk Appender is deprecated, please use SemanticLogger::Appender::SplunkHttp')
+  # Write to Splunk.
+  #
+  # Parameters
+  #   :username [String]
+  #     User name to log into splunk with.
+  #     Not required if :token has been supplied.
+  #
+  #   :password [String]
+  #     Password to log into splunk with.
+  #     Not required if :token has been supplied.
+  #
+  #   :token
+  #     Supply a preauthenticated Splunk token instead of username and password.
+  #     Not required if username and password are supplied.
+  #
+  #   :host [String]
+  #      Splunk host name.
+  #      Default: 'localhost'
+  #
+  #   :port [Integer]
+  #      The Splunk management port.
+  #      Default: 8089
+  #
+  #   :scheme [Symbol]
+  #     Either :https or :http
+  #     Default: :https
+  #
+  #   :index [String]
+  #      Splunk index to use.
+  #      Default: 'main'
+  #
+  #   :namespace [Namespace]
+  #      Application namespace instance.
+  #
+  #   :ssl_client_cert [OpenSSL::X509::Certificate]
+  #     Client certificate.
+  #
+  #   :ssl_client_key [OpenSSL::PKey::RSA | OpenSSL::PKey::DSA]
+  #     Client key.
+  #
+  #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+  #     Override the log level for this appender.
+  #     Default: SemanticLogger.default_level
+  #
+  #   formatter: [Object|Proc]
+  #     An instance of a class that implements #call, or a Proc to be used to format
+  #     the output from this appender
+  #     Default: Use the built-in formatter (See: #call)
+  #
+  #   filter: [Regexp|Proc]
+  #     RegExp: Only include log messages where the class name matches the supplied.
+  #     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, _deprecated_level = nil, &block)
+    @config         = options.dup
+    @config[:level] = _deprecated_level if _deprecated_level
+    @index          = @config.delete(:index) || 'main'
 
-    # Parse input options for setting up splunk connection
-    parse_options(options)
+    options = {
+      level:     @config.delete(:level) || :error,
+      formatter: @config.delete(:formatter),
+      filter:    @config.delete(:filter)
+    }
 
     reopen
 
     # Pass on the level and custom formatter if supplied
-    super(level: level, &block)
+    super(options, &block)
   end
 
   # After forking an active process call #reopen to re-open
   # open the handles to resources
   def reopen
     # Connect to splunk. Connect is a synonym for creating a Service by hand and calling login.
-    @service       = Splunk::connect(@config)
+    self.service       = Splunk::connect(config)
 
     # The index we are logging to
-    @service_index = @service.indexes[@index]
+    self.service_index = service.indexes[index]
   end
 
   # Log the message to Splunk
   def log(log)
-    # Ensure minimum log level is met, and check filter
-    return false if (level_index > (log.level_index || 0)) || !include_message?(log)
-    # Submit the log message
-    @service_index.submit(formatter.call(log, self))
+    return false unless should_log?(log)
+
+    service_index.submit(log.message, formatter.call(log, self))
     true
   end
 
-  private
-
-  def parse_options(options)
-    @config = {
-      scheme:   options[:scheme] || :https,
-      host:     options[:host] || 'localhost',
-      port:     options[:port] || 8089,
-      username: options[:username],
-      password: options[:password]
-    }
-
-    @index = options[:index] || 'main'
-
-    if @config[:username].nil?
-      raise ArgumentError, 'Must supply a username.'
-    elsif @config[:password].nil?
-      raise ArgumentError, 'Must supply a password.'
-    elsif @index.nil?
-      raise ArgumentError, 'Must supply an index.'
-    end
+  # Returns [String] JSON to send to Splunk
+  # For splunk format requirements see:
+  #   http://dev.splunk.com/view/event-collector/SP-CAAAE6P
+  def call(log, _logger)
+    h = log.to_h
+    h.delete(:message)
+    h.delete(:application)
+    h.delete(:host)
+    h.delete(:time)
+    h
   end
 end

data/lib/semantic_logger/appender/splunk_http.rb

@@ -1,5 +1,5 @@
 require 'json'
-# Splunk log appender.
+# Splunk log appender using the Splunk HTTP(S) listener.
 #
 # Use the newer, faster and more complete JSON over HTTP interface for Splunk.
 #

data/lib/semantic_logger/appender/syslog.rb

@@ -211,8 +211,7 @@ module SemanticLogger
 
       # Write the log using the specified protocol and server.
       def log(log)
-        # Ensure minimum log level is met, and check filter
-        return false if (level_index > (log.level_index || 0)) || !include_message?(log)
+        return false unless should_log?(log)
 
         case @protocol
         when :syslog

data/lib/semantic_logger/appender/wrapper.rb

@@ -58,8 +58,7 @@ module SemanticLogger
       #  trace entries are mapped to debug since :trace is not supported by the
       #  Ruby or Rails Loggers
       def log(log)
-        # Ensure minimum log level is met, and check filter
-        return false if (level_index > (log.level_index || 0)) || !include_message?(log)
+        return false unless should_log?(log)
 
         @logger.send(log.level == :trace ? :debug : log.level, formatter.call(log, self))
         true

data/lib/semantic_logger/base.rb

@@ -62,7 +62,7 @@ module SemanticLogger
     #    SemanticLogger.add_appender(io: STDOUT, formatter: :color)
     #
     #    # And log to a file at the same time
-    #    SemanticLogger.add_appender(file: 'application.log', formatter: :color)
+    #    SemanticLogger.add_appender(file_name: 'application.log', formatter: :color)
     #
     #    logger = SemanticLogger['MyApplication']
     #    logger.debug("Only display this if log level is set to Debug or lower")
@@ -118,51 +118,37 @@ module SemanticLogger
 
     alias_method :benchmark, :measure
 
-    # If the tag being supplied is definitely a string then this fast
-    # tag api can be used for short lived tags
-    def fast_tag(tag)
-      (Thread.current[:semantic_logger_tags] ||= []) << tag
-      yield
-    ensure
-      Thread.current[:semantic_logger_tags].pop
-    end
-
-    # Add the supplied tags to the list of tags to log for this thread whilst
-    # the supplied block is active
-    # Returns nil if no tags are currently set
-    #   To support: ActiveSupport::TaggedLogging V3 and above
-    def tagged(*tags)
-      new_tags = push_tags(*tags)
-      yield self
-    ensure
-      pop_tags(new_tags.size)
+    # :nodoc:
+    def tagged(*tags, &block)
+      SemanticLogger.tagged(*tags, &block)
     end
 
-    # Previous method for supplying tags
+    # :nodoc:
     alias_method :with_tags, :tagged
 
-    # Returns a copy of the [Array] of [String] tags currently active for this thread
-    # Returns nil if no tags are set
+    # :nodoc:
     def tags
-      # Since tags are stored on a per thread basis this list is thread-safe
-      t = Thread.current[:semantic_logger_tags]
-      t.nil? ? [] : t.clone
+      SemanticLogger.tags
+    end
+
+    # :nodoc:
+    def push_tags(*tags)
+      SemanticLogger.push_tags(*tags)
+    end
+
+    # :nodoc:
+    def pop_tags(quantity = 1)
+      SemanticLogger.pop_tags(quantity)
     end
 
-    # Add tags to the current scope
-    # Returns the list of tags pushed after flattening them out and removing blanks
-    def push_tags *tags
-      # Need to flatten and reject empties to support calls from Rails 4
-      new_tags                              = tags.flatten.collect(&:to_s).reject(&:empty?)
-      t                                     = Thread.current[:semantic_logger_tags]
-      Thread.current[:semantic_logger_tags] = t.nil? ? new_tags : t.concat(new_tags)
-      new_tags
+    # :nodoc:
+    def silence(new_level = :error, &block)
+      SemanticLogger.silence(new_level, &block)
     end
 
-    # Remove specified number of tags from the current tag list
-    def pop_tags(quantity=1)
-      t = Thread.current[:semantic_logger_tags]
-      t.pop(quantity) unless t.nil?
+    # :nodoc:
+    def fast_tag(tag, &block)
+      SemanticLogger.fast_tag(tag, &block)
     end
 
     # Thread specific context information to be logged with every log entry
@@ -194,62 +180,6 @@ module SemanticLogger
       Thread.current[:semantic_logger_payload]
     end
 
-    # Silence noisy log levels by changing the default_level within the block
-    #
-    # This setting is thread-safe and only applies to the current thread
-    #
-    # Any threads spawned within the block will not be affected by this setting
-    #
-    # #silence can be used to both raise and lower the log level within
-    # the supplied block.
-    #
-    # Example:
-    #
-    #   # Perform trace level logging within the block when the default is higher
-    #   SemanticLogger.default_level = :info
-    #
-    #   logger.debug 'this will _not_ be logged'
-    #
-    #   logger.silence(:trace) do
-    #     logger.debug "this will be logged"
-    #   end
-    #
-    # Parameters
-    #   new_level
-    #     The new log level to apply within the block
-    #     Default: :error
-    #
-    # Example:
-    #   # Silence all logging below :error level
-    #   logger.silence do
-    #     logger.info "this will _not_ be logged"
-    #     logger.warn "this neither"
-    #     logger.error "but errors will be logged"
-    #   end
-    #
-    # Note:
-    #   #silence does not affect any loggers which have had their log level set
-    #   explicitly. I.e. That do not rely on the global default level
-    def silence(new_level = :error)
-      current_index                            = Thread.current[:semantic_logger_silence]
-      Thread.current[:semantic_logger_silence] = SemanticLogger.level_to_index(new_level)
-      yield
-    ensure
-      Thread.current[:semantic_logger_silence] = current_index
-    end
-
-    # DEPRECATED See SemanticLogger.default_level=
-    def self.default_level=(level)
-      warn '[DEPRECATION] SemanticLogger::Logger.default_level= is deprecated.  Please use SemanticLogger.default_level= instead.'
-      SemanticLogger.default_level = level
-    end
-
-    # DEPRECATED See SemanticLogger.default_level
-    def self.default_level
-      warn '[DEPRECATION] SemanticLogger::Logger.default_level is deprecated.  Please use SemanticLogger.default_level instead.'
-      SemanticLogger.default_level
-    end
-
     protected
 
     # Write log data to underlying data storage
@@ -304,6 +234,12 @@ module SemanticLogger
       end
     end
 
+    # Whether the log message should be logged for the current logger or appender
+    def should_log?(log)
+      # Ensure minimum log level is met, and check filter
+      (level_index <= (log.level_index || 0)) && include_message?(log)
+    end
+
     # Log message at the specified level
     def log_internal(level, index, message=nil, payload=nil, exception=nil)
       # Exception being logged?

data/lib/semantic_logger/logger.rb

@@ -85,21 +85,14 @@ module SemanticLogger
       @@logger = logger
     end
 
-    # DEPRECATED See SemanticLogger.add_appender
-    def self.appenders
-      warn '[DEPRECATION] SemanticLogger::Logger.appenders is deprecated.  Please use SemanticLogger.add_appender instead.'
-      SemanticLogger.appenders
-    end
-
-    # DEPRECATED: Please use queue_size instead.
-    def self.cache_count
-      warn '[DEPRECATION] SemanticLogger::Logger.cache_count is deprecated.  Please use SemanticLogger::Logger.queue_size instead.'
-      queue_size
-    end
-
-    # Supply a block to be called whenever a metric is seen during measure logging
+    # Supply a metrics appender to be called whenever a logging metric is encountered
     #
     #  Parameters
+    #    appender: [Symbol | Object | Proc]
+    #      [Proc] the block to call.
+    #      [Object] the block on which to call #call.
+    #      [Symbol] :new_relic, or :statsd to forward metrics to
+    #
     #    block
     #      The block to be called
     #
@@ -107,9 +100,21 @@ module SemanticLogger
     #   SemanticLogger.on_metric do |log|
     #     puts "#{log.metric} was received. Log Struct: #{log.inspect}"
     #   end
-    def self.on_metric(object = nil, &block)
-      raise('When supplying an object, it must support the #call method') if object && !object.respond_to?(:call)
-      (@@metric_subscribers ||= Concurrent::Array.new) << (object || block)
+    #
+    # Note:
+    # * This callback is called in the logging thread.
+    # * Does not slow down the application.
+    # * Only context is what is passed in the log struct, the original thread context is not available.
+    def self.on_metric(options = {}, &block)
+      # Backward compatibility
+      options  = options.is_a?(Hash) ? options.dup : {appender: options}
+      appender = block || options.delete(:appender)
+
+      # Convert symbolized metrics appender to an actual object
+      appender = named_appender(appender, 'SemanticLogger::Appender::Metrics').new(options) if appender.is_a?(Symbol)
+
+      raise('When supplying a metrics appender, it must support the #call method') unless appender.is_a?(Proc) || appender.respond_to?(:call)
+      (@@metric_subscribers ||= Concurrent::Array.new) << appender
     end
 
     # Place log request on the queue for the Appender thread to write to each
@@ -168,7 +173,7 @@ module SemanticLogger
       begin
         count = 0
         while message = queue.pop
-          if message.is_a? Log
+          if message.is_a?(Log)
             SemanticLogger.appenders.each do |appender|
               begin
                 appender.log(message)

data/lib/semantic_logger/metrics/new_relic.rb

@@ -1,10 +1,22 @@
 module SemanticLogger
   module Metrics
     class NewRelic
+      attr_accessor :prefix
+
+      # Parameters:
+      #   :prefix [String]
+      #     Prefix to add to every metric before forwarding to NewRelic
+      #     Default: 'Custom'
+      def initialize(options = {})
+        options = options.dup
+        @prefix = options.delete(:prefix) || 'Custom'
+        raise(ArgumentError, "Unknown options: #{options.inspect}") if options.size > 0
+      end
+
       def call(log)
         metric = log.metric
-        # Add 'Custom/' prefix for NewRelic
-        metric = "Custom/#{metric}" unless metric.start_with?('Custom')
+        # Add prefix for NewRelic
+        metric = "#{prefix}/#{metric}" unless metric.start_with?(prefix)
 
         if duration = log.duration
           # Convert duration to seconds

data/lib/semantic_logger/metrics/statsd.rb

@@ -32,13 +32,13 @@ module SemanticLogger
       def call(log)
         metric = log.metric
         if duration = log.duration
-          $statsd.timing(metric, duration)
+          @statsd.timing(metric, duration)
         else
           amount = (log.metric_amount || 1).round
           if amount < 0
-            amount.times { $statsd.decrement(metric) }
+            amount.times { @statsd.decrement(metric) }
           else
-            amount.times { $statsd.increment(metric) }
+            amount.times { @statsd.increment(metric) }
           end
         end
       end

data/lib/semantic_logger/semantic_logger.rb

@@ -192,6 +192,11 @@ module SemanticLogger
   # Supply a block to be called whenever a metric is seen during measure logging
   #
   #  Parameters
+  #    appender: [Symbol | Object | Proc]
+  #      [Proc] the block to call.
+  #      [Object] the block on which to call #call.
+  #      [Symbol] :new_relic, or :statsd to forward metrics to
+  #
   #    block
   #      The block to be called
   #
@@ -199,8 +204,13 @@ module SemanticLogger
   #   SemanticLogger.on_metric do |log|
   #     puts "#{log.metric} was received. Log Struct: #{log.inspect}"
   #   end
-  def self.on_metric(object = nil, &block)
-    SemanticLogger::Logger.on_metric(object, &block)
+  #
+  # Note:
+  # * This callback is called in the logging thread.
+  # * Does not slow down the application.
+  # * Only context is what is passed in the log struct, the original thread context is not available.
+  def self.on_metric(options = {}, &block)
+    SemanticLogger::Logger.on_metric(options, &block)
   end
 
   # Add signal handlers for Semantic Logger
@@ -271,6 +281,106 @@ module SemanticLogger
     true
   end
 
+  # If the tag being supplied is definitely a string then this fast
+  # tag api can be used for short lived tags
+  def self.fast_tag(tag)
+    (Thread.current[:semantic_logger_tags] ||= []) << tag
+    yield
+  ensure
+    Thread.current[:semantic_logger_tags].pop
+  end
+
+  # Add the supplied named tags to the list of tags to log for this thread whilst
+  # the supplied block is active.
+  #
+  # Returns result of block
+  #
+  # Example:
+  def self.named_tags(tag)
+    (Thread.current[:semantic_logger_tags] ||= []) << tag
+    yield
+  ensure
+    Thread.current[:semantic_logger_tags].pop
+  end
+
+  # Add the supplied tags to the list of tags to log for this thread whilst
+  # the supplied block is active.
+  # Returns result of block
+  def self.tagged(*tags)
+    new_tags = push_tags(*tags)
+    yield self
+  ensure
+    pop_tags(new_tags.size)
+  end
+
+  # Returns a copy of the [Array] of [String] tags currently active for this thread
+  # Returns nil if no tags are set
+  def self.tags
+    # Since tags are stored on a per thread basis this list is thread-safe
+    t = Thread.current[:semantic_logger_tags]
+    t.nil? ? [] : t.clone
+  end
+
+  # Add tags to the current scope
+  # Returns the list of tags pushed after flattening them out and removing blanks
+  def self.push_tags(*tags)
+    # Need to flatten and reject empties to support calls from Rails 4
+    new_tags                              = tags.flatten.collect(&:to_s).reject(&:empty?)
+    t                                     = Thread.current[:semantic_logger_tags]
+    Thread.current[:semantic_logger_tags] = t.nil? ? new_tags : t.concat(new_tags)
+    new_tags
+  end
+
+  # Remove specified number of tags from the current tag list
+  def self.pop_tags(quantity=1)
+    t = Thread.current[:semantic_logger_tags]
+    t.pop(quantity) unless t.nil?
+  end
+
+  # Silence noisy log levels by changing the default_level within the block
+  #
+  # This setting is thread-safe and only applies to the current thread
+  #
+  # Any threads spawned within the block will not be affected by this setting
+  #
+  # #silence can be used to both raise and lower the log level within
+  # the supplied block.
+  #
+  # Example:
+  #
+  #   # Perform trace level logging within the block when the default is higher
+  #   SemanticLogger.default_level = :info
+  #
+  #   logger.debug 'this will _not_ be logged'
+  #
+  #   SemanticLogger.silence(:trace) do
+  #     logger.debug "this will be logged"
+  #   end
+  #
+  # Parameters
+  #   new_level
+  #     The new log level to apply within the block
+  #     Default: :error
+  #
+  # Example:
+  #   # Silence all logging for this thread below :error level
+  #   SemanticLogger.silence do
+  #     logger.info "this will _not_ be logged"
+  #     logger.warn "this neither"
+  #     logger.error "but errors will be logged"
+  #   end
+  #
+  # Note:
+  #   #silence does not affect any loggers which have had their log level set
+  #   explicitly. I.e. That do not rely on the global default level
+  def self.silence(new_level = :error)
+    current_index                            = Thread.current[:semantic_logger_silence]
+    Thread.current[:semantic_logger_silence] = SemanticLogger.level_to_index(new_level)
+    yield
+  ensure
+    Thread.current[:semantic_logger_silence] = current_index
+  end
+
   private
 
   @@appenders = Concurrent::Array.new
@@ -345,14 +455,14 @@ module SemanticLogger
     end
   end
 
-  def self.named_appender(appender)
+  def self.named_appender(appender, root = 'SemanticLogger::Appender')
     appender = appender.to_s
     klass    = appender.respond_to?(:camelize) ? appender.camelize : camelize(appender)
-    klass    = "SemanticLogger::Appender::#{klass}"
+    klass    = "#{root}::#{klass}"
     begin
       appender.respond_to?(:constantize) ? klass.constantize : eval(klass)
     rescue NameError
-      raise(ArgumentError, "Could not find appender class: #{klass} for #{appender}")
+      raise(ArgumentError, "Could not find #{root} class: #{klass} for #{appender}")
     end
   end
 

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = '3.1.0'
+  VERSION = '3.2.0'
 end

data/test/appender/honeybadger_test.rb

@@ -0,0 +1,40 @@
+require_relative '../test_helper'
+
+# Unit Test for SemanticLogger::Appender::Bugsnag
+module Appender
+  class HoneybadgerTest < Minitest::Test
+    describe SemanticLogger::Appender::Honeybadger do
+      before do
+        @appender = SemanticLogger::Appender::Honeybadger.new(:trace)
+        @message  = 'AppenderHoneybadgerTest log message'
+      end
+
+      SemanticLogger::LEVELS.each do |level|
+        it "sends #{level} message" do
+          hash = nil
+          Honeybadger.stub(:notify, -> h { hash = h }) do
+            @appender.send(level, @message)
+          end
+          assert_equal @message, hash[:error_message]
+          assert_equal 'SemanticLogger::Appender::Honeybadger', hash[:error_class]
+          assert_equal true, hash.has_key?(:backtrace)
+          assert_equal true, hash.has_key?(:context)
+          assert_equal level, hash[:context][:level]
+        end
+
+        it "sends #{level} exceptions" do
+          error     = RuntimeError.new('Oh no, Error.')
+          exception = hash = nil
+          Honeybadger.stub(:notify, -> exc, h { exception = exc; hash = h }) do
+            @appender.send(level, @message, error)
+          end
+
+          assert_equal error.class.to_s, exception.class.to_s
+          assert_equal error.message, exception.message
+          assert_equal @message, hash[:message], hash
+        end
+      end
+
+    end
+  end
+end

data/test/appender/splunk_test.rb

@@ -4,45 +4,76 @@ require_relative '../test_helper'
 #
 module Appender
   class SplunkTest < 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
+    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(level: :info)
+        end
+        @message = 'AppenderSplunkTest log message'
+      end
 
-            assert_equal 'Must supply a username.', error.message
-          end
+      it 'not send :trace notifications to Splunk when set to :error' do
+        mock = Mock.new
+        @appender.stub(:service_index, mock) do
+          @appender.trace('AppenderSplunkTest trace message')
+        end
+        assert_nil mock.event
+        assert_nil mock.message
+      end
 
-          it 'raise argument error for missing password' do
-            error = assert_raises ArgumentError do
-              SemanticLogger::Appender::Splunk.new(username: 'username')
-            end
+      it 'send exception notifications to Splunk with severity' do
+        hash = nil
+        exc  = nil
+        begin
+          Uh oh
+        rescue Exception => e
+          exc = e
+        end
+        mock = Mock.new
+        @appender.stub(:service_index, mock) do
+          @appender.error 'Reading File', exc
+        end
+        assert_equal 'Reading File', mock.message
+        hash = mock.event
+        refute hash[:message]
+        assert 'NameError', hash[:exception][:name]
+        assert 'undefined local variable or method', hash[:exception][:message]
+        assert_equal 4, hash[:level_index], 'Should be error level (4)'
+        assert_equal :error, hash[:level]
+        assert hash[:exception][:stack_trace].first.include?(__FILE__), hash[:exception]
+      end
 
-            assert_equal 'Must supply a password.', error.message
-          end
+      it 'send error notifications to Splunk with severity' do
+        mock = Mock.new
+        @appender.stub(:service_index, mock) do
+          @appender.error @message
         end
+        assert_equal @message, mock.message
+        assert_equal :error, mock.event[:level]
+        refute mock.event[:stack_trace]
+      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
+      it 'send notification to Splunk with custom attributes' do
+        mock = Mock.new
+        @appender.stub(:service_index, mock) do
+          @appender.error @message, {key1: 1, key2: 'a'}
         end
+        assert_equal @message, mock.message
+        hash = mock.event
+        assert_equal :error, hash[:level]
+        refute hash[:stack_trace]
+        assert_equal(1, hash[:key1], hash)
+        assert_equal('a', hash[:key2], hash)
       end
 
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-27 00:00:00.000000000 Z
+date: 2016-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -42,6 +42,7 @@ files:
 - lib/semantic_logger/appender/elasticsearch.rb
 - lib/semantic_logger/appender/file.rb
 - lib/semantic_logger/appender/graylog.rb
+- lib/semantic_logger/appender/honeybadger.rb
 - lib/semantic_logger/appender/http.rb
 - lib/semantic_logger/appender/mongodb.rb
 - lib/semantic_logger/appender/new_relic.rb
@@ -68,6 +69,7 @@ files:
 - test/appender/elasticsearch_test.rb
 - test/appender/file_test.rb
 - test/appender/graylog_test.rb
+- test/appender/honeybadger_test.rb
 - test/appender/http_test.rb
 - test/appender/mongodb_test.rb
 - test/appender/new_relic_test.rb
@@ -111,6 +113,7 @@ test_files:
 - test/appender/elasticsearch_test.rb
 - test/appender/file_test.rb
 - test/appender/graylog_test.rb
+- test/appender/honeybadger_test.rb
 - test/appender/http_test.rb
 - test/appender/mongodb_test.rb
 - test/appender/new_relic_test.rb