sentry-rails 5.23.0 → 5.28.0

data/lib/sentry/rails/configuration.rb

@@ -6,23 +6,26 @@ require "sentry/rails/tracing/active_record_subscriber"
 require "sentry/rails/tracing/active_storage_subscriber"
 require "sentry/rails/tracing/active_support_subscriber"
 
+require "sentry/rails/log_subscribers/active_record_subscriber"
+require "sentry/rails/log_subscribers/action_controller_subscriber"
+
 module Sentry
   class Configuration
     attr_reader :rails
 
-    add_post_initialization_callback do
+    after(:initialize) do
       @rails = Sentry::Rails::Configuration.new
       @excluded_exceptions = @excluded_exceptions.concat(Sentry::Rails::IGNORE_DEFAULT)
 
       if ::Rails.logger
         if defined?(::ActiveSupport::BroadcastLogger) && ::Rails.logger.is_a?(::ActiveSupport::BroadcastLogger)
           dupped_broadcasts = ::Rails.logger.broadcasts.map(&:dup)
-          @logger = ::ActiveSupport::BroadcastLogger.new(*dupped_broadcasts)
+          self.sdk_logger = ::ActiveSupport::BroadcastLogger.new(*dupped_broadcasts)
         else
-          @logger = ::Rails.logger.dup
+          self.sdk_logger = ::Rails.logger.dup
         end
       else
-        @logger.warn(Sentry::LOGGER_PROGNAME) do
+        sdk_logger.warn(Sentry::LOGGER_PROGNAME) do
           <<~MSG
           sentry-rails can't detect Rails.logger. it may be caused by misplacement of the SDK initialization code
           please make sure you place the Sentry.init block under the `config/initializers` folder, e.g. `config/initializers/sentry.rb`
@@ -30,6 +33,10 @@ module Sentry
         end
       end
     end
+
+    after(:configured) do
+      rails.structured_logging.enabled = enable_logs if rails.structured_logging.enabled.nil?
+    end
   end
 
   module Rails
@@ -156,6 +163,13 @@ module Sentry
       # @return [Hash<String, Array<Symbol>>]
       attr_accessor :active_support_logger_subscription_items
 
+      # Set this option to true if you want Sentry to capture each retry failure
+      attr_accessor :active_job_report_on_retry_error
+
+      # Configuration for structured logging feature
+      # @return [StructuredLoggingConfiguration]
+      attr_reader :structured_logging
+
       def initialize
         @register_error_subscriber = false
         @report_rescued_exceptions = true
@@ -172,6 +186,34 @@ module Sentry
         @enable_db_query_source = true
         @db_query_source_threshold_ms = 100
         @active_support_logger_subscription_items = Sentry::Rails::ACTIVE_SUPPORT_LOGGER_SUBSCRIPTION_ITEMS_DEFAULT.dup
+        @active_job_report_on_retry_error = false
+        @structured_logging = StructuredLoggingConfiguration.new
+      end
+    end
+
+    class StructuredLoggingConfiguration
+      # Enable or disable structured logging
+      # @return [Boolean]
+      attr_accessor :enabled
+
+      # Hash of components to subscriber classes for structured logging
+      # @return [Hash<Symbol, Class>]
+      attr_accessor :subscribers
+
+      DEFAULT_SUBSCRIBERS = {
+        active_record: Sentry::Rails::LogSubscribers::ActiveRecordSubscriber,
+        action_controller: Sentry::Rails::LogSubscribers::ActionControllerSubscriber
+      }.freeze
+
+      def initialize
+        @enabled = nil
+        @subscribers = DEFAULT_SUBSCRIBERS.dup
+      end
+
+      # Returns true if structured logging should be enabled.
+      # @return [Boolean]
+      def enabled?
+        enabled
       end
     end
   end

data/lib/sentry/rails/log_subscriber.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
+
+module Sentry
+  module Rails
+    # Base class for Sentry log subscribers that extends ActiveSupport::LogSubscriber
+    # to provide structured logging capabilities for Rails components.
+    #
+    # This class follows Rails' LogSubscriber pattern and provides common functionality
+    # for capturing Rails instrumentation events and logging them through Sentry's
+    # structured logging system.
+    #
+    # @example Creating a custom log subscriber
+    #   class MySubscriber < Sentry::Rails::LogSubscriber
+    #     attach_to :my_component
+    #
+    #     def my_event(event)
+    #       log_structured_event(
+    #         message: "My event occurred",
+    #         level: :info,
+    #         attributes: {
+    #           duration_ms: event.duration,
+    #           custom_data: event.payload[:custom_data]
+    #         }
+    #       )
+    #     end
+    #   end
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      ORIGIN = "auto.logger.rails.log_subscriber"
+
+      class << self
+        if ::Rails.version.to_f < 6.0
+          # Rails 5.x does not provide detach_from
+          def detach_from(namespace, notifications = ActiveSupport::Notifications)
+            listeners = public_instance_methods(false)
+              .flat_map { |key|
+                notifications.notifier.listeners_for("#{key}.#{namespace}")
+              }
+              .select { |listener| listener.instance_variable_get(:@delegate).is_a?(self) }
+
+            listeners.map do |listener|
+              notifications.notifier.unsubscribe(listener)
+            end
+          end
+        end
+      end
+
+      protected
+
+      # Log a structured event using Sentry's structured logger
+      #
+      # @param message [String] The log message
+      # @param level [Symbol] The log level (:trace, :debug, :info, :warn, :error, :fatal)
+      # @param attributes [Hash] Additional structured attributes to include
+      # @param origin [String] The origin of the log event
+      def log_structured_event(message:, level: :info, attributes: {}, origin: ORIGIN)
+        Sentry.logger.public_send(level, message, **attributes, origin: origin)
+      rescue => e
+        # Silently handle any errors in logging to avoid breaking the application
+        Sentry.configuration.sdk_logger.debug("Failed to log structured event: #{e.message}")
+      end
+
+      # Calculate duration in milliseconds from an event
+      #
+      # @param event [ActiveSupport::Notifications::Event] The event
+      # @return [Float] Duration in milliseconds
+      def duration_ms(event)
+        event.duration.round(2)
+      end
+    end
+  end
+end

data/lib/sentry/rails/log_subscribers/action_controller_subscriber.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "sentry/rails/log_subscriber"
+require "sentry/rails/log_subscribers/parameter_filter"
+
+module Sentry
+  module Rails
+    module LogSubscribers
+      # LogSubscriber for ActionController events that captures HTTP request processing
+      # and logs them using Sentry's structured logging system.
+      #
+      # This subscriber captures process_action.action_controller events and formats them
+      # with relevant request information including controller, action, HTTP status,
+      # request parameters, and performance metrics.
+      #
+      # @example Usage
+      #   # Enable structured logging for ActionController
+      #   Sentry.init do |config|
+      #     config.enable_logs = true
+      #     config.rails.structured_logging = true
+      #     config.rails.structured_logging.subscribers = { action_controller: Sentry::Rails::LogSubscribers::ActionControllerSubscriber }
+      #   end
+      class ActionControllerSubscriber < Sentry::Rails::LogSubscriber
+        include ParameterFilter
+
+        # Handle process_action.action_controller events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The controller action event
+        def process_action(event)
+          payload = event.payload
+
+          controller = payload[:controller]
+          action = payload[:action]
+
+          status = extract_status(payload)
+
+          attributes = {
+            controller: controller,
+            action: action,
+            duration_ms: duration_ms(event),
+            method: payload[:method],
+            path: payload[:path],
+            format: payload[:format]
+          }
+
+          attributes[:status] = status if status
+
+          if payload[:view_runtime]
+            attributes[:view_runtime_ms] = payload[:view_runtime].round(2)
+          end
+
+          if payload[:db_runtime]
+            attributes[:db_runtime_ms] = payload[:db_runtime].round(2)
+          end
+
+          if Sentry.configuration.send_default_pii && payload[:params]
+            filtered_params = filter_sensitive_params(payload[:params])
+            attributes[:params] = filtered_params unless filtered_params.empty?
+          end
+
+          level = level_for_request(payload)
+          message = "#{controller}##{action}"
+
+          log_structured_event(
+            message: message,
+            level: level,
+            attributes: attributes
+          )
+        end
+
+        private
+
+        def extract_status(payload)
+          if payload[:status]
+            payload[:status]
+          elsif payload[:exception]
+            case payload[:exception].first
+            when "ActionController::RoutingError"
+              404
+            when "ActionController::BadRequest"
+              400
+            else
+              500
+            end
+          end
+        end
+
+        def level_for_request(payload)
+          status = payload[:status]
+
+          # In Rails < 6.0 status is not set when an action raised an exception
+          if status.nil? && payload[:exception]
+            case payload[:exception].first
+            when "ActionController::RoutingError"
+              :warn
+            when "ActionController::BadRequest"
+              :warn
+            else
+              :error
+            end
+          elsif status.nil?
+            :info
+          elsif status >= 200 && status < 400
+            :info
+          elsif status >= 400 && status < 500
+            :warn
+          elsif status >= 500
+            :error
+          else
+            :info
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/log_subscribers/action_mailer_subscriber.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "sentry/rails/log_subscriber"
+require "sentry/rails/log_subscribers/parameter_filter"
+
+module Sentry
+  module Rails
+    module LogSubscribers
+      # LogSubscriber for ActionMailer events that captures email delivery
+      # and processing events using Sentry's structured logging system.
+      #
+      # This subscriber captures deliver.action_mailer and process.action_mailer events
+      # and formats them with relevant email information while respecting PII settings.
+      #
+      # @example Usage
+      #   # Enable structured logging for ActionMailer
+      #   Sentry.init do |config|
+      #     config.enable_logs = true
+      #     config.rails.structured_logging = true
+      #     config.rails.structured_logging.subscribers = { action_mailer: Sentry::Rails::LogSubscribers::ActionMailerSubscriber }
+      #   end
+      class ActionMailerSubscriber < Sentry::Rails::LogSubscriber
+        include ParameterFilter
+
+        # Handle deliver.action_mailer events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The email delivery event
+        def deliver(event)
+          payload = event.payload
+
+          mailer = payload[:mailer]
+
+          attributes = {
+            mailer: mailer,
+            duration_ms: duration_ms(event),
+            perform_deliveries: payload[:perform_deliveries]
+          }
+
+          attributes[:delivery_method] = payload[:delivery_method] if payload[:delivery_method]
+          attributes[:date] = payload[:date].to_s if payload[:date]
+
+          if Sentry.configuration.send_default_pii
+            attributes[:message_id] = payload[:message_id] if payload[:message_id]
+          end
+
+          message = "Email delivered via #{mailer}"
+
+          # Log the structured event
+          log_structured_event(
+            message: message,
+            level: :info,
+            attributes: attributes
+          )
+        end
+
+        # Handle process.action_mailer events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The email processing event
+        def process(event)
+          payload = event.payload
+
+          mailer = payload[:mailer]
+          action = payload[:action]
+          duration = duration_ms(event)
+
+          attributes = {
+            mailer: mailer,
+            action: action,
+            duration_ms: duration
+          }
+
+          if Sentry.configuration.send_default_pii && payload[:params]
+            filtered_params = filter_sensitive_params(payload[:params])
+            attributes[:params] = filtered_params unless filtered_params.empty?
+          end
+
+          message = "#{mailer}##{action}"
+
+          log_structured_event(
+            message: message,
+            level: :info,
+            attributes: attributes
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/log_subscribers/active_job_subscriber.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "sentry/rails/log_subscriber"
+require "sentry/rails/log_subscribers/parameter_filter"
+
+module Sentry
+  module Rails
+    module LogSubscribers
+      # LogSubscriber for ActiveJob events that captures background job execution
+      # and logs them using Sentry's structured logging system.
+      #
+      # This subscriber captures various ActiveJob events including job execution,
+      # enqueueing, retries, and failures with relevant job information.
+      #
+      # @example Usage
+      #   # Enable structured logging for ActiveJob
+      #   Sentry.init do |config|
+      #     config.enable_logs = true
+      #     config.rails.structured_logging = true
+      #     config.rails.structured_logging.subscribers = { active_job: Sentry::Rails::LogSubscribers::ActiveJobSubscriber }
+      #   end
+      class ActiveJobSubscriber < Sentry::Rails::LogSubscriber
+        include ParameterFilter
+
+        # Handle perform.active_job events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The job performance event
+        def perform(event)
+          job = event.payload[:job]
+          duration = duration_ms(event)
+
+          attributes = {
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue_name: job.queue_name,
+            duration_ms: duration,
+            executions: job.executions,
+            priority: job.priority
+          }
+
+          attributes[:adapter] = job.class.queue_adapter.class.name
+
+          if job.scheduled_at
+            attributes[:scheduled_at] = job.scheduled_at.iso8601
+            attributes[:delay_ms] = ((Time.current - job.scheduled_at) * 1000).round(2)
+          end
+
+          if Sentry.configuration.send_default_pii && job.arguments.present?
+            filtered_args = filter_sensitive_arguments(job.arguments)
+            attributes[:arguments] = filtered_args unless filtered_args.empty?
+          end
+
+          message = "Job performed: #{job.class.name}"
+
+          log_structured_event(
+            message: message,
+            level: :info,
+            attributes: attributes
+          )
+        end
+
+        # Handle enqueue.active_job events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The job enqueue event
+        def enqueue(event)
+          job = event.payload[:job]
+
+          attributes = {
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue_name: job.queue_name,
+            priority: job.priority
+          }
+
+          attributes[:adapter] = job.class.queue_adapter.class.name if job.class.respond_to?(:queue_adapter)
+
+          if job.scheduled_at
+            attributes[:scheduled_at] = job.scheduled_at.iso8601
+            attributes[:delay_seconds] = (job.scheduled_at - Time.current).round(2)
+          end
+
+          message = "Job enqueued: #{job.class.name}"
+
+          log_structured_event(
+            message: message,
+            level: :info,
+            attributes: attributes
+          )
+        end
+
+        def retry_stopped(event)
+          job = event.payload[:job]
+          error = event.payload[:error]
+
+          attributes = {
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue_name: job.queue_name,
+            executions: job.executions,
+            error_class: error.class.name,
+            error_message: error.message
+          }
+
+          message = "Job retry stopped: #{job.class.name}"
+
+          log_structured_event(
+            message: message,
+            level: :error,
+            attributes: attributes
+          )
+        end
+
+        def discard(event)
+          job = event.payload[:job]
+          error = event.payload[:error]
+
+          attributes = {
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue_name: job.queue_name,
+            executions: job.executions
+          }
+
+          attributes[:error_class] = error.class.name if error
+          attributes[:error_message] = error.message if error
+
+          message = "Job discarded: #{job.class.name}"
+
+          log_structured_event(
+            message: message,
+            level: :warn,
+            attributes: attributes
+          )
+        end
+
+        private
+
+        def filter_sensitive_arguments(arguments)
+          return [] unless arguments.is_a?(Array)
+
+          arguments.map do |arg|
+            case arg
+            when Hash
+              filter_sensitive_params(arg)
+            when String
+              arg.length > 100 ? "[FILTERED: #{arg.length} chars]" : arg
+            else
+              arg
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/log_subscribers/active_record_subscriber.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "sentry/rails/log_subscriber"
+require "sentry/rails/log_subscribers/parameter_filter"
+
+module Sentry
+  module Rails
+    module LogSubscribers
+      # LogSubscriber for ActiveRecord events that captures database queries
+      # and logs them using Sentry's structured logging system.
+      #
+      # This subscriber captures sql.active_record events and formats them
+      # with relevant database information including SQL queries, duration,
+      # database configuration, and caching information.
+      #
+      # @example Usage
+      #   # Automatically attached when structured logging is enabled for :active_record
+      #   Sentry.init do |config|
+      #     config.enable_logs = true
+      #     config.rails.structured_logging = true
+      #     config.rails.structured_logging.subscribers = { active_record: Sentry::Rails::LogSubscribers::ActiveRecordSubscriber }
+      #   end
+      class ActiveRecordSubscriber < Sentry::Rails::LogSubscriber
+        include ParameterFilter
+
+        EXCLUDED_NAMES = ["SCHEMA", "TRANSACTION"].freeze
+
+        # Handle sql.active_record events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The SQL event
+        def sql(event)
+          return if EXCLUDED_NAMES.include?(event.payload[:name])
+
+          sql = event.payload[:sql]
+          statement_name = event.payload[:name]
+
+          # Rails 5.0.0 doesn't include :cached in the payload, it was added in Rails 5.1
+          cached = event.payload.fetch(:cached, false)
+          connection_id = event.payload[:connection_id]
+
+          db_config = extract_db_config(event.payload)
+
+          attributes = {
+            sql: sql,
+            duration_ms: duration_ms(event),
+            cached: cached
+          }
+
+          attributes[:statement_name] = statement_name if statement_name && statement_name != "SQL"
+          attributes[:connection_id] = connection_id if connection_id
+
+          add_db_config_attributes(attributes, db_config)
+
+          message = build_log_message(statement_name)
+
+          log_structured_event(
+            message: message,
+            level: :info,
+            attributes: attributes
+          )
+        end
+
+        private
+
+        def build_log_message(statement_name)
+          if statement_name && statement_name != "SQL"
+            "Database query: #{statement_name}"
+          else
+            "Database query"
+          end
+        end
+
+        def extract_db_config(payload)
+          connection = payload[:connection]
+
+          return unless connection
+
+          extract_db_config_from_connection(connection)
+        end
+
+        def add_db_config_attributes(attributes, db_config)
+          return unless db_config
+
+          attributes[:db_system] = db_config[:adapter] if db_config[:adapter]
+
+          if db_config[:database]
+            db_name = db_config[:database]
+
+            if db_config[:adapter] == "sqlite3" && db_name.include?("/")
+              db_name = File.basename(db_name)
+            end
+
+            attributes[:db_name] = db_name
+          end
+
+          attributes[:server_address] = db_config[:host] if db_config[:host]
+          attributes[:server_port] = db_config[:port] if db_config[:port]
+          attributes[:server_socket_address] = db_config[:socket] if db_config[:socket]
+        end
+
+        if ::Rails.version.to_f >= 6.1
+          def extract_db_config_from_connection(connection)
+            if connection.pool.respond_to?(:db_config)
+              db_config = connection.pool.db_config
+              if db_config.respond_to?(:configuration_hash)
+                return db_config.configuration_hash
+              elsif db_config.respond_to?(:config)
+                return db_config.config
+              end
+            end
+
+            extract_db_config_fallback(connection)
+          end
+        else
+          # Rails 6.0 and earlier use spec API
+          def extract_db_config_from_connection(connection)
+            if connection.pool.respond_to?(:spec)
+              spec = connection.pool.spec
+              if spec.respond_to?(:config)
+                return spec.config
+              end
+            end
+
+            extract_db_config_fallback(connection)
+          end
+        end
+
+        def extract_db_config_fallback(connection)
+          connection.config if connection.respond_to?(:config)
+        end
+      end
+    end
+  end
+end