Baggage items not propagated to span's descendants

[philtre]

The problem

As I was testing out various Datadog features, I noticed that baggage items set in a span are not propagated to its descendants.

It seems that the OTSpan.baggageItem(withKey:) only returns the baggage item if it was set directly on the span, and does not query the span's parent.

This is also evident from the implementation of DDSpan and BaggageItems:

internal class DDSpan: OTSpan {
    //...
    func baggageItem(withKey key: String) -> String? {
        if warnIfFinished("baggageItem(withKey:)") {
            return nil
        }
        return ddContext.baggageItems.get(key: key)
    }
    //...
}

internal class BaggageItems {
    //...
    /// Baggage items of the parent `DDSpan` or`nil` for items of the root span.
    private let parent: BaggageItems?

    /// Unsynchronized baggage items dictionary. Use `queue` to synchronize the access.
    private var unsafeItems: [String: String] = [:]
	//...
    func get(key: String) -> String? {
        queue.sync { self.unsafeItems[key] }
    }
    //...
    /// Returns all baggage items for the span, including its parent items.
    /// This property is unsafe and should be accessed using `queue`.
    private var unsafeAll: [String: String] {
        let parentItems = parent?.unsafeAll ?? [:]
        let selfItems = unsafeItems

        let allItems = parentItems.merging(selfItems) { _, selfItem -> String in
            return selfItem
        }

        return allItems
    }
}

The only way to access the parent span's baggage items is to iterate through all of then in DDSpanContext:

internal class DDSpanContext: OTSpanContext {
    //...
    func forEachBaggageItem(callback: (String, String) -> Bool) {
        for (itemKey, itemValue) in baggageItems.all {
            if callback(itemKey, itemValue) {
                break
            }
        }
    }
    //...
}

The documentation for OTSpan.baggageItem(forKey:) does not specify whether this is expected behavior.

Suggestions

If this is expected behavior, adding a note in the OTSpan.baggageItem(forKey:) would be very useful.

If OTSpan.baggageItem(forKey:) is expected to return ancestor baggage items, then BaggaggeItems could be modified in the following way:

internal class BaggageItems {
    //...
    func get(key: String) -> String? {
        queue.sync { self.unsafeItems[key] } ?? parent?.get(key: key)
    }
    //...

[buranmert]

hi again @philtre 👋
thanks for the issue with a great explanation and even solution 🙏 much appreciated!

we made a fix and it will be in the next release 🚀