chore(android-sqlite): Skip wrapping SupportSQLiteDriver bridge to avoid duplicate spans (#5514)

SentrySQLiteDriver.create() now recognizes the Room 2.7+ androidx.sqlite.driver.SupportSQLiteDriver bridge adapter and returns it unwrapped. That lets us protect against the one known vector where using both SentrySQLiteDriver and SentrySupportSQLiteOpenHelper with the same db table is allowed under either the Room or SQLDelight APIs:

```kotlin
// AVOID — this configuration produces duplicate spans for every SQL statement.

// Step 1: Developer wraps their open helper with Sentry, either manually or
// via the Sentry Android Gradle Plugin.
val sentryWrappedHelper: SupportSQLiteOpenHelper =
    SentrySupportSQLiteOpenHelper.create(
        FrameworkSQLiteOpenHelperFactory().create(configuration)
    )

// Step 2: Developer builds the compat driver around that wrapped helper.
val driver: SQLiteDriver = SupportSQLiteDriver(sentryWrappedHelper)

// Step 3: Developer (wrongly!) wraps the driver with Sentry as well. All
// spans will now be duplicated.
val sentryWrappedDriver: SQLiteDriver = SentrySQLiteDriver.create(driver)

Room.databaseBuilder(context, MyDb::class.java, "mydb")
    .setDriver(sentryWrappedDriver)
    .build()
```

This commit lets us avoid step 3 by no-op'ing if a developer tries to pass a SupportSQLiteDriver to SentrySQLiteDriver.create().

Author: 0xadam-brown

sentry-android-sqlite/proguard-rules.pro

@@ -4,4 +4,8 @@
 # https://developer.android.com/studio/build/shrink-code#decode-stack-trace
 -keepattributes LineNumberTable,SourceFile
 
+# SentrySQLiteDriver.create() uses a runtime class-name check to skip wrapping the Room 2.7+
+# SupportSQLiteDriver bridge adapter and avoid duplicate spans.
+-keepnames class androidx.sqlite.driver.SupportSQLiteDriver
+
 ##---------------End: proguard configuration for SQLite  ----------

sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt

@@ -22,11 +22,6 @@ import org.jetbrains.annotations.ApiStatus
  *     .build()
  * ```
  *
- * **Warning:** Do not use [SentrySQLiteDriver] together with
- * [SentrySupportSQLiteOpenHelper][io.sentry.android.sqlite.SentrySupportSQLiteOpenHelper] on the
- * same database file. Both wrappers instrument at different layers and combining them will produce
- * duplicate spans.
- *
  * @param delegate The [SQLiteDriver] instance to delegate calls to.
  */
 @ApiStatus.Experimental
@@ -73,11 +68,32 @@ public class SentrySQLiteDriver private constructor(private val delegate: SQLite
   public companion object {
 
     /**
-     * Wraps the provided delegate in a [SentrySQLiteDriver]. Returns the delegate as-is if already
-     * wrapped.
+     * Name of the bridge adapter often used with Room 2.7+. It implements the `SQLiteDriver`
+     * interface and its constructor consumes a `SupportSQLiteOpenHelper`. (Users of the Sentry
+     * Android Gradle Plugin will have the `SupportSQLiteOpenHelper` wrapped for them
+     * automatically.) We deliberately avoid wrapping the adapter to prevent duplicate spans.
+     *
+     * String (rather than an `is` check) lets us avoid a compile-time dependency on
+     * androidx.sqlite:sqlite-framework.
+     */
+    private const val SUPPORT_SQLITE_DRIVER_FQN = "androidx.sqlite.driver.SupportSQLiteDriver"
+
+    /**
+     * Wraps the provided delegate in a [SentrySQLiteDriver].
+     *
+     * To avoid duplicate spans, returns the delegate as-is if:
+     * 1. it's already wrapped, or
+     * 2. it's an `androidx.sqlite.driver.SupportSQLiteDriver`.
+     *
+     * In the case of (2), wrap the open helper passed to the `SupportSQLiteDriver` constructor via
+     * `SentrySupportSQLiteOpenHelper` instead.
      */
     @JvmStatic
     public fun create(delegate: SQLiteDriver): SQLiteDriver =
-      delegate as? SentrySQLiteDriver ?: SentrySQLiteDriver(delegate)
+      if (delegate is SentrySQLiteDriver || delegate.javaClass.name == SUPPORT_SQLITE_DRIVER_FQN) {
+        delegate
+      } else {
+        SentrySQLiteDriver(delegate)
+      }
   }
 }

sentry-android-sqlite/src/test/java/androidx/sqlite/driver/SupportSQLiteDriver.kt

@@ -0,0 +1,18 @@
+package androidx.sqlite.driver
+
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.SQLiteDriver
+
+/**
+ * Minimal stub of `androidx.sqlite.driver.SupportSQLiteDriver` (which lives in
+ * `androidx.sqlite:sqlite-framework`, not on this module's compile/test classpath) for verifying
+ * behavior of `SentrySQLiteDriver.create(SupportSQLiteDriver)`.
+ */
+internal class SupportSQLiteDriver : SQLiteDriver {
+
+  override val hasConnectionPool: Boolean = false
+
+  override fun open(fileName: String): SQLiteConnection {
+    throw UnsupportedOperationException("Test stub; not for runtime use")
+  }
+}

sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteDriverTest.kt

@@ -3,6 +3,7 @@ package io.sentry.sqlite
 import androidx.sqlite.SQLiteConnection
 import androidx.sqlite.SQLiteDriver
 import androidx.sqlite.SQLiteStatement
+import androidx.sqlite.driver.SupportSQLiteDriver
 import io.sentry.IScopes
 import io.sentry.Sentry
 import io.sentry.SentryIntegrationPackageStorage
@@ -64,6 +65,16 @@ class SentrySQLiteDriverTest {
     assertSame(wrapped, doubleWrapped)
   }
 
+  @Test
+  fun `create with SupportSQLiteDriver bridge returns same instance without wrapping`() {
+    val bridge = SupportSQLiteDriver()
+
+    val result = SentrySQLiteDriver.create(bridge)
+
+    assertSame(bridge, result)
+    assertFalse(result is SentrySQLiteDriver)
+  }
+
   @Test
   fun `hasConnectionPool forwards delegate value when supported`() {
     whenever(fixture.mockDriver.hasConnectionPool).thenReturn(true)

sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/DisplayInfo.kt

@@ -87,6 +87,11 @@ internal val OPENHELPER_ROOM =
         .trimIndent(),
   )
 
+// Bridge demos run the same SQL as the driver paths; spans come from the open-helper layer.
+internal val BRIDGE_DIRECT = DRIVER_DIRECT
+
+internal val BRIDGE_ROOM2 = DRIVER_ROOM2
+
 internal val OPENHELPER_SQLDELIGHT =
   DisplayInfo(
     sql =