sentry-rails 5.26.0 → 5.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8136167d60f6ee67885cdde939a5aa1e29f0e9f9bc1bd64b0ff4aecc29a477a9
-  data.tar.gz: d03846dced0b11fbe03df3b3386c01e2d4ff84d5cfc64dcaf33612f82f2de69a
+  metadata.gz: 15c5cac1232851c12adb474d437c228335f2c23b3f9f65e9000d769b6265d52d
+  data.tar.gz: fe44e7fe542de216cf8eb97bef21a72f058c62e862dec51edbbd244a98cd21aa
 SHA512:
-  metadata.gz: '0900b1dd825499e01d9a5ce77c71bc7821581420abbb60ea8123fcdafed8d7fd9db53b8fb31bdcbbe445e95583c9b477b47f15bdeb58bc3988c54289f328d1bb'
-  data.tar.gz: 356eb3d7a526cb1bcd4ee56c3b32201fbbbfe58b0f6ea2cb8152fd7d732964522dea8bc83e08411271fc531c92a5cc9185b2a17dfd50d06153a1ca0f9a6ba87a
+  metadata.gz: ed7cc92a5d90ce2d251f1afaeaa1a08cc5e4af878f4b254b3a7bcf369e1353af3acba97228cec5c86d20f63e354b44860bc4a8120f1577dd66c01fb2d75600d7
+  data.tar.gz: 30b11a5ed39d0351a91348938d4aa6a2a7625c28e55293c591087747e71e2488b086967f6e811a5281292a332b1f66b3e94e18ed7e7783eab50f9d1408740a3b

data/Gemfile

@@ -3,7 +3,7 @@
 source "https://rubygems.org"
 git_source(:github) { |name| "https://github.com/#{name}.git" }
 
-eval_gemfile "../Gemfile"
+eval_gemfile "../Gemfile.dev"
 
 # Specify your gem's dependencies in sentry-ruby.gemspec
 gemspec
@@ -16,8 +16,18 @@ end
 
 ruby_version = Gem::Version.new(RUBY_VERSION)
 
-rails_version = ENV["RAILS_VERSION"]
-rails_version = "8.0.0" if rails_version.nil?
+rails_version = ENV.fetch("RAILS_VERSION") do
+  if ruby_version >= Gem::Version.new("3.2")
+    "8.0"
+  elsif ruby_version >= Gem::Version.new("3.1")
+    "7.2"
+  elsif ruby_version >= Gem::Version.new("2.7")
+    "7.1"
+  elsif ruby_version >= Gem::Version.new("2.4")
+    "5.2"
+  end
+end
+
 rails_version = Gem::Version.new(rails_version)
 
 gem "rails", "~> #{rails_version}"
@@ -26,6 +36,7 @@ if rails_version >= Gem::Version.new("8.0.0")
   gem "rspec-rails"
   gem "sqlite3", "~> 2.1.1", platform: :ruby
 elsif rails_version >= Gem::Version.new("7.1.0")
+  gem "psych", "~> 4.0.0"
   gem "rspec-rails"
   gem "sqlite3", "~> 1.7.3", platform: :ruby
 elsif rails_version >= Gem::Version.new("6.1.0")
@@ -37,8 +48,8 @@ elsif rails_version >= Gem::Version.new("6.1.0")
     gem "sqlite3", "~> 1.6.9", platform: :ruby
   end
 else
-  gem "rspec-rails", "~> 4.0"
   gem "psych", "~> 3.0.0"
+  gem "rspec-rails", "~> 4.0"
 
   if rails_version >= Gem::Version.new("6.0.0")
     gem "sqlite3", "~> 1.4.0", platform: :ruby

data/bin/test

@@ -0,0 +1,389 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+# Standalone CLI script to test sentry-rails against multiple Rails versions
+#
+# FEATURES:
+# - Dedicated lock files for each Ruby/Rails version combination
+# - Prevents dependency conflicts between different Rails versions
+# - Automatic lock file management and restoration
+# - Clean up functionality for old lock files
+#
+# LOCK FILE STRATEGY:
+# Each Ruby/Rails combination gets its own lock file:
+# - Ruby 3.4.5 + Rails 6.1 → Gemfile-ruby-3.4.5-rails-6.1.lock
+# - Ruby 3.4.5 + Rails 7.0 → Gemfile-ruby-3.4.5-rails-7.0.lock
+#
+# Usage:
+#   ./bin/test --version 5.0
+#   ./bin/test --all
+#   ./bin/test --help
+
+require 'optparse'
+require 'fileutils'
+
+class RailsVersionTester
+  SUPPORTED_VERSIONS = %w[5.0 5.1 5.2 6.0 6.1 7.0 7.1 7.2 8.0].freeze
+
+  def initialize
+    @options = {}
+    @failed_versions = []
+    @ruby_version = RUBY_VERSION
+    @spec_paths = []
+  end
+
+  def run(args)
+    parse_options(args)
+
+    case
+    when @options[:help]
+      show_help
+    when @options[:list]
+      list_versions
+    when @options[:clean]
+      clean_lock_files
+    when @options[:all]
+      test_all_versions
+    when @options[:version]
+      test_single_version(@options[:version])
+    else
+      puts "Error: No action specified. Use --help for usage information."
+      exit(1)
+    end
+  end
+
+  private
+
+  def parse_options(args)
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{$0} [options] [spec_paths...]"
+
+      opts.on("-v", "--version VERSION", "Test specific Rails version") do |version|
+        unless SUPPORTED_VERSIONS.include?(version)
+          puts "Error: Unsupported Rails version '#{version}'"
+          puts "Supported versions: #{SUPPORTED_VERSIONS.join(', ')}"
+          exit(1)
+        end
+        @options[:version] = version
+      end
+
+      opts.on("-a", "--all", "Test all supported Rails versions") do
+        @options[:all] = true
+      end
+
+      opts.on("-l", "--list", "List supported Rails versions and lock file status") do
+        @options[:list] = true
+      end
+
+      opts.on("-c", "--clean", "Clean up old lock files for current Ruby version") do
+        @options[:clean] = true
+      end
+
+      opts.on("-h", "--help", "Show this help message") do
+        @options[:help] = true
+      end
+    end.parse!(args)
+
+    # Remaining arguments are spec paths
+    @spec_paths = args
+  end
+
+  def show_help
+    puts <<~HELP
+      Rails Version Tester for sentry-rails
+
+      This script tests sentry-rails against different Rails versions by:
+      1. Setting the RAILS_VERSION environment variable
+      2. Managing bundle dependencies with dedicated lock files per Ruby/Rails combination
+      3. Running the test suite in isolated processes
+      4. Providing proper exit codes for CI/CD integration
+
+      Each Ruby/Rails version combination gets its own Gemfile.lock to prevent conflicts:
+      - Ruby #{@ruby_version} + Rails 6.1 → Gemfile-ruby-#{@ruby_version}-rails-6.1.lock
+      - Ruby #{@ruby_version} + Rails 7.0 → Gemfile-ruby-#{@ruby_version}-rails-7.0.lock
+
+      Usage:
+        #{$0} --version 6.1                                    # Test specific Rails version (all specs)
+        #{$0} --version 7.0 spec/sentry/rails/log_subscribers  # Test specific Rails version with specific specs
+        #{$0} --all                                            # Test all supported versions
+        #{$0} --list                                           # List supported versions and lock file status
+        #{$0} --clean                                          # Clean up old lock files for current Ruby version
+        #{$0} --help                                           # Show this help
+
+      Supported Rails versions: #{SUPPORTED_VERSIONS.join(', ')}
+
+      Examples:
+        #{$0} -v 7.1                                           # Test Rails 7.1 (all specs)
+        #{$0} -v 7.0 spec/sentry/rails/log_subscribers         # Test Rails 7.0 log subscriber specs only
+        #{$0} -v 7.0 spec/sentry/rails/tracing                 # Test Rails 7.0 tracing specs only
+        #{$0} -a                                               # Test all versions
+        #{$0} -c                                               # Clean up old lock files
+    HELP
+  end
+
+  def list_versions
+    puts "Supported Rails versions:"
+    SUPPORTED_VERSIONS.each do |version|
+      lock_file = generate_lock_file_name(version)
+      status = File.exist?(lock_file) ? "(has lock file)" : "(no lock file)"
+      puts "  - #{version} #{status}"
+    end
+    puts
+    puts "Current Ruby version: #{@ruby_version}"
+    puts "Lock files are stored as: Gemfile-ruby-X.X.X-rails-Y.Y.lock"
+  end
+
+  def test_all_versions
+    puts "Testing sentry-rails against all supported Rails versions: #{SUPPORTED_VERSIONS.join(', ')}"
+    puts
+
+    SUPPORTED_VERSIONS.each do |version|
+      puts "=" * 60
+      puts "Testing Rails #{version}"
+      puts "=" * 60
+
+      exit_code = test_rails_version(version)
+
+      if exit_code == 0
+        puts "✓ Rails #{version} - PASSED"
+      else
+        puts "✗ Rails #{version} - FAILED (exit code: #{exit_code})"
+        @failed_versions << version
+      end
+      puts
+    end
+
+    print_summary
+  end
+
+  def test_single_version(version)
+    puts "Testing sentry-rails against Rails #{version}..."
+    exit_code = test_rails_version(version)
+    exit(exit_code) unless exit_code == 0
+  end
+
+  def test_rails_version(version)
+    puts "Setting up environment for Rails #{version}..."
+
+    # Generate dedicated lock file name for this Ruby/Rails combination
+    dedicated_lock_file = generate_lock_file_name(version)
+    current_lock_file = "Gemfile.lock"
+
+    # Set up environment variables
+    env = {
+      "RAILS_VERSION" => version,
+      "BUNDLE_GEMFILE" => File.expand_path("Gemfile", Dir.pwd)
+    }
+
+    puts "Using dedicated lock file: #{dedicated_lock_file}"
+
+    # Manage lock file switching
+    setup_lock_file(dedicated_lock_file, current_lock_file)
+
+    begin
+      # Check if bundle update is needed
+      if bundle_update_needed?(env, dedicated_lock_file)
+        puts "Dependencies need to be updated for Rails #{version}..."
+        unless update_bundle(env, dedicated_lock_file)
+          puts "✗ Failed to update bundle for Rails #{version}"
+          return 1
+        end
+      end
+
+      # Run the tests in a separate process
+      puts "Running test suite..."
+      run_tests(env, @spec_paths)
+    ensure
+      # Save the current lock file back to the dedicated location
+      save_lock_file(dedicated_lock_file, current_lock_file)
+    end
+  end
+
+  def generate_lock_file_name(rails_version)
+    # Create a unique lock file name for this Ruby/Rails combination
+    ruby_version_clean = @ruby_version.gsub(/[^\d\.]/, '')
+    rails_version_clean = rails_version.gsub(/[^\d\.]/, '')
+    "Gemfile-ruby-#{ruby_version_clean}-rails-#{rails_version_clean}.lock"
+  end
+
+  def setup_lock_file(dedicated_lock_file, current_lock_file)
+    # If we have a dedicated lock file, copy it to the current location
+    if File.exist?(dedicated_lock_file)
+      puts "Restoring lock file from #{dedicated_lock_file}"
+      FileUtils.cp(dedicated_lock_file, current_lock_file)
+    elsif File.exist?(current_lock_file)
+      # If no dedicated lock file exists but current one does, remove it
+      # so we get a fresh resolution
+      puts "Removing existing lock file for fresh dependency resolution"
+      File.delete(current_lock_file)
+    end
+  end
+
+  def save_lock_file(dedicated_lock_file, current_lock_file)
+    # Save the current lock file to the dedicated location
+    if File.exist?(current_lock_file)
+      puts "Saving lock file to #{dedicated_lock_file}"
+      FileUtils.cp(current_lock_file, dedicated_lock_file)
+    end
+  end
+
+  def bundle_update_needed?(env, dedicated_lock_file)
+    # Check if current Gemfile.lock exists
+    current_lock_file = "Gemfile.lock"
+    gemfile_path = env["BUNDLE_GEMFILE"] || "Gemfile"
+
+    return true unless File.exist?(current_lock_file)
+
+    # Check if Gemfile is newer than the current lock file
+    return true if File.mtime(gemfile_path) > File.mtime(current_lock_file)
+
+    # For Rails version changes, check if lockfile has incompatible Rails version
+    if env["RAILS_VERSION"] && lockfile_has_incompatible_rails_version?(current_lock_file, env["RAILS_VERSION"])
+      return true
+    end
+
+    # Check if bundle check passes
+    system(env, "bundle check > /dev/null 2>&1") == false
+  end
+
+  def lockfile_has_incompatible_rails_version?(lockfile_path, target_rails_version)
+    return false unless File.exist?(lockfile_path)
+
+    lockfile_content = File.read(lockfile_path)
+
+    # Extract Rails version from lockfile
+    if lockfile_content =~ /^\s*rails \(([^)]+)\)/
+      locked_rails_version = $1
+      target_major_minor = target_rails_version.split('.')[0..1].join('.')
+      locked_major_minor = locked_rails_version.split('.')[0..1].join('.')
+
+      # If major.minor versions don't match, we need to update
+      return target_major_minor != locked_major_minor
+    end
+
+    # If we can't determine the Rails version, assume update is needed
+    true
+  end
+
+  def update_bundle(env, dedicated_lock_file)
+    puts "Updating bundle for Rails #{env['RAILS_VERSION']}..."
+
+    current_lock_file = "Gemfile.lock"
+
+    # Try bundle update first
+    if system(env, "bundle update --quiet")
+      puts "Bundle updated successfully"
+      return true
+    end
+
+    puts "Bundle update failed, trying clean install..."
+
+    # Remove the current lockfile and try fresh install
+    File.delete(current_lock_file) if File.exist?(current_lock_file)
+
+    if system(env, "bundle install --quiet")
+      puts "Bundle installed successfully"
+      return true
+    end
+
+    puts "Bundle install failed"
+    false
+  end
+
+  def run_tests(env, spec_paths = [])
+    # Determine the command to run
+    if spec_paths.empty?
+      # Run all tests via rake
+      command = "bundle exec rake"
+    else
+      # Run specific specs via rspec
+      command = "bundle exec rspec #{spec_paths.join(' ')}"
+    end
+
+    puts "Executing: #{command}"
+
+    # Run the tests in a separate process with proper signal handling
+    pid = spawn(env, command,
+               out: $stdout,
+               err: $stderr,
+               pgroup: true)
+
+    begin
+      _, status = Process.wait2(pid)
+      status.exitstatus
+    rescue Interrupt
+      puts "\nInterrupted! Terminating test process..."
+      terminate_process_group(pid)
+      130 # Standard exit code for SIGINT
+    end
+  end
+
+  def terminate_process_group(pid)
+    begin
+      Process.kill("TERM", -pid) # Kill the process group
+      sleep(2)
+      Process.kill("KILL", -pid) if process_running?(pid)
+    rescue Errno::ESRCH
+      # Process already terminated
+    end
+  end
+
+  def process_running?(pid)
+    Process.getpgid(pid)
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
+  def clean_lock_files
+    puts "Cleaning up lock files for Ruby #{@ruby_version}..."
+
+    # Find all lock files matching our pattern
+    pattern = "Gemfile-ruby-#{@ruby_version.gsub(/[^\d\.]/, '')}-rails-*.lock"
+    lock_files = Dir.glob(pattern)
+
+    if lock_files.empty?
+      puts "No lock files found matching pattern: #{pattern}"
+      return
+    end
+
+    puts "Found #{lock_files.length} lock file(s):"
+    lock_files.each { |file| puts "  - #{file}" }
+
+    print "Delete these files? [y/N]: "
+    response = $stdin.gets.chomp.downcase
+
+    if response == 'y' || response == 'yes'
+      lock_files.each do |file|
+        File.delete(file)
+        puts "Deleted: #{file}"
+      end
+      puts "Cleanup complete!"
+    else
+      puts "Cleanup cancelled."
+    end
+  end
+
+  def print_summary
+    puts "=" * 60
+    puts "SUMMARY"
+    puts "=" * 60
+
+    if @failed_versions.empty?
+      puts "✓ All Rails versions passed!"
+      exit(0)
+    else
+      puts "✗ Failed versions: #{@failed_versions.join(', ')}"
+      puts
+      puts "Some Rails versions failed. See output above for details."
+      exit(1)
+    end
+  end
+end
+
+# Run the script if called directly
+if __FILE__ == $0
+  tester = RailsVersionTester.new
+  tester.run(ARGV)
+end

data/lib/sentry/rails/background_worker.rb

@@ -2,14 +2,18 @@
 
 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.release_connection
+    module ActiveRecordConnectionPatch
+      def _perform(&block)
+        super(&block)
+      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.release_connection
+        end
       end
     end
   end
 end
+
+Sentry::BackgroundWorker.prepend(Sentry::BackgroundWorker::ActiveRecordConnectionPatch)

data/lib/sentry/rails/configuration.rb

@@ -6,6 +6,9 @@ require "sentry/rails/tracing/active_record_subscriber"
 require "sentry/rails/tracing/active_storage_subscriber"
 require "sentry/rails/tracing/active_support_subscriber"
 
+require "sentry/rails/log_subscribers/active_record_subscriber"
+require "sentry/rails/log_subscribers/action_controller_subscriber"
+
 module Sentry
   class Configuration
     attr_reader :rails
@@ -159,6 +162,10 @@ module Sentry
       # Set this option to true if you want Sentry to capture each retry failure
       attr_accessor :active_job_report_on_retry_error
 
+      # Configuration for structured logging feature
+      # @return [StructuredLoggingConfiguration]
+      attr_reader :structured_logging
+
       def initialize
         @register_error_subscriber = false
         @report_rescued_exceptions = true
@@ -176,6 +183,27 @@ module Sentry
         @db_query_source_threshold_ms = 100
         @active_support_logger_subscription_items = Sentry::Rails::ACTIVE_SUPPORT_LOGGER_SUBSCRIPTION_ITEMS_DEFAULT.dup
         @active_job_report_on_retry_error = false
+        @structured_logging = StructuredLoggingConfiguration.new
+      end
+    end
+
+    class StructuredLoggingConfiguration
+      # Enable or disable structured logging
+      # @return [Boolean]
+      attr_accessor :enabled
+
+      # Hash of components to subscriber classes for structured logging
+      # @return [Hash<Symbol, Class>]
+      attr_accessor :subscribers
+
+      DEFAULT_SUBSCRIBERS = {
+        active_record: Sentry::Rails::LogSubscribers::ActiveRecordSubscriber,
+        action_controller: Sentry::Rails::LogSubscribers::ActionControllerSubscriber
+      }.freeze
+
+      def initialize
+        @enabled = false
+        @subscribers = DEFAULT_SUBSCRIBERS.dup
       end
     end
   end

data/lib/sentry/rails/log_subscriber.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
+
+module Sentry
+  module Rails
+    # Base class for Sentry log subscribers that extends ActiveSupport::LogSubscriber
+    # to provide structured logging capabilities for Rails components.
+    #
+    # This class follows Rails' LogSubscriber pattern and provides common functionality
+    # for capturing Rails instrumentation events and logging them through Sentry's
+    # structured logging system.
+    #
+    # @example Creating a custom log subscriber
+    #   class MySubscriber < Sentry::Rails::LogSubscriber
+    #     attach_to :my_component
+    #
+    #     def my_event(event)
+    #       log_structured_event(
+    #         message: "My event occurred",
+    #         level: :info,
+    #         attributes: {
+    #           duration_ms: event.duration,
+    #           custom_data: event.payload[:custom_data]
+    #         }
+    #       )
+    #     end
+    #   end
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      class << self
+        if ::Rails.version.to_f < 6.0
+          # Rails 5.x does not provide detach_from
+          def detach_from(namespace, notifications = ActiveSupport::Notifications)
+            listeners = public_instance_methods(false)
+              .flat_map { |key|
+                notifications.notifier.listeners_for("#{key}.#{namespace}")
+              }
+              .select { |listener| listener.instance_variable_get(:@delegate).is_a?(self) }
+
+            listeners.map do |listener|
+              notifications.notifier.unsubscribe(listener)
+            end
+          end
+        end
+      end
+
+      protected
+
+      # Log a structured event using Sentry's structured logger
+      #
+      # @param message [String] The log message
+      # @param level [Symbol] The log level (:trace, :debug, :info, :warn, :error, :fatal)
+      # @param attributes [Hash] Additional structured attributes to include
+      def log_structured_event(message:, level: :info, attributes: {})
+        Sentry.logger.public_send(level, message, **attributes)
+      rescue => e
+        # Silently handle any errors in logging to avoid breaking the application
+        Sentry.configuration.sdk_logger.debug("Failed to log structured event: #{e.message}")
+      end
+
+      # Calculate duration in milliseconds from an event
+      #
+      # @param event [ActiveSupport::Notifications::Event] The event
+      # @return [Float] Duration in milliseconds
+      def duration_ms(event)
+        event.duration.round(2)
+      end
+    end
+  end
+end

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/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
 
@@ -138,6 +139,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 = "5.27.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

@@ -31,5 +31,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "railties", ">= 5.0"
-  spec.add_dependency "sentry-ruby", "~> 5.26.0"
+  spec.add_dependency "sentry-ruby", "~> 5.27.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sentry-rails
 version: !ruby/object:Gem::Version
-  version: 5.26.0
+  version: 5.27.0
 platform: ruby
 authors:
 - Sentry Team
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.26.0
+        version: 5.27.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.26.0
+        version: 5.27.0
 description: A gem that provides Rails integration for the Sentry error logger
 email: accounts@sentry.io
 executables: []
@@ -56,6 +56,7 @@ files:
 - app/jobs/sentry/send_event_job.rb
 - bin/console
 - bin/setup
+- bin/test
 - lib/generators/sentry_generator.rb
 - lib/sentry-rails.rb
 - lib/sentry/rails.rb
@@ -72,9 +73,16 @@ files:
 - lib/sentry/rails/engine.rb
 - lib/sentry/rails/error_subscriber.rb
 - lib/sentry/rails/instrument_payload_cleanup_helper.rb
+- lib/sentry/rails/log_subscriber.rb
+- lib/sentry/rails/log_subscribers/action_controller_subscriber.rb
+- lib/sentry/rails/log_subscribers/action_mailer_subscriber.rb
+- lib/sentry/rails/log_subscribers/active_job_subscriber.rb
+- lib/sentry/rails/log_subscribers/active_record_subscriber.rb
+- lib/sentry/rails/log_subscribers/parameter_filter.rb
 - lib/sentry/rails/overrides/streaming_reporter.rb
 - lib/sentry/rails/railtie.rb
 - lib/sentry/rails/rescued_exception_interceptor.rb
+- lib/sentry/rails/structured_logging.rb
 - lib/sentry/rails/tracing.rb
 - lib/sentry/rails/tracing/abstract_subscriber.rb
 - lib/sentry/rails/tracing/action_controller_subscriber.rb
@@ -84,15 +92,15 @@ files:
 - lib/sentry/rails/tracing/active_support_subscriber.rb
 - lib/sentry/rails/version.rb
 - sentry-rails.gemspec
-homepage: https://github.com/getsentry/sentry-ruby/tree/5.26.0/sentry-rails
+homepage: https://github.com/getsentry/sentry-ruby/tree/5.27.0/sentry-rails
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/getsentry/sentry-ruby/tree/5.26.0/sentry-rails
-  source_code_uri: https://github.com/getsentry/sentry-ruby/tree/5.26.0/sentry-rails
-  changelog_uri: https://github.com/getsentry/sentry-ruby/blob/5.26.0/CHANGELOG.md
+  homepage_uri: https://github.com/getsentry/sentry-ruby/tree/5.27.0/sentry-rails
+  source_code_uri: https://github.com/getsentry/sentry-ruby/tree/5.27.0/sentry-rails
+  changelog_uri: https://github.com/getsentry/sentry-ruby/blob/5.27.0/CHANGELOG.md
   bug_tracker_uri: https://github.com/getsentry/sentry-ruby/issues
-  documentation_uri: http://www.rubydoc.info/gems/sentry-rails/5.26.0
+  documentation_uri: http://www.rubydoc.info/gems/sentry-rails/5.27.0
 rdoc_options: []
 require_paths:
 - lib
@@ -107,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A gem that provides Rails integration for the Sentry error logger
 test_files: []