sentry-rails 5.23.0 → 5.27.0

data/lib/sentry/rails/log_subscriber.rb

@@ -0,0 +1,70 @@
+# 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
+      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
+      def log_structured_event(message:, level: :info, attributes: {})
+        Sentry.logger.public_send(level, message, **attributes)
+      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

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Rails
+    module LogSubscribers
+      # Shared utility module for filtering sensitive parameters in log subscribers.
+      #
+      # This module provides consistent parameter filtering across all Sentry Rails
+      # log subscribers, leveraging Rails' built-in parameter filtering when available.
+      # It automatically detects the correct Rails parameter filtering API based on
+      # the Rails version and includes the appropriate implementation module.
+      #
+      # @example Usage in a log subscriber
+      #   class MySubscriber < Sentry::Rails::LogSubscriber
+      #     include Sentry::Rails::LogSubscribers::ParameterFilter
+      #
+      #     def my_event(event)
+      #       if Sentry.configuration.send_default_pii && event.payload[:params]
+      #         filtered_params = filter_sensitive_params(event.payload[:params])
+      #         attributes[:params] = filtered_params unless filtered_params.empty?
+      #       end
+      #     end
+      #   end
+      module ParameterFilter
+        EMPTY_HASH = {}.freeze
+
+        if ::Rails.version.to_f >= 6.0
+          def self.backend
+            ActiveSupport::ParameterFilter
+          end
+        else
+          def self.backend
+            ActionDispatch::Http::ParameterFilter
+          end
+        end
+
+        # Filter sensitive parameters from a hash, respecting Rails configuration.
+        #
+        # @param params [Hash] The parameters to filter
+        # @return [Hash] Filtered parameters with sensitive data removed
+        def filter_sensitive_params(params)
+          return EMPTY_HASH unless params.is_a?(Hash)
+
+          filter_parameters = ::Rails.application.config.filter_parameters
+          parameter_filter = ParameterFilter.backend.new(filter_parameters)
+
+          parameter_filter.filter(params)
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/railtie.rb

@@ -49,8 +49,14 @@ module Sentry
       setup_backtrace_cleanup_callback
       inject_breadcrumbs_logger
       activate_tracing
+      activate_structured_logging
 
       register_error_subscriber(app) if ::Rails.version.to_f >= 7.0 && Sentry.configuration.rails.register_error_subscriber
+
+      # Presence of ActiveJob is no longer a reliable cue
+      if defined?(Sentry::Rails::ActiveJobExtensions)
+        Sentry::Rails::ActiveJobExtensions::SentryReporter.register_event_handlers
+      end
     end
 
     runner do
@@ -133,6 +139,12 @@ module Sentry
       end
     end
 
+    def activate_structured_logging
+      if Sentry.configuration.rails.structured_logging.enabled && Sentry.configuration.enable_logs
+        Sentry::Rails::StructuredLogging.attach(Sentry.configuration.rails.structured_logging)
+      end
+    end
+
     def register_error_subscriber(app)
       require "sentry/rails/error_subscriber"
       app.executor.error_reporter.subscribe(Sentry::Rails::ErrorSubscriber.new)

data/lib/sentry/rails/structured_logging.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "sentry/rails/log_subscriber"
+require "sentry/rails/log_subscribers/action_controller_subscriber"
+require "sentry/rails/log_subscribers/active_record_subscriber"
+require "sentry/rails/log_subscribers/active_job_subscriber"
+require "sentry/rails/log_subscribers/action_mailer_subscriber"
+
+module Sentry
+  module Rails
+    module StructuredLogging
+      class << self
+        def attach(config)
+          config.subscribers.each do |component, subscriber_class|
+            subscriber_class.attach_to component
+          end
+        rescue => e
+          Sentry.configuration.sdk_logger.error("Failed to attach structured loggers: #{e.message}")
+          Sentry.configuration.sdk_logger.error(e.backtrace.join("\n"))
+        end
+
+        def detach(config)
+          config.subscribers.each do |component, subscriber_class|
+            subscriber_class.detach_from component
+          end
+        rescue => e
+          Sentry.configuration.sdk_logger.debug("Error during detaching loggers: #{e.message}")
+        end
+      end
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ module Sentry
         SPAN_ORIGIN = "auto.view.rails"
 
         def self.subscribe!
-          Sentry.logger.warn <<~MSG
+          Sentry.sdk_logger.warn <<~MSG
             DEPRECATION WARNING: sentry-rails has changed its approach on controller span recording and #{self.name} is now depreacted.
             Please stop using or referencing #{self.name} as it will be removed in the next major release.
           MSG

data/lib/sentry/rails/tracing/active_storage_subscriber.rb

@@ -33,7 +33,10 @@ module Sentry
               duration: duration
             ) do |span|
               payload.each do |key, value|
-                span.set_data(key, value) unless key == START_TIMESTAMP_NAME
+                next if key == START_TIMESTAMP_NAME
+                next if key == :key && !Sentry.configuration.send_default_pii
+
+                span.set_data(key, value)
               end
             end
           end