sentry-rails 6.6.2 → 7.0.0

data/lib/sentry/rails/active_job.rb

@@ -1,17 +1,66 @@
 # frozen_string_literal: true
 
 require "set"
+require "sentry/rails/serializer"
+require "sentry/rails/error_reporter_context"
 
 module Sentry
   module Rails
     module ActiveJobExtensions
+      SENTRY_PAYLOAD_KEY = "_sentry"
+
+      USER_FIELDS_ALLOWLIST = %w[id email username].freeze
+
+      def self.prepended(base)
+        base.attr_accessor :_sentry
+      end
+
       def perform_now
         if !Sentry.initialized? || already_supported_by_sentry_integration?
           super
         else
-          SentryReporter.record(self) do
-            super
+          data = _sentry || {}
+          SentryReporter.record(
+            self,
+            trace_headers: data["trace_propagation_headers"],
+            user: data["user"]
+          ) { super }
+        end
+      end
+
+      def serialize
+        payload = super
+        return payload if !Sentry.initialized? || already_supported_by_sentry_integration?
+
+        begin
+          sentry_data = {}
+          if Sentry.configuration.rails.active_job_propagate_traces
+            headers = Sentry.get_trace_propagation_headers
+            sentry_data["trace_propagation_headers"] = headers if headers && !headers.empty?
           end
+
+          if Sentry.configuration.data_collection.user_info
+            user = Sentry.get_current_scope.user
+            allowed = user.transform_keys(&:to_s).slice(*USER_FIELDS_ALLOWLIST)
+            sentry_data["user"] = allowed unless allowed.empty?
+          end
+
+          payload[SENTRY_PAYLOAD_KEY] = sentry_data unless sentry_data.empty?
+        rescue StandardError => e
+          Sentry.sdk_logger&.error("sentry-rails: failed to inject _sentry payload: #{e.class}: #{e.message}\n  #{Array(e.backtrace).first(5).join("\n  ")}")
+        end
+
+        payload
+      end
+
+      def deserialize(job_data)
+        super
+        return if !Sentry.initialized? || already_supported_by_sentry_integration?
+
+        begin
+          self._sentry = job_data[SENTRY_PAYLOAD_KEY]
+        rescue StandardError => e
+          Sentry.sdk_logger&.error("sentry-rails: failed to extract _sentry payload: #{e.class}: #{e.message}\n  #{Array(e.backtrace).first(5).join("\n  ")}")
         end
       end
 
@@ -20,27 +69,104 @@ module Sentry
       end
 
       class SentryReporter
-        OP_NAME = "queue.active_job"
+        OP_NAME = "queue.process"
         SPAN_ORIGIN = "auto.queue.active_job"
 
+        # Emitted as messaging.system when the configured queue adapter's
+        # identity cannot be resolved from the job. ActiveJob is adapter-agnostic
+        # and supports arbitrary third-party backends, so the concrete value is
+        # normally derived from the adapter itself; this is only the last resort.
+        MESSAGING_SYSTEM_FALLBACK = "activejob"
+
         EVENT_HANDLERS = {
           "enqueue_retry.active_job" => :retry_handler
         }
 
         class << self
-          def record(job, &block)
+          include ErrorReporterContext
+
+          def producer_callback_registered?
+            @producer_callback_registered ||= false
+          end
+
+          def producer_callback_registered!
+            @producer_callback_registered = true
+          end
+
+          def record_producer_span(job, &enqueue)
+            return yield if !Sentry.initialized? || job.already_supported_by_sentry_integration?
+
+            enqueued = false
+
+            run_enqueue = lambda do
+              enqueued = true
+              enqueue.call
+            end
+
+            begin
+              Sentry.with_child_span(op: "queue.publish", description: job.class.name) do |span|
+                if span
+                  span.set_origin(SPAN_ORIGIN)
+                  span.set_data(Sentry::Span::DataConventions::MESSAGING_SYSTEM, messaging_system(job))
+                  span.set_data(Sentry::Span::DataConventions::MESSAGING_MESSAGE_ID, job.job_id)
+                  span.set_data(Sentry::Span::DataConventions::MESSAGING_DESTINATION_NAME, job.queue_name)
+
+                  if (count = retry_count(job))
+                    span.set_data(Sentry::Span::DataConventions::MESSAGING_MESSAGE_RETRY_COUNT, count)
+                  end
+                end
+
+                run_enqueue.call
+              end
+            rescue StandardError => e
+              raise if enqueued
+
+              log_producer_span_error(e)
+
+              run_enqueue.call
+            end
+          end
+
+          def log_producer_span_error(e)
+            Sentry.sdk_logger&.error("sentry-rails: failed to record producer span: #{e.class}: #{e.message}\n  #{Array(e.backtrace).first(5).join("\n  ")}")
+          end
+
+          def record(job, trace_headers: nil, user: nil, &block)
+            original_hub = Sentry.get_current_hub_internal
+            Sentry.clone_hub_to_current_thread
+
             Sentry.with_scope do |scope|
               begin
+                scope.set_user(user.transform_keys(&:to_sym)) if user && !user.empty?
+
                 scope.set_transaction_name(job.class.name, source: :task)
+                scope.set_tags(queue: job.queue_name)
 
-                transaction = Sentry.start_transaction(
+                scope.set_contexts(active_job: {
+                  job_class: job.class.name,
+                  job_id: job.job_id,
+                  queue: job.queue_name,
+                  provider_job_id: job.provider_job_id
+                })
+
+                transaction_options = {
                   name: scope.transaction_name,
                   source: scope.transaction_source,
                   op: OP_NAME,
                   origin: SPAN_ORIGIN
-                )
+                }
+
+                transaction = if trace_headers && !trace_headers.empty?
+                  continued = Sentry.continue_trace(trace_headers, **transaction_options)
+                  Sentry.start_transaction(transaction: continued, **transaction_options)
+                else
+                  Sentry.start_transaction(**transaction_options)
+                end
 
-                scope.set_span(transaction) if transaction
+                if transaction
+                  set_messaging_data(transaction, job)
+                  scope.set_span(transaction)
+                end
 
                 yield.tap do
                   finish_sentry_transaction(transaction, 200)
@@ -53,17 +179,60 @@ module Sentry
                 raise
               end
             end
+          ensure
+            Sentry.set_current_hub_internal(original_hub)
+          end
+
+          def set_messaging_data(transaction, job)
+            transaction.set_data(Sentry::Span::DataConventions::MESSAGING_SYSTEM, messaging_system(job))
+            transaction.set_data(Sentry::Span::DataConventions::MESSAGING_MESSAGE_ID, job.job_id)
+            transaction.set_data(Sentry::Span::DataConventions::MESSAGING_DESTINATION_NAME, job.queue_name)
+            if (count = retry_count(job))
+              transaction.set_data(Sentry::Span::DataConventions::MESSAGING_MESSAGE_RETRY_COUNT, count)
+            end
+
+            if (latency = compute_latency(job))
+              transaction.set_data(Sentry::Span::DataConventions::MESSAGING_MESSAGE_RECEIVE_LATENCY, latency)
+            end
+          end
+
+          def messaging_system(job)
+            name = job.class.queue_adapter_name if job.class.respond_to?(:queue_adapter_name)
+            name = name.to_s
+            name.empty? ? MESSAGING_SYSTEM_FALLBACK : name
+          end
+
+          # Number of retries the job has already gone through, as observed at
+          # the moment the span is opened. On the consumer the span opens before
+          # ActiveJob increments +executions+, so a job's first attempt reads 0,
+          # its first retry reads 1, and so on. On the producer the retry enqueue
+          # runs after the failed attempt bumped +executions+, so it observes the
+          # same progression.
+          def retry_count(job)
+            job.executions.to_i if job.respond_to?(:executions)
+          end
+
+          def compute_latency(job)
+            return unless job.respond_to?(:enqueued_at) && job.enqueued_at
+
+            enqueued_time = job.enqueued_at.is_a?(String) ? Time.parse(job.enqueued_at) : job.enqueued_at
+            (Time.now.to_f - enqueued_time.to_f) * 1000.0
           end
 
           def capture_exception(job, e)
-            Sentry::Rails.capture_exception(
-              e,
+            options = {
               extra: sentry_context(job),
               tags: {
                 job_id: job.job_id,
                 provider_job_id: job.provider_job_id
-              }
-            )
+              },
+              # Send synchronously: a worker process may exit before the async
+              # background worker flushes its queue, which would drop the event.
+              hint: { background: false }
+            }
+            options[:contexts] = execution_context if Sentry.configuration.data_collection.queues
+
+            Sentry::Rails.capture_exception(e, **options)
           end
 
           def register_event_handlers
@@ -104,33 +273,23 @@ module Sentry
           end
 
           def sentry_context(job)
-            {
+            context = {
               active_job: job.class.name,
-              arguments: sentry_serialize_arguments(job.arguments),
               scheduled_at: job.scheduled_at,
               job_id: job.job_id,
               provider_job_id: job.provider_job_id,
               locale: job.locale
             }
+
+            if Sentry.configuration.data_collection.queues
+              context[:arguments] = sentry_serialize_arguments(job.arguments)
+            end
+
+            context
           end
 
           def sentry_serialize_arguments(argument)
-            case argument
-            when Range
-              if (argument.begin || argument.end).is_a?(ActiveSupport::TimeWithZone)
-                argument.to_s
-              else
-                argument.map { |v| sentry_serialize_arguments(v) }
-              end
-            when Hash
-              argument.transform_values { |v| sentry_serialize_arguments(v) }
-            when Array, Enumerable
-              argument.map { |v| sentry_serialize_arguments(v) }
-            when ->(v) { v.respond_to?(:to_global_id) }
-              argument.to_global_id.to_s rescue argument
-            else
-              argument
-            end
+            Sentry::Rails::Serializer.serialize(argument)
           end
 
           private

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

@@ -1,16 +1,22 @@
 # frozen_string_literal: true
 
+require "sentry/utils/http_tracing"
+
 module Sentry
   module Rails
     module Breadcrumb
       module ActiveSupportLogger
         class << self
+          include Sentry::Utils::HttpTracing
           def add(name, started, _finished, _unique_id, data)
+            return unless Sentry.initialized?
+
             # skip Rails' internal events
             return if name.start_with?("!")
 
             if data.is_a?(Hash)
               data = data.slice(*@allowed_keys[name])
+              filter_data_collection!(data)
             end
 
             crumb = Sentry::Breadcrumb.new(
@@ -35,6 +41,30 @@ module Sentry
           def detach
             ::ActiveSupport::Notifications.unsubscribe(@subscriber)
           end
+
+          private
+
+          def filter_data_collection!(data)
+            filter_params!(data)
+            filter_path!(data)
+          end
+
+          def filter_params!(data)
+            return unless data.key?(:params) && data[:params].is_a?(Hash)
+
+            data[:params] = Sentry.configuration.data_collection.url_query_params.filter(data[:params])
+            data.delete(:params) if data[:params].empty?
+          end
+
+          def filter_path!(data)
+            return unless data.key?(:path) && data[:path].is_a?(String)
+
+            path, query = data[:path].split("?", 2)
+            return unless query
+
+            filtered_query = filter_query_params(query)
+            data[:path] = filtered_query ? "#{path}?#{filtered_query}" : path
+          end
         end
       end
     end

data/lib/sentry/rails/capture_exceptions.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require "sentry/rails/error_reporter_context"
+
 module Sentry
   module Rails
     class CaptureExceptions < Sentry::Rack::CaptureExceptions
+      include ErrorReporterContext
+
       RAILS_7_1 = Gem::Version.new(::Rails.version) >= Gem::Version.new("7.1.0.alpha")
       SPAN_ORIGIN = "auto.http.rails"
 
@@ -30,7 +34,10 @@ module Sentry
         return unless Sentry.initialized?
         return if show_exceptions?(exception, env) && !Sentry.configuration.rails.report_rescued_exceptions
 
-        Sentry::Rails.capture_exception(exception).tap do |event|
+        options = {}
+        options[:contexts] = execution_context if Sentry.configuration.data_collection.user_info
+
+        Sentry::Rails.capture_exception(exception, **options).tap do |event|
           env[ERROR_EVENT_ID_KEY] = event.event_id if event
         end
       end

data/lib/sentry/rails/configuration.rb

@@ -35,7 +35,13 @@ module Sentry
     end
 
     after(:configured) do
-      rails.structured_logging.enabled = enable_logs if rails.structured_logging.enabled.nil?
+      collection = data_collection.url_query_params
+      if collection.mode == :deny_list
+        filter_parameters = ::Rails.application.config.filter_parameters.select do |filter|
+          filter.is_a?(String) || filter.is_a?(Symbol) || filter.is_a?(Regexp)
+        end
+        collection.terms = (Array(collection.terms) + filter_parameters).uniq
+      end
     end
   end
 
@@ -172,6 +178,11 @@ module Sentry
       # Set this option to true if you want Sentry to capture each retry failure
       attr_accessor :active_job_report_on_retry_error
 
+      # Whether we should inject trace propagation headers into the serialized job
+      # payload in order to have a connected trace between producer and consumer.
+      # Defaults to true. Set to false to opt out.
+      attr_accessor :active_job_propagate_traces
+
       # Configuration for structured logging feature
       # @return [StructuredLoggingConfiguration]
       attr_reader :structured_logging
@@ -193,6 +204,7 @@ module Sentry
         @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
+        @active_job_propagate_traces = true
         @structured_logging = StructuredLoggingConfiguration.new
       end
     end
@@ -212,7 +224,7 @@ module Sentry
       }.freeze
 
       def initialize
-        @enabled = nil
+        @enabled = true
         @subscribers = DEFAULT_SUBSCRIBERS.dup
       end
 

data/lib/sentry/rails/controller_transaction.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "sentry/utils/http_tracing"
+
 module Sentry
   module Rails
     module ControllerTransaction
@@ -24,9 +26,28 @@ module Sentry
                 child_span.set_data(:format, request.format)
                 child_span.set_data(:method, request.method)
 
-                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)
+                data_collection = Sentry.configuration.data_collection
+
+                path = request.path
+                query_parameters = request.query_parameters
+
+                if query_parameters.is_a?(Hash)
+                  filtered_query_parameters = data_collection.url_query_params.filter(query_parameters)
+
+                  unless filtered_query_parameters.empty?
+                    formatted_query = Sentry::Utils::HttpTracing.format_query(filtered_query_parameters)
+                    path = "#{path}?#{formatted_query}"
+                  end
+                end
+
+                child_span.set_data(:path, path)
+
+                # all params request + body
+                params = request.params
+                if params.is_a?(Hash)
+                  filtered_params = data_collection.url_query_params.filter(params)
+                  child_span.set_data(:params, filtered_params)
+                end
               end
 
               result

data/lib/sentry/rails/error_reporter_context.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "sentry/rails/serializer"
+
+module Sentry
+  module Rails
+    module ErrorReporterContext
+      SUPPORTS_EXECUTION_CONTEXT = Gem::Version.new(::Rails.version) >= Gem::Version.new("7.0.0")
+
+      if SUPPORTS_EXECUTION_CONTEXT
+        def execution_context
+          context = ::ActiveSupport::ExecutionContext.to_h
+          return {} if context.empty?
+
+          { "rails.error" => Sentry::Rails::Serializer.serialize(context) }
+        end
+      else
+        def execution_context
+          {}
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "sentry/rails/log_subscriber"
-require "sentry/rails/log_subscribers/parameter_filter"
 
 module Sentry
   module Rails
@@ -16,13 +15,10 @@ module Sentry
       # @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
@@ -55,9 +51,9 @@ module Sentry
             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?
+          if payload[:params].is_a?(Hash)
+            params = Sentry.configuration.data_collection.url_query_params.filter(payload[:params])
+            attributes[:params] = params unless params.empty?
           end
 
           level = level_for_request(payload)

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "sentry/rails/log_subscriber"
-require "sentry/rails/log_subscribers/parameter_filter"
 
 module Sentry
   module Rails
@@ -15,13 +14,10 @@ module Sentry
       # @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
@@ -41,8 +37,8 @@ module Sentry
           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]
+          if Sentry.configuration.data_collection.user_info && payload[:message_id]
+            attributes[:message_id] = payload[:message_id]
           end
 
           message = "Email delivered via #{mailer}"
@@ -73,9 +69,9 @@ module Sentry
             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?
+          if payload[:params].is_a?(Hash)
+            params = Sentry.configuration.data_collection.url_query_params.filter(payload[:params])
+            attributes[:params] = params unless params.empty?
           end
 
           message = "#{mailer}##{action}"

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "sentry/rails/log_subscriber"
-require "sentry/rails/log_subscribers/parameter_filter"
 
 module Sentry
   module Rails
@@ -15,13 +14,10 @@ module Sentry
       # @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
@@ -47,7 +43,7 @@ module Sentry
             attributes[:delay_ms] = ((Time.current - job.scheduled_at) * 1000).round(2)
           end
 
-          if Sentry.configuration.send_default_pii && job.arguments.present?
+          if Sentry.configuration.data_collection.queues && job.arguments.present?
             filtered_args = filter_sensitive_arguments(job.arguments)
             attributes[:arguments] = filtered_args unless filtered_args.empty?
           end
@@ -149,9 +145,11 @@ module Sentry
           arguments.map do |arg|
             case arg
             when Hash
-              filter_sensitive_params(arg)
+              # we're using url_query_params here since rails filter_parameters end up there
+              # and we don't have a dedicated queue params config yet
+              Sentry.configuration.data_collection.url_query_params.filter(arg, cookie: false)
             when String
-              arg.length > 100 ? "[FILTERED: #{arg.length} chars]" : arg
+              arg.length > 100 ? "[Filtered: #{arg.length} chars]" : arg
             else
               arg
             end

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "sentry/rails/log_subscriber"
-require "sentry/rails/log_subscribers/parameter_filter"
 
 module Sentry
   module Rails
@@ -16,13 +15,10 @@ module Sentry
       # @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
         EMPTY_ARRAY = [].freeze
 
@@ -49,7 +45,7 @@ module Sentry
 
           binds = event.payload[:binds]
 
-          if Sentry.configuration.send_default_pii && (binds && !binds.empty?)
+          if Sentry.configuration.data_collection.database_query_data && (binds && !binds.empty?)
             type_casted_binds = type_casted_binds(event)
 
             type_casted_binds.each_with_index do |value, index|

data/lib/sentry/rails/railtie.rb

@@ -21,6 +21,13 @@ module Sentry
       ActiveSupport.on_load(:active_job) do
         require "sentry/rails/active_job"
         prepend Sentry::Rails::ActiveJobExtensions
+
+        unless Sentry::Rails::ActiveJobExtensions::SentryReporter.producer_callback_registered?
+          around_enqueue do |job, block|
+            Sentry::Rails::ActiveJobExtensions::SentryReporter.record_producer_span(job, &block)
+          end
+          Sentry::Rails::ActiveJobExtensions::SentryReporter.producer_callback_registered!
+        end
       end
     end
 
@@ -135,7 +142,7 @@ module Sentry
     end
 
     def activate_structured_logging
-      if Sentry.configuration.rails.structured_logging.enabled? && Sentry.configuration.enable_logs
+      if Sentry.configuration.rails.structured_logging.enabled?
         Sentry::Rails::StructuredLogging.attach(Sentry.configuration.rails.structured_logging)
       end
     end

data/lib/sentry/rails/serializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Rails
+    module Serializer
+      def self.serialize(value)
+        case value
+        when Range
+          serialize_range(value)
+        when Hash
+          value.transform_values { |item| serialize(item) }
+        when Array, Enumerable
+          value.map { |item| serialize(item) }
+        when ->(item) { item.respond_to?(:to_global_id) }
+          serialize_global_id(value)
+        else
+          value
+        end
+      end
+
+      def self.serialize_global_id(value)
+        value.to_global_id.to_s
+      rescue StandardError
+        value
+      end
+
+      def self.serialize_range(range)
+        return range.to_s if range.begin.nil? || range.end.nil?
+        return range.to_s if range.begin.is_a?(::ActiveSupport::TimeWithZone)
+
+        range.map { |item| serialize(item) }
+      end
+    end
+  end
+end