semantic_logger 4.0.0 → 4.1.0

data/lib/semantic_logger/formatters/raw.rb

@@ -2,9 +2,105 @@ require 'json'
 module SemanticLogger
   module Formatters
     class Raw < Base
+
+      # Fields are added by populating this hash.
+      attr_accessor :hash, :log, :logger
+
+      # Host name
+      def host
+        hash[:host] = logger.host if log_host && logger.host
+      end
+
+      # Application name
+      def application
+        hash[:application] = logger.application if log_application && logger.application
+      end
+
+      # Date & time
+      def time
+        hash[:time] = log.time
+      end
+
+      # Log level
+      def level
+        hash[:level]       = log.level
+        hash[:level_index] = log.level_index
+      end
+
+      # Process info
+      def process_info
+        hash[:pid]    = $$
+        hash[:thread] = log.thread_name
+
+        file, line = log.file_name_and_line
+        if file
+          hash[:file] = file
+          hash[:line] = line.to_i
+        end
+      end
+
+      # Tags
+      def tags
+        hash[:tags] = log.tags if log.tags && !log.tags.empty?
+      end
+
+      # Named Tags
+      def named_tags
+        hash[:named_tags] = log.named_tags if log.named_tags && !log.named_tags.empty?
+      end
+
+      # Duration
+      def duration
+        return unless log.duration
+
+        hash[:duration_ms] = log.duration
+        hash[:duration]    = log.duration_human
+      end
+
+      # Class / app name
+      def name
+        hash[:name] = log.name
+      end
+
+      # Log message
+      def message
+        hash[:message] = log.cleansed_message if log.message
+      end
+
+      # Payload
+      def payload
+        hash[:payload] = log.payload if log.payload && log.payload.respond_to?(:empty?) && !log.payload.empty?
+      end
+
+      # Exception
+      def exception
+        return unless log.exception
+        root = hash
+        log.each_exception do |exception, i|
+          name       = i == 0 ? :exception : :cause
+          root[name] = {
+            name:        exception.class.name,
+            message:     exception.message,
+            stack_trace: exception.backtrace
+          }
+          root       = root[name]
+        end
+      end
+
+      # Metric
+      def metric
+        hash[:metric]        = log.metric if log.metric
+        hash[:metric_amount] = log.metric_amount if log.metric_amount
+      end
+
       # Returns log messages in Hash format
       def call(log, logger)
-        log.to_h(log_host ? logger.host : nil, log_application ? logger.application : nil)
+        self.hash   = {}
+        self.log    = log
+        self.logger = logger
+
+        host; application; time; level; process_info; duration; tags; named_tags; name; message; payload; exception; metric
+        hash
       end
 
     end

data/lib/semantic_logger/formatters/syslog.rb

@@ -7,112 +7,78 @@ end
 module SemanticLogger
   module Formatters
     class Syslog < Default
-      attr_accessor :level_map, :options, :facility
+      attr_accessor :level_map, :facility
 
-      # Default mapping of ruby log levels to syslog log levels
+      # Default level map for every log level
       #
+      # :fatal   => ::Syslog::LOG_CRIT    - "A critical condition has occurred"
+      # :error   => ::Syslog::LOG_ERR     - "An error occurred"
+      # :warning =>::Syslog::LOG_WARNING  - "Warning of a possible problem"
+      # :info    => ::Syslog::LOG_NOTICE  - "A normal but significant condition occurred"
+      # :debug   => ::Syslog::LOG_INFO    - "Informational message"
+      # :trace   => ::Syslog::LOG_DEBUG   - "Debugging information"
+      #
+      # The following levels are not used by default.
       # ::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
+      class LevelMap
+        attr_accessor :trace, :debug, :info, :warn, :error, :fatal
+
+        def initialize(trace: ::Syslog::LOG_DEBUG, debug: ::Syslog::LOG_INFO, info: ::Syslog::LOG_NOTICE, warn: ::Syslog::LOG_WARNING, error: ::Syslog::LOG_ERR, fatal: ::Syslog::LOG_CRIT)
+          @trace = trace
+          @debug = debug
+          @info  = info
+          @warn  = warn
+          @error = error
+          @fatal = fatal
+        end
+
+        def [](level)
+          public_send(level)
+        end
+      end
 
       # 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]
+      #   level_map: [Hash | SemanticLogger::Formatters::Syslog::LevelMap]
       #     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)
+      #
+      #   Example:
+      #     # Change the warn level to LOG_NOTICE level instead of a the default of LOG_WARNING.
+      #     SemanticLogger.add_appender(appender: :syslog, level_map: {warn: ::Syslog::LOG_NOTICE})
+      def initialize(facility: ::Syslog::LOG_USER, level_map: LevelMap.new)
+        @facility  = facility
+        @level_map = level_map.is_a?(LevelMap) ? level_map : LevelMap.new(level_map)
+        super()
+      end
+
+      # Time is part of the syslog packet and is not included in the formatted message.
+      def time
+        nil
       end
 
       def call(log, logger)
         message = super(log, logger)
-        create_syslog_packet(log, message)
+        create_syslog_packet(message)
       end
 
+      private
+
       # Create Syslog Packet
-      def create_syslog_packet(log, message)
+      def create_syslog_packet(message)
         packet          = SyslogProtocol::Packet.new
-        packet.hostname = host
+        packet.hostname = logger.host
         packet.facility = facility
-        packet.tag      = application.gsub(' ', '')
+        packet.tag      = logger.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/formatters/syslog_cee.rb

@@ -0,0 +1,57 @@
+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 SyslogCee < Raw
+      attr_accessor :level_map, :facility
+
+      # CEE JSON Syslog format
+      #   Untested prototype code. Based on documentation only.
+      #   If this works for you, please let us know by opening an issue.
+      #
+      # Parameters:
+      #   facility: [Integer]
+      #     Default: ::Syslog::LOG_USER
+      #
+      #   level_map: [Hash | SemanticLogger::Formatters::Syslog::LevelMap]
+      #     Supply a custom map of SemanticLogger levels to syslog levels.
+      #
+      # Example:
+      #   # Log via udp to a remote syslog server on host: `server1` and port `8514`, using the CEE format.
+      #   SemanticLogger.add_appender(appender: :syslog, formatter: syslog_cee, url: 'udp://server1:8514')
+      def initialize(facility: ::Syslog::LOG_USER, level_map: SemanticLogger::Formatters::Syslog::LevelMap.new)
+        @facility  = facility
+        @level_map = level_map.is_a?(SemanticLogger::Formatters::Syslog::LevelMap) ? level_map : SemanticLogger::Formatters::Syslog::LevelMap.new(level_map)
+        super()
+      end
+
+      # Time is part of the syslog packet and is not included in the formatted message.
+      def time
+      end
+
+      def call(log, logger)
+        hash = super(log, logger)
+        create_syslog_packet("@cee: #{hash.to_json}")
+      end
+
+      private
+
+      # Create Syslog Packet
+      def create_syslog_packet(message)
+        packet          = SyslogProtocol::Packet.new
+        packet.hostname = logger.host
+        packet.facility = facility
+        packet.tag      = logger.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

@@ -43,8 +43,11 @@ module SemanticLogger
   # metric_amount [Numeric]
   #   Used for numeric or counter metrics.
   #   For example, the number of inquiries or, the amount purchased etc.
+  #
+  # context [Hash]
+  #   Named contexts that were captured when the log entry was created.
   class Log
-    attr_accessor :level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric, :backtrace, :metric_amount, :named_tags
+    attr_accessor :level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric, :backtrace, :metric_amount, :named_tags, :context
 
     def initialize(name, level, index = nil)
       @level       = level
@@ -180,7 +183,7 @@ module SemanticLogger
     # Returns [String] duration of the log entry as a string
     # Returns nil if their is no duration
     # Java time precision does not include microseconds
-    if defined? JRuby
+    if Formatters::Base::PRECISION == 3
       def duration_to_s
         "#{duration.to_i}ms" if duration
       end
@@ -256,75 +259,22 @@ module SemanticLogger
       !(payload.nil? || (payload.respond_to?(:empty?) && payload.empty?))
     end
 
-    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
+    # DEPRECATED
+    def formatted_time
+      time.strftime(Formatters::Base::TIME_FORMAT)
     end
 
-    # Returns [Hash] representation of this log entry
-    def to_h(host = SemanticLogger.host, application = SemanticLogger.application)
-      # Header
-      h               = {
-        name:        name,
-        pid:         $$,
-        thread:      thread_name,
-        time:        time,
-        level:       level,
-        level_index: level_index,
-      }
-      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
-      end
-
-      # Tags
-      h[:tags]       = tags if tags && !tags.empty?
-      h[:named_tags] = named_tags if named_tags && !named_tags.empty?
+    DeprecatedLogger = Struct.new(:host, :application)
 
-      # Duration
-      if duration
-        h[:duration_ms] = duration
-        h[:duration]    = duration_human
-      end
-
-      # Log message
-      h[:message] = cleansed_message if message
-
-      # Payload
-      h[:payload] = payload if payload && payload.respond_to?(:empty?) && !payload.empty?
-
-      # Exceptions
-      if exception
-        root = h
-        each_exception do |exception, i|
-          name       = i == 0 ? :exception : :cause
-          root[name] = {
-            name:        exception.class.name,
-            message:     exception.message,
-            stack_trace: exception.backtrace
-          }
-          root       = root[name]
-        end
-      end
+    # DEPRECATED: Use SemanticLogger::Formatters::Raw
+    def to_h(host = SemanticLogger.host, application = SemanticLogger.application)
+      logger = DeprecatedLogger.new(host, application)
+      SemanticLogger::Formatters::Raw.new.call(self, logger)
+    end
 
-      # Metric
-      h[:metric]        = metric if metric
-      h[:metric_amount] = metric_amount if metric_amount
-      h
+    # Lazy initializes the context hash and assigns a key value pair.
+    def set_context(key, value)
+      (self.context ||= {})[key] = value
     end
 
     private

data/lib/semantic_logger/logger.rb

@@ -13,7 +13,7 @@ module SemanticLogger
     #   logger = SemanticLogger::Logger.new('MyClass')
     #
     # Parameters:
-    #  application
+    #  klass
     #    A class, module or a string with the application/class name
     #    to be used in the logger
     #
@@ -26,47 +26,37 @@ 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)
-      super
+    def initialize(klass, level = nil, filter = nil)
+      super(klass, level, filter)
     end
 
-    # Returns [Integer] the number of log entries that have not been written
-    # to the appenders
-    #
-    # When this number grows it is because the logging appender thread is not
-    # able to write to the appenders fast enough. Either reduce the amount of
-    # logging, increase the log level, reduce the number of appenders, or
-    # look into speeding up the appenders themselves
+    # Place log request on the queue for the Appender thread to write to each
+    # appender in the order that they were registered
+    def log(log, message = nil, progname = nil, &block)
+      # Compatibility with ::Logger
+      return add(log, message, progname, &block) unless log.is_a?(SemanticLogger::Log)
+      Processor << log
+    end
+
+    # DEPRECATED
     def self.queue_size
       Processor.queue_size
     end
 
-    # Flush all queued log entries disk, database, etc.
-    #  All queued log messages are written and then each appender is flushed in turn
+    # DEPRECATED
     def self.flush
-      Processor.submit_request(:flush)
+      Processor.flush
     end
 
-    # Close all appenders and flush any outstanding messages
+    # DEPRECATED
     def self.close
-      Processor.submit_request(:close)
+      Processor.close
     end
 
-    # Allow the internal logger to be overridden from its default of STDERR
-    #   Can be replaced with another Ruby logger or Rails logger, but never to
-    #   SemanticLogger::Logger itself since it is for reporting problems
-    #   while trying to log to the various appenders
+    # DEPRECATED
     def self.logger=(logger)
       Processor.logger = logger
     end
 
-    # Place log request on the queue for the Appender thread to write to each
-    # appender in the order that they were registered
-    def log(log, message = nil, progname = nil, &block)
-      # Compatibility with ::Logger
-      return add(log, message, progname, &block) unless log.is_a?(SemanticLogger::Log)
-      Processor << log
-    end
-
   end
 end