semantic_logger 4.0.0 → 4.1.0

data/lib/semantic_logger/appender/udp.rb

@@ -57,14 +57,11 @@ module SemanticLogger
       #     appender: :udp,
       #     server:   'server:3300'
       #   )
-      def initialize(options = {}, &block)
-        @socket    = nil
-        options    = options.dup
-        @server    = options.delete(:server)
-        @udp_flags = options.delete(:udp_flags) || 0
-        raise(ArgumentError, 'Missing mandatory argument: :server') unless @server
+      def initialize(server:, udp_flags: 0, level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+        @server    = server
+        @udp_flags = udp_flags
 
-        super(options, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
         reopen
       end
 

data/lib/semantic_logger/appender/wrapper.rb

@@ -39,19 +39,15 @@ module SemanticLogger
       #    logger.info('Hello World', some: :payload)
       #
       # Install the `rails_semantic_logger` gem to replace the Rails logger with Semantic Logger.
-      def initialize(options, &block)
-        # Backward compatibility
-        options = {logger: options} unless options.is_a?(Hash)
-        options = options.dup
-        @logger = options.delete(:logger)
+      def initialize(logger:, level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+        @logger = 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
 
-        raise 'SemanticLogging::Appender::Wrapper missing mandatory parameter :logger' unless @logger
-        super(options, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
       end
 
       # Pass log calls to the underlying Rails, log4j or Ruby logger

data/lib/semantic_logger/base.rb

@@ -132,7 +132,7 @@ module SemanticLogger
         else
           log.thread_name = thread.name
           log.tags        = (thread[:semantic_logger_tags] || []).clone
-          log.named_tags  = (thread[:semantic_logger_named_tags] || []).clone
+          log.named_tags  = (thread[:semantic_logger_named_tags] || {}).clone
           thread.backtrace
         end
       # TODO: Keep backtrace instead of transforming into a text message at this point
@@ -147,9 +147,42 @@ module SemanticLogger
       end
     end
 
-    # :nodoc:
+    # Add the tags or named tags to the list of tags to log for this thread whilst the supplied block is active.
+    #
+    # Returns result of block.
+    #
+    # Tagged example:
+    #   SemanticLogger.tagged(12345, 'jack') do
+    #     logger.debug('Hello World')
+    #   end
+    #
+    # Named Tags (Hash) example:
+    #   SemanticLogger.tagged(tracking_number: 12345) do
+    #     logger.debug('Hello World')
+    #   end
+    #
+    # Notes:
+    # - Named tags are the recommended approach since the tag consists of a name value pair this is more useful
+    #   than just a string value in the logs, or centralized logging system.
+    # - This method is slow when using multiple text tags since it needs to flatten the tags and
+    #   remove empty elements to support Rails 4.
+    # - It is recommended to keep tags as a list without any empty values, or contain any child arrays.
+    #   However, this api will convert:
+    #     `logger.tagged([['first', nil], nil, ['more'], 'other'])`
+    #   to:
+    #     `logger.tagged('first', 'more', 'other')`
+    # - For better performance with clean tags, see `SemanticLogger.tagged`.
     def tagged(*tags, &block)
-      SemanticLogger.tagged(*tags, &block)
+      # Allow named tags to be passed into the logger
+      if tags.size == 1
+        tag = tags[0]
+        return yield if tag.nil? || tag == ''
+        return tag.is_a?(Hash) ? SemanticLogger.named_tagged(tag, &block) : SemanticLogger.fast_tag(tag.to_s, &block)
+      end
+
+      # Need to flatten and reject empties to support calls from Rails 4
+      new_tags = tags.flatten.collect(&:to_s).reject(&:empty?)
+      SemanticLogger.tagged(*new_tags, &block)
     end
 
     # :nodoc:
@@ -160,9 +193,16 @@ module SemanticLogger
       SemanticLogger.tags
     end
 
-    # :nodoc:
+    # Returns the list of tags pushed after flattening them out and removing blanks
+    #
+    # Note:
+    # - This method is slow since it needs to flatten the tags and remove empty elements
+    #   to support Rails 4.
+    # - For better performance with clean tags, use `SemanticLogger.push_tags`
     def push_tags(*tags)
-      SemanticLogger.push_tags(*tags)
+      # Need to flatten and reject empties to support calls from Rails 4
+      new_tags = tags.flatten.collect(&:to_s).reject(&:empty?)
+      SemanticLogger.push_tags(*new_tags)
     end
 
     # :nodoc:
@@ -175,7 +215,7 @@ module SemanticLogger
       SemanticLogger.silence(new_level, &block)
     end
 
-    # :nodoc:
+    # Deprecated. Use `SemanticLogger.tagged`
     def fast_tag(tag, &block)
       SemanticLogger.fast_tag(tag, &block)
     end
@@ -286,7 +326,7 @@ module SemanticLogger
             if silence_level = params[:silence]
               # In case someone accidentally sets `silence: true` instead of `silence: :error`
               silence_level = :error if silence_level == true
-              silence(silence_level) { yield(params) }
+              silence(silence_level) {yield(params)}
             else
               yield(params)
             end

data/lib/semantic_logger/formatters/base.rb

@@ -1,7 +1,23 @@
+require 'time'
 module SemanticLogger
   module Formatters
     class Base
-      attr_accessor :time_format, :precision, :log_host, :log_application
+      attr_accessor :time_format, :log_host, :log_application
+
+      # Time precision varies by Ruby interpreter
+      # JRuby 9.1.8.0 supports microseconds
+      PRECISION   =
+        if defined?(JRuby)
+          if (JRUBY_VERSION.to_f >= 9.1)
+            maint = JRUBY_VERSION.match(/\A\d\.\d\.(\d)\./)[1].to_i
+            (maint >= 8) || (JRUBY_VERSION.to_f > 9.1) ? 6 : 3
+          else
+            3
+          end
+        else
+          6
+        end
+      TIME_FORMAT = "%Y-%m-%d %H:%M:%S.%#{PRECISION}N"
 
       # Parameters
       #   time_format: [String|Symbol|nil]
@@ -9,21 +25,24 @@ module SemanticLogger
       #     :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
+      def initialize(time_format: TIME_FORMAT, log_host: true, log_application: true)
+        @time_format     = time_format
+        @log_host        = log_host
+        @log_application = log_application
       end
 
+      # Date & time
+      def time
+        format_time(log.time) if time_format
+      end
+
+      private
+
       # Return the Time as a formatted string
       def format_time(time)
         case time_format
         when :iso_8601
-          time.utc.iso8601(precision)
+          time.utc.iso8601(PRECISION)
         when nil
           ''
         else

data/lib/semantic_logger/formatters/color.rb

@@ -6,68 +6,98 @@ end
 
 module SemanticLogger
   module Formatters
-    class Color < Base
-      # Parameters:
-      #   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 = {})
-        options     = options.dup
-        @ai_options = options.delete(:ap) || {multiline: false}
-        super(options)
+    class Color < Default
+      attr_accessor :color_map, :color
+
+      # Supply a custom color map for every log level
+      class ColorMap
+        attr_accessor :trace, :debug, :info, :warn, :error, :fatal, :bold, :clear
+
+        def initialize(trace: AnsiColors::MAGENTA, debug: AnsiColors::GREEN, info: AnsiColors::CYAN, warn: AnsiColors::BOLD, error: AnsiColors::RED, fatal: AnsiColors::RED, bold: AnsiColors::BOLD, clear: AnsiColors::CLEAR)
+          @trace = trace
+          @debug = debug
+          @info  = info
+          @warn  = warn
+          @error = error
+          @fatal = fatal
+          @bold  = bold
+          @clear = clear
+        end
+
+        def [](level)
+          public_send(level)
+        end
       end
 
       # Adds color to the default log formatter
+      #
       # Example:
+      #   # Use a colorized output logger.
       #   SemanticLogger.add_appender(io: $stdout, formatter: :color)
-      def call(log, logger)
-        colors      = SemanticLogger::AnsiColors
-        level_color = colors::LEVEL_MAP[log.level]
-
-        message = time_format.nil? ? '' : "#{format_time(log.time)} "
+      #
+      # Example:
+      #   # Use a colorized output logger chenging the color for info to green.
+      #   SemanticLogger.add_appender(io: $stdout, formatter: :color, color_map: {info: SemanticLogger::AnsiColors::YELLOW})
+      #
+      # Parameters:
+      #  ap: [Hash]
+      #    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.
+      #
+      #  color_map: [Hash | SemanticLogger::Formatters::Color::ColorMap]
+      #    ColorMaps each of the log levels to a color
+      def initialize(ap: {multiline: false}, color_map: ColorMap.new, time_format: TIME_FORMAT, log_host: false, log_application: false)
+        @ai_options = ap
+        @color_map  = color_map.is_a?(ColorMap) ? color_map : ColorMap.new(color_map)
+        super(time_format: time_format, log_host: log_host, log_application: log_application)
+      end
 
-        # Header with date, time, log level and process info
-        message << "#{level_color}#{log.level_to_s}#{colors::CLEAR} [#{log.process_info}]"
+      def level
+        "#{color}#{super}#{color_map.clear}"
+      end
 
-        # Tags
-        message << ' ' << log.tags.collect { |tag| "[#{level_color}#{tag}#{colors::CLEAR}]" }.join(' ') if log.tags && (log.tags.size > 0)
+      def tags
+        "[#{color}#{log.tags.join("#{color_map.clear}] [#{color}")}#{color_map.clear}]" if log.tags && !log.tags.empty?
+      end
 
-        # Named Tags
+      # Named Tags
+      def 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(' ')
+          named_tags.each_pair { |name, value| list << "#{color}#{name}: #{value}#{color_map.clear}" }
+          "{#{list.join(', ')}}"
         end
+      end
 
-        # Duration
-        message << " (#{colors::BOLD}#{log.duration_human}#{colors::CLEAR})" if log.duration
+      def duration
+        "(#{color_map.bold}#{log.duration_human}#{color_map.clear})" if log.duration
+      end
 
-        # Class / app name
-        message << " #{level_color}#{log.name}#{colors::CLEAR}"
+      def name
+        "#{color}#{super}#{color_map.clear}"
+      end
 
-        # Log message
-        message << " -- #{log.message}" if log.message
+      def payload
+        return unless log.has_payload?
 
-        # Payload: Colorize the payload if the AwesomePrint gem is loaded
-        if log.has_payload?
-          payload = log.payload
-          message << ' -- ' <<
-            if !defined?(AwesomePrint) || !payload.respond_to?(:ai)
-              payload.inspect
-            else
-              payload.ai(@ai_options) rescue payload.inspect
-            end
+        if !defined?(AwesomePrint) || !log.payload.respond_to?(:ai)
+          super
+        else
+          "-- #{log.payload.ai(@ai_options)}" rescue super
         end
+      end
 
-        # Exceptions
-        if log.exception
-          message << " -- Exception: #{colors::BOLD}#{log.exception.class}: #{log.exception.message}#{colors::CLEAR}\n"
-          message << log.backtrace_to_s
-        end
-        message
+      def exception
+        "-- Exception: #{color}#{log.exception.class}: #{log.exception.message}#{color_map.clear}\n#{log.backtrace_to_s}" if log.exception
+      end
+
+      def call(log, logger)
+        self.color = color_map[log.level]
+        super(log, logger)
       end
 
     end

data/lib/semantic_logger/formatters/default.rb

@@ -1,46 +1,71 @@
 module SemanticLogger
   module Formatters
+    # Default non-colored text log output
     class Default < Base
-      # Default text log format
-      #  Generates logs of the form:
-      #    2011-07-19 14:36:15.660235 D [1149:ScriptThreadProcess] Rails -- Hello World
-      def call(log, logger)
-        # Date & time
-        message = time_format.nil? ? '' : "#{format_time(log.time)} "
+      attr_accessor :log, :logger
 
-        # Log level and process info
-        message << "#{log.level_to_s} [#{log.process_info}]"
+      # Formatting methods, must return nil, or a string
+      # Nil values are ignored
 
-        # Tags
-        message << ' ' << log.tags.collect { |tag| "[#{tag}]" }.join(' ') if log.tags && (log.tags.size > 0)
+      # Log level
+      def level
+        log.level_to_s
+      end
 
-        # Named Tags
+      # Process info
+      def process_info
+        "[#{log.process_info}]"
+      end
+
+      # Tags
+      def tags
+        "[#{log.tags.join('] [')}]" if log.tags && !log.tags.empty?
+      end
+
+      # Named Tags
+      def named_tags
         if (named_tags = log.named_tags) && !named_tags.empty?
           list = []
-          named_tags.each_pair { |name, value| list << "[#{name}: #{value}]" }
-          message << ' ' << list.join(' ')
+          named_tags.each_pair { |name, value| list << "#{name}: #{value}" }
+          "{#{list.join(', ')}}"
         end
+      end
 
-        # Duration
-        message << " (#{log.duration_human})" if log.duration
+      # Duration
+      def duration
+        "(#{log.duration_human})" if log.duration
+      end
 
-        # Class / app name
-        message << " #{log.name}"
+      # Class / app name
+      def name
+        log.name
+      end
 
-        # Log message
-        message << " -- #{log.message}" if log.message
+      # Log message
+      def message
+        "-- #{log.message}" if log.message
+      end
 
-        # Payload
-        if payload = log.payload_to_s
-          message << ' -- ' << payload
+      # Payload
+      def payload
+        if pl = log.payload_to_s
+          "-- #{pl}"
         end
+      end
 
-        # Exceptions
-        if log.exception
-          message << " -- Exception: #{log.exception.class}: #{log.exception.message}\n"
-          message << log.backtrace_to_s
-        end
-        message
+      # Exception
+      def exception
+        "-- Exception: #{log.exception.class}: #{log.exception.message}\n#{log.backtrace_to_s}" if log.exception
+      end
+
+      # Default text log format
+      #  Generates logs of the form:
+      #    2011-07-19 14:36:15.660235 D [1149:ScriptThreadProcess] Rails -- Hello World
+      def call(log, logger)
+        self.log    = log
+        self.logger = logger
+
+        [time, level, process_info, tags, named_tags, duration, name, message, payload, exception].compact.join(' ')
       end
 
     end

data/lib/semantic_logger/formatters/json.rb

@@ -3,18 +3,17 @@ module SemanticLogger
   module Formatters
     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)
+      def initialize(time_format: :iso_8601, log_host: true, log_application: true)
+        super(time_format: time_format, log_host: log_host, log_application: log_application)
+      end
+
+      def time
+        hash[:timestamp] = format_time(log.time)
       end
 
       # Returns log messages in JSON format
       def call(log, logger)
-        h = super(log, logger)
-        h.delete(:time)
-        h[:timestamp] = format_time(log.time)
-        h.to_json
+        super(log, logger).to_json
       end
 
     end