Add GoodJob integration for structured job logging

Implements comprehensive GoodJob integration providing structured logging for PostgreSQL-based ActiveJob backend operations.

Features:
- LogStruct::Log::GoodJob class with full job metadata support
- Custom Logger extending SemanticLogger for high-performance logging
- LogSubscriber for capturing ActiveSupport notifications
- Automatic job context extraction from thread-local variables
- Performance metrics tracking (wait_time, run_time, execution_time)
- Error tracking with backtrace support
- Support for GoodJob-specific features (batches, cron, priorities)

Architecture improvements:
- Updated IntegrationInterface to return T.nilable(T::Boolean)
- Added level field to CommonFields interface
- Fixed all integration setup methods for consistent return types
- Added private_class_method declarations for proper encapsulation

Includes comprehensive test coverage for all components.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ndbroadbent

lib/log_struct/config_struct/integrations.rb

@@ -52,6 +52,10 @@ class Integrations < T::Struct
       # Default: true
       prop :enable_carrierwave, T::Boolean, default: true
 
+      # Enable or disable GoodJob integration
+      # Default: true
+      prop :enable_goodjob, T::Boolean, default: true
+
       # Enable SemanticLogger integration for high-performance logging
       # Default: true
       prop :enable_semantic_logger, T::Boolean, default: true

lib/log_struct/formatter.rb

@@ -76,8 +76,8 @@ def process_values(arg, recursion_depth: 0)
       when Array
         result = arg.map { |value| process_values(value, recursion_depth: recursion_depth + 1) }
 
-        # Filter large arrays
-        if result.size > 10
+        # Filter large arrays, but don't truncate backtraces (arrays of strings that look like file:line)
+        if result.size > 10 && !looks_like_backtrace?(result)
           result = result.take(10) + ["... and #{result.size - 10} more items"]
         end
         result
@@ -205,5 +205,19 @@ def call(severity, time, progname, log_value)
     def generate_json(data)
       "#{data.to_json}\n"
     end
+
+    # Check if an array looks like a backtrace (array of strings with file:line pattern)
+    sig { params(array: T::Array[T.untyped]).returns(T::Boolean) }
+    def looks_like_backtrace?(array)
+      return false if array.empty?
+      
+      # Check if most elements look like backtrace lines (file.rb:123 or similar patterns)
+      backtrace_like_count = array.first(5).count do |element|
+        element.is_a?(String) && element.match?(/\A[^:\s]+:\d+/)
+      end
+      
+      # If at least 3 out of the first 5 elements look like backtrace lines, treat as backtrace
+      backtrace_like_count >= 3
+    end
   end
 end

lib/log_struct/integrations.rb

@@ -9,6 +9,7 @@
 require_relative "integrations/lograge"
 require_relative "integrations/shrine"
 require_relative "integrations/sidekiq"
+require_relative "integrations/good_job"
 require_relative "integrations/active_storage"
 require_relative "integrations/carrierwave"
 require_relative "integrations/sorbet"
@@ -26,6 +27,7 @@ def self.setup_integrations
       Integrations::ActionMailer.setup(config) if config.integrations.enable_actionmailer
       Integrations::ActiveJob.setup(config) if config.integrations.enable_activejob
       Integrations::Sidekiq.setup(config) if config.integrations.enable_sidekiq
+      Integrations::GoodJob.setup(config) if config.integrations.enable_goodjob
       Integrations::HostAuthorization.setup(config) if config.integrations.enable_host_authorization
       Integrations::RackErrorHandler.setup(config) if config.integrations.enable_rack_error_handler
       Integrations::Shrine.setup(config) if config.integrations.enable_shrine

lib/log_struct/integrations/action_mailer.rb

@@ -23,11 +23,11 @@ module ActionMailer
       extend IntegrationInterface
 
       # Set up ActionMailer structured logging
-      sig { override.params(config: LogStruct::Configuration).void }
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
-        return unless defined?(::ActionMailer)
-        return unless config.enabled
-        return unless config.integrations.enable_actionmailer
+        return nil unless defined?(::ActionMailer)
+        return nil unless config.enabled
+        return nil unless config.integrations.enable_actionmailer
 
         # Silence default ActionMailer logs (we use our own structured logging)
         # This is required because we replace the logging using our own callbacks
@@ -41,6 +41,8 @@ def self.setup(config)
         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 }
+
+        true
       end
     end
   end

lib/log_struct/integrations/active_job.rb

@@ -18,11 +18,11 @@ module ActiveJob
       extend IntegrationInterface
 
       # Set up ActiveJob structured logging
-      sig { override.params(config: LogStruct::Configuration).void }
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
-        return unless defined?(::ActiveJob::LogSubscriber)
-        return unless config.enabled
-        return unless config.integrations.enable_activejob
+        return nil unless defined?(::ActiveJob::LogSubscriber)
+        return nil unless config.enabled
+        return nil unless config.integrations.enable_activejob
 
         ::ActiveSupport.on_load(:active_job) do
           # Detach the default text formatter
@@ -31,6 +31,7 @@ def self.setup(config)
           # Attach our structured formatter
           Integrations::ActiveJob::LogSubscriber.attach_to :active_job
         end
+        true
       end
     end
   end

lib/log_struct/integrations/active_storage.rb

@@ -13,16 +13,18 @@ module ActiveStorage
       extend IntegrationInterface
 
       # Set up ActiveStorage structured logging
-      sig { override.params(config: LogStruct::Configuration).void }
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
-        return unless defined?(::ActiveStorage)
-        return unless config.enabled
-        return unless config.integrations.enable_activestorage
+        return nil unless defined?(::ActiveStorage)
+        return nil unless config.enabled
+        return nil unless config.integrations.enable_activestorage
 
         # Subscribe to all ActiveStorage service events
         ::ActiveSupport::Notifications.subscribe(/service_.*\.active_storage/) do |*args|
           process_active_storage_event(::ActiveSupport::Notifications::Event.new(*args), config)
         end
+
+        true
       end
 
       private_class_method

lib/log_struct/integrations/carrierwave.rb

@@ -15,14 +15,16 @@ module CarrierWave
       extend IntegrationInterface
 
       # Set up CarrierWave structured logging
-      sig { override.params(config: LogStruct::Configuration).void }
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
-        return unless defined?(::CarrierWave)
-        return unless config.enabled
-        return unless config.integrations.enable_carrierwave
+        return nil unless defined?(::CarrierWave)
+        return nil unless config.enabled
+        return nil unless config.integrations.enable_carrierwave
 
         # Patch CarrierWave to add logging
         ::CarrierWave::Uploader::Base.prepend(LoggingMethods)
+
+        true
       end
 
       # Methods to add logging to CarrierWave operations

lib/log_struct/integrations/good_job.rb

@@ -0,0 +1,111 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "good_job"
+rescue LoadError
+  # GoodJob gem is not available, integration will be skipped
+end
+
+require_relative "good_job/logger" if defined?(::GoodJob)
+require_relative "good_job/log_subscriber" if defined?(::GoodJob)
+
+module LogStruct
+  module Integrations
+    # GoodJob integration for structured logging
+    #
+    # GoodJob is a PostgreSQL-based ActiveJob backend that provides reliable,
+    # scalable job processing for Rails applications. This integration provides
+    # structured logging for all GoodJob operations.
+    #
+    # ## Features:
+    # - Structured logging for job execution lifecycle
+    # - Error tracking and retry logging
+    # - Performance metrics and timing data
+    # - Database operation logging
+    # - Thread and process tracking
+    # - Custom GoodJob logger with LogStruct formatting
+    #
+    # ## Integration Points:
+    # - Replaces GoodJob.logger with LogStruct-compatible logger
+    # - Subscribes to GoodJob's ActiveSupport notifications
+    # - Captures job execution events, errors, and performance metrics
+    # - Logs database operations and connection information
+    #
+    # ## Configuration:
+    # The integration is automatically enabled when GoodJob is detected and
+    # LogStruct configuration allows it. It can be disabled by setting:
+    # 
+    # ```ruby
+    # config.integrations.enable_goodjob = false
+    # ```
+    module GoodJob
+      extend T::Sig
+      extend IntegrationInterface
+
+      # Set up GoodJob structured logging
+      # 
+      # This method configures GoodJob to use LogStruct's structured logging
+      # by replacing the default logger and subscribing to job events.
+      #
+      # @param config [LogStruct::Configuration] The LogStruct configuration
+      # @return [Boolean, nil] Returns true if setup was successful, nil if skipped
+      sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
+      def self.setup(config)
+        return nil unless defined?(::GoodJob)
+        return nil unless config.enabled
+        return nil unless config.integrations.enable_goodjob
+
+        # Replace GoodJob's logger with our structured logger
+        configure_logger
+
+        # Subscribe to GoodJob's ActiveSupport notifications
+        subscribe_to_notifications
+
+        true
+      end
+
+      # Configure GoodJob to use LogStruct's structured logger
+      sig { void }
+      def self.configure_logger
+        return unless defined?(::GoodJob)
+
+        # Use T.unsafe to avoid Sorbet errors with external constants
+        goodjob_module = T.unsafe(Object.const_get("GoodJob"))
+
+        # Replace GoodJob.logger with our structured logger if GoodJob is available
+        if goodjob_module.respond_to?(:logger=)
+          goodjob_module.logger = LogStruct::Integrations::GoodJob::Logger.new("GoodJob")
+        end
+
+        # Configure error handling for thread errors if GoodJob supports it
+        if goodjob_module.respond_to?(:on_thread_error=)
+          goodjob_module.on_thread_error = ->(exception) do
+            # Log the error using our structured format
+            log_entry = LogStruct::Log::GoodJob.new(
+              event: Event::Error,
+              level: Level::Error,
+              error_class: exception.class.name,
+              error_message: exception.message,
+              error_backtrace: exception.backtrace
+            )
+
+            goodjob_module.logger.error(log_entry)
+          end
+        end
+      end
+
+      # Subscribe to GoodJob's ActiveSupport notifications
+      sig { void }
+      def self.subscribe_to_notifications
+        return unless defined?(::GoodJob)
+
+        # Subscribe to our custom log subscriber for GoodJob events
+        LogStruct::Integrations::GoodJob::LogSubscriber.attach_to :good_job
+      end
+
+      private_class_method :configure_logger
+      private_class_method :subscribe_to_notifications
+    end
+  end
+end