Collect database transaction spans (BEGIN, COMMIT, ROLLBACK) (#5072)

* Collect db transaction spans

* make span creation for db transactions opt-in

* remove code duplication

* changelog

Author: adinauer

CHANGELOG.md

@@ -7,6 +7,14 @@
 - Add `installGroupsOverride` parameter and `installGroups` property to Build Distribution SDK ([#5062](https://github.com/getsentry/sentry-java/pull/5062))
 - Update Android targetSdk to API 36 (Android 16) ([#5016](https://github.com/getsentry/sentry-java/pull/5016))
 - Add AndroidManifest support for Spotlight configuration via `io.sentry.spotlight.enable` and `io.sentry.spotlight.url` ([#5064](https://github.com/getsentry/sentry-java/pull/5064))
+- Collect database transaction spans (`BEGIN`, `COMMIT`, `ROLLBACK`) ([#5072](https://github.com/getsentry/sentry-java/pull/5072))
+  - To enable creation of these spans, set `options.enableDatabaseTransactionTracing` to `true`
+  - `enable-database-transaction-tracing=true` when using `sentry.properties`
+  - For Spring Boot, use `sentry.enable-database-transaction-tracing=true` in `application.properties` or in `application.yml`:
+    ```yaml
+    sentry:
+      enable-database-transaction-tracing: true
+    ```
 
 ### Fixes
 

sentry-jdbc/api/sentry-jdbc.api

@@ -6,6 +6,7 @@ public final class io/sentry/jdbc/BuildConfig {
 public final class io/sentry/jdbc/DatabaseUtils {
 	public fun <init> ()V
 	public static fun parse (Ljava/lang/String;)Lio/sentry/jdbc/DatabaseUtils$DatabaseDetails;
+	public static fun readFrom (Lcom/p6spy/engine/common/ConnectionInformation;)Lio/sentry/jdbc/DatabaseUtils$DatabaseDetails;
 	public static fun readFrom (Lcom/p6spy/engine/common/StatementInformation;)Lio/sentry/jdbc/DatabaseUtils$DatabaseDetails;
 }
 
@@ -19,6 +20,12 @@ public class io/sentry/jdbc/SentryJdbcEventListener : com/p6spy/engine/event/Sim
 	public fun <init> ()V
 	public fun <init> (Lio/sentry/IScopes;)V
 	public fun onAfterAnyExecute (Lcom/p6spy/engine/common/StatementInformation;JLjava/sql/SQLException;)V
+	public fun onAfterCommit (Lcom/p6spy/engine/common/ConnectionInformation;JLjava/sql/SQLException;)V
+	public fun onAfterRollback (Lcom/p6spy/engine/common/ConnectionInformation;JLjava/sql/SQLException;)V
+	public fun onAfterSetAutoCommit (Lcom/p6spy/engine/common/ConnectionInformation;ZZLjava/sql/SQLException;)V
 	public fun onBeforeAnyExecute (Lcom/p6spy/engine/common/StatementInformation;)V
+	public fun onBeforeCommit (Lcom/p6spy/engine/common/ConnectionInformation;)V
+	public fun onBeforeRollback (Lcom/p6spy/engine/common/ConnectionInformation;)V
+	public fun onBeforeSetAutoCommit (Lcom/p6spy/engine/common/ConnectionInformation;ZZ)V
 }
 

sentry-jdbc/src/main/java/io/sentry/jdbc/DatabaseUtils.java

@@ -20,6 +20,11 @@ public static DatabaseDetails readFrom(
 
     final @Nullable ConnectionInformation connectionInformation =
         statementInformation.getConnectionInformation();
+    return readFrom(connectionInformation);
+  }
+
+  public static DatabaseDetails readFrom(
+      final @Nullable ConnectionInformation connectionInformation) {
     if (connectionInformation == null) {
       return EMPTY;
     }

sentry-jdbc/src/main/java/io/sentry/jdbc/SentryJdbcEventListener.java

@@ -4,14 +4,14 @@
 import static io.sentry.SpanDataConvention.DB_SYSTEM_KEY;
 
 import com.jakewharton.nopen.annotation.Open;
+import com.p6spy.engine.common.ConnectionInformation;
 import com.p6spy.engine.common.StatementInformation;
 import com.p6spy.engine.event.SimpleJdbcEventListener;
 import io.sentry.IScopes;
 import io.sentry.ISentryLifecycleToken;
 import io.sentry.ISpan;
 import io.sentry.ScopesAdapter;
 import io.sentry.SentryIntegrationPackageStorage;
-import io.sentry.Span;
 import io.sentry.SpanOptions;
 import io.sentry.SpanStatus;
 import io.sentry.util.AutoClosableReentrantLock;
@@ -20,12 +20,12 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-/** P6Spy JDBC event listener that creates {@link Span}s around database queries. */
 @Open
 public class SentryJdbcEventListener extends SimpleJdbcEventListener {
   private static final String TRACE_ORIGIN = "auto.db.jdbc";
   private final @NotNull IScopes scopes;
-  private static final @NotNull ThreadLocal<ISpan> CURRENT_SPAN = new ThreadLocal<>();
+  private static final @NotNull ThreadLocal<ISpan> CURRENT_QUERY_SPAN = new ThreadLocal<>();
+  private static final @NotNull ThreadLocal<ISpan> CURRENT_TRANSACTION_SPAN = new ThreadLocal<>();
 
   private volatile @Nullable DatabaseUtils.DatabaseDetails cachedDatabaseDetails = null;
   protected final @NotNull AutoClosableReentrantLock databaseDetailsLock =
@@ -47,24 +47,109 @@ public SentryJdbcEventListener() {
 
   @Override
   public void onBeforeAnyExecute(final @NotNull StatementInformation statementInformation) {
-    final ISpan parent = scopes.getSpan();
-    if (parent != null && !parent.isNoOp()) {
-      final @NotNull SpanOptions spanOptions = new SpanOptions();
-      spanOptions.setOrigin(TRACE_ORIGIN);
-      final ISpan span = parent.startChild("db.query", statementInformation.getSql(), spanOptions);
-      CURRENT_SPAN.set(span);
-    }
+    startSpan(CURRENT_QUERY_SPAN, "db.query", statementInformation.getSql());
   }
 
   @Override
   public void onAfterAnyExecute(
       final @NotNull StatementInformation statementInformation,
       long timeElapsedNanos,
       final @Nullable SQLException e) {
-    final ISpan span = CURRENT_SPAN.get();
+    finishSpan(CURRENT_QUERY_SPAN, statementInformation.getConnectionInformation(), e);
+  }
+
+  @Override
+  public void onBeforeSetAutoCommit(
+      final @NotNull ConnectionInformation connectionInformation,
+      boolean newAutoCommit,
+      boolean currentAutoCommit) {
+    if (!isDatabaseTransactionTracingEnabled()) {
+      return;
+    }
+    final boolean isSwitchingToManualCommit = !newAutoCommit && currentAutoCommit;
+    if (isSwitchingToManualCommit) {
+      startSpan(CURRENT_TRANSACTION_SPAN, "db.sql.transaction.begin", "BEGIN");
+    }
+  }
+
+  @Override
+  public void onAfterSetAutoCommit(
+      final @NotNull ConnectionInformation connectionInformation,
+      final boolean newAutoCommit,
+      final boolean oldAutoCommit,
+      final @Nullable SQLException e) {
+    if (!isDatabaseTransactionTracingEnabled()) {
+      return;
+    }
+    final boolean isSwitchingToManualCommit = !newAutoCommit && oldAutoCommit;
+    if (isSwitchingToManualCommit) {
+      finishSpan(CURRENT_TRANSACTION_SPAN, connectionInformation, e);
+    }
+  }
+
+  @Override
+  public void onBeforeCommit(final @NotNull ConnectionInformation connectionInformation) {
+    if (!isDatabaseTransactionTracingEnabled()) {
+      return;
+    }
+    startSpan(CURRENT_TRANSACTION_SPAN, "db.sql.transaction.commit", "COMMIT");
+  }
+
+  @Override
+  public void onAfterCommit(
+      final @NotNull ConnectionInformation connectionInformation,
+      final long timeElapsedNanos,
+      final @Nullable SQLException e) {
+    if (!isDatabaseTransactionTracingEnabled()) {
+      return;
+    }
+    finishSpan(CURRENT_TRANSACTION_SPAN, connectionInformation, e);
+  }
+
+  @Override
+  public void onBeforeRollback(final @NotNull ConnectionInformation connectionInformation) {
+    if (!isDatabaseTransactionTracingEnabled()) {
+      return;
+    }
+    startSpan(CURRENT_TRANSACTION_SPAN, "db.sql.transaction.rollback", "ROLLBACK");
+  }
+
+  @Override
+  public void onAfterRollback(
+      final @NotNull ConnectionInformation connectionInformation,
+      final long timeElapsedNanos,
+      final @Nullable SQLException e) {
+    if (!isDatabaseTransactionTracingEnabled()) {
+      return;
+    }
+    finishSpan(CURRENT_TRANSACTION_SPAN, connectionInformation, e);
+  }
+
+  private boolean isDatabaseTransactionTracingEnabled() {
+    return scopes.getOptions().isEnableDatabaseTransactionTracing();
+  }
+
+  private void startSpan(
+      final @NotNull ThreadLocal<ISpan> spanHolder,
+      final @NotNull String operation,
+      final @Nullable String description) {
+    final @Nullable ISpan parent = scopes.getSpan();
+    if (parent != null && !parent.isNoOp()) {
+      final @NotNull SpanOptions spanOptions = new SpanOptions();
+      spanOptions.setOrigin(TRACE_ORIGIN);
+      final @NotNull ISpan span = parent.startChild(operation, description, spanOptions);
+      spanHolder.set(span);
+    }
+  }
+
+  private void finishSpan(
+      final @NotNull ThreadLocal<ISpan> spanHolder,
+      final @Nullable ConnectionInformation connectionInformation,
+      final @Nullable SQLException e) {
+    final @Nullable ISpan span = spanHolder.get();
 
     if (span != null) {
-      applyDatabaseDetailsToSpan(statementInformation, span);
+      applyDatabaseDetailsToSpan(connectionInformation, span);
 
       if (e != null) {
         span.setThrowable(e);
@@ -73,7 +158,7 @@ public void onAfterAnyExecute(
         span.setStatus(SpanStatus.OK);
       }
       span.finish();
-      CURRENT_SPAN.set(null);
+      spanHolder.remove();
     }
   }
 
@@ -82,9 +167,9 @@ private void addPackageAndIntegrationInfo() {
   }
 
   private void applyDatabaseDetailsToSpan(
-      final @NotNull StatementInformation statementInformation, final @NotNull ISpan span) {
+      final @Nullable ConnectionInformation connectionInformation, final @NotNull ISpan span) {
     final @NotNull DatabaseUtils.DatabaseDetails databaseDetails =
-        getOrComputeDatabaseDetails(statementInformation);
+        getOrComputeDatabaseDetails(connectionInformation);
 
     if (databaseDetails.getDbSystem() != null) {
       span.setData(DB_SYSTEM_KEY, databaseDetails.getDbSystem());
@@ -96,11 +181,11 @@ private void applyDatabaseDetailsToSpan(
   }
 
   private @NotNull DatabaseUtils.DatabaseDetails getOrComputeDatabaseDetails(
-      final @NotNull StatementInformation statementInformation) {
+      final @Nullable ConnectionInformation connectionInformation) {
     if (cachedDatabaseDetails == null) {
       try (final @NotNull ISentryLifecycleToken ignored = databaseDetailsLock.acquire()) {
         if (cachedDatabaseDetails == null) {
-          cachedDatabaseDetails = DatabaseUtils.readFrom(statementInformation);
+          cachedDatabaseDetails = DatabaseUtils.readFrom(connectionInformation);
         }
       }
     }