lumberjack_rails 1.0.0

data/lib/lumberjack/rails/railtie.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# Railtie for integrating Lumberjack::Logger with Rails applications.
+#
+# This railtie replaces the standard Rails logger with a Lumberjack::Logger while
+# maintaining compatibility with Rails' logging configuration options.
+#
+# Configuration options:
+#   config.lumberjack.enabled (default: true)
+#     Whether to replace Rails.logger with Lumberjack::Logger
+#
+#   config.lumberjack.device (default: Rails log file)
+#     The device to write logs to (file path, IO object, Lumberjack Device)
+#
+#   config.lumberjack.level (default: config.log_level)
+#     The log level for the Lumberjack logger
+#
+#   config.lumberjack.attributes (default: nil)
+#     Attributes to apply to log messages
+#
+#   config.lumberjack.shift_age (default: 0)
+#     The age (in seconds) of log files before they are rotated or
+#     a shift name (daily, weekly, monthly)
+#
+#   config.lumberjack.shift_size (default: 1048576)
+#     The size (in bytes) of log files before they are rotated if shift_age
+#     is set to 0.
+#
+#   config.lumberjack.log_rake_tasks (default: false)
+#     Whether to redirect $stdout and $stderr to Rails.logger for rake tasks
+#     that depend on the :environment task when using a Lumberjack::Logger
+#
+#   config.lumberjack.middleware (default: true)
+#     Whether to install Rack middleware that adds a Lumberjack context to each request.
+#
+#   config.lumberjack.request_attributes_proc (default: nil)
+#     A proc to add tags to log entries for each request. The proc, will be
+#     called with the request object and must return a hash of attributes to
+#     include in each log entry for the request.
+#
+#   config.lumberjack.silence_rack_request_started (default: false)
+#     Whether to silence the "Started ..." log lines in Rack::Logger. You may want to silence
+#     this entry if it is just creating noise in your production logs.
+#
+#   config.lumberjack.*
+#     All other options are sent as options to the Lumberjack logger
+#     constructor.
+#
+# Example usage in config/application.rb:
+#   config.log_level = :info
+#   config.lumberjack.attributes = {app: "my_app", host: Lumberjack::Utils.hostname}
+#   config.lumberjack.device = STDOUT  # optional override
+class Lumberjack::Rails::Railtie < ::Rails::Railtie
+  class << self
+    # Create a Lumberjack logger based on Rails configuration.
+    #
+    # @param config [Rails::Application::Configuration] the Rails application configuration
+    # @param log_file_path [String, nil] optional path to the log file
+    # @return [Lumberjack::Logger, nil] the configured logger or nil if not enabled
+    def lumberjack_logger(config, log_file_path = nil)
+      return nil if config.logger
+      return nil if config.lumberjack.nil? || config.lumberjack == false
+      return nil unless config.lumberjack.enabled
+
+      # Determine the log device
+      device = config.lumberjack.device
+      if device.nil?
+        if log_file_path
+          FileUtils.mkdir_p(File.dirname(log_file_path)) unless File.exist?(File.dirname(log_file_path))
+          device = log_file_path
+        else
+          device = $stdout
+        end
+      end
+
+      # Determine the log level
+      level = config.lumberjack.level || config.log_level || :debug
+
+      # Set default attributes
+      attributes = config.lumberjack.attributes
+      if config.log_tags
+        attributes ||= {}
+        attributes["tags"] = config.log_tags
+      end
+
+      shift_age = config.lumberjack.shift_age || 0
+      shift_size = config.lumberjack.shift_size || 1048576
+
+      # Create logger options
+      logger_options = config.lumberjack.to_h.except(
+        :enabled,
+        :raise_logger_errors,
+        :device, :level,
+        :progname,
+        :attributes,
+        :shift_age,
+        :shift_size,
+        :log_rake_tasks,
+        :middleware,
+        :request_attribute,
+        :silence_rack_request_started
+      )
+
+      logger_options.merge!(
+        level: level,
+        formatter: config.lumberjack.formatter,
+        progname: config.lumberjack.progname
+      )
+
+      # Create the Lumberjack logger
+      logger = Lumberjack::Logger.new(device, shift_age, shift_size, **logger_options)
+      logger.tag!(attributes) if attributes
+      logger.formatter.prepend(Lumberjack::Rails.active_record_entry_formatter)
+
+      logger
+    end
+
+    # Redirect standard streams ($stdout, $stderr) to logger instances.
+    #
+    # @param config [Rails::Application::Configuration] the Rails application configuration
+    # @param logger [Lumberjack::Logger] the logger to redirect streams to
+    # @return [void]
+    def set_standard_streams_to_loggers!(config, logger)
+      return unless config.lumberjack&.log_rake_tasks
+      return unless logger.respond_to?(:fork) && logger.respond_to?(:puts)
+
+      if !$stdout.tty? && !$stdout.is_a?(::Logger)
+        stdout_logger = logger.fork
+        stdout_logger.default_severity = :info
+        $stdout = stdout_logger
+      end
+
+      if !$stderr.tty? && !$stderr.is_a?(::Logger)
+        stderr_logger = logger.fork
+        stderr_logger.default_severity = :warn
+        $stderr = stderr_logger
+      end
+    end
+  end
+
+  config.lumberjack = ActiveSupport::OrderedOptions.new
+  config.lumberjack.enabled = true
+  config.lumberjack.log_rake_tasks = false
+  config.lumberjack.template = "[{{time}} {{severity(padded)}} {{progname}} ({{pid}})] {{tags}} {{message}} -- {{attributes}}"
+  config.lumberjack.raise_logger_errors = !(Rails.env.development? || Rails.env.test?)
+
+  initializer "lumberjack.configure_logger", before: :initialize_logger do |app|
+    Lumberjack.raise_logger_errors = app.config.lumberjack.raise_logger_errors
+    Lumberjack::Rails.silence_rack_request_started = app.config.lumberjack.silence_rack_request_started
+
+    logger = Lumberjack::Rails::Railtie.lumberjack_logger(app.config, app.paths["log"]&.first)
+    app.config.logger = logger if logger
+  end
+
+  initializer "lumberjack.insert_middleware" do |app|
+    next unless app.config.lumberjack&.enabled
+
+    app.middleware.unshift(Lumberjack::Rails::ContextMiddleware)
+
+    if app.config.lumberjack.request_attributes_proc
+      app.middleware.use(Lumberjack::Rails::RequestAttributesMiddleware, app.config.lumberjack.request_attributes_proc)
+    end
+  end
+
+  config.after_initialize do
+    # Enhance the :environment task to set standard streams to loggers
+    # This will apply to any rake task that depends on :environment
+    if defined?(Rake::Task) && Rake::Task.task_defined?(:environment)
+      Rake::Task[:environment].enhance do
+        Lumberjack::Rails::Railtie.set_standard_streams_to_loggers!(::Rails.application.config, ::Rails.logger)
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/request_attributes_middleware.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  module Rails
+    # This Rack middleware provides a hook for adding attributes from the request
+    # onto the Rails.logger context so that they will appear on all log entries
+    # for the request.
+    class RequestAttributesMiddleware
+      # @param app [#call] The Rack application.
+      # @param attributes_block [Proc] A block that takes the Rack request and returns
+      #   a hash of attributes to add to the logger context for the request.
+      #   The block will be called with an ActionDispatch::Request object.
+      def initialize(app, attributes_block)
+        unless attributes_block.respond_to?(:call)
+          raise ArgumentError.new("attributes_block must be a Proc or callable object")
+        end
+
+        @app = app
+        @attributes_block = attributes_block
+      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)
+        return @app.call(env) if ::Rails.logger.nil?
+
+        Lumberjack::Rails.logger_context do
+          attributes = @attributes_block.call(ActionDispatch::Request.new(env))
+          if attributes.is_a?(Hash)
+            ::Rails.logger.tag(attributes)
+          elsif !attributes.nil?
+            warn "RequestAttributesMiddleware attributes_block did not return a Hash, got #{attributes.class.name}"
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/tagged_forked_logger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Lumberjack
+  module Rails
+    # Extension for Lumberjack::ForkedLogger to support ActiveSupport tagged logging.
+    #
+    # This module adds tagged logging capabilities to forked loggers by
+    # delegating tagged calls to the parent logger when available.
+    module TaggedForkedLogger
+      # Execute a block with the specified tags if the parent logger supports tagging.
+      #
+      # @param tags [Array] the tags to apply during block execution
+      # @yield the block to execute with the specified tags
+      # @return [Object] the result of the block execution, or nil if parent doesn't support tagging
+      def tagged(*tags, &block)
+        if parent_logger.respond_to?(:tagged)
+          parent_logger.tagged(*tags, &block)
+        end
+      end
+    end
+  end
+end

data/lib/lumberjack/rails/tagged_logging_formatter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lumberjack::Rails
+  # Extension for the Lumberjack::EntryFormatter that adds support for adding the array of
+  # tags added by ActiveSupport::TaggedLogging.
+  #
+  # This module integrates ActiveSupport's tagged logging mechanism with Lumberjack's
+  # entry formatting, ensuring that tags from Rails' tagged logging are properly
+  # included in the formatted log output.
+  module TaggedLoggingFormatter
+    # Format a log message with support for ActiveSupport tagged logging.
+    #
+    # @param message [String] the log message to format
+    # @param tags [Hash, nil] existing tags to include in the formatted output
+    # @return [String] the formatted log message
+    def format(message, tags)
+      tagged_values = current_tags if respond_to?(:current_tags)
+      if tagged_values && !tagged_values.empty?
+        tagged = {"tags" => tagged_values}
+        new_tags = tags.nil? ? tagged : tags.merge(tagged)
+      else
+        new_tags = tags
+      end
+
+      super(message, new_tags)
+    end
+  end
+end

data/lib/lumberjack/rails.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "lumberjack"
+require "active_support"
+
+# Lumberjack is a logging framework for Ruby applications.
+# This gem extends Lumberjack with Rails-specific functionality.
+module Lumberjack
+  # Rails integration for Lumberjack logger.
+  #
+  # This module provides integration between Lumberjack and Rails applications,
+  # enhancing Rails' logging capabilities while maintaining compatibility with
+  # existing Rails logging patterns.
+  module Rails
+    VERSION = ::File.read(::File.join(__dir__, "..", "..", "VERSION")).strip.freeze
+
+    @silence_rack_request_started = false
+    @silenced_log_events = Set.new
+
+    class << self
+      # Safely wrap Rails.logger with a Lumberjack context.
+      #
+      # @param additional_logger [Logger] an optional additional logger to wrap with a context.
+      # @yield [Logger] the block to execute with the wrapped logger context.
+      # @return [Object] the result of the block execution.
+      def logger_context(additional_logger = nil, &block)
+        rails_logger = ::Rails.logger
+        Lumberjack.context do
+          if additional_logger && rails_logger != additional_logger
+            wrap_block_with_logger_context(rails_logger) do
+              wrap_block_with_logger_context(additional_logger, &block)
+            end
+          else
+            wrap_block_with_logger_context(rails_logger, &block)
+          end
+        end
+      end
+
+      # Configuration option to silence "Started ..." log lines in Rack::Logger.
+      #
+      # When set to true, the "Started ..." log lines generated by Rack::Logger
+      # will be suppressed. This can help reduce log noise in applications where
+      # these lines are not needed.
+      #
+      # @param value [Boolean] whether to silence "Started ..." log lines (default: false)
+      # @return [void]
+      def silence_rack_request_started=(value)
+        @silence_rack_request_started = !!value
+      end
+
+      # Returns true if the "Started ..." log lines in Rack::Logger are silenced.
+      #
+      # @return [Boolean] whether to silence "Started ..." log lines (default: false)
+      def silence_rack_request_started?
+        @silence_rack_request_started
+      end
+
+      # EntryFormatter that adds a formatter for ActiveRecord models that outputs
+      # only the type and id.
+      #
+      # @return [Lumberjack::EntryFormatter] the configured entry formatter
+      def active_record_entry_formatter
+        Lumberjack::EntryFormatter.build do |formatter|
+          formatter.format_message("ActiveRecord::Base") { |record| "#{record.class.name}.#{record.id || "new_record"}" }
+          formatter.format_attributes("ActiveRecord::Base", :id)
+        end
+      end
+
+      private
+
+      # Wrap a block with a logger context if the logger supports it.
+      #
+      # @param logger [Logger] the logger to wrap
+      # @yield the block to execute within the logger context
+      # @return [Object] the result of the block execution
+      def wrap_block_with_logger_context(logger, &block)
+        if logger&.respond_to?(:context)
+          logger.context(&block)
+        else
+          block.call
+        end
+      end
+    end
+  end
+end
+
+require_relative "rails/action_cable_extension"
+require_relative "rails/action_controller_extension"
+require_relative "rails/action_controller_log_subscriber_extension"
+require_relative "rails/action_mailbox_extension"
+require_relative "rails/action_mailer_extension"
+require_relative "rails/active_job_extension"
+require_relative "rails/broadcast_logger_extension"
+require_relative "rails/context_middleware"
+require_relative "rails/log_at_level"
+require_relative "rails/log_subscriber_extension"
+require_relative "rails/rack_logger_extension"
+require_relative "rails/request_attributes_middleware"
+require_relative "rails/tagged_forked_logger"
+require_relative "rails/tagged_logging_formatter"
+
+require_relative "rails/apply_patches"
+
+if defined?(::Rails::Railtie)
+  require_relative "rails/railtie"
+end

data/lib/lumberjack_rails.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "lumberjack/rails"

data/lumberjack_rails.gemspec

@@ -0,0 +1,40 @@
+Gem::Specification.new do |spec|
+  spec.name = "lumberjack_rails"
+  spec.version = File.read(File.join(__dir__, "VERSION")).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
+
+  spec.summary = "Support for using the lumberjack logging library in Rails applications."
+  spec.homepage = "https://github.com/bdurand/lumberjack_rails"
+  spec.license = "MIT"
+
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGE_LOG.md"
+  }
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  ignore_files = %w[
+    .gitignore
+    .travis.yml
+    Appraisals
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    gemfiles/
+    spec/
+    test_app/
+  ]
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 3.0"
+
+  spec.add_dependency "lumberjack", ">=2.0"
+  spec.add_dependency "activesupport", ">= 7.1"
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: lumberjack_rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Durand
+bindir: bin
+cert_chain: []
+date: 2025-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lumberjack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+email:
+- bbdurand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/dependabot.yml"
+- ".github/workflows/continuous_integration.yml"
+- ".standard.yml"
+- ".yardopts"
+- CHANGE_LOG.md
+- MIT_LICENSE.txt
+- README.md
+- VERSION
+- lib/lumberjack/rails.rb
+- lib/lumberjack/rails/action_cable_extension.rb
+- lib/lumberjack/rails/action_controller_extension.rb
+- lib/lumberjack/rails/action_controller_log_subscriber_extension.rb
+- lib/lumberjack/rails/action_mailbox_extension.rb
+- lib/lumberjack/rails/action_mailer_extension.rb
+- lib/lumberjack/rails/active_job_extension.rb
+- lib/lumberjack/rails/apply_patches.rb
+- lib/lumberjack/rails/broadcast_logger_extension.rb
+- lib/lumberjack/rails/context_middleware.rb
+- lib/lumberjack/rails/log_at_level.rb
+- lib/lumberjack/rails/log_subscriber_extension.rb
+- lib/lumberjack/rails/rack_logger_extension.rb
+- lib/lumberjack/rails/railtie.rb
+- lib/lumberjack/rails/request_attributes_middleware.rb
+- lib/lumberjack/rails/tagged_forked_logger.rb
+- lib/lumberjack/rails/tagged_logging_formatter.rb
+- lib/lumberjack_rails.rb
+- lumberjack_rails.gemspec
+homepage: https://github.com/bdurand/lumberjack_rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/bdurand/lumberjack_rails
+  source_code_uri: https://github.com/bdurand/lumberjack_rails
+  changelog_uri: https://github.com/bdurand/lumberjack_rails/blob/main/CHANGE_LOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Support for using the lumberjack logging library in Rails applications.
+test_files: []