lumberjack 1.0.13 → 1.2.8

data/lib/lumberjack/rack.rb

@@ -2,7 +2,8 @@
 
 module Lumberjack
   module Rack
-    require File.expand_path("../rack/unit_of_work.rb", __FILE__)
-    require File.expand_path("../rack/request_id.rb", __FILE__)
+    require_relative "rack/unit_of_work"
+    require_relative "rack/request_id"
+    require_relative "rack/context"
   end
 end

data/lib/lumberjack/rack/context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literals: true
+
+module Lumberjack
+  module Rack
+    # Middleware to create a global context for Lumberjack for the scope of a rack request.
+    class Context
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Lumberjack.context do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/lumberjack/rack/request_id.rb

@@ -6,17 +6,17 @@ module Lumberjack
     # The format is expected to be a random UUID and only the first chunk is used for terseness
     # if the abbreviated argument is true.
     class RequestId
-      REQUEST_ID = "action_dispatch.request_id".freeze
-  
+      REQUEST_ID = "action_dispatch.request_id"
+
       def initialize(app, abbreviated = false)
         @app = app
         @abbreviated = abbreviated
       end
-  
+
       def call(env)
         request_id = env[REQUEST_ID]
         if request_id && @abbreviated
-          request_id = request_id.split('-'.freeze, 2).first
+          request_id = request_id.split("-", 2).first
         end
         Lumberjack.unit_of_work(request_id) do
           @app.call(env)

data/lib/lumberjack/rack/unit_of_work.rb

@@ -6,7 +6,7 @@ module Lumberjack
       def initialize(app)
         @app = app
       end
-      
+
       def call(env)
         Lumberjack.unit_of_work do
           @app.call(env)

data/lib/lumberjack/severity.rb

@@ -3,20 +3,21 @@
 module Lumberjack
   # The standard severity levels for logging messages.
   module Severity
-    UNKNOWN = 5
-    FATAL = 4
-    ERROR = 3
-    WARN = 2
-    INFO = 1
-    DEBUG = 0
-    
-    SEVERITY_LABELS = %w(DEBUG INFO WARN ERROR FATAL UNKNOWN).freeze
-    
+    # Backward compatibilty with 1.0 API
+    DEBUG = ::Logger::Severity::DEBUG
+    INFO = ::Logger::Severity::INFO
+    WARN = ::Logger::Severity::WARN
+    ERROR = ::Logger::Severity::ERROR
+    FATAL = ::Logger::Severity::FATAL
+    UNKNOWN = ::Logger::Severity::UNKNOWN
+
+    SEVERITY_LABELS = %w[DEBUG INFO WARN ERROR FATAL UNKNOWN].freeze
+
     class << self
       def level_to_label(severity)
         SEVERITY_LABELS[severity] || SEVERITY_LABELS.last
       end
-    
+
       def label_to_level(label)
         SEVERITY_LABELS.index(label.to_s.upcase) || UNKNOWN
       end

data/lib/lumberjack/tag_formatter.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  # Class for formatting tags. You can register a default formatter and tag
+  # name specific formatters. Formatters can be either `Lumberjack::Formatter`
+  # objects or any object that responds to `call`.
+  #
+  # tag_formatter = Lumberjack::TagFormatter.new.default(Lumberjack::Formatter.new)
+  # tag_formatter.add(["password", "email"]) { |value| "***" }
+  # tag_formatter.add("finished_at", Lumberjack::Formatter::DateTimeFormatter.new("%Y-%m-%dT%H:%m:%S%z"))
+  class TagFormatter
+    def initialize
+      @formatters = {}
+      @default_formatter = nil
+    end
+
+    # Add a default formatter applied to all tag values. This can either be a Lumberjack::Formatter
+    # or an object that responds to `call` or a block.
+    def default(formatter = nil, &block)
+      formatter ||= block
+      formatter = dereference_formatter(formatter)
+      @default_formatter = formatter
+      self
+    end
+
+    # Remove the default formatter.
+    def remove_default
+      @default_formatter = nil
+      self
+    end
+
+    # Add a formatter for specific tag names. This can either be a Lumberjack::Formatter
+    # or an object that responds to `call` or a block. The default formatter will not be
+    # applied.
+    def add(names, formatter = nil, &block)
+      formatter ||= block
+      formatter = dereference_formatter(formatter)
+      if formatter.nil?
+        remove(key)
+      else
+        Array(names).each do |name|
+          @formatters[name.to_s] = formatter
+        end
+      end
+      self
+    end
+
+    # Remove formatters for specific tag names. The default formatter will still be applied.
+    def remove(names)
+      Array(names).each do |name|
+        @formatters.delete(name.to_s)
+      end
+      self
+    end
+
+    # Remove all formatters.
+    def clear
+      @default_formatter = nil
+      @formatters.clear
+      self
+    end
+
+    # Format a hash of tags using the formatters
+    def format(tags)
+      return nil if tags.nil?
+      if @default_formatter.nil? && (@formatters.empty? || (@formatters.keys & tags.keys).empty?)
+        tags
+      else
+        formatted = {}
+        tags.each do |name, value|
+          formatter = (@formatters[name.to_s] || @default_formatter)
+          if formatter.is_a?(Lumberjack::Formatter)
+            value = formatter.format(value)
+          elsif formatter.respond_to?(:call)
+            value = formatter.call(value)
+          end
+          formatted[name.to_s] = value
+        end
+        formatted
+      end
+    end
+
+    private
+
+    def dereference_formatter(formatter)
+      if formatter.is_a?(TaggedLoggerSupport::Formatter)
+        formatter.__formatter
+      elsif formatter.is_a?(Symbol)
+        formatter_class_name = "#{formatter.to_s.gsub(/(^|_)([a-z])/) { |m| $~[2].upcase }}Formatter"
+        Formatter.const_get(formatter_class_name).new
+      else
+        formatter
+      end
+    end
+  end
+end

data/lib/lumberjack/tagged_logger_support.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "forwardable"
+
+module Lumberjack
+  # Methods to make Lumberjack::Logger API compatible with ActiveSupport::TaggedLogger.
+  module TaggedLoggerSupport
+    class Formatter < DelegateClass(Lumberjack::Formatter)
+      extend Forwardable
+      def_delegators :@logger, :tagged, :push_tags, :pop_tags, :clear_tags!
+
+      def initialize(formatter:, logger:)
+        @logger = logger
+        @formatter = formatter
+        super(formatter)
+      end
+
+      def current_tags
+        tags = @logger.instance_variable_get(:@tags)
+        if tags.is_a?(Hash)
+          Array(tags["tagged"])
+        else
+          []
+        end
+      end
+
+      def tags_text
+        tags = current_tags
+        if tags.any?
+          tags.collect { |tag| "[#{tag}] " }.join
+        end
+      end
+
+      def __formatter
+        @formatter
+      end
+    end
+
+    # Compatibility with ActiveSupport::TaggedLogging which only supports adding tags as strings.
+    # If a tag looks like "key:value"  or "key=value", it will be added as a key value pair.
+    # Otherwise it will be appended to a list named "tagged".
+    def tagged(*tags, &block)
+      tag_hash = {}
+      tags.flatten.each do |tag|
+        tagged_values = Array(tag_hash["tagged"] || self.tags["tagged"])
+        tag_hash["tagged"] = tagged_values + [tag]
+      end
+      tag(tag_hash, &block)
+    end
+
+    def push_tags(*tags)
+      tagged(*tags)
+    end
+
+    def pop_tags(size = 1)
+      tagged_values = Array(@tags["tagged"])
+      tagged_values = (tagged_values.size > size ? tagged_values[0, tagged_values.size - size] : nil)
+      tag("tagged" => tagged_values)
+    end
+
+    def clear_tags!
+      tag("tagged" => nil)
+    end
+  end
+end

data/lib/lumberjack/tagged_logging.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  # Monkey patch for ActiveSupport::TaggedLogger so it doesn't blow up when
+  # a Lumberjack logger is trying to be wrapped. This module will be automatically
+  # included in ActiveSupport::TaggedLogger if activesupport is already loaded.
+  module TaggedLogging
+    class << self
+      def included(base)
+        base.singleton_class.send(:prepend, ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def new(logger)
+        if logger.is_a?(Lumberjack::Logger)
+          logger = logger.tagged_logger! unless logger.respond_to?(:tagged)
+          logger
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActiveSupport::TaggedLogging)
+  ActiveSupport::TaggedLogging.include(Lumberjack::TaggedLogging)
+end

data/lib/lumberjack/tags.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  class Tags
+    class << self
+      # Transform hash keys to strings. This method exists for optimization and backward compatibility.
+      # If a hash already has string keys, it will be returned as is.
+      def stringify_keys(hash)
+        return nil if hash.nil?
+        if hash.keys.all? { |key| key.is_a?(String) }
+          hash
+        elsif hash.respond_to?(:transform_keys)
+          hash.transform_keys(&:to_s)
+        else
+          copy = {}
+          hash.each do |key, value|
+            copy[key.to_s] = value
+          end
+          copy
+        end
+      end
+
+      # Ensure keys are strings and expand any values in a hash that are Proc's by calling them and replacing
+      # the value with the result. This allows setting global tags with runtime values.
+      def expand_runtime_values(hash)
+        return nil if hash.nil?
+        if hash.all? { |key, value| key.is_a?(String) && !value.is_a?(Proc) }
+          return hash
+        end
+
+        copy = {}
+        hash.each do |key, value|
+          if value.is_a?(Proc) && (value.arity == 0 || value.arity == -1)
+            value = value.call
+          end
+          copy[key.to_s] = value
+        end
+        copy
+      end
+    end
+  end
+end

data/lib/lumberjack/template.rb

@@ -4,70 +4,118 @@ module Lumberjack
   # A template converts entries to strings. Templates can contain the following place holders to
   # reference log entry values:
   #
-  # * <tt>:time</tt>
-  # * <tt>:severity</tt>
-  # * <tt>:progname</tt>
-  # * <tt>:unit_of_work_id</tt>
-  # * <tt>:message</tt>
+  # * :time
+  # * :severity
+  # * :progname
+  # * :tags
+  # * :message
+  #
+  # Any other words prefixed with a colon will be substituted with the value of the tag with that name.
+  # If your tag name contains characters other than alpha numerics and the underscore, you must surround it
+  # with curly brackets: `:{http.request-id}`.
   class Template
-    TEMPLATE_ARGUMENT_ORDER = %w(:time :severity :progname :pid :unit_of_work_id :message).freeze
-    DEFAULT_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S."
-    MILLISECOND_FORMAT = "%03d"
-    MICROSECOND_FORMAT = "%06d"
-    
+    TEMPLATE_ARGUMENT_ORDER = %w[:time :severity :progname :pid :message :tags].freeze
+    MILLISECOND_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%3N"
+    MICROSECOND_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%6N"
+    PLACEHOLDER_PATTERN = /:(([a-z0-9_]+)|({[^}]+}))/i.freeze
+
     # Create a new template from the markup. The +first_line+ argument is used to format only the first
     # line of a message. Additional lines will be added to the message unformatted. If you wish to format
-    # the additional lines, use the <tt>:additional_lines</tt> options to specify a template. Note that you'll need
+    # the additional lines, use the :additional_lines options to specify a template. Note that you'll need
     # to provide the line separator character in this template if you want to keep the message on multiple lines.
     #
     # The time will be formatted as YYYY-MM-DDTHH:MM:SSS.SSS by default. If you wish to change the format, you
-    # can specify the <tt>:time_format</tt> option which can be either a time format template as documented in
+    # can specify the :time_format option which can be either a time format template as documented in
     # +Time#strftime+ or the values +:milliseconds+ or +:microseconds+ to use the standard format with the
     # specified precision.
     #
     # Messages will have white space stripped from both ends.
     def initialize(first_line, options = {})
-      @first_line_template = compile(first_line)
+      @first_line_template, @first_line_tags = compile(first_line)
       additional_lines = options[:additional_lines] || "#{Lumberjack::LINE_SEPARATOR}:message"
-      @additional_line_template = compile(additional_lines)
+      @additional_line_template, @additional_line_tags = compile(additional_lines)
       # Formatting the time is relatively expensive, so only do it if it will be used
       @template_include_time = first_line.include?(":time") || additional_lines.include?(":time")
-      @time_format = options[:time_format] || :milliseconds
+      self.datetime_format = (options[:time_format] || :milliseconds)
+    end
+
+    def datetime_format=(format)
+      if format == :milliseconds
+        format = MILLISECOND_TIME_FORMAT
+      elsif format == :microseconds
+        format = MICROSECOND_TIME_FORMAT
+      end
+      @time_formatter = Formatter::DateTimeFormatter.new(format)
     end
-    
+
+    def datetime_format
+      @time_formatter.format
+    end
+
     # Convert an entry into a string using the template.
     def call(entry)
-      lines = entry.message.strip.split(Lumberjack::LINE_SEPARATOR)
-      formatted_time = format_time(entry.time) if @template_include_time
-      message = @first_line_template % [formatted_time, entry.severity_label, entry.progname, entry.pid, entry.unit_of_work_id, lines.shift]
-      lines.each do |line|
-        message << @additional_line_template % [formatted_time, entry.severity_label, entry.progname, entry.pid, entry.unit_of_work_id, line]
+      return entry unless entry.is_a?(LogEntry)
+
+      first_line = entry.message.to_s
+      additional_lines = nil
+      if first_line.include?(Lumberjack::LINE_SEPARATOR)
+        additional_lines = first_line.split(Lumberjack::LINE_SEPARATOR)
+        first_line = additional_lines.shift
+      end
+
+      formatted_time = @time_formatter.call(entry.time) if @template_include_time
+      format_args = [formatted_time, entry.severity_label, entry.progname, entry.pid, first_line]
+      tag_arguments = tag_args(entry.tags, @first_line_tags)
+      message = (@first_line_template % (format_args + tag_arguments))
+      message.rstrip! if message.end_with?(" ")
+
+      if additional_lines && !additional_lines.empty?
+        tag_arguments = tag_args(entry.tags, @additional_line_tags) unless @additional_line_tags == @first_line_tags
+        additional_lines.each do |line|
+          format_args[format_args.size - 1] = line
+          line_message = (@additional_line_template % (format_args + tag_arguments)).rstrip
+          line_message.rstrip! if line_message.end_with?(" ")
+          message << line_message
+        end
       end
       message
     end
-    
+
     private
 
-    def format_time(time) #:nodoc:
-      if @time_format.is_a?(String)
-        time.strftime(@time_format)
-      elsif @time_format == :milliseconds
-        time.strftime(DEFAULT_TIME_FORMAT) << MILLISECOND_FORMAT % (time.usec / 1000.0).round
-      else
-        time.strftime(DEFAULT_TIME_FORMAT) << MICROSECOND_FORMAT % time.usec
+    def tag_args(tags, tag_vars)
+      return [nil] * (tag_vars.size + 1) if tags.nil? || tags.size == 0
+
+      tags_string = ""
+      tags.each do |name, value|
+        unless value.nil? || tag_vars.include?(name)
+          value = value.to_s
+          value = value.gsub(Lumberjack::LINE_SEPARATOR, " ") if value.include?(Lumberjack::LINE_SEPARATOR)
+          tags_string << "[#{name}:#{value}] "
+        end
+      end
+
+      args = [tags_string.chop]
+      tag_vars.each do |name|
+        args << tags[name]
       end
+      args
     end
-    
+
     # Compile the template string into a value that can be used with sprintf.
     def compile(template) #:nodoc:
-      template.gsub(/:[a-z0-9_]+/) do |match|
-        position = TEMPLATE_ARGUMENT_ORDER.index(match)
+      tag_vars = []
+      template = template.gsub(PLACEHOLDER_PATTERN) do |match|
+        var_name = match.sub("{", "").sub("}", "")
+        position = TEMPLATE_ARGUMENT_ORDER.index(var_name)
         if position
           "%#{position + 1}$s"
         else
-          match
+          tag_vars << var_name[1, var_name.length]
+          "%#{TEMPLATE_ARGUMENT_ORDER.size + tag_vars.size}$s"
         end
       end
+      [template, tag_vars]
     end
   end
 end