sentry-rails 5.10.0 → 5.26.0

data/lib/sentry/rails/configuration.rb

@@ -1,7 +1,10 @@
+# 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"
 
 module Sentry
   class Configuration
@@ -12,9 +15,14 @@ module Sentry
       @excluded_exceptions = @excluded_exceptions.concat(Sentry::Rails::IGNORE_DEFAULT)
 
       if ::Rails.logger
-        @logger = ::Rails.logger
+        if defined?(::ActiveSupport::BroadcastLogger) && ::Rails.logger.is_a?(::ActiveSupport::BroadcastLogger)
+          dupped_broadcasts = ::Rails.logger.broadcasts.map(&:dup)
+          self.sdk_logger = ::ActiveSupport::BroadcastLogger.new(*dupped_broadcasts)
+        else
+          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`
@@ -26,21 +34,82 @@ module Sentry
 
   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 = {
+      # action_controller
+      "write_fragment.action_controller" => %i[key],
+      "read_fragment.action_controller" => %i[key],
+      "exist_fragment?.action_controller" => %i[key],
+      "expire_fragment.action_controller" => %i[key],
+      "start_processing.action_controller" => %i[controller action params format method path],
+      "process_action.action_controller" => %i[controller action params format method path status view_runtime db_runtime],
+      "send_file.action_controller" => %i[path],
+      "redirect_to.action_controller" => %i[status location],
+      "halted_callback.action_controller" => %i[filter],
+      # action_dispatch
+      "process_middleware.action_dispatch" => %i[middleware],
+      # action_view
+      "render_template.action_view" => %i[identifier layout],
+      "render_partial.action_view" => %i[identifier],
+      "render_collection.action_view" => %i[identifier count cache_hits],
+      "render_layout.action_view" => %i[identifier],
+      # active_record
+      "sql.active_record" => %i[sql name statement_name cached],
+      "instantiation.active_record" => %i[record_count class_name],
+      # action_mailer
+      # not including to, from, or subject..etc. because of PII concern
+      "deliver.action_mailer" => %i[mailer date perform_deliveries],
+      "process.action_mailer" => %i[mailer action params],
+      # active_support
+      "cache_read.active_support" => %i[key store hit],
+      "cache_generate.active_support" => %i[key store],
+      "cache_fetch_hit.active_support" => %i[key store],
+      "cache_write.active_support" => %i[key store],
+      "cache_delete.active_support" => %i[key store],
+      "cache_exist?.active_support" => %i[key store],
+      # active_job
+      "enqueue_at.active_job" => %i[],
+      "enqueue.active_job" => %i[],
+      "enqueue_retry.active_job" => %i[],
+      "perform_start.active_job" => %i[],
+      "perform.active_job" => %i[],
+      "retry_stopped.active_job" => %i[],
+      "discard.active_job" => %i[],
+      # action_cable
+      "perform_action.action_cable" => %i[channel_class action],
+      "transmit.action_cable" => %i[channel_class],
+      "transmit_subscription_confirmation.action_cable" => %i[channel_class],
+      "transmit_subscription_rejection.action_cable" => %i[channel_class],
+      "broadcast.action_cable" => %i[broadcasting],
+      # active_storage
+      "service_upload.active_storage" => %i[service key checksum],
+      "service_streaming_download.active_storage" => %i[service key],
+      "service_download_chunk.active_storage" => %i[service key],
+      "service_download.active_storage" => %i[service key],
+      "service_delete.active_storage" => %i[service key],
+      "service_delete_prefixed.active_storage" => %i[service prefix],
+      "service_exist.active_storage" => %i[service key exist],
+      "service_url.active_storage" => %i[service key url],
+      "service_update_metadata.active_storage" => %i[service key],
+      "preview.active_storage" => %i[key],
+      "analyze.active_storage" => %i[analyzer]
+    }.freeze
+
     class Configuration
       # Rails 7.0 introduced a new error reporter feature, which the SDK once opted-in by default.
       # But after receiving multiple issue reports, the integration seemed to cause serious troubles to some users.
@@ -50,8 +119,8 @@ module Sentry
 
       # Rails catches exceptions in the ActionDispatch::ShowExceptions or
       # ActionDispatch::DebugExceptions middlewares, depending on the environment.
-      # When `rails_report_rescued_exceptions` is true (it is by default), Sentry
-      # will report exceptions even when they are rescued by these middlewares.
+      # When `report_rescued_exceptions` is true (it is by default), Sentry will
+      # report exceptions even when they are rescued by these middlewares.
       attr_accessor :report_rescued_exceptions
 
       # Some adapters, like sidekiq, already have their own sentry integration.
@@ -60,6 +129,14 @@ module Sentry
 
       attr_accessor :tracing_subscribers
 
+      # When the ActiveRecordSubscriber is enabled, capture the source location of the query in the span data.
+      # This is enabled by default, but can be disabled by setting this to false.
+      attr_accessor :enable_db_query_source
+
+      # The threshold in milliseconds for the ActiveRecordSubscriber to capture the source location of the query
+      # in the span data. Default is 100ms.
+      attr_accessor :db_query_source_threshold_ms
+
       # sentry-rails by default skips asset request' transactions by checking if the path matches
       #
       # ```rb
@@ -75,6 +152,13 @@ module Sentry
       # ```
       attr_accessor :assets_regexp
 
+      # Hash of subscription items that will be shown in breadcrumbs active support logger.
+      # @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
+
       def initialize
         @register_error_subscriber = false
         @report_rescued_exceptions = true
@@ -84,9 +168,14 @@ 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
       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,6 +1,10 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     module ControllerTransaction
+      SPAN_ORIGIN = "auto.view.rails"
+
       def self.included(base)
         base.prepend_around_action(:sentry_around_action)
       end
@@ -11,7 +15,7 @@ module Sentry
         if Sentry.initialized?
           transaction_name = "#{self.class}##{action_name}"
           Sentry.get_current_scope.set_transaction_name(transaction_name, source: :view)
-          Sentry.with_child_span(op: "view.process_action.action_controller", description: transaction_name) do |child_span|
+          Sentry.with_child_span(op: "view.process_action.action_controller", description: transaction_name, origin: SPAN_ORIGIN) do |child_span|
             if child_span
               begin
                 result = yield
@@ -19,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.
@@ -19,7 +21,13 @@ module Sentry
           tags.merge!(context.delete(:tags))
         end
 
-        Sentry::Rails.capture_exception(error, level: severity, contexts: { "rails.error" => context }, tags: tags)
+        hint = {}
+        if context[:hint].is_a?(Hash)
+          context = context.dup
+          hint.merge!(context.delete(:hint))
+        end
+
+        Sentry::Rails.capture_exception(error, level: severity, contexts: { "rails.error" => context }, tags: tags, hint: hint)
       end
     end
   end

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/overrides/streaming_reporter.rb

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

data/lib/sentry/rails/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sentry/rails/capture_exceptions"
 require "sentry/rails/rescued_exception_interceptor"
 require "sentry/rails/backtrace_cleaner"
@@ -12,7 +14,7 @@ module Sentry
       app.config.middleware.insert_after ActionDispatch::DebugExceptions, Sentry::Rails::RescuedExceptionInterceptor
     end
 
-    # because the extension works by registering the around_perform callcack, it should always be ran
+    # because the extension works by registering the around_perform callback, it should always be run
     # before the application is eager-loaded (before user's jobs register their own callbacks)
     # See https://github.com/getsentry/sentry-ruby/issues/1249#issuecomment-853871871 for the detail explanation
     initializer "sentry.extend_active_job", before: :eager_load! do |app|
@@ -40,6 +42,7 @@ module Sentry
 
       configure_project_root
       configure_trusted_proxies
+      configure_cron_timezone
       extend_controller_methods if defined?(ActionController)
       patch_background_worker if defined?(ActiveRecord)
       override_streaming_reporter if defined?(ActionView)
@@ -48,6 +51,11 @@ module Sentry
       activate_tracing
 
       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
@@ -70,6 +78,11 @@ module Sentry
       Sentry.configuration.trusted_proxies += Array(::Rails.application.config.action_dispatch.trusted_proxies)
     end
 
+    def configure_cron_timezone
+      tz_info = ::ActiveSupport::TimeZone.find_tzinfo(::Rails.application.config.time_zone)
+      Sentry.configuration.cron.default_timezone = tz_info.name
+    end
+
     def extend_controller_methods
       require "sentry/rails/controller_methods"
       require "sentry/rails/controller_transaction"
@@ -88,14 +101,14 @@ module Sentry
 
     def inject_breadcrumbs_logger
       if Sentry.configuration.breadcrumbs_logger.include?(:active_support_logger)
-        require 'sentry/rails/breadcrumb/active_support_logger'
-        Sentry::Rails::Breadcrumb::ActiveSupportLogger.inject
+        require "sentry/rails/breadcrumb/active_support_logger"
+        Sentry::Rails::Breadcrumb::ActiveSupportLogger.inject(Sentry.configuration.rails.active_support_logger_subscription_items)
       end
 
       if Sentry.configuration.breadcrumbs_logger.include?(:monotonic_active_support_logger)
         return warn "Usage of `monotonic_active_support_logger` require a version of Rails >= 6.1, please upgrade your Rails version or use another logger" if ::Rails.version.to_f < 6.1
 
-        require 'sentry/rails/breadcrumb/monotonic_active_support_logger'
+        require "sentry/rails/breadcrumb/monotonic_active_support_logger"
         Sentry::Rails::Breadcrumb::MonotonicActiveSupportLogger.inject
       end
     end

data/lib/sentry/rails/rescued_exception_interceptor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     class RescuedExceptionInterceptor
@@ -17,7 +19,16 @@ module Sentry
       end
 
       def report_rescued_exceptions?
-        Sentry.configuration.rails.report_rescued_exceptions
+        # In rare edge cases, `Sentry.configuration` might be `nil` here.
+        # Hence, we use a safe navigation and fallback to a reasonable default
+        # of `true` in case the configuration couldn't be loaded.
+        # See https://github.com/getsentry/sentry-ruby/issues/2386
+        report_rescued_exceptions = Sentry.configuration&.rails&.report_rescued_exceptions
+        return report_rescued_exceptions unless report_rescued_exceptions.nil?
+
+        # `true` is the default for `report_rescued_exceptions`, as specified in
+        # `sentry-rails/lib/sentry/rails/configuration.rb`.
+        true
       end
     end
   end

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

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     module Tracing
       class AbstractSubscriber
-
         class << self
           def subscribe!
             raise NotImplementedError

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sentry/rails/tracing/abstract_subscriber"
 require "sentry/rails/instrument_payload_cleanup_helper"
 
@@ -8,10 +10,11 @@ module Sentry
         extend InstrumentPayloadCleanupHelper
 
         EVENT_NAMES = ["process_action.action_controller"].freeze
-        OP_NAME = "view.process_action.action_controller".freeze
+        OP_NAME = "view.process_action.action_controller"
+        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
@@ -22,6 +25,7 @@ module Sentry
 
             record_on_current_span(
               op: OP_NAME,
+              origin: SPAN_ORIGIN,
               start_timestamp: payload[START_TIMESTAMP_NAME],
               description: "#{controller}##{action}",
               duration: duration

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sentry/rails/tracing/abstract_subscriber"
 
 module Sentry
@@ -5,11 +7,18 @@ module Sentry
     module Tracing
       class ActionViewSubscriber < AbstractSubscriber
         EVENT_NAMES = ["render_template.action_view"].freeze
-        SPAN_PREFIX = "template.".freeze
+        SPAN_PREFIX = "template."
+        SPAN_ORIGIN = "auto.template.rails"
 
         def self.subscribe!
           subscribe_to_event(EVENT_NAMES) do |event_name, duration, payload|
-            record_on_current_span(op: SPAN_PREFIX + event_name, start_timestamp: payload[START_TIMESTAMP_NAME], description: payload[:identifier], duration: duration)
+            record_on_current_span(
+              op: SPAN_PREFIX + event_name,
+              origin: SPAN_ORIGIN,
+              start_timestamp: payload[START_TIMESTAMP_NAME],
+              description: payload[:identifier],
+              duration: duration
+            )
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sentry/rails/tracing/abstract_subscriber"
 
 module Sentry
@@ -5,16 +7,96 @@ module Sentry
     module Tracing
       class ActiveRecordSubscriber < AbstractSubscriber
         EVENT_NAMES = ["sql.active_record"].freeze
-        SPAN_PREFIX = "db.".freeze
+        SPAN_PREFIX = "db."
+        SPAN_ORIGIN = "auto.db.rails"
         EXCLUDED_EVENTS = ["SCHEMA", "TRANSACTION"].freeze
 
-        def self.subscribe!
-          subscribe_to_event(EVENT_NAMES) do |event_name, duration, payload|
-            next if EXCLUDED_EVENTS.include? payload[:name]
+        SUPPORT_SOURCE_LOCATION = ActiveSupport::BacktraceCleaner.method_defined?(:clean_frame)
+
+        if SUPPORT_SOURCE_LOCATION
+          class_attribute :backtrace_cleaner, default: (ActiveSupport::BacktraceCleaner.new.tap do |cleaner|
+            cleaner.add_silencer { |line| line.include?("sentry-ruby/lib") || line.include?("sentry-rails/lib") }
+          end)
+        end
+
+        class << self
+          def subscribe!
+            record_query_source = SUPPORT_SOURCE_LOCATION && Sentry.configuration.rails.enable_db_query_source
+            query_source_threshold = Sentry.configuration.rails.db_query_source_threshold_ms
+
+            subscribe_to_event(EVENT_NAMES) do |event_name, duration, payload|
+              next if EXCLUDED_EVENTS.include? payload[:name]
+
+              record_on_current_span(
+                op: SPAN_PREFIX + event_name,
+                origin: SPAN_ORIGIN,
+                start_timestamp: payload[START_TIMESTAMP_NAME],
+                description: payload[:sql],
+                duration: duration
+              ) do |span|
+                span.set_tag(:cached, true) if payload.fetch(:cached, false) # cached key is only set for hits in the QueryCache, from Rails 5.1
+
+                connection = payload[:connection]
+
+                if payload[:connection_id]
+                  span.set_data(:connection_id, payload[:connection_id])
+
+                  # we fallback to the base connection on rails < 6.0.0 since the payload doesn't have it
+                  connection ||= ActiveRecord::Base.connection_pool.connections.find { |conn| conn.object_id == payload[:connection_id] }
+                end
+
+                next unless connection
+
+                db_config =
+                  if connection.pool.respond_to?(:db_config)
+                    connection.pool.db_config.configuration_hash
+                  elsif connection.pool.respond_to?(:spec)
+                    connection.pool.spec.config
+                  end
 
-            record_on_current_span(op: SPAN_PREFIX + event_name, start_timestamp: payload[START_TIMESTAMP_NAME], description: payload[:sql], duration: duration) do |span|
-              span.set_data(:connection_id, payload[:connection_id])
-              span.set_tag(:cached, true) if payload.fetch(:cached, false) # cached key is only set for hits in the QueryCache, from Rails 5.1
+                next unless db_config
+
+                span.set_data(Span::DataConventions::DB_SYSTEM, db_config[:adapter]) if db_config[:adapter]
+                span.set_data(Span::DataConventions::DB_NAME, db_config[:database]) if db_config[:database]
+                span.set_data(Span::DataConventions::SERVER_ADDRESS, db_config[:host]) if db_config[:host]
+                span.set_data(Span::DataConventions::SERVER_PORT, db_config[:port]) if db_config[:port]
+                span.set_data(Span::DataConventions::SERVER_SOCKET_ADDRESS, db_config[:socket]) if db_config[:socket]
+
+                next unless record_query_source
+
+                # both duration and query_source_threshold are in ms
+                next unless duration >= query_source_threshold
+
+                source_location = query_source_location
+
+                if source_location
+                  backtrace_line = Sentry::Backtrace::Line.parse(source_location)
+
+                  span.set_data(Span::DataConventions::FILEPATH, backtrace_line.file) if backtrace_line.file
+                  span.set_data(Span::DataConventions::LINENO, backtrace_line.number) if backtrace_line.number
+                  span.set_data(Span::DataConventions::FUNCTION, backtrace_line.method) if backtrace_line.method
+                  # Only JRuby has namespace in the backtrace
+                  span.set_data(Span::DataConventions::NAMESPACE, backtrace_line.module_name) if backtrace_line.module_name
+                end
+              end
+            end
+          end
+
+          # Thread.each_caller_location is an API added in Ruby 3.2 that doesn't always collect the entire stack like
+          # Kernel#caller or #caller_locations do. See https://github.com/rails/rails/pull/49095 for more context.
+          if SUPPORT_SOURCE_LOCATION && Thread.respond_to?(:each_caller_location)
+            def query_source_location
+              Thread.each_caller_location do |location|
+                frame = backtrace_cleaner.clean_frame(location)
+                return frame if frame
+              end
+              nil
+            end
+          else
+            # Since Sentry is mostly used in production, we don't want to fallback to the slower implementation
+            # and adds potentially big overhead to the application.
+            def query_source_location
+              nil
             end
           end
         end

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require "sentry/rails/tracing/abstract_subscriber"
 
 module Sentry
   module Rails
     module Tracing
       class ActiveStorageSubscriber < AbstractSubscriber
-        EVENT_NAMES = %w(
+        EVENT_NAMES = %w[
           service_upload.active_storage
           service_download.active_storage
           service_streaming_download.active_storage
@@ -17,13 +19,24 @@ module Sentry
           service_update_metadata.active_storage
           preview.active_storage
           analyze.active_storage
-        ).freeze
+        ].freeze
+
+        SPAN_ORIGIN = "auto.file.rails"
 
         def self.subscribe!
           subscribe_to_event(EVENT_NAMES) do |event_name, duration, payload|
-            record_on_current_span(op: "file.#{event_name}".freeze, start_timestamp: payload[START_TIMESTAMP_NAME], description: payload[:service], duration: duration) do |span|
+            record_on_current_span(
+              op: "file.#{event_name}",
+              origin: SPAN_ORIGIN,
+              start_timestamp: payload[START_TIMESTAMP_NAME],
+              description: payload[:service],
+              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

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "sentry/rails/tracing/abstract_subscriber"
+
+module Sentry
+  module Rails
+    module Tracing
+      class ActiveSupportSubscriber < AbstractSubscriber
+        READ_EVENT_NAMES = %w[
+          cache_read.active_support
+        ].freeze
+
+        WRITE_EVENT_NAMES = %w[
+          cache_write.active_support
+          cache_increment.active_support
+          cache_decrement.active_support
+        ].freeze
+
+        REMOVE_EVENT_NAMES = %w[
+          cache_delete.active_support
+        ].freeze
+
+        FLUSH_EVENT_NAMES = %w[
+          cache_prune.active_support
+        ].freeze
+
+        EVENT_NAMES = READ_EVENT_NAMES + WRITE_EVENT_NAMES + REMOVE_EVENT_NAMES + FLUSH_EVENT_NAMES
+
+        SPAN_ORIGIN = "auto.cache.rails"
+
+        def self.subscribe!
+          subscribe_to_event(EVENT_NAMES) do |event_name, duration, payload|
+            record_on_current_span(
+              op: operation_name(event_name),
+              origin: SPAN_ORIGIN,
+              start_timestamp: payload[START_TIMESTAMP_NAME],
+              description: payload[:store],
+              duration: duration
+            ) do |span|
+              span.set_data("cache.key", [*payload[:key]].select { |key| Utils::EncodingHelper.valid_utf_8?(key) })
+              span.set_data("cache.hit", payload[:hit] == true) # Handle nil case
+            end
+          end
+        end
+
+        def self.operation_name(event_name)
+          case
+          when READ_EVENT_NAMES.include?(event_name)
+            "cache.get"
+          when WRITE_EVENT_NAMES.include?(event_name)
+            "cache.put"
+          when REMOVE_EVENT_NAMES.include?(event_name)
+            "cache.remove"
+          when FLUSH_EVENT_NAMES.include?(event_name)
+            "cache.flush"
+          else
+            "other"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/tracing.rb

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

data/lib/sentry/rails/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
-    VERSION = "5.10.0"
+    VERSION = "5.26.0"
   end
 end

data/lib/sentry/rails.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails"
 require "sentry-ruby"
 require "sentry/integrable"

data/lib/sentry-rails.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require "sentry/rails/version"
 require "sentry/rails"