fix(okhttp): delegate canceled() outside of the call window

OkHttp may invoke canceled() before callStart() and after callEnd()/callFailed(),
so there is not always a listener bound to the call in originalEventListenerMap.
Fall back to creating a listener on the fly, without storing it, because a call
that is canceled before it starts never gets a callEnd() or callFailed() that
would remove the entry again.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: markushi

sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpEventListener.kt

@@ -397,7 +397,13 @@ public open class SentryOkHttpEventListener(
   }
 
   override fun canceled(call: Call) {
-    originalEventListenerMap[call]?.canceled(call)
+    // Unlike the other callbacks, canceled() can occur before callStart() and after
+    // callEnd()/callFailed(), so there is not always a listener bound to the call. Create one on
+    // the fly in that case, but do not put it in the map: nothing would remove it again, because
+    // a call that is canceled before it starts never gets a callEnd() or callFailed().
+    val originalEventListener =
+      originalEventListenerMap[call] ?: originalEventListenerCreator?.invoke(call) ?: return
+    originalEventListener.canceled(call)
   }
 
   override fun satisfactionFailure(call: Call, response: Response) {

sentry-okhttp/src/test/java/io/sentry/okhttp/SentryOkHttpEventListenerDelegationTest.kt

@@ -32,6 +32,10 @@ class SentryOkHttpEventListenerDelegationTest {
       received += "callFailed" to call
     }
 
+    override fun canceled(call: Call) {
+      received += "canceled" to call
+    }
+
     fun mismatches(): List<Pair<String, Call>> = received.filter { it.second !== ownCall }
   }
 
@@ -119,4 +123,71 @@ class SentryOkHttpEventListenerDelegationTest {
       .containsExactly("callStart", "callFailed")
       .inOrder()
   }
+
+  @Test
+  fun `cancel during a call is delegated to the listener of that call`() {
+    val sut = fixture.getSut()
+    val call = fixture.newCall("1")
+
+    sut.callStart(call)
+    sut.canceled(call)
+    sut.callFailed(call, IOException())
+
+    assertThat(fixture.listeners.single().received.map { it.first })
+      .containsExactly("callStart", "canceled", "callFailed")
+      .inOrder()
+  }
+
+  @Test
+  fun `cancel before callStart is delegated`() {
+    val sut = fixture.getSut()
+    val call = fixture.newCall("1")
+
+    sut.canceled(call)
+
+    assertThat(fixture.listeners.single().received).containsExactly("canceled" to call)
+  }
+
+  @Test
+  fun `cancel after callEnd is delegated`() {
+    val sut = fixture.getSut()
+    val call = fixture.newCall("1")
+
+    sut.callStart(call)
+    sut.callEnd(call)
+    sut.canceled(call)
+
+    assertThat(fixture.listeners.first().received.map { it.first })
+      .containsExactly("callStart", "callEnd")
+      .inOrder()
+    assertThat(fixture.listeners.last().received).containsExactly("canceled" to call)
+  }
+
+  @Test
+  fun `cancel outside of a call does not bind a listener to the call`() {
+    val sut = fixture.getSut()
+    val call = fixture.newCall("1")
+
+    sut.canceled(call)
+    sut.dnsStart(call, "sentry.io")
+
+    assertThat(fixture.listeners.single().received.map { it.first }).containsExactly("canceled")
+  }
+
+  @Test
+  fun `a single wrapped listener receives cancels outside of the call window`() {
+    whenever(fixture.scopes.options).thenReturn(SentryOptions())
+    val call = fixture.newCall("1")
+    val listener = RecordingListener(call)
+    val sut = SentryOkHttpEventListener(fixture.scopes, listener)
+
+    sut.canceled(call)
+    sut.callStart(call)
+    sut.callEnd(call)
+    sut.canceled(call)
+
+    assertThat(listener.received.map { it.first })
+      .containsExactly("canceled", "callStart", "callEnd", "canceled")
+      .inOrder()
+  }
 }