semantic_logger 2.21.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7835135546f3ebf18ce484c594cd52fef0d4ecee
-  data.tar.gz: 12cd7ddcbf431f070a0b57792ad436f100aca649
+  metadata.gz: 16e4711a6003653a8d7cf1668fe3180e10493e43
+  data.tar.gz: c0266b7ebb30904275543fc083e553260bead056
 SHA512:
-  metadata.gz: cfb139be7ea5cb63d9787638e4e2e2bc464c8bd0bf49f60a9447b4b2b28033e66de8766c8c5b648e544d8bd3068813765d13cee9275130f2823416881e20bfde
-  data.tar.gz: 92e4e1fc6e445696c04596f4f12839d6504d32a62df005baa83e82adb2b4ed4343b9a808193104bfd615ac159ceab7631e5cb36e70457c265efb6de1cb475e18
+  metadata.gz: cdbf75bce867ba9fae2a524447d62f65093fc6ada2cb2214b67f599b5ee77b3d997ffb29e3e6db34efb09fdab24b8cc662700b664a58835aa1d88763f4d893b7
+  data.tar.gz: 3eff413a5f6a09af3f4aa84b7eaf717bd10cedff41d49202d0882442ba53e3519aff4b88c37a06bcc5703e9b744c2dbbc6f5533948c24cfd03fd9bc90905412e

data/LICENSE.txt

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2012, 2013, 2014 Reid Morrison
+   Copyright 2012, 2013, 2014, 2015, 2016 Reid Morrison
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/lib/semantic_logger.rb

@@ -5,20 +5,24 @@ require 'semantic_logger/semantic_logger'
 # @formatter:off
 module SemanticLogger
   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 :DebugAsTraceLogger, 'semantic_logger/debug_as_trace_logger'
 
   module Appender
-    autoload :Base,     'semantic_logger/appender/base'
-    autoload :File,     'semantic_logger/appender/file'
-    autoload :Wrapper,  'semantic_logger/appender/wrapper'
-    autoload :MongoDB,  'semantic_logger/appender/mongodb'
-    autoload :Syslog,   'semantic_logger/appender/syslog'
-    autoload :NewRelic, 'semantic_logger/appender/new_relic'
-    autoload :Splunk,   'semantic_logger/appender/splunk'
-    autoload :Bugsnag,   'semantic_logger/appender/bugsnag'
+    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
   # @formatter:on
 

data/lib/semantic_logger/appender/base.rb

@@ -48,7 +48,7 @@ module SemanticLogger
       #  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|
+        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}]"
 
@@ -70,9 +70,9 @@ module SemanticLogger
           end
 
           # Exceptions
-          log.each_exception do |exception, i|
-            entry << (i == 0 ? ' -- Exception: ' : "\nCause: ")
-            entry << "#{exception.class}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}"
+          if log.exception
+            entry << " -- Exception: #{log.exception.class}: #{log.exception.message}\n"
+            entry << log.backtrace_to_s
           end
           entry
         end
@@ -84,7 +84,7 @@ module SemanticLogger
       #
       #    2011-07-19 14:36:15.660 D [1149:ScriptThreadProcess] Rails -- Hello World
       def self.colorized_formatter
-        Proc.new do |log|
+        Proc.new do |log, logger|
           colors      = SemanticLogger::Appender::AnsiColors
           level_color = colors::LEVEL_MAP[log.level]
 
@@ -109,14 +109,26 @@ module SemanticLogger
           end
 
           # Exceptions
-          log.each_exception do |exception, i|
-            entry << (i == 0 ? ' -- Exception: ' : "\nCause: ")
-            entry << "#{colors::BOLD}#{exception.class}: #{exception.message}#{colors::CLEAR}\n#{(exception.backtrace || []).join("\n")}"
+          if log.exception
+            entry << " -- Exception: #{colors::BOLD}#{log.exception.class}: #{log.exception.message}#{colors::CLEAR}\n"
+            entry << log.backtrace_to_s
           end
           entry
         end
       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
+      end
+
       def flush
         # An appender can implement a flush method if it supports it.
       end
@@ -157,22 +169,6 @@ module SemanticLogger
         @level_index || 0
       end
 
-      if defined? Java
-        # Return the Time as a formatted string
-        # JRuby only supports time in ms
-        def self.formatted_time(time)
-          warn '[deprecated] SemanticLogger::Base.formatted_time is deprecated please use log.formatted_time'
-          "#{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)
-          warn '[deprecated] SemanticLogger::Base.formatted_time is deprecated please use log.formatted_time'
-          "#{time.strftime('%Y-%m-%d %H:%M:%S')}.#{'%06d' % (time.usec)}"
-        end
-      end
-
     end
   end
 end

data/lib/semantic_logger/appender/bugsnag.rb

@@ -1,53 +1,35 @@
-=begin
-Bugsnag appender for SemanticLogger
-
-Skips the fatal log level because unrescued exceptions get logged as fatal and will be reported automatically by Bugsnag.
-
-Note: Payload information is not filtered, so take care not to push any sensitive information when logging with tags or a payload.
-
-Example 1
-
-Adding the Bugsnag appender will send :error log entries to Bugsnag with the error severity.
-
-For a Rails application already configured to use SemanticLogger and Bugsnag, create a file called <Rails Root>/config/initializers/bugsnag_appender.rb with the following contents and restart the application:
-
-# Send :error and log messages to Bugsnag
-SemanticLogger.add_appender(SemanticLogger::Appender::Bugsnag.new)
-Rails.logger.info 'SemanticLogger Bugsnag Appender added.'
-
-Example 2
-
-For a non-Rails application, send :info and more severe log entries to a file called application.log and also send :error log entries to Bugsnag.
-
-require 'semantic_logger'
-require 'bugsnag'
-
-# Bugsnag setup
-Bugsnag.configure do |config|
-  config.api_key = 'abc123'
+begin
+  require 'bugsnag'
+rescue LoadError
+  raise 'Gem bugsnag is required for logging purposes. Please add the gem "bugsnag" to your Gemfile.'
 end
 
-# SemanticLogger setup
-SemanticLogger.default_level = :info
-SemanticLogger.add_appender('application.log')
-SemanticLogger.add_appender(SemanticLogger::Appender::Bugsnag.new)
-logger = SemanticLogger['Example']
-
-# Log some messages
-logger.info  'This is only written to application.log'
-logger.error 'This is written to application.log and will also be sent to Bugsnag as an error event'
-
-# The appender will send payloads to Bugsnag
-logger.error 'Something bad happened', info: 'Related information'
-=end
-
-require 'bugsnag'
-
+# Send log messages to Bugsnag
+#
+# Example:
+#   SemanticLogger.add_appender(SemanticLogger::Appender::Bugsnag.new)
+#
 class SemanticLogger::Appender::Bugsnag < 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 Bugsnag with Error notices
-  def initialize(level = :error, &block)
+  # Create Appender
+  #
+  # Parameters
+  #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+  #     Override the log level for this appender.
+  #     Default: :error
+  #
+  #   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)
+
+    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(level, &block)
@@ -55,10 +37,11 @@ class SemanticLogger::Appender::Bugsnag < SemanticLogger::Appender::Base
 
   # Returns [Hash] of parameters to send to Bugsnag.
   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
+    Proc.new do |log|
+      h            = log.to_h
+      h[:severity] = log_level(log)
+      h.delete(:time)
+      h.delete(:exception)
       h
     end
   end
@@ -68,7 +51,7 @@ class SemanticLogger::Appender::Bugsnag < SemanticLogger::Appender::Base
     # 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) ||
+      #(log.level == :fatal) ||
       # Ignore logs coming from Bugsnag itself
       (log.name == 'Bugsnag') ||
       # Filtered out?
@@ -83,9 +66,10 @@ class SemanticLogger::Appender::Bugsnag < SemanticLogger::Appender::Base
         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(exception, formatter.call(log))
+    Bugsnag.notify(exception, formatter.call(log, self))
     true
   end
 

data/lib/semantic_logger/appender/elasticsearch.rb

@@ -0,0 +1,53 @@
+require 'date'
+# Forward all log messages to Elasticsearch.
+#
+# Example:
+#   appender = SemanticLogger::Appender::Elasticsearch.new(
+#     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
+
+  # Create Elasticsearch appender over persistent HTTP(S)
+  #
+  # Parameters:
+  #   index: [String]
+  #     Index to store the logs in Elasticsearch.
+  #     Default: 'semantic_logger-YYYY.MM.DD'
+  #
+  #   type: [String]
+  #     Document type to associate with logs when they are written.
+  #     Default: 'log'
+  #
+  #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+  #     Override the log level for this appender.
+  #     Default: SemanticLogger.default_level
+  #
+  #   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       = options.dup
+    @index        = options.delete(:index) || "semantic_logger-#{Date.today.to_s.gsub('-', '.')}"
+    @type         = options.delete(:type) || 'log'
+    options[:url] ||= 'http://localhost:9200'
+
+    super(options, &block)
+
+    @request_uri = "#{@index}/#{@type}"
+  end
+
+  # Deletes all log data captured for this index
+  def delete_all
+    delete(index)
+  end
+
+end

data/lib/semantic_logger/appender/file.rb

@@ -6,7 +6,22 @@ module SemanticLogger
   module Appender
     class File < SemanticLogger::Appender::Base
 
-      # Create a File Logger appender instance
+      # Create a File Logger appender instance.
+      #
+      # Parameters
+      #  filename [String|IO]
+      #    Name of file to write to.
+      #    Or, an IO stream to which to write the log message to.
+      #
+      #  level [:trace | :debug | :info | :warn | :error | :fatal]
+      #    Override the log level for this appender.
+      #    Default: SemanticLogger.default_level
+      #
+      #  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.
       #
       # Example
       #    require 'semantic_logger'
@@ -38,7 +53,6 @@ module SemanticLogger
       #
       #    logger =  SemanticLogger['test']
       #    logger.info 'Hello World'
-      #
       def initialize(filename, level=nil, filter=nil, &block)
         raise 'filename cannot be null when initializing the SemanticLogging::Appender::File' unless filename
         @log =
@@ -79,7 +93,7 @@ module SemanticLogger
         # 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
         # Allow this logger to filter out log levels lower than it's own
-        @log.write(@formatter.call(log) << "\n")
+        @log.write(@formatter.call(log, self) << "\n")
         true
       end
 

data/lib/semantic_logger/appender/graylog.rb

@@ -0,0 +1,123 @@
+require 'uri'
+begin
+  require 'gelf'
+rescue LoadError
+  raise 'Gem gelf is required for logging to Graylog. Please add the gem "gelf" to your Gemfile.'
+end
+
+# Forward log entries to a Graylog server.
+#
+# Example:
+#   appender        = SemanticLogger::Appender::Graylog.new(
+#     url: 'udp://localhost:12201'
+#   )
+#
+#   # Optional: Add filter to exclude health_check, or other log entries
+#   appender.filter = Proc.new { |log| log.message !~ /(health_check|Not logged in)/ }
+#
+#   SemanticLogger.add_appender(appender)
+#
+# Notes:
+# * trace is not supported by Graylog, so trace level logging will appear as debug in Graylog.
+#
+# In the Graylog Web UI search screen, it is recommended to include the following fields:
+#  `duration`, `level`, `message`, `metric`, `name`, `tags
+class SemanticLogger::Appender::Graylog < SemanticLogger::Appender::Base
+  # Map Semantic Logger levels to Graylog levels
+  LEVEL_MAP = {
+    fatal: GELF::FATAL,
+    error: GELF::ERROR,
+    warn:  GELF::WARN,
+    info:  GELF::INFO,
+    debug: GELF::DEBUG,
+    trace: GELF::DEBUG
+  }
+
+  attr_reader :notifier
+
+  # Create Graylog log appender.
+  #
+  # Options:
+  #   url: [String]
+  #     Valid URL to post to.
+  #     Log to UDP Example:
+  #       'udp://localhost:12201'
+  #     Log to TCP Example:
+  #       'tcp://localhost:12201'
+  #     Default: 'udp://localhost:12201'
+  #
+  #   host: [String]
+  #     Name of this host to appear in log messages.
+  #     Default: Socket.gethostname
+  #
+  #   application: [String]
+  #     Name of this application to appear in log messages.
+  #     Default: SemanticLogger.application
+  #
+  #   max_size: [String]
+  #     Max udp packet size. Ignored when protocol is :tcp
+  #     Default: "WAN"
+  #
+  #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+  #     Override the log level for this appender.
+  #     Default: SemanticLogger.default_level
+  #
+  #   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  = options.dup
+    level     = @options.delete(:level)
+    filter    = @options.delete(:filter)
+    @url      = options.delete(:url) || 'udp://localhost:12201'
+    @max_size = @options.delete(:max_size) || 'WAN'
+
+    uri      = URI.parse(@url)
+    @server  = uri.host
+    @port    = uri.port
+    protocol = uri.scheme.to_sym
+
+    raise(ArgumentError, "Invalid protocol value: #{protocol}. Must be :udp or :tcp") unless [:udp, :tcp].include?(protocol)
+
+    @options[:protocol] = protocol == :tcp ? GELF::Protocol::TCP : GELF::Protocol::UDP
+    @options[:facility] = @options.delete(:application) || SemanticLogger.application
+    reopen
+    super(level, filter, &block)
+  end
+
+  # Re-open after process fork
+  def reopen
+    @notifier                       = GELF::Notifier.new(@server, @port, @max_size, @options)
+    @notifier.collect_file_and_line = false
+  end
+
+  # Returns [Hash] of parameters to send
+  def default_formatter
+    Proc.new do |log, logger|
+      h = log.to_h
+      h.delete(:time)
+      h[:timestamp]     = log.time.utc.to_f
+      h[:level]         = logger.map_level(log)
+      h[:level_str]     = log.level.to_s
+      h[:short_message] = h.delete(:message) if log.message
+      h
+    end
+  end
+
+  # Forward log messages
+  def log(log)
+    return false if (level_index > (log.level_index || 0)) ||
+      !include_message?(log) # Filtered out?
+
+    @notifier.notify!(formatter.call(log, self))
+    true
+  end
+
+  # Returns the Graylog level for the supplied log message
+  def map_level(log)
+    LEVEL_MAP[log.level]
+  end
+
+end