feat(sequel): add Sequel database extension for query instrumentation

Author: solnic

sentry-ruby/Gemfile

@@ -7,8 +7,11 @@ eval_gemfile "../Gemfile.dev"
 
 gem "sentry-ruby", path: "./"
 
+ruby_version = Gem::Version.new(RUBY_VERSION)
+
 rack_version = ENV["RACK_VERSION"]
 rack_version = "3.0.0" if rack_version.nil?
+
 gem "rack", "~> #{Gem::Version.new(rack_version)}" unless rack_version == "0"
 
 redis_rb_version = ENV.fetch("REDIS_RB_VERSION", "5.0")
@@ -32,3 +35,24 @@ gem "webrick"
 gem "faraday"
 gem "excon"
 gem "webmock"
+
+group :sequel do
+  gem "sequel"
+
+  sqlite_version = if ruby_version >= Gem::Version.new("3.2")
+    "2.1.0"
+  elsif ruby_version >= Gem::Version.new("3.0")
+    "1.4.0"
+  else
+    "1.3.0"
+  end
+
+  platform :ruby do
+    gem "sqlite3", "~> #{sqlite_version}"
+  end
+
+  platform :jruby do
+    gem "activerecord-jdbcmysql-adapter"
+    gem "jdbc-sqlite3"
+  end
+end

sentry-ruby/lib/sentry/sequel.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Sequel
+    OP_NAME = "db.sql.sequel"
+    SPAN_ORIGIN = "auto.db.sequel"
+
+    # Sequel Database extension module that instruments queries
+    module DatabaseExtension
+      def log_connection_yield(sql, conn, args = nil)
+        return super unless Sentry.initialized?
+
+        Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f, origin: SPAN_ORIGIN) do |span|
+          result = super
+
+          if span
+            span.set_description(sql)
+            span.set_data(Span::DataConventions::DB_SYSTEM, database_type.to_s)
+            span.set_data(Span::DataConventions::DB_NAME, opts[:database]) if opts[:database]
+            span.set_data(Span::DataConventions::SERVER_ADDRESS, opts[:host]) if opts[:host]
+            span.set_data(Span::DataConventions::SERVER_PORT, opts[:port]) if opts[:port]
+          end
+
+          result
+        end
+      end
+    end
+  end
+
+  ::Sequel::Database.register_extension(:sentry, Sentry::Sequel::DatabaseExtension)
+end
+
+Sentry.register_patch(:sequel) do
+  ::Sequel::Database.extension(:sentry) if defined?(::Sequel::Database)
+end

sentry-ruby/spec/sentry/sequel_spec.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "sequel"
+
+# Load the sequel patch
+require "sentry/sequel"
+
+RSpec.describe Sentry::Sequel do
+  let(:db) do
+    if RUBY_ENGINE == "jruby"
+      Sequel.connect("jdbc:sqlite::memory:")
+    else
+      Sequel.sqlite
+    end
+  end
+
+  before do
+    # Create a simple test table
+    db.create_table :posts do
+      primary_key :id
+      String :title
+    end
+
+    # Trigger Sequel's internal initialization (e.g., SELECT sqlite_version())
+    db[:posts].count
+  end
+
+  after do
+    db.drop_table?(:posts)
+  end
+
+  context "with tracing enabled" do
+    before do
+      perform_basic_setup do |config|
+        config.traces_sample_rate = 1.0
+        config.enabled_patches << :sequel
+      end
+
+      # Apply patch to this specific database instance
+      db.extension(:sentry)
+    end
+
+    it "records a span for SELECT queries" do
+      transaction = Sentry.start_transaction
+      Sentry.get_current_scope.set_span(transaction)
+
+      db[:posts].all
+
+      spans = transaction.span_recorder.spans
+      db_span = spans.find { |span| span.op == "db.sql.sequel" }
+
+      expect(db_span).not_to be_nil
+      expect(db_span.description).to include("SELECT")
+      expect(db_span.description).to include("posts")
+      expect(db_span.origin).to eq("auto.db.sequel")
+    end
+
+    it "records a span for INSERT queries" do
+      transaction = Sentry.start_transaction
+      Sentry.get_current_scope.set_span(transaction)
+
+      db[:posts].insert(title: "Hello World")
+
+      spans = transaction.span_recorder.spans
+      db_span = spans.find { |span| span.op == "db.sql.sequel" && span.description&.include?("INSERT") }
+
+      expect(db_span).not_to be_nil
+      expect(db_span.description).to include("INSERT")
+      expect(db_span.description).to include("posts")
+    end
+
+    it "records a span for UPDATE queries" do
+      db[:posts].insert(title: "Hello World")
+
+      transaction = Sentry.start_transaction
+      Sentry.get_current_scope.set_span(transaction)
+
+      db[:posts].where(title: "Hello World").update(title: "Updated")
+
+      spans = transaction.span_recorder.spans
+      db_span = spans.find { |span| span.op == "db.sql.sequel" && span.description&.include?("UPDATE") }
+
+      expect(db_span).not_to be_nil
+      expect(db_span.description).to include("UPDATE")
+      expect(db_span.description).to include("posts")
+    end
+
+    it "records a span for DELETE queries" do
+      db[:posts].insert(title: "Hello World")
+
+      transaction = Sentry.start_transaction
+      Sentry.get_current_scope.set_span(transaction)
+
+      db[:posts].where(title: "Hello World").delete
+
+      spans = transaction.span_recorder.spans
+      db_span = spans.find { |span| span.op == "db.sql.sequel" && span.description&.include?("DELETE") }
+
+      expect(db_span).not_to be_nil
+      expect(db_span.description).to include("DELETE")
+      expect(db_span.description).to include("posts")
+    end
+
+    it "sets span data with database information" do
+      transaction = Sentry.start_transaction
+      Sentry.get_current_scope.set_span(transaction)
+
+      db[:posts].all
+
+      spans = transaction.span_recorder.spans
+      db_span = spans.find { |span| span.op == "db.sql.sequel" }
+
+      expect(db_span.data["db.system"]).to eq("sqlite")
+    end
+
+    it "sets correct timestamps on span" do
+      transaction = Sentry.start_transaction
+      Sentry.get_current_scope.set_span(transaction)
+
+      db[:posts].all
+
+      spans = transaction.span_recorder.spans
+      db_span = spans.find { |span| span.op == "db.sql.sequel" }
+
+      expect(db_span.start_timestamp).not_to be_nil
+      expect(db_span.timestamp).not_to be_nil
+      expect(db_span.start_timestamp).to be < db_span.timestamp
+    end
+  end
+
+  context "without active transaction" do
+    before do
+      perform_basic_setup do |config|
+        config.traces_sample_rate = 1.0
+        config.enabled_patches << :sequel
+      end
+
+      db.extension(:sentry)
+    end
+
+    it "does not create spans when no transaction is active" do
+      # No transaction started
+      result = db[:posts].all
+
+      # Query should still work
+      expect(result).to eq([])
+    end
+  end
+
+  context "when Sentry is not initialized" do
+    before do
+      # Don't initialize Sentry
+      db.extension(:sentry)
+    end
+
+    it "does not interfere with normal database operations" do
+      result = db[:posts].insert(title: "Test")
+      expect(result).to eq(1)
+
+      posts = db[:posts].all
+      expect(posts.length).to eq(1)
+      expect(posts.first[:title]).to eq("Test")
+    end
+  end
+end