lumberjack_rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9e2d5624bd1b1c1c67487fde54b2ebd11def32b5e715e4d8ff7c7e7ece1d3253
+  data.tar.gz: d3bf91601bf2380602e887d71c863cf631968b910655db9020aee66377882fc7
+SHA512:
+  metadata.gz: '08425991455694b32dbccf992ad8448b003a94a09b5a2971f27aa2d056c186d70fa5793715a28b83d43b22696ae0401833c84af8ec83a098832a3950811014db'
+  data.tar.gz: 6c17517e84a4e0520a50da6199632403f1e4b4899c203a1688d4f1ae5d92361030d535375f6add1f4ab663fe37c5708b16343b54d61d8f36660053b5a52e1ace

data/.github/dependabot.yml

@@ -0,0 +1,12 @@
+# Dependabot update strategy
+version: 2
+updates:
+  - package-ecosystem: bundler
+    directory: "/"
+    schedule:
+      interval: weekly
+    allow:
+      # Automatically keep all runtime dependencies updated
+      - dependency-name: "*"
+        dependency-type: "production"
+    versioning-strategy: lockfile-only

data/.github/workflows/continuous_integration.yml

@@ -0,0 +1,70 @@
+name: Continuous Integration
+
+on:
+  push:
+    branches:
+      - main
+      - actions-*
+  pull_request:
+    branches-ignore:
+      - actions-*
+  workflow_dispatch:
+
+env:
+  BUNDLE_CLEAN: "true"
+  BUNDLE_PATH: vendor/bundle
+  BUNDLE_JOBS: 3
+  BUNDLE_RETRY: 3
+
+jobs:
+  build:
+    name: build ruby-${{ matrix.ruby }} ${{ matrix.appraisal }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - ruby: "ruby"
+            standardrb: true
+            yard: true
+          - ruby: "3.4"
+            appraisal: rails_8
+          - ruby: "3.3"
+            appraisal: rails_8.0
+          - ruby: "3.1"
+            appraisal: rails_7
+          - ruby: "3.0"
+            appraisal: rails_7.1
+          - ruby: "ruby"
+            appraisal: no_rails
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby ${{ matrix.ruby }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "${{ matrix.ruby }}"
+      - name: Install packages
+        run: |
+          sudo apt-get update
+          sudo apt-get install libsqlite3-dev
+      - name: Setup bundler
+        if: matrix.bundler != ''
+        run: |
+          gem uninstall bundler --all
+          gem install bundler --no-document --version ${{ matrix.bundler }}
+      - name: Set Appraisal bundle
+        if: matrix.appraisal != ''
+        run: |
+          echo "using gemfile gemfiles/${{ matrix.appraisal }}.gemfile"
+          bundle config set gemfile "gemfiles/${{ matrix.appraisal }}.gemfile"
+      - name: Install gems
+        run: |
+          bundle update
+      - name: Run Tests
+        run: bundle exec rake
+      - name: standardrb
+        if:   matrix.standardrb == true
+        run:  bundle exec standardrb
+      - name: yard
+        if: matrix.yard == true
+        run:  bundle exec yard --fail-on-warning

data/.standard.yml

@@ -0,0 +1,9 @@
+ruby_version: 3.0
+
+format: progress
+
+ignore:
+  - 'spec/**/*':
+    - Lint/UselessAssignment
+    - Lint/Void
+  - 'test_app/**/*'

data/.yardopts

@@ -0,0 +1 @@
+--exclude lib/lumberjack/rails/apply_patches.rb

data/CHANGE_LOG.md

@@ -0,0 +1,11 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 1.0.0
+
+### Added
+
+- Initial release

data/MIT_LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2025 Brian Durand
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,329 @@
+# Lumberjack Rails
+
+[![Continuous Integration](https://github.com/bdurand/lumberjack_rails/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/lumberjack_rails/actions/workflows/continuous_integration.yml)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+[![Gem Version](https://badge.fury.io/rb/lumberjack_rails.svg)](https://badge.fury.io/rb/lumberjack_rails)
+
+The `lumberjack_rails` gem provides support for using the [lumberjack](https://github.com/bdurand/lumberjack) logging library in Rails applications.
+
+Rails has some of its own extensions to the Ruby standard library logger, and this gem bridges the gap between the two logging systems to add Lumberjack features to the `Rails.logger` and Rails features to Lumberjack loggers.
+
+## Usage
+
+With this gem installed, your main application logger will be a Lumberjack logger. The logger that gets initialized is defined by your application's configuration.
+
+### Configuration Options
+
+#### `config.lumberjack.enabled`
+
+Enables or disables the Lumberjack logger. If this is set to `false`, then Lumberjack will not be used.
+
+#### `config.lumberjack.level`
+
+Sets the log level for the Lumberjack logger. This can be set to any valid log level supported by Lumberjack. This will defer to the standard Rails `config.log_level` setting or default to `:debug` if neither is set.
+
+#### `config.lumberjack.device`
+
+The device to write logs to (file path, IO object, etc.). Defaults to the Rails log file.
+
+#### `config.lumberjack.attributes`
+
+Hash of attributes to apply to all log messages. These attributes will be included in every log entry.
+
+#### `config.lumberjack.shift_age`
+
+The age (in seconds) of log files before they are rotated, or a shift name (`daily`, `weekly`, `monthly`). The default is no log rotation. See the [logger](https://github.com/ruby/logger) gem documentation for details.
+
+#### `config.lumberjack.shift_size`
+
+The size (in bytes) of log files before they are rotated if `shift_age` is set to an integer. Defaults to `1048576` (1MB). See the [logger](https://github.com/ruby/logger) gem documentation for details.
+
+#### `config.lumberjack.log_rake_tasks`
+
+Whether to redirect `$stdout` and `$stderr` to `Rails.logger` for rake tasks that depend on the `:environment` task when using a Lumberjack::Logger. Defaults to `false`.
+
+> [!TIP]
+> This is useful for getting output from `db:migrate` and other rake tasks run in production into your logs. It can often be difficult to track down issues in these tasks without proper logging.
+
+> [!NOTE]
+> This setting is ignored when running in an interactive terminal session.
+
+#### `config.lumberjack.middleware`
+
+Whether to install Rack middleware that adds a Lumberjack context to each request. Defaults to `true`.
+
+#### `config.lumberjack.silence_rack_request_started`
+
+When set to `true`, the "Started ..." log lines generated by `Rails::Rack::Logger` will be suppressed. This can help reduce log noise in applications where these lines are not needed. Defaults to `false`.
+
+#### `config.lumberjack.request_attributes_proc`
+
+A proc to add to log entries for each Rack request. The proc will be called with the request object.
+
+> [!TIP]
+> You can use this feature to add both static attributes and dynamic attributes (using a proc) to all log entries within a request context.
+
+```ruby
+config.lumberjack.request_attributes_proc = ->(request) {
+  {
+    host: request.host,
+    method: request.request_method,
+    path: request.path,
+    request_id: request.request_id
+  }
+}
+```
+
+#### Additional Options
+
+> [!TIP]
+> For more readable logs in development or test environments, you can set `config.lumberjack.template` to `:local` to use the built-in template intended for human readability.
+>
+> If you have attributes that are logged on every entry but don't want them cluttering up your development logs (i.e. `host`, `version`, etc.), you can set `config.lumberjack.exclude_attributes` to the attribute names to exclude.
+
+You can include `Lumberjack::Rails.active_record_entry_formatter` in your logger formatter to format ActiveRecord models in log attributes with just the model name and id.
+
+```ruby
+config.lumberjack.formatter = Lumberjack.build_formatter do |formatter|
+  formatter.include(Lumberjack::Rails.active_record_entry_formatter)
+end
+```
+
+#### Example Configuration
+
+Here's an example of how you might configure Lumberjack in your `config/application.rb`:
+
+```ruby
+config.log_level = :info
+
+# Set the program name on the logger
+config.lumberjack.progname = Rails.application.railtie_name
+
+# Add values we want on all log entries
+config.lumberjack.attributes = {
+  host: Lumberjack::Utils.hostname, # Ensures hostname is UTF-8 encoded
+  pid: Lumberjack::Utils.global_pid # Returns a global PID value across all hosts
+}
+
+config.lumberjack.device = STDOUT
+
+# Build the log entry formatter
+config.lumberjack.formatter = Lumberjack.build_formatter do |formatter|
+  formatter.add(ActiveRecord::Base, :id)
+
+  # Format the :tags attribute as tags (e.g. [tag1] [tag2])
+  formatter.add_attribute("tags", :tags)
+
+  formatter.add_attribute("cost", :round, 2)
+  formatter.add_attribute_class("User") { |user| {id: user.id, username: user.username} }
+end
+
+# Use a custom template that adds the request id on all log entry lines.
+config.lumberjack.template = "[{{time}} {{severity}} {{progname}} {{request_id}}] {{tags}} {{message}} -- {{attributes}}"
+config.lumberjack.additional_lines = "> :request_id :message"
+
+# Format log attributes as "[name=value]" (default is [name:value])
+config.lumberjack.attribute_format = "[name=value]"
+
+# Convert db:migrate and other rails task output to log entries
+config.lumberjack.log_rake_tasks = true
+```
+
+> [!TIP]
+> If you are using a logging pipeline in production that supports [JSONL](https://jsonlines.org/) logs, then check out the [lumberjack_json_device](https://github.com/bdurand/lumberjack_json_device). The gem provides a mechanism for defining the JSON schema for your logs and outputting them to JSONL.
+
+> [!TIP]
+> If you want more easily readable log output in development or test environments, you can set the `config.lumberjack.template` to `:local`.
+>
+> If you have attributes that are logged on every entry but don't want them cluttering up your development logs, you can set `config.lumberjack.exclude_attributes` to the attribute names to exclude.
+>
+> You can also colorize the logs by setting `config.lumberjack.colorize` to `true` and set the format of the severity with `config.lumberjack.severity_format`.
+
+```ruby
+config.lumberjack.template = :local
+config.lumberjack.exclude_progname = true
+config.lumberjack.exclude_attributes = [:host, :request_id]
+config.lumberjack.colorize = true
+config.lumberjack.severity_format = :emoji
+```
+
+### TaggedLogger
+
+Rails has its own solution for logging metadata in the `tagged` method added to logger which can add an array of tags to log entries.
+
+Lumberjack supports the `tagged` method and will put the tags into the `tags` attribute. You can format these similar to how Rails formats them in the logger template with the `{{tags}}` formatter.
+
+```ruby
+# The :tags placeholder will be replaced with the tags attribute. This is the default template.
+config.lumberjack.template = "[{{time}} {{severity}} {{progname}} ({{pid}})] {{tags}} {{message}} -- {{attributes}}"
+
+# Add the :tags formatter. If you don't do this, then the tags will be formatted as an inspected array.
+config.lumberjack.formatter = Lumberjack.build_formatter do |formatter|
+  formatter.add_attribute(:tags, :tags)
+end
+```
+
+### Broadcast Logger
+
+Rails provides a built-in mechanism for broadcasting log messages to multiple destinations. `Rails.logger` is actually an `ActiveSupport::BroadcastLogger` object wrapping one or more underlying loggers. When you call a method on `Rails.logger`, it will call that method on all underlying loggers. This can create some problems for methods that take a block since that block could get called once for each logger being broadcast to. Only one Lumberjack logger should be added `Rails.logger`. If more than one is added, method like `tag` or `context` that take a block will only be called on one of the loggers.
+
+If you want to send your logs to multiple devices with Lumberjack, you can use the Multi device instead.
+
+The one place that Rails uses multiple loggers out of the box is in development mode where logs are also sent to the console in addition to the log file. This functionality is supported.
+
+### Lumberjack Contexts
+
+Contexts are used in Lumberjack to provide isolation for changes to your logger. Within a context block, you can change the log level, progname, or attributes and they will only apply within that block execution.
+
+Contexts will be added via `around` callbacks to the following frameworks if they are installed:
+
+- ActionController
+- ActiveJob
+- ActionCable
+- ActionMailer
+- ActionMailbox
+
+In addition, a Rack middleware will be added to ensure a context is set on Rails.logger for each request.
+
+This allows you to change the log level or tag attributes on `Rails.logger` within your application code in these frameworks without affecting the global logger or the settings in any concurrent requests.
+
+### Log Subscribers
+
+Rails comes with several built-in log subscribers that are extended with Lumberjack. These include:
+
+- `ActiveRecord::LogSubscriber`
+- `ActionController::LogSubscriber`
+- `ActionDispatch::LogSubscriber`
+- `ActionView::LogSubscriber`
+- `ActiveJob::LogSubscriber`
+- `ActionMailer::LogSubscriber`
+- `ActiveStorage::LogSubscriber`
+
+These log subscribers will all use fork loggers. This these forked loggers are isolated from the main logger allowing you to change the log level and add attributes that is isolated to that log subscriber.
+
+```ruby
+# Set up log subscribers in an initializer
+
+ActiveSupport.on_load(:action_controller) do
+  ActionController::LogSubscriber.logger.tag!(user_id: Current.user_id) # Tag all log entries with the user ID
+end
+
+ActiveSupport.on_load(:action_view) do
+  unless Rails.env.local?
+    ActionView::LogSubscriber.logger.level = :warn # Silence view rendering logs in non-local environments
+  end
+end
+```
+
+You can also silence individual log subscriber events if you don't want to see them in your logs.
+
+```ruby
+ActiveSupport.on_load(:action_controller) do
+  ActionController::LogSubscriber.silence_event!!(:start_processing) # Silence the "Started ..." log lines
+end
+```
+
+You can also silence the logs that Rack adds when a request starts processing. This subscriber is implemented a bit differently by Rails, so there is a different method to silence it.
+
+```ruby
+Lumberjack::Rails.silence_rack_request_started = true
+```
+
+You can also silence the Rack logger in your application's configuration.
+
+```ruby
+config.lumberjack.silence_rack_request_started = true
+```
+
+#### Enhanced ActionController Logging
+
+The `ActionController::LogSubscriber` has been enhanced to allow you to specify additional attributes to be logged in the log entry when each request is finished processing. This log entry can be extremely useful as a canonical log entry for the request and Rails already supports adding some metadata onto the message. This extension allows you to add more metadata and add it as attributes for better structured logging.
+
+```ruby
+# Setup the additional attributes in an initializer.
+
+ActiveSupport.on_load(:action_controller) do
+  # Add the IP address from the request to the canonical log entry for the request.
+  # The notification event is passed to the block.
+  ActionController::LogSubscriber.add_process_log_attribute(:ip_address) { |event| event.payload[:request].remote_ip }
+
+  # You can also add multiple attributes with with a block that returns a hash.
+  ActionController::LogSubscriber.process_log_attributes do |event|
+    request = event.payload[:request]
+
+    # Get the HTTP status code from the event payload.
+    status = event.payload[:status]
+    if status.nil? && (exception_class_name = event.payload[:exception]&.first)
+      status = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
+    end
+
+    {
+      http: {
+        status: status,
+        method: request.method,
+        url: request.base_url + request.filtered_path,
+        useragent: request.user_agent,
+      }
+    }
+  end
+end
+```
+
+### Log Formatter
+
+ActiveRecord models logged in attributes will automatically be logged with a formatter that will only log the class name and id for the model. You can add additional formatters for `ApplicationRecord` or for your models to override this behavior.
+
+### Testing
+
+Lumberjack comes with built-in support for testing that critical log messages are generated. See the [lumberjack documentation](https://github.com/bdurand/lumberjack#testing-utilities) for more information.
+
+If you are using RSpec, then you can use the [lumberjack_rails_rspec](https://github.com/bdurand/lumberjack_capture_device) gem for to add RSpec matchers for testing log messages to your test suite.
+
+```ruby
+# In spec/rails_helper.rb
+
+require "lumberjack/capture_device/rspec"
+
+RSpec.configure do |config|
+  config.around do |example|
+    capture_logger_around_example(Rails.logger, example)
+  end
+end
+
+RSpec.describe MyModel do
+  it "logs a message when doing something" do
+    MyModel.do_something_important
+    expect(Rails.logger).to include_log_entry(:info, /did something important/)
+  end
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lumberjack_rails'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install lumberjack_rails
+```
+
+## Contributing
+
+Open a pull request on GitHub.
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/lumberjack/rails/action_cable_extension.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  module Rails
+    # Extension for ActionCable::Connection::Base to wrap command processing with Lumberjack context.
+    #
+    # This module ensures that all logging within ActionCable command processing is wrapped
+    # with the appropriate Lumberjack logger context, maintaining log consistency
+    # and enabling tagged logging features.
+    module ActionCableExtension
+      # Override the command method to wrap it with Lumberjack logger context.
+      #
+      # @return [Object] the result of the original command method
+      def command(...)
+        Lumberjack::Rails.logger_context(logger) { super }
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/action_controller_extension.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  module Rails
+    # Extension for ActionController::Base to wrap request processing with Lumberjack context.
+    #
+    # This module ensures that all logging within a controller action is wrapped
+    # with the appropriate Lumberjack logger context, maintaining log consistency
+    # and enabling tagged logging features.
+    module ActionControllerExtension
+      # Override the process method to wrap it with Lumberjack logger context.
+      #
+      # @return [Object] the result of the original process method
+      def process(...)
+        Lumberjack::Rails.logger_context(logger) { super }
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/action_controller_log_subscriber_extension.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Lumberjack::Rails
+  # This extension to the ActionController::LogSubscriber class allows specifying log attributes that
+  # will only be applied on the process_action event. This log entry already serves as the canonical
+  # log entry for requests and includes metadata such as duration, allocations, etc. With this extension
+  # you can add whatever additonal attributes you want to summarize what happened during the request
+  # as log attributes. This gives you more flexibility to add context to your request logs.
+  #
+  # You can add dynamically evaluated attributes by providing a block that takes the event as an argument.
+  #
+  # @example
+  #   ActionController::LogSubscriber.add_process_log_attribute(:ip_address) do |event|
+  #     event.payload.request.remote_ip
+  #   end
+  #
+  #   ActionController::LogSubscriber.add_process_log_attribute(:duration) do |event|
+  #     event.duration
+  #   end
+  module ActionControllerLogSubscriberExtension
+    extend ActiveSupport::Concern
+
+    prepended do
+      @lumberjack_process_log_attributes = {}
+      @lumberjack_process_log_blocks = []
+    end
+
+    class_methods do
+      # Add a log attribute to be included in the process_action log entry. You must provide
+      # either a static value or a block that takes the event as an argument to dynamically
+      # evaluate the value at log time.
+      #
+      # @param name [String, Symbol] the name of the log attribute
+      # @param value [Object] the static value of the log attribute (optional if block is provided)
+      # @yield [event] a block that takes the event as an argument to dynamically evaluate the value (optional if value is provided)
+      # @raise [ArgumentError] if neither a value nor a block is provided, or if both are provided
+      # @return [void]
+      def add_process_log_attribute(name, value = nil, &block)
+        raise ArgumentError.new("Must provide a value or a block") if value.nil? && block.nil?
+        raise ArgumentError.new("Cannot provide both a value and a block") if value && block
+
+        @lumberjack_process_log_attributes[name.to_s] = value || block
+      end
+
+      # Add log attributes to be included in the process_action log entry. The block must
+      # take an ActiveSupport::Notifications::Event as an argument and return a hash.
+      #
+      # @yieldparam event [ActiveSupport::Notifications::Event] the event being processed
+      # @yieldreturn [Hash] a hash of log attributes to be merged into the log entry attributes.
+      # @return [void]
+      def process_log_attributes(&block)
+        @lumberjack_process_log_blocks << block
+      end
+
+      # Get the log attributes to be included in the process_action log entry.
+      #
+      # @param event [ActiveSupport::Notifications::Event] the event being processed
+      # @return [Hash{String => Object}] a hash of log attributes
+      # @api private
+      def eval_process_log_attributes(event)
+        attributes = @lumberjack_process_log_attributes.each_with_object({}) do |(name, value_or_block), attrs|
+          attrs[name] = if value_or_block.respond_to?(:call)
+            value_or_block.call(event)
+          else
+            value_or_block
+          end
+        end
+
+        @lumberjack_process_log_blocks.each do |block|
+          attrs = block.call(event)
+          attributes.merge!(Lumberjack::Utils.flatten_attributes(attrs)) if attrs.is_a?(Hash)
+        end
+
+        attributes
+      end
+
+      private
+
+      # Used for testing.
+      def clear_process_log_attributes
+        @lumberjack_process_log_attributes = {}
+        @lumberjack_process_log_blocks = []
+      end
+    end
+
+    def process_action(event) # :nodoc:
+      with_process_logger_attributes(event) do
+        super
+      end
+    end
+
+    private
+
+    def with_process_logger_attributes(event, &block)
+      attributes = self.class.eval_process_log_attributes(event) if logger
+      if attributes && !attributes.empty?
+        logger.tag(attributes, &block)
+      else
+        block.call
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/action_mailbox_extension.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  module Rails
+    # Extension for ActionMailbox::Base to wrap mailbox processing with Lumberjack context.
+    #
+    # This module ensures that all logging within mailbox processing is wrapped
+    # with the appropriate Lumberjack logger context, maintaining log consistency
+    # and enabling tagged logging features.
+    module ActionMailboxExtension
+      # Override the perform_processing method to wrap it with Lumberjack logger context.
+      #
+      # @return [Object] the result of the original perform_processing method
+      def perform_processing(...)
+        Lumberjack::Rails.logger_context(logger) { super }
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/action_mailer_extension.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  module Rails
+    # Extension for ActionMailer::Base to wrap mail processing with Lumberjack context.
+    #
+    # This module ensures that all logging within mailer processing is wrapped
+    # with the appropriate Lumberjack logger context, maintaining log consistency
+    # and enabling tagged logging features.
+    module ActionMailerExtension
+      # Override the process method to wrap it with Lumberjack logger context.
+      #
+      # @return [Object] the result of the original process method
+      def process(...)
+        Lumberjack::Rails.logger_context(logger) { super }
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/active_job_extension.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  module Rails
+    # Extension for ActiveJob::Base to wrap job execution with Lumberjack context.
+    #
+    # This module ensures that all logging within job execution is wrapped
+    # with the appropriate Lumberjack logger context, maintaining log consistency
+    # and enabling tagged logging features.
+    module ActiveJobExtension
+      # Override the perform_now method to wrap it with Lumberjack logger context.
+      #
+      # @return [Object] the result of the original perform_now method
+      def perform_now(...)
+        Lumberjack::Rails.logger_context(logger) { super }
+      end
+    end
+  end
+end