receivedResponse Doesn't Seem to Have Data

[agarrharr]

In URLSessionInstrumentationConfiguration() there is a parameter called receivedResponse that takes response, data, and span. It seems like, in my testing, that I don't receive any data when the response includes json data. Am I holding it wrong? Or is the library filtering out some of the responses?

 let networkInstrumentation = URLSessionInstrumentation(
    configuration: URLSessionInstrumentationConfiguration(
        shouldInstrument: { request in
            true
        },
        receivedResponse: { response, dataOrFile, span in
            if let data = dataOrFile as? Data {
                print("Data: ", String(data: data, encoding: .utf8) ?? "binary data")
            } else {
                print("dataOrFile is not data")
            }
        }
    )
)

[agarrharr]

To add more context, I wanted to access the response body to add extra attributes.

[tomerhy]

@agarrharr here a sample code how I use it.

  let configuration = URLSessionInstrumentationConfiguration(
            spanCustomization: self.spanCustomization,
            shouldInjectTracingHeaders: { [weak self] request in
                return self?.shouldAddTraceParent(to: request, options: options) ?? false
            },
            receivedResponse: self.receivedResponse
        )

    private func receivedResponse(response: URLResponse, data: DataOrFile?, span: any Span) {
        if let httpResponse = response as? HTTPURLResponse {
            let statusCode = httpResponse.statusCode
            let logSeverity = statusCode > 400 ?  CoralogixLogSeverity.error : CoralogixLogSeverity.info
            span.setAttribute(key: Keys.severity.rawValue, value: AttributeValue.int(logSeverity.rawValue))
        }
     }

[agarrharr]

Thanks @tomerhy. It looks like you are getting the httpResponse.statusCode, but not the response body, which is what I'm trying to do.

[nachoBonafonte]

Hi @agarrharr, is it happening with an asynchronous task, if so, could you try setting your own delegate?

[agarrharr]

@nachoBonafonte, I'm not sure what you mean. I don't think it's with an asynchronous task. I just call this function when my app starts:

func setupOpenTelemetry(with config: OpenTelemetryConfig) {
    let resource = DefaultResources().get().merging(other: Resource(attributes: [
        "service.name": AttributeValue.string(config.serviceName),
        "service.version": AttributeValue.string(config.serviceVersion),
    ]))

    let otlpConfiguration = OtlpConfiguration(timeout: TimeInterval(10))
    let otlpTraceExporter = OtlpHttpTraceExporter(
        endpoint: config.endpoint,
        config: otlpConfiguration
    )

    let stdoutExporter = StdoutSpanExporter(isDebug: true)
    let multiExporter = MultiSpanExporter(
        spanExporters: config.debugOutput ? [otlpTraceExporter, stdoutExporter] : [otlpTraceExporter]
    )
    let spanProcessor = SimpleSpanProcessor(spanExporter: multiExporter)
    
    let sampler = Samplers.traceIdRatio(ratio: config.samplingRatio)
    
    OpenTelemetry.registerTracerProvider(
        tracerProvider: TracerProviderBuilder()
            .add(spanProcessor: spanProcessor)
            .with(resource: resource)
            .with(sampler: sampler)
            .build()
    )

    _ = URLSessionInstrumentation(
        configuration: URLSessionInstrumentationConfiguration(
            shouldInstrument: { request in
                guard let url = request.url, let host = url.host else {
                    return false
                }

                if host == "myOtelCollector.com" || config.ignoredHosts.contains(host) {
                    return false
                }

                return true
            },
            nameSpan: nameSpan(from:)
        )
    )
    
    if config.debugOutput {
        print("OpenTelemetry configured successfully")
    }
}

[nachoBonafonte]

I am referring to the network calls that get instrumented, are they called asynchronously (using await) ?

[agarrharr]

Oh! Yes, they are... like this:

let (data, urlResponse) = try await URLSession.shared.data(for: request)

[nachoBonafonte]

Then yes, that is a current limitation of the instrumentation library with asynchronous network requests that don't have a delegate, it will only return the data for network requests called synchronously.

The reason is that in order to instrument asynchronous network requests we need to add a custom delegate in order to capture the network calls (as other synchronous methods are not being called and only some delegate methods are). We assign it and instance of AsyncTaskDelegate that is implemented in

opentelemetry-swift/Sources/Instrumentation/URLSession/URLSessionInstrumentation.swift

Line 844 in 59ef505

class AsyncTaskDelegate: NSObject, URLSessionTaskDelegate {

As you can see we call logResponse method with a nil parameter in the dataOrFile parameter that is sent later to the callback you are using, because we don't have access to the data in it. We should investigate again if it is possible to access to the data somehow or in other delegate methods and add its content here.

Your best option right now if you want to get the data in the callback is using the non async version of the network calls.