lumberjack 2.0.5 → 2.1.0

data/lib/lumberjack/device/writer.rb

@@ -54,7 +54,11 @@ module Lumberjack
     # @option options [Boolean] :colorize (false) Whether to colorize log output
     def initialize(stream, options = {})
       @stream = stream
-      @stream.sync = true if @stream.respond_to?(:sync=) && options[:autoflush] != false
+      @autoflush = options[:autoflush] != false
+      # Only turn sync on; the stream may be shared with other code (i.e. $stdout), so
+      # disabling autoflush must not change how anything else writing to it behaves.
+      @stream.sync = true if @autoflush && @stream.respond_to?(:sync=)
+      @lock = Mutex.new
 
       @binmode = options[:binmode]
 
@@ -107,8 +111,10 @@ module Lumberjack
     #
     # @return [void]
     def close
+      # Call the public flush so that subclasses that override it still get a chance to
+      # drain whatever they buffer. It must be called outside the lock since it takes it.
       flush
-      stream.close
+      @lock.synchronize { stream.close }
     end
 
     # Flush the underlying stream to ensure all buffered data is written to the
@@ -117,7 +123,9 @@ module Lumberjack
     #
     # @return [void]
     def flush
-      stream.flush if stream.respond_to?(:flush)
+      @lock.synchronize do
+        stream.flush if stream.respond_to?(:flush)
+      end
     end
 
     # Get the current datetime format from the template if supported. Returns the
@@ -164,7 +172,20 @@ module Lumberjack
     # The underlying stream object that is being written to.
     #
     # @return [IO] The current stream object
-    attr_accessor :stream
+    attr_reader :stream
+
+    # Replace the underlying stream. The swap is synchronized against in-flight
+    # writes so a log line is never split across the old and new streams, and the
+    # autoflush setting is re-applied to the new stream.
+    #
+    # @param value [IO, #write] The new stream to write to
+    # @return [void]
+    def stream=(value)
+      @lock.synchronize do
+        value.sync = true if @autoflush && value.respond_to?(:sync=)
+        @stream = value
+      end
+    end
 
     private
 
@@ -177,16 +198,18 @@ module Lumberjack
     def write_to_stream(line)
       out = line.end_with?(Lumberjack::LINE_SEPARATOR) ? line : "#{line}#{Lumberjack::LINE_SEPARATOR}"
       begin
-        begin
-          stream.write(out)
-        rescue IOError => e
-          raise e if stream.closed?
-
-          stream.write(out)
+        @lock.synchronize do
+          target = stream
+          begin
+            target.write(out)
+          rescue IOError => e
+            raise e if target.closed?
+
+            target.write(out)
+          end
         end
       rescue => e
-        $stderr.write(error_message(e))
-        $stderr.write(out)
+        $stderr.write("#{error_message(e)}#{out}")
       end
     end
 

data/lib/lumberjack/device.rb

@@ -32,8 +32,6 @@ module Lumberjack
     require_relative "device/null"
     require_relative "device/test"
     require_relative "device/buffer"
-    require_relative "device/size_rolling_log_file"
-    require_relative "device/date_rolling_log_file"
 
     class << self
       # Open a logging device with the given options.

data/lib/lumberjack/device_registry.rb

@@ -17,6 +17,7 @@ module Lumberjack
   #   logger = Lumberjack::Logger.new(:my_device)
   module DeviceRegistry
     @registry = {stdout: :stdout, stderr: :stderr}
+    @lock = Mutex.new
 
     class << self
       # Register a device name. Device names can be used to associate a symbol with a device
@@ -31,7 +32,7 @@ module Lumberjack
       def add(name, klass)
         raise ArgumentError.new("name must be a symbol") unless name.is_a?(Symbol)
 
-        @registry[name] = klass
+        @lock.synchronize { @registry[name] = klass }
       end
 
       # Remove a device from the registry.
@@ -39,7 +40,7 @@ module Lumberjack
       # @param name [Symbol] The name of the device to remove
       # @return [void]
       def remove(name)
-        @registry.delete(name)
+        @lock.synchronize { @registry.delete(name) }
       end
 
       # Check if a device is registered.
@@ -47,7 +48,7 @@ module Lumberjack
       # @param name [Symbol] The name of the device
       # @return [Boolean] True if the device is registered, false otherwise
       def registered?(name)
-        @registry.include?(name)
+        @lock.synchronize { @registry.include?(name) }
       end
 
       # Instantiate a new device with the specified options from the device registry.
@@ -58,7 +59,7 @@ module Lumberjack
       def new_device(name, options)
         klass = device_class(name)
         unless klass
-          valid_names = @registry.keys.map(&:inspect).join(", ")
+          valid_names = registered_devices.keys.map(&:inspect).join(", ")
           raise ArgumentError.new("#{name.inspect} is not registered as a device name; valid names are: #{valid_names}")
         end
 
@@ -76,14 +77,14 @@ module Lumberjack
       # @param name [Symbol] The name of the device
       # @return [Class, nil] The registered device class or nil if not found
       def device_class(name)
-        @registry[name]
+        @lock.synchronize { @registry[name] }
       end
 
       # Return the map of registered device class names.
       #
       # @return [Hash]
       def registered_devices
-        @registry.dup
+        @lock.synchronize { @registry.dup }
       end
     end
   end

data/lib/lumberjack/entry_formatter.rb

@@ -293,8 +293,10 @@ module Lumberjack
       message_attributes = Utils.flatten_attributes(message_attributes) if message_attributes
 
       attributes = merge_attributes(attributes, message_attributes) if message_attributes
-      attributes = AttributesHelper.expand_runtime_values(attributes)
-      attributes = attribute_formatter.format(attributes) if attributes && attribute_formatter
+      if attributes
+        attributes = AttributesHelper.expand_runtime_values(attributes)
+        attributes = attribute_formatter.format(attributes) if attribute_formatter
+      end
 
       [message, attributes]
     end

data/lib/lumberjack/formatter/structured_formatter.rb

@@ -16,7 +16,7 @@ module Lumberjack
 
       # Exception raised when a circular reference is detected during traversal.
       # This prevents infinite recursion when formatting objects that reference themselves.
-      class RecusiveReferenceError < StandardError
+      class RecursiveReferenceError < StandardError
       end
 
       # @param formatter [Formatter, nil] The formatter to call on each element
@@ -42,7 +42,7 @@ module Lumberjack
             hash = {}
             obj.each do |name, value|
               value = call_with_references(value, references)
-              hash[name.to_s] = value unless value.is_a?(RecusiveReferenceError)
+              hash[name.to_s] = value unless value.is_a?(RecursiveReferenceError)
             end
             hash
           end
@@ -51,7 +51,7 @@ module Lumberjack
             array = []
             obj.each do |value|
               value = call_with_references(value, references)
-              array << value unless value.is_a?(RecusiveReferenceError)
+              array << value unless value.is_a?(RecursiveReferenceError)
             end
             array
           end
@@ -64,7 +64,7 @@ module Lumberjack
 
       def with_object_reference(obj, references)
         if obj.is_a?(Enumerable)
-          return RecusiveReferenceError.new if references.include?(obj.object_id)
+          return RecursiveReferenceError.new if references.include?(obj.object_id)
 
           references << obj.object_id
           begin

data/lib/lumberjack/formatter/tags_formatter.rb

@@ -13,7 +13,7 @@ module Lumberjack
     def call(tags)
       tags = tags.collect { |key, value| "#{key}=#{value}" } if tags.is_a?(Hash)
       if tags.is_a?(Array)
-        tags.collect { |tag| format_tag(tag) }.join(" ") unless tags.empty?
+        tags.collect { |tag| format_tag(tag) }.join(" ")
       else
         format_tag(tags)
       end
@@ -23,9 +23,9 @@ module Lumberjack
 
     def format_tag(tag)
       if tag.is_a?(Hash)
-        tag.collect { |key, value| "[#{key}=#{value.strip}]" }.join(" ")
+        tag.collect { |key, value| "[#{key}=#{value.to_s.strip}]" }.join(" ")
       else
-        "[#{tag.strip}]"
+        "[#{tag.to_s.strip}]"
       end
     end
   end

data/lib/lumberjack/formatter.rb

@@ -46,7 +46,6 @@ module Lumberjack
     require_relative "formatter/structured_formatter"
     require_relative "formatter/tags_formatter"
     require_relative "formatter/truncate_formatter"
-    require_relative "formatter/tagged_message"
 
     class << self
       # Build a new formatter using a configuration block. The block receives the new formatter
@@ -67,16 +66,6 @@ module Lumberjack
         formatter
       end
 
-      # Create a new empty formatter with no mappings. This is an alias for #new.
-      #
-      # @return [Lumberjack::Formatter] A new formatter with no default mappings.
-      # @deprecated Use #new instead.
-      def empty
-        Utils.deprecated("Formatter.empty", "Lumberjack::Formatter.empty is deprecated and will be removed in version 2.1; use new instead.") do
-          new
-        end
-      end
-
       # Create a new formatter with default mappings.
       #
       #   Object: inspect formatter

data/lib/lumberjack/formatter_registry.rb

@@ -18,6 +18,7 @@ module Lumberjack
   #   end
   module FormatterRegistry
     @registry = {}
+    @lock = Mutex.new
 
     class << self
       # Register a formatter name. Formatter names can be used to associate a symbol with a formatter
@@ -37,7 +38,7 @@ module Lumberjack
         formatter ||= block
         raise ArgumentError.new("formatter must be a class or respond to call") unless formatter.is_a?(Class) || formatter.respond_to?(:call)
 
-        @registry[name] = formatter
+        @lock.synchronize { @registry[name] = formatter }
       end
 
       # Remove a formatter from the registry.
@@ -45,7 +46,7 @@ module Lumberjack
       # @param name [Symbol] The name of the formatter to remove
       # @return [void]
       def remove(name)
-        @registry.delete(name)
+        @lock.synchronize { @registry.delete(name) }
       end
 
       # Check if a formatter is registered.
@@ -53,7 +54,7 @@ module Lumberjack
       # @param name [Symbol] The name of the formatter
       # @return [Boolean] True if the formatter is registered, false otherwise
       def registered?(name)
-        @registry.include?(name)
+        @lock.synchronize { @registry.include?(name) }
       end
 
       # Retrieve the formatter registered with the given name or nil if the name is not defined.
@@ -61,10 +62,10 @@ module Lumberjack
       # @param name [Symbol] The name of the formatter
       # @return [#call, nil] The registered formatter class or nil if not found
       def formatter(name, *args)
-        instance = @registry[name]
+        instance = @lock.synchronize { @registry[name] }
 
         if instance.nil?
-          valid_names = @registry.keys.map(&:inspect).join(", ")
+          valid_names = registered_formatters.keys.map(&:inspect).join(", ")
           raise ArgumentError.new("#{name.inspect} is not registered as a formatter name; valid names are: #{valid_names}")
         end
 
@@ -77,7 +78,7 @@ module Lumberjack
       #
       # @return [Hash]
       def registered_formatters
-        @registry.dup
+        @lock.synchronize { @registry.dup }
       end
     end
   end

data/lib/lumberjack/log_entry.rb

@@ -94,17 +94,6 @@ module Lumberjack
         attributes == other.attributes
     end
 
-    # Alias for tags to provide backward compatibility with version 1.x API. This method
-    # will eventually be removed.
-    #
-    # @return [Hash, nil] The attributes of the log entry.
-    # @deprecated Use {#attributes} instead.
-    def tags
-      Utils.deprecated("LogEntry#tags", "Lumberjack::LogEntry#tags is deprecated and will be removed in version 2.1; use attributes instead.") do
-        attributes
-      end
-    end
-
     # Access an attribute value by name. Supports both simple and nested attribute
     # access using dot notation for hierarchical data structures.
     #
@@ -116,17 +105,6 @@ module Lumberjack
       AttributesHelper.new(attributes)[name]
     end
 
-    # Alias method for #[] to provide backward compatibility with version 1.x API. This
-    # method will eventually be removed.
-    #
-    # @return [Hash]
-    # @deprecated Use {#[]} instead.
-    def tag(name)
-      Utils.deprecated("LogEntry#tag", "Lumberjack::LogEntry#tag is deprecated and will be removed in version 2.1; use [] instead.") do
-        self[name]
-      end
-    end
-
     # Expand flat attributes with dot notation into a nested hash structure.
     # Attributes containing dots in their names are converted into hierarchical
     # nested hashes for structured data representation.
@@ -136,17 +114,6 @@ module Lumberjack
       Utils.expand_attributes(attributes)
     end
 
-    # Alias for nested_attributes to provide API compatibility with version 1.x.
-    # This method will eventually be removed.
-    #
-    # @return [Hash]
-    # @deprecated Use {#nested_attributes} instead.
-    def nested_tags
-      Utils.deprecated("LogEntry#nested_tags", "Lumberjack::LogEntry#nested_tags is deprecated and will be removed in version 2.1; use nested_attributes instead.") do
-        nested_attributes
-      end
-    end
-
     # Determine if the log entry contains no meaningful content. An entry is
     # considered empty if it has no message content and no attributes.
     #
@@ -183,30 +150,30 @@ module Lumberjack
       attributes_string
     end
 
-    # Flatten nested attributes and remove empty values.
+    # Flatten nested attributes and remove empty values. The returned hash is always
+    # a new copy so that the entry does not alias a hash owned by the caller (such as
+    # a live logger context hash that could be mutated after the entry is created).
     #
     # @param attributes [Hash] The attributes hash to compact
     # @return [Hash] The flattened attributes with empty values removed
     def flatten_attributes(attributes)
-      unless attributes.all? { |key, value| key.is_a?(String) && !value.is_a?(Hash) }
-        attributes = Utils.flatten_attributes(attributes)
-      end
-
+      needs_flattening = false
       delete_keys = nil
       attributes.each do |key, value|
-        if value.nil? || value == ""
-          delete_keys ||= []
-          delete_keys << key
-        elsif value.is_a?(Array) && value.empty?
+        needs_flattening = true if !key.is_a?(String) || value.is_a?(Hash)
+        if value.nil? || value == "" || (value.is_a?(Array) && value.empty?)
           delete_keys ||= []
           delete_keys << key
         end
       end
 
-      return attributes if delete_keys.nil?
-
-      attributes = attributes.dup
-      delete_keys&.each { |key| attributes.delete(key) }
+      if needs_flattening
+        attributes = Utils.flatten_attributes(attributes)
+        attributes.delete_if { |_key, value| value.nil? || value == "" || (value.is_a?(Array) && value.empty?) }
+      else
+        attributes = attributes.dup
+        delete_keys&.each { |key| attributes.delete(key) }
+      end
 
       attributes
     end

data/lib/lumberjack/log_entry_matcher/indifferent_hash.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# A minimal hash implementation that allows values to be looked up with either
+# string or symbol keys.
+#
+# The keys stored in the hash are left exactly as they are; only lookups are
+# indifferent. Log entry attributes are matched with string keys, but matchers
+# that do their own key lookups on the attributes hash (i.e. RSpec's
+# `hash_including`) have no way of knowing that. Wrapping the attributes in this
+# class lets those matchers use either form.
+#
+# @api private
+class Lumberjack::LogEntryMatcher::IndifferentHash < Hash
+  class << self
+    # Recursively wrap a value so that any hashes in it, including hashes nested
+    # inside arrays, allow indifferent key lookups. Values that are not hashes or
+    # arrays are returned as is.
+    #
+    # @param value [Object] The value to wrap.
+    # @return [Object] The wrapped value.
+    def wrap(value)
+      case value
+      when self
+        value
+      when Hash
+        value.each_with_object(new) { |(key, val), hash| hash[key] = wrap(val) }
+      when Array
+        value.collect { |val| wrap(val) }
+      else
+        value
+      end
+    end
+  end
+
+  # Capture the unaliased implementation so the overrides below can check for a
+  # key without recursing back into themselves.
+  alias_method :stored_key?, :key?
+  private :stored_key?
+
+  def [](key)
+    super(resolve_key(key))
+  end
+
+  def fetch(key, *args, &block)
+    super(resolve_key(key), *args, &block)
+  end
+
+  def dig(key, *rest)
+    super(resolve_key(key), *rest)
+  end
+
+  def values_at(*keys)
+    super(*keys.collect { |key| resolve_key(key) })
+  end
+
+  def key?(key)
+    stored_key?(resolve_key(key))
+  end
+
+  alias_method :has_key?, :key?
+  alias_method :include?, :key?
+  alias_method :member?, :key?
+
+  private
+
+  # Return the key as it is stored in the hash. If the key is not present in
+  # either its string or symbol form, then the key itself is returned so that
+  # normal missing key semantics apply.
+  #
+  # @param key [Object] The key being looked up.
+  # @return [Object] The key to use for the lookup.
+  def resolve_key(key)
+    return key if stored_key?(key)
+
+    alternate = if key.is_a?(String)
+      key.to_sym
+    elsif key.is_a?(Symbol)
+      key.to_s
+    end
+
+    (alternate && stored_key?(alternate)) ? alternate : key
+  end
+end

data/lib/lumberjack/log_entry_matcher/score.rb

@@ -47,9 +47,15 @@ class Lumberjack::LogEntryMatcher::Score
       end
 
       # Check attributes match
-      if attributes.is_a?(Hash) && !attributes.empty?
-        attributes_score = calculate_attributes_score(entry.attributes, attributes)
-        scores << attributes_score
+      if attributes.is_a?(Hash)
+        unless attributes.empty?
+          scores << calculate_attributes_score(entry.attributes, attributes)
+          weights << 0.3
+        end
+      elsif attributes
+        # Matchers like RSpec's hash_including are applied to the attributes hash as a whole.
+        entry_attributes = Lumberjack::LogEntryMatcher::IndifferentHash.wrap(Lumberjack::Utils.expand_attributes(entry.attributes))
+        scores << calculate_field_score(entry_attributes, attributes)
         weights << 0.3
       end
 
@@ -132,7 +138,9 @@ class Lumberjack::LogEntryMatcher::Score
       return 0.0 unless entry_attributes && attributes_filter.is_a?(Hash)
 
       attributes_filter = deep_stringify_keys(Lumberjack::Utils.expand_attributes(attributes_filter))
-      attributes = deep_stringify_keys(Lumberjack::Utils.expand_attributes(entry_attributes))
+      attributes = Lumberjack::LogEntryMatcher::IndifferentHash.wrap(
+        deep_stringify_keys(Lumberjack::Utils.expand_attributes(entry_attributes))
+      )
 
       total_attribute_filters = count_attribute_filters(attributes_filter)
       return 0.0 if total_attribute_filters == 0