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

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

CHANGELOG.md

@@ -8,6 +8,7 @@
   - Automatically generates spans for all SQLite statements
   - To use it, pass your `SQLiteDriver` to `SentrySQLiteDriver.create(...)`
   - You'll need `androidx.sqlite:sqlite` (2.5.0+) on your app's classpath (Room usually provides it for you). androidx.sqlite 2.6.0+ requires minSdk 23.
+  - The Room 2.7+ `androidx.sqlite.driver.SupportSQLiteDriver` bridge adapter is recognized and skipped by `SentrySQLiteDriver.create(...)` so apps that wrap both the open helper and the bridge driver do not emit duplicate spans. Spans come from the open helper layer in that configuration.
   - See https://docs.sentry.io/platforms/android/integrations/room-and-sqlite/ for more details, including info about migrating from `SentrySupportSQLiteOpenHelper`
 
 ## 8.43.1

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

@@ -21,10 +21,9 @@ import io.sentry.SentryLevel
  *     .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, so combining them will produce
- * duplicate spans for every SQL statement.
+ * Note: In order to avoid duplicate spans, wrapping no-ops in the case of the
+ * `androidx.sqlite.driver.SupportSQLiteDriver`. Wrap the open helper passed to its constructor via
+ * `SentrySupportSQLiteOpenHelper` instead.
  *
  * @param delegate The [SQLiteDriver] instance to delegate calls to.
  */
@@ -68,8 +67,22 @@ public class SentrySQLiteDriver private constructor(private val delegate: SQLite
 
   public companion object {
 
+    /**
+     * Fully-qualified class 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.
+     */
+    private const val SUPPORT_SQLITE_DRIVER_FQN = "androidx.sqlite.driver.SupportSQLiteDriver"
+
     @JvmStatic
     public fun create(delegate: SQLiteDriver): SQLiteDriver =
-      delegate as? SentrySQLiteDriver ?: SentrySQLiteDriver(delegate)
+      // String rather than an `is` check for SupportSQLiteDriver to avoid a compile-time dependency
+      // on androidx.sqlite:sqlite-framework.
+      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,22 @@
+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)`.
+ *
+ * The production check is `delegate.javaClass.name ==
+ * "androidx.sqlite.driver.SupportSQLiteDriver"`, so any class with this exact fully-qualified name
+ * exercises the branch.
+ */
+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)