feat: exposure dedupe call site

[abelonogov-ld]

Requirements

• I have added test coverage for new or changed functionality
• I have followed the repository's pull request submission guidelines

Related issues

Stacked on #REPLACE_WITH_DEDUPE_PR, the evaluation exposure deduplication PR. Review that one first; this changes what "the same exposure" means.

Describe the solution you've provided

A deduping hook was told about a flag once per window however many places in the application read it, so whichever place read it first stood for all of them: a flag read on a view redraw and again in a tap handler produced one report, and nothing distinguished which read it came from.

The variation methods now capture where they were called from, and that becomes part of the exposure:

public func boolVariation(forKey flagKey: LDFlagKey, defaultValue: Bool, file: String? = #fileID, line: UInt = #line) -> Bool

public struct EvaluationCallSite: Hashable {
    public let fileID: String
    public let line: UInt
}

The deduper holds a record per call site rather than per flag, so each place a flag is read from gets its own window and its own memory of the result it last reported. Repeats from one place are suppressed exactly as before; two places reading the same flag to the same result now report both.

The call site had to go in the record's identity rather than in the result compared against it. Were it part of the result, reading a flag alternately from two places would look like the result changing every time and nothing would ever be suppressed.

Prerequisite evaluations inherit the call site of the evaluation that caused them, since that is where the application read from.

Objective-C

ObjcLDClient passes file: nil, so evaluations made through it carry no call site. Left to the default, the captured location would be the wrapper's own line rather than anywhere in the caller's application, and every read made through that interface would look like the same handful of places. Objective-C has no way to supply its own, so those evaluations deduplicate per flag as they did before.

Compatibility

The new parameters have defaults, so existing Swift and Objective-C call sites compile and behave as they did, except for now being deduplicated per place rather than per flag. The one source break is taking an unapplied reference to a variation method, as in let evaluate = client.boolVariation, whose type gains the two parameters.

Describe alternatives you've considered

• A single callSite: EvaluationCallSite? = .here() parameter rather than file: and line:. Nicer to read, but #fileID and #line expand at the call site of the function whose default they are, and nesting them one level deeper inside here() does not carry that through to the application.
• Capturing #function as well. The file and line already identify a place uniquely, and the function name would only make the key larger.
• Making this opt-in, on the deduper or the hook. Every caller of a deduping hook wants to know where a flag is read from, and an option would have meant carrying both policies.

Additional context

Test coverage: two places reading one flag to one result reach the hook twice while repeats from each are suppressed; the key carries the file and line of the application's read rather than anywhere inside the SDK; and the deduper tracks a flag separately per call site, with an unattributed read forming its own record. The existing hook specs now evaluate through a helper, so their evaluations share one call site: written inline they sit on separate lines, and would no longer suppress one another.

The documentation snippets in sdk-meta and the prose in ld-docs-private need a follow-up saying that deduplication is per place rather than per flag; happy to open those once the shape here is agreed.

---

Note

Overview
Evaluation exposure deduplication is now per call site, so a flag read from a view and from a tap handler can both reach a wrapped hook while repeats from the same line stay folded within the window.

Swift variation and *VariationDetail methods gain optional file (#fileID) and line defaults. Those feed EvaluationCallSite and EvaluationSeriesContext.evaluationExposureKey, and EvaluationExposureDeduper keys state by environment, flag, and call site (not just flag). Prerequisite evaluations reuse the parent read’s call site. LDClient also records environmentName, fixes the hook list after plugin registration, and reads each flag once per evaluation so hooks see a consistent result.

ObjcLDClient passes file: nil, so Objective-C reads still dedupe as one bucket per flag with no caller location.

Existing call sites keep compiling via defaults; unapplied method references (e.g. client.boolVariation) pick up the new parameter types. LaunchDarkly analytics events are unchanged—dedupe still applies only to hook stages.

^{Reviewed by Cursor Bugbot for commit 5c569a7. Bugbot is set up for automated code reviews on this repo. Configure here.}

[cursor]

Cursor Bugbot has reviewed your changes using default effort and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, have a team admin enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 5c569a7. Configure here.}

[cursor]

Identify skips secondary plugin dedupers

Medium Severity

DedupingHook clears its dedupe state in beforeIdentify, but identify runs those hooks only on the client that received the call while updating every environment’s context. Config-level hooks are shared so they reset once; plugin getHooks builds a fresh DedupingHook per environment, so secondary instances never reset. After identify with the same context key, those hooks can keep suppressing exposures that should be reported again.

 

^{Reviewed by Cursor Bugbot for commit 5c569a7. Configure here.}