sentry-rails 6.6.2 → 6.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44a207c0e909b1ea919c9d130a2bf27485e8bd874adb0a966e1e9bb30d9c71c2
-  data.tar.gz: b844646d40267eafbd251589e92980dc7e53f51516de55719c7e6ea2151013f5
+  metadata.gz: c85c3cd23ce9e1d1cc8487220a8669e462dd01318d0309cec4af19289d9840c4
+  data.tar.gz: 30d3605a772942de5b36aa561a0780b1d697bd274c012a0168e49334ab88e71e
 SHA512:
-  metadata.gz: fef273825c5a0027a80ada950a7c2ef944f9ff1e90aeaeab5edf394fed2fdbd2e15b2d358dc23b164f0c20194de7d8ad24f0cc4d4ef709b99352b8848dcd3703
-  data.tar.gz: 02a194fc6e01148d5b24522f8eb03b56d430ea93631325ab7118d43ebae99610b584f5518939636693ec46e7f2dbfc6304072acf1bb0e0063aa8cbc94d54a0f9
+  metadata.gz: 4af8635e17a8f79ffe219a155ab68b8077f24966fa0ea42383e26e484fbfdea8d7ddf63e9959ed627023a9209cf62dc1522953797cef8e324bf4402b5954bd6f
+  data.tar.gz: 67cc6cd95888b69e8c18d24fdb8b34184977ccce450a1e66b2610b71a49ee3339843eeded930180b1a6aa7144ecc7ab23e9ad33bd0eeace72669f785a68c46af

data/.gitignore

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

data/Gemfile

@@ -32,13 +32,16 @@ gem "rails", "~> #{rails_version}"
 
 if rails_version >= Gem::Version.new("8.1.0")
   gem "rspec-rails", "~> 8.0.0"
+  gem "solid_queue"
   gem "sqlite3", "~> 2.1.1", platform: :ruby
 elsif rails_version >= Gem::Version.new("8.0.0")
   gem "rspec-rails", "~> 8.0.0"
+  gem "solid_queue"
   gem "sqlite3", "~> 2.1.1", platform: :ruby
 elsif rails_version >= Gem::Version.new("7.1.0")
   gem "psych", "~> 4.0.0"
   gem "rspec-rails", "~> 7.0"
+  gem "solid_queue"
   gem "sqlite3", "~> 1.7.3", platform: :ruby
 elsif rails_version >= Gem::Version.new("6.1.0")
   gem "rspec-rails", "~> 6.0"
@@ -56,6 +59,53 @@ end
 
 gem "mini_magick"
 
+# Sidekiq is a dev-only dependency, used by the common ActiveJob spec
+# suite to verify the AJ tracing extension works against the :sidekiq
+# adapter independent of sentry-sidekiq's native middleware.
+#
+# Gated on Ruby/Rails/platform because:
+#   - The sidekiq_adapter_spec only passes on Rails > 7.0.
+#   - Sidekiq 8 requires Ruby >= 3.2; older Rubies fall back to Sidekiq 7.
+#   - Sidekiq does not reliably support JRuby.
+#
+# sidekiq_adapter_spec.rb also rescues LoadError and re-checks the
+# Rails version, so matrices that don't bundle Sidekiq skip the spec
+# cleanly without any other gating.
+unless RUBY_PLATFORM.include?("java")
+  if rails_version > Gem::Version.new("7.0.0") && ruby_version >= Gem::Version.new("3.2")
+    gem "sidekiq", "~> 8.0"
+  elsif rails_version > Gem::Version.new("7.0.0")
+    gem "sidekiq", "~> 7.0"
+  end
+end
+
+# delayed_job and resque are dev-only dependencies, used by the common
+# ActiveJob spec suite to verify the AJ tracing extension works against
+# the :delayed_job and :resque adapters independent of the dedicated
+# sentry-delayed_job / sentry-resque integrations.
+#
+# Both spec files rescue LoadError and skip cleanly on matrices that
+# don't bundle the gem, so the gating below only needs to keep
+# `bundle install` resolvable — it doesn't have to be exact.
+unless RUBY_PLATFORM.include?("java")
+  # delayed_job is backed by ActiveRecord here (delayed_job_active_record),
+  # reusing the dummy app's SQLite database. It supports every Ruby/Rails
+  # combination in the matrix.
+  gem "delayed_job"
+  gem "delayed_job_active_record"
+
+  # resque has no in-memory test mode, so the spec drives it through
+  # mock_redis instead of a live Redis (mirroring how the sidekiq context
+  # uses Sidekiq's fake mode). resque 3 / resque-scheduler 5 / mock_redis
+  # all require Ruby >= 3.0, so gate them on that — older matrices skip
+  # the resque spec via its LoadError rescue.
+  if ruby_version >= Gem::Version.new("3.0")
+    gem "resque"
+    gem "resque-scheduler", "~> 5.0"
+    gem "mock_redis"
+  end
+end
+
 gem "sprockets-rails"
 
 gem "benchmark-ips"

data/README.md

@@ -11,7 +11,7 @@
 
 
 [![Gem Version](https://img.shields.io/gem/v/sentry-rails.svg)](https://rubygems.org/gems/sentry-rails)
-![Build Status](https://github.com/getsentry/sentry-ruby/actions/workflows/sentry_rails_test.yml/badge.svg)
+![Build Status](https://github.com/getsentry/sentry-ruby/actions/workflows/tests.yml/badge.svg)
 [![Coverage Status](https://img.shields.io/codecov/c/github/getsentry/sentry-ruby/master?logo=codecov)](https://codecov.io/gh/getsentry/sentry-ruby/branch/master)
 [![Gem](https://img.shields.io/gem/dt/sentry-rails.svg)](https://rubygems.org/gems/sentry-rails/)
 [![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=sentry-rails&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=sentry-rails&package-manager=bundler&version-scheme=semver)

data/bin/test

@@ -1,389 +1,15 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env bash
 
-# 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
+# Thin wrapper so you can run this gem's specs from inside its own directory:
+# forwards to the repo-root bin/test scoped to this gem (--gem <thisgem>). All
+# args pass through, so spec paths and flags work as documented there.
 #
-# 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
+#   bin/test                          # auto-pick the newest installed Ruby cell
+#   bin/test spec/.../foo_spec.rb     # forward args to rspec
+#   bin/test --cell <path>            # pin an exact cell
+#   bin/test --rake                   # run `bundle exec rake` like CI
 #
-# Usage:
-#   ./bin/test --version 5.0
-#   ./bin/test --all
-#   ./bin/test --help
-
-require 'optparse'
-require 'fileutils'
-
-class RailsVersionTester
-  SUPPORTED_VERSIONS = %w[5.2 6.0 6.1 7.0 7.1 7.2 8.0 8.1].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
+# See `../../bin/test --help` for the full interface.
+set -euo pipefail
+gem_dir="$(cd "$(dirname "$0")/.." && pwd)"
+exec "$(dirname "$gem_dir")/bin/test" --gem "$(basename "$gem_dir")" "$@"