logstruct 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b926657fc690c72031cf72973642c3654264b3ea348f2212a625788b62d1ade
-  data.tar.gz: 650b11e3b8b3e975feee474994ae9420b68da2eb933942f28cc495649d71f225
+  metadata.gz: 77b4f5cd95c84bd5b418bb95b1856af146e70a64e6d39e3a303e33e083faa64d
+  data.tar.gz: 670c515b7eb8fbe5320c3bc52e2a68234aff31f8633fc071286a1b4a816132b6
 SHA512:
-  metadata.gz: 2e0339abeafbea5bf239799dcf1ca843f57aae004e356e407a18909d9c0b6e4d1302c897f358be7bf539b5e0534efd032319a0b3055ff29e169c1d3f22557193
-  data.tar.gz: de385bc25a32f189044fbf1749e4511c1f9411d37a9af8628fc655e9706daba1a6b94b9482de756ef12557cc497deffa6f49a39ab9b434b3be6e25c7cb402214
+  metadata.gz: f7b81a7d6893f7db9b51c71d5623beedfa75d81e5c9c1ec51003db37a5873018427e81a86aaa2de3a73741cb372bea2d859980b96695592ee9249ea0def0fe9d
+  data.tar.gz: e8fd117ec5795acebba1a996d2777f25f2ac89afdbb4fa76cb18ec1faa5fea11800b9cf452178412eb0fabe77ca4bcc223dd516d53b1217031f7433361bdc41c

data/CHANGELOG.md

@@ -5,6 +5,23 @@ 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).
 
+## [0.1.3] - 2025-10-11
+
+### Changed
+
+- **Fix**: Changed storage, queue name, and format fields from `String` to `Symbol` type to match Rails conventions
+  - Affected log types: ActiveStorage, CarrierWave, Shrine (storage field), ActiveJob, GoodJob (queue_name field), Request (format field)
+- JSON logging now enabled for all test runs (both local and CI) to ensure tests catch production bugs
+  - Previously only enabled for CI test runs, now always enabled in test environment
+  - This ensures local tests match CI behavior and catch serialization issues early
+- Fixed host authorization app
+
+## [0.1.2] - 2025-10-03
+
+Better default policy for when JSON logs are enabled: machines get JSON, humans get readable logs.
+Enable LogStruct for production servers and test runs (both local and CI) to ensure tests catch production bugs.
+Keep dev-friendly logging on local machines or when running interactive commands on production servers.
+
 ## [0.1.1] - 2025-09-29
 
 Added dotenv-rails integration. Many other fixes and improvements.

data/README.md

@@ -1,12 +1,12 @@
 # LogStruct
 
-Adds JSON structured logging to any Rails app. Simply add the gem to your Gemfile and add an initializer to configure it. By default, your Rails app prints JSON logs to STDOUT (or to the configured destination when `RAILS_LOG_TO_STDOUT` is set). They're easy to search and filter, you can turn them into metrics and alerts, and they're great for building dashboards in CloudWatch, Grafana, or Datadog.
+Adds secure JSON structured logging to any Rails app (>= 7.1). Simply add the gem to your Gemfile and add an initializer to configure it. By default, your Rails app prints JSON logs to STDOUT (or to the configured destination when `RAILS_LOG_TO_STDOUT` is set). They're easy to search and filter, you can turn them into metrics and alerts, and they're great for building dashboards in CloudWatch, Grafana, or Datadog.
 
 We support all your other favorite gems too, like Sidekiq, Sentry, and Shrine. (And if not, please open a PR!)
 
 ## Features
 
-- JSON logging enabled by default in production and test environments
+- JSON logging enabled by default for server processes in production and test environments (automatically disabled for console and other Rake tasks)
 - ActionMailer integration for email delivery logging
 - ActiveJob integration for job execution logging
 - Sidekiq integration for background job logging
@@ -17,7 +17,6 @@ We support all your other favorite gems too, like Sidekiq, Sentry, and Shrine. (
 - Sensitive data scrubbing for strings (inspired by the Logstop gem)
 - Host authorization logging for security violations
 - Rack middleware for enhanced error logging
-- ActionMailer delivery callbacks for Rails 7.0.x (backported from Rails 7.1)
 - Type checking with Sorbet and RBS annotations
 
 ## Installation
@@ -58,11 +57,15 @@ Once initialized (and enabled), the gem automatically includes its modules into
 - Rails `config.filter_parameters` are merged into LogStruct's filters and then cleared (to avoid double filtering). Configure sensitive keys via `LogStruct.config.filters`.
 - When `RAILS_LOG_TO_STDOUT` is set, we log to STDOUT only. Otherwise, we log to STDOUT by default without adding a file appender to avoid duplicate logs.
 
-### Development behavior
+### Default behavior by process type
 
-- Disabled by default in development. Enable explicitly via `LOGSTRUCT_ENABLED=true` or `LogStruct.configure { |c| c.enabled = true }`.
-- When enabled in development, LogStruct now defaults to production‑style JSON output so you can preview exactly what will be shipped in prod.
-- You can opt back into the colorful human formatter with:
+- **Server processes** (`rails server`): JSON logging is enabled by default in production and test environments
+- **Test runs** (`rails test`): JSON logging is enabled by default in test environment to ensure tests catch production bugs
+- **Console** (`rails console`): JSON logging is disabled by default in all environments, providing human-readable logs instead
+- **Other Rake tasks** (`rake db:migrate`, etc.): JSON logging is disabled by default in production, providing human-readable logs instead
+- **Development environment**: Disabled by default for all process types. Enable explicitly via `LOGSTRUCT_ENABLED=true` or `LogStruct.configure { |c| c.enabled = true }`.
+
+When enabled in development, LogStruct defaults to production‑style JSON output so you can preview exactly what will be shipped in prod. You can opt back into the colorful human formatter with:
 
 ```ruby
 LogStruct.configure do |c|
@@ -71,6 +74,8 @@ LogStruct.configure do |c|
 end
 ```
 
+To force JSON logs in console or other Rake tasks (e.g., for debugging), set `LOGSTRUCT_ENABLED=true` in your environment.
+
 ## Documentation
 
 Please see the [documentation](https://logstruct.com/docs) for more details. (All code examples are type-checked and tested, and it's harder to keep a README up to date.)

data/lib/log_struct/concerns/configuration.rb

@@ -10,6 +10,11 @@ module LogStruct
       module ClassMethods
         extend T::Sig
 
+        SERVER_COMMAND_ARGS = T.let(["server", "s"].freeze, T::Array[String])
+        CONSOLE_COMMAND_ARGS = T.let(["console", "c"].freeze, T::Array[String])
+        EMPTY_ARGV = T.let([].freeze, T::Array[String])
+        CI_FALSE_VALUES = T.let(["false", "0", "no"].freeze, T::Array[String])
+
         sig { params(block: T.proc.params(config: LogStruct::Configuration).void).void }
         def configure(&block)
           yield(config)
@@ -45,14 +50,20 @@ module LogStruct
           #    - Sets enabled=true only when value is "true", "yes", "1", etc.
           #    - Sets enabled=false when value is any other value
           # 2. Otherwise, check if current Rails environment is in enabled_environments
+          #    AND one of: Rails::Server is defined, OR test environment with CI=true
+          #    BUT NOT Rails::Console (to exclude interactive console)
           # 3. Otherwise, leave as config.enabled (defaults to true)
 
           # Then check if LOGSTRUCT_ENABLED env var is set
           config.enabled = if ENV["LOGSTRUCT_ENABLED"]
-            # Override to true only if env var is "true"
             %w[true t yes y 1].include?(ENV["LOGSTRUCT_ENABLED"]&.strip&.downcase)
           else
-            config.enabled_environments.include?(::Rails.env.to_sym)
+            is_console = console_process?
+            is_server = server_process?
+            ci_build?
+            in_enabled_env = config.enabled_environments.include?(::Rails.env.to_sym)
+
+            in_enabled_env && !is_console && (is_server || ::Rails.env.test?)
           end
         end
 
@@ -112,6 +123,45 @@ module LogStruct
 
         private
 
+        sig { returns(T::Boolean) }
+        def console_process?
+          return true if defined?(::Rails::Console)
+
+          current_argv.any? { |arg| CONSOLE_COMMAND_ARGS.include?(arg) }
+        end
+
+        sig { returns(T::Boolean) }
+        def server_process?
+          return true if logstruct_server_mode?
+
+          current_argv.any? { |arg| SERVER_COMMAND_ARGS.include?(arg) }
+        end
+
+        sig { returns(T::Boolean) }
+        def logstruct_server_mode?
+          ::LogStruct.server_mode?
+        end
+
+        sig { returns(T::Array[String]) }
+        def current_argv
+          raw = ::ARGV
+          strings = raw.map { |arg| arg.to_s }
+          T.let(strings, T::Array[String])
+        rescue NameError
+          EMPTY_ARGV
+        end
+
+        sig { returns(T::Boolean) }
+        def ci_build?
+          value = ENV["CI"]
+          return false if value.nil?
+
+          normalized = value.strip.downcase
+          return false if normalized.empty?
+
+          !CI_FALSE_VALUES.include?(normalized)
+        end
+
         sig { params(filter: T.untyped).returns(T.nilable(Symbol)) }
         def normalize_filter_symbol(filter)
           return filter if filter.is_a?(Symbol)

data/lib/log_struct/config_struct/integrations.rb

@@ -24,6 +24,11 @@ module LogStruct
       # Default: true
       prop :enable_actionmailer, T::Boolean, default: true
 
+      # Map instance variables on mailer to ID fields in additional_data
+      # Default: { account: :account_id, user: :user_id }
+      # Example: { organization: :org_id, company: :company_id }
+      prop :actionmailer_id_mapping, T::Hash[Symbol, Symbol], factory: -> { {account: :account_id, user: :user_id} }
+
       # Enable or disable host authorization logging
       # Default: true
       prop :enable_host_authorization, T::Boolean, default: true

data/lib/log_struct/enums/log_field.rb

@@ -47,6 +47,8 @@ module LogStruct
       # Security-specific fields
       BlockedHost = new(:blocked_host)
       BlockedHosts = new(:blocked_hosts)
+      AllowedHosts = new(:allowed_hosts)
+      AllowIpHosts = new(:allow_ip_hosts)
       ClientIp = new(:client_ip)
       XForwardedFor = new(:x_forwarded_for)
 
@@ -54,9 +56,13 @@ module LogStruct
       To = new(:to)
       From = new(:from)
       Subject = new(:subject)
+      MessageId = new(:msg_id)
+      MailerClass = new(:mailer)
+      MailerAction = new(:mailer_action)
+      AttachmentCount = new(:attachments)
 
       # Error fields
-      ErrClass = new(:err_class)
+      ErrorClass = new(:error_class)
       Backtrace = new(:backtrace)
 
       # Job-specific fields
@@ -82,6 +88,8 @@ module LogStruct
       Priority = new(:priority)
       CronKey = new(:cron_key)
       ErrorMessage = new(:error_message)
+      Result = new(:result)
+      EnqueueCaller = new(:enqueue_caller)
 
       # Dotenv fields
       File = new(:file)
@@ -117,6 +125,9 @@ module LogStruct
       # CarrierWave-specific fields
       Model = new(:model)
       MountPoint = new(:mount_point)
+      Version = new(:version)
+      StorePath = new(:store_path)
+      Extension = new(:ext)
 
       # SQL-specific fields
       Sql = new(:sql)

data/lib/log_struct/integrations/action_mailer/error_handling.rb

@@ -15,6 +15,9 @@ module LogStruct
         extend T::Sig
         extend ActiveSupport::Concern
 
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :logstruct_mail_failed
+
         # NOTE: rescue_from handlers are checked in reverse order of declaration.
         # We want LogStruct handlers to be checked AFTER user handlers (lower priority),
         # so we need to add them BEFORE user handlers are declared.
@@ -47,6 +50,7 @@ module LogStruct
         # Just log the error without reporting or retrying
         sig { params(ex: StandardError).void }
         def log_and_ignore_error(ex)
+          self.logstruct_mail_failed = true
           log_email_delivery_error(ex, notify: false, report: false, reraise: false)
         end
 
@@ -67,20 +71,54 @@ module LogStruct
         # Handle an error from a mailer
         sig { params(mailer: T.untyped, error: StandardError, message: String).void }
         def log_structured_error(mailer, error, message)
-          # Create a structured exception log with context
-          context = {
-            mailer_class: mailer.class.to_s,
-            mailer_action: mailer.respond_to?(:action_name) ? mailer.action_name : nil,
-            message: message
-          }
+          # Get message if available
+          mailer_message = mailer.respond_to?(:message) ? mailer.message : nil
+
+          # Prepare universal mailer fields
+          message_data = {}
+          MetadataCollection.add_message_metadata(mailer, message_data)
+
+          # Prepare app-specific context data for additional_data
+          context_data = {}
+          MetadataCollection.add_context_metadata(mailer, context_data)
 
-          # Create the structured exception log
-          exception_data = Log.from_exception(Source::Mailer, error, context)
+          # Extract email fields
+          to = mailer_message&.to
+          from = mailer_message&.from&.first
+          subject = mailer_message&.subject
+          message_id = extract_message_id_from_mailer(mailer)
+
+          # Create ActionMailer-specific error struct
+          exception_data = Log::ActionMailer::Error.new(
+            to: to,
+            from: from,
+            subject: subject,
+            message_id: message_id,
+            mailer_class: mailer.class.to_s,
+            mailer_action: mailer.respond_to?(:action_name) ? mailer.action_name&.to_s : nil,
+            attachment_count: message_data[:attachment_count],
+            error_class: error.class,
+            message: message,
+            backtrace: error.backtrace,
+            additional_data: context_data.presence,
+            timestamp: Time.now
+          )
 
           # Log the structured error
           LogStruct.error(exception_data)
         end
 
+        # Extract message ID from the mailer
+        sig { params(mailer: T.untyped).returns(T.nilable(String)) }
+        def extract_message_id_from_mailer(mailer)
+          return nil unless mailer.respond_to?(:message)
+
+          mail_message = mailer.message
+          return nil unless mail_message.respond_to?(:message_id)
+
+          mail_message.message_id
+        end
+
         # Log when email delivery fails
         sig { params(error: StandardError, notify: T::Boolean, report: T::Boolean, reraise: T::Boolean).void }
         def log_email_delivery_error(error, notify: false, report: true, reraise: true)
@@ -98,9 +136,9 @@ module LogStruct
         sig { params(error: StandardError, reraise: T::Boolean).returns(String) }
         def error_message_for(error, reraise)
           if reraise
-            "#{error.class}: Email delivery error, will retry. Recipients: #{recipients(error)}"
+            "#{error.class}: Email delivery error, will retry. Recipients: #{recipients(error)}. Error message: #{error.message}"
           else
-            "#{error.class}: Cannot send email to #{recipients(error)}"
+            "#{error.class}: Cannot send email to #{recipients(error)}. Error message: #{error.message}"
           end
         end
 
@@ -112,19 +150,48 @@ module LogStruct
 
           # Report to error reporting service if requested
           if report
-            context = {
-              mailer_class: self.class.to_s,
-              mailer_action: respond_to?(:action_name) ? action_name : nil,
-              recipients: recipients(error)
-            }
+            # Get message if available
+            mailer_message = respond_to?(:message) ? message : nil
 
-            # Create an exception log for structured logging
-            exception_data = Log.from_exception(Source::Mailer, error, context)
+            # Prepare universal mailer fields
+            message_data = {}
+            MetadataCollection.add_message_metadata(self, message_data)
+
+            # Prepare app-specific context data
+            context_data = {recipients: recipients(error)}
+            MetadataCollection.add_context_metadata(self, context_data)
+
+            # Extract email fields
+            to = mailer_message&.to
+            from = mailer_message&.from&.first
+            subject = mailer_message&.subject
+            message_id = extract_message_id_from_mailer(self)
+
+            # Create ActionMailer-specific error struct
+            exception_data = Log::ActionMailer::Error.new(
+              to: to,
+              from: from,
+              subject: subject,
+              message_id: message_id,
+              mailer_class: self.class.to_s,
+              mailer_action: respond_to?(:action_name) ? action_name&.to_s : nil,
+              attachment_count: message_data[:attachment_count],
+              error_class: error.class,
+              message: error.message,
+              backtrace: error.backtrace,
+              additional_data: context_data.presence,
+              timestamp: Time.now
+            )
 
             # Log the exception with structured data
             LogStruct.error(exception_data)
 
-            # Call the error handler
+            # Call the error handler with flat context for compatibility
+            context = {
+              mailer_class: self.class.to_s,
+              mailer_action: respond_to?(:action_name) ? action_name : nil,
+              recipients: recipients(error)
+            }
             LogStruct.handle_exception(error, source: Source::Mailer, context: context)
           end
 
@@ -135,15 +202,42 @@ module LogStruct
         # Log a notification event that can be picked up by external systems
         sig { params(error: StandardError).void }
         def log_notification_event(error)
-          # Create an error log data object
-          exception_data = Log.from_exception(
-            Source::Mailer,
-            error,
-            {
-              mailer: self.class,
-              action: action_name,
-              recipients: recipients(error)
-            }
+          # Get message if available
+          mailer_message = respond_to?(:message) ? message : nil
+
+          # Prepare universal mailer fields
+          message_data = {}
+          MetadataCollection.add_message_metadata(self, message_data)
+
+          # Prepare app-specific context data
+          context_data = {
+            mailer: self.class.to_s,
+            action: action_name&.to_s,
+            recipients: recipients(error)
+          }
+          MetadataCollection.add_context_metadata(self, context_data)
+
+          # Extract email fields
+          to = mailer_message&.to
+          from = mailer_message&.from&.first
+          subject = mailer_message&.subject
+          message_id = extract_message_id_from_mailer(self)
+
+          # Create ActionMailer-specific error struct
+          exception_data = Log::ActionMailer::Error.new(
+            to: to,
+            from: from,
+            subject: subject,
+            message_id: message_id,
+            mailer_class: self.class.to_s,
+            mailer_action: respond_to?(:action_name) ? action_name&.to_s : nil,
+            attachment_count: message_data[:attachment_count],
+            error_class: error.class,
+            message: error.message,
+            backtrace: error.backtrace,
+            additional_data: context_data.presence,
+            timestamp: Time.now,
+            level: Level::Info
           )
 
           # Log the error at info level since it's not a critical error

data/lib/log_struct/integrations/action_mailer/event_logging.rb

@@ -10,15 +10,27 @@ module LogStruct
         extend T::Sig
         extend T::Helpers
         requires_ancestor { ::ActionMailer::Base }
+        requires_ancestor { ErrorHandling }
 
         included do
-          T.bind(self, ActionMailer::Callbacks::ClassMethods)
+          T.bind(self, T.class_of(::ActionMailer::Base))
 
           # Add callbacks for delivery events
           before_deliver :log_email_delivery
           after_deliver :log_email_delivered
         end
 
+        # When this module is prepended (our integration uses prepend), ensure callbacks are registered
+        if respond_to?(:prepended)
+          prepended do
+            T.bind(self, T.class_of(::ActionMailer::Base))
+
+            # Add callbacks for delivery events
+            before_deliver :log_email_delivery
+            after_deliver :log_email_delivered
+          end
+        end
+
         protected
 
         # Log when an email is about to be delivered
@@ -30,6 +42,9 @@ module LogStruct
         # Log when an email is delivered
         sig { void }
         def log_email_delivered
+          # Don't log delivered event if the delivery failed (error was handled with log_and_ignore_error)
+          return if logstruct_mail_failed
+
           log_mailer_event(Event::Delivered)
         end
 
@@ -41,17 +56,14 @@ module LogStruct
           # Get message (self refers to the mailer instance)
           mailer_message = message if respond_to?(:message)
 
-          # Prepare data for the log entry
-          data = {
-            message_id: extract_message_id,
-            mailer_class: self.class.to_s,
-            mailer_action: action_name.to_s
-          }.compact
+          # Prepare universal mailer fields
+          message_data = {}
+          MetadataCollection.add_message_metadata(self, message_data)
 
-          # Add any additional metadata
-          MetadataCollection.add_message_metadata(self, data)
-          MetadataCollection.add_context_metadata(self, data)
-          data.merge!(additional_data) if additional_data.present?
+          # Prepare app-specific context data for additional_data
+          context_data = {}
+          MetadataCollection.add_context_metadata(self, context_data)
+          context_data.merge!(additional_data) if additional_data.present?
 
           # Extract email fields (these will be filtered if email_addresses=true)
           to = mailer_message&.to
@@ -61,20 +73,24 @@ module LogStruct
           base_fields = Log::ActionMailer::BaseFields.new(
             to: to,
             from: from,
-            subject: subject
+            subject: subject,
+            message_id: extract_message_id,
+            mailer_class: self.class.to_s,
+            mailer_action: action_name.to_s,
+            attachment_count: message_data[:attachment_count]
           )
 
           log = case event_type
           when Event::Delivery
             Log::ActionMailer::Delivery.new(
               **base_fields.to_kwargs,
-              additional_data: data,
+              additional_data: context_data.presence,
               timestamp: Time.now
             )
           when Event::Delivered
             Log::ActionMailer::Delivered.new(
               **base_fields.to_kwargs,
-              additional_data: data,
+              additional_data: context_data.presence,
               timestamp: Time.now
             )
           else

data/lib/log_struct/integrations/action_mailer/metadata_collection.rb

@@ -12,18 +12,11 @@ module LogStruct
         def self.add_message_metadata(mailer, log_data)
           message = mailer.respond_to?(:message) ? mailer.message : nil
 
-          # Add recipient count if message is available
-          if message
-            # Don't log actual email addresses
-            log_data[:recipient_count] = [message.to, message.cc, message.bcc].flatten.compact.count
-
-            # Handle case when attachments might be nil
-            log_data[:has_attachments] = message.attachments&.any? || false
-            log_data[:attachment_count] = message.attachments&.count || 0
+          # Add attachment count if message is available
+          log_data[:attachment_count] = if message
+            message.attachments&.count || 0
           else
-            log_data[:recipient_count] = 0
-            log_data[:has_attachments] = false
-            log_data[:attachment_count] = 0
+            0
           end
         end
 
@@ -39,26 +32,27 @@ module LogStruct
 
         sig { params(mailer: T.untyped, log_data: T::Hash[Symbol, T.untyped]).void }
         def self.extract_ids_to_log_data(mailer, log_data)
-          # Extract account ID if available
-          if mailer.instance_variable_defined?(:@account)
-            account = mailer.instance_variable_get(:@account)
-            log_data[:account_id] = account.id if account.respond_to?(:id)
-          end
+          # Use configured ID mapping from LogStruct configuration
+          id_mapping = LogStruct.config.integrations.actionmailer_id_mapping
 
-          # Extract user ID if available
-          return unless mailer.instance_variable_defined?(:@user)
+          id_mapping.each do |ivar_name, log_key|
+            ivar = :"@#{ivar_name}"
+            next unless mailer.instance_variable_defined?(ivar)
 
-          user = mailer.instance_variable_get(:@user)
-          log_data[:user_id] = user.id if user.respond_to?(:id)
+            obj = mailer.instance_variable_get(ivar)
+            log_data[log_key] = obj.id if obj.respond_to?(:id)
+          end
         end
 
         sig { params(log_data: T::Hash[Symbol, T.untyped]).void }
         def self.add_current_tags_to_log_data(log_data)
-          # Get current tags from ActiveSupport::TaggedLogging if available
-          if ::ActiveSupport::TaggedLogging.respond_to?(:current_tags)
-            tags = T.unsafe(::ActiveSupport::TaggedLogging).current_tags
-            log_data[:tags] = tags if tags.present?
+          # Get current tags from thread-local storage or ActiveSupport::TaggedLogging
+          tags = if ::ActiveSupport::TaggedLogging.respond_to?(:current_tags)
+            T.unsafe(::ActiveSupport::TaggedLogging).current_tags
+          else
+            Thread.current[:activesupport_tagged_logging_tags] || []
           end
+          log_data[:tags] = tags if tags.present?
 
           # Get request_id from ActionDispatch if available
           if ::ActionDispatch::Request.respond_to?(:current_request_id) &&

data/lib/log_struct/integrations/action_mailer.rb

@@ -12,7 +12,6 @@ if defined?(::ActionMailer)
   require_relative "action_mailer/metadata_collection"
   require_relative "action_mailer/event_logging"
   require_relative "action_mailer/error_handling"
-  require_relative "action_mailer/callbacks"
 end
 
 module LogStruct
@@ -37,11 +36,19 @@ module LogStruct
 
         # Register our custom observers and handlers
         # Registering these at the class level means all mailers will use them
-        ActiveSupport.on_load(:action_mailer) { prepend LogStruct::Integrations::ActionMailer::MetadataCollection }
-        ActiveSupport.on_load(:action_mailer) { prepend LogStruct::Integrations::ActionMailer::EventLogging }
-        ActiveSupport.on_load(:action_mailer) { prepend LogStruct::Integrations::ActionMailer::ErrorHandling }
-        ActiveSupport.on_load(:action_mailer) { prepend LogStruct::Integrations::ActionMailer::Callbacks }
-        ActiveSupport.on_load(:action_mailer) { LogStruct::Integrations::ActionMailer::Callbacks.patch_message_delivery }
+        ActiveSupport.on_load(:action_mailer) do
+          prepend LogStruct::Integrations::ActionMailer::EventLogging
+          prepend LogStruct::Integrations::ActionMailer::ErrorHandling
+          prepend LogStruct::Integrations::ActionMailer::MetadataCollection
+        end
+
+        # If ActionMailer::Base is already loaded, the on_load hooks won't run
+        # So we need to apply the modules directly
+        if defined?(::ActionMailer::Base)
+          ::ActionMailer::Base.prepend(LogStruct::Integrations::ActionMailer::EventLogging)
+          ::ActionMailer::Base.prepend(LogStruct::Integrations::ActionMailer::ErrorHandling)
+          ::ActionMailer::Base.prepend(LogStruct::Integrations::ActionMailer::MetadataCollection)
+        end
 
         true
       end

data/lib/log_struct/integrations/active_job/log_subscriber.rb

@@ -81,7 +81,7 @@ module LogStruct
           Log::ActiveJob::BaseFields.new(
             job_id: job.job_id,
             job_class: job.class.to_s,
-            queue_name: job.queue_name,
+            queue_name: job.queue_name&.to_sym,
             executions: job.executions,
             provider_job_id: job.provider_job_id,
             arguments: ((job.class.respond_to?(:log_arguments?) && job.class.log_arguments?) ? job.arguments : nil)
@@ -98,7 +98,7 @@ module LogStruct
           logger.error(log_data)
         end
 
-        sig { returns(::ActiveSupport::Logger) }
+        sig { returns(T.untyped) }
         def logger
           ::ActiveJob::Base.logger
         end