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

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 =