semantic_logger 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 50213eafcd6560b8240844cfb686a2a954537091
-  data.tar.gz: d6df1d6905b315ccef4915cf59b819e62d2697bf
+  metadata.gz: 7010f9d28a473c9cd0c9fb9d52608216bad68043
+  data.tar.gz: 052152f47b9eb211a26c47a2bbbff8742f497449
 SHA512:
-  metadata.gz: 048295e8e5a07f91ffe44a2108cb12135fbcfb25d604ad3ec0656e41cc0435689dc215de8bd0c994b81ec1fcf4e850e46d7733c7e2a5676e3b2e92ecc42971e5
-  data.tar.gz: ce6f018889578dc8a44855e2bfc528d939cf5b8c0bd4872c41f55b5e1537adb8e99cd231c86e4829164bea1a5f1c2b728c2df52c566d79d73bcbf7bf578370b5
+  metadata.gz: 17d21c7f8bc35b93e52074cfac26bb0c350c989b589a8fb4a096c43a71148b4e245ace66ef36c8af9693355dc3741623896afb48bc2a01473b062a3ee1b6111a
+  data.tar.gz: 43eaa8a554e95b8936e4a595593977e30a98b849dcaa9d419762420a0f3edcd03d9f1f923cdeda2897b48332c1b5bcd89a9500f1df181d57283e56c11cc296ac

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('development.log', &SemanticLogger::Appender::Base.colorized_formatter)
+SemanticLogger.add_appender(file: 'development.log', formatter: :color)
 ```
 
 If running rails, see: [Semantic Logger Rails](http://rocketjob.github.io/semantic_logger/rails.html)

data/lib/semantic_logger.rb

@@ -4,6 +4,7 @@ require 'semantic_logger/semantic_logger'
 
 # @formatter:off
 module SemanticLogger
+  autoload :AnsiColors,         'semantic_logger/ansi_colors'
   autoload :Base,               'semantic_logger/base'
   autoload :DebugAsTraceLogger, 'semantic_logger/debug_as_trace_logger'
   autoload :Log,                'semantic_logger/log'
@@ -11,20 +12,34 @@ module SemanticLogger
   autoload :Loggable,           'semantic_logger/loggable'
 
   module Appender
-    autoload :Base,          'semantic_logger/appender/base'
-    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 :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 :Wrapper,       'semantic_logger/appender/wrapper'
+    autoload :Base,             'semantic_logger/appender/base'
+    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 :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 :Wrapper,          'semantic_logger/appender/wrapper'
+  end
+
+  module Concerns
+    autoload :Compatibility,    'semantic_logger/concerns/compatibility'
+  end
+
+  module Formatters
+    autoload :Color,            'semantic_logger/formatters/color'
+    autoload :Default,          'semantic_logger/formatters/default'
+    autoload :Json,             'semantic_logger/formatters/json'
+  end
+
+  module Metrics
+    autoload :NewRelic,         'semantic_logger/metrics/new_relic'
+    autoload :Statsd,           'semantic_logger/metrics/statsd'
   end
-  # @formatter:on
 
   if defined?(JRuby)
     module JRuby
@@ -32,6 +47,7 @@ module SemanticLogger
     end
   end
 end
+# @formatter:on
 
 # Flush all appenders at exit, waiting for outstanding messages on the queue
 # to be written first

data/lib/semantic_logger/ansi_colors.rb

@@ -0,0 +1,27 @@
+module SemanticLogger
+  # Formatting & colors used by optional color formatter
+  module AnsiColors
+    CLEAR     = "\e[0m"
+    BOLD      = "\e[1m"
+    BLACK     = "\e[30m"
+    RED       = "\e[31m"
+    GREEN     = "\e[32m"
+    YELLOW    = "\e[33m"
+    BLUE      = "\e[34m"
+    MAGENTA   = "\e[35m"
+    CYAN      = "\e[36m"
+    WHITE     = "\e[37m"
+
+    # Maps the log level to a color for colorized formatters
+    # Since this map is not frozen, it can be modified as needed
+    LEVEL_MAP = {
+      trace: MAGENTA,
+      debug: GREEN,
+      info:  CYAN,
+      warn:  BOLD,
+      error: RED,
+      fatal: RED
+    }
+  end
+
+end

data/lib/semantic_logger/appender/base.rb

@@ -1,10 +1,3 @@
-require 'json'
-# Load AwesomePrint if available
-begin
-  require 'awesome_print'
-rescue LoadError
-end
-
 # Base appender
 #
 #   Abstract base class for appenders
@@ -16,128 +9,42 @@ end
 module SemanticLogger
   module Appender
 
-    # Formatting & colors used by optional colorized_formatter
-    module AnsiColors
-      CLEAR     = "\e[0m"
-      BOLD      = "\e[1m"
-      BLACK     = "\e[30m"
-      RED       = "\e[31m"
-      GREEN     = "\e[32m"
-      YELLOW    = "\e[33m"
-      BLUE      = "\e[34m"
-      MAGENTA   = "\e[35m"
-      CYAN      = "\e[36m"
-      WHITE     = "\e[37m"
-
-      # Maps the log level to a color for colorized formatters
-      # Since this map is not frozen, it can be modified as needed
-      LEVEL_MAP = {
-        trace: MAGENTA,
-        debug: GREEN,
-        info:  CYAN,
-        warn:  BOLD,
-        error: RED,
-        fatal: RED
-      }
-    end
+    # DEPRECATED, use SemanticLogger::AnsiColors
+    AnsiColors = SemanticLogger::AnsiColors
 
     class Base < SemanticLogger::Base
+      # Every logger has its own formatter
       attr_accessor :formatter
 
-      # Default log formatter
-      #  Replace this formatter by supplying a Block to the initializer
-      #  Generates logs of the form:
-      #    2011-07-19 14:36:15.660 D [1149:ScriptThreadProcess] Rails -- Hello World
-      def default_formatter
-        Proc.new do |log, logger|
-          # Header with date, time, log level and process info
-          entry = "#{log.formatted_time} #{log.level_to_s} [#{log.process_info}]"
-
-          # Tags
-          entry << ' ' << log.tags.collect { |tag| "[#{tag}]" }.join(' ') if log.tags && (log.tags.size > 0)
-
-          # Duration
-          entry << " (#{log.duration_human})" if log.duration
-
-          # Class / app name
-          entry << " #{log.name}"
-
-          # Log message
-          entry << " -- #{log.message}" if log.message
-
-          # Payload
-          if payload = log.payload_to_s(false)
-            entry << ' -- ' << payload
-          end
-
-          # Exceptions
-          if log.exception
-            entry << " -- Exception: #{log.exception.class}: #{log.exception.message}\n"
-            entry << log.backtrace_to_s
-          end
-          entry
-        end
+      # Returns the current log level if set, otherwise it logs everything it receives
+      def level
+        @level || :trace
       end
 
-      # Optional log formatter to colorize log output
-      # To use this formatter
-      #   SemanticLogger.add_appender($stdout, &SemanticLogger::Appender::Base.colorized_formatter)
-      #
-      #    2011-07-19 14:36:15.660 D [1149:ScriptThreadProcess] Rails -- Hello World
-      def self.colorized_formatter
-        Proc.new do |log, logger|
-          colors      = SemanticLogger::Appender::AnsiColors
-          level_color = colors::LEVEL_MAP[log.level]
-
-          # Header with date, time, log level and process info
-          entry       = "#{log.formatted_time} #{level_color}#{log.level_to_s}#{colors::CLEAR} [#{log.process_info}]"
-
-          # Tags
-          entry << ' ' << log.tags.collect { |tag| "[#{level_color}#{tag}#{colors::CLEAR}]" }.join(' ') if log.tags && (log.tags.size > 0)
-
-          # Duration
-          entry << " (#{colors::BOLD}#{log.duration_human}#{colors::CLEAR})" if log.duration
-
-          # Class / app name
-          entry << " #{level_color}#{log.name}#{colors::CLEAR}"
-
-          # Log message
-          entry << " -- #{log.message}" if log.message
-
-          # Payload
-          if payload = log.payload_to_s(true)
-            entry << ' -- ' << payload
-          end
-
-          # Exceptions
-          if log.exception
-            entry << " -- Exception: #{colors::BOLD}#{log.exception.class}: #{log.exception.message}#{colors::CLEAR}\n"
-            entry << log.backtrace_to_s
-          end
-          entry
-        end
+      # An appender can implement a flush method if it is able to.
+      def flush
+        # NOOP
       end
 
-      # Optional log formatter to output data in a hash format
-      # To use this formatter
-      #   SemanticLogger.add_appender($stdout, &SemanticLogger::Appender::Base.json_formatter)
-      def self.json_formatter
-        Proc.new do |log, logger|
-          h = log.to_h
-          h.delete(:time)
-          h[:timestamp] = log.time.utc.iso8601(defined?(JRuby) ? 3 : 6)
-          h.to_json
-        end
+      # DEPRECATED: use SemanticLogger::Formatters::Default.new
+      def default_formatter
+        warn '[DEPRECATION] SemanticLogger::Appender::Base.default_level is deprecated.  Please use SemanticLogger::Formatters::Default.new instead.'
+        formatter = SemanticLogger::Formatters::Default.new
+        Proc.new { |log, logger| formatter.call(log, logger) }
       end
 
-      def flush
-        # An appender can implement a flush method if it supports it.
+      # DEPRECATED: use SemanticLogger::Formatters::Color.new
+      def self.colorized_formatter
+        warn '[DEPRECATION] SemanticLogger::Appender::Base.colorized_formatter is deprecated.  Please use SemanticLogger::Formatters::Color.new instead.'
+        formatter = SemanticLogger::Formatters::Color.new
+        Proc.new { |log, logger| formatter.call(log, logger) }
       end
 
-      # Returns the current log level if set, otherwise it returns the global
-      # default log level
-      def level
-        @level || :trace
+      # DEPRECATED: use SemanticLogger::Formatters::Json.new
+      def self.json_formatter
+        warn '[DEPRECATION] SemanticLogger::Appender::Base.json_formatter is deprecated.  Please use SemanticLogger::Formatters::Json.new instead.'
+        formatter = SemanticLogger::Formatters::Json.new
+        Proc.new { |log, logger| formatter.call(log, logger) }
       end
 
       private
@@ -145,18 +52,32 @@ module SemanticLogger
       # Initializer for Abstract Class SemanticLogger::Appender
       #
       # Parameters
-      #  level [Symbol]
-      #    Only allow log entries of this level or higher to be written to this appender
-      #    For example if set to :warn, this appender would only log :warn and :fatal
-      #    log messages when other appenders could be logging :info and lower
+      #   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]
-      #    Optional regular expression to filter log entries based on the class name
-      #    When filter is a proc, it is passed the entire log struct and must return
-      #    true or false indicating whether to log the message
-      def initialize(level=nil, filter=nil, &block)
-        # Set the formatter to the supplied block
-        @formatter = block || default_formatter
+      #   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)
+        # Backward compatibility
+        options    = {level: options} unless options.is_a?(Hash)
+        options    = options.dup
+        level      = options.delete(:level)
+        filter     = options.delete(:filter)
+        @formatter = options.delete(:formatter)
+        @formatter = self.class.extract_formatter(@formatter) if @formatter.is_a?(Symbol)
+        @formatter ||= block
+        # Default to #call method for formatting if defined for an appender
+        @formatter ||= (respond_to?(:call) ? self : SemanticLogger::Formatters::Default.new)
+        raise(ArgumentError, "Unknown options: #{options.inspect}") if options.size > 0
 
         # Appenders don't take a class name, so use this class name if an appender
         # is logged to directly
@@ -170,6 +91,11 @@ module SemanticLogger
         @level_index || 0
       end
 
+      # Return formatter for supplied Symbol
+      def self.extract_formatter(formatter)
+        SemanticLogger.send(:named_formatter, formatter).new
+      end
+
     end
   end
 end

data/lib/semantic_logger/appender/bugsnag.rb

@@ -7,51 +7,53 @@ end
 # Send log messages to Bugsnag
 #
 # Example:
-#   SemanticLogger.add_appender(SemanticLogger::Appender::Bugsnag.new)
+#   SemanticLogger.add_appender(appender: :bugsnag)
 #
 class SemanticLogger::Appender::Bugsnag < SemanticLogger::Appender::Base
-  # Create Appender
+  # Create Bugsnag Error / Exception 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
-    filter    = @options.delete(:filter)
+    # 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?(level)
+    raise 'Bugsnag only supports :info, :warn, or :error log levels' unless [:info, :warn, :error].include?(options[: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(level, &block)
+
+    super(options, &block)
   end
 
   # Returns [Hash] of parameters to send to Bugsnag.
-  def default_formatter
-    Proc.new do |log|
-      h            = log.to_h
-      h[:severity] = log_level(log)
-      h.delete(:time)
-      h.delete(:exception)
-      h
-    end
+  def call(log, logger)
+    h            = log.to_h
+    h[:severity] = log_level(log)
+    h.delete(:time)
+    h.delete(:exception)
+    h
   end
 
   # 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)) ||
-      # 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?
@@ -75,7 +77,15 @@ class SemanticLogger::Appender::Bugsnag < SemanticLogger::Appender::Base
 
   private
 
+  # Bugsnag supports: error, warning or info
   def log_level(log)
-    log.level == :warn ? 'warning' : log.level.to_s
+    case log.level
+    when :error, :fatal
+      'error'
+    when :warn
+      'warning'
+    else
+      'info'
+    end
   end
 end

data/lib/semantic_logger/appender/elasticsearch.rb

@@ -2,15 +2,10 @@ require 'date'
 # Forward all log messages to Elasticsearch.
 #
 # Example:
-#   appender = SemanticLogger::Appender::Elasticsearch.new(
-#     url:   'http://localhost:9200'
+#   SemanticLogger.add_appender(
+#     appender: :elasticsearch,
+#     url:      'http://localhost:9200'
 #   )
-#
-#   # Optional: Exclude health_check log entries
-#   appender.filter = Proc.new { |log| log.message !~ /(health_check|Not logged in)/}
-#
-#   SemanticLogger.add_appender(appender)
-#
 class SemanticLogger::Appender::Elasticsearch < SemanticLogger::Appender::Http
   attr_accessor :index, :type
 
@@ -31,6 +26,11 @@ class SemanticLogger::Appender::Elasticsearch < SemanticLogger::Appender::Http
   #     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.
@@ -38,7 +38,7 @@ class SemanticLogger::Appender::Elasticsearch < SemanticLogger::Appender::Http
   #           The Proc must return true or false.
   def initialize(options, &block)
     options       = options.dup
-    @index        = options.delete(:index) || "semantic_logger"
+    @index        = options.delete(:index) || 'semantic_logger'
     @type         = options.delete(:type) || 'log'
     options[:url] ||= 'http://localhost:9200'