lumberjack_rails 1.0.0

data/lib/lumberjack/rails/apply_patches.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Integration patches for Lumberjack Rails support.
+#
+# This file applies various patches and extensions to integrate Lumberjack
+# with Rails framework components. It performs the following key integrations:
+#
+# 1. Removes deprecated Lumberjack::Logger methods that conflict with ActiveSupport
+# 2. Adds tagged logging support to Lumberjack formatters and loggers
+# 3. Extends ActiveSupport::BroadcastLogger with Lumberjack compatibility
+# 4. Integrates with Rails framework components (ActiveJob, ActionCable, etc.)
+# 5. Sets up log subscribers to use forked Lumberjack loggers
+#
+# These patches ensure seamless integration between Lumberjack's logging
+# capabilities and Rails' existing logging infrastructure while maintaining
+# backward compatibility with existing Rails logging patterns.
+
+# Remove deprecated methods on Lumberjack::Logger that are implemented by ActiveSupport
+Lumberjack::Logger.remove_method(:tagged) if Lumberjack::Logger.instance_methods.include?(:tagged)
+Lumberjack::Logger.remove_method(:log_at) if Lumberjack::Logger.instance_methods.include?(:log_at)
+Lumberjack::Logger.remove_method(:silence) if Lumberjack::Logger.instance_methods.include?(:silence)
+
+# Add tagged logging support to the Lumberjack::EntryFormatter
+Lumberjack::EntryFormatter.prepend(Lumberjack::Rails::TaggedLoggingFormatter)
+Lumberjack::EntryFormatter.include(ActiveSupport::TaggedLogging::Formatter)
+
+# Add silence method to Lumberjack::Logger
+require "active_support/logger_silence"
+Lumberjack::ContextLogger.include(ActiveSupport::LoggerSilence)
+
+# Use prepend to ensure level is overridden properly
+Lumberjack::ContextLogger.prepend(Lumberjack::Rails::LogAtLevel)
+
+# Add tagged logging support to Lumberjack
+Lumberjack::ContextLogger.prepend(ActiveSupport::TaggedLogging)
+Lumberjack::ForkedLogger.include(Lumberjack::Rails::TaggedForkedLogger)
+
+ActiveSupport::BroadcastLogger.prepend(Lumberjack::Rails::BroadcastLoggerExtension)
+
+ActiveSupport.on_load(:active_job) do
+  ActiveJob::Base.prepend(Lumberjack::Rails::ActiveJobExtension)
+  ActiveJob::LogSubscriber.prepend(Lumberjack::Rails::LogSubscriberExtension)
+  ActiveJob::LogSubscriber.logger = -> { ActiveJob::Base.logger }
+end
+
+ActiveSupport.on_load(:action_cable) do
+  ActionCable::Connection::Base.prepend(Lumberjack::Rails::ActionCableExtension)
+end
+
+ActiveSupport.on_load(:action_mailer) do
+  ActionMailer::Base.prepend(Lumberjack::Rails::ActionMailerExtension)
+  ActionMailer::LogSubscriber.prepend(Lumberjack::Rails::LogSubscriberExtension)
+  ActionMailer::LogSubscriber.logger = -> { ActionMailer::Base.logger }
+end
+
+ActiveSupport.on_load(:action_mailbox) do
+  ActionMailbox::Base.prepend(Lumberjack::Rails::ActionMailboxExtension)
+end
+
+ActiveSupport.on_load(:action_controller) do
+  # Add hook to allow disabling of "Started ..." log lines in Rack::Logger
+  ::Rails::Rack::Logger.prepend(Lumberjack::Rails::RackLoggerExtension) if defined?(::Rails::Rack::Logger)
+
+  ActionController::Base.prepend(Lumberjack::Rails::ActionControllerExtension)
+
+  ActionController::LogSubscriber.prepend(Lumberjack::Rails::ActionControllerLogSubscriberExtension)
+  ActionController::LogSubscriber.prepend(Lumberjack::Rails::LogSubscriberExtension)
+  ActionController::LogSubscriber.logger = -> { ActionController::Base.logger }
+
+  ActionDispatch::LogSubscriber.prepend(Lumberjack::Rails::LogSubscriberExtension)
+end
+
+ActiveSupport.on_load(:action_view) do
+  ActionView::LogSubscriber.prepend(Lumberjack::Rails::LogSubscriberExtension)
+  ActionView::LogSubscriber.logger = -> { ActionView::Base.logger }
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::LogSubscriber.prepend(Lumberjack::Rails::LogSubscriberExtension)
+  ActiveRecord::LogSubscriber.logger = -> { ActiveRecord::Base.logger }
+end
+
+ActiveSupport.on_load(:active_storage_record) do
+  ActiveStorage::LogSubscriber.prepend(Lumberjack::Rails::LogSubscriberExtension)
+  ActiveStorage::LogSubscriber.logger = -> { ActiveStorage.logger }
+end

data/lib/lumberjack/rails/broadcast_logger_extension.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  module Rails
+    # Extension for ActiveSupport::BroadcastLogger to provide Lumberjack compatibility.
+    #
+    # This module extends ActiveSupport::BroadcastLogger to ensure proper handling
+    # of Lumberjack loggers when broadcasting to multiple loggers, including
+    # support for Lumberjack-specific features like attributes and contexts.
+    module BroadcastLoggerExtension
+      # Initialize the broadcast logger with validation for Lumberjack loggers.
+      #
+      # @param loggers [Array<Logger>] array of loggers to broadcast to
+      # @raise [ArgumentError] if more than one Lumberjack logger is provided
+      def initialize(*loggers)
+        if loggers.count { |logger| logger.is_a?(Lumberjack::ContextLogger) } > 1
+          raise ArgumentError, "Only one Lumberjack logger is allowed"
+        end
+
+        super
+      end
+
+      # Log a debug message with optional attributes support.
+      #
+      # @param message_or_progname_or_attributes [String, Hash] the message, progname, or attributes
+      # @param progname_or_attributes [String, Hash] the progname or attributes
+      # @yield optional block that returns the message
+      # @return [void]
+      def debug(message_or_progname_or_attributes = nil, progname_or_attributes = nil, &block)
+        dispatch_to_each(block) do |logger, one_time_block|
+          call_with_attributes_arg(logger, :debug, message_or_progname_or_attributes, progname_or_attributes, &one_time_block)
+        end
+      end
+
+      # Log an info message with optional attributes support.
+      #
+      # @param message_or_progname_or_attributes [String, Hash] the message, progname, or attributes
+      # @param progname_or_attributes [String, Hash] the progname or attributes
+      # @yield optional block that returns the message
+      # @return [void]
+      def info(message_or_progname_or_attributes = nil, progname_or_attributes = nil, &block)
+        dispatch_to_each(block) do |logger, one_time_block|
+          call_with_attributes_arg(logger, :info, message_or_progname_or_attributes, progname_or_attributes, &one_time_block)
+        end
+      end
+
+      # Log a warning message with optional attributes support.
+      #
+      # @param message_or_progname_or_attributes [String, Hash] the message, progname, or attributes
+      # @param progname_or_attributes [String, Hash] the progname or attributes
+      # @yield optional block that returns the message
+      # @return [void]
+      def warn(message_or_progname_or_attributes = nil, progname_or_attributes = nil, &block)
+        dispatch_to_each(block) do |logger, one_time_block|
+          call_with_attributes_arg(logger, :warn, message_or_progname_or_attributes, progname_or_attributes, &one_time_block)
+        end
+      end
+
+      # Log an error message with optional attributes support.
+      #
+      # @param message_or_progname_or_attributes [String, Hash] the message, progname, or attributes
+      # @param progname_or_attributes [String, Hash] the progname or attributes
+      # @yield optional block that returns the message
+      # @return [void]
+      def error(message_or_progname_or_attributes = nil, progname_or_attributes = nil, &block)
+        dispatch_to_each(block) do |logger, one_time_block|
+          call_with_attributes_arg(logger, :error, message_or_progname_or_attributes, progname_or_attributes, &one_time_block)
+        end
+      end
+
+      # Log a fatal message with optional attributes support.
+      #
+      # @param message_or_progname_or_attributes [String, Hash] the message, progname, or attributes
+      # @param progname_or_attributes [String, Hash] the progname or attributes
+      # @yield optional block that returns the message
+      # @return [void]
+      def fatal(message_or_progname_or_attributes = nil, progname_or_attributes = nil, &block)
+        dispatch_to_each(block) do |logger, one_time_block|
+          call_with_attributes_arg(logger, :fatal, message_or_progname_or_attributes, progname_or_attributes, &one_time_block)
+        end
+      end
+
+      # Log an unknown severity message with optional attributes support.
+      #
+      # @param message_or_progname_or_attributes [String, Hash] the message, progname, or attributes
+      # @param progname_or_attributes [String, Hash] the progname or attributes
+      # @yield optional block that returns the message
+      # @return [void]
+      def unknown(message_or_progname_or_attributes = nil, progname_or_attributes = nil, &block)
+        dispatch_to_each(block) do |logger, one_time_block|
+          call_with_attributes_arg(logger, :unknown, message_or_progname_or_attributes, progname_or_attributes, &one_time_block)
+        end
+      end
+
+      # Add a log entry with the specified severity and optional attributes support.
+      #
+      # @param severity [Integer, Symbol, String] the severity for the log entry
+      # @param message_or_progname_or_attributes [String, Hash] the message, progname, or attributes
+      # @param progname_or_attributes [String, Hash] the progname or attributes
+      # @yield optional block that returns the message
+      # @return [void]
+      def add(severity, message_or_progname_or_attributes = nil, progname_or_attributes = nil, &block)
+        severity = Logger::Severity.coerce(severity)
+        dispatch_to_each(block) do |logger, one_time_block|
+          call_add_with_attributes_arg(logger, severity, message_or_progname_or_attributes, progname_or_attributes, &one_time_block)
+        end
+      end
+
+      alias_method :log, :add
+
+      # Override the with_level method defined on the logger gem to use Rails' log_at method instead.
+      #
+      # @param level [Symbol, Integer] the log level to set temporarily
+      # @yield the block to execute at the specified log level
+      # @return [Object] the result of the block execution
+      def with_level(level, &block)
+        log_at(level, &block)
+      end
+
+      # Tag log entries with the specified attributes.
+      #
+      # @param attributes [Hash] the attributes to tag with
+      # @yield the block to execute with the tagged context
+      # @return [Object] the result of the block execution
+      def tag(attributes, &block)
+        dispatch_block_method(:tag, attributes, &block)
+      end
+
+      # Execute a block within a logger context.
+      #
+      # @yield the block to execute within the context
+      # @return [Object] the result of the block execution
+      def context(&block)
+        dispatch_block_method(:context, &block)
+      end
+
+      # Ensure a Lumberjack context is present for the duration of the block.
+      #
+      # @yield the block to execute within the ensured context
+      # @return [Object] the result of the block execution
+      def ensure_context(&block)
+        dispatch_block_method(:ensure_context, &block)
+      end
+
+      # Append values to an existing attribute.
+      #
+      # @param attribute_name [String, Symbol] the name of the attribute
+      # @param tag [Array] the values to append
+      # @yield the block to execute with the modified attribute
+      # @return [Object] the result of the block execution
+      def append_to(attribute_name, *tag, &block)
+        dispatch_block_method(:append_to, attribute_name, *tag, &block)
+      end
+
+      # Clear all current attributes.
+      #
+      # @yield the block to execute with cleared attributes
+      # @return [Object] the result of the block execution
+      def clear_attributes(&block)
+        dispatch_block_method(:clear_attributes, &block)
+      end
+
+      # Execute a block without any tags.
+      #
+      # @yield the block to execute without tags
+      # @return [Object] the result of the block execution
+      def untagged(&block)
+        dispatch_block_method(:untagged, &block)
+      end
+
+      # Set the progname temporarily for a block.
+      #
+      # @param value [String] the progname to set
+      # @yield the block to execute with the specified progname
+      # @return [Object] the result of the block execution
+      def with_progname(value, &block)
+        dispatch_block_method(:with_progname, value, &block)
+      end
+
+      # Alias for with_progname for backward compatibility.
+      #
+      # @param value [String] the progname to set
+      # @yield the block to execute with the specified progname
+      # @return [Object] the result of the block execution
+      def set_progname(value, &block)
+        dispatch_block_method(:with_progname, value, &block)
+      end
+
+      # Create a forked logger from this broadcast logger.
+      #
+      # @param level [Symbol, Integer] optional log level for the forked logger
+      # @param progname [String] optional progname for the forked logger
+      # @param attributes [Hash] optional attributes for the forked logger
+      # @return [Lumberjack::ForkedLogger] the forked logger
+      def fork(level: nil, progname: nil, attributes: nil)
+        logger = Lumberjack::ForkedLogger.new(self)
+        logger.level = level if level
+        logger.progname = progname if progname
+        logger.tag!(attributes) if attributes && !attributes.empty?
+        logger
+      end
+
+      private
+
+      # Lumberjack loggers support an optional attributes argument to the logging methods. This method provides
+      # compatibility with other Loggers that don't support that argument. The arguments here are funky because
+      # the methods on Logger are funky. On Logger the sole argument to a logging method can be message or
+      # the progname depending on if the message is in the block.
+      #
+      # @param logger [Logger] the logger to call the method on
+      # @param method [Symbol] the logging method to call
+      # @param message_or_progname_or_attributes [String, Hash] the message, progname, or attributes
+      # @param progname_or_attributes [String, Hash] the progname or attributes
+      # @yield optional block that returns the message
+      # @return [void]
+      def call_with_attributes_arg(logger, method, message_or_progname_or_attributes, progname_or_attributes, &block)
+        if logger.is_a?(Lumberjack::ContextLogger)
+          logger.send(method, message_or_progname_or_attributes, progname_or_attributes, &block)
+        elsif block
+          progname = message_or_progname_or_attributes unless progname_or_attributes.is_a?(Hash)
+          logger.send(method, progname, &block)
+        else
+          logger.send(method, message_or_progname_or_attributes)
+        end
+      end
+
+      # Lumberjack loggers support an optional attributes argument to the logging methods. This method provides
+      # compatibility with other Loggers that don't support that argument. The arguments here are funky because
+      # the methods on Logger#add are funky. On Logger the sole argument to a logging method can be message or
+      # the progname depending on if the message is in the block.
+      #
+      # @param logger [Logger] the logger to call the method on
+      # @param severity [Integer, Symbol, String] the severity for the log entry
+      # @param message_or_progname_or_attributes [String, Hash] the message, progname, or attributes
+      # @param progname_or_attributes [String, Hash] the progname or attributes
+      # @yield optional block that returns the message
+      # @return [void]
+      def call_add_with_attributes_arg(logger, severity, message_or_progname_or_attributes, progname_or_attributes, &block)
+        if logger.is_a?(Lumberjack::ContextLogger)
+          logger.add(severity, message_or_progname_or_attributes, progname_or_attributes, &block)
+        elsif block
+          progname = message_or_progname_or_attributes unless progname_or_attributes.is_a?(Hash)
+          logger.add(severity, progname, &block)
+        else
+          logger.add(severity, message_or_progname_or_attributes)
+        end
+      end
+
+      # Guard against multiple loggers responding to the same method that takes
+      # a block. In that case we don't want to call the block multiple times.
+      # This does not include the logging methods like `info` but does include
+      # methods like `tag` that are expected to be called with a block that
+      # has business logic inside of it.
+      #
+      # This method is used for methods that modify the state of the logger. Since the block
+      # is only called once, other loggers will not have the internal state modified as expected.
+      #
+      # @param name [Symbol] the method name to dispatch
+      # @yield optional block to execute
+      # @return [Object] the result of the method execution
+      def dispatch_block_method(name, ...)
+        loggers = broadcasts.select { |logger| logger.respond_to?(name) }
+
+        if loggers.none?
+          result = yield if block_given?
+          return result
+        end
+
+        return loggers.first.send(name, ...) if loggers.one?
+
+        message = "BroadcastLogger cannot call #{name} on multiple loggers with a block."
+        loggers.first.warn("#{message} It was called on this logger.")
+        loggers[1..].each { |logger| logger.warn("#{message} It was not called on this logger.") }
+        loggers.first.send(name, ...)
+      end
+
+      # Dispatch to each logger and the block if any. The block will only be called once.
+      #
+      # @param block [Proc] Block that will be called on the wrapped method.
+      # @yield block to execute for each logger
+      # @return [Object] the result of the first logger's block execution
+      # @yieldparam logger [Logger] the current logger
+      # @yieldparam one_time_block [Proc, nil] the block to execute, or nil if no block was given.
+      def dispatch_to_each(block)
+        if block
+          called = false
+          result = nil
+          one_time_block = lambda do
+            if called
+              result
+            else
+              called = true
+              result = block.call
+            end
+          end
+        end
+
+        broadcasts.map { |logger| yield(logger, one_time_block) }.first
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/context_middleware.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  module Rails
+    # This Rack middleware provides a Lumberjack context for each request.
+    class ContextMiddleware
+      # @param app [#call] The Rack application.
+      def initialize(app)
+        @app = app
+      end
+
+      # Process a request through the middleware stack with Lumberjack context.
+      #
+      # @param env [Hash] the Rack environment hash
+      # @return [Array] the Rack response array
+      def call(env)
+        Lumberjack::Rails.logger_context do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/log_at_level.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  module Rails
+    # Extension that provides log level override functionality.
+    #
+    # This module allows temporary overriding of the logger's level using
+    # Rails' local_level mechanism while maintaining compatibility with
+    # the underlying Lumberjack logger.
+    module LogAtLevel
+      # Get the effective log level, checking for local level override first.
+      #
+      # @return [Integer] the effective log level
+      def level
+        local_level || super
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/log_subscriber_extension.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Lumberjack::Rails
+  # Extension for Rails log subscribers to provide Lumberjack logger integration.
+  #
+  # This module enables Rails log subscribers (such as ActiveRecord::LogSubscriber,
+  # ActionController::LogSubscriber, etc.) to use forked Lumberjack loggers.
+  # Forked loggers provide isolation, allowing different log levels and attributes
+  # to be set for different log subscribers without affecting the main logger.
+  #
+  # When a log subscriber's logger is accessed, this extension checks if the
+  # parent logger supports forking. If it does, a ForkedLogger is created and
+  # cached for subsequent use. This ensures each log subscriber has its own
+  # isolated logger context.
+  module LogSubscriberExtension
+    extend ActiveSupport::Concern
+
+    prepended do
+      @__logger ||= nil
+      @__silenced_events ||= nil
+    end
+
+    class_methods do
+      # Get the logger for this log subscriber class.
+      #
+      # This method overrides the default Rails log subscriber logger behavior
+      # to provide Lumberjack forked logger support. If the parent logger supports
+      # forking, a ForkedLogger is created and cached. Otherwise, the original
+      # logger is returned unchanged.
+      #
+      # @return [Lumberjack::ForkedLogger, Logger] the logger instance for this subscriber
+      def logger
+        class_logger = super
+        class_logger = class_logger.call if class_logger.is_a?(Proc)
+
+        if class_logger.respond_to?(:fork)
+          if !@__logger.is_a?(Lumberjack::ForkedLogger) || @__logger&.parent_logger != class_logger
+            @__logger = class_logger.fork
+          end
+        else
+          @__logger = class_logger
+        end
+
+        @__logger
+      end
+
+      # Silence an individual event for this subscriber. The event name is the name of the public
+      # instance method to silence.
+      #
+      # @param event_name [String, Symbol] the name of the event to silence
+      # @return [void]
+      def silence_event!(event_name)
+        @__silenced_events ||= Set.new
+        @__silenced_events << event_name.to_s
+      end
+
+      # Unsilence an individual event for this subscriber.
+      #
+      # @param event_name [String, Symbol] the name of the event to unsilence
+      # @return [void]
+      def unsilence_event!(event_name)
+        @__silenced_events&.delete(event_name.to_s)
+      end
+
+      # Check if a specific event is silenced for this subscriber.
+      #
+      # @param event [String] the full event name of the event to check with the namespace
+      # @return [Boolean] true if the event is silenced, false otherwise
+      # @api private
+      def silenced_event?(event)
+        return false if @__silenced_events.nil?
+
+        i = event.index(".")
+        event_name = i ? event[0, i] : event
+        @__silenced_events.include?(event_name)
+      end
+    end
+
+    # Override the silenced? method to check if the event has been explicitly silenced.
+    #
+    # @param event [String] the event to check
+    # @return [Boolean] true if the event is silenced, false otherwise
+    def silenced?(event)
+      super || self.class.silenced_event?(event)
+    end
+
+    # Get the logger for this log subscriber instance.
+    #
+    # Delegates to the class-level logger method to ensure consistent
+    # behavior across all instances of the log subscriber.
+    #
+    # @return [Lumberjack::ForkedLogger, Logger] the logger instance for this subscriber
+    def logger
+      self.class.logger
+    end
+  end
+end

data/lib/lumberjack/rails/rack_logger_extension.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lumberjack::Rails
+  module RackLoggerExtension
+    private
+
+    def started_request_message(request)
+      return if Lumberjack::Rails.silence_rack_request_started?
+
+      super
+    end
+  end
+end