lumberjack 1.4.2 → 2.0.0

data/lib/lumberjack/utils.rb

@@ -3,6 +3,11 @@
 require "socket"
 
 module Lumberjack
+  # Error raised when a deprecated method is called and the deprecation mode is set to :raise.
+  class DeprecationError < StandardError
+  end
+
+  # Utils provides utility methods and helper functions used throughout the Lumberjack logging framework.
   module Utils
     UNDEFINED = Object.new.freeze
     private_constant :UNDEFINED
@@ -16,36 +21,73 @@ module Lumberjack
 
     class << self
       # Print warning when deprecated methods are called the first time. This can be disabled
-      # by setting the environment variable `LUMBERJACK_NO_DEPRECATION_WARNINGS` to "true".
-      # You can see every usage of a deprecated method along with a full stack trace by setting
-      # the environment variable `VERBOSE_LUMBERJACK_DEPRECATION_WARNING` to "true".
+      # by setting +Lumberjack.deprecation_mode+ to +:silent+.
+      #
+      # In order to cut down on noise, each deprecated method will only print a warning once per process.
+      # You can change this by setting +Lumberjack.deprecation_mode+ to +:verbose+.
+      #
+      # @param method [String, Symbol] The name of the deprecated method.
+      # @param message [String] The deprecation message explaining what to use instead.
+      # @yield The block containing the deprecated functionality to execute.
+      # @return [Object] The result of the yielded block.
       #
-      # @param method [String] The name of the deprecated method.
-      # @param message [String] Optional message to include in the warning.
-      # @yield The block to execute after the warning.
+      # @example
+      #   def old_method
+      #     Utils.deprecated(:old_method, "Use new_method instead.") do
+      #       # deprecated implementation
+      #     end
+      #   end
       def deprecated(method, message)
-        @deprecations_lock ||= Mutex.new
-        unless @deprecations&.include?(method)
+        if Lumberjack.deprecation_mode != :silent && !@deprecations&.include?(method)
+          @deprecations_lock ||= Mutex.new
           @deprecations_lock.synchronize do
             @deprecations ||= {}
             unless @deprecations.include?(method)
-              trace = caller[3..-1]
-              unless ENV["VERBOSE_LUMBERJACK_DEPRECATION_WARNING"] == "true"
-                trace = [trace.first]
+              trace = ($VERBOSE && Lumberjack.deprecation_mode != :raise) ? caller[3..] : caller[3, 1]
+              if trace.first.start_with?(__dir__) && !$VERBOSE
+                non_lumberjack_caller = caller[4..].detect { |line| !line.start_with?(__dir__) }
+                trace = [non_lumberjack_caller] if non_lumberjack_caller
+              end
+              message = "DEPRECATION WARNING: #{message} Called from #{trace.join(Lumberjack::LINE_SEPARATOR)}"
+
+              if Lumberjack.deprecation_mode == :raise
+                raise DeprecationError, message
+              end
+
+              unless Lumberjack.deprecation_mode == :verbose
                 @deprecations[method] = true
               end
-              message = "DEPRECATION WARNING: #{message} Called from #{trace.join("\n")}"
-              warn(message) unless ENV["LUMBERJACK_NO_DEPRECATION_WARNINGS"] == "true"
+
+              warn(message)
             end
           end
         end
 
-        yield
+        yield if block_given?
+      end
+
+      # Helper method for tests to silence deprecation warnings within a block. You should
+      # not use this in production code since it will silence all deprecation warnings
+      # globally across all threads.
+      #
+      # @param mode [Symbol, String] The deprecation mode to set within the block. Valid values are
+      #   :normal, :verbose, :silent, and :raise.
+      # @yield The block in which to silence deprecation warnings.
+      # @return [Object] The result of the yielded block.
+      def with_deprecation_mode(mode)
+        save_mode = Lumberjack.deprecation_mode
+        begin
+          Lumberjack.deprecation_mode = mode
+          yield
+        ensure
+          Lumberjack.deprecation_mode = save_mode
+        end
       end
 
       # Get the hostname of the machine. The returned value will be in UTF-8 encoding.
+      # The hostname is cached after the first call for performance.
       #
-      # @return [String] The hostname of the machine.
+      # @return [String] The hostname of the machine in UTF-8 encoding.
       def hostname
         if @hostname.equal?(UNDEFINED)
           @hostname = force_utf8(Socket.gethostname)
@@ -53,83 +95,179 @@ module Lumberjack
         @hostname
       end
 
-      # Set the hostname to a specific value. If this is not specified, it will use the system hostname.
+      # Get the current line of code that calls this method. This is useful for debugging
+      # purposes to record the exact location in your code that generated a log entry.
+      #
+      # @param root_path [String, Pathname, nil] An optional root path to strip from the file path.
+      # @return [String] A string representation of the caller location (file:line:method).
+      #
+      # @example Adding source location to log entries
+      #   logger.info("Something happened", source: Lumberjack::Utils.current_line)
+      #   # Logs: "Something happened" with source: "/path/to/file.rb:123:in `method_name'"
+      def current_line(root_path = nil)
+        location = caller_locations(1, 1)[0]
+        path = location.path
+        if root_path
+          root_path = root_path.to_s
+          root_path = "#{root_path}#{File::SEPARATOR}" unless root_path.end_with?(File::SEPARATOR)
+          path = path.delete_prefix(root_path)
+        end
+        "#{path}:#{location.lineno}:in `#{location.label}'"
+      end
+
+      # Set the hostname to a specific value. This overrides the system hostname.
+      # Useful for testing or when you want to use a specific identifier.
       #
-      # @param hostname [String]
+      # @param hostname [String] The hostname to use.
       # @return [void]
       def hostname=(hostname)
         @hostname = force_utf8(hostname)
       end
 
-      # Generate a global process ID that includes the hostname and process ID.
+      # Generate a global process identifier that includes the hostname and process ID.
+      # This creates a unique identifier that can distinguish processes across different machines.
       #
-      # @return [String] The global process ID.
-      def global_pid
+      # @return [String] The global process ID in the format "hostname-pid".
+      #
+      # @example
+      #   Lumberjack::Utils.global_pid
+      #   # => "server1-12345"
+      def global_pid(pid = Process.pid)
         if hostname
-          "#{hostname}-#{Process.pid}"
+          "#{hostname}-#{pid}"
         else
-          Process.pid.to_s
+          pid.to_s
         end
       end
 
-      # Generate a global thread ID that includes the global process ID and the thread name.
+      # Generate a global thread identifier that includes the global process ID and thread name.
+      # This creates a unique identifier for threads across processes and machines.
+      #
+      # @return [String] The global thread ID in the format "hostname-pid-threadname".
       #
-      # @return [String] The global thread ID.
+      # @example
+      #   Lumberjack::Utils.global_thread_id
+      #   # => "server1-12345-main" or "server1-12345-worker-1"
       def global_thread_id
         "#{global_pid}-#{thread_name}"
       end
 
-      # Get the name of a thread. The value will be based on the thread's name if it exists.
-      # Otherwise a unique id is generated based on the thread's object id. Only alphanumeric
-      # characters, underscores, dashes, and periods are kept in thread name.
+      # Get a safe name for a thread. Uses the thread's assigned name if available,
+      # otherwise generates a unique identifier based on the thread's object ID.
+      # Non-alphanumeric characters (except underscores, dashes, and periods) are replaced
+      # with dashes to create URL-safe identifiers.
       #
       # @param thread [Thread] The thread to get the name for. Defaults to the current thread.
-      # @return [String] The name of the thread.
+      # @return [String] A safe string identifier for the thread.
+      #
+      # @example
+      #   Thread.current.name = "worker-thread"
+      #   Lumberjack::Utils.thread_name  # => "worker-thread"
+      #
+      #   # For unnamed threads
+      #   Lumberjack::Utils.thread_name  # => "2c001a80c" (based on object_id)
       def thread_name(thread = Thread.current)
         thread.name ? slugify(thread.name) : thread.object_id.to_s(36)
       end
 
-      # Force encode a string to UTF-8. Any invalid byte sequences will be
-      # ignored and replaced with an empty string.
+      # Force encode a string to UTF-8, handling invalid byte sequences gracefully.
+      # Any invalid or undefined byte sequences will be replaced with an empty string,
+      # ensuring the result is always valid UTF-8.
+      #
+      # @param str [String, nil] The string to encode. Returns nil if input is nil.
+      # @return [String, nil] The UTF-8 encoded string, or nil if input was nil.
       #
-      # @param str [String] The string to encode.
-      # @return [String] The UTF-8 encoded string.
+      # @example
+      #   # Handles strings with invalid encoding
+      #   bad_string = "Hello\xff\xfeWorld".force_encoding("ASCII-8BIT")
+      #   Lumberjack::Utils.force_utf8(bad_string)  # => "HelloWorld"
       def force_utf8(str)
         return nil if str.nil?
 
         str.dup.force_encoding("ASCII-8BIT").encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
       end
 
-      # Flatten a tag hash to a single level hash with dot notation for nested keys.
+      # Flatten a nested attribute hash into a single-level hash using dot notation for nested keys.
+      # This is useful for converting structured data into a flat format suitable for logging systems
+      # that don't support nested structures.
+      #
+      # @param attr_hash [Hash] The hash to flatten. Non-hash values are ignored.
+      # @return [Hash<String, Object>] A flattened hash with dot-notation keys.
+      #
+      # @example Basic flattening
+      #   hash = {user: {id: 123, profile: {name: "Alice"}}, action: "login"}
+      #   Lumberjack::Utils.flatten_attributes(hash)
+      #   # => {"user.id" => 123, "user.profile.name" => "Alice", "action" => "login"}
+      #
+      # @example With mixed types
+      #   hash = {config: {db: {host: "localhost", port: 5432}}, debug: true}
+      #   Lumberjack::Utils.flatten_attributes(hash)
+      #   # => {"config.db.host" => "localhost", "config.db.port" => 5432, "debug" => true}
+      def flatten_attributes(attr_hash)
+        return {} unless attr_hash.is_a?(Hash)
+
+        flatten_hash_recursive(attr_hash)
+      end
+
+      # Alias for {.flatten_attributes} to provide compatibility with the 1.x API.
+      # This method will eventually be removed in a future version.
       #
       # @param tag_hash [Hash] The hash to flatten.
       # @return [Hash<String, Object>] The flattened hash.
-      # @example
-      #   expand_tags(user: {id: 123, name: "Alice"}, action: "login")})
-      #   # => {"user.id" => 123, "user.name" => "Alice", "action" => "login"}
+      # @deprecated Use {.flatten_attributes} instead.
       def flatten_tags(tag_hash)
-        return {} unless tag_hash.is_a?(Hash)
-
-        flatten_hash_recursive(tag_hash)
+        Utils.deprecated("Lumberjack::Utils.flatten_tags", "Lumberjack::Utils.flatten_tags is deprecated and will be removed in version 2.1; use flatten_attributes instead.") do
+          flatten_attributes(tag_hash)
+        end
       end
 
-      # Expand a hash of tags that may contain nested hashes or dot notation keys. Dot notation tags
-      # will be expanded into nested hashes.
+      # Expand a hash containing dot notation keys into a nested hash structure.
+      # This is the inverse operation of {.flatten_attributes} and is useful for converting
+      # flat attribute structures back into nested hashes.
       #
-      # @param tags [Hash] The hash of tags to expand.
-      # @return [Hash] The expanded hash with dot notation keys.
+      # @param attributes [Hash] The hash with dot notation keys to expand. Non-hash values are ignored.
+      # @return [Hash] A nested hash with dot notation keys expanded into nested structures.
       #
-      # @example
-      #   expand_tags({"user.id" => 123, "user.name" => "Alice", "action" => "login"})
+      # @example Basic expansion
+      #   flat = {"user.id" => 123, "user.name" => "Alice", "action" => "login"}
+      #   Lumberjack::Utils.expand_attributes(flat)
       #   # => {"user" => {"id" => 123, "name" => "Alice"}, "action" => "login"}
-      def expand_tags(tags)
-        return {} unless tags.is_a?(Hash)
+      #
+      # @example Deep nesting
+      #   flat = {"app.db.host" => "localhost", "app.db.port" => 5432, "app.debug" => true}
+      #   Lumberjack::Utils.expand_attributes(flat)
+      #   # => {"app" => {"db" => {"host" => "localhost", "port" => 5432}, "debug" => true}}
+      #
+      # @example Mixed with existing nested structures
+      #   mixed = {"user.id" => 123, "settings" => {"theme" => "dark"}}
+      #   Lumberjack::Utils.expand_attributes(mixed)
+      #   # => {"user" => {"id" => 123}, "settings" => {"theme" => "dark"}}
+      def expand_attributes(attributes)
+        return {} unless attributes.is_a?(Hash)
 
-        expand_dot_notation_hash(tags)
+        expand_dot_notation_hash(attributes)
+      end
+
+      # Alias for {.expand_attributes} to provide compatibility with the 1.x API.
+      # This method will eventually be removed in a future version.
+      #
+      # @param tags [Hash] The hash to expand.
+      # @return [Hash] The expanded hash.
+      # @deprecated Use {.expand_attributes} instead.
+      def expand_tags(tags)
+        Utils.deprecated("Lumberjack::Utils.expand_tags", "Lumberjack::Utils.expand_tags is deprecated and will be removed in version 2.1; use expand_attributes instead.") do
+          expand_attributes(tags)
+        end
       end
 
       private
 
+      # Recursively flatten a hash, building dot notation keys for nested structures.
+      #
+      # @param hash [Hash] The hash to flatten.
+      # @param prefix [String, nil] The current key prefix for nested structures.
+      # @return [Hash<String, Object>] The flattened hash.
+      # @api private
       def flatten_hash_recursive(hash, prefix = nil)
         hash.each_with_object({}) do |(key, value), result|
           full_key = prefix ? "#{prefix}.#{key}" : key.to_s
@@ -141,6 +279,12 @@ module Lumberjack
         end
       end
 
+      # Convert a string to a URL-safe slug by replacing non-alphanumeric characters
+      # (except underscores, dashes, and periods) with dashes, and removing leading/trailing dashes.
+      #
+      # @param str [String, nil] The string to slugify.
+      # @return [String, nil] The slugified string, or nil if input was nil.
+      # @api private
       def slugify(str)
         return nil if str.nil?
 
@@ -150,6 +294,12 @@ module Lumberjack
         str
       end
 
+      # Recursively expand dot notation keys in a hash into nested structures.
+      #
+      # @param hash [Hash] The hash containing dot notation keys to expand.
+      # @param expanded [Hash] The target hash to store expanded results.
+      # @return [Hash] The expanded hash with nested structures.
+      # @api private
       def expand_dot_notation_hash(hash, expanded = {})
         return hash unless hash.is_a?(Hash)
 

data/lib/lumberjack.rb

@@ -2,117 +2,225 @@
 
 require "rbconfig"
 require "time"
-require "securerandom"
 require "logger"
 require "fiber"
+require "pathname"
 
+# Lumberjack is a flexible logging framework for Ruby that extends the standard
+# Logger functionality with structured logging, context isolation, and advanced
+# formatting capabilities.
+#
+# The main features include:
+# - Structured logging with attributes for machine-readable metadata
+# - Context isolation for scoping logging behavior to specific code blocks
+# - Flexible formatters for customizing log output
+# - Multiple output devices and templates
+# - Built-in testing utilities
+#
+# @example Basic usage
+#   logger = Lumberjack::Logger.new(STDOUT)
+#   logger.info("Hello world")
+#
+# @example Using contexts
+#   Lumberjack.context do
+#     Lumberjack.tag(user_id: 123)
+#     logger.info("User action") # Will include user_id: 123
+#   end
+#
+# @see Lumberjack::Logger
+# @see Lumberjack::ContextLogger
 module Lumberjack
+  VERSION = File.read(File.join(__dir__, "..", "VERSION")).strip.freeze
+
   LINE_SEPARATOR = ((RbConfig::CONFIG["host_os"] =~ /mswin/i) ? "\r\n" : "\n")
 
-  require_relative "lumberjack/severity"
-  require_relative "lumberjack/formatter"
+  require_relative "lumberjack/device_registry"
+  require_relative "lumberjack/template_registry"
+  require_relative "lumberjack/formatter_registry"
 
+  require_relative "lumberjack/attribute_formatter"
+  require_relative "lumberjack/attributes_helper"
   require_relative "lumberjack/context"
+  require_relative "lumberjack/context_logger"
+  require_relative "lumberjack/fiber_locals"
+  require_relative "lumberjack/io_compatibility"
   require_relative "lumberjack/log_entry"
+  require_relative "lumberjack/log_entry_matcher"
   require_relative "lumberjack/device"
+  require_relative "lumberjack/entry_formatter"
+  require_relative "lumberjack/formatter"
+  require_relative "lumberjack/forked_logger"
   require_relative "lumberjack/logger"
-  require_relative "lumberjack/tags"
-  require_relative "lumberjack/tag_context"
-  require_relative "lumberjack/tag_formatter"
-  require_relative "lumberjack/tagged_logger_support"
-  require_relative "lumberjack/tagged_logging"
-  require_relative "lumberjack/template"
+  require_relative "lumberjack/local_log_template"
+  require_relative "lumberjack/message_attributes"
+  require_relative "lumberjack/remap_attribute"
   require_relative "lumberjack/rack"
+  require_relative "lumberjack/severity"
+  require_relative "lumberjack/template"
   require_relative "lumberjack/utils"
 
-  class << self
-    # Define a unit of work within a block. Within the block supplied to this
-    # method, calling +unit_of_work_id+ will return the same value that can
-    # This can then be used for tying together log entries.
-    #
-    # You can specify the id for the unit of work if desired. If you don't supply
-    # it, a 12 digit hexidecimal number will be automatically generated for you.
-    #
-    # For the common use case of treating a single web request as a unit of work, see the
-    # Lumberjack::Rack::UnitOfWork class.
-    #
-    # @param id [String] The id for the unit of work.
-    # @return [void]
-    # @deprecated Use tags instead. This will be removed in version 2.0.
-    def unit_of_work(id = nil)
-      Lumberjack::Utils.deprecated("Lumberjack.unit_of_work", "Lumberjack.unit_of_work will be removed in version 2.0. Use Lumberjack::Logger#tag(unit_of_work: id) instead.") do
-        id ||= SecureRandom.hex(6)
-        context do
-          context[:unit_of_work_id] = id
-          yield
-        end
-      end
-    end
+  # Deprecated
+  require_relative "lumberjack/tag_context"
+  require_relative "lumberjack/tag_formatter"
+  require_relative "lumberjack/tags"
 
-    # Get the UniqueIdentifier for the current unit of work.
-    #
-    # @return [String, nil] The id for the current unit of work.
-    # @deprecated Use tags instead. This will be removed in version 2.0.
-    def unit_of_work_id
-      context[:unit_of_work_id]
-    end
+  @global_contexts = {}
+  @global_contexts_mutex = Mutex.new
+  @deprecation_mode = nil
+  @raise_logger_errors = false
 
-    # Contexts can be used to store tags that will be attached to all log entries in the block.
+  class << self
+    # Contexts can be used to store attributes that will be attached to all log entries in the block.
     # The context will apply to all Lumberjack loggers that are used within the block.
     #
     # If this method is called with a block, it will set a logging context for the scope of a block.
     # If there is already a context in scope, a new one will be created that inherits
-    # all the tags of the parent context.
+    # all the attributes of the parent context.
     #
     # Otherwise, it will return the current context. If one doesn't exist, it will return a new one
     # but that context will not be in any scope.
     #
-    # @return [Lumberjack::Context] The current context if called without a block.
+    # @return [Object] The result
+    #   of the block
     def context(&block)
-      current_context = Thread.current[:lumberjack_context]
-      if block
-        use_context(Context.new(current_context), &block)
+      use_context(Context.new(current_context), &block)
+    end
+
+    # Ensure that the block of code is wrapped by a global context. If there is not already
+    # a context in scope, one will be created.
+    #
+    # @return [Object] The result of the block.
+    def ensure_context(&block)
+      if in_context?
+        yield
       else
-        current_context || Context.new
+        context(&block)
       end
     end
 
     # Set the context to use within a block.
     #
-    # @param [Lumberjack::Context] context The context to use within the block.
+    # @param context [Lumberjack::Context] The context to use within the block.
     # @return [Object] The result of the block.
+    # @api private
     def use_context(context, &block)
-      current_context = Thread.current[:lumberjack_context]
+      fiber_id = Fiber.current.object_id
+      ctx = @global_contexts[fiber_id]
       begin
-        Thread.current[:lumberjack_context] = (context || Context.new)
+        @global_contexts_mutex.synchronize do
+          @global_contexts[fiber_id] = (context || Context.new)
+        end
         yield
       ensure
-        Thread.current[:lumberjack_context] = current_context
+        @global_contexts_mutex.synchronize do
+          if ctx.nil?
+            @global_contexts.delete(fiber_id)
+          else
+            @global_contexts[fiber_id] = ctx
+          end
+        end
       end
     end
 
     # Return true if inside a context block.
     #
     # @return [Boolean]
+    def in_context?
+      !!@global_contexts[Fiber.current.object_id]
+    end
+
     def context?
-      !!Thread.current[:lumberjack_context]
+      Utils.deprecated("Lumberjack.context?", "Lumberjack.context? is deprecated and will be removed in version 2.1; use in_context? instead.") do
+        in_context?
+      end
+    end
+
+    # Return attributes that will be applied to all Lumberjack loggers.
+    #
+    # @return [Hash, nil]
+    def context_attributes
+      current_context&.attributes
     end
 
-    # Return the tags from the current context or nil if there are no tags.
+    # Alias for context_attributes to provide API compatibility with version 1.x.
+    # This method will eventually be removed.
     #
     # @return [Hash, nil]
+    # @deprecated Use {.context_attributes}
     def context_tags
-      context = Thread.current[:lumberjack_context]
-      context&.tags
+      Utils.deprecated("Lumberjack.context_tags", "Lumberjack.context_tags is deprecated and will be removed in version 2.1; use context_attributes instead.") do
+        context_attributes
+      end
+    end
+
+    # Tag all loggers with attributes on the current context.
+    #
+    # @param attributes [Hash] The attributes to set.
+    # @param block [Proc] optional context block in which to set the attributes.
+    # @return [void]
+    def tag(attributes, &block)
+      if block
+        context do
+          current_context.assign_attributes(attributes)
+          block.call
+        end
+      else
+        current_context&.assign_attributes(attributes)
+      end
+    end
+
+    # Helper method to build an entry formatter.
+    #
+    # @param block [Proc] The block to use for building the entry formatter.
+    # @return [Lumberjack::EntryFormatter] The built entry formatter.
+    # @see Lumberjack::EntryFormatter.build
+    def build_formatter(&block)
+      EntryFormatter.build(&block)
+    end
+
+    # Control how use of deprecated methods is handled. The default is to print a warning
+    # the first time a deprecated method is called. Setting this to :verbose will print
+    # a warning every time a deprecated method is called. Setting this to :silent will
+    # suppress all deprecation warnings. Setting this to :raise will raise an exception
+    # when a deprecated method is called.
+    #
+    # The default value can be set with the +LUMBERJACK_DEPRECATION_WARNINGS+ environment variable.
+    #
+    # @param value [Symbol, String, nil] The deprecation mode to set. Valid values are :normal,
+    #   :verbose, :silent, and :raise.
+    def deprecation_mode=(value)
+      @deprecation_mode = value&.to_sym
     end
 
-    # Set tags on the current context
+    # @return [Symbol] The current deprecation mode.
+    # @api private
+    def deprecation_mode
+      @deprecation_mode ||= ENV.fetch("LUMBERJACK_DEPRECATION_WARNINGS", "normal").to_sym
+    end
+
+    # Set whether errors encountered while logging entries should be raised. The default behavior
+    # is to rescue these errors and print them to standard error. Otherwise there can be no way
+    # to record the error since it cannot be logged.
     #
-    # @param [Hash] tags The tags to set.
+    # You can set this to true in you test and development environments to catch logging errors
+    # before they make it to production.
+    #
+    # @param value [Boolean] Whether to raise logger errors.
     # @return [void]
-    def tag(tags)
-      context = Thread.current[:lumberjack_context]
-      context&.tag(tags)
+    def raise_logger_errors=(value)
+      @raise_logger_errors = !!value
+    end
+
+    # @return [Boolean] Whether logger errors should be raised.
+    # @api private
+    def raise_logger_errors?
+      @raise_logger_errors
+    end
+
+    private
+
+    def current_context
+      @global_contexts[Fiber.current.object_id]
     end
   end
 end

data/lumberjack.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |spec|
   spec.authors = ["Brian Durand"]
   spec.email = ["bbdurand@gmail.com"]
 
-  spec.summary = "A simple, powerful, and fast logging utility with excellent structured logging support that can be a drop in replacement for the standard library Logger."
+  spec.summary = "Extension of Ruby’s standard Logger for advanced, structured logging. Includes log entry attributes, context isolation, customizable formatters, flexible output devices, and testing tools."
   spec.homepage = "https://github.com/bdurand/lumberjack"
   spec.license = "MIT"
 
@@ -31,7 +31,9 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.5.0"
+  spec.required_ruby_version = ">= 2.7"
+
+  spec.add_runtime_dependency "logger"
 
   spec.add_development_dependency "bundler"
 end