Skip to content

Commit 105211a

Browse files
markushiclaude
andcommitted
fix(okhttp): keep the wrapped EventListener per Call
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1 parent 27e07a5 commit 105211a

4 files changed

Lines changed: 195 additions & 59 deletions

File tree

‎sentry-okhttp/build.gradle.kts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,7 @@ dependencies {
3838
testImplementation(libs.mockito.inline)
3939
testImplementation(libs.okhttp)
4040
testImplementation(libs.okhttp.mockwebserver)
41+
testImplementation(libs.google.truth)
4142
}
4243

4344
buildConfig {

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

Lines changed: 62 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,7 @@ public open class SentryOkHttpEventListener(
4545
private val scopes: IScopes = ScopesAdapter.getInstance(),
4646
private val originalEventListenerCreator: ((call: Call) -> EventListener)? = null,
4747
) : EventListener() {
48-
private var originalEventListener: EventListener? = null
48+
private val originalEventListenerMap: MutableMap<Call, EventListener> = ConcurrentHashMap()
4949

5050
public companion object {
5151
internal const val PROXY_SELECT_EVENT = "http.client.proxy_select_ms"
@@ -85,27 +85,32 @@ public open class SentryOkHttpEventListener(
8585
) : this(scopes, originalEventListenerCreator = { originalEventListenerFactory.create(it) })
8686

8787
override fun callStart(call: Call) {
88-
originalEventListener = originalEventListenerCreator?.invoke(call)
88+
// The EventListener.Factory contract binds a listener to a single call, so the wrapped
89+
// listener is kept per call instead of in a field shared by all concurrent calls
90+
val originalEventListener = originalEventListenerCreator?.invoke(call)
91+
if (originalEventListener != null) {
92+
originalEventListenerMap[call] = originalEventListener
93+
}
8994
originalEventListener?.callStart(call)
9095
// If the wrapped EventListener is ours, we can just delegate the calls,
9196
// without creating other events that would create duplicates
92-
if (canCreateEventSpan()) {
97+
if (canCreateEventSpan(originalEventListener)) {
9398
eventMap[call] = SentryOkHttpEvent(scopes, call.request())
9499
}
95100
}
96101

97102
override fun proxySelectStart(call: Call, url: HttpUrl) {
98-
originalEventListener?.proxySelectStart(call, url)
99-
if (!canCreateEventSpan()) {
103+
originalEventListenerMap[call]?.proxySelectStart(call, url)
104+
if (!canCreateEventSpan(call)) {
100105
return
101106
}
102107
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
103108
okHttpEvent.onEventStart(PROXY_SELECT_EVENT)
104109
}
105110

106111
override fun proxySelectEnd(call: Call, url: HttpUrl, proxies: List<Proxy>) {
107-
originalEventListener?.proxySelectEnd(call, url, proxies)
108-
if (!canCreateEventSpan()) {
112+
originalEventListenerMap[call]?.proxySelectEnd(call, url, proxies)
113+
if (!canCreateEventSpan(call)) {
109114
return
110115
}
111116
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -117,17 +122,17 @@ public open class SentryOkHttpEventListener(
117122
}
118123

119124
override fun dnsStart(call: Call, domainName: String) {
120-
originalEventListener?.dnsStart(call, domainName)
121-
if (!canCreateEventSpan()) {
125+
originalEventListenerMap[call]?.dnsStart(call, domainName)
126+
if (!canCreateEventSpan(call)) {
122127
return
123128
}
124129
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
125130
okHttpEvent.onEventStart(DNS_EVENT)
126131
}
127132

128133
override fun dnsEnd(call: Call, domainName: String, inetAddressList: List<InetAddress>) {
129-
originalEventListener?.dnsEnd(call, domainName, inetAddressList)
130-
if (!canCreateEventSpan()) {
134+
originalEventListenerMap[call]?.dnsEnd(call, domainName, inetAddressList)
135+
if (!canCreateEventSpan(call)) {
131136
return
132137
}
133138
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -140,26 +145,26 @@ public open class SentryOkHttpEventListener(
140145
}
141146

142147
override fun connectStart(call: Call, inetSocketAddress: InetSocketAddress, proxy: Proxy) {
143-
originalEventListener?.connectStart(call, inetSocketAddress, proxy)
144-
if (!canCreateEventSpan()) {
148+
originalEventListenerMap[call]?.connectStart(call, inetSocketAddress, proxy)
149+
if (!canCreateEventSpan(call)) {
145150
return
146151
}
147152
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
148153
okHttpEvent.onEventStart(CONNECT_EVENT)
149154
}
150155

151156
override fun secureConnectStart(call: Call) {
152-
originalEventListener?.secureConnectStart(call)
153-
if (!canCreateEventSpan()) {
157+
originalEventListenerMap[call]?.secureConnectStart(call)
158+
if (!canCreateEventSpan(call)) {
154159
return
155160
}
156161
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
157162
okHttpEvent.onEventStart(SECURE_CONNECT_EVENT)
158163
}
159164

160165
override fun secureConnectEnd(call: Call, handshake: Handshake?) {
161-
originalEventListener?.secureConnectEnd(call, handshake)
162-
if (!canCreateEventSpan()) {
166+
originalEventListenerMap[call]?.secureConnectEnd(call, handshake)
167+
if (!canCreateEventSpan(call)) {
163168
return
164169
}
165170
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -172,8 +177,8 @@ public open class SentryOkHttpEventListener(
172177
proxy: Proxy,
173178
protocol: Protocol?,
174179
) {
175-
originalEventListener?.connectEnd(call, inetSocketAddress, proxy, protocol)
176-
if (!canCreateEventSpan()) {
180+
originalEventListenerMap[call]?.connectEnd(call, inetSocketAddress, proxy, protocol)
181+
if (!canCreateEventSpan(call)) {
177182
return
178183
}
179184
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -188,8 +193,8 @@ public open class SentryOkHttpEventListener(
188193
protocol: Protocol?,
189194
ioe: IOException,
190195
) {
191-
originalEventListener?.connectFailed(call, inetSocketAddress, proxy, protocol, ioe)
192-
if (!canCreateEventSpan()) {
196+
originalEventListenerMap[call]?.connectFailed(call, inetSocketAddress, proxy, protocol, ioe)
197+
if (!canCreateEventSpan(call)) {
193198
return
194199
}
195200
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -202,53 +207,53 @@ public open class SentryOkHttpEventListener(
202207
}
203208

204209
override fun connectionAcquired(call: Call, connection: Connection) {
205-
originalEventListener?.connectionAcquired(call, connection)
206-
if (!canCreateEventSpan()) {
210+
originalEventListenerMap[call]?.connectionAcquired(call, connection)
211+
if (!canCreateEventSpan(call)) {
207212
return
208213
}
209214
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
210215
okHttpEvent.onEventStart(CONNECTION_EVENT)
211216
}
212217

213218
override fun connectionReleased(call: Call, connection: Connection) {
214-
originalEventListener?.connectionReleased(call, connection)
215-
if (!canCreateEventSpan()) {
219+
originalEventListenerMap[call]?.connectionReleased(call, connection)
220+
if (!canCreateEventSpan(call)) {
216221
return
217222
}
218223
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
219224
okHttpEvent.onEventFinish(CONNECTION_EVENT)
220225
}
221226

222227
override fun requestHeadersStart(call: Call) {
223-
originalEventListener?.requestHeadersStart(call)
224-
if (!canCreateEventSpan()) {
228+
originalEventListenerMap[call]?.requestHeadersStart(call)
229+
if (!canCreateEventSpan(call)) {
225230
return
226231
}
227232
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
228233
okHttpEvent.onEventStart(REQUEST_HEADERS_EVENT)
229234
}
230235

231236
override fun requestHeadersEnd(call: Call, request: Request) {
232-
originalEventListener?.requestHeadersEnd(call, request)
233-
if (!canCreateEventSpan()) {
237+
originalEventListenerMap[call]?.requestHeadersEnd(call, request)
238+
if (!canCreateEventSpan(call)) {
234239
return
235240
}
236241
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
237242
okHttpEvent.onEventFinish(REQUEST_HEADERS_EVENT)
238243
}
239244

240245
override fun requestBodyStart(call: Call) {
241-
originalEventListener?.requestBodyStart(call)
242-
if (!canCreateEventSpan()) {
246+
originalEventListenerMap[call]?.requestBodyStart(call)
247+
if (!canCreateEventSpan(call)) {
243248
return
244249
}
245250
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
246251
okHttpEvent.onEventStart(REQUEST_BODY_EVENT)
247252
}
248253

249254
override fun requestBodyEnd(call: Call, byteCount: Long) {
250-
originalEventListener?.requestBodyEnd(call, byteCount)
251-
if (!canCreateEventSpan()) {
255+
originalEventListenerMap[call]?.requestBodyEnd(call, byteCount)
256+
if (!canCreateEventSpan(call)) {
252257
return
253258
}
254259
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -261,8 +266,8 @@ public open class SentryOkHttpEventListener(
261266
}
262267

263268
override fun requestFailed(call: Call, ioe: IOException) {
264-
originalEventListener?.requestFailed(call, ioe)
265-
if (!canCreateEventSpan()) {
269+
originalEventListenerMap[call]?.requestFailed(call, ioe)
270+
if (!canCreateEventSpan(call)) {
266271
return
267272
}
268273
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -282,17 +287,17 @@ public open class SentryOkHttpEventListener(
282287
}
283288

284289
override fun responseHeadersStart(call: Call) {
285-
originalEventListener?.responseHeadersStart(call)
286-
if (!canCreateEventSpan()) {
290+
originalEventListenerMap[call]?.responseHeadersStart(call)
291+
if (!canCreateEventSpan(call)) {
287292
return
288293
}
289294
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
290295
okHttpEvent.onEventStart(RESPONSE_HEADERS_EVENT)
291296
}
292297

293298
override fun responseHeadersEnd(call: Call, response: Response) {
294-
originalEventListener?.responseHeadersEnd(call, response)
295-
if (!canCreateEventSpan()) {
299+
originalEventListenerMap[call]?.responseHeadersEnd(call, response)
300+
if (!canCreateEventSpan(call)) {
296301
return
297302
}
298303
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -307,17 +312,17 @@ public open class SentryOkHttpEventListener(
307312
}
308313

309314
override fun responseBodyStart(call: Call) {
310-
originalEventListener?.responseBodyStart(call)
311-
if (!canCreateEventSpan()) {
315+
originalEventListenerMap[call]?.responseBodyStart(call)
316+
if (!canCreateEventSpan(call)) {
312317
return
313318
}
314319
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
315320
okHttpEvent.onEventStart(RESPONSE_BODY_EVENT)
316321
}
317322

318323
override fun responseBodyEnd(call: Call, byteCount: Long) {
319-
originalEventListener?.responseBodyEnd(call, byteCount)
320-
if (!canCreateEventSpan()) {
324+
originalEventListenerMap[call]?.responseBodyEnd(call, byteCount)
325+
if (!canCreateEventSpan(call)) {
321326
return
322327
}
323328
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -330,8 +335,8 @@ public open class SentryOkHttpEventListener(
330335
}
331336

332337
override fun responseFailed(call: Call, ioe: IOException) {
333-
originalEventListener?.responseFailed(call, ioe)
334-
if (!canCreateEventSpan()) {
338+
originalEventListenerMap[call]?.responseFailed(call, ioe)
339+
if (!canCreateEventSpan(call)) {
335340
return
336341
}
337342
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -351,14 +356,15 @@ public open class SentryOkHttpEventListener(
351356
}
352357

353358
override fun callEnd(call: Call) {
354-
originalEventListener?.callEnd(call)
359+
originalEventListenerMap.remove(call)?.callEnd(call)
355360
val okHttpEvent: SentryOkHttpEvent = eventMap.remove(call) ?: return
356361
okHttpEvent.finish()
357362
}
358363

359364
override fun callFailed(call: Call, ioe: IOException) {
365+
val originalEventListener = originalEventListenerMap.remove(call)
360366
originalEventListener?.callFailed(call, ioe)
361-
if (!canCreateEventSpan()) {
367+
if (!canCreateEventSpan(originalEventListener)) {
362368
return
363369
}
364370
val okHttpEvent: SentryOkHttpEvent = eventMap.remove(call) ?: return
@@ -370,26 +376,29 @@ public open class SentryOkHttpEventListener(
370376
}
371377

372378
override fun canceled(call: Call) {
373-
originalEventListener?.canceled(call)
379+
originalEventListenerMap[call]?.canceled(call)
374380
}
375381

376382
override fun satisfactionFailure(call: Call, response: Response) {
377-
originalEventListener?.satisfactionFailure(call, response)
383+
originalEventListenerMap[call]?.satisfactionFailure(call, response)
378384
}
379385

380386
override fun cacheHit(call: Call, response: Response) {
381-
originalEventListener?.cacheHit(call, response)
387+
originalEventListenerMap[call]?.cacheHit(call, response)
382388
}
383389

384390
override fun cacheMiss(call: Call) {
385-
originalEventListener?.cacheMiss(call)
391+
originalEventListenerMap[call]?.cacheMiss(call)
386392
}
387393

388394
override fun cacheConditionalHit(call: Call, cachedResponse: Response) {
389-
originalEventListener?.cacheConditionalHit(call, cachedResponse)
395+
originalEventListenerMap[call]?.cacheConditionalHit(call, cachedResponse)
390396
}
391397

392-
private fun canCreateEventSpan(): Boolean {
398+
private fun canCreateEventSpan(call: Call): Boolean =
399+
canCreateEventSpan(originalEventListenerMap[call])
400+
401+
private fun canCreateEventSpan(originalEventListener: EventListener?): Boolean {
393402
// If the wrapped EventListener is ours, we shouldn't create spans, as the originalEventListener
394403
// already did it
395404
// In case SentryOkHttpEventListener from sentry-android-okhttp is used, the is check won't work

0 commit comments

Comments
 (0)