Skip to content

(DO NOT MERGE) Identity integration branch - #1608

Open
aram356 wants to merge 215 commits into
mainfrom
rc/identity
Open

aram356 wants to merge 215 commits into
mainfrom
rc/identity

Conversation

@aram356

@aram356 aram356 commented Nov 14, 2026 •

Copy link
Copy Markdown
Collaborator

Summary

  • rc/identity is the Trusted Server integration branch for server-side identity on every adapter (Server-side identity on every adapter #1558), the counterpart of (DO NOT MERGE) Identity integration branch edgezero#495. It carries the ready PRs the Fastly and Axum MVP builds on, joined by history-preserving merges, so identity work can start on the combined stack and CI can test it against main.
  • Each included PR keeps its own review and still lands on main by itself. This PR shows the combined diff and its CI.
  • The branch only moves forward. When an included PR's head moves, or a waiting PR becomes ready, the new head is merged on top.

Included

Merged in this order on main 1810c763a:

Order PR Head Merge commit Merge What it brings
1 #1557 76e1dd5f6 9084af2d5 Clean Sourcepoint TCF consent bridge
2 #1525 cd8977cad 7b01cab86 Clean Explicit per-provider HTTP auction endpoints
3 #1526 e529e5576 ad63e68a4 Clean Awaitable shared EC persistence (#1522)
4 #1503 5e10c24e4 aa9c03461 Clean ts ec show and ts ec eids (#1432)
5 #1506 cee4acb48 30a74def1 31 hunks Cutover to EdgeZero PR 275 (#1507)
6 none 6b32d2b61 Fix commit Lint allowance where #1503 meets #1506
7 #1506 858f95087 4bc4c4847 Clean #1506 repinned to EdgeZero rc/identity at 10166628 (see below)
8 #1506 7ee7e89a5 4a414a00b 1 hunk #1506's round-3 fixes, repinned to EdgeZero rc/identity at 3d92ee38
9 #1506 47a539528 9bd4b1415 Clean #1506 repinned to EdgeZero rc/identity at f84ffbbb

Moved since 9bd4b1415

None.

How #1506's conflicts were resolved

30a74def1 resolves #1506's conflicts with #1525 and #1526 on #1506's structure. git show --remerge-diff 30a74def1 shows exactly what the resolution changed.

Area #1525 / #1526 side #1506 side Resolution
Fastly EC finalize (adapter-fastly/src/main.rs) Awaits EC persistence, bridged with block_on inside edgezero_main Deletes edgezero_main; finalize runs in finalize_response The block_on bridge moves into finalize_response. EdgeZero calls that hook after its dispatch executor has returned, so nothing nests
Post-send pull sync (main.rs) Async pull-sync helpers in main.rs Moves post-send work to post_delivery.rs, which already awaits it #1506's version kept; no production change needed
Pull sync and batch sync (ec/pull_sync.rs, ec/batch_sync.rs) Awaits on snapshot and upsert calls Sends through EdgeZero's send_all_until and a new request builder #1506's send path with #1526's awaits; KV-touching tests become async
Endpoint rule (auction/plan.rs) https, or http with allow_insecure_http https, or http to loopback Union: https, loopback http, or any http with the opt-in
Code #1506 deleted Edits to it Deleted Stays deleted; the edits moved into #1506's replacements

4a414a00b resolves the one conflict of #1506's round-3 head, in ec/pull_sync.rs. #1506 added a sync test, pull_sync_group_failure_names_every_partner_of_the_group, where #1526 had made the pull-sync tests async. The new test moves to #1526's async KV API (a tokio test, with seed_present_snapshot and graph.get awaited), and the existing test keeps this branch's async header.

6b32d2b61 is the one non-merge commit. #1503's ec_admin CLI test reads a body with Body::into_bytes, which #1506's clippy.toml disallows; neither PR fails alone. It allows the lint for that test crate the way #1506's own test crates do.

The EdgeZero repin

On 2026-11-17 #1506 moved to EdgeZero rc/identity at f84ffbbb. It carries PR 275's head ea2549fb, 16 fix and docs commits inside EdgeZero, and #422's stock-celld store service. No Trusted Server code changes; this branch takes it as the plain merge 9bd4b1415.

On 2026-11-16 #1506 moved to EdgeZero rc/identity at 3d92ee38, which carries PR 275's head b65e7144. PR 275's new commits answer three Trusted Server asks:

#1506's Fastly logging_for now uses that macro (#1611). This branch takes the repin as part of merge 4a414a00b. The earlier repin to 10166628 follows.

The repin lives in #1506 itself, not in this branch, so this branch takes it as a plain merge. EdgeZero's rc/identity adds the PRs stacked on PR 275 to the pin. Three of them reach Trusted Server:

EdgeZero change Trusted Server change in #1506 Commit
IABTechLab/edgezero#409 removes Forwarded and X-Forwarded-* fields on Axum before routing The Axum router records its authenticated forwarder decision in EdgeZero's received-head preparer (IABTechLab/edgezero#499), which runs before that removal. Code and tests come from 3da80afd7 in #1605 32526960d
IABTechLab/edgezero#460 adds cache tags to OutboundCachePolicy, so it is no longer Copy Test code clones it, and ExpectedTransport drops Copy 32526960d
EdgeZero's workspace pins getrandom exactly, as one of its audited exact pins The lockfile moves from getrandom 0.4.3 to 0.4.2 32526960d
None The spec's D5 now pins an rc/identity commit rather than PR 275's head 858f95087

Without the preparer, two ts dev proxy tests fail on Axum. One shows the publisher rewriting links to the loopback authority instead of the browser's. The other shows trace enable returning 403 when the proxy does not rewrite Host. With the preparer both pass, and removing it makes the new preparer test fail.

Open points for the owning PRs

Point Owning PR
The endpoint error text and its docs describe only the loopback rule, not the allow_insecure_http opt-in #1525 or #1506, whichever lands second
No test sends to an opted-in non-loopback http endpoint through EdgeZero's client #1525 or #1506, whichever lands second
docs/superpowers/specs/2026-11-10-shared-async-ec-design.md says EcFinalizeState carries services, which #1506 removed #1526
ec_admin.rs needs the disallowed_methods allowance from 6b32d2b61 #1503 or #1506, whichever lands second

Waiting on

PR Head Builds on Conflicts with this branch Waits for
#1487 bc8df76cc main 23 files, 87 hunks; 2 are in files #1506 deletes (core/src/platform/http.rs, Fastly platform/deadline.rs) Its rebase onto #1506, which moves its lookups onto EdgeZero's outbound client as its review asks
#1488 518f88984 #1487 Follows #1487 #1487
#1489 7bb9e741d #1488 Follows #1488 #1488

All three are ready for review; they wait on the rebase, not on draft status. Together they deliver #1567.

Not included

PR What it is Why not here
#1566 Server-side identity collection on the Axum dev server Stacked on #1488; its Axum part is rebuilt on the shared identity app
#1531 Native prepared startup Rebases onto #1506 first (plan item A1)
#1532 to #1540 Native Axum baseline stack Stacks on #1531
#1605 Follow-up above an older #1506 checkpoint Closed. Its forwarder change lives in #1506 (32526960d)
#1449, #1543 Reproducible Fastly builds and release publishing Release tooling; the identity MVP does not wait on it

EdgeZero pin

Pinned by EdgeZero revision Next
#1506 rc/identity at f84ffbbb (IABTechLab/edgezero#495), which carries PR 275 at ea2549fb Moves with EdgeZero's rc/identity; an EdgeZero release tag once PR 275 merges

Refs #1558. Planned in #1559.

Test plan

At 9bd4b1415, run locally on macOS:

Check Result
cargo fmt --all -- --check, all eight clippy aliases and the core build-digest clippy Pass
test-fastly (3,726), test-fastly-reuse (224), test-axum (60), test-cloudflare (62), test-spin (85), parity (33), host CLI tests (993) Pass
Core build-digest test, scripts/lint-wasm-clock.sh, JS tests (3,310) and format, docs and Markdown format, docs-proposal scripts, Node pin guard, URL-host lint Pass
CI on this PR Running at 9bd4b1415

Earlier, at 4a414a00b, run locally on macOS:

Check Result
cargo fmt --all -- --check Pass
All eight clippy aliases and the core build-digest clippy Pass
test-fastly (3,726), test-fastly-reuse (224), test-cloudflare (62), test-spin (85), parity (33), host CLI tests (993) Pass
test-axum (60) 59 passed, 1 failed in the gate run: publisher_input_cap_matrix_axum read an incomplete body (IncompleteBody). The test then passed 3 of 3 alone and the alias passed 5 of 5 full runs. #1506's head 7ee7e89a5 also passed 5 of 5. The cause is not reproduced
Core build-digest test, scripts/lint-wasm-clock.sh, JS tests (3,310) and format, docs and Markdown format, docs-proposal scripts, Node pin guard, URL-host lint Pass
CI on this PR Running at 4a414a00b

Earlier, at 4bc4c4847, run locally on macOS:

Check Result
Every head in Included is an ancestor of this branch through history-preserving merges Pass
cargo fmt --all -- --check Pass
All eight clippy aliases and the core build-digest clippy Pass
test-fastly (3,723), test-fastly-reuse (223), test-axum (60), test-cloudflare (62), test-spin (85), parity (33), host CLI tests (981) Pass
Core build-digest test, scripts/lint-wasm-clock.sh, JS tests (3,310) and format, docs and Markdown format, docs-proposal scripts, Node pin guard, URL-host lint Pass
The same 27 gates on #1506's own head 858f95087 Pass
CI on this PR 31 of 31 pass at 4bc4c4847

prk-Jr and others added 30 commits November 5, 2026 20:01
Wrap GET /_ts/admin/ec/{id} and GET /_ts/admin/eids so operators no
longer pass the admin password to curl. Both commands read the password
from TRUSTED_SERVER_ADMIN_PASSWORD only, check the EC ID or cookie values
locally before sending, explain 401/404/501, and print response data to
standard output only.

Extract the admin transport from ts cache purge into a shared
admin_client module (service URL checks, password source, no redirects,
401 hint) and move purge onto it, so #1430's ts keys commands can reuse
it.

Closes #1432
Trusted Server moves onto EdgeZero PR 275 in one hard cut, using the canonical lifecycle on every adapter and EdgeZero's outbound API for every call, with no Trusted Server transport plumbing. This document states what EdgeZero must provide for that: nine blocking requirements, sixteen follow-ups, and a qualification gate, each with its need, the gap at the PR 275 head, observable requirements, and acceptance criteria.
Replace the stale draft, which kept the Trusted Server outbound layer and the
custom Fastly lifecycle, with a design on EdgeZero PR 275's APIs: every
outbound call through EdgeZero's HttpClient, Fastly on the canonical
lifecycle, and redirects through EdgeZero. The spec maps each outbound site,
inbound reader, and harness onto the new APIs, lists the Fastly behavior
differences, Trusted Server's share of EdgeZero's qualification run, and a
commit sequence with a dependents inventory, and records four review rounds.
Batch checks never poll the SDK on Fastly, so collection after the cutoff
uses batch.next(), and the expired-snapshot harness case and the late-bid
Fastly difference say so. The ported deadline test module stays out of the
platform::deadline path the dependents inventory searches. Two unverified
harness claims now cite Viceroy and EdgeZero source, and the review log
records round 5, which found nothing blocking.
Retarget H from 8f82547b to 9b31a697, which changes no public API and no
line an earlier draft cited. Fold in the per-requirement source check and
review 5798502238 on PR 275: correct the claims the EdgeZero source
contradicted, list the open EdgeZero defects at H, and close the gaps against
Trusted Server's own acceptance criteria (per-request synthesized headers on
Fastly, the head-conversion 500, parity on the Axum test server, and the legs
of the confirmed follow-ups). Add D19, D20, and Q7, and record the update and
its sixth review round in the review log.

Mark the requirements file as the text handed to EdgeZero, since EdgeZero's
amended copy is the contract it is measured against.
Construct the publisher origin send and begin inside the response-body
scope, so a raw origin body never gets its own owner and the attach holds.
Collect every raw publisher variant on Axum, Cloudflare, and Spin before
egress under today's caps. Narrow the overlap claim and test 6 to where the
overlap runs. Extend D10 to operator hop-by-hop fields, keep Image Optimizer
options on the final client HEAD, and state the telemetry latency's changed
stop point.
Keep the Axum, Cloudflare, and Spin origin input caps for every publisher
classification, processed HTML included, through an encoded-byte cap and a
cumulative decoded-byte bound, separate from the processed-output cap. State
that skipping an operator Connection entry drops its nomination semantics,
replacing the claim that the skip is wire-neutral, and test the retained
field.
…tover spec

The cut is stacked on PR 275 and follows its head; main merges without
waiting for EdgeZero's qualification record, and production deploys do not
wait for qualification. Limits stay app-owned with D7's values, hosted
qualification is manual, HTTP/3 is qualified per adapter, new outbound-layer
uses are not frozen, loopback http bidder endpoints are accepted, and the
bodiless part of EZ-18.4 is withdrawn in favor of strict suppression. The
HTTP/3 and EZ-18.4 changes are requested in PR 275 threads.
Fastly and Axum read request heads through parts, headers and extensions,
propagate into_request errors, and convert bodies through into_body_payload.
Hooks::routes returns Err(startup_error(..)) on a settings failure; core maps
the root status to the matching EdgeError constructor. Axum main assembles
the app with App::build and exits non-zero before binding when startup fails,
and its startup_error_router is gone. Fastly keeps its startup router and
hand-built App; its run_custom and serve_custom callbacks return Ok(()).

The Axum route tests and the CLI proxy test now serve the real app through
AxumTestServer over loopback TCP.
…egress policies

Core gains edge_app.rs. install_edge_policies sets a response write deadline
60 s after egress starts and installs x-ts-version as the app-level
synthesized response header set. Every adapter's Hooks::configure calls it,
and Fastly also adds x-ts-fastly-version from FASTLY_SERVICE_VERSION. Fastly's
hand-built app still logs a configure error instead of failing.

Cloudflare and Spin read request heads through parts, headers and
extensions, propagate into_request errors, convert bodies through
into_body_payload, and convert ConfigValue to String at the config store
boundary. Their startup_error_routers are gone: routes() returns Err, mapped
by startup_error on Cloudflare and always service_unavailable on Spin. Spin
opens its config store with for_label, normalizes RequestParts, and its entry
point returns SpinResponse. sanitize_forwarded_headers takes a HeaderMap.
Spin's outbound client detaches its tasks with spawn_local, because the
repinned spin-sdk deprecates spawn.

Cloudflare and Spin route tests drive the assembled app and check that
EdgeZero's canonical 404 and 405 carry x-ts-version.
The Axum route tests now prove that TrustedServerApp::configure installs the
synthesized response headers over real TCP. TRACE /auction gets the canonical
405 with a sorted Allow and x-ts-version. A raw OPTIONS * request, the one
target the publisher fallback does not claim, gets the canonical 404 with
x-ts-version.
EdgeZero PR 275 hands inbound bodies to handlers as deadline-bounded
streams, so the old readers broke: POST /auction and EC batch sync read
an empty body, and the sign, rebuild, request-signing, and cache purge
endpoints answered 400 for any streamed body.

Add http_util::read_request_body, which rejects a single valid
Content-Length over the cap without polling the body and otherwise reads
with Body::into_bytes_bounded. Errors map by status: 413 to
RequestTooLarge, 408 to the new TrustedServerError::RequestTimeout,
another 4xx to BadRequest, and a 5xx to Proxy (502). A duplicate or
malformed Content-Length skips the precheck and the bounded read
governs. Body bytes are never logged.

Move every inbound reader onto it with its existing cap: /auction (keeps
the text/plain 413), EC batch sync (keeps the body_too_large body), cache
purge, first-party sign and rebuild, verify-signature, key rotate and
deactivate, the six integration proxies, and the GTM beacon. Delete
request_body_bytes, collect_body_bounded, enforce_max_body_size, and the
GTM PayloadSizeError path. The request-signing handlers and batch sync
become async, and the adapters await them.

Add a shared body-read case table so each reader asserts the declared
413, the streamed 413, 408, 400, and 502 through its handler, plus Axum
listener tests that sign a URL and parse an auction body sent as
streams.
ScriptedHttpClient implements EdgeZero's OutboundHttpClient for core and adapter tests. It records each prepared request with its options and answers from a first-in, first-out script per method and URI, with chunked, delayed, held, and failing replies. Its forbid mode fails and records every request.

TestClock pairs a hand-advanced clock with a timer factory that wakes on advance, so batch cutoffs, timeouts, and slot timing follow EdgeZero's batch ledger deterministically.
Start TestClock an hour ahead of the process clock, so a deadline built from MonotonicClock::default() is already expired on it and code that mixes clocks fails its tests. Expect a buffered body for begin and batch instead of silently recording an empty one.
RuntimeServices gains two required services, outbound_client (EdgeZero's
HttpClient) and clock (MonotonicClock), beside the old http_client and
backend, which stay until the old outbound layer is deleted. Every
RuntimeServices::builder() call sets both. Test helpers and fixtures use a
forbid-mode ScriptedHttpClient and a TestClock, and the parity suite's
ForbiddenLifecycle checks on drop that no outbound request was sent.

Each adapter's per-request builder takes the client from the request context
with the proxy marker off, and the clock from the context. A request with no
client is an internal EdgeError, not a panic. The oneshot route helpers in the
Fastly, Cloudflare, and Spin tests install a forbid-mode client, as EdgeZero's
request conversion installs the adapter default.

The new outbound module holds the constant timeouts and caps, the buffered and
streamed request helpers, and outbound_error. outbound_error maps a 413 to
RequestTooLarge, a 408 to RequestTimeout, and a 400 to BadRequest only for a
forwarded client request. Every other failure keeps the site's own error. The
report carries the EdgeError, its budget source, and its provider failure
detail, and the detail is logged at warn without provider text or URLs.

No outbound site uses the new client yet.
Serve the Axum, Cloudflare, and Spin apps on AxumTestServer, each
assembled under its own platform metadata with its production policies
and a forbidding scripted client in router state. Add the
routes_with_settings_and_outbound_client testing seam to the three
adapters so that client can reach router state.

Add test 19 (EZ-23 criterion 13): a 9000-byte target gets 414 with the
synthesized headers from all three apps, and a bodiless GET whose
inbound body is an unread stream reaches a loopback origin with no body.

Add test_support::insert_outbound_client and use it in the Fastly,
Cloudflare, and Spin oneshot route helpers. Check the forbidden
lifecycle script explicitly at the end of each trace parity test.
Drop the tower, http-body-util, and urlencoding dev-dependencies the
crate no longer uses.
…routers

Record the loopback origin's request headers, and assert that the
bodiless GET forward carries no Transfer-Encoding and no Content-Length
other than 0. Say that the router-state Axum client is staged for
Task 7, when the publisher forward moves to EdgeZero.

Split each adapter's router assembly into a private router_builder, so
production builds no client branch. Only the
routes_with_settings_and_outbound_client seam adds router state.

Build the Axum route tests' settings-based servers through that seam
with a forbidding script, drop the ForbiddenLifecycle drop check now
that every test asserts explicitly, and fix the test_settings doc.
Port Sourcepoint, Lockr, Permutive, DataDome, DataDome Protection, and
Didomi from the platform HTTP client onto services.outbound_client(),
with the settings, caps, decoding, and timeouts from the spec's site map.
Delete the backend registration helpers and test doubles those paths
used, and move their tests to the scripted client with request readback.

Reject proxy.certificate_check = false at deploy validation and ignore it
with a warning at runtime, and drop it from fixtures, scripts, and CI.
Keep EdgeError text out of outbound_error reports, and put the services
client in router state at the Axum, Cloudflare, and Spin services seams.
proxy_request, which serves the first-party proxy, GTM, the Prebid bundle,
testlight, GPT, and the JS asset proxy, now checks the initial target as
before and then calls HttpClient::follow with a four-redirect limit, the
15 s per-hop timeout, and a 60 s chain deadline. A 'static redirect policy
owns the allowlist and the HTTPS rule and checks each hop in the old order.
Callers that do not follow redirects use send. Buffered calls keep 10 MiB
(testlight 2 MiB) and the original coding, and streamed calls get 60 s.

The asset proxy sends the final GET streamed and the final HEAD and the S3
HEAD preflight buffered, all in their original coding. Image Optimizer
options are mapped from the resolved profile to EdgeZero's options, with
Trusted Server's region aliases mapped to the seven regions, and go on the
final request only. A profile the builder rejects serves the image
unoptimized with a warning.

Delete proxy_with_redirects, ProxyRedirectPolicy, ProxyRequestHeaders,
REQUEST_BODY_HEADERS, the platform-response converters,
build_asset_platform_request, AssetProxyResponse::into_response, the old
test doubles, and the StubHttpClient members only these paths used. Port
the redirect, allowlist, asset, and Image Optimizer tests to the scripted
client, and add the deadline, userinfo, cross-origin, non-ASCII Location,
send-path, readback, and SigV4 host cases.
Add an Axum-binary integration case that signs a first-party proxy URL
through /first-party/sign and proxies a chain against a loopback origin. A
permitted hop is followed to the final origin, a hop to a host outside
proxy.allowed_domains answers 403, and a Location with userinfo answers the
proxy's 502. RecordingOrigin now answers from a responder, so the chain
origin reuses it.

Reuse UPSTREAM_RTB_MAX_RESPONSE_BYTES for the testlight cap instead of a
duplicate constant, and declare the ring feature the SigV4 TLS origin uses
on the integration crate's rustls dev-dependency.
At the pin, run_custom and serve_custom install EdgeZero's managed logger
before Trusted Server's callback and return without a response when that
fails, so no route is answered, /health included; Viceroy 0.21.0 then answers
200 with an empty body. main answered /health before logger setup and served
every request after printing the failure.

Record this as an open EdgeZero gap, with no Trusted Server workaround, in the
spec's section 3 steps and outcome table, section 9, Fastly differences item
28, Failure handling and Follow-ups, in the CHANGELOG Fastly logging entry, and
in a new Fastly guide section. The Fastly guide's and the API reference's
/health sentences now name the case.
The PR body's follow-ups were missing from the spec. Follow-ups now lists the
Wrangler pin that scripts/smoke-cloudflare.sh needs and the per-instance
manifest parse in the hand-written Hooks::logging_for, which is one parse per
request on non-reusable Fastly. Runtime marks smoke-cloudflare.sh as a known
failure: it exits on the missing pin, and main's .tool-versions has none
either.
858f950 moved the pin to rc/identity at 10166628, which carries PR 275's
current head, and CHANGELOG.md and edgezero.md no longer call any commit "the
head of EdgeZero pull request 275". What remained: the spec dates 5c32ae61 to
2026-11-13 while the PR body says 2026-11-14. The citation rule now says dates
are US Pacific and gives 5c32ae61's UTC date. The Open EdgeZero defects
section still called 5c32ae61 "the pin", and the Date line gains 2026-11-14.
The implementation entry stopped before the repins and the logging cut, and
said both test 6 asks were built. It now records that 737f8452 answered the
two EdgeZero asks; the logging cut with its commits (the added and reverted
Cloudflare and Spin loggers, the 737f8452 and 5c32ae61 repins, the Axum
run_app move and the Fastly logging.rs deletion); the maintainer's
rc/identity repin to 10166628; and review 5907840090 with its 25 findings,
4 rejected replies and this fix round. The test 6 line now matches the
thread: the streaming half was built, and the overlapped order stays pinned
by core's scripted-client test because Viceroy supplies no JA4.
MinimalOrigin and CookieVaryingOrigin accept from a nonblocking listener
and then read once. On macOS an accepted socket keeps the listener's
nonblocking mode, so when the request bytes trail the handshake the read
returns WouldBlock: CookieVaryingOrigin dropped the connection and
Trusted Server answered 502. That failed
test_cloudflare_dynamic_publisher_response_does_not_cross_cookie_boundaries
in 2 of 10 isolated runs on macOS; Linux CI passed it.

Both origins now make the accepted stream blocking, bound the read with
a timeout, and read until the blank line that ends the head, as
RecordingOrigin does.
The normalize tests covered headers only, so a normalize that blanked
the body would have reported every body change as the same. The new
case gives two bodies that differ beyond their UUIDs and EC IDs and
expects compare to report the body, hashed after the scrub.
The opt-in checked only that spin was on PATH, though its message named
the pinned version. An older Spin cannot link the production component,
so a named case got past the check and failed inside the test. The
script now sources smoke-common.sh and runs smoke_require_spin_version,
which compares spin --version with .tool-versions.
bad_content_length_returns_400 ran only on Fastly and Axum. Its checks
move into a helper that takes a base URL, and a new local-only case,
spin_runtime_bad_content_length_returns_400, runs them on Spin through
with_spin_ingress. Spin's HTTP host refuses the malformed and the
duplicate length with 400 before the component runs, as EdgeZero
records, and the origin sees neither.

Cloudflare gets no case. Local Wrangler refuses both before the Worker
runs, but with 500 on workerd 1.20260415.1 (Wrangler 4.83.0) and 400 on
1.20261113.1 (Wrangler 4.162.0, which CI installs), and EdgeZero
documents only the 500 for the duplicate.
Local Wrangler refuses a malformed or duplicate Content-Length before
the Worker runs, with a status that depends on workerd: 400 on
1.20261113.1 (Wrangler 4.162.0, which CI installs) and 500 on
1.20260415.1 (Wrangler 4.83.0), the one EdgeZero records.
bad_content_length_never_reaches_origin_cloudflare accepts either
status and asserts that the origin records nothing.

The shared helper now takes the accepted statuses. Fastly, Axum and
Spin still require exactly 400.
Pins the six EdgeZero crates to 3d92ee38, the rc/identity commit that
merges the refreshed outbound compatibility stack from #439. It carries
PR 275's head b65e7144, which adds four commits on top of e9ffaa8f:

- 4cbabfee answers a managed-logger setup failure with EdgeZero's
  canonical 500 and validates Fastly logging endpoint names when the
  manifest loads (IABTechLab/edgezero#505, #506).
- fe32185f preserves terminal errors and response policies.
- c7e3ac9f adds assembly-failure attestation tests.
- b65e7144 adds logging_config! for hand-written Hooks
  (IABTechLab/edgezero#504).

Each stack PR merged the one below it first. Only the EdgeZero source
lines of Cargo.lock change.
Hooks::logging_for parsed the compiled-in edgezero.toml with EdgeZero's
ManifestLoader once per instance, which on non-reusable Fastly is once
per request. EdgeZero's logging_config! (IABTechLab/edgezero#504)
resolves and validates the same table at compile time, as app! does, so
logging_for now returns it directly. The manifest constant, the cache
and the loader import are gone.

Closes #1611
The CHANGELOG, the EdgeZero guide and the cutover spec named 10166628.
The pin is now 3d92ee38 on rc/identity, which carries PR 275's head
b65e7144 and the refreshed stack on it. The spec records the four new
PR 275 commits, that only lifecycle.rs changed among the Fastly files it
cites at 5c32ae61, and the JA4 review merge the branch took between the
two pins. The 10166628 paragraph stays as history.
At 3d92ee38, EdgeZero answers a managed-logger setup failure before a
Fastly custom callback with its canonical, redacted JSON 500 (no payload
for HEAD) and still returns the ManagedLoggerError to main. Manifest
loading and logging_config! reject an empty, malformed, or reserved Fastly
endpoint name, so such a name fails Trusted Server's build.

The CHANGELOG, the Fastly guide, the /health contract, and the cutover
spec said a logger failure answered nothing and called it an open gap.
They now describe the 500, its missing Trusted Server headers, and the
build-time endpoint check. The spec cites lifecycle.rs at 3d92ee38,
records the endpoint probe, notes the round-2 asks are answered at
b65e7144, and drops the #505/#506 follow-up.
4088c15 replaced the hand-written Hooks' ManifestLoader parse with
EdgeZero's logging_config!, which b65e7144 adds for hand-written Hooks.
Section 9 of the cutover spec now says the table is resolved and
validated at compile time, and the #1611 follow-up, which waited on that
helper, is removed because this PR closes it.
Adds a review log entry for the move to rc/identity at 3d92ee38: how PR
275's head b65e7144 was merged up the stack, the JA4 merge the branch
took in between, the two PR 275 commits that answer the round-2 asks,
the logging_config! switch, the endpoint probe, and the docs commits
that followed.
…to rc/identity

#1506 now pins EdgeZero rc/identity at 3d92ee38 (PR 275 at b65e7144)
and resolves the Fastly logging table with logging_config!.

Resolve the one conflict in ec/pull_sync.rs on #1526's structure: keep
rc/identity's async header for the existing pull-cap test, and port
#1506's new pull_sync_group_failure_names_every_partner_of_the_group
test to #1526's async KV API (tokio test, awaited
seed_present_snapshot and graph.get).
Pins the six EdgeZero crates to f84ffbbb, the rc/identity commit that
merges the refreshed outbound compatibility stack from #439. It carries
PR 275's head ea2549fb, 16 fix and docs commits after b65e7144 inside
EdgeZero, and #422's stock-celld store service. Each stack PR merged the
one below it with no conflicts. Only the EdgeZero source lines of
Cargo.lock change, and no Trusted Server code changes.

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

Development

Successfully merging this pull request may close these issues.

4 participants