sentry-rails 4.4.0 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fba76642a6793e6026aca10630ca659fae4832d31aed0710d31805da14676c3
-  data.tar.gz: 15a570cc7acefceeb6e601d52cd2b55763761cb9e855d21282ba75b5a05a578b
+  metadata.gz: 59ad5d09cc5a579e3790610a661a3ea67fea7a71c11859ad8731d67ccb57f4c9
+  data.tar.gz: 982e987f3905ee2b4dec3d254ddfa055cd635857307d2a4a798bf01451b7a757
 SHA512:
-  metadata.gz: a57118b831bf7830caea725b3fdd008d4015026db29bb82dbbdccf98476a0686a795868b4d4831e7ee09cd8cbffa0adeadeb2ab646a37f37ee3c74da90f34874
-  data.tar.gz: 0e0e165ce9d0ee629bd8df754e08615fc1ce73b68928b483ba2abe5304bfe71ee92037c617f63b594b41286f722c62bbc79f44ff116a0546ef833e749fdba81b
+  metadata.gz: 4afbf7ca6532f422ce2f772865287363fcefe1133589151610bfc158dfc4377d86789aff2b6fc78d8889a112ca36ad13de69e7fb60ac401a964fd8dde072c186
+  data.tar.gz: 792a75fce8fdf69c1cfe62ffd7250952666811d14591758ba6a8897e70691477b5b9dab1990cdea8a5641c93933bacaea0faab7fce833817de9286e82a145391

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/CHANGELOG.md

@@ -1,5 +1,7 @@
 # Changelog
 
+Individual gem's changelog has been deprecated. Please check the [project changelog](https://github.com/getsentry/sentry-ruby/blob/master/CHANGELOG.md).
+
 ## 4.4.0
 
 ### Features

data/Gemfile

@@ -2,36 +2,42 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in sentry-ruby.gemspec
 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"
+
 gem "rspec", "~> 3.0"
 gem "rspec-retry"
 gem "rspec-rails", "~> 4.0"
-gem "codecov", "0.2.12"
+gem 'simplecov'
+gem "simplecov-cobertura", "~> 1.4"
+gem "rexml"
 
 gem "rake", "~> 12.0"
 
-# TODO: Remove this if https://github.com/jruby/jruby/issues/6547 is addressed
-gem "i18n", "<= 1.8.7"
-
-gem "sidekiq"
-
-gem "sentry-ruby", path: "../sentry-ruby"
-
+gem "object_tracer"
+gem "debug", github: "ruby/debug", platform: :ruby if RUBY_VERSION.to_f >= 2.6
 gem "pry"
 
 gem "benchmark-ips"

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 st0012
+Copyright (c) 2020 Sentry
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Rakefile

@@ -5,4 +5,10 @@ RSpec::Core::RakeTask.new(:spec).tap do |task|
   task.rspec_opts = "--order rand"
 end
 
-task :default => :spec
+task :isolated_specs do
+  Dir["spec/isolated/*"].each do |file|
+    sh "bundle exec ruby #{file}"
+  end
+end
+
+task :default => [:spec, :isolated_specs]

data/app/jobs/sentry/send_event_job.rb

@@ -16,17 +16,12 @@ 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
 
       def perform(event, hint = {})
-        # users don't need the tracing result of this job
-        if transaction = Sentry.get_current_scope.span
-          transaction.instance_variable_set(:@sampled, false)
-        end
-
         Sentry.send_event(event, hint)
       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,74 +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 = Sentry.start_transaction(name: scope.transaction_name, op: "active_job")
+      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/background_worker.rb

@@ -1,11 +1,9 @@
 module Sentry
   class BackgroundWorker
-    def perform(&block)
-      @executor.post do
-        # 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
+    def _perform(&block)
+      # 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
     end
   end

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

@@ -1,9 +1,11 @@
+require "sentry/rails/instrument_payload_cleanup_helper"
+
 module Sentry
   module Rails
     module Breadcrumb
       module ActiveSupportLogger
         class << self
-          IGNORED_DATA_TYPES = [:request, :headers, :exception, :exception_object]
+          include InstrumentPayloadCleanupHelper
 
           def add(name, started, _finished, _unique_id, data)
             # skip Rails' internal events
@@ -23,12 +25,6 @@ module Sentry
             Sentry.add_breadcrumb(crumb)
           end
 
-          def cleanup_data(data)
-            IGNORED_DATA_TYPES.each do |key|
-              data.delete(key) if data.key?(key)
-            end
-          end
-
           def inject
             @subscriber = ::ActiveSupport::Notifications.subscribe(/.*/) do |name, started, finished, unique_id, data|
               # we only record events that has a started timestamp

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

@@ -0,0 +1,44 @@
+require "sentry/rails/instrument_payload_cleanup_helper"
+
+module Sentry
+  module Rails
+    module Breadcrumb
+      module MonotonicActiveSupportLogger
+        class << self
+          include InstrumentPayloadCleanupHelper
+
+          def add(name, started, _finished, _unique_id, data)
+            # skip Rails' internal events
+            return if name.start_with?("!")
+
+            if data.is_a?(Hash)
+              # we should only mutate the copy of the data
+              data = data.dup
+              cleanup_data(data)
+            end
+
+            crumb = Sentry::Breadcrumb.new(
+              data: data,
+              category: name,
+              timestamp: started.to_i
+            )
+            Sentry.add_breadcrumb(crumb)
+          end
+
+          def inject
+            @subscriber = ::ActiveSupport::Notifications.monotonic_subscribe(/.*/) do |name, started, finished, unique_id, data|
+              # we only record events that has a float as started timestamp
+              if started.is_a?(Float)
+                add(name, started, finished, unique_id, data)
+              end
+            end
+          end
+
+          def detach
+            ::ActiveSupport::Notifications.unsubscribe(@subscriber)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/configuration.rb

@@ -1,6 +1,7 @@
 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"
 
 module Sentry
   class Configuration
@@ -59,7 +60,8 @@ module Sentry
         @tracing_subscribers = Set.new([
           Sentry::Rails::Tracing::ActionControllerSubscriber,
           Sentry::Rails::Tracing::ActionViewSubscriber,
-          Sentry::Rails::Tracing::ActiveRecordSubscriber
+          Sentry::Rails::Tracing::ActiveRecordSubscriber,
+          Sentry::Rails::Tracing::ActiveStorageSubscriber
         ])
       end
     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/instrument_payload_cleanup_helper.rb

@@ -0,0 +1,13 @@
+module Sentry
+  module Rails
+    module InstrumentPayloadCleanupHelper
+      IGNORED_DATA_TYPES = [:request, :response, :headers, :exception, :exception_object, Tracing::START_TIMESTAMP_NAME]
+
+      def cleanup_data(data)
+        IGNORED_DATA_TYPES.each do |key|
+          data.delete(key) if data.key?(key)
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/railtie.rb

@@ -7,9 +7,32 @@ module Sentry
     # middlewares can't be injected after initialize
     initializer "sentry.use_rack_middleware" do |app|
       # placed after all the file-sending middlewares so we can avoid unnecessary transactions
-      app.config.middleware.insert_after ActionDispatch::Executor, Sentry::Rails::CaptureExceptions
-      # need to be placed at last to smuggle app exceptions via env
-      app.config.middleware.use(Sentry::Rails::RescuedExceptionInterceptor)
+      app.config.middleware.insert_after ActionDispatch::ShowExceptions, Sentry::Rails::CaptureExceptions
+      # need to place as close to DebugExceptions as possible to intercept most of the exceptions, including those raised by middlewares
+      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
+    # 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|
+      ActiveSupport.on_load(:active_job) do
+        require "sentry/rails/active_job"
+        prepend Sentry::Rails::ActiveJobExtensions
+      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|
@@ -18,12 +41,18 @@ module Sentry
       configure_project_root
       configure_trusted_proxies
       extend_controller_methods if defined?(ActionController)
-      extend_active_job if defined?(ActiveJob)
       patch_background_worker if defined?(ActiveRecord)
       override_streaming_reporter if defined?(ActionView)
       setup_backtrace_cleanup_callback
       inject_breadcrumbs_logger
       activate_tracing
+
+      register_error_subscriber(app) if ::Rails.version.to_f >= 7.0
+    end
+
+    runner do
+      next unless Sentry.initialized?
+      Sentry.configuration.background_worker_threads = 0
     end
 
     def configure_project_root
@@ -34,11 +63,6 @@ module Sentry
       Sentry.configuration.trusted_proxies += Array(::Rails.application.config.action_dispatch.trusted_proxies)
     end
 
-    def extend_active_job
-      require "sentry/rails/active_job"
-      ActiveJob::Base.send(:prepend, Sentry::Rails::ActiveJobExtensions)
-    end
-
     def extend_controller_methods
       require "sentry/rails/controller_methods"
       require "sentry/rails/controller_transaction"
@@ -60,12 +84,19 @@ module Sentry
         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
+      end
     end
 
     def setup_backtrace_cleanup_callback
       backtrace_cleaner = Sentry::Rails::BacktraceCleaner.new
 
-      Sentry.configuration.backtrace_cleanup_callback = lambda do |backtrace|
+      Sentry.configuration.backtrace_cleanup_callback ||= lambda do |backtrace|
         backtrace_cleaner.clean(backtrace)
       end
     end
@@ -86,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/rescued_exception_interceptor.rb

@@ -11,22 +11,6 @@ module Sentry
         begin
           @app.call(env)
         rescue => e
-          request = ActionDispatch::Request.new(env)
-
-          # Rails' ShowExceptions#render_exception will mutate env for the exceptions app
-          # so we need to hold a copy of env to report the accurate data (like request's url)
-          if request.show_exceptions?
-            scope = Sentry.get_current_scope
-            copied_env = scope.rack_env.dup
-            copied_env["sentry.original_transaction"] = scope.transaction_name
-            scope.set_rack_env(copied_env)
-
-            if report_rescued_exceptions?
-              Sentry::Rails.capture_exception(e)
-              env["sentry.already_captured"] = true
-            end
-          end
-
           env["sentry.rescued_exception"] = e if report_rescued_exceptions?
           raise e
         end

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

@@ -9,22 +9,30 @@ module Sentry
           end
 
           def unsubscribe!
-            ActiveSupport::Notifications.unsubscribe(self::EVENT_NAME)
+            self::EVENT_NAMES.each do |name|
+              ActiveSupport::Notifications.unsubscribe(name)
+            end
           end
 
-          def subscribe_to_event(event_name)
-            if ::Rails.version.to_i == 5
-              ActiveSupport::Notifications.subscribe(event_name) do |*args|
-                next unless Tracing.get_current_transaction
+          if ::Rails.version.to_i == 5
+            def subscribe_to_event(event_names)
+              event_names.each do |event_name|
+                ActiveSupport::Notifications.subscribe(event_name) do |*args|
+                  next unless Tracing.get_current_transaction
 
-                event = ActiveSupport::Notifications::Event.new(*args)
-                yield(event_name, event.duration, event.payload)
+                  event = ActiveSupport::Notifications::Event.new(*args)
+                  yield(event_name, event.duration, event.payload)
+                end
               end
-            else
-              ActiveSupport::Notifications.subscribe(event_name) do |event|
-                next unless Tracing.get_current_transaction
-
-                yield(event_name, event.duration, event.payload)
+            end
+          else
+            def subscribe_to_event(event_names)
+              event_names.each do |event_name|
+                ActiveSupport::Notifications.subscribe(event_name) do |event|
+                  next unless Tracing.get_current_transaction
+
+                  yield(event_name, event.duration, event.payload)
+                end
               end
             end
           end

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

@@ -1,25 +1,27 @@
 require "sentry/rails/tracing/abstract_subscriber"
+require "sentry/rails/instrument_payload_cleanup_helper"
 
 module Sentry
   module Rails
     module Tracing
       class ActionControllerSubscriber < AbstractSubscriber
-        EVENT_NAME = "process_action.action_controller".freeze
+        extend InstrumentPayloadCleanupHelper
+
+        EVENT_NAMES = ["process_action.action_controller"].freeze
 
         def self.subscribe!
-          subscribe_to_event(EVENT_NAME) do |event_name, duration, payload|
+          subscribe_to_event(EVENT_NAMES) do |event_name, duration, payload|
             controller = payload[:controller]
             action = payload[:action]
 
             record_on_current_span(
               op: event_name,
-              start_timestamp: payload[:start_timestamp],
+              start_timestamp: payload[START_TIMESTAMP_NAME],
               description: "#{controller}##{action}",
               duration: duration
             ) do |span|
               payload = payload.dup
-              payload.delete(:headers)
-              payload.delete(:request)
+              cleanup_data(payload)
               span.set_data(:payload, payload)
               span.set_http_status(payload[:status])
             end

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

@@ -4,11 +4,12 @@ module Sentry
   module Rails
     module Tracing
       class ActionViewSubscriber < AbstractSubscriber
-        EVENT_NAME = "render_template.action_view".freeze
+        EVENT_NAMES = ["render_template.action_view"].freeze
+        SPAN_PREFIX = "template.".freeze
 
         def self.subscribe!
-          subscribe_to_event(EVENT_NAME) do |event_name, duration, payload|
-            record_on_current_span(op: event_name, start_timestamp: payload[:start_timestamp], description: payload[:identifier], duration: duration)
+          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)
           end
         end
       end

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

@@ -4,14 +4,15 @@ module Sentry
   module Rails
     module Tracing
       class ActiveRecordSubscriber < AbstractSubscriber
-        EVENT_NAME = "sql.active_record".freeze
+        EVENT_NAMES = ["sql.active_record"].freeze
+        SPAN_PREFIX = "db.".freeze
         EXCLUDED_EVENTS = ["SCHEMA", "TRANSACTION"].freeze
 
         def self.subscribe!
-          subscribe_to_event(EVENT_NAME) do |event_name, duration, payload|
+          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], 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/tracing/active_storage_subscriber.rb

@@ -0,0 +1,34 @@
+require "sentry/rails/tracing/abstract_subscriber"
+
+module Sentry
+  module Rails
+    module Tracing
+      class ActiveStorageSubscriber < AbstractSubscriber
+        EVENT_NAMES = %w(
+          service_upload.active_storage
+          service_download.active_storage
+          service_streaming_download.active_storage
+          service_download_chunk.active_storage
+          service_delete.active_storage
+          service_delete_prefixed.active_storage
+          service_exist.active_storage
+          service_url.active_storage
+          service_mirror.active_storage
+          service_update_metadata.active_storage
+          preview.active_storage
+          analyze.active_storage
+        ).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[:service], duration: duration) do |span|
+              payload.each do |key, value|
+                span.set_data(key, value) unless key == START_TIMESTAMP_NAME
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/tracing.rb

@@ -1,6 +1,8 @@
 module Sentry
   module Rails
     module Tracing
+      START_TIMESTAMP_NAME = :sentry_start_timestamp
+
       def self.register_subscribers(subscribers)
         @subscribers = subscribers
       end
@@ -9,11 +11,19 @@ module Sentry
         @subscribers
       end
 
+      def self.subscribed_tracing_events
+        @subscribed_tracing_events ||= []
+      end
+
       def self.subscribe_tracing_events
         # need to avoid duplicated subscription
         return if @subscribed
 
-        subscribers.each(&:subscribe!)
+        subscribers.each do |subscriber|
+          subscriber.subscribe!
+          @subscribed_tracing_events ||= []
+          @subscribed_tracing_events += subscriber::EVENT_NAMES
+        end
 
         @subscribed = true
       end
@@ -22,6 +32,7 @@ module Sentry
         return unless @subscribed
 
         subscribers.each(&:unsubscribe!)
+        subscribed_tracing_events.clear
 
         @subscribed = false
       end
@@ -35,9 +46,10 @@ module Sentry
 
         SentryNotificationExtension.module_eval do
           def instrument(name, payload = {}, &block)
-            is_public_event = name[0] != "!"
-
-            payload[:start_timestamp] = Time.now.utc.to_f if is_public_event
+            # only inject timestamp to the events the SDK subscribes to
+            if Tracing.subscribed_tracing_events.include?(name)
+              payload[START_TIMESTAMP_NAME] = Time.now.utc.to_f if name[0] != "!" && payload.is_a?(Hash)
+            end
 
             super(name, payload, &block)
           end

data/lib/sentry/rails/version.rb

@@ -1,5 +1,5 @@
 module Sentry
   module Rails
-    VERSION = "4.4.0"
+    VERSION = "5.1.1"
   end
 end

data/lib/sentry/rails.rb

@@ -1,10 +1,10 @@
 require "rails"
 require "sentry-ruby"
 require "sentry/integrable"
+require "sentry/rails/tracing"
 require "sentry/rails/configuration"
 require "sentry/rails/engine"
 require "sentry/rails/railtie"
-require "sentry/rails/tracing"
 
 module Sentry
   module Rails

data/sentry-rails.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |spec|
   spec.authors = ["Sentry Team"]
   spec.description = spec.summary = "A gem that provides Rails integration for the Sentry error logger"
   spec.email = "accounts@sentry.io"
-  spec.license = 'Apache-2.0'
+  spec.license = 'MIT'
   spec.homepage = "https://github.com/getsentry/sentry-ruby"
 
   spec.platform = Gem::Platform::RUBY
@@ -16,12 +16,12 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/sentry-rails/CHANGELOG.md"
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
 
   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", "~> 4.4.0.pre.beta"
+  spec.add_dependency "sentry-ruby-core", "~> 5.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-rails
 version: !ruby/object:Gem::Version
-  version: 4.4.0
+  version: 5.1.1
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-05-03 00:00:00.000000000 Z
+date: 2022-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.4.0.pre.beta
+        version: 5.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.4.0.pre.beta
+        version: 5.1.1
 description: A gem that provides Rails integration for the Sentry error logger
 email: accounts@sentry.io
 executables: []
@@ -46,7 +46,6 @@ extra_rdoc_files:
 - README.md
 - LICENSE.txt
 files:
-- ".craft.yml"
 - ".gitignore"
 - ".rspec"
 - CHANGELOG.md
@@ -61,15 +60,19 @@ 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
 - lib/sentry/rails/breadcrumb/active_support_logger.rb
+- lib/sentry/rails/breadcrumb/monotonic_active_support_logger.rb
 - lib/sentry/rails/capture_exceptions.rb
 - lib/sentry/rails/configuration.rb
 - 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
 - lib/sentry/rails/rescued_exception_interceptor.rb
@@ -78,15 +81,16 @@ files:
 - lib/sentry/rails/tracing/action_controller_subscriber.rb
 - lib/sentry/rails/tracing/action_view_subscriber.rb
 - lib/sentry/rails/tracing/active_record_subscriber.rb
+- lib/sentry/rails/tracing/active_storage_subscriber.rb
 - lib/sentry/rails/version.rb
 - sentry-rails.gemspec
 homepage: https://github.com/getsentry/sentry-ruby
 licenses:
-- Apache-2.0
+- MIT
 metadata:
   homepage_uri: https://github.com/getsentry/sentry-ruby
   source_code_uri: https://github.com/getsentry/sentry-ruby
-  changelog_uri: https://github.com/getsentry/sentry-ruby/blob/master/sentry-rails/CHANGELOG.md
+  changelog_uri: https://github.com/getsentry/sentry-ruby/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -102,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A gem that provides Rails integration for the Sentry error logger

data/.craft.yml

@@ -1,20 +0,0 @@
-minVersion: '0.13.2'
-github:
-    owner: getsentry
-    repo: sentry-ruby
-changelogPolicy: simple
-preReleaseCommand: ruby ../.scripts/bump-version.rb
-releaseBranchPrefix: release-sentry-rails
-statusProvider:
-  name: github
-artifactProvider:
-  name: github
-targets:
-    - name: gem
-    - name: registry
-      type: sdk
-      config:
-          canonical: 'gem:sentry-rails'
-    - name: github
-      tagPrefix: sentry-rails-v
-      changelog: sentry-rails/CHANGELOG.md