semantic_logger 3.0.1 → 3.1.0

data/lib/semantic_logger/appender/syslog.rb

@@ -5,27 +5,19 @@ require 'socket'
 # Send log messages to local syslog, or remote syslog servers over TCP or UDP.
 #
 # Example: Log to a local Syslog daemon
-#   SemanticLogger.add_appender(SemanticLogger::Appender::Syslog.new)
+#   SemanticLogger.add_appender(appender: :syslog)
 #
 # Example: Log to a remote Syslog server using TCP:
-#   appender        = SemanticLogger::Appender::Syslog.new(
-#     url: 'tcp://myloghost:514'
+#   SemanticLogger.add_appender(
+#     appender: :syslog,
+#     url:      'tcp://myloghost:514'
 #   )
 #
-#   # 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)
-#
 # Example: Log to a remote Syslog server using UDP:
-#   appender        = SemanticLogger::Appender::Syslog.new(
-#     url: 'udp://myloghost:514'
+#   SemanticLogger.add_appender(
+#     appender: :syslog,
+#     url:      'udp://myloghost:514'
 #   )
-#
-#   # 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)
 module SemanticLogger
   module Appender
     class Syslog < SemanticLogger::Appender::Base
@@ -81,6 +73,11 @@ module SemanticLogger
       #     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.
@@ -143,10 +140,15 @@ module SemanticLogger
       #         debug:   ::Syslog::LOG_INFO,
       #         trace:   ::Syslog::LOG_DEBUG
       #       }
+      #
+      #   format: [Symbol]
+      #     Format for the Syslog message
+      #       :syslog uses the default syslog format
+      #       :json uses the CEE JSON Syslog format
+      #          Example: "@cee: #{JSON.dump(data)}"
+      #     Default: :syslog
       def initialize(options = {}, &block)
         options             = options.dup
-        level               = options.delete(:level)
-        filter              = options.delete(:filter)
         @application        = options.delete(:application) || options.delete(:ident) || 'ruby'
         @options            = options.delete(:options) || (::Syslog::LOG_PID | ::Syslog::LOG_CONS)
         @facility           = options.delete(:facility) || ::Syslog::LOG_USER
@@ -161,7 +163,6 @@ module SemanticLogger
         @tcp_client_options = options.delete(:tcp_client)
 
         raise "Unknown protocol #{@protocol}!" unless [:syslog, :tcp, :udp].include?(@protocol)
-        raise(ArgumentError, "Unknown options: #{options.inspect}") if options.size > 0
 
         @level_map = DEFAULT_LEVEL_MAP.dup
         @level_map.update(level_map) if level_map
@@ -188,7 +189,7 @@ module SemanticLogger
 
         reopen
 
-        super(level, filter, &block)
+        super(options, &block)
       end
 
       # After forking an active process call #reopen to re-open
@@ -235,35 +236,33 @@ module SemanticLogger
 
       # Custom log formatter for syslog.
       # Only difference is the removal of the timestamp string since it is in the syslog packet.
-      def default_formatter
-        Proc.new do |log|
-          # Header with date, time, log level and process info
-          entry = "#{log.level_to_s} [#{log.process_info}]"
+      def call(log, logger)
+        # Header with date, time, log level and process info
+        message = "#{log.level_to_s} [#{log.process_info}]"
 
-          # Tags
-          entry << ' ' << log.tags.collect { |tag| "[#{tag}]" }.join(' ') if log.tags && (log.tags.size > 0)
+        # Tags
+        message << ' ' << log.tags.collect { |tag| "[#{tag}]" }.join(' ') if log.tags && (log.tags.size > 0)
 
-          # Duration
-          entry << " (#{log.duration_human})" if log.duration
+        # Duration
+        message << " (#{log.duration_human})" if log.duration
 
-          # Class / app name
-          entry << " #{log.name}"
+        # Class / app name
+        message << " #{log.name}"
 
-          # Log message
-          entry << " -- #{log.message}" if log.message
+        # Log message
+        message << " -- #{log.message}" if log.message
 
-          # Payload
-          if payload = log.payload_to_s(false)
-            entry << ' -- ' << payload
-          end
+        # Payload
+        if payload = log.payload_to_s
+          message << ' -- ' << payload
+        end
 
-          # Exceptions
-          if log.exception
-            entry << " -- Exception: #{log.exception.class}: #{log.exception.message}\n"
-            entry << log.backtrace_to_s
-          end
-          entry
+        # Exceptions
+        if log.exception
+          message << " -- Exception: #{log.exception.class}: #{log.exception.message}\n"
+          message << log.backtrace_to_s
         end
+        message
       end
 
       # Format the syslog packet so it can be sent over TCP or UDP
@@ -273,7 +272,7 @@ module SemanticLogger
         packet.facility = @facility
         packet.severity = @level_map[log.level]
         packet.tag      = @application
-        packet.content  = default_formatter.call(log, self)
+        packet.content  = formatter.call(log, self)
         packet.time     = log.time
         packet.to_s
       end

data/lib/semantic_logger/appender/wrapper.rb

@@ -17,6 +17,11 @@ module SemanticLogger
       #     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.
@@ -28,27 +33,25 @@ module SemanticLogger
       #    require 'semantic_logger'
       #
       #    ruby_logger = Logger.new(STDOUT)
-      #    SemanticLogger.add_appender(ruby_logger)
+      #    SemanticLogger.add_appender(logger: ruby_logger)
       #
       #    logger =  SemanticLogger['test']
       #    logger.info('Hello World', some: :payload)
       #
-      # Enhance the Rails Logger
-      #    # Add the Rails logger to the list of appenders
-      #    SemanticLogger.add_appender(Rails.logger)
-      #    Rails.logger = SemanticLogger['Rails']
-      #
-      #    # Make ActiveRecord logging include its class name in every log entry
-      #    ActiveRecord::Base.logger = SemanticLogger['ActiveRecord']
-      #
       # Install the `rails_semantic_logger` gem to replace the Rails logger with Semantic Logger.
-      def initialize(logger, level = nil, filter = nil, &block)
-        raise 'logger cannot be null when initializing the SemanticLogging::Appender::Wrapper' unless logger
-        @logger    = logger
+      def initialize(options, &block)
+        # Backward compatibility
+        options = {logger: options} unless options.is_a?(Hash)
+        options = options.dup
+        @logger = options.delete(:logger)
+
+        # Check if the custom appender responds to all the log levels. For example Ruby ::Logger
+        if does_not_implement = LEVELS[1..-1].find { |i| !@logger.respond_to?(i) }
+          raise(ArgumentError, "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}")
+        end
 
-        # Set the formatter to the supplied block
-        @formatter = block || self.default_formatter
-        super(level, filter, &block)
+        raise 'SemanticLogging::Appender::Wrapper missing mandatory parameter :logger' unless @logger
+        super(options, &block)
       end
 
       # Pass log calls to the underlying Rails, log4j or Ruby logger
@@ -58,8 +61,7 @@ module SemanticLogger
         # Ensure minimum log level is met, and check filter
         return false if (level_index > (log.level_index || 0)) || !include_message?(log)
 
-        # Underlying wrapper logger implements log level, so don't check here
-        @logger.send(log.level == :trace ? :debug : log.level, @formatter.call(log, self))
+        @logger.send(log.level == :trace ? :debug : log.level, formatter.call(log, self))
         true
       end
 

data/lib/semantic_logger/base.rb

@@ -21,7 +21,7 @@ module SemanticLogger
     # nil if this logger instance should use the global default level
     def level=(level)
       @level_index = SemanticLogger.level_to_index(level)
-      @level       = level
+      @level       = SemanticLogger.send(:index_to_level, @level_index)
     end
 
     # Returns the current log level if set, otherwise it returns the global
@@ -59,10 +59,10 @@ module SemanticLogger
     #    SemanticLogger.default_level = :info
     #
     #    # Log to screen
-    #    SemanticLogger.add_appender(STDOUT)
+    #    SemanticLogger.add_appender(io: STDOUT, formatter: :color)
     #
     #    # And log to a file at the same time
-    #    SemanticLogger.add_appender('application.log')
+    #    SemanticLogger.add_appender(file: 'application.log', formatter: :color)
     #
     #    logger = SemanticLogger['MyApplication']
     #    logger.debug("Only display this if log level is set to Debug or lower")
@@ -88,9 +88,17 @@ module SemanticLogger
           level_index <= #{index}
         end
 
+        def measure_#{level}(message, params = {}, &block)
+          if level_index <= #{index}
+            measure_internal(:#{level}, #{index}, message, params, &block)
+          else
+            block.call(params) if block
+          end
+        end
+
         def benchmark_#{level}(message, params = {}, &block)
           if level_index <= #{index}
-            benchmark_internal(:#{level}, #{index}, message, params, &block)
+            measure_internal(:#{level}, #{index}, message, params, &block)
           else
             block.call(params) if block
           end
@@ -98,16 +106,18 @@ module SemanticLogger
       EOT
     end
 
-    # Dynamically supply the log level with every benchmark call
-    def benchmark(level, message, params = {}, &block)
+    # Dynamically supply the log level with every measurement call
+    def measure(level, message, params = {}, &block)
       index = SemanticLogger.level_to_index(level)
       if level_index <= index
-        benchmark_internal(level, index, message, params, &block)
+        measure_internal(level, index, message, params, &block)
       else
         block.call(params) if block
       end
     end
 
+    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)
@@ -184,12 +194,6 @@ module SemanticLogger
       Thread.current[:semantic_logger_payload]
     end
 
-    # Semantic Logging does not support :unknown level since these
-    # are not understood by the majority of the logging providers
-    # Map it to :error
-    alias :unknown :error
-    alias :unknown? :error?
-
     # Silence noisy log levels by changing the default_level within the block
     #
     # This setting is thread-safe and only applies to the current thread
@@ -246,6 +250,13 @@ module SemanticLogger
       SemanticLogger.default_level
     end
 
+    protected
+
+    # Write log data to underlying data storage
+    def log(log_)
+      raise NotImplementedError.new('Logging Appender must implement #log(log)')
+    end
+
     private
 
     # Initializer for Abstract Class SemanticLogger::Base
@@ -275,11 +286,6 @@ module SemanticLogger
       self.level = level unless level.nil?
     end
 
-    # Write log data to underlying data storage
-    def log(log_)
-      raise NotImplementedError.new('Logging Appender must implement #log(log)')
-    end
-
     # Return the level index for fast comparisons
     # Returns the global default level index if the level has not been explicitly
     # set for this instance
@@ -288,25 +294,25 @@ module SemanticLogger
     end
 
     # Whether to log the supplied message based on the current filter if any
-    def include_message?(struct)
+    def include_message?(log)
       return true if @filter.nil?
 
       if @filter.is_a?(Regexp)
-        (@filter =~ struct.name) != nil
+        (@filter =~ log.name) != nil
       elsif @filter.is_a?(Proc)
-        @filter.call(struct) == true
+        @filter.call(log) == true
       end
     end
 
     # Log message at the specified level
     def log_internal(level, index, message=nil, payload=nil, exception=nil)
-      # Detect exception being logged
-      if exception.nil? && payload.nil? && message.kind_of?(Exception)
+      # Exception being logged?
+      # Under JRuby a java exception is not a Ruby Exception
+      #   Java::JavaLang::ClassCastException.new.is_a?(Exception) => false
+      if exception.nil? && payload.nil? && message.respond_to?(:backtrace) && message.respond_to?(:message)
         exception = message
         message   = nil
       elsif exception.nil? && payload && payload.respond_to?(:backtrace) && payload.respond_to?(:message)
-        # Under JRuby a java exception is not a Ruby Exception
-        #   Java::JavaLang::ClassCastException.new.is_a?(Exception) => false
         exception = payload
         payload   = nil
       end
@@ -315,6 +321,8 @@ module SemanticLogger
       if block_given? && (result = yield)
         if result.is_a?(String)
           message = message.nil? ? result : "#{message} -- #{result}"
+        elsif message.nil? && result.is_a?(Hash)
+          message = result
         elsif payload && payload.respond_to?(:merge)
           payload.merge(result)
         else
@@ -330,8 +338,25 @@ module SemanticLogger
       # Add caller stack trace
       backtrace = extract_backtrace if index >= SemanticLogger.backtrace_level_index
 
-      struct = Log.new(level, Thread.current.name, name, message, payload, Time.now, nil, tags, index, exception, nil, backtrace)
-      log(struct) if include_message?(struct)
+      log = Log.new(level, Thread.current.name, name, message, payload, Time.now, nil, tags, index, exception, nil, backtrace)
+
+      # Logging Hash only?
+      # logger.info(name: 'value')
+      if payload.nil? && exception.nil? && message.is_a?(Hash)
+        payload           = message.dup
+        min_duration      = payload.delete(:min_duration) || 0.0
+        log.exception     = payload.delete(:exception)
+        log.message       = payload.delete(:message)
+        log.metric        = payload.delete(:metric)
+        log.metric_amount = payload.delete(:metric_amount) || 1
+        if duration = payload.delete(:duration)
+          return false if duration <= min_duration
+          log.duration = duration
+        end
+        log.payload = payload if payload.size > 0
+      end
+
+      self.log(log) if include_message?(log)
     end
 
     SELF_PATTERN = File.join('lib', 'semantic_logger')
@@ -346,7 +371,7 @@ module SemanticLogger
     end
 
     # Measure the supplied block and log the message
-    def benchmark_internal(level, index, message, params)
+    def measure_internal(level, index, message, params)
       start     = Time.now
       exception = nil
       begin
@@ -407,16 +432,16 @@ module SemanticLogger
             logged_exception = nil
             backtrace        = exception.backtrace
           end
-          struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, logged_exception, metric, backtrace)
-          log(struct) if include_message?(struct)
+          log = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, logged_exception, metric, backtrace)
+          self.log(log) if include_message?(log)
           raise exception
         elsif duration >= min_duration
           # Only log if the block took longer than 'min_duration' to complete
           # Add caller stack trace
           backtrace = extract_backtrace if index >= SemanticLogger.backtrace_level_index
 
-          struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, nil, metric, backtrace)
-          log(struct) if include_message?(struct)
+          log = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, nil, metric, backtrace)
+          self.log(log) if include_message?(log)
         end
       end
     end

data/lib/semantic_logger/concerns/compatibility.rb

@@ -0,0 +1,51 @@
+# :nodoc:
+module SemanticLogger
+  # :nodoc:
+  module Concerns
+    # :nodoc:
+    module Compatibility
+      #
+      # For compatibility with Ruby Logger only.
+      #
+      def self.included(base)
+        base.class_eval do
+          # Map :unknown to :error
+          alias_method :unknown, :error # :nodoc:
+          alias_method :unknown?, :error? # :nodoc:
+
+          alias_method :<<, :info # :nodoc:
+
+          alias_method :progname, :name # :nodoc:
+          alias_method :progname=, :name= # :nodoc:
+
+          alias_method :sev_threshold, :level # :nodoc:
+          alias_method :sev_threshold=, :level= # :nodoc:
+
+          attr_accessor :formatter # :nodoc:
+          attr_accessor :datetime_format # :nodoc:
+        end
+      end
+
+      # :nodoc:
+      def close
+      end
+
+      # :nodoc:
+      def reopen(logdev = nil)
+      end
+
+      # :nodoc:
+      def add(severity, message = nil, progname = nil, &block)
+        index = SemanticLogger.send(:level_to_index, severity)
+        if level_index <= index
+          level = SemanticLogger.send(:index_to_level, index)
+          log_internal(level, index, message, progname, &block)
+          true
+        else
+          false
+        end
+      end
+
+    end
+  end
+end