@@ -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