sentry-rails 5.1.0 → 6.2.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     module Overrides
@@ -7,17 +9,6 @@ module Sentry
           super
         end
       end
-
-      module OldStreamingReporter
-        def self.included(base)
-          base.send(:alias_method_chain, :log_error, :raven)
-        end
-
-        def log_error_with_raven(exception)
-          Sentry::Rails.capture_exception(exception)
-          log_error_without_raven(exception)
-        end
-      end
     end
   end
 end

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,19 +42,33 @@ 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)
       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
 
-      register_error_subscriber(app) if ::Rails.version.to_f >= 7.0
+      # 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
       next unless Sentry.initialized?
       Sentry.configuration.background_worker_threads = 0
+
+      at_exit do
+        # TODO: Add a condition for Rails 7.1 to avoid confliction with https://github.com/rails/rails/pull/44999
+        if $ERROR_INFO && !($ERROR_INFO.is_a?(SystemExit) && $ERROR_INFO.success?)
+          Sentry::Rails.capture_exception($ERROR_INFO, tags: { source: "runner" })
+        end
+      end
     end
 
     def configure_project_root
@@ -63,6 +79,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"
@@ -80,16 +101,11 @@ module Sentry
     end
 
     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
-      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'
-        Sentry::Rails::Breadcrumb::MonotonicActiveSupportLogger.inject
+      if Sentry.configuration.breadcrumbs_logger.include?(:active_support_logger) ||
+        ## legacy name redirected for backwards compat
+        Sentry.configuration.breadcrumbs_logger.include?(:monotonic_active_support_logger)
+        require "sentry/rails/breadcrumb/active_support_logger"
+        Sentry::Rails::Breadcrumb::ActiveSupportLogger.inject(Sentry.configuration.rails.active_support_logger_subscription_items)
       end
     end
 
@@ -110,7 +126,7 @@ module Sentry
     end
 
     def activate_tracing
-      if Sentry.configuration.tracing_enabled?
+      if Sentry.configuration.tracing_enabled? && Sentry.configuration.instrumenter == :sentry
         subscribers = Sentry.configuration.rails.tracing_subscribers
         Sentry::Rails::Tracing.register_subscribers(subscribers)
         Sentry::Rails::Tracing.subscribe_tracing_events
@@ -118,6 +134,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/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/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/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
@@ -40,15 +41,12 @@ module Sentry
           def record_on_current_span(duration:, **options)
             return unless options[:start_timestamp]
 
-            scope = Sentry.get_current_scope
-            transaction = scope.get_transaction
-            return unless transaction && transaction.sampled
-
-            span = transaction.start_child(**options)
-            # duration in ActiveSupport is computed in millisecond
-            # so we need to covert it as second before calculating the timestamp
-            span.set_timestamp(span.start_timestamp + duration / 1000)
-            yield(span) if block_given?
+            Sentry.with_child_span(**options) do |child_span|
+              # duration in ActiveSupport is computed in millisecond
+              # so we need to covert it as second before calculating the timestamp
+              child_span.set_timestamp(child_span.start_timestamp + duration / 1000)
+              yield(child_span) if block_given?
+            end
           end
         end
       end

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,19 +1,83 @@
+# frozen_string_literal: true
+
 require "sentry/rails/tracing/abstract_subscriber"
+require "sentry/backtrace"
 
 module Sentry
   module Rails
     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
+          backtrace_cleaner = ActiveSupport::BacktraceCleaner.new.tap do |cleaner|
+            cleaner.add_silencer { |line| line.include?("sentry-ruby/lib") || line.include?("sentry-rails/lib") }
+          end.method(:clean_frame)
+
+          class_attribute :backtrace_cleaner, default: backtrace_cleaner
+        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
+
+                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]
+
+                # both duration and query_source_threshold are in ms
+                if record_query_source && duration >= query_source_threshold
+                  backtrace_line = Backtrace.source_location(&backtrace_cleaner)
 
-            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])
+                  if backtrace_line
+                    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
           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: event_name, 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
@@ -67,7 +69,7 @@ module Sentry
       end
 
       def self.get_current_transaction
-        Sentry.get_current_scope.get_transaction
+        Sentry.get_current_scope.get_transaction if Sentry.initialized?
       end
 
       # it's just a container for the extended method

data/lib/sentry/rails/version.rb

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

data/lib/sentry/rails.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require "rails"
 require "sentry-ruby"
 require "sentry/integrable"
 require "sentry/rails/tracing"
 require "sentry/rails/configuration"
+require "sentry/rails/structured_logging"
 require "sentry/rails/engine"
 require "sentry/rails/railtie"
 

data/lib/sentry-rails.rb

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

data/sentry-rails.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "lib/sentry/rails/version"
 
 Gem::Specification.new do |spec|
@@ -7,21 +9,27 @@ Gem::Specification.new do |spec|
   spec.description = spec.summary = "A gem that provides Rails integration for the Sentry error logger"
   spec.email = "accounts@sentry.io"
   spec.license = 'MIT'
-  spec.homepage = "https://github.com/getsentry/sentry-ruby"
 
   spec.platform = Gem::Platform::RUBY
-  spec.required_ruby_version = '>= 2.4'
+  spec.required_ruby_version = '>= 2.7'
   spec.extra_rdoc_files = ["README.md", "LICENSE.txt"]
-  spec.files = `git ls-files | grep -Ev '^(spec|benchmarks|examples)'`.split("\n")
+  spec.files = `git ls-files | grep -Ev '^(spec|benchmarks|examples|\.rubocop\.yml)'`.split("\n")
+
+  github_root_uri = 'https://github.com/getsentry/sentry-ruby'
+  spec.homepage = "#{github_root_uri}/tree/#{spec.version}/#{spec.name}"
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "changelog_uri" => "#{github_root_uri}/blob/#{spec.version}/CHANGELOG.md",
+    "bug_tracker_uri" => "#{github_root_uri}/issues",
+    "documentation_uri" => "http://www.rubydoc.info/gems/#{spec.name}/#{spec.version}"
+  }
 
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "railties", ">= 5.0"
-  spec.add_dependency "sentry-ruby-core", "~> 5.1.0"
+  spec.add_dependency "railties", ">= 5.2.0"
+  spec.add_dependency "sentry-ruby", "~> 6.2.0"
 end