semantic_logger 3.4.1 → 4.0.0.beta1

data/lib/semantic_logger/core_ext/thread.rb

@@ -1,5 +1,8 @@
 require 'thread'
 class Thread
+  undef :name if method_defined? :name
+  undef :name= if method_defined? :name=
+
   # Returns the name of the current thread
   # Default:
   #    JRuby: The underlying Java thread name
@@ -25,4 +28,4 @@ class Thread
       @name = name.to_s
     end
   end
-end
+end

data/lib/semantic_logger/formatters/color.rb

@@ -35,6 +35,13 @@ module SemanticLogger
         # Tags
         message << ' ' << log.tags.collect { |tag| "[#{level_color}#{tag}#{colors::CLEAR}]" }.join(' ') if log.tags && (log.tags.size > 0)
 
+        # Named Tags
+        if (named_tags = log.named_tags) && !named_tags.empty?
+          list = {}
+          named_tags.each_pair { |name, value| list << "[#{level_color}#{name}: #{value}#{colors::CLEAR}]" }
+          message << ' ' << list.join(' ')
+        end
+
         # Duration
         message << " (#{colors::BOLD}#{log.duration_human}#{colors::CLEAR})" if log.duration
 

data/lib/semantic_logger/formatters/default.rb

@@ -14,6 +14,13 @@ module SemanticLogger
         # Tags
         message << ' ' << log.tags.collect { |tag| "[#{tag}]" }.join(' ') if log.tags && (log.tags.size > 0)
 
+        # Named Tags
+        if (named_tags = log.named_tags) && !named_tags.empty?
+          list = []
+          named_tags.each_pair { |name, value| list << "[#{name}: #{value}]" }
+          message << ' ' << list.join(' ')
+        end
+
         # Duration
         message << " (#{log.duration_human})" if log.duration
 

data/lib/semantic_logger/formatters/syslog.rb

@@ -88,7 +88,7 @@ module SemanticLogger
         @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)
+        if level_map = options.delete(:level_map)
           @level_map.update(level_map)
         end
         # Time is already part of Syslog packet

data/lib/semantic_logger/log.rb

@@ -1,7 +1,7 @@
 module SemanticLogger
-  # Log Struct
+  # Log
   #
-  #   Structure for holding all log entries
+  #   Class to hold all log entry information
   #
   # level
   #   Log level of the supplied log call
@@ -43,7 +43,103 @@ module SemanticLogger
   # metric_amount [Numeric]
   #   Used for numeric or counter metrics.
   #   For example, the number of inquiries or, the amount purchased etc.
-  Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric, :backtrace, :metric_amount) do
+  class Log
+    attr_accessor :level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception, :metric, :backtrace, :metric_amount, :named_tags
+
+    def initialize(name, level, index = nil)
+      @level       = level
+      @thread_name = Thread.current.name
+      @name        = name
+      @time        = Time.now
+      @tags        = SemanticLogger.tags
+      @named_tags  = SemanticLogger.named_tags
+      @level_index = index.nil? ? SemanticLogger.level_to_index(level) : index
+    end
+
+    # Assign named arguments to this log entry, supplying defaults where applicable
+    #
+    # Returns [true|false] whether this log entry should be logged
+    #
+    # Example:
+    #   logger.info(name: 'value')
+    def assign(message: nil, payload: nil, min_duration: 0.0, exception: nil, metric: nil, metric_amount: 1, duration: nil, backtrace: nil, log_exception: :full, on_exception_level: nil)
+      # Elastic logging: Log when :duration exceeds :min_duration
+      # Except if there is an exception when it will always be logged
+      if duration
+        self.duration = duration
+        return false if (duration <= min_duration) && exception.nil?
+      end
+
+      self.message = message
+      self.payload = payload
+
+      if exception
+        case log_exception
+        when :full
+          self.exception = exception
+        when :partial
+          self.message = "#{message} -- Exception: #{exception.class}: #{exception.message}"
+        when nil, :none
+          # Log the message without the exception that was raised
+        else
+          raise(ArgumentError, "Invalid value:#{log_exception.inspect} for argument :log_exception")
+        end
+        # On exception change the log level
+        if on_exception_level
+          self.level       = on_exception_level
+          self.level_index = SemanticLogger.level_to_index(level)
+        end
+      end
+
+      if backtrace
+        self.backtrace = self.class.cleanse_backtrace(backtrace)
+      elsif level_index >= SemanticLogger.backtrace_level_index
+        self.backtrace = self.class.cleanse_backtrace
+      end
+
+      if metric
+        self.metric        = metric
+        self.metric_amount = metric_amount
+      end
+
+      self.payload = payload if payload && (payload.size > 0)
+      true
+    end
+
+    # Assign positional arguments to this log entry, supplying defaults where applicable
+    #
+    # Returns [true|false] whether this log entry should be logged
+    #
+    # Example:
+    #   logger.info('value', :debug, 0, "hello world")
+    def assign_positional(message = nil, payload = nil, exception = nil)
+      # 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)
+        exception = payload
+        payload   = nil
+      end
+
+      # Add result of block as message or payload if not nil
+      if block_given? && (result = yield)
+        if result.is_a?(String)
+          message = message.nil? ? result : "#{message} -- #{result}"
+          assign(message: message, payload: payload, exception: exception)
+        elsif message.nil? && result.is_a?(Hash)
+          assign(result)
+        elsif payload && payload.respond_to?(:merge)
+          assign(message: message, payload: payload.merge(result), exception: exception)
+        else
+          assign(message: message, payload: result, exception: exception)
+        end
+      else
+        assign(message: message, payload: payload, exception: exception)
+      end
+    end
 
     MAX_EXCEPTIONS_TO_UNWRAP = 5
     # Call the block for exception and any nested exception
@@ -196,7 +292,8 @@ module SemanticLogger
       end
 
       # Tags
-      h[:tags] = tags if tags && (tags.size > 0)
+      h[:tags]       = tags if tags && !tags.empty?
+      h[:named_tags] = named_tags if named_tags && !named_tags.empty?
 
       # Duration
       if duration
@@ -208,13 +305,7 @@ module SemanticLogger
       h[:message] = cleansed_message if message
 
       # Payload
-      if payload
-        if payload.is_a?(Hash)
-          h.merge!(payload)
-        else
-          h[:payload] = payload
-        end
-      end
+      h[:payload] = payload if payload && payload.respond_to?(:empty?) && !payload.empty?
 
       # Exceptions
       if exception
@@ -231,11 +322,23 @@ module SemanticLogger
       end
 
       # Metric
-      h[:metric] = metric if metric
+      h[:metric]        = metric if metric
       h[:metric_amount] = metric_amount if metric_amount
       h
     end
 
+    private
+
+    SELF_PATTERN = File.join('lib', 'semantic_logger')
+
+    # Extract the backtrace leaving out Semantic Logger
+    def self.cleanse_backtrace(stack = caller)
+      while (first = stack.first) && first.include?(SELF_PATTERN)
+        stack.shift
+      end
+      stack
+    end
+
   end
 
 end

data/lib/semantic_logger/logger.rb

@@ -38,95 +38,26 @@ module SemanticLogger
     # logging, increase the log level, reduce the number of appenders, or
     # look into speeding up the appenders themselves
     def self.queue_size
-      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
     def self.flush
-      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)
+      Processor.submit_request(:flush)
     end
 
     # 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)
+      Processor.submit_request(:close)
     end
 
-    @@lag_check_interval = 5000
-    @@lag_threshold_s    = 30
-
-    # Returns the check_interval which is the number of messages between checks
-    # to determine if the appender thread is falling behind
-    def self.lag_check_interval
-      @@lag_check_interval
-    end
-
-    # Set the check_interval which is the number of messages between checks
-    # to determine if the appender thread is falling behind
-    def self.lag_check_interval=(lag_check_interval)
-      @@lag_check_interval = lag_check_interval
-    end
-
-    # Returns the amount of time in seconds
-    # to determine if the appender thread is falling behind
-    def self.lag_threshold_s
-      @@lag_threshold_s
-    end
-
-    # Allow the internal logger to be overridden from its default to STDERR
+    # 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
     def self.logger=(logger)
-      @@logger = logger
-    end
-
-    # Supply a metrics appender to be called whenever a logging metric is encountered
-    #
-    #  Parameters
-    #    appender: [Symbol | Object | Proc]
-    #      [Proc] the block to call.
-    #      [Object] the block on which to call #call.
-    #      [Symbol] :new_relic, or :statsd to forward metrics to
-    #
-    #    block
-    #      The block to be called
-    #
-    # Example:
-    #   SemanticLogger.on_metric do |log|
-    #     puts "#{log.metric} was received. Log Struct: #{log.inspect}"
-    #   end
-    #
-    # Note:
-    # * This callback is called in the logging thread.
-    # * Does not slow down the application.
-    # * Only context is what is passed in the log struct, the original thread context is not available.
-    def self.on_metric(options = {}, &block)
-      # Backward compatibility
-      options  = options.is_a?(Hash) ? options.dup : {appender: options}
-      appender = block || options.delete(:appender)
-
-      # Convert symbolized metrics appender to an actual object
-      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
+      Processor.logger = logger
     end
 
     # Place log request on the queue for the Appender thread to write to each
@@ -134,147 +65,7 @@ module SemanticLogger
     def log(log, message = nil, progname = nil, &block)
       # Compatibility with ::Logger
       return add(log, message, progname, &block) unless log.is_a?(SemanticLogger::Log)
-      self.class.queue << log if @@appender_thread
-    end
-
-    private
-
-    @@appender_thread    = nil
-    @@queue              = Queue.new
-    @@metric_subscribers = nil
-
-    # Queue to hold messages that need to be logged to the various appenders
-    def self.queue
-      @@queue
-    end
-
-    # Internal logger for SemanticLogger
-    #   For example when an appender is not working etc..
-    #   By default logs to STDERR
-    def self.logger
-      @@logger ||= begin
-        l      = SemanticLogger::Appender::File.new(STDERR, :warn)
-        l.name = name
-        l
-      end
-    end
-
-    # Start the appender thread
-    def self.start_appender_thread
-      return false if appender_thread_active?
-      @@appender_thread = Thread.new { appender_thread }
-      raise 'Failed to start Appender Thread' unless @@appender_thread
-      true
-    end
-
-    # Returns true if the appender_thread is active
-    def self.appender_thread_active?
-      @@appender_thread && @@appender_thread.alive?
-    end
-
-    # Separate appender thread responsible for reading log messages and
-    # calling the appenders in it's thread
-    def self.appender_thread
-      # This thread is designed to never go down unless the main thread terminates
-      # Before terminating at_exit is used to flush all the appenders
-      #
-      # Should any appender fail to log or flush, the exception is logged and
-      # other appenders will still be called
-      Thread.current.name = 'SemanticLogger::AppenderThread'
-      logger.trace "V#{VERSION} Appender thread active"
-      begin
-        count = 0
-        while message = queue.pop
-          if message.is_a?(Log)
-            SemanticLogger.appenders.each do |appender|
-              begin
-                appender.log(message)
-              rescue Exception => exc
-                logger.error "Appender thread: Failed to log to appender: #{appender.inspect}", exc
-              end
-            end
-            call_metric_subscribers(message) if message.metric
-            count += 1
-            # Check every few log messages whether this appender thread is falling behind
-            if count > lag_check_interval
-              if (diff = Time.now - message.time) > lag_threshold_s
-                logger.warn "Appender thread has fallen behind by #{diff} seconds with #{queue_size} messages queued up. Consider reducing the log level or changing the appenders"
-              end
-              count = 0
-            end
-          else
-            case message[:command]
-            when :flush
-              SemanticLogger.appenders.each do |appender|
-                begin
-                  logger.trace "Appender thread: Flushing appender: #{appender.name}"
-                  appender.flush
-                rescue Exception => exc
-                  logger.error "Appender thread: Failed to flush appender: #{appender.inspect}", exc
-                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
-              logger.warn "Appender thread: Ignoring unknown command: #{message[:command]}"
-            end
-          end
-        end
-      rescue Exception => exception
-        # This block may be called after the file handles have been released by Ruby
-        begin
-          logger.error 'Appender thread restarting due to exception', exception
-        rescue Exception
-          nil
-        end
-        retry
-      ensure
-        @@appender_thread = nil
-        # This block may be called after the file handles have been released by Ruby
-        begin
-          logger.trace 'Appender thread has stopped'
-        rescue Exception
-          nil
-        end
-      end
-    end
-
-    # Call Metric subscribers
-    def self.call_metric_subscribers(log)
-      # If no subscribers registered, then return immediately
-      return unless @@metric_subscribers
-
-      @@metric_subscribers.each do |subscriber|
-        begin
-          subscriber.call(log)
-        rescue Exception => exc
-          logger.error 'Exception calling metrics subscriber', exc
-        end
-      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
+      Processor << log
     end
 
   end