Skip to content

Add identity providers for ID5, LiveIntent, LiveRamp, ConnectID and UID2 - #1488

Open
dhruv8sh wants to merge 89 commits into
feat/s2s-eid-collection-corefrom
feat/s2s-eid-vendors
Open

dhruv8sh wants to merge 89 commits into
feat/s2s-eid-collection-corefrom
feat/s2s-eid-vendors

Conversation

@dhruv8sh

@dhruv8sh dhruv8sh commented Nov 2, 2026 •

Copy link
Copy Markdown
Collaborator

Stacked on #1487.

Summary

  • Adds server-side identity providers for ID5, LiveIntent, LiveRamp, Yahoo ConnectID, UID2, Prebid SharedID, Criteo and Unified ID (TDID). Each one plugs into the S2S EID collection framework from Collect server-side identity provider EIDs in a single page-load write #1487.
  • Adds a Lockr cookie capability, so a provider can take its ID from a Lockr-managed first-party cookie.
  • Adds the framework hooks the providers need. They could move into Collect server-side identity provider EIDs in a single page-load write #1487 if reviewers prefer:
    • providers can read their own first-party cookies, including every duplicate of a cookie name for opt-out checks
    • provider builds get the configured provider ID
    • lookups can read cookies and build an EID ext
    • providers can name sources they exclude where GDPR applies
    • a failed lookup logs its HTTP status

Per vendor

Provider Source Lockr capability
ID5 ID5 first-party cookie (including encoded cookies), else the /gs/v2 fetch API with an RFC 3339 ts and gpp_sid as an array; carries linkType and keeps ext; a universal_uid of 0 is an opt-out Yes
LiveIntent Lookup API that sends the LiveIntent first-party cookie; partner IDs are marked; needs a did- distributor ID; segments only when non-empty No
LiveRamp First-party envelope cookie (_lr_env, or the bare envelope Prebid stores in idl_env); with an endpoint, placement_id and custom_id_namespace, a visitor without a cookie is looked up server side by Custom ID Yes
ConnectID Yahoo's connectId first-party cookie; no server call No
UID2 First-party token cookie; with an endpoint, the token is refreshed server side before it expires Yes
SharedID Prebid _sharedid / _pubcid cookie as an atype 1 EID; honours _pubcid_optout; with generate = true (default off), generates a UUID stored only in the row No
Criteo cto_bidid cookie, stored verbatim as the atype 1 EID Prebid sends No
Unified ID TDID from the pbjs-unifiedid cookie, with rtiPartner ext and adserver.org inserter/matcher, mm 4 No

Consent and cookie handling

  • UID2 is excluded where GDPR applies, based on the visitor's detected jurisdiction. UID2 is not looked up there, UID2 IDs LiveIntent resolves are dropped, and UID2 IDs already stored in the row are removed.
  • A vendor cookie fills only the sources it covers; the provider's other due sources are still looked up, and the two results are merged.
  • The lookup rate limit is checked only once a request is built, so cookie-only providers use no budget.
  • Cookie readers try each value in turn, skipping empty values and IDs that have already expired; opt-out checks look at every duplicate of a cookie.
  • Cookie-supplied expiry is bounded, and vendor cookie opt-outs remove stored IDs.

Known limitations

  • ConnectID and SharedID opt-outs kept in localStorage are invisible to the server. A leftover connectId cookie is still read until it expires, and SharedID generation should be enabled only where the opt-out lives in the _pubcid_optout cookie.
  • LiveRamp server-side lookup needs Custom ID enabled on the placement and the publisher's namespace; it has not been tested against LiveRamp yet.
  • Logged-in and hashed-email inputs are not used by any provider.
  • Capturing Lockr responses is not supported.

The plans list the remaining unported reference behaviours.

Changes

Area Change
crates/trusted-server-identity-providers/src/{id5,liveintent,liveramp,connectid,uid2,sharedid,criteo,unifiedid}.rs Provider implementations and tests
crates/trusted-server-identity-providers/src/common.rs Shared helpers: cookie name lists, Lockr cookie capability, parsing
crates/trusted-server-core/src/ec/provider.rs, ec/coordinator/ Framework hooks for own-cookie reading, provider ID, EID ext, cookies in lookups, GDPR source exclusion, cookie/lookup merging, and HTTP status logging
crates/trusted-server-core/src/settings.rs, adapter-fastly/src/app.rs Passes the provider ID and registers providers
trusted-server.example.toml Example provider config, using example.com hosts except LiveIntent's fixed attribute sources
docs/guide/configuration.md, docs/guide/api-reference.md Provider configuration docs
docs/superpowers/plans/2026-11-02-identity-provider-*.md One plan per provider plus the Lockr capability

Closes

Part of #1246 and #1245. No issue is closed yet.

Spec

The spec is in #1487. This PR adds only plans, no new spec.

Test plan

  • cargo test-fastly && cargo test-fastly-reuse && cargo test-axum && cargo test-cloudflare && cargo test-spin
  • All 8 clippy aliases
  • cargo fmt --all -- --check
  • Parity tests, plus the template_build_digest test and its clippy run
  • scripts/lint-wasm-clock.sh
  • JS vitest, format and lint
  • Docs and markdown prettier
  • ./scripts/test-cli.sh, the node pin guard, docs-proposal scripts, and ts dev lint domains against the base branch
  • Local run against ID5's public test partner: the /gs/v2 fetch returned an ID that was stored in KV and attached to the auction
  • Local run reading a real LiveRamp envelope cookie into KV
  • LiveRamp server-side Custom ID lookup against LiveRamp (pending placement setup)
  • UID2 refresh against the UID2 service

Checklist

  • Changes follow AGENTS.md conventions
  • No unwrap() in production code
  • Uses log macros
  • New code has tests
  • No secrets or credentials committed

Closes #1567

@jwrosewell

Copy link
Copy Markdown
Collaborator

@dhruv8sh, the same point as on #1487. Directionally, eight identity vendors as files in one shared crate is not compatible with V2 (the 55 pull requests tracked in #777, merged in order), where each vendor is a module in a folder of its own at identity/<vendor> with its own named maintainer, so each provider owns and maintains its module.

The V2 spec is identifier-modules, with the folder layout in integrations-crate, both in #1342. The associated pull request is #1382 (a module hands core its identifiers, starting with the Prebid EID cookie).

Could you evaluate the V2 spec and #1382 before progressing this pull request?

@ChristianPavilonis ChristianPavilonis left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Summary

Adds eight vendor identity providers and the coordinator hooks they need. Two opt-out handling defects and two UID2 refresh-lifecycle defects need correction before merging.

One inline comment carries a one-click GitHub suggestion. Use Commit suggestion or Add suggestion to batch to apply it. The other fixes need manual changes across files or outside the diff.

Blocking

🔧 wrench

  • UID2 SDK opt-outs leave cached tokens active — see inline at crates/trusted-server-identity-providers/src/uid2.rs:347–349 (suggestion).
  • LiveRamp's 204 opt-out never reaches its parser — see inline at crates/trusted-server-identity-providers/src/liveramp.rs:265–267.
  • Overdue UID2 refresh credentials are permanently discarded — see the body-level finding below.
  • A stale cookie rolls back a refreshed UID2 token — see inline at crates/trusted-server-core/src/ec/coordinator/mod.rs:602–610.

Cross-cutting / body-level findings

🔧 wrench — Overdue UID2 refresh credentials are permanently discarded

References: crates/trusted-server-identity-providers/src/uid2.rs:173–176 and crates/trusted-server-core/src/ec/coordinator/validate.rs:151–155.

Two focused reproductions expose the same underlying problem:

  • Importing a still-live identity after refresh_from drops its refresh credentials, so subsequent navigations cannot refresh it.
  • If a refresh times out while the cookie repeats the stored token, validation drops the cookie's already-due refresh state. The cookie result survives the failed lookup and replaces the stored record without refresh credentials; future attempts stop.

Due refresh state must remain usable rather than becoming invalid merely because its scheduled time passed. The proposed validation change is:

        Some(from) if usable => Ok(stored.with_refresh(KvRefresh {
            state: refresh.state.into_owned(),
            from,
        })),

Apply manually — the actual guard is outside a diff hunk; its documentation and existing test expectations also need updating. Retain the existing state-size checks and use the configured lookup rate limit to control retries. If the future-only policy is retained for lookup replies, distinguish cookie ingress instead of discarding its already-due credentials.

Verification

  • Existing provider unit tests: 91 PASS locally.
  • Five focused scratch reproductions confirmed the four findings on the reviewed head. The SDK opt-out regression passes with the suggestion applied in isolation.
  • Exact suggestion bytes pass cargo fmt --all -- --check, all eight clippy aliases, cargo check-fastly, cargo check-axum, cargo check-cloudflare, all four adapter test aliases, cargo test-fastly-reuse, and the cross-adapter parity suite.
  • The initial local Fastly attempt used Viceroy 0.17 and failed on an unsupported host import; rerunning with the repository-pinned Viceroy 0.21.0 passed.
  • Byte-exact post-verification patch comparison: PASS. Scratch changes were discarded; the reviewer worktree is clean at the reviewed head.

Coverage: provider/coordinator implementations were read fully; large supporting files were reviewed through diffs and relevant context rather than exhaustively end-to-end. No live vendor service testing was performed. The prose fix sketches were not applied.

CI Status

No required checks were reported for this branch.

@aram356 aram356 left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Summary

This adds eight vendor identity providers and the coordinator hooks they need. Four things block it. The coordinator's cookie path rewrites unchanged IDs while another source is due, which also loses refresh state. Criteo's ID differs from what Prebid sends. LiveRamp's server lookup cannot parse the v2 reply. And ID5's gpp_sid type needs an answer. This round does not repeat the four findings of the earlier review at this head; where a finding here extends one of them, the comment says so.

4 of the inline comments below carry a one-click GitHub suggestion. Use Commit suggestion, or Add suggestion to batch for several at once. The other comments describe the fix in prose, because it touches several files or lines outside the diff.

Blocking

🔧 wrench

  • Cookie IDs that repeat the held UIDs are rewritten while another source is due (a KV write on every navigation, and refresh state lost after a failed refresh): see inline at crates/trusted-server-core/src/ec/coordinator/mod.rs:599-612
  • The Criteo bid ID is stored percent-encoded, but Prebid sends it decoded: see inline at crates/trusted-server-identity-providers/src/criteo.rs:92-102
  • The LiveRamp Custom ID lookup cannot parse a v2 envelope reply (also atype and gpp_sid): see inline at crates/trusted-server-identity-providers/src/liveramp.rs:272-273

❓ question

  • Does /gs/v2 take gpp_sid as an array?: see inline at crates/trusted-server-identity-providers/src/id5.rs:182-183

Non-blocking

♻️ refactor

  • The Lockr capability reads nothing with its defaults: see inline at crates/trusted-server-identity-providers/src/common.rs:284-287
  • Say which client settings put the token in a cookie (UID2 and ID5; suggestion): see inline at trusted-server.example.toml:243-247
  • Send IPv6 addresses as ipv6 (ID5): see inline at crates/trusted-server-identity-providers/src/id5.rs:360-364
  • Match Prebid's ConnectID validity rules: see inline at crates/trusted-server-identity-providers/src/connectid.rs:108-118
  • Prebid sends the resolved Trade Desk ID as atype 1 (suggestion): see inline at crates/trusted-server-identity-providers/src/liveintent.rs:355-372
  • Compare more than the UID strings: see inline at crates/trusted-server-core/src/ec/coordinator/mod.rs:832-854
  • Providers now read the clock: see inline at crates/trusted-server-identity-providers/src/common.rs:337-339
  • Plans and docs that contradict the code: see the body-level finding below

🤔 thinking

  • Cookie and consent-derived opt-outs now get the 30-day lockout: see inline at crates/trusted-server-core/src/ec/coordinator/mod.rs:560-565
  • A placeholder ID reads as "no ID", not as an opt-out: see inline at crates/trusted-server-identity-providers/src/common.rs:153-159
  • Structure of this PR: see the body-level finding below

⛏ nitpick

  • exclude_sources keeps the pre-exclusion kept count (suggestion): see inline at crates/trusted-server-core/src/ec/coordinator/mod.rs:770-772
  • Where GDPR applies, UID2 is skipped for region, not consent (suggestion): see inline at crates/trusted-server-identity-providers/src/uid2.rs:34-35

🌱 seedling

  • A generated SharedID changes every 30 days: see inline at crates/trusted-server-identity-providers/src/sharedid.rs:131-142
  • Smaller gaps: see the body-level finding below

Cross-cutting / body-level findings

♻️ Plans and docs that contradict the code

The plans say "Status: Implemented", but several statements no longer match the code:

  • 2026-11-02-identity-provider-uid2.md, "Stored ID": the token "is refreshed only when the cookies no longer yield a usable token". Since 25f35720b, it is also refreshed while the cookie repeats it.
  • 2026-11-02-identity-provider-uid2.md, risk note: "a server refresh spends the SDK cookie's refresh token ... the browser SDK's own refresh of that identity may then fail". A refresh token is not spent. The operator's UIDOperatorService.refreshIdentity has no replay check, and the UID2 token docs say "Refreshing a UID2 token does not invalidate/expire the original or previous UID2 token". The server refresh and the SDK refresh both succeed and fork into two token chains. Combined with the stale-cookie rollback from the earlier review, that can repeat the refresh about every other navigation until the cookie's identity_expires, bounded only by rate_limit_per_hour (inferred).
  • 2026-11-02-identity-provider-liveramp.md: the goal and architecture still say "no server call" and "build_request always fails", and "Stored ID" documents 200 {"envelope"} (see the LiveRamp comment).
  • 2026-11-02-identity-provider-id5.md: an opted-out universal_uid of 0 "is reported as LookupOutcome::NoMatch". The code reports OptedOut.
  • 2026-11-02-identity-provider-connectid.md: "The provider reads no clock". is_expired reads it.
  • 2026-11-02-identity-provider-liveintent.md: "The Expires header becomes ProviderExpiry::At". The code produces After(Expires - Date).
  • 2026-11-02-identity-provider-criteo.md, criteo.rs:4-6 and the example config: "still percent-encoded" (see the Criteo comment).
  • docs/guide/configuration.md:836: allowed_domains is marked required, but cookie-only kinds without an endpoint do not need it, and the field has #[serde(default)].

🤔 Structure of this PR

jwrosewell's question on this PR about the V2 layout (one module per vendor under identity/<vendor>, each with its own maintainer; #1342 and #1382) is still unanswered. Independent of that answer, this PR combines framework changes with eight vendors in 7.2k lines. The description offers to move the framework hooks into #1487. Doing that, and landing the vendors as separate PRs, would let each vendor's fidelity be reviewed and verified against its own service on its own.

🌱 Smaller gaps

  • validate.rs:171 clamps absolute expiries to 30 days but leaves ProviderExpiry::After unbounded in core. Every provider here bounds it itself, so this is defense in depth.
  • The adapter's joining of multiple Cookie headers into RequestCookies (crates/trusted-server-adapter-fastly/src/app.rs:433-439) has no test, and the adapter tests pass RequestCookies::default().
  • id5.rs defines the same "0" twice, as OPTED_OUT_UID (line 71) and OPT_OUT_UID (line 415).

Verification

  • Every changed file was read at 25f35720b. Vendor behaviour was checked against Prebid.js master modules, LiveRamp's ATS Envelope API docs, ID5's Prebid Server Java module, uid2-web-integrations and uid2-operator. No live vendor calls were made.
  • The coordinator findings were reproduced with probe tests that run dispatch, collect and plan_write. The fix proposed at mod.rs:599-612 makes both blocking probes pass, and all existing ec:: tests and the 91 provider tests still pass (native run). The Criteo and ID5 ipv6 prose fixes were compiled and tested in a scratch tree; the other prose sketches were not applied.
  • Each suggestion was applied on its own at this head, and its patch was byte-identical before and after the checks:
    • liveintent.rs (TDID atype): cargo fmt --check, clippy-fastly, check-fastly, check-axum, check-cloudflare, test-fastly.
    • coordinator/mod.rs (kept count): cargo fmt --check, clippy-fastly, clippy-axum, clippy-cloudflare, clippy-cloudflare-wasm, clippy-spin-native, clippy-spin-wasm, clippy-cli, the three check-* aliases, test-fastly, test-fastly-reuse, test-axum, test-cloudflare, test-spin, and the parity suite.
    • uid2.rs (module doc): cargo fmt --check, clippy-fastly.
    • trusted-server.example.toml: every added line is a comment.
    • All four together: cargo fmt --check, clippy-fastly, native core and provider tests.

CI Status

  • CI Node pin guard: PASS
  • CLAUDE.md symlink guard: PASS
  • HTML EOF runtime (Fastly): PASS
  • browser integration tests: PASS
  • cargo check (cloudflare native + wasm32-unknown-unknown): PASS
  • cargo check/build/test (spin native + wasm32-wasip1): PASS
  • cargo fmt: PASS
  • cargo test: PASS
  • cargo test (axum native): PASS
  • cargo test (cross-adapter parity): PASS
  • cargo test (ts CLI, native) (macos-latest): PASS
  • cargo test (ts CLI, native) (ubuntu-latest): PASS
  • docs-proposal scripts: PASS
  • format-docs: PASS
  • format-typescript: PASS
  • integration tests: PASS
  • integration tests (Fastly EC lifecycle): PASS
  • prepare integration artifacts: PASS
  • trace runtime and browser acceptance: PASS
  • ts dev lint domains (changed lines): PASS
  • vitest: PASS
  • worker-deadlines (cloudflare): PASS
  • worker-deadlines (spin): PASS

No required checks are configured for this base branch.

Comment on lines +284 to +287
reader.lockr = names
.into_iter()
.filter(|name| !reader.own.contains(name))
.collect();

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

♻️ refactor: The Lockr capability reads nothing with its defaults

with_lockr drops Lockr names that are already in own, and every Lockr default equals that kind's own default: id5id for ID5, _lr_env for LiveRamp (own default ["_lr_env", "idl_env"]) and __uid2_advertising_token for UID2. So [settings.lockr] enabled = true with the defaults reads no extra cookie. Neither do the three Lockr tables in trusted-server.example.toml, which repeat the own names. An operator who turns Lockr on sees no change.

With custom names, [settings.lockr].cookie_names behaves exactly like appending those names to cookie_names: same parser, same order, read before any lookup. The only difference is a debug log line. That is a trait, a settings type, reads_lockr, gating tests, a plan and docs, with no behaviour beyond cookie_names.

Suggest removing the capability and documenting "add the Lockr key to cookie_names" until there is Lockr-specific behaviour, for example provenance through inserter, or the revoke-consent opt-out the Lockr plan lists as not ported. If it stays, the example tables should use a key that differs from the own cookies, and the docs should say the default Lockr keys are already read as own cookies.

@dhruv8sh dhruv8sh Nov 12, 2026 •

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The capability stays, and f68083c changes it:

  • The example tables now use Lockr keys that differ from the vendors' own cookies. The docs say the default Lockr keys are already read as own cookies, so enabling the capability with the defaults reads nothing extra.
  • Lockr-specific behaviour: Lockr cookies are not read where GDPR applies. Prebid's lockrAIMIdSystem stops when gdprApplies is true, so a Lockr cookie on such a request is a leftover, not a current delivery. Own cookies are still read there.

inserter provenance and revoke-consent are not ported. Lockr's storage holds neither: per the Prebid module, it stores the raw advertising_token under the configured key_name, and its own keys are localStorage only. Both exist only in Lockr API responses, which the framework does not capture. The plan records this.

@prk-Jr prk-Jr left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Summary

This round covers areas the two earlier reviews at this head did not reach: the auction read path, untrusted response handling in the providers, and the CLI's provider validation. It found two new blocking problems. UID2 IDs that the GDPR exclusion removes can still reach bidders. A large LiveIntent segments list drops LiveIntent's own ID. The earlier findings are not repeated here.

Blocking

🔧 wrench

  • UIDs the GDPR exclusion removes are still sent to bidders: see inline at crates/trusted-server-core/src/ec/coordinator/mod.rs:361
  • A large LiveIntent segments list drops nonId: see inline at crates/trusted-server-identity-providers/src/liveintent.rs:337-346

Non-blocking

🤔 thinking

  • ID5 never sends back the previous signature: see inline at crates/trusted-server-identity-providers/src/id5.rs:21

⛏ nitpick

  • ID5 percent-decodes the fetch reply before the opt-out check: see inline at crates/trusted-server-identity-providers/src/id5.rs:390
  • RequestCookies Debug prints the whole Cookie header: see inline at crates/trusted-server-core/src/ec/provider.rs:168

Verification

  • The findings were reproduced with probe tests in a scratch tree at 25f35720b: an auction-read probe for the GDPR finding, plus probes for the LiveIntent ext size and the ID5 reply decoding. The ID5 signature point is not checked against ID5's docs or a live call.
  • cargo test -p trusted-server-core --lib ec:: (native): 523 passed.
  • Checked and found sound: CheckedAppConfig (no provider reads secrets at build, so validating before secrets resolve is safe); checking the rate limit only once a request is built; cookie and lookup merging; an unknown jurisdiction failing closed; endpoint: None (every request is still checked against allowed_domains); UID2 refresh decryption and its panic paths; response size caps; and identifiers going only to the configured endpoint.
  • No live vendor calls were made. The fixes are prose sketches and were not applied.

CI Status

All 23 checks PASS at 25f35720b, including cargo test, cargo fmt, cross-adapter parity, axum/cloudflare/spin, ts CLI (macOS and Ubuntu), integration and browser integration tests, Fastly EC lifecycle, vitest and the format jobs. No required checks are configured for this base branch.

@dhruv8sh

dhruv8sh commented Nov 12, 2026 •

Copy link
Copy Markdown
Collaborator Author

Re: review 5814450927 (ChristianPavilonis)

Fixed in 5c0bca7. Validation now keeps refresh state whose from has passed, so the source stays due. This covers a live identity imported after refresh_from and a held record after a failed refresh. The size and empty-state checks are unchanged, and rate_limit_per_hour bounds the retries. The validate test now expects due state to be kept.

Re: review 5821978901 (aram356)

Plans and docs: fixed in 7b60dd6, with the UID2 risk note rewritten in 8f575ad. Token chains: a server refresh and an SDK refresh do fork, as you describe. Since 7667acf an older cookie no longer rolls the refreshed token back, and since 5c0bca7 a failed refresh keeps the state. Once the SDK refreshes, its newer cookie token replaces the stored one, so the row follows the SDK chain again instead of alternating on every navigation. What remains is one server refresh per refresh_from interval while the SDK has not refreshed, bounded by rate_limit_per_hour. Operators running the SDK with useCookie: true can leave endpoint unset. The UID2 plan states this risk.

Structure: No. We are keeping this as a stack instead: #1487 holds the framework and this PR the vendors. The coordinator hooks that only the vendors use (cookie reads, refresh freshness, Lockr) stay here, next to the code that needs them.

Smaller gaps:

  • 89e0e17 clamps ProviderExpiry::After to 30 days in validation.
  • 579932d adds a Fastly adapter test that several Cookie headers are joined and read by providers.
  • OPT_OUT_UID / OPTED_OUT_UID in id5.rs are now one constant (7b60dd6).
  • allowed_domains is now optional in the guide table, needed only with endpoint.

@dhruv8sh
dhruv8sh added this pull request to stack #1563 November 12, 2026 13:08
Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
Add an optional IdentityProvider::read_request_cookies step that runs for providers with due sources before any lookup. Cookie IDs pass the same consent gates, validation and write plan as lookup results and replace the lookup. The provider endpoint becomes optional so cookie-only kinds need none; lookup kinds reject a missing endpoint.

Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
@aram356

aram356 commented Nov 13, 2026 •

Copy link
Copy Markdown
Collaborator

CREATOR: From the server-side identity plan (#1559, 10c5e436d): Take #1566's 0a2a00aaf, which reads the SharedID name from managed_user_ids, defaults the source to pubcid.org and keeps the stored value (still open here: sharedid.rs:46-59, common.rs:94,110,129-136). Take 0c13d4272: the blanket reject_providers_without_a_kind (config.rs:348) makes ts config validate, push and diff reject every enabled provider. SID-6 holds for the provider path. LiveRamp's Custom ID waits on DEC-9, which gates enabling LiveRamp, not this merge. Answer its open threads. In the body, write Part of #1567 in place of Closes #1567 and drop #1246, which #1567 replaces: only #1489, the last PR of the stack, closes #1567.

Blocks #1584, #1593, #1601, #1555, #1567

Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
…s not run them

Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
@dhruv8sh

Copy link
Copy Markdown
Collaborator Author

Two findings from @ChristianPavilonis's review (#1488 (review)) are filed as follow-ups, since each changes persisted opt-out state or the request egress paths:

ID5 rejects a fetch without v with 400 missing (v)ersion on both /g/v2 and /gs/v2, so no server-side ID5 lookup succeeded. Send the crate version as v; o, tml and nbPage stay unsent.

Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
Signed-off-by: dhruv8sh <dhruv8sh@proton.me>

# Conflicts:
#	crates/trusted-server-core/src/ec/provider.rs
ID5, LiveIntent, ConnectID, UID2, Criteo, UnifiedID and SharedID send no EC ID, so they now report sends_ec_id false and are looked up within identity_budget_ms on the first navigation, with results in the write that creates the row. LiveRamp puts the EC ID in its envelope lookup and keeps waiting for a later navigation.

Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
Add a provider-kinds table and per-kind sections covering server calls, first-page-view behaviour (every kind but LiveRamp runs on the navigation that mints the EC), default cookies, Lockr, atype, TTLs, opt-out and GDPR handling, and the ID5 fetch body including v. Drop the stale claim that this release registers no provider kind.

Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
LiveRamp sends the EC ID only in its Custom ID envelope lookup. Without an endpoint it only reads cookies, so sends_ec_id now reports whether a lookup is configured, and a cookie-only LiveRamp joins the first page view like the other kinds.

Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
Read the cookie named by the Prebid sharedId module's storage.name, default the source to pubcid.org with atype 1, and keep a stored SharedID for as long as the row lives instead of letting a different cookie replace it after a day.

Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
#1488 already dropped core's blanket rejection of enabled providers. Note in core's deploy validation that ts config checks registered kinds by building each provider, and test that core accepts an enabled provider.

Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
A stored SharedID no longer wins over a different cookie value. When Prebid writes its own SharedID after Trusted Server generated one, bidders get the ID Prebid sends from the browser. Cookie IDs again expire after a day and generated IDs after MAX_TTL; the cookie name, source and atype defaults stay.

Signed-off-by: dhruv8sh <dhruv8sh@proton.me>
@dhruv8sh dhruv8sh linked an issue Nov 13, 2026 that may be closed by this pull request
aram356 added a commit that referenced this pull request Nov 13, 2026
#1567 is the story PRs #1487, #1488 and #1489 deliver, so it takes #1246's place under #1558. It moves to wave 5, after #1489, and the provider-stack tie-out and Part C items now name it.
@aram356 aram356 linked an issue Nov 13, 2026 that may be closed by this pull request

@ChristianPavilonis ChristianPavilonis left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Summary

Adds eight vendor identity providers and the cookie, refresh, consent and configuration hooks they need. Previously corrected feedback is not repeated; three existing opt-out privacy defects remain unresolved at 518f88984900d97262594f64ec60a600085a5d64, so changes are still required.

One inline comment carries a one-click GitHub suggestion. The other four findings are body-level and describe manual changes; the three blocking findings reference their existing reports rather than creating duplicate inline threads.

Blocking

🔧 wrench

  • An unchanged cookie reverses a server-reported opt-out — existing #1602; see body-level finding 1.
  • Vendor opt-out cookies do not suppress current-request identity egress — existing #1603; see body-level finding 2.
  • A delayed lookup can restore a source after a newer cookie opt-out — existing #1604; see body-level finding 3.

Non-blocking

♻️ refactor

  • Correct SharedID lifetime and precedence documentation — see inline at trusted-server.example.toml:302–303 (suggestion).
  • Configuration documentation describes obsolete behavior — see body-level finding 5.

Cross-cutting / body-level findings

1. 🔧 An unchanged cookie reverses a server-reported opt-out — #1602

Reference: crates/trusted-server-core/src/ec/coordinator/mod.rs:598–604.

Any usable cookie clears the provider's remembered opt-out. A server refresh does not rewrite the browser cookie, so that cookie is not evidence of renewed consent or identity issuance.

A fresh two-navigation reproduction with the real ID5 provider confirmed this at the reviewed head: the first navigation receives universal_uid: "0", clears the source and remembers the server opt-out; the next navigation sends the same id5id=held-id cookie, forgets that opt-out and restores held-id.

Keep server-reported suppression until there is evidence of a renewed identity. For example:

remember opt-out with the observed cookie fingerprint
clear suppression only when a genuinely renewed identity arrives

Apply manually — requires persisted-state and lifecycle-test changes. This remains the existing unresolved #1602, not a new duplicate finding.

2. 🔧 Vendor opt-out cookies do not suppress current-request identity egress — #1603

References: crates/trusted-server-core/src/ec/coordinator/mod.rs:583–590, crates/trusted-server-adapter-fastly/src/app.rs:1065–1111, crates/trusted-server-core/src/auction/endpoints.rs:354–391, and crates/trusted-server-core/src/ec/identify.rs:104–118.

The cookie reader records an opt-out for the later write. The publisher auction still uses the earlier snapshot, while named auction/page-bids/identify routes never run those provider cookie readers. The ordinary GDPR/vendor filters do not replace request-local vendor opt-out suppression.

A fresh authenticated identify reproduction with a stored ID5 UID and id5id=0 returned the stored held-id. The publisher, page-bids and auction consumers were also traced through their shared EID resolver/filter paths.

read vendor opt-out cookies before identity egress
remove denied sources from stored and browser-supplied EIDs

Apply manually — must cover publisher auctions, page-bids, /auction and identify without adding provider HTTP lookups to read-only routes. This remains the existing #1603.

3. 🔧 A delayed lookup can restore a source after a newer cookie opt-out — #1604

References: crates/trusted-server-core/src/ec/write_plan.rs:130–163 and crates/trusted-server-core/src/ec/after_response.rs:90–103.

Cookie opt-outs leave no persisted revocation marker. The after-response writer re-reads the newer row and uses its current generation, so CAS protects only changes after that last read, not the revocation that happened while the lookup was in flight.

A fresh reproduction dispatched an ID5 lookup, committed a newer cookie opt-out, confirmed the source was absent, then collected the older response and passed it through commit_after_response_lookups. The source was restored as late-result. A control confirmed that whole-row consent withdrawal does correctly block the same delayed result.

capture provider revision at dispatch
discard results superseded by a newer revocation

Apply manually — requires dispatch/persistence changes and an ordering regression. This remains the existing #1604; filing the follow-up has not corrected the behavior.

5. ♻️ Configuration documentation describes obsolete behavior — non-blocking

References:

  • docs/guide/configuration.md:935–937 says push/diff do not know the target adapter.
  • docs/guide/configuration.md:1037–1039, crates/trusted-server-cli/src/checked_app_config.rs:4–7, and crates/trusted-server-identity-providers/src/lib.rs:184–191 describe invalid providers being disabled per request.

The implementation instead selects ProviderlessAppConfig from the push/diff adapter and propagates provider-build errors out of Fastly application startup. Suggested authoritative wording:

`ts config validate` is adapter-agnostic. `ts config push` and
`ts config diff` reject enabled providers for targets other than Fastly.
On Fastly, invalid enabled provider configuration prevents application
startup; providers are not silently disabled for individual requests.

Apply manually — the correction spans multiple files and separate documentation blocks.

Verification and scope

Reviewed only this PR's delta against feat/s2s-eid-collection-core: merge base bc8df76ccaf243877c4754c2df9e9ee8ef100385, head 518f88984900d97262594f64ec60a600085a5d64.

  • cargo test-fastly, using repository-pinned Viceroy 0.21.0: 4,040 tests/doc-tests passed, 31 ignored, zero failures.
  • cargo test -p trusted-server-identity-providers --lib --locked: 114 passed.
  • cargo test -p trusted-server-core --lib ec:: --locked: 591 passed.
  • cargo test -p trusted-server-core --lib auction::endpoints::tests --locked: 36 passed.
  • Isolated review probes: 13 passed, including the three defect reproductions; whole-row withdrawal protection; full CLI-wrapper validation success, unknown-kind rejection and disabled-provider bypass; SharedID default-source roundtrip; and private refresh-state omission from identify output.
  • cargo fmt --all -- --check and pinned-range git diff --check: PASS.
  • The exact comment-only inline suggestion was verified independently: valid TOML, identical complete parsed configuration, whitespace check and byte-exact post-verification patch comparison.
  • Probe sources and suggestion edits were discarded. The reviewer worktree is clean at the reviewed head; no commits or pushes were made.

Provider implementations/tests and the affected startup, cookie, persistence/concurrency, egress and configuration paths were reviewed. Unchanged unrelated sections of the largest supporting files were not exhaustively audited. No live vendor API calls were made; UID2 service refresh and LiveRamp Custom ID service validation remain unverified. The cross-adapter matrix relies on passing remote CI rather than a duplicate full local run. Local compilation initially required resuming timed-out builds and correcting probe-only toolchain/fixture setup; final results above passed.

CI Status

Comment on lines +302 to +303
# ["pubcid.org"], which needs a matching [[ec.partners]] entry. A stored
# SharedID lives as long as the row and wins over a different cookie value.

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

♻️ Correct SharedID lifetime and precedence documentation — non-blocking

The current implementation gives cookie IDs a 24-hour expiry and generated IDs a 30-day expiry; a different usable cookie ID replaces the stored ID. This example still describes the superseded store-wins behavior.

Suggested change
# ["pubcid.org"], which needs a matching [[ec.partners]] entry. A stored
# SharedID lives as long as the row and wins over a different cookie value.
# ["pubcid.org"], which needs a matching [[ec.partners]] entry. Cookie IDs
# are kept for 24 hours; generated IDs for 30 days. A different cookie ID
# replaces the stored ID.

Verification: applied these exact bytes in isolation; both versions parse as TOML and their complete parsed configurations are identical. git diff --check and the byte-exact post-verification drift check passed.

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

6 participants