semantic_logger 3.2.1 → 3.3.0

data/lib/semantic_logger/appender/wrapper.rb

@@ -4,7 +4,7 @@
 #
 module SemanticLogger
   module Appender
-    class Wrapper < SemanticLogger::Appender::Base
+    class Wrapper < SemanticLogger::Subscriber
       attr_reader :logger
 
       # Forward all logging calls to the supplied logging instance.

data/lib/semantic_logger/base.rb

@@ -211,9 +211,15 @@ module SemanticLogger
       # 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
-      @name      = klass.is_a?(String) ? klass : klass.name
-      self.level = level unless level.nil?
+      @filter = filter.is_a?(Regexp) ? filter.freeze : filter
+      @name   = klass.is_a?(String) ? klass : klass.name
+      if level.nil?
+        # Allow the global default level to determine this loggers log level
+        @level_index = nil
+        @level       = nil
+      else
+        self.level = level
+      end
     end
 
     # Return the level index for fast comparisons

data/lib/semantic_logger/formatters/base.rb

@@ -0,0 +1,36 @@
+module SemanticLogger
+  module Formatters
+    class Base
+      attr_accessor :time_format, :precision, :log_host, :log_application
+
+      # Parameters
+      #   time_format: [String|Symbol|nil]
+      #     See Time#strftime for the format of this string
+      #     :iso_8601 Outputs an ISO8601 Formatted timestamp
+      #     nil:      Returns Empty string for time ( no time is output ).
+      #     Default: '%Y-%m-%d %H:%M:%S.%6N'
+      def initialize(options = {})
+        options          = options.dup
+        @precision       = defined?(JRuby) ? 3 : 6
+        default_format   = "%Y-%m-%d %H:%M:%S.%#{precision}N"
+        @time_format     = options.has_key?(:time_format) ? options.delete(:time_format) : default_format
+        @log_host        = options.has_key?(:log_host) ? options.delete(:log_host) : true
+        @log_application = options.has_key?(:log_application) ? options.delete(:log_application) : true
+        raise(ArgumentError, "Unknown options: #{options.inspect}") if options.size > 0
+      end
+
+      # Return the Time as a formatted string
+      def format_time(time)
+        case time_format
+        when :iso_8601
+          time.utc.iso8601(precision)
+        when nil
+          ''
+        else
+          time.strftime(time_format)
+        end
+      end
+
+    end
+  end
+end

data/lib/semantic_logger/formatters/color.rb

@@ -6,17 +6,18 @@ end
 
 module SemanticLogger
   module Formatters
-    class Color
+    class Color < Base
       # Parameters:
-      #  Any valid AwesomePrint option for rendering data.
-      #  These options can also be changed be creating a `~/.aprc` file.
-      #  See: https://github.com/michaeldv/awesome_print
+      #   ap: Any valid AwesomePrint option for rendering data.
+      #       These options can also be changed be creating a `~/.aprc` file.
+      #       See: https://github.com/michaeldv/awesome_print
       #
-      #  Note: The option :multiline is set to false if not supplied.
-      #  Note: Has no effect if Awesome Print is not installed.
-      def initialize(options={})
-        @ai_options             = options.dup
-        @ai_options[:multiline] = false unless @ai_options.has_key?(:multiline)
+      #       Note: The option :multiline is set to false if not supplied.
+      #       Note: Has no effect if Awesome Print is not installed.
+      def initialize(options = {})
+        options     = options.dup
+        @ai_options = options.delete(:ap) || {multiline: false}
+        super(options)
       end
 
       # Adds color to the default log formatter
@@ -26,8 +27,10 @@ module SemanticLogger
         colors      = SemanticLogger::AnsiColors
         level_color = colors::LEVEL_MAP[log.level]
 
+        message = time_format.nil? ? '' : "#{format_time(log.time)} "
+
         # Header with date, time, log level and process info
-        message     = "#{log.formatted_time} #{level_color}#{log.level_to_s}#{colors::CLEAR} [#{log.process_info}]"
+        message << "#{level_color}#{log.level_to_s}#{colors::CLEAR} [#{log.process_info}]"
 
         # Tags
         message << ' ' << log.tags.collect { |tag| "[#{level_color}#{tag}#{colors::CLEAR}]" }.join(' ') if log.tags && (log.tags.size > 0)

data/lib/semantic_logger/formatters/default.rb

@@ -1,12 +1,15 @@
 module SemanticLogger
   module Formatters
-    class Default
-      # Default log formatter
+    class Default < Base
+      # Default text log format
       #  Generates logs of the form:
-      #    2011-07-19 14:36:15.660 D [1149:ScriptThreadProcess] Rails -- Hello World
+      #    2011-07-19 14:36:15.660235 D [1149:ScriptThreadProcess] Rails -- Hello World
       def call(log, logger)
-        # Header with date, time, log level and process info
-        message = "#{log.formatted_time} #{log.level_to_s} [#{log.process_info}]"
+        # Date & time
+        message = time_format.nil? ? '' : "#{format_time(log.time)} "
+
+        # Log level and process info
+        message << "#{log.level_to_s} [#{log.process_info}]"
 
         # Tags
         message << ' ' << log.tags.collect { |tag| "[#{tag}]" }.join(' ') if log.tags && (log.tags.size > 0)

data/lib/semantic_logger/formatters/json.rb

@@ -1,12 +1,19 @@
 require 'json'
 module SemanticLogger
   module Formatters
-    class Json
+    class Json < Raw
+      # Default JSON time format is ISO8601
+      def initialize(options = {})
+        options               = options.dup
+        options[:time_format] = :iso_8601 unless options.has_key?(:time_format)
+        super(options)
+      end
+
       # Returns log messages in JSON format
       def call(log, logger)
-        h = log.to_h
+        h = super(log, logger)
         h.delete(:time)
-        h[:timestamp] = log.time.utc.iso8601(defined?(JRuby) ? 3 : 6)
+        h[:timestamp] = format_time(log.time)
         h.to_json
       end
 

data/lib/semantic_logger/formatters/raw.rb

@@ -0,0 +1,13 @@
+require 'json'
+module SemanticLogger
+  module Formatters
+    class Raw < Base
+      # Returns log messages in Hash format
+      def call(log, logger)
+        log.to_h(log_host ? logger.host : nil, log_application ? logger.application : nil)
+      end
+
+    end
+  end
+end
+

data/lib/semantic_logger/formatters/syslog.rb

@@ -0,0 +1,119 @@
+begin
+  require 'syslog_protocol'
+rescue LoadError
+  raise 'Gem syslog_protocol is required for remote logging using the Syslog protol. Please add the gem "syslog_protocol" to your Gemfile.'
+end
+
+module SemanticLogger
+  module Formatters
+    class Syslog < Default
+      attr_accessor :level_map, :options, :facility
+
+      # Default mapping of ruby log levels to syslog log levels
+      #
+      # ::Syslog::LOG_EMERG   - "System is unusable"
+      # ::Syslog::LOG_ALERT   - "Action needs to be taken immediately"
+      # ::Syslog::LOG_CRIT    - "A critical condition has occurred"
+      # ::Syslog::LOG_ERR     - "An error occurred"
+      # ::Syslog::LOG_WARNING - "Warning of a possible problem"
+      # ::Syslog::LOG_NOTICE  - "A normal but significant condition occurred"
+      # ::Syslog::LOG_INFO    - "Informational message"
+      # ::Syslog::LOG_DEBUG   - "Debugging information"
+      DEFAULT_LEVEL_MAP = {
+        fatal: ::Syslog::LOG_CRIT,
+        error: ::Syslog::LOG_ERR,
+        warn:  ::Syslog::LOG_WARNING,
+        info:  ::Syslog::LOG_NOTICE,
+        debug: ::Syslog::LOG_INFO,
+        trace: ::Syslog::LOG_DEBUG
+      }.freeze
+
+      # Create a Syslog Log Formatter
+      #
+      # Parameters:
+      #   options: [Integer]
+      #     Default: ::Syslog::LOG_PID | ::Syslog::LOG_CONS
+      #     Any of the following (options can be logically OR'd together)
+      #       ::Syslog::LOG_CONS
+      #       ::Syslog::LOG_NDELAY
+      #       ::Syslog::LOG_NOWAIT
+      #       ::Syslog::LOG_ODELAY
+      #       ::Syslog::LOG_PERROR
+      #       ::Syslog::LOG_PID
+      #
+      #   facility: [Integer]
+      #     Default: ::Syslog::LOG_USER
+      #     Type of program (can be logically OR'd together)
+      #       ::Syslog::LOG_AUTH
+      #       ::Syslog::LOG_AUTHPRIV
+      #       ::Syslog::LOG_CONSOLE
+      #       ::Syslog::LOG_CRON
+      #       ::Syslog::LOG_DAEMON
+      #       ::Syslog::LOG_FTP
+      #       ::Syslog::LOG_KERN
+      #       ::Syslog::LOG_LRP
+      #       ::Syslog::LOG_MAIL
+      #       ::Syslog::LOG_NEWS
+      #       ::Syslog::LOG_NTP
+      #       ::Syslog::LOG_SECURITY
+      #       ::Syslog::LOG_SYSLOG
+      #       ::Syslog::LOG_USER
+      #       ::Syslog::LOG_UUCP
+      #       ::Syslog::LOG_LOCAL0
+      #       ::Syslog::LOG_LOCAL1
+      #       ::Syslog::LOG_LOCAL2
+      #       ::Syslog::LOG_LOCAL3
+      #       ::Syslog::LOG_LOCAL4
+      #       ::Syslog::LOG_LOCAL5
+      #       ::Syslog::LOG_LOCAL6
+      #       ::Syslog::LOG_LOCAL7
+      #
+      #   level_map: [Hash]
+      #     Supply a custom map of SemanticLogger levels to syslog levels.
+      #     For example, passing in { warn: ::Syslog::LOG_NOTICE }
+      #       would result in a log mapping that matches the default level map,
+      #       except for :warn, which ends up with a LOG_NOTICE level instead of a
+      #       LOG_WARNING one.
+      #     Without overriding any parameters, the level map will be
+      #       LEVEL_MAP = {
+      #         fatal:   ::Syslog::LOG_CRIT,
+      #         error:   ::Syslog::LOG_ERR,
+      #         warn:    ::Syslog::LOG_WARNING,
+      #         info:    ::Syslog::LOG_NOTICE,
+      #         debug:   ::Syslog::LOG_INFO,
+      #         trace:   ::Syslog::LOG_DEBUG
+      #       }
+      def initialize(options = {})
+        options    = options.dup
+        @options   = options.delete(:options) || (::Syslog::LOG_PID | ::Syslog::LOG_CONS)
+        @facility  = options.delete(:facility) || ::Syslog::LOG_USER
+        @level_map = DEFAULT_LEVEL_MAP.dup
+        if level_map  = options.delete(:level_map)
+          @level_map.update(level_map)
+        end
+        # Time is already part of Syslog packet
+        options[:time_format] = nil unless options.has_key?(:time_format)
+        super(options)
+      end
+
+      def call(log, logger)
+        message = super(log, logger)
+        create_syslog_packet(log, message)
+      end
+
+      # Create Syslog Packet
+      def create_syslog_packet(log, message)
+        packet          = SyslogProtocol::Packet.new
+        packet.hostname = host
+        packet.facility = facility
+        packet.tag      = application.gsub(' ', '')
+        packet.content  = message
+        packet.time     = log.time
+        packet.severity = level_map[log.level]
+        packet.to_s
+      end
+
+    end
+  end
+end
+

data/lib/semantic_logger/log.rb

@@ -163,23 +163,23 @@ module SemanticLogger
     if defined? JRuby
       # Return the Time as a formatted string
       # JRuby only supports time in ms
+      # DEPRECATED
       def 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
+      # DEPRECATED
       def formatted_time
         "#{time.strftime('%Y-%m-%d %H:%M:%S')}.#{'%06d' % (time.usec)}"
       end
     end
 
     # Returns [Hash] representation of this log entry
-    def to_h
+    def to_h(host = SemanticLogger.host, application = SemanticLogger.application)
       # Header
-      h          = {
-        host:        SemanticLogger.host,
-        application: SemanticLogger.application,
+      h               = {
         name:        name,
         pid:         $$,
         thread:      thread_name,
@@ -187,7 +187,9 @@ module SemanticLogger
         level:       level,
         level_index: level_index,
       }
-      file, line = file_name_and_line
+      h[:host]        = host if host
+      h[:application] = application if application
+      file, line      = file_name_and_line
       if file
         h[:file] = file
         h[:line] = line.to_i

data/lib/semantic_logger/loggable.rb

@@ -34,6 +34,11 @@ module SemanticLogger
           @semantic_logger ||= SemanticLogger[self]
         end
 
+        # Replace instance class level logger
+        def self.logger=(logger)
+          @semantic_logger = logger
+        end
+
         # Returns [SemanticLogger::Logger] instance level logger
         def logger
           @semantic_logger ||= self.class.logger

data/lib/semantic_logger/logger.rb

@@ -44,12 +44,28 @@ module SemanticLogger
     # Flush all queued log entries disk, database, etc.
     #  All queued log messages are written and then each appender is flushed in turn
     def self.flush
-      return false unless appender_thread_active?
+      msg = "Flushing appenders with #{queue_size} log messages on the queue"
+      if queue_size > 1_000
+        logger.warn msg
+      elsif queue_size > 100
+        logger.info msg
+      elsif queue_size > 0
+        logger.trace msg
+      end
+      process_request(:flush)
+    end
 
-      logger.trace "Flushing appenders with #{queue_size} log messages on the queue"
-      reply_queue = Queue.new
-      queue << {command: :flush, reply_queue: reply_queue}
-      reply_queue.pop
+    # Close all appenders and flush any outstanding messages
+    def self.close
+      msg = "Closing appenders with #{queue_size} log messages on the queue"
+      if queue_size > 1_000
+        logger.warn msg
+      elsif queue_size > 100
+        logger.info msg
+      elsif queue_size > 0
+        logger.trace msg
+      end
+      process_request(:close)
     end
 
     @@lag_check_interval = 5000
@@ -73,10 +89,6 @@ module SemanticLogger
       @@lag_threshold_s
     end
 
-    def self.time_threshold_s=(time_threshold_s)
-      @@lag_threshold_s = time_threshold_s
-    end
-
     # Allow the internal logger to be overridden from its default to STDERR
     #   Can be replaced with another Ruby logger or Rails logger, but never to
     #   SemanticLogger::Logger itself since it is for reporting problems
@@ -111,7 +123,7 @@ module SemanticLogger
       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)
+      appender = SemanticLogger.constantize_symbol(appender, 'SemanticLogger::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
@@ -202,6 +214,20 @@ module SemanticLogger
                 end
               end
 
+              message[:reply_queue] << true if message[:reply_queue]
+              logger.trace 'Appender thread: All appenders flushed'
+            when :close
+              SemanticLogger.appenders.each do |appender|
+                begin
+                  logger.trace "Appender thread: Closing appender: #{appender.name}"
+                  appender.flush
+                  appender.close
+                  SemanticLogger.remove_appender(appender)
+                rescue Exception => exc
+                  logger.error "Appender thread: Failed to close appender: #{appender.inspect}", exc
+                end
+              end
+
               message[:reply_queue] << true if message[:reply_queue]
               logger.trace 'Appender thread: All appenders flushed'
             else
@@ -242,5 +268,14 @@ module SemanticLogger
       end
     end
 
+    # Close all appenders and flush any outstanding messages
+    def self.process_request(command)
+      return false unless appender_thread_active?
+
+      reply_queue = Queue.new
+      queue << {command: command, reply_queue: reply_queue}
+      reply_queue.pop
+    end
+
   end
 end

data/lib/semantic_logger/metrics/new_relic.rb

@@ -1,6 +1,6 @@
 module SemanticLogger
   module Metrics
-    class NewRelic
+    class NewRelic < Subscriber
       attr_accessor :prefix
 
       # Parameters:

data/lib/semantic_logger/metrics/statsd.rb

@@ -7,7 +7,7 @@ end
 
 module SemanticLogger
   module Metrics
-    class Statsd
+    class Statsd < Subscriber
       # Create Statsd metrics subscriber
       #
       # Parameters:
@@ -18,6 +18,10 @@ module SemanticLogger
       #     Example, send all metrics to a particular namespace:
       #       udp://localhost:8125/namespace
       #     Default: udp://localhost:8125
+      #
+      # Example:
+      #   subscriber = SemanticLogger::Metrics::Statsd.new(url: 'udp://localhost:8125')
+      #   SemanticLogger.on_metric(subscriber)
       def initialize(options = {})
         options = options.dup
         @url    = options.delete(:url) || 'udp://localhost:8125'