sentry-rails 5.18.2 → 5.28.1

data/lib/sentry/rails/background_worker.rb

@@ -1,13 +1,19 @@
+# frozen_string_literal: true
+
 module Sentry
   class BackgroundWorker
-    def _perform(&block)
-      block.call
-    ensure
-      # some applications have partial or even no AR connection
-      if ActiveRecord::Base.connected?
-        # make sure the background worker returns AR connection if it accidentally acquire one during serialization
-        ActiveRecord::Base.connection_pool.release_connection
+    module ActiveRecordConnectionPatch
+      def _perform(&block)
+        super(&block)
+      ensure
+        # some applications have partial or even no AR connection
+        if ActiveRecord::Base.connected?
+          # make sure the background worker returns AR connection if it accidentally acquire one during serialization
+          ActiveRecord::Base.connection_pool.release_connection
+        end
       end
     end
   end
 end
+
+Sentry::BackgroundWorker.prepend(Sentry::BackgroundWorker::ActiveRecordConnectionPatch)

data/lib/sentry/rails/backtrace_cleaner.rb

@@ -1,21 +1,21 @@
+# frozen_string_literal: true
+
 require "active_support/backtrace_cleaner"
 require "active_support/core_ext/string/access"
 
 module Sentry
   module Rails
     class BacktraceCleaner < ActiveSupport::BacktraceCleaner
-      APP_DIRS_PATTERN = /\A(?:\.\/)?(?:app|config|lib|test|\(\w*\))/.freeze
-      RENDER_TEMPLATE_PATTERN = /:in `.*_\w+_{2,3}\d+_\d+'/.freeze
+      APP_DIRS_PATTERN = /\A(?:\.\/)?(?:app|config|lib|test|\(\w*\))/
+      RENDER_TEMPLATE_PATTERN = /:in (?:`|').*_\w+_{2,3}\d+_\d+'/
 
       def initialize
         super
-        # we don't want any default silencers because they're too aggressive
+        # We don't want any default silencers because they're too aggressive
         remove_silencers!
+        # We don't want any default filters because Rails 7.2 starts shortening the paths. See #2472
+        remove_filters!
 
-        @root = "#{Sentry.configuration.project_root}/"
-        add_filter do |line|
-          line.start_with?(@root) ? line.from(@root.size) : line
-        end
         add_filter do |line|
           if line =~ RENDER_TEMPLATE_PATTERN
             line.sub(RENDER_TEMPLATE_PATTERN, "")

data/lib/sentry/rails/breadcrumb/active_support_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     module Breadcrumb

data/lib/sentry/rails/breadcrumb/monotonic_active_support_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sentry/rails/instrument_payload_cleanup_helper"
 
 module Sentry

data/lib/sentry/rails/capture_exceptions.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     class CaptureExceptions < Sentry::Rack::CaptureExceptions
       RAILS_7_1 = Gem::Version.new(::Rails.version) >= Gem::Version.new("7.1.0.alpha")
-      SPAN_ORIGIN = 'auto.http.rails'.freeze
+      SPAN_ORIGIN = "auto.http.rails"
 
       def initialize(_)
         super
@@ -20,7 +22,7 @@ module Sentry
       end
 
       def transaction_op
-        "http.server".freeze
+        "http.server"
       end
 
       def capture_exception(exception, env)

data/lib/sentry/rails/configuration.rb

@@ -1,25 +1,31 @@
+# frozen_string_literal: true
+
 require "sentry/rails/tracing/action_controller_subscriber"
 require "sentry/rails/tracing/action_view_subscriber"
 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`
@@ -27,24 +33,28 @@ module Sentry
         end
       end
     end
+
+    after(:configured) do
+      rails.structured_logging.enabled = enable_logs if rails.structured_logging.enabled.nil?
+    end
   end
 
   module Rails
     IGNORE_DEFAULT = [
-      'AbstractController::ActionNotFound',
-      'ActionController::BadRequest',
-      'ActionController::InvalidAuthenticityToken',
-      'ActionController::InvalidCrossOriginRequest',
-      'ActionController::MethodNotAllowed',
-      'ActionController::NotImplemented',
-      'ActionController::ParameterMissing',
-      'ActionController::RoutingError',
-      'ActionController::UnknownAction',
-      'ActionController::UnknownFormat',
-      'ActionDispatch::Http::MimeNegotiation::InvalidType',
-      'ActionController::UnknownHttpMethod',
-      'ActionDispatch::Http::Parameters::ParseError',
-      'ActiveRecord::RecordNotFound'
+      "AbstractController::ActionNotFound",
+      "ActionController::BadRequest",
+      "ActionController::InvalidAuthenticityToken",
+      "ActionController::InvalidCrossOriginRequest",
+      "ActionController::MethodNotAllowed",
+      "ActionController::NotImplemented",
+      "ActionController::ParameterMissing",
+      "ActionController::RoutingError",
+      "ActionController::UnknownAction",
+      "ActionController::UnknownFormat",
+      "ActionDispatch::Http::MimeNegotiation::InvalidType",
+      "ActionController::UnknownHttpMethod",
+      "ActionDispatch::Http::Parameters::ParseError",
+      "ActiveRecord::RecordNotFound"
     ].freeze
 
     ACTIVE_SUPPORT_LOGGER_SUBSCRIPTION_ITEMS_DEFAULT = {
@@ -153,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
@@ -162,12 +179,41 @@ module Sentry
         end
         @tracing_subscribers = Set.new([
           Sentry::Rails::Tracing::ActionViewSubscriber,
+          Sentry::Rails::Tracing::ActiveSupportSubscriber,
           Sentry::Rails::Tracing::ActiveRecordSubscriber,
           Sentry::Rails::Tracing::ActiveStorageSubscriber
         ])
         @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/controller_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     module ControllerMethods

data/lib/sentry/rails/controller_transaction.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     module ControllerTransaction
-      SPAN_ORIGIN = 'auto.view.rails'.freeze
+      SPAN_ORIGIN = "auto.view.rails"
 
       def self.included(base)
         base.prepend_around_action(:sentry_around_action)
@@ -21,8 +23,10 @@ module Sentry
                 child_span.set_http_status(response.status)
                 child_span.set_data(:format, request.format)
                 child_span.set_data(:method, request.method)
-                child_span.set_data(:path, request.path)
-                child_span.set_data(:params, request.params)
+
+                pii = Sentry.configuration.send_default_pii
+                child_span.set_data(:path, pii ? request.fullpath : request.filtered_path)
+                child_span.set_data(:params, pii ? request.params : request.filtered_parameters)
               end
 
               result

data/lib/sentry/rails/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   class Engine < ::Rails::Engine
     isolate_namespace Sentry

data/lib/sentry/rails/error_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     # This is not a user-facing class. You should use it with Rails 7.0's error reporter feature and its interfaces.

data/lib/sentry/rails/instrument_payload_cleanup_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     module InstrumentPayloadCleanupHelper

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.log.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