lumberjack 2.0.4 → 2.1.0

data/lib/lumberjack/log_entry_matcher.rb

@@ -12,8 +12,16 @@ module Lumberjack
   # device in testing scenarios but can be used anywhere log entry filtering
   # is needed.
   #
+  # A matcher can optionally be constructed with an entry formatter. Filter
+  # values are always compared raw first. If a raw comparison fails, the filter
+  # value is run through the formatter and compared again. Since log entries
+  # are formatted before they are written to a device, this allows expectations
+  # to be written with unformatted values (an Exception, for example) and still
+  # match the formatted values captured on the entry.
+  #
   # @see Lumberjack::Device::Test
   class LogEntryMatcher
+    require_relative "log_entry_matcher/indifferent_hash"
     require_relative "log_entry_matcher/score"
 
     # Create a new log entry matcher with optional filtering criteria. All
@@ -27,14 +35,29 @@ module Lumberjack
     #   Accepts numeric levels or symbolic names (:debug, :info, etc.)
     # @param progname [Object, nil] Pattern to match against program names.
     #   Supports strings, regular expressions, or any object responding to ===
-    # @param attributes [Hash, nil] Hash of attribute patterns to match against
-    #   log entry attributes. Supports nested attribute matching and dot notation
-    def initialize(message: nil, severity: nil, progname: nil, attributes: nil)
+    # @param attributes [Hash, Object, nil] Hash of attribute patterns to match against
+    #   log entry attributes. Supports nested attribute matching and dot notation.
+    #   Any other object is matched against the entire attributes hash with ===
+    #   so matchers like RSpec's hash_including can be used.
+    # @param formatter [Lumberjack::EntryFormatter, Lumberjack::Logger, nil] Optional
+    #   formatter used to format filter values when a raw comparison fails. A Logger
+    #   can be passed to use its entry formatter. The message filter is formatted with
+    #   the message formatter; when the result is a MessageAttributes, only the message
+    #   part is used and the derived attributes are ignored. Attribute filter values are
+    #   formatted with the attribute formatter using their dot notation names. Pattern
+    #   objects (classes, regular expressions, ranges, procs, hashes, and test framework
+    #   matchers) are never formatted.
+    # @raise [ArgumentError] If the formatter is not an EntryFormatter or a Logger.
+    def initialize(message: nil, severity: nil, progname: nil, attributes: nil, formatter: nil)
       message = message.strip if message.is_a?(String)
       @message_filter = message
       @severity_filter = Severity.coerce(severity) if severity
       @progname_filter = progname
-      @attributes_filter = Utils.expand_attributes(attributes) if attributes
+      if attributes
+        @attributes_filter = attributes.is_a?(Hash) ? Utils.expand_attributes(attributes) : attributes
+      end
+      @formatter = resolve_formatter(formatter)
+      @formatted_attribute_filters = {}
     end
 
     # Test whether a log entry matches all specified criteria. The entry must
@@ -44,16 +67,56 @@ module Lumberjack
     # @param entry [Lumberjack::LogEntry] The log entry to test against the matcher
     # @return [Boolean] True if the entry matches all specified criteria, false otherwise
     def match?(entry)
-      return false unless match_filter?(entry.message, @message_filter)
-      return false unless match_filter?(entry.severity, @severity_filter)
-      return false unless match_filter?(entry.progname, @progname_filter)
+      diff(entry).empty?
+    end
+
+    # Compare a log entry against the matcher criteria and return only the fields
+    # that do not match. An empty hash means the entry matches, so
+    # +diff(entry).empty?+ is always equal to +match?(entry)+.
+    #
+    # The returned hash uses string keys for the fields ("message", "severity",
+    # "progname", and "attributes"). Each mismatched field maps to a hash with
+    # +:expected+ and +:actual+ (the entry value). Severity values are converted
+    # to labels on both sides for readability. When a formatter is set and the
+    # filter value was formatted, +:expected+ shows the formatted filter value
+    # so both sides of the mismatch are in the same form.
+    #
+    # Attribute mismatches are reported per attribute using dot notation keys.
+    # A missing attribute is reported with +actual: nil+. An attribute that was
+    # expected to be absent (a nil or empty filter value) is reported with the
+    # raw filter as +:expected+ and the entry value as +:actual+. When the
+    # attributes filter is not a hash (a matcher object applied to the whole
+    # attributes hash), a failure is reported as a single hash with +:expected+
+    # and +:actual+ keys instead of per attribute detail.
+    #
+    # @param entry [Lumberjack::LogEntry] The log entry to compare against the matcher
+    # @return [Hash] A hash of the fields that do not match; empty if the entry matches
+    def diff(entry)
+      result = {}
+
+      unless match_message?(entry.message)
+        result["message"] = {expected: expected_message, actual: entry.message}
+      end
+
+      unless match_filter?(entry.severity, @severity_filter)
+        result["severity"] = {expected: Severity.level_to_label(@severity_filter), actual: entry.severity_label}
+      end
+
+      unless match_filter?(entry.progname, @progname_filter)
+        result["progname"] = {expected: @progname_filter, actual: entry.progname}
+      end
 
       if @attributes_filter
-        attributes = Utils.expand_attributes(entry.attributes)
-        return false unless match_attributes?(attributes, @attributes_filter)
+        attributes = IndifferentHash.wrap(Utils.expand_attributes(entry.attributes))
+        if @attributes_filter.is_a?(Hash)
+          mismatches = attribute_mismatches(attributes, @attributes_filter)
+          result["attributes"] = mismatches unless mismatches.empty?
+        elsif !match_filter?(attributes, @attributes_filter)
+          result["attributes"] = {expected: @attributes_filter, actual: attributes}
+        end
       end
 
-      true
+      result
     end
 
     # Find the closest matching log entry from a list of candidates. This method
@@ -81,6 +144,21 @@ module Lumberjack
       )
     end
 
+    # Coerce the formatter argument into an EntryFormatter or nil.
+    #
+    # @param formatter [Lumberjack::EntryFormatter, Lumberjack::Logger, nil] The formatter argument.
+    # @return [Lumberjack::EntryFormatter, nil] The resolved entry formatter.
+    def resolve_formatter(formatter)
+      return nil if formatter.nil?
+      return formatter if formatter.is_a?(Lumberjack::EntryFormatter)
+
+      if formatter.respond_to?(:formatter) && formatter.formatter.is_a?(Lumberjack::EntryFormatter)
+        formatter.formatter
+      else
+        raise ArgumentError.new("formatter must be a Lumberjack::EntryFormatter or Lumberjack::Logger")
+      end
+    end
+
     # Apply a filter pattern against a value using case equality. Returns true
     # if no filter is specified (nil) or if the filter matches the value.
     #
@@ -93,34 +171,157 @@ module Lumberjack
       filter === value
     end
 
-    # Recursively match nested attribute structures against filter patterns.
-    # Handles both simple attribute matching and complex nested hash structures
-    # with support for partial matching and empty value detection.
+    # Match the message filter against an entry message. If the raw comparison
+    # fails, the filter is formatted with the message formatter and compared again.
+    #
+    # @param message [Object] The entry message.
+    # @return [Boolean] True if the message matches.
+    def match_message?(message)
+      return true if match_filter?(message, @message_filter)
+      return false if @formatter.nil? || @message_filter.nil? || pattern_filter?(@message_filter)
+
+      formatted = formatted_message_filter
+      return false if formatted.equal?(@message_filter)
+
+      match_filter?(message, formatted)
+    end
+
+    # The message filter value to report in a diff. The formatted value is used
+    # when the formatter changed the filter so both sides of a mismatch are in
+    # the same form.
+    #
+    # @return [Object] The message filter value to report.
+    def expected_message
+      if @formatter && !@message_filter.nil? && !pattern_filter?(@message_filter)
+        formatted_message_filter
+      else
+        @message_filter
+      end
+    end
+
+    # Format the message filter with the message formatter. The result is
+    # memoized so the formatter is only invoked once per matcher.
     #
-    # @param attributes [Hash] The expanded attributes hash from the log entry
-    # @param filter [Hash] The filter patterns to match against attributes
-    # @return [Boolean] True if all filter patterns match their corresponding attributes
-    def match_attributes?(attributes, filter)
-      return true unless filter
-      return false unless attributes
-
-      filter.all? do |name, value_filter|
+    # @return [Object] The formatted message filter.
+    def formatted_message_filter
+      return @formatted_message_filter if defined?(@formatted_message_filter)
+
+      value = @message_filter
+      message_formatter = @formatter.message_formatter
+      if message_formatter.respond_to?(:format)
+        begin
+          value = message_formatter.format(@message_filter)
+        rescue
+          value = @message_filter
+        end
+      end
+      value = value.message if value.is_a?(MessageAttributes)
+      value = value.strip if value.is_a?(String)
+      @formatted_message_filter = value
+    end
+
+    # Recursively compare attribute filter patterns against entry attributes and
+    # collect the mismatches. Keys in the returned hash use dot notation.
+    #
+    # @param attributes [Hash] The expanded attributes hash from the log entry.
+    # @param filter [Hash] The filter patterns to match against the attributes.
+    # @param path [String, nil] The dot notation path of the current nesting level.
+    # @param allow_formatting [Boolean] Whether filter values can be formatted on a failed comparison.
+    # @return [Hash] The mismatched attributes keyed by dot notation name.
+    def attribute_mismatches(attributes, filter, path = nil, allow_formatting: true)
+      mismatches = {}
+
+      filter.each do |name, value_filter|
         name = name.to_s
-        attribute_values = attributes[name]
-        if attribute_values.is_a?(Hash)
+        key = path ? "#{path}.#{name}" : name
+        attribute_value = attributes[name]
+
+        if attribute_value.is_a?(Hash)
           if value_filter.is_a?(Hash)
-            match_attributes?(attribute_values, value_filter)
+            mismatches.merge!(attribute_mismatches(attribute_value, value_filter, key, allow_formatting: allow_formatting))
           else
-            match_filter?(attribute_values, value_filter)
+            add_leaf_mismatches(mismatches, key, attribute_value, value_filter, allow_formatting)
           end
         elsif value_filter.nil? || (value_filter.is_a?(Enumerable) && value_filter.empty?)
-          attribute_values.nil? || (attribute_values.is_a?(Array) && attribute_values.empty?)
+          empty_value = attribute_value.nil? || (attribute_value.is_a?(Array) && attribute_value.empty?)
+          mismatches[key] = {expected: value_filter, actual: attribute_value} unless empty_value
         elsif attributes.include?(name)
-          match_filter?(attribute_values, value_filter)
+          add_leaf_mismatches(mismatches, key, attribute_value, value_filter, allow_formatting)
         else
-          false
+          mismatches[key] = {expected: value_filter, actual: nil}
+        end
+      end
+
+      mismatches
+    end
+
+    # Match a single attribute value against a filter and add any mismatches to
+    # the collector. If the raw comparison fails, the filter is formatted with the
+    # attribute formatter and compared again. Mismatches are reported with the
+    # formatted filter value so both sides are in the same form. A formatted result
+    # that is a hash is compared recursively against the entry value with formatting
+    # disabled since its values are already formatted, and mismatches are reported
+    # per attribute under the leaf's dot notation name.
+    #
+    # @param mismatches [Hash] The mismatch collector.
+    # @param path [String] The dot notation name of the attribute.
+    # @param value [Object] The entry attribute value.
+    # @param filter [Object] The filter pattern.
+    # @param allow_formatting [Boolean] Whether the filter can be formatted on a failed comparison.
+    # @return [void]
+    def add_leaf_mismatches(mismatches, path, value, filter, allow_formatting)
+      return if match_filter?(value, filter)
+
+      unless allow_formatting && @formatter && !pattern_filter?(filter)
+        mismatches[path] = {expected: filter, actual: value}
+        return
+      end
+
+      formatted = formatted_attribute_filter(path, filter)
+      if formatted.equal?(filter)
+        mismatches[path] = {expected: filter, actual: value}
+      elsif formatted.is_a?(Hash)
+        if value.is_a?(Hash)
+          mismatches.merge!(attribute_mismatches(value, Utils.expand_attributes(formatted), path, allow_formatting: false))
+        else
+          mismatches[path] = {expected: formatted, actual: value}
+        end
+      elsif !match_filter?(value, formatted)
+        mismatches[path] = {expected: formatted, actual: value}
+      end
+    end
+
+    # Determine if a filter is a pattern that must never be formatted since
+    # formatting it would destroy its matching behavior.
+    #
+    # @param filter [Object] The filter to check.
+    # @return [Boolean] True if the filter is a pattern object.
+    def pattern_filter?(filter)
+      filter.is_a?(Module) || filter.is_a?(Regexp) || filter.is_a?(Range) ||
+        filter.is_a?(Proc) || filter.is_a?(Hash) || filter.respond_to?(:matches?)
+    end
+
+    # Format an attribute filter value with the attribute formatter using its dot
+    # notation name so name based formatters apply. Results are memoized per name.
+    # The raw filter is returned if formatting fails or removes the attribute.
+    #
+    # @param path [String] The dot notation name of the attribute.
+    # @param filter [Object] The filter value to format.
+    # @return [Object] The formatted filter value.
+    def formatted_attribute_filter(path, filter)
+      return @formatted_attribute_filters[path] if @formatted_attribute_filters.include?(path)
+
+      attribute_formatter = @formatter.attribute_formatter
+      formatted = filter
+      if attribute_formatter.respond_to?(:format)
+        begin
+          result = attribute_formatter.format({path => filter})
+          formatted = result.fetch(path, filter) if result.is_a?(Hash)
+        rescue
+          formatted = filter
         end
       end
+      @formatted_attribute_filters[path] = formatted
     end
   end
 end

data/lib/lumberjack/logger.rb

@@ -69,11 +69,9 @@ module Lumberjack
     #   log files will be rolled when they get to the size specified in shift_size and the number of
     #   files to keep will be determined by this value. Otherwise it will be interpreted as a date
     #   rolling value and must be one of "daily", "weekly", or "monthly". This parameter has no
-    #   effect unless the device parameter is a file path or file stream. This can also be
-    #   specified with the :roll keyword argument.
+    #   effect unless the device parameter is a file path or file stream.
     # @param shift_size [Integer] The size in bytes of the log files before rolling them. This can
     #   be passed as a string with a unit suffix of K, M, or G (e.g. "10M" for 10 megabytes).
-    #   This can also be specified with the :max_size keyword argument.
     # @param level [Integer, Symbol, String] The logging level below which messages will be ignored.
     # @param progname [String] The name of the program that will be recorded with each log entry.
     # @param formatter [Lumberjack::EntryFormatter, Lumberjack::Formatter, ::Logger::Formatter, :default, #call]
@@ -95,16 +93,7 @@ module Lumberjack
       level: DEBUG, progname: nil, formatter: nil, datetime_format: nil,
       binmode: false, shift_period_suffix: "%Y%m%d", **kwargs)
       init_context_locals!
-
-      if shift_age.is_a?(Hash)
-        Lumberjack::Utils.deprecated("Logger.new(options)", "Passing a Hash as the second argument to Logger.new is deprecated and will be removed in version 2.1; use keyword arguments instead.")
-        options = shift_age
-        level = options[:level] if options.include?(:level)
-        progname = options[:progname] if options.include?(:progname)
-        formatter = options[:formatter] if options.include?(:formatter)
-        datetime_format = options[:datetime_format] if options.include?(:datetime_format)
-        kwargs = options.merge(kwargs)
-      end
+      @recursion_guard_key = :"lumberjack_logging_#{object_id}"
 
       self.isolation_level = kwargs.delete(:isolation_level) || Lumberjack.isolation_level
 
@@ -113,36 +102,13 @@ module Lumberjack
       device_options = kwargs.merge(shift_age: shift_age, shift_size: size_with_units(shift_size), binmode: binmode, shift_period_suffix: shift_period_suffix)
       device_options[:standard_logger_formatter] = formatter if standard_logger_formatter?(formatter)
 
-      if device_options.include?(:roll)
-        Utils.deprecated("Logger.options(:roll)", "Lumberjack::Logger :roll option is deprecated and will be removed in version 2.1; use the shift_age argument instead.")
-        device_options[:shift_age] = device_options.delete(:roll) unless shift_age != 0
-      end
-
-      if device_options.include?(:max_size)
-        Utils.deprecated("Logger.options(:max_size)", "Lumberjack::Logger :max_size option is deprecated and will be removed in version 2.1; use the shift_size argument instead.")
-        device_options[:shift_age] = 10 if shift_age == 0
-        device_options[:shift_size] = device_options.delete(:max_size)
-      end
-
-      message_formatter = nil
-      if device_options.include?(:message_formatter)
-        Utils.deprecated("Logger.options(:message_formatter)", "Lumberjack::Logger :message_formatter option is deprecated and will be removed in version 2.1; use the formatter argument instead to specify an EntryFormatter.")
-        message_formatter = device_options.delete(:message_formatter)
-      end
-
-      attribute_formatter = nil
-      if device_options.include?(:tag_formatter)
-        Utils.deprecated("Logger.options(:tag_formatter)", "Lumberjack::Logger :tag_formatter option is deprecated and will be removed in version 2.1; use the formatter argument instead to specify an EntryFormatter.")
-        attribute_formatter = device_options.delete(:tag_formatter)
-      end
-
       @logdev = Device.open_device(logdev, device_options)
 
       @context = Context.new
       self.level = level || DEBUG
       self.progname = progname
 
-      self.formatter = build_entry_formatter(formatter, message_formatter, attribute_formatter)
+      self.formatter = build_entry_formatter(formatter)
       self.datetime_format = datetime_format if datetime_format
 
       @closed = false
@@ -169,7 +135,7 @@ module Lumberjack
     # @param value [Lumberjack::EntryFormatter, ::Logger::Formatter, #call] The formatter to use.
     # @return [void]
     def formatter=(value)
-      @formatter = build_entry_formatter(value, nil, nil)
+      @formatter = build_entry_formatter(value)
     end
 
     # Get the timestamp format on the device if it has one.
@@ -219,20 +185,6 @@ module Lumberjack
       formatter.attribute_formatter = value
     end
 
-    # @deprecated Use {#attribute_formatter} instead.
-    def tag_formatter
-      Utils.deprecated("Logger#tag_formatter", "Lumberjack::Logger#tag_formatter is deprecated and will be removed in version 2.1; use attribute_formatter instead.") do
-        formatter.attributes.attribute_formatter
-      end
-    end
-
-    # @deprecated Use {#attribute_formatter=} instead.
-    def tag_formatter=(value)
-      Utils.deprecated("Logger#tag_formatter=", "Lumberjack::Logger#tag_formatter= is deprecated and will be removed in version 2.1; use attribute_formatter= instead.") do
-        formatter.attributes.attribute_formatter = value
-      end
-    end
-
     # Flush the logging device. Messages are not guaranteed to be written until this method is called.
     #
     # @return [void]
@@ -269,125 +221,6 @@ module Lumberjack
       self
     end
 
-    # Set the program name that is associated with log messages. If a block
-    # is given, the program name will be valid only within the block.
-    #
-    # @param value [String] The program name to use.
-    # @return [void]
-    # @deprecated Use with_progname or progname= instead.
-    def set_progname(value, &block)
-      Utils.deprecated("Logger#set_progname", "Lumberjack::Logger#set_progname is deprecated and will be removed in version 2.1; use with_progname or progname= instead.") do
-        if block
-          with_progname(value, &block)
-        else
-          self.progname = value
-        end
-      end
-    end
-
-    # Alias method for #attributes to provide backward compatibility with version 1.x API. This
-    # method will eventually be removed.
-    #
-    # @return [Hash]
-    # @deprecated Use {#attributes} instead
-    def tags
-      Utils.deprecated("Logger#tags", "Lumberjack::Logger#tags is deprecated and will be removed in version 2.1; use attributes instead.") do
-        attributes
-      end
-    end
-
-    # Alias method for #attribute_value to provide backward compatibility with version 1.x API. This
-    # method will eventually be removed.
-    #
-    # @return [Hash]
-    # @deprecated Use {#attribute_value} instead
-    def tag_value(name)
-      Utils.deprecated("Logger#tag_value", "Lumberjack::Logger#tag_value is deprecated and will be removed in version 2.1; use attribute_value instead.") do
-        attribute_value(name)
-      end
-    end
-
-    # Use tag! instead
-    #
-    # @return [void]
-    # @deprecated Use {#tag!} instead.
-    def tag_globally(tags)
-      Utils.deprecated("Logger#tag_globally", "Lumberjack::Logger#tag_globally is deprecated and will be removed in version 2.1; use tag! instead.") do
-        tag!(tags)
-      end
-    end
-
-    # Use context? instead
-    #
-    # @return [Boolean]
-    # @deprecated Use {#in_context?} instead.
-    def in_tag_context?
-      Utils.deprecated("Logger#in_tag_context?", "Lumberjack::Logger#in_tag_context? is deprecated and will be removed in version 2.1; use in_context? instead.") do
-        context?
-      end
-    end
-
-    # Remove a tag from the current context block. If this is called inside a context block,
-    # the attributes will only be removed for the duration of that block. Otherwise they will be removed
-    # from the global attributes.
-    #
-    # @param tag_names [Array<String, Symbol>] The attributes to remove.
-    # @return [void]
-    # @deprecated Use untag or untag! instead.
-    def remove_tag(*tag_names)
-      Utils.deprecated("Logger#remove_tag", "Lumberjack::Logger#remove_tag is deprecated and will be removed in version 2.1; use untag or untag! instead.") do
-        attributes = current_context&.attributes
-        AttributesHelper.new(attributes).delete(*tag_names) if attributes
-      end
-    end
-
-    # Alias for append_to(:tagged) for compatibility with ActiveSupport support in Lumberjack 1.x.
-    # This functionality has been moved to the lumberjack_rails gem. Note that in that gem the
-    # tags are added to the :tags attribute instead of the :tagged attribute.
-    #
-    # @see append_to
-    # @deprecated This implementation is deprecated. Install the lumberjack_rails gem for full support.
-    def tagged(*tags, &block)
-      deprecation_message = "Install the lumberjack_rails gem for full support of the tagged method."
-      Utils.deprecated("Logger#tagged", deprecation_message) do
-        append_to(:tagged, *tags, &block)
-      end
-    end
-
-    # Alias for clear_attributes.
-    #
-    # @see clear_attributes
-    # @deprecated Use clear_attributes instead.
-    def untagged(&block)
-      Utils.deprecated("Logger#untagged", "Lumberjack::Logger#untagged is deprecated and will be removed in version 2.1; use clear_attributes instead.") do
-        clear_attributes(&block)
-      end
-    end
-
-    # Alias for with_level for compatibility with ActiveSupport loggers. This functionality
-    # has been moved to the lumberjack_rails gem.
-    #
-    # @see with_level
-    # @deprecated This implementation is deprecated. Install the lumberjack_rails gem for full support.
-    def log_at(level, &block)
-      deprecation_message = "Install the lumberjack_rails gem for full support of the log_at method."
-      Utils.deprecated("Logger#log_at", deprecation_message) do
-        with_level(level, &block)
-      end
-    end
-
-    # Alias for with_level for compatibilty with ActiveSupport loggers. This functionality
-    # has been moved to the lumberjack_rails gem.
-    #
-    # @see with_level
-    # @deprecated This implementation is deprecated. Install the lumberjack_rails gem for full support.
-    def silence(level = Logger::ERROR, &block)
-      deprecation_message = "Install the lumberjack_rails gem for full support of the silence method."
-      Utils.deprecated("Logger#silence", deprecation_message) do
-        with_level(level, &block)
-      end
-    end
-
     # Add an entry to the log.
     #
     # @param severity [Integer, Symbol, String] The severity of the message.
@@ -400,25 +233,30 @@ module Lumberjack
       return false unless device
 
       # Prevent infinite recursion if logging is attempted from within a logging call.
-      if current_context_locals&.logging
+      # The guard is stored in fiber-local storage since recursion is a property of the
+      # current call stack, which belongs to exactly one fiber.
+      if Thread.current[@recursion_guard_key]
         log_to_stderr(severity, message)
         return false
       end
 
       severity = Severity.label_to_level(severity) unless severity.is_a?(Integer)
 
-      new_context_locals do |locals|
-        locals.logging = true # protection from infinite loops
+      begin
+        Thread.current[@recursion_guard_key] = true
 
+        locals = current_context_locals
         time = Time.now
-        progname ||= self.progname
+        progname ||= locals&.context&.progname || default_context&.progname
         attributes = nil unless attributes.is_a?(Hash)
-        attributes = merge_attributes(merge_all_attributes, attributes)
+        attributes = merge_all_attributes(locals, attributes)
         message, attributes = formatter.format(message, attributes) if formatter
 
         entry = Lumberjack::LogEntry.new(time, severity, message, progname, Process.pid, attributes)
 
         write_to_device(entry)
+      ensure
+        Thread.current[@recursion_guard_key] = nil
       end
 
       true
@@ -449,18 +287,14 @@ module Lumberjack
       raise e if Lumberjack.raise_logger_errors?
     end
 
-    def build_entry_formatter(formatter, message_formatter, attribute_formatter) # :nodoc:
-      entry_formatter = formatter if formatter.is_a?(Lumberjack::EntryFormatter)
-
-      unless entry_formatter
-        message_formatter ||= formatter if formatter.is_a?(Lumberjack::Formatter) || formatter == :default
-        entry_formatter = Lumberjack::EntryFormatter.new
-      end
+    def build_entry_formatter(formatter) # :nodoc:
+      return formatter if formatter.is_a?(Lumberjack::EntryFormatter)
 
-      message_formatter = Lumberjack::Formatter.default if message_formatter == :default
+      entry_formatter = Lumberjack::EntryFormatter.new
 
+      message_formatter = formatter if formatter.is_a?(Lumberjack::Formatter)
+      message_formatter = Lumberjack::Formatter.default if formatter == :default
       entry_formatter.message_formatter = message_formatter if message_formatter
-      entry_formatter.attribute_formatter = attribute_formatter if attribute_formatter
 
       entry_formatter
     end