sentry-rails 4.8.1 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5457a6fe448b94ade0388542ea975187fb7dd532d5a4ee3ec8caf65b6b2d785d
-  data.tar.gz: a4d537a4d7c3ddebc41afdb1e00187c5a776bfa269c4342f802cc1252146d4f6
+  metadata.gz: a6ab84e3b98547af93706b752c0242271cc0fc684269deb3bda71318b03536a0
+  data.tar.gz: 324b90217b7331cb38267ccdd39c07d9a87abf52880d40741ea0435e26dec621
 SHA512:
-  metadata.gz: 6aff15bc8465765af61e404ea7a709057531a12d018fd93624fa7f470e5d7c2c51c5105c4ef63225ec66a867b54cab57e0d8b40046f145d1a43d7b641c454a58
-  data.tar.gz: e597ec4f143aca81cc4b3bf5aa47315eb84f02df0f93a4d402b701dfe32a811dcc2eba7c437bde430cd21d2fea98eae3ee4c3f324dedc24a63941b06bdcf82bb
+  metadata.gz: 153d75c83b8756638f554c0a8de42154ff1e76e13725fee6a1c576bb936b1df0ac6f84968eb5bd6da1c3348052b491355aa67f233c97db8979a0f534ee65d53d
+  data.tar.gz: af6b9717fee9623f8923df70aa52a1b898a9296d2a28f8624f8d1358ad0569213cdb2fd34add7742509b5e247292c6a318541c329bfa0ae64c4fda578260682c

data/.gitignore

@@ -5,7 +5,7 @@
 /doc/
 /pkg/
 /spec/reports/
-/spec/support/test_rails_app/db
+/spec/dummy/test_rails_app/db
 /tmp/
 
 # rspec failure tracking

data/Gemfile

@@ -5,18 +5,24 @@ gemspec
 gem "sentry-ruby", path: "../sentry-ruby"
 
 rails_version = ENV["RAILS_VERSION"]
-rails_version = "6.1.0" if rails_version.nil?
+rails_version = "7.0.0" if rails_version.nil?
+rails_version = Gem::Version.new(rails_version)
 
 gem 'activerecord-jdbcmysql-adapter', platform: :jruby
 gem "jdbc-sqlite3", platform: :jruby
 
-if rails_version.to_f < 6
+if rails_version < Gem::Version.new("6.0.0")
   gem "sqlite3", "~> 1.3.0", platform: :ruby
 else
   gem "sqlite3", platform: :ruby
 end
 
-gem "rails", "~> #{rails_version}"
+if rails_version >= Gem::Version.new("7.0.0")
+  gem "rails", github: "rails/rails", branch: "7-0-stable"
+else
+  gem "rails", "~> #{rails_version}"
+end
+
 gem "sprockets-rails"
 
 gem "sidekiq"

data/app/jobs/sentry/send_event_job.rb

@@ -16,8 +16,8 @@ if defined?(ActiveJob)
         discard_on ActiveJob::DeserializationError
       else
         # mimic what discard_on does for Rails 5.0
-        rescue_from ActiveJob::DeserializationError do
-          logger.error "Discarded #{self.class} due to a #{exception}. The original exception was #{error.cause.inspect}."
+        rescue_from ActiveJob::DeserializationError do |exception|
+          logger.error "Discarded #{self.class} due to a #{exception}. The original exception was #{exception.cause.inspect}."
         end
       end
 

data/lib/sentry/rails/action_cable.rb

@@ -0,0 +1,96 @@
+module Sentry
+  module Rails
+    module ActionCableExtensions
+      class ErrorHandler
+        class << self
+          def capture(connection, transaction_name:, extra_context: nil, &block)
+            return block.call unless Sentry.initialized?
+            # ActionCable's ConnectionStub (for testing) doesn't implement the exact same interfaces as Connection::Base.
+            # One thing that's missing is `env`. So calling `connection.env` direclty will fail in test environments when `stub_connection` is used.
+            # See https://github.com/getsentry/sentry-ruby/pull/1684 for more information.
+            env = connection.respond_to?(:env) ? connection.env : {}
+
+            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_span(transaction) if transaction
+
+              begin
+                block.call
+                finish_transaction(transaction, 200)
+              rescue Exception => e # rubocop:disable Lint/RescueException
+                Sentry::Rails.capture_exception(e)
+                finish_transaction(transaction, 500)
+
+                raise
+              end
+            end
+          end
+
+          def start_transaction(env, transaction_name)
+            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
+            Sentry.start_transaction(transaction: transaction, **options)
+          end
+
+          def finish_transaction(transaction, status_code)
+            return unless transaction
+
+            transaction.set_http_status(status_code)
+            transaction.finish
+          end
+        end
+      end
+
+      module Connection
+        private
+
+        def handle_open
+          ErrorHandler.capture(self, transaction_name: "#{self.class.name}#connect") do
+            super
+          end
+        end
+
+        def handle_close
+          ErrorHandler.capture(self, transaction_name: "#{self.class.name}#disconnect") do
+            super
+          end
+        end
+      end
+
+      module Channel
+        module Subscriptions
+          def self.included(base)
+            base.class_eval do
+              set_callback :subscribe, :around, ->(_, block) { sentry_capture(:subscribed, &block) }, prepend: true
+              set_callback :unsubscribe, :around, ->(_, block) { sentry_capture(:unsubscribed, &block) }, prepend: true
+            end
+          end
+
+          private
+
+          def sentry_capture(hook, &block)
+            extra_context = { params: params }
+
+            ErrorHandler.capture(connection, transaction_name: "#{self.class.name}##{hook}", extra_context: extra_context, &block)
+          end
+        end
+
+        module Actions
+          private
+
+          def dispatch_action(action, data)
+            extra_context = { params: params, data: data }
+
+            ErrorHandler.capture(connection, transaction_name: "#{self.class.name}##{action}", extra_context: extra_context) do
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/active_job.rb

@@ -1,79 +1,86 @@
 module Sentry
   module Rails
     module ActiveJobExtensions
-      def self.included(base)
-        base.class_eval do
-          around_perform do |job, block|
-            if Sentry.initialized?
-              if already_supported_by_specific_integration?(job)
-                block.call
-              else
-                Sentry.with_scope do |scope|
-                  capture_and_reraise_with_sentry(job, scope, block)
-                end
-              end
-            else
-              block.call
-            end
+      def perform_now
+        if !Sentry.initialized? || already_supported_by_sentry_integration?
+          super
+        else
+          SentryReporter.record(self) do
+            super
           end
         end
       end
 
-      def capture_and_reraise_with_sentry(job, scope, block)
-        scope.set_transaction_name(job.class.name)
-        transaction =
-          if job.is_a?(::Sentry::SendEventJob)
-            nil
-          else
-            Sentry.start_transaction(name: scope.transaction_name, op: "active_job")
-          end
+      def already_supported_by_sentry_integration?
+        Sentry.configuration.rails.skippable_job_adapters.include?(self.class.queue_adapter.class.to_s)
+      end
 
-        scope.set_span(transaction) if transaction
+      class SentryReporter
+        class << self
+          def record(job, &block)
+            Sentry.with_scope do |scope|
+              begin
+                scope.set_transaction_name(job.class.name)
+                transaction =
+                  if job.is_a?(::Sentry::SendEventJob)
+                    nil
+                  else
+                    Sentry.start_transaction(name: scope.transaction_name, op: "active_job")
+                  end
 
-        block.call
+                scope.set_span(transaction) if transaction
 
-        finish_transaction(transaction, 200)
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        rescue_handler_result = rescue_with_handler(e)
-        finish_transaction(transaction, 500)
-        return rescue_handler_result if rescue_handler_result
+                yield.tap do
+                  finish_sentry_transaction(transaction, 200)
+                end
+              rescue Exception => e # rubocop:disable Lint/RescueException
+                finish_sentry_transaction(transaction, 500)
 
-        Sentry::Rails.capture_exception(
-          e,
-          extra: sentry_context(job),
-          tags: {
-            job_id: job.job_id,
-            provider_job_id: job.provider_job_id
-          }
-        )
-        raise e
-      end
+                Sentry::Rails.capture_exception(
+                  e,
+                  extra: sentry_context(job),
+                  tags: {
+                    job_id: job.job_id,
+                    provider_job_id: job.provider_job_id
+                  }
+                )
+                raise
+              end
+            end
+          end
 
-      def finish_transaction(transaction, status)
-        return unless transaction
+          def finish_sentry_transaction(transaction, status)
+            return unless transaction
 
-        transaction.set_http_status(status)
-        transaction.finish
-      end
+            transaction.set_http_status(status)
+            transaction.finish
+          end
 
-      def already_supported_by_specific_integration?(job)
-        Sentry.configuration.rails.skippable_job_adapters.include?(job.class.queue_adapter.class.to_s)
-      end
+          def sentry_context(job)
+            {
+              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
+            }
+          end
 
-      def sentry_context(job)
-        {
-          active_job: job.class.name,
-          arguments: job.arguments,
-          scheduled_at: job.scheduled_at,
-          job_id: job.job_id,
-          provider_job_id: job.provider_job_id,
-          locale: job.locale
-        }
+          def sentry_serialize_arguments(argument)
+            case argument
+            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
+          end
+        end
       end
     end
   end
 end
-
-class ActiveJob::Base
-  include Sentry::Rails::ActiveJobExtensions
-end

data/lib/sentry/rails/error_subscriber.rb

@@ -0,0 +1,11 @@
+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.
+    class ErrorSubscriber
+      def report(error, handled:, severity:, context:)
+        Sentry::Rails.capture_exception(error, level: severity, contexts: { "rails.error" => context }, tags: { handled: handled })
+      end
+    end
+  end
+end

data/lib/sentry/rails/railtie.rb

@@ -22,6 +22,19 @@ module Sentry
       end
     end
 
+    initializer "sentry.extend_action_cable", before: :eager_load! do |app|
+      ActiveSupport.on_load(:action_cable_connection) do
+        require "sentry/rails/action_cable"
+        prepend Sentry::Rails::ActionCableExtensions::Connection
+      end
+
+      ActiveSupport.on_load(:action_cable_channel) do
+        require "sentry/rails/action_cable"
+        include Sentry::Rails::ActionCableExtensions::Channel::Subscriptions
+        prepend Sentry::Rails::ActionCableExtensions::Channel::Actions
+      end
+    end
+
     config.after_initialize do |app|
       next unless Sentry.initialized?
 
@@ -33,6 +46,8 @@ module Sentry
       setup_backtrace_cleanup_callback
       inject_breadcrumbs_logger
       activate_tracing
+
+      register_error_subscriber(app) if ::Rails.version.to_f >= 7.0
     end
 
     runner do
@@ -102,5 +117,10 @@ module Sentry
         Sentry::Rails::Tracing.patch_active_support_notifications
       end
     end
+
+    def register_error_subscriber(app)
+      require "sentry/rails/error_subscriber"
+      app.executor.error_reporter.subscribe(Sentry::Rails::ErrorSubscriber.new)
+    end
   end
 end

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

@@ -5,10 +5,11 @@ module Sentry
     module Tracing
       class ActionViewSubscriber < AbstractSubscriber
         EVENT_NAMES = ["render_template.action_view"].freeze
+        SPAN_PREFIX = "template.".freeze
 
         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[:identifier], duration: duration)
+            record_on_current_span(op: SPAN_PREFIX + event_name, start_timestamp: payload[START_TIMESTAMP_NAME], description: payload[:identifier], duration: duration)
           end
         end
       end

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

@@ -5,13 +5,14 @@ module Sentry
     module Tracing
       class ActiveRecordSubscriber < AbstractSubscriber
         EVENT_NAMES = ["sql.active_record"].freeze
+        SPAN_PREFIX = "db.".freeze
         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]
 
-            record_on_current_span(op: event_name, start_timestamp: payload[START_TIMESTAMP_NAME], description: payload[:sql], duration: duration) do |span|
+            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])
             end
           end

data/lib/sentry/rails/version.rb

@@ -1,5 +1,5 @@
 module Sentry
   module Rails
-    VERSION = "4.8.1"
+    VERSION = "5.2.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", "~> 4.8.1"
+  spec.add_dependency "sentry-ruby-core", "~> 5.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-rails
 version: !ruby/object:Gem::Version
-  version: 4.8.1
+  version: 5.2.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-22 00:00:00.000000000 Z
+date: 2022-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.8.1
+        version: 5.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.8.1
+        version: 5.2.0
 description: A gem that provides Rails integration for the Sentry error logger
 email: accounts@sentry.io
 executables: []
@@ -60,6 +60,7 @@ files:
 - bin/setup
 - lib/sentry-rails.rb
 - lib/sentry/rails.rb
+- lib/sentry/rails/action_cable.rb
 - lib/sentry/rails/active_job.rb
 - lib/sentry/rails/background_worker.rb
 - lib/sentry/rails/backtrace_cleaner.rb
@@ -70,6 +71,7 @@ files:
 - lib/sentry/rails/controller_methods.rb
 - lib/sentry/rails/controller_transaction.rb
 - lib/sentry/rails/engine.rb
+- lib/sentry/rails/error_subscriber.rb
 - lib/sentry/rails/instrument_payload_cleanup_helper.rb
 - lib/sentry/rails/overrides/streaming_reporter.rb
 - lib/sentry/rails/railtie.rb