sentry-rails 5.3.0 → 5.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c10021ca91c13dc4b34f024269a01974d75e8971b72b027f497c7c3c248ba448
-  data.tar.gz: e4daa4206bd67b93787a7b08653808d72f7e1f667caab27f2382496e9dec474b
+  metadata.gz: 7338e366bfa078e533320c9d9fcac994ca4202104a3a3efb2069644d4ac80e9c
+  data.tar.gz: 27b90498fc73e7884ffcdea4733244723fa0e6f8a48d3322f9e7a91b25f8b73b
 SHA512:
-  metadata.gz: 18b27b1e7b1acc3facd390069f7cd62ef434bd94b5dee2cd440f6f29cfb7b3411193c7425851116aaa199394f57df93c3d1be4c634e8d9a985786342a7ca6745
-  data.tar.gz: f4a3c87c7b053b9e3c0adaffa620570b0d92be984d8c2337df552fcab1a9cae1b34c299f3bdb5506106037d960f35b8cc8f51a9f3b73d8666e2ee0ae02634055
+  metadata.gz: 7c67ec56cf2d1cd69d8808f7a83ce2af69fea58781fff3c5979bac4005ea077451b9682e6e45b1b8333d9d1b42cb29690dc53cc59b6baef4ba2ef47895bd0bb0
+  data.tar.gz: 1ec19c91b4d6e7bd2255c2f73ad12f035d90433a1d36a6fbba4f7ec21cbe6d5694b9ec44690ac22411003ab2e6948b9a56da8ba441123a84daa1d4b477266a51

data/Gemfile

@@ -18,12 +18,14 @@ else
   gem "sqlite3", platform: :ruby
 end
 
-if rails_version >= Gem::Version.new("7.0.0")
-  gem "rails", github: "rails/rails", branch: "7-0-stable"
+if rails_version > Gem::Version.new("7.0.0")
+  gem "rails", github: "rails/rails"
 else
   gem "rails", "~> #{rails_version}"
 end
 
+gem "mini_magick"
+
 gem "sprockets-rails"
 
 gem "sidekiq"

data/lib/sentry/rails/action_cable.rb

@@ -2,6 +2,8 @@ module Sentry
   module Rails
     module ActionCableExtensions
       class ErrorHandler
+        OP_NAME = "websocket.server".freeze
+
         class << self
           def capture(connection, transaction_name:, extra_context: nil, &block)
             return block.call unless Sentry.initialized?
@@ -13,13 +15,14 @@ module Sentry
             Sentry.with_scope do |scope|
               scope.set_rack_env(env)
               scope.set_context("action_cable", extra_context) if extra_context
-              scope.set_transaction_name(transaction_name)
-              transaction = start_transaction(env, scope.transaction_name)
+              scope.set_transaction_name(transaction_name, source: :view)
+              transaction = start_transaction(env, scope)
               scope.set_span(transaction) if transaction
 
               begin
-                block.call
+                result = block.call
                 finish_transaction(transaction, 200)
+                result
               rescue Exception => e # rubocop:disable Lint/RescueException
                 Sentry::Rails.capture_exception(e)
                 finish_transaction(transaction, 500)
@@ -29,10 +32,12 @@ module Sentry
             end
           end
 
-          def start_transaction(env, transaction_name)
+          def start_transaction(env, scope)
             sentry_trace = env["HTTP_SENTRY_TRACE"]
-            options = { name: transaction_name, op: "rails.action_cable".freeze }
-            transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, **options) if sentry_trace
+            baggage = env["HTTP_BAGGAGE"]
+
+            options = { name: scope.transaction_name, source: scope.transaction_source, op: OP_NAME }
+            transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, baggage: baggage, **options) if sentry_trace
             Sentry.start_transaction(transaction: transaction, **options)
           end
 

data/lib/sentry/rails/active_job.rb

@@ -16,16 +16,18 @@ module Sentry
       end
 
       class SentryReporter
+        OP_NAME = "queue.active_job".freeze
+
         class << self
           def record(job, &block)
             Sentry.with_scope do |scope|
               begin
-                scope.set_transaction_name(job.class.name)
+                scope.set_transaction_name(job.class.name, source: :task)
                 transaction =
                   if job.is_a?(::Sentry::SendEventJob)
                     nil
                   else
-                    Sentry.start_transaction(name: scope.transaction_name, op: "active_job")
+                    Sentry.start_transaction(name: scope.transaction_name, source: scope.transaction_source, op: OP_NAME)
                   end
 
                 scope.set_span(transaction) if transaction

data/lib/sentry/rails/background_worker.rb

@@ -1,14 +1,12 @@
 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.with_connection do
-          block.call
-        end
-      else
-        block.call
+        ActiveRecord::Base.connection_pool.release_connection
       end
     end
   end

data/lib/sentry/rails/capture_exceptions.rb

@@ -1,11 +1,11 @@
 module Sentry
   module Rails
     class CaptureExceptions < Sentry::Rack::CaptureExceptions
-      def initialize(app)
+      def initialize(_)
         super
 
-        if defined?(::Sprockets::Rails)
-          @assets_regex = %r(\A/{0,2}#{::Rails.application.config.assets.prefix})
+        if Sentry.initialized?
+          @assets_regexp = Sentry.configuration.rails.assets_regexp
         end
       end
 
@@ -17,28 +17,30 @@ module Sentry
       end
 
       def transaction_op
-        "rails.request".freeze
+        "http.server".freeze
       end
 
-      def capture_exception(exception)
-        current_scope = Sentry.get_current_scope
+      def capture_exception(exception, env)
+        request = ActionDispatch::Request.new(env)
 
-        if original_transaction = current_scope.rack_env["sentry.original_transaction"]
-          current_scope.set_transaction_name(original_transaction)
+        # the exception will be swallowed by ShowExceptions middleware
+        return if request.show_exceptions? && !Sentry.configuration.rails.report_rescued_exceptions
+        Sentry::Rails.capture_exception(exception).tap do |event|
+          env[ERROR_EVENT_ID_KEY] = event.event_id if event
         end
-
-        Sentry::Rails.capture_exception(exception)
       end
 
       def start_transaction(env, scope)
         sentry_trace = env["HTTP_SENTRY_TRACE"]
-        options = { name: scope.transaction_name, op: transaction_op }
+        baggage = env["HTTP_BAGGAGE"]
+
+        options = { name: scope.transaction_name, source: scope.transaction_source, op: transaction_op }
 
-        if @assets_regex && scope.transaction_name.match?(@assets_regex)
+        if @assets_regexp && scope.transaction_name.match?(@assets_regexp)
           options.merge!(sampled: false)
         end
 
-        transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, **options) if sentry_trace
+        transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, baggage: baggage, **options) if sentry_trace
         Sentry.start_transaction(transaction: transaction, custom_sampling_context: { env: env }, **options)
       end
     end

data/lib/sentry/rails/configuration.rb

@@ -60,12 +60,29 @@ module Sentry
 
       attr_accessor :tracing_subscribers
 
+      # sentry-rails by default skips asset request' transactions by checking if the path matches
+      #
+      # ```rb
+      # %r(\A/{0,2}#{::Rails.application.config.assets.prefix})
+      # ```
+      #
+      # If you want to use a different pattern, you can configure the `assets_regexp` option like:
+      #
+      # ```rb
+      # Sentry.init do |config|
+      #   config.rails.assets_regexp = /my_regexp/
+      # end
+      # ```
+      attr_accessor :assets_regexp
+
       def initialize
         @register_error_subscriber = false
         @report_rescued_exceptions = true
         @skippable_job_adapters = []
+        @assets_regexp = if defined?(::Sprockets::Rails)
+          %r(\A/{0,2}#{::Rails.application.config.assets.prefix})
+        end
         @tracing_subscribers = Set.new([
-          Sentry::Rails::Tracing::ActionControllerSubscriber,
           Sentry::Rails::Tracing::ActionViewSubscriber,
           Sentry::Rails::Tracing::ActiveRecordSubscriber,
           Sentry::Rails::Tracing::ActiveStorageSubscriber

data/lib/sentry/rails/controller_transaction.rb

@@ -2,8 +2,34 @@ module Sentry
   module Rails
     module ControllerTransaction
       def self.included(base)
-        base.prepend_before_action do |controller|
-          Sentry.get_current_scope.set_transaction_name("#{controller.class}##{controller.action_name}")
+        base.prepend_around_action(:sentry_around_action)
+      end
+
+      private
+
+      def sentry_around_action
+        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|
+            if child_span
+              begin
+                result = yield
+              ensure
+                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)
+              end
+
+              result
+            else
+              yield
+            end
+          end
+        else
+          yield
         end
       end
     end

data/lib/sentry/rails/error_subscriber.rb

@@ -1,10 +1,25 @@
 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.
-    # See https://github.com/rails/rails/blob/main/activesupport/lib/active_support/error_reporter.rb for more information.
+    # See https://github.com/rails/rails/blob/main/activesupport/lib/active_support/error_reporter.rb to learn more about reporting APIs.
+    # If you want Sentry to subscribe to the error reporter, please set `config.rails.register_error_subscriber` to `true`.
     class ErrorSubscriber
-      def report(error, handled:, severity:, context:)
-        Sentry::Rails.capture_exception(error, level: severity, contexts: { "rails.error" => context }, tags: { handled: handled })
+      SKIP_SOURCES = Regexp.union([/.*_cache_store.active_support/])
+
+      def report(error, handled:, severity:, context:, source: nil)
+        tags = { handled: handled }
+
+        if source
+          return if SKIP_SOURCES.match?(source)
+          tags[:source] = source
+        end
+
+        if context[:tags].is_a?(Hash)
+          context = context.dup
+          tags.merge!(context.delete(:tags))
+        end
+
+        Sentry::Rails.capture_exception(error, level: severity, contexts: { "rails.error" => context }, tags: tags)
       end
     end
   end

data/lib/sentry/rails/railtie.rb

@@ -53,6 +53,13 @@ module Sentry
     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
@@ -110,7 +117,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

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

@@ -8,14 +8,20 @@ module Sentry
         extend InstrumentPayloadCleanupHelper
 
         EVENT_NAMES = ["process_action.action_controller"].freeze
+        OP_NAME = "view.process_action.action_controller".freeze
 
         def self.subscribe!
+          Sentry.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
+
           subscribe_to_event(EVENT_NAMES) do |event_name, duration, payload|
             controller = payload[:controller]
             action = payload[:action]
 
             record_on_current_span(
-              op: event_name,
+              op: OP_NAME,
               start_timestamp: payload[START_TIMESTAMP_NAME],
               description: "#{controller}##{action}",
               duration: duration

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

@@ -14,6 +14,7 @@ module Sentry
 
             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
             end
           end
         end

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

@@ -21,7 +21,7 @@ module Sentry
 
         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}".freeze, 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
               end

data/lib/sentry/rails/tracing.rb

@@ -67,7 +67,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,5 @@
 module Sentry
   module Rails
-    VERSION = "5.3.0"
+    VERSION = "5.8.0"
   end
 end

data/sentry-rails.gemspec

@@ -23,5 +23,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "railties", ">= 5.0"
-  spec.add_dependency "sentry-ruby-core", "~> 5.3.0"
+  spec.add_dependency "sentry-ruby", "~> 5.8.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-rails
 version: !ruby/object:Gem::Version
-  version: 5.3.0
+  version: 5.8.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-04-27 00:00:00.000000000 Z
+date: 2023-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: sentry-ruby-core
+  name: sentry-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.3.0
+        version: 5.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.3.0
+        version: 5.8.0
 description: A gem that provides Rails integration for the Sentry error logger
 email: accounts@sentry.io
 executables: []