sentry-rails 5.1.0 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f45143dd79cff19a0e7338912f235cec728d9ceb81a37e7a50df78a1722ce1b8
-  data.tar.gz: 7b5a8dec4f9b6875f6f42794911d30e7a75e0a8662e7d5e83584726066eb3fd4
+  metadata.gz: b63ec61238dbea2a3fee7cebbdcf72d1810dc50fe4863502ecdbc66b8da7b31e
+  data.tar.gz: 165e2974b74f63c062db1587c1852c151a5b350a15df13c408cea97476d6c10f
 SHA512:
-  metadata.gz: 0dbdd5331da560f4bc67a84390bb1f3579fbe7e03da95758cc2e3b103540f407bb2efb153202070f57dc4e2e1b5044dd9dca7e237272460560531d160890211c
-  data.tar.gz: 1163c26220a308aca6fe3f624e4358446f82d1919eda4daf0c38729f1977eba08b53c4f8bb65543adfc1df7a129ca4098af35060acb3d921d8ddf58025176633
+  metadata.gz: ec0d90eb1b44f1dfb45bb369586cb8ee22da1a79604679ec12f475e1916eefe646a34c1ab97de386a43e7a27c3e3999c684d61038571ad88c6e0dca667f23f45
+  data.tar.gz: fa67c7c00d3d9f71efd13fecb195ea945538f6535464e704115d5e1a8bf7f6c3cf65c3423369270809a6d49cb99ce4b7ab700cca0885756da673f39f99fac166

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/.rspec

@@ -1,3 +1,3 @@
---format documentation
+--format progress
 --color
 --require spec_helper

data/Gemfile

@@ -1,44 +1,62 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
+git_source(:github) { |name| "https://github.com/#{name}.git" }
+
+eval_gemfile "../Gemfile.dev"
 
 # Specify your gem's dependencies in sentry-ruby.gemspec
 gemspec
 gem "sentry-ruby", path: "../sentry-ruby"
 
-rails_version = ENV["RAILS_VERSION"]
-rails_version = "7.0.0" if rails_version.nil?
-rails_version = Gem::Version.new(rails_version)
+platform :jruby do
+  gem "activerecord-jdbcmysql-adapter"
+  gem "jdbc-sqlite3"
+end
 
-gem 'activerecord-jdbcmysql-adapter', platform: :jruby
-gem "jdbc-sqlite3", platform: :jruby
+ruby_version = Gem::Version.new(RUBY_VERSION)
 
-if rails_version < Gem::Version.new("6.0.0")
-  gem "sqlite3", "~> 1.3.0", platform: :ruby
-else
-  gem "sqlite3", platform: :ruby
+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"
+  else
+    "7.1"
+  end
 end
 
-if rails_version >= Gem::Version.new("7.0.0")
-  gem "rails", github: "rails/rails", branch: "7-0-stable"
-else
-  gem "rails", "~> #{rails_version}"
-end
+rails_version = Gem::Version.new(rails_version)
 
-gem "sprockets-rails"
+gem "rails", "~> #{rails_version}"
 
-gem "sidekiq"
+if rails_version >= Gem::Version.new("8.1.0")
+  gem "rspec-rails", "~> 8.0.0"
+  gem "sqlite3", "~> 2.1.1", platform: :ruby
+elsif rails_version >= Gem::Version.new("8.0.0")
+  gem "rspec-rails", "~> 8.0.0"
+  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 "sqlite3", "~> 1.7.3", platform: :ruby
+elsif rails_version >= Gem::Version.new("6.1.0")
+  gem "rspec-rails", "~> 6.0"
+  gem "sqlite3", "~> 1.7.3", platform: :ruby
+else
+  gem "psych", "~> 3.0.0"
+  gem "rspec-rails", "~> 4.0"
 
-gem "rspec", "~> 3.0"
-gem "rspec-retry"
-gem "rspec-rails", "~> 4.0"
-gem 'simplecov'
-gem "simplecov-cobertura", "~> 1.4"
-gem "rexml"
+  if rails_version >= Gem::Version.new("6.0.0")
+    gem "sqlite3", "~> 1.4.0", platform: :ruby
+  else
+    gem "sqlite3", "~> 1.3.0", platform: :ruby
+  end
+end
 
-gem "rake", "~> 12.0"
+gem "mini_magick"
 
-gem "object_tracer"
-gem "debug", github: "ruby/debug", platform: :ruby if RUBY_VERSION.to_f >= 2.6
-gem "pry"
+gem "sprockets-rails"
 
 gem "benchmark-ips"
 gem "benchmark_driver"

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/workflows/sentry-rails%20Test/badge.svg)
+![Build Status](https://github.com/getsentry/sentry-ruby/actions/workflows/sentry_rails_test.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/Rakefile

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require_relative "../lib/sentry/test/rake_tasks"
 
-RSpec::Core::RakeTask.new(:spec).tap do |task|
-  task.rspec_opts = "--order rand"
-end
+Sentry::Test::RakeTasks.define_spec_tasks(
+  spec_pattern: "spec/sentry/**/*_spec.rb",
+  spec_rspec_opts: "--order rand --format progress",
+  isolated_specs_pattern: "spec/isolated/**/*_spec.rb",
+  isolated_rspec_opts: "--format progress"
+)
 
-task :isolated_specs do
-  Dir["spec/isolated/*"].each do |file|
-    sh "bundle exec ruby #{file}"
-  end
-end
+Sentry::Test::RakeTasks.define_versioned_specs_task(
+  rspec_opts: "--order rand --format progress"
+)
 
-task :default => [:spec, :isolated_specs]
+task default: [:spec, :"spec:versioned", :"spec:isolated"]

data/app/jobs/sentry/send_event_job.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if defined?(ActiveJob)
   module Sentry
     parent_job =
@@ -31,4 +33,3 @@ else
     class SendEventJob; end
   end
 end
-

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
 require "sentry/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.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

data/lib/generators/sentry_generator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+class SentryGenerator < ::Rails::Generators::Base
+  class_option :dsn, type: :string, desc: "Sentry DSN"
+
+  class_option :inject_meta, type: :boolean, default: true, desc: "Inject meta tag into layout"
+
+  def copy_initializer_file
+    dsn = options[:dsn] ? "'#{options[:dsn]}'" : "ENV['SENTRY_DSN']"
+
+    create_file "config/initializers/sentry.rb", <<~RUBY
+      # frozen_string_literal: true
+
+      Sentry.init do |config|
+        config.breadcrumbs_logger = [:active_support_logger]
+        config.dsn = #{dsn}
+        config.traces_sample_rate = 1.0
+      end
+    RUBY
+  end
+
+  def inject_code_into_layout
+    return unless options[:inject_meta]
+
+    inject_into_file "app/views/layouts/application.html.erb", before: "</head>\n" do
+      "  <%= Sentry.get_trace_propagation_meta.html_safe %>\n  "
+    end
+  end
+end

data/lib/sentry/rails/action_cable.rb

@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rails
     module ActionCableExtensions
       class ErrorHandler
+        OP_NAME = "websocket.server"
+        SPAN_ORIGIN = "auto.http.rails.actioncable"
+
         class << self
           def capture(connection, transaction_name:, extra_context: nil, &block)
             return block.call unless Sentry.initialized?
@@ -13,13 +18,14 @@ module Sentry
             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_transaction_name(transaction_name, source: :view)
+              transaction = start_transaction(env, scope)
               scope.set_span(transaction) if transaction
 
               begin
-                block.call
+                result = block.call
                 finish_transaction(transaction, 200)
+                result
               rescue Exception => e # rubocop:disable Lint/RescueException
                 Sentry::Rails.capture_exception(e)
                 finish_transaction(transaction, 500)
@@ -29,10 +35,15 @@ module Sentry
             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
+          def start_transaction(env, scope)
+            options = {
+              name: scope.transaction_name,
+              source: scope.transaction_source,
+              op: OP_NAME,
+              origin: SPAN_ORIGIN
+            }
+
+            transaction = Sentry.continue_trace(env, **options)
             Sentry.start_transaction(transaction: transaction, **options)
           end