sentry-rails 5.26.0 → 6.0.0

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "sentry/rails/log_subscriber"
+require "sentry/rails/log_subscribers/parameter_filter"
+
+module Sentry
+  module Rails
+    module LogSubscribers
+      # LogSubscriber for ActionController events that captures HTTP request processing
+      # and logs them using Sentry's structured logging system.
+      #
+      # This subscriber captures process_action.action_controller events and formats them
+      # with relevant request information including controller, action, HTTP status,
+      # request parameters, and performance metrics.
+      #
+      # @example Usage
+      #   # Enable structured logging for ActionController
+      #   Sentry.init do |config|
+      #     config.enable_logs = true
+      #     config.rails.structured_logging = true
+      #     config.rails.structured_logging.subscribers = { action_controller: Sentry::Rails::LogSubscribers::ActionControllerSubscriber }
+      #   end
+      class ActionControllerSubscriber < Sentry::Rails::LogSubscriber
+        include ParameterFilter
+
+        # Handle process_action.action_controller events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The controller action event
+        def process_action(event)
+          payload = event.payload
+
+          controller = payload[:controller]
+          action = payload[:action]
+
+          status = extract_status(payload)
+
+          attributes = {
+            controller: controller,
+            action: action,
+            duration_ms: duration_ms(event),
+            method: payload[:method],
+            path: payload[:path],
+            format: payload[:format]
+          }
+
+          attributes[:status] = status if status
+
+          if payload[:view_runtime]
+            attributes[:view_runtime_ms] = payload[:view_runtime].round(2)
+          end
+
+          if payload[:db_runtime]
+            attributes[:db_runtime_ms] = payload[:db_runtime].round(2)
+          end
+
+          if Sentry.configuration.send_default_pii && payload[:params]
+            filtered_params = filter_sensitive_params(payload[:params])
+            attributes[:params] = filtered_params unless filtered_params.empty?
+          end
+
+          level = level_for_request(payload)
+          message = "#{controller}##{action}"
+
+          log_structured_event(
+            message: message,
+            level: level,
+            attributes: attributes
+          )
+        end
+
+        private
+
+        def extract_status(payload)
+          if payload[:status]
+            payload[:status]
+          elsif payload[:exception]
+            case payload[:exception].first
+            when "ActionController::RoutingError"
+              404
+            when "ActionController::BadRequest"
+              400
+            else
+              500
+            end
+          end
+        end
+
+        def level_for_request(payload)
+          status = payload[:status]
+
+          # In Rails < 6.0 status is not set when an action raised an exception
+          if status.nil? && payload[:exception]
+            case payload[:exception].first
+            when "ActionController::RoutingError"
+              :warn
+            when "ActionController::BadRequest"
+              :warn
+            else
+              :error
+            end
+          elsif status.nil?
+            :info
+          elsif status >= 200 && status < 400
+            :info
+          elsif status >= 400 && status < 500
+            :warn
+          elsif status >= 500
+            :error
+          else
+            :info
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/log_subscribers/action_mailer_subscriber.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "sentry/rails/log_subscriber"
+require "sentry/rails/log_subscribers/parameter_filter"
+
+module Sentry
+  module Rails
+    module LogSubscribers
+      # LogSubscriber for ActionMailer events that captures email delivery
+      # and processing events using Sentry's structured logging system.
+      #
+      # This subscriber captures deliver.action_mailer and process.action_mailer events
+      # and formats them with relevant email information while respecting PII settings.
+      #
+      # @example Usage
+      #   # Enable structured logging for ActionMailer
+      #   Sentry.init do |config|
+      #     config.enable_logs = true
+      #     config.rails.structured_logging = true
+      #     config.rails.structured_logging.subscribers = { action_mailer: Sentry::Rails::LogSubscribers::ActionMailerSubscriber }
+      #   end
+      class ActionMailerSubscriber < Sentry::Rails::LogSubscriber
+        include ParameterFilter
+
+        # Handle deliver.action_mailer events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The email delivery event
+        def deliver(event)
+          payload = event.payload
+
+          mailer = payload[:mailer]
+
+          attributes = {
+            mailer: mailer,
+            duration_ms: duration_ms(event),
+            perform_deliveries: payload[:perform_deliveries]
+          }
+
+          attributes[:delivery_method] = payload[:delivery_method] if payload[:delivery_method]
+          attributes[:date] = payload[:date].to_s if payload[:date]
+
+          if Sentry.configuration.send_default_pii
+            attributes[:message_id] = payload[:message_id] if payload[:message_id]
+          end
+
+          message = "Email delivered via #{mailer}"
+
+          # Log the structured event
+          log_structured_event(
+            message: message,
+            level: :info,
+            attributes: attributes
+          )
+        end
+
+        # Handle process.action_mailer events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The email processing event
+        def process(event)
+          payload = event.payload
+
+          mailer = payload[:mailer]
+          action = payload[:action]
+          duration = duration_ms(event)
+
+          attributes = {
+            mailer: mailer,
+            action: action,
+            duration_ms: duration
+          }
+
+          if Sentry.configuration.send_default_pii && payload[:params]
+            filtered_params = filter_sensitive_params(payload[:params])
+            attributes[:params] = filtered_params unless filtered_params.empty?
+          end
+
+          message = "#{mailer}##{action}"
+
+          log_structured_event(
+            message: message,
+            level: :info,
+            attributes: attributes
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sentry/rails/log_subscribers/active_job_subscriber.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "sentry/rails/log_subscriber"
+require "sentry/rails/log_subscribers/parameter_filter"
+
+module Sentry
+  module Rails
+    module LogSubscribers
+      # LogSubscriber for ActiveJob events that captures background job execution
+      # and logs them using Sentry's structured logging system.
+      #
+      # This subscriber captures various ActiveJob events including job execution,
+      # enqueueing, retries, and failures with relevant job information.
+      #
+      # @example Usage
+      #   # Enable structured logging for ActiveJob
+      #   Sentry.init do |config|
+      #     config.enable_logs = true
+      #     config.rails.structured_logging = true
+      #     config.rails.structured_logging.subscribers = { active_job: Sentry::Rails::LogSubscribers::ActiveJobSubscriber }
+      #   end
+      class ActiveJobSubscriber < Sentry::Rails::LogSubscriber
+        include ParameterFilter
+
+        # Handle perform.active_job events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The job performance event
+        def perform(event)
+          job = event.payload[:job]
+          duration = duration_ms(event)
+
+          attributes = {
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue_name: job.queue_name,
+            duration_ms: duration,
+            executions: job.executions,
+            priority: job.priority
+          }
+
+          attributes[:adapter] = job.class.queue_adapter.class.name
+
+          if job.scheduled_at
+            attributes[:scheduled_at] = job.scheduled_at.iso8601
+            attributes[:delay_ms] = ((Time.current - job.scheduled_at) * 1000).round(2)
+          end
+
+          if Sentry.configuration.send_default_pii && job.arguments.present?
+            filtered_args = filter_sensitive_arguments(job.arguments)
+            attributes[:arguments] = filtered_args unless filtered_args.empty?
+          end
+
+          message = "Job performed: #{job.class.name}"
+
+          log_structured_event(
+            message: message,
+            level: :info,
+            attributes: attributes
+          )
+        end
+
+        # Handle enqueue.active_job events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The job enqueue event
+        def enqueue(event)
+          job = event.payload[:job]
+
+          attributes = {
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue_name: job.queue_name,
+            priority: job.priority
+          }
+
+          attributes[:adapter] = job.class.queue_adapter.class.name if job.class.respond_to?(:queue_adapter)
+
+          if job.scheduled_at
+            attributes[:scheduled_at] = job.scheduled_at.iso8601
+            attributes[:delay_seconds] = (job.scheduled_at - Time.current).round(2)
+          end
+
+          message = "Job enqueued: #{job.class.name}"
+
+          log_structured_event(
+            message: message,
+            level: :info,
+            attributes: attributes
+          )
+        end
+
+        def retry_stopped(event)
+          job = event.payload[:job]
+          error = event.payload[:error]
+
+          attributes = {
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue_name: job.queue_name,
+            executions: job.executions,
+            error_class: error.class.name,
+            error_message: error.message
+          }
+
+          message = "Job retry stopped: #{job.class.name}"
+
+          log_structured_event(
+            message: message,
+            level: :error,
+            attributes: attributes
+          )
+        end
+
+        def discard(event)
+          job = event.payload[:job]
+          error = event.payload[:error]
+
+          attributes = {
+            job_class: job.class.name,
+            job_id: job.job_id,
+            queue_name: job.queue_name,
+            executions: job.executions
+          }
+
+          attributes[:error_class] = error.class.name if error
+          attributes[:error_message] = error.message if error
+
+          message = "Job discarded: #{job.class.name}"
+
+          log_structured_event(
+            message: message,
+            level: :warn,
+            attributes: attributes
+          )
+        end
+
+        private
+
+        def filter_sensitive_arguments(arguments)
+          return [] unless arguments.is_a?(Array)
+
+          arguments.map do |arg|
+            case arg
+            when Hash
+              filter_sensitive_params(arg)
+            when String
+              arg.length > 100 ? "[FILTERED: #{arg.length} chars]" : arg
+            else
+              arg
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "sentry/rails/log_subscriber"
+require "sentry/rails/log_subscribers/parameter_filter"
+
+module Sentry
+  module Rails
+    module LogSubscribers
+      # LogSubscriber for ActiveRecord events that captures database queries
+      # and logs them using Sentry's structured logging system.
+      #
+      # This subscriber captures sql.active_record events and formats them
+      # with relevant database information including SQL queries, duration,
+      # database configuration, and caching information.
+      #
+      # @example Usage
+      #   # Automatically attached when structured logging is enabled for :active_record
+      #   Sentry.init do |config|
+      #     config.enable_logs = true
+      #     config.rails.structured_logging = true
+      #     config.rails.structured_logging.subscribers = { active_record: Sentry::Rails::LogSubscribers::ActiveRecordSubscriber }
+      #   end
+      class ActiveRecordSubscriber < Sentry::Rails::LogSubscriber
+        include ParameterFilter
+
+        EXCLUDED_NAMES = ["SCHEMA", "TRANSACTION"].freeze
+
+        # Handle sql.active_record events
+        #
+        # @param event [ActiveSupport::Notifications::Event] The SQL event
+        def sql(event)
+          return if EXCLUDED_NAMES.include?(event.payload[:name])
+
+          sql = event.payload[:sql]
+          statement_name = event.payload[:name]
+
+          # Rails 5.0.0 doesn't include :cached in the payload, it was added in Rails 5.1
+          cached = event.payload.fetch(:cached, false)
+          connection_id = event.payload[:connection_id]
+
+          db_config = extract_db_config(event.payload)
+
+          attributes = {
+            sql: sql,
+            duration_ms: duration_ms(event),
+            cached: cached
+          }
+
+          attributes[:statement_name] = statement_name if statement_name && statement_name != "SQL"
+          attributes[:connection_id] = connection_id if connection_id
+
+          add_db_config_attributes(attributes, db_config)
+
+          message = build_log_message(statement_name)
+
+          log_structured_event(
+            message: message,
+            level: :info,
+            attributes: attributes
+          )
+        end
+
+        private
+
+        def build_log_message(statement_name)
+          if statement_name && statement_name != "SQL"
+            "Database query: #{statement_name}"
+          else
+            "Database query"
+          end
+        end
+
+        def extract_db_config(payload)
+          connection = payload[:connection]
+
+          return unless connection
+
+          extract_db_config_from_connection(connection)
+        end
+
+        def add_db_config_attributes(attributes, db_config)
+          return unless db_config
+
+          attributes[:db_system] = db_config[:adapter] if db_config[:adapter]
+
+          if db_config[:database]
+            db_name = db_config[:database]
+
+            if db_config[:adapter] == "sqlite3" && db_name.include?("/")
+              db_name = File.basename(db_name)
+            end
+
+            attributes[:db_name] = db_name
+          end
+
+          attributes[:server_address] = db_config[:host] if db_config[:host]
+          attributes[:server_port] = db_config[:port] if db_config[:port]
+          attributes[:server_socket_address] = db_config[:socket] if db_config[:socket]
+        end
+
+        if ::Rails.version.to_f >= 6.1
+          def extract_db_config_from_connection(connection)
+            if connection.pool.respond_to?(:db_config)
+              db_config = connection.pool.db_config
+              if db_config.respond_to?(:configuration_hash)
+                return db_config.configuration_hash
+              elsif db_config.respond_to?(:config)
+                return db_config.config
+              end
+            end
+
+            extract_db_config_fallback(connection)
+          end
+        else
+          # Rails 6.0 and earlier use spec API
+          def extract_db_config_from_connection(connection)
+            if connection.pool.respond_to?(:spec)
+              spec = connection.pool.spec
+              if spec.respond_to?(:config)
+                return spec.config
+              end
+            end
+
+            extract_db_config_fallback(connection)
+          end
+        end
+
+        def extract_db_config_fallback(connection)
+          connection.config if connection.respond_to?(:config)
+        end
+      end
+    end
+  end
+end

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

@@ -9,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

@@ -49,6 +49,7 @@ module Sentry
       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
 
@@ -100,17 +101,12 @@ module Sentry
     end
 
     def inject_breadcrumbs_logger
-      if Sentry.configuration.breadcrumbs_logger.include?(:active_support_logger)
+      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
-
-      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
@@ -138,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/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/version.rb

@@ -2,6 +2,6 @@
 
 module Sentry
   module Rails
-    VERSION = "5.26.0"
+    VERSION = "6.0.0"
   end
 end

data/lib/sentry/rails.rb

@@ -5,6 +5,7 @@ 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/sentry-rails.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.license = 'MIT'
 
   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|\.rubocop\.yml)'`.split("\n")
 
@@ -30,6 +30,6 @@ Gem::Specification.new do |spec|
   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", "~> 5.26.0"
+  spec.add_dependency "railties", ">= 5.2.0"
+  spec.add_dependency "sentry-ruby", "~> 6.0.0"
 end