Skip to content

Commit 11786ec

Browse files
markushiclaude
andcommitted
refactor(okhttp): look up the wrapped EventListener once per callback
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1 parent 14f6b50 commit 11786ec

1 file changed

Lines changed: 63 additions & 45 deletions

File tree

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

Lines changed: 63 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -100,17 +100,19 @@ public open class SentryOkHttpEventListener(
100100
}
101101

102102
override fun proxySelectStart(call: Call, url: HttpUrl) {
103-
originalEventListenerMap[call]?.proxySelectStart(call, url)
104-
if (!canCreateEventSpan(call)) {
103+
val originalEventListener = originalEventListenerMap[call]
104+
originalEventListener?.proxySelectStart(call, url)
105+
if (!canCreateEventSpan(originalEventListener)) {
105106
return
106107
}
107108
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
108109
okHttpEvent.onEventStart(PROXY_SELECT_EVENT)
109110
}
110111

111112
override fun proxySelectEnd(call: Call, url: HttpUrl, proxies: List<Proxy>) {
112-
originalEventListenerMap[call]?.proxySelectEnd(call, url, proxies)
113-
if (!canCreateEventSpan(call)) {
113+
val originalEventListener = originalEventListenerMap[call]
114+
originalEventListener?.proxySelectEnd(call, url, proxies)
115+
if (!canCreateEventSpan(originalEventListener)) {
114116
return
115117
}
116118
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -122,17 +124,19 @@ public open class SentryOkHttpEventListener(
122124
}
123125

124126
override fun dnsStart(call: Call, domainName: String) {
125-
originalEventListenerMap[call]?.dnsStart(call, domainName)
126-
if (!canCreateEventSpan(call)) {
127+
val originalEventListener = originalEventListenerMap[call]
128+
originalEventListener?.dnsStart(call, domainName)
129+
if (!canCreateEventSpan(originalEventListener)) {
127130
return
128131
}
129132
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
130133
okHttpEvent.onEventStart(DNS_EVENT)
131134
}
132135

133136
override fun dnsEnd(call: Call, domainName: String, inetAddressList: List<InetAddress>) {
134-
originalEventListenerMap[call]?.dnsEnd(call, domainName, inetAddressList)
135-
if (!canCreateEventSpan(call)) {
137+
val originalEventListener = originalEventListenerMap[call]
138+
originalEventListener?.dnsEnd(call, domainName, inetAddressList)
139+
if (!canCreateEventSpan(originalEventListener)) {
136140
return
137141
}
138142
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -145,26 +149,29 @@ public open class SentryOkHttpEventListener(
145149
}
146150

147151
override fun connectStart(call: Call, inetSocketAddress: InetSocketAddress, proxy: Proxy) {
148-
originalEventListenerMap[call]?.connectStart(call, inetSocketAddress, proxy)
149-
if (!canCreateEventSpan(call)) {
152+
val originalEventListener = originalEventListenerMap[call]
153+
originalEventListener?.connectStart(call, inetSocketAddress, proxy)
154+
if (!canCreateEventSpan(originalEventListener)) {
150155
return
151156
}
152157
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
153158
okHttpEvent.onEventStart(CONNECT_EVENT)
154159
}
155160

156161
override fun secureConnectStart(call: Call) {
157-
originalEventListenerMap[call]?.secureConnectStart(call)
158-
if (!canCreateEventSpan(call)) {
162+
val originalEventListener = originalEventListenerMap[call]
163+
originalEventListener?.secureConnectStart(call)
164+
if (!canCreateEventSpan(originalEventListener)) {
159165
return
160166
}
161167
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
162168
okHttpEvent.onEventStart(SECURE_CONNECT_EVENT)
163169
}
164170

165171
override fun secureConnectEnd(call: Call, handshake: Handshake?) {
166-
originalEventListenerMap[call]?.secureConnectEnd(call, handshake)
167-
if (!canCreateEventSpan(call)) {
172+
val originalEventListener = originalEventListenerMap[call]
173+
originalEventListener?.secureConnectEnd(call, handshake)
174+
if (!canCreateEventSpan(originalEventListener)) {
168175
return
169176
}
170177
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -177,8 +184,9 @@ public open class SentryOkHttpEventListener(
177184
proxy: Proxy,
178185
protocol: Protocol?,
179186
) {
180-
originalEventListenerMap[call]?.connectEnd(call, inetSocketAddress, proxy, protocol)
181-
if (!canCreateEventSpan(call)) {
187+
val originalEventListener = originalEventListenerMap[call]
188+
originalEventListener?.connectEnd(call, inetSocketAddress, proxy, protocol)
189+
if (!canCreateEventSpan(originalEventListener)) {
182190
return
183191
}
184192
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -193,8 +201,9 @@ public open class SentryOkHttpEventListener(
193201
protocol: Protocol?,
194202
ioe: IOException,
195203
) {
196-
originalEventListenerMap[call]?.connectFailed(call, inetSocketAddress, proxy, protocol, ioe)
197-
if (!canCreateEventSpan(call)) {
204+
val originalEventListener = originalEventListenerMap[call]
205+
originalEventListener?.connectFailed(call, inetSocketAddress, proxy, protocol, ioe)
206+
if (!canCreateEventSpan(originalEventListener)) {
198207
return
199208
}
200209
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -207,53 +216,59 @@ public open class SentryOkHttpEventListener(
207216
}
208217

209218
override fun connectionAcquired(call: Call, connection: Connection) {
210-
originalEventListenerMap[call]?.connectionAcquired(call, connection)
211-
if (!canCreateEventSpan(call)) {
219+
val originalEventListener = originalEventListenerMap[call]
220+
originalEventListener?.connectionAcquired(call, connection)
221+
if (!canCreateEventSpan(originalEventListener)) {
212222
return
213223
}
214224
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
215225
okHttpEvent.onEventStart(CONNECTION_EVENT)
216226
}
217227

218228
override fun connectionReleased(call: Call, connection: Connection) {
219-
originalEventListenerMap[call]?.connectionReleased(call, connection)
220-
if (!canCreateEventSpan(call)) {
229+
val originalEventListener = originalEventListenerMap[call]
230+
originalEventListener?.connectionReleased(call, connection)
231+
if (!canCreateEventSpan(originalEventListener)) {
221232
return
222233
}
223234
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
224235
okHttpEvent.onEventFinish(CONNECTION_EVENT)
225236
}
226237

227238
override fun requestHeadersStart(call: Call) {
228-
originalEventListenerMap[call]?.requestHeadersStart(call)
229-
if (!canCreateEventSpan(call)) {
239+
val originalEventListener = originalEventListenerMap[call]
240+
originalEventListener?.requestHeadersStart(call)
241+
if (!canCreateEventSpan(originalEventListener)) {
230242
return
231243
}
232244
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
233245
okHttpEvent.onEventStart(REQUEST_HEADERS_EVENT)
234246
}
235247

236248
override fun requestHeadersEnd(call: Call, request: Request) {
237-
originalEventListenerMap[call]?.requestHeadersEnd(call, request)
238-
if (!canCreateEventSpan(call)) {
249+
val originalEventListener = originalEventListenerMap[call]
250+
originalEventListener?.requestHeadersEnd(call, request)
251+
if (!canCreateEventSpan(originalEventListener)) {
239252
return
240253
}
241254
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
242255
okHttpEvent.onEventFinish(REQUEST_HEADERS_EVENT)
243256
}
244257

245258
override fun requestBodyStart(call: Call) {
246-
originalEventListenerMap[call]?.requestBodyStart(call)
247-
if (!canCreateEventSpan(call)) {
259+
val originalEventListener = originalEventListenerMap[call]
260+
originalEventListener?.requestBodyStart(call)
261+
if (!canCreateEventSpan(originalEventListener)) {
248262
return
249263
}
250264
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
251265
okHttpEvent.onEventStart(REQUEST_BODY_EVENT)
252266
}
253267

254268
override fun requestBodyEnd(call: Call, byteCount: Long) {
255-
originalEventListenerMap[call]?.requestBodyEnd(call, byteCount)
256-
if (!canCreateEventSpan(call)) {
269+
val originalEventListener = originalEventListenerMap[call]
270+
originalEventListener?.requestBodyEnd(call, byteCount)
271+
if (!canCreateEventSpan(originalEventListener)) {
257272
return
258273
}
259274
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -266,8 +281,9 @@ public open class SentryOkHttpEventListener(
266281
}
267282

268283
override fun requestFailed(call: Call, ioe: IOException) {
269-
originalEventListenerMap[call]?.requestFailed(call, ioe)
270-
if (!canCreateEventSpan(call)) {
284+
val originalEventListener = originalEventListenerMap[call]
285+
originalEventListener?.requestFailed(call, ioe)
286+
if (!canCreateEventSpan(originalEventListener)) {
271287
return
272288
}
273289
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -287,17 +303,19 @@ public open class SentryOkHttpEventListener(
287303
}
288304

289305
override fun responseHeadersStart(call: Call) {
290-
originalEventListenerMap[call]?.responseHeadersStart(call)
291-
if (!canCreateEventSpan(call)) {
306+
val originalEventListener = originalEventListenerMap[call]
307+
originalEventListener?.responseHeadersStart(call)
308+
if (!canCreateEventSpan(originalEventListener)) {
292309
return
293310
}
294311
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
295312
okHttpEvent.onEventStart(RESPONSE_HEADERS_EVENT)
296313
}
297314

298315
override fun responseHeadersEnd(call: Call, response: Response) {
299-
originalEventListenerMap[call]?.responseHeadersEnd(call, response)
300-
if (!canCreateEventSpan(call)) {
316+
val originalEventListener = originalEventListenerMap[call]
317+
originalEventListener?.responseHeadersEnd(call, response)
318+
if (!canCreateEventSpan(originalEventListener)) {
301319
return
302320
}
303321
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -312,17 +330,19 @@ public open class SentryOkHttpEventListener(
312330
}
313331

314332
override fun responseBodyStart(call: Call) {
315-
originalEventListenerMap[call]?.responseBodyStart(call)
316-
if (!canCreateEventSpan(call)) {
333+
val originalEventListener = originalEventListenerMap[call]
334+
originalEventListener?.responseBodyStart(call)
335+
if (!canCreateEventSpan(originalEventListener)) {
317336
return
318337
}
319338
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
320339
okHttpEvent.onEventStart(RESPONSE_BODY_EVENT)
321340
}
322341

323342
override fun responseBodyEnd(call: Call, byteCount: Long) {
324-
originalEventListenerMap[call]?.responseBodyEnd(call, byteCount)
325-
if (!canCreateEventSpan(call)) {
343+
val originalEventListener = originalEventListenerMap[call]
344+
originalEventListener?.responseBodyEnd(call, byteCount)
345+
if (!canCreateEventSpan(originalEventListener)) {
326346
return
327347
}
328348
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -335,8 +355,9 @@ public open class SentryOkHttpEventListener(
335355
}
336356

337357
override fun responseFailed(call: Call, ioe: IOException) {
338-
originalEventListenerMap[call]?.responseFailed(call, ioe)
339-
if (!canCreateEventSpan(call)) {
358+
val originalEventListener = originalEventListenerMap[call]
359+
originalEventListener?.responseFailed(call, ioe)
360+
if (!canCreateEventSpan(originalEventListener)) {
340361
return
341362
}
342363
val okHttpEvent: SentryOkHttpEvent = eventMap[call] ?: return
@@ -395,9 +416,6 @@ public open class SentryOkHttpEventListener(
395416
originalEventListenerMap[call]?.cacheConditionalHit(call, cachedResponse)
396417
}
397418

398-
private fun canCreateEventSpan(call: Call): Boolean =
399-
canCreateEventSpan(originalEventListenerMap[call])
400-
401419
private fun canCreateEventSpan(originalEventListener: EventListener?): Boolean {
402420
// If the wrapped EventListener is ours, we shouldn't create spans, as the originalEventListener
403421
// already did it

0 commit comments

Comments
 (0)