feat(router-worker): record canonical routing differences

Author: jbwcloudflare

packages/workers-shared/router-worker/src/analytics.ts

@@ -39,6 +39,10 @@ type Data = {
 	userWorkerFreeTierLimiting?: boolean;
 	// double9 - The time it takes for the request to be handed off the Asset Worker or user Worker in milliseconds
 	timeToDispatch?: number;
+	// double10 - Canonicalization performed while in shadow mode
+	pathNormalization?: number;
+	// double11 - Canonical routing decision differs from current behavior
+	pathNormalizationDifference?: number;
 
 	// -- Blobs --
 	// blob1 - Hostname of the request
@@ -103,6 +107,8 @@ export class Analytics {
 				this.data.abuseMitigationBlocked ? 1 : 0, // double7
 				this.data.userWorkerFreeTierLimiting ? 1 : 0, // double8
 				this.data.timeToDispatch ?? -1, // double9
+				this.data.pathNormalization ?? 0, // double10
+				this.data.pathNormalizationDifference ?? 0, // double11
 			],
 			blobs: [
 				this.data.hostname?.substring(0, 256), // blob1 - trim to 256 bytes

packages/workers-shared/router-worker/src/worker.ts

@@ -1,4 +1,5 @@
 import { WorkerEntrypoint } from "cloudflare:workers";
+import { canonicalizePath } from "../../asset-worker/src/utils/canonical-path";
 import { generateStaticRoutingRuleMatcher } from "../../asset-worker/src/utils/rules-engine";
 import { PerformanceTimer } from "../../utils/performance";
 import { TemporaryRedirectResponse } from "../../utils/responses";
@@ -281,6 +282,26 @@ export class RouterInnerEntrypoint extends WorkerEntrypoint<Env> {
 			};
 
 			if (config.static_routing) {
+				// Shadow-only: raw-path dispatch below remains authoritative.
+				const canonicalPath = canonicalizePath(url.pathname);
+				if (canonicalPath.routingPath !== url.pathname) {
+					const currentTarget = getStaticRoutingTarget(
+						request,
+						config.static_routing
+					);
+					const canonicalTarget = getStaticRoutingTarget(
+						request,
+						config.static_routing,
+						canonicalPath.routingPath
+					);
+					if (currentTarget !== canonicalTarget) {
+						analytics.setData({
+							pathNormalization: canonicalPath.normalization,
+							pathNormalizationDifference: 1,
+						});
+					}
+				}
+
 				switch (getStaticRoutingTarget(request, config.static_routing)) {
 					case "asset":
 						// direct to asset worker

packages/workers-shared/router-worker/tests/index.test.ts

@@ -5,6 +5,7 @@ import DefaultRouterEntrypoint, {
 	RouterInnerEntrypoint,
 	RouterOuterEntrypoint,
 } from "../src/worker";
+import type { ReadyAnalyticsEvent } from "../src/types";
 import type { Env } from "../src/worker";
 
 async function fetchFromInnerEntrypoint(
@@ -200,6 +201,42 @@ describe("inner entrypoint unit tests", () => {
 		expect(await response.text()).toEqual("hello from user worker");
 	});
 
+	it("records a canonical routing difference without changing dispatch", async ({
+		expect,
+	}) => {
+		const request = new Request("https://example.com/docs+draft");
+		const ctx = createExecutionContext();
+		const logEvent = vi.fn((_event: ReadyAnalyticsEvent) => undefined);
+		const env = {
+			CONFIG: {
+				has_user_worker: true,
+				static_routing: { user_worker: ["/docs%2Bdraft"] },
+			},
+			ANALYTICS: { logEvent },
+			USER_WORKER: {
+				async fetch(_request: Request): Promise<Response> {
+					return new Response("user worker");
+				},
+			},
+			ASSET_WORKER: {
+				async fetch(_request: Request): Promise<Response> {
+					return new Response("asset worker");
+				},
+				async unstable_canFetch(_request: Request): Promise<boolean> {
+					return true;
+				},
+			},
+		} as unknown as Env;
+
+		const response = await fetchFromInnerEntrypoint(request, env, ctx);
+
+		expect(await response.text()).toBe("asset worker");
+		expect(logEvent).toHaveBeenCalledOnce();
+		const event = logEvent.mock.calls[0]?.[0];
+		expect(event?.doubles?.[9]).toBe(8);
+		expect(event?.doubles?.[10]).toBe(1);
+	});
+
 	it("returns fetch from asset worker when static_routing asset_worker rule matches", async ({
 		expect,
 	}) => {