Support sendable in OTSpan

[muukii]

The thing

in some cases, potentially moving between threads(actors)

[ganeshnj]

Thanks for opening the issue @muukii

We have not looked into supporting Swift concurrency features but this is interesting use case. Conforming OTSpan to Sendable will not be trivial because of DDSpan which opens up all other types. Hence, we have to figure out a strategy for conformation.

Let me discuss with the team and will get back to you.

[muukii]

Okay, thanks for replying.

In Swift6, swift-concurrency will be enhanced, and errors when it comes to using UNSAFE multi-threading programming.
It boils down to supporting swift-concurrency attributes such as Sendable to prevent errors.
I probably help this project.

[ganeshnj]

We discussed this internally and created a backlog item for prioritization. The use case mentioned makes sense where we want SDK's public types to be thread safe even if the SDK doesn't use any Swift concurrency features.

Keep an eye on this issue for further updates.

[jaredsinclair]

@ganeshnj Do ya'll have a target date by which you plan to be ready for Swift 6 and strict concurrency?

[ganeshnj]

We have bumped the priority of the backlog item to highest. Unfortunately, we don't have date to share as it would require some significant changes how we handle things.

We will keep the issue updated.

[markusfassbender-lb]

Any updates on this issue?

In the mean time I use this workaround:

/// The box helps to access the span from different context.
/// It's temporary solution and should be deleted when Datadog fully supports concurrency and Sendable types: https://github.com/DataDog/dd-sdk-ios/issues/1440
private final class SpanBox: @unchecked Sendable {
    private let lock = NSLock()
    private let span: any OTSpan

    init(_ span: any OTSpan) {
        self.span = span
    }

    func setError(
        _ error: any Error,
        file: StaticString = #fileID,
        line: UInt = #line
    ) {
        lock.lock()
        defer { lock.unlock() }

        span.setError(
            error,
            file: file,
            line: line
        )
    }

    func finish() {
        lock.lock()
        defer { lock.unlock() }

        span.finish()
    }
}

[mariedm]

Hi everyone 👋 We can't provide any ETA at the moment, but we have been discussing Swift 6 strict concurrency internally.