Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
fix(web): align native HTTP spans with the frontend observation clock
Gener95d67f6c092c
diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex 77d44074e..52e7b08db 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -322,6 +322,9 @@ importers:'@opentelemetry/api':specifier: 1.9.0version: 1.9.0+ '@opentelemetry/sdk-trace-web':+ specifier: 2.11.0+ version: 2.11.0(@opentelemetry/[email protected])'@shikijs/core':specifier: 4.5.0version: 4.5.0diff --git a/src/web/package.json b/src/web/package.jsonindex fa260b713..9a99fa4c5 100644--- a/src/web/package.json+++ b/src/web/package.json@@ -61,6 +61,7 @@"@opennextjs/cloudflare": "^1.20.6","@openrouter/sdk": "1.4.18","@opentelemetry/api": "1.9.0",+ "@opentelemetry/sdk-trace-web": "2.11.0","@shikijs/core": "4.5.0","@shikijs/engine-oniguruma": "4.5.0","@shikijs/langs": "4.5.0",diff --git a/src/web/src/lib/observability/client.ts b/src/web/src/lib/observability/client.tsindex 0f09ddc7a..ce77650bc 100644--- a/src/web/src/lib/observability/client.ts+++ b/src/web/src/lib/observability/client.ts@@ -11,6 +11,7 @@ import { resolveCommunityModulePlan } from "../community/community-route"import { observeTransportSpan, finishTransportSpan, installNavigationFetchContext } from "./requests"import { resolveFrontendIdentity } from "./runtime"import { resolveObservationBuild } from "./build"+import { observationEpoch, finishTransportClock } from "./clock"type BuildProfile = { url?: string; environment?: string; release?: string; release_status: string; environment_status: string }function validBuildProfile(profile: BuildProfile) {@@ -75,8 +76,8 @@ async function activate() {configure()if (pendingInitialNavigation) { pendingInitialNavigation = false; beginNavigation(window.location.href, "document") }const capturedSession = sessionId- const [{ initializeFaro, FetchTransport: NativeFetchTransport, getWebInstrumentations, InternalLoggerLevel, VolatileSessionsManager }, { TracingInstrumentation, getDefaultOTELInstrumentations: createHttp }] = await Promise.all([- import("@grafana/faro-web-sdk"), import("@grafana/faro-web-tracing"),+ const [{ initializeFaro, FetchTransport: NativeFetchTransport, getWebInstrumentations, InternalLoggerLevel, VolatileSessionsManager }, { getDefaultOTELInstrumentations: createHttp }, { ObservationTracingInstrumentation }] = await Promise.all([+ import("@grafana/faro-web-sdk"), import("@grafana/faro-web-tracing"), import("./clock-tracing"),])clearNativeSession = () => VolatileSessionsManager.removeUserSession()if (documentSuspended || !hasAnalyticsConsent() || capturedSession !== sessionId || !isTelemetryEligible()) return@@ -91,7 +92,7 @@ async function activate() {let storedScope: string | undefinedtry { storedScope = VolatileSessionsManager.fetchUserSession()?.sessionMeta?.attributes?.alook_account } catch { clearNativeSession() }if (!mayResume || storedScope !== accountScope) clearNativeSession()- httpInstrumentations = createHttp({ fetchInstrumentationOptions: { requestHook: observeTransportSpan, applyCustomAttributesOnSpan: (span, _request, result) => finishTransportSpan(span, result) }, ignoreUrls: [build.url!], propagateTraceHeaderCorsUrls: [new RegExp("^" + window.location.origin.replace(/[.*+?^$(){}|[\]\\]/g, "\\$&") + "/")] })+ httpInstrumentations = createHttp({ fetchInstrumentationOptions: { requestHook: observeTransportSpan, applyCustomAttributesOnSpan: (span, _request, result) => finishTransportSpan(span, result) }, xhrInstrumentationOptions: { applyCustomAttributesOnSpan: finishTransportClock }, ignoreUrls: [build.url!], propagateTraceHeaderCorsUrls: [new RegExp("^" + window.location.origin.replace(/[.*+?^$(){}|[\]\\]/g, "\\$&") + "/")] })const defaults = getWebInstrumentations({ captureConsole: false, enableContentSecurityPolicyInstrumentation: false, enablePerformanceInstrumentation: true })const initialTransport = transportfaro = initializeFaro({@@ -100,7 +101,7 @@ async function activate() {dedupe: false,internalLoggerLevel: InternalLoggerLevel.OFF,transports: [transport],- instrumentations: [...defaults, new TracingInstrumentation({ instrumentations: httpInstrumentations })],+ instrumentations: [...defaults, new ObservationTracingInstrumentation({ instrumentations: httpInstrumentations })],sessionTracking: { enabled: true, persistent: false, samplingRate: 1, generateSessionId: telemetryId, session: { attributes: { alook_account: accountScope } }, onSessionChange: (_previous, next) => { if (next.id) adoptNativeSession(next.id) } },pageTracking: { generatePageId: () => pageId },trackGeolocation: false,@@ -108,7 +109,7 @@ async function activate() {ignoreUrls: [build.url!],webVitalsInstrumentation: { trackAttributionSources: false },batching: { enabled: true, itemLimit: 40, sendTimeout: 1000 },- beforeSend: item => hasAnalyticsConsent() && isTelemetryEligible() ? sanitizeItem(item, sessionId, window.location.origin, identity, eligibleTimestamp, documentVitalsEligible) : null,+ beforeSend: item => hasAnalyticsConsent() && isTelemetryEligible() ? sanitizeItem(item, sessionId, window.location.origin, identity, eligibleTimestamp, documentVitalsEligible, observationEpoch(eligibleSince)) : null,})const initialized = faro?.api.getSession()if (!faro || !initialized?.id || !/^[a-zA-Z0-9_-]{1,80}$/.test(initialized.id) || initialized.attributes?.alook_account !== accountScope) { deactivate(); return }diff --git a/src/web/src/lib/observability/clock-tracing.dom.test.ts b/src/web/src/lib/observability/clock-tracing.dom.test.tsnew file mode 100644index 000000000..ed9c74621--- /dev/null+++ b/src/web/src/lib/observability/clock-tracing.dom.test.ts@@ -0,0 +1,163 @@+import { afterEach, expect, it, vi } from "vitest"+import type { Faro } from "@grafana/faro-web-sdk"+import { act } from "@/test/react-dom-harness"+import { announceAnalyticsConsent } from "../analytics-consent"++const native = vi.hoisted(() => ({ faro: undefined as Faro | undefined }))+vi.mock("@grafana/faro-web-sdk", async importOriginal => {+ const real = await importOriginal<typeof import("@grafana/faro-web-sdk")>()+ return { ...real, initializeFaro: (...args: Parameters<typeof real.initializeFaro>) => { native.faro = real.initializeFaro(...args); return native.faro } }+})++afterEach(async () => {+ await act(async () => {+ document.cookie = "alook_analytics_consent=v1.denied; path=/"; announceAnalyticsConsent("denied")+ if (vi.isFakeTimers()) await vi.advanceTimersByTimeAsync(0)+ })+ vi.useRealTimers(); vi.restoreAllMocks(); vi.unstubAllEnvs(); vi.unstubAllGlobals()+})++it("normalizes real native HTTP exports and mirrors, retaining missing-hook and retired-session boundaries", async () => {+ vi.useFakeTimers(); sessionStorage.clear()+ vi.stubEnv("NEXT_PUBLIC_FARO_COLLECTOR_URL", "https://collector.example/collect/public")+ let now = 1000, drift = 230_000, mode = "success"+ vi.spyOn(performance, "now").mockImplementation(() => now)+ vi.spyOn(performance, "getEntriesByType").mockReturnValue([])+ vi.setSystemTime(performance.timeOrigin + now + drift)+ vi.spyOn(XMLHttpRequest.prototype, "open").mockImplementation(() => {})+ vi.spyOn(XMLHttpRequest.prototype, "send").mockImplementation(() => {})+ vi.spyOn(XMLHttpRequest.prototype, "setRequestHeader").mockImplementation(() => {})+ const sent: unknown[] = []+ let settle: ((response: Response) => void) | undefined+ vi.stubGlobal("fetch", vi.fn(async (input: unknown, options?: RequestInit) => {+ if (String(input) === "https://collector.example/collect/public") {+ if (options?.body) sent.push(JSON.parse(String(options.body)))+ return new Response(null, { status: 204 })+ }+ if (mode === "pending") return new Promise<Response>(resolve => { settle = resolve })+ now += 12+ if (mode !== "clone-failure" && mode !== "reader-failure") { drift *= -1; vi.setSystemTime(performance.timeOrigin + now + drift) }+ if (mode === "error") throw new TypeError("fixture failure")+ if (mode === "abort") throw new DOMException("fixture cancellation", "AbortError")+ const response = new Response(mode === "body" || mode === "reader-failure" ? "{}" : null, { status: mode === "http-error" ? 500 : 200 })+ if (mode === "clone-failure") vi.spyOn(response, "clone").mockImplementation(() => { throw new TypeError("fixture clone failure") })+ if (mode === "reader-failure") vi.spyOn(response, "clone").mockImplementation(() => {+ const clone = new Response("{}")+ Object.defineProperty(clone, "body", { value: { getReader: () => { throw new TypeError("fixture reader failure") } } })+ return clone+ })+ return response+ }))+ const consent = (value: "granted" | "denied") => { document.cookie = "alook_analytics_consent=v1." + value + "; path=/"; announceAnalyticsConsent(value) }+ consent("granted")+ const { bootstrapObservability, setTelemetryUser } = await import("./client")+ const { emitTelemetry } = await import("./telemetry")+ await act(async () => { bootstrapObservability("web"); setTelemetryUser("account-a") })+ await vi.waitFor(() => expect(native.faro).toBeDefined())+ const exported = () => {+ const spans: Record<string, unknown>[] = [], events: Array<{ name: string; attributes: Record<string, string>; trace?: { span_id: string } }> = []+ const visit = (value: unknown) => {+ if (!value || typeof value !== "object") return+ const row = value as Record<string, unknown>+ if (typeof row.spanId === "string") spans.push(row)+ if (typeof row.name === "string" && row.name.startsWith("faro.tracing.")) events.push(row as typeof events[number])+ for (const child of Object.values(row)) visit(child)+ }+ visit(sent)+ return { spans, events }+ }+ const flush = async () => { await vi.advanceTimersByTimeAsync(0); now += 4000; await vi.advanceTimersByTimeAsync(3000) }+ const path = "/api/agents"+ for (const next of ["success", "body", "error", "abort", "http-error"]) {+ mode = next; const start = now+ if (next === "error" || next === "abort") await expect(window.fetch(path)).rejects.toThrow()+ else await window.fetch(path)+ await flush()+ const { spans, events } = exported(), span = spans.filter(s => s.name === "GET /api/agents").at(-1)!+ expect(Number(span.startTimeUnixNano) / 1e6 - performance.timeOrigin).toBeCloseTo(start, 2)+ expect(Number(span.endTimeUnixNano) / 1e6 - performance.timeOrigin).toBeCloseTo(start + 12, 2)+ const mirror = events.find(e => e.trace?.span_id === span.spanId)!+ expect(mirror.name).toBe("faro.tracing.fetch")+ expect(Number(mirror.attributes.duration_ms)).toBeCloseTo(12, 2)+ if (next === "http-error") expect(span.status).toEqual({ code: 2 })+ }+ for (const event of ["load", "error", "abort", "timeout"]) {+ const start = now, xhr = new XMLHttpRequest()+ xhr.open("GET", "/api/workspaces"); xhr.send()+ now += 17; drift *= -1; vi.setSystemTime(performance.timeOrigin + now + drift)+ Object.defineProperty(xhr, "status", { value: event === "load" ? 200 : 0 })+ xhr.dispatchEvent(new Event(event))+ await flush()+ const { spans, events } = exported(), span = spans.filter(s => s.name === "GET /api/workspaces").at(-1)!+ expect(Number(span.startTimeUnixNano) / 1e6 - performance.timeOrigin).toBeCloseTo(start, 2)+ expect(Number(span.endTimeUnixNano) / 1e6 - performance.timeOrigin).toBeCloseTo(start + 17, 2)+ const mirror = events.find(e => e.trace?.span_id === span.spanId)!+ expect(mirror.name).toBe("faro.tracing.xml-http-request")+ expect(Number(mirror.attributes.duration_ms)).toBeCloseTo(17, 2)+ if (event === "error" || event === "timeout") expect(span.status).toEqual({ code: 2 })+ }+ drift = 230_000; vi.setSystemTime(performance.timeOrigin + now + drift)+ for (const next of ["clone-failure", "reader-failure"]) {+ mode = next; const wallStart = Date.now(), start = now+ await window.fetch("/api/community/users/me/notifications")+ await flush()+ const span = exported().spans.filter(s => s.name === "GET /api/community/users/me/notifications").at(-1)!+ expect(Number(span.startTimeUnixNano) / 1e6).toBeCloseTo(wallStart, 2)+ expect(Number(span.startTimeUnixNano) / 1e6 - performance.timeOrigin).not.toBeCloseTo(start, 2)+ }+ for (const retirement of ["consent", "account", "native-session"]) {+ mode = "pending"+ const pending = window.fetch("/api/community/channels/retired/messages")+ const retiredSession = native.faro!.api.getSession()!.id!+ now += 20+ if (retirement === "consent") { consent("denied"); consent("granted") }+ else if (retirement === "account") setTelemetryUser("account-b")+ else { vi.setSystemTime(Date.now() + 5 * 60 * 60 * 1000); emitTelemetry("business.result", { outcome: "success" }) }+ await vi.advanceTimersByTimeAsync(0)+ await vi.waitFor(() => expect(native.faro!.api.getSession()!.id).not.toBe(retiredSession))+ settle!(new Response(null, { status: 204 })); await pending; await flush()+ expect(exported().spans.some(s => s.name === "GET /api/community/channels/[id]/messages")).toBe(false)+ expect(exported().events.some(e => e.attributes.route_template === "/api/community/channels/[id]/messages")).toBe(false)+ }+ mode = "success"; const resumedStart = now+ await window.fetch(path); await flush()+ expect(Number(exported().spans.filter(s => s.name === "GET /api/agents").at(-1)!.startTimeUnixNano) / 1e6 - performance.timeOrigin).toBeCloseTo(resumedStart, 2)+ expect(JSON.stringify(sent)).not.toContain("alook.internal.http")+})++it("preserves public identity, links and explicit manual/preflight timing without normalizing unrelated or incomplete spans", async () => {+ vi.useRealTimers()+ const { SpanKind, SpanStatusCode, ROOT_CONTEXT, trace } = await import("@opentelemetry/api")+ const { WebTracerProvider, InMemorySpanExporter, SimpleSpanProcessor } = await import("@opentelemetry/sdk-trace-web")+ const { ObservationClockProcessor } = await import("./clock-tracing")+ const { observationTime, finishTransportClock, transportClockStart, transportClockEnd } = await import("./clock")+ let now = 400+ vi.spyOn(performance, "now").mockImplementation(() => now)+ const exporter = new InMemorySpanExporter(), processor = new ObservationClockProcessor(new SimpleSpanProcessor(exporter))+ const provider = new WebTracerProvider({ spanProcessors: [processor] })+ const manual = provider.getTracer("alook.frontend").startSpan("navigation", { startTime: observationTime(300) })+ const parent = manual.spanContext(), context = trace.setSpan(ROOT_CONTEXT, manual)+ const httpTracer = provider.getTracer("@opentelemetry/instrumentation-fetch", "0.222.0")+ const http = httpTracer.startSpan("GET", { kind: SpanKind.CLIENT, startTime: [1234, 0], links: [{ context: parent }] }, context)+ now = 500; finishTransportClock(http); http.setStatus({ code: SpanStatusCode.ERROR }); http.end([1235, 0])+ const preflight = httpTracer.startSpan("CORS Preflight", { kind: SpanKind.INTERNAL, startTime: observationTime(200) }, context)+ preflight.end(observationTime(250))+ const unrelated = provider.getTracer("alook.frontend").startSpan("explicit-client", { kind: SpanKind.CLIENT, startTime: observationTime(100), attributes: { [transportClockStart]: 400, [transportClockEnd]: 500 } })+ unrelated.end(observationTime(150))+ const incomplete = httpTracer.startSpan("missing-completion", { kind: SpanKind.CLIENT, startTime: [1234, 0] })+ now = 9000; incomplete.end([1235, 0]); manual.end(observationTime(900))+ await processor.forceFlush()+ const spans = exporter.getFinishedSpans(), normalized = spans.find(s => s.name === "GET")!+ expect(normalized.startTime).toEqual(observationTime(400)); expect(normalized.endTime).toEqual(observationTime(500)); expect(normalized.duration).toEqual([0, 100_000_000])+ expect(normalized.spanContext()).toEqual(http.spanContext()); expect(normalized.parentSpanContext).toEqual(parent)+ expect(normalized.links).toEqual([{ context: parent }]); expect(normalized.status).toEqual({ code: SpanStatusCode.ERROR })+ expect(normalized.instrumentationScope).toEqual({ name: "@opentelemetry/instrumentation-fetch", version: "0.222.0", schemaUrl: undefined })+ expect(spans.find(s => s.name === "CORS Preflight")!.startTime).toEqual(observationTime(200))+ expect(spans.find(s => s.name === "CORS Preflight")!.endTime).toEqual(observationTime(250))+ expect(spans.find(s => s.name === "explicit-client")!.startTime).toEqual(observationTime(100))+ expect(spans.find(s => s.name === "missing-completion")!.startTime).toEqual([1234, 0])+ expect(spans.find(s => s.name === "missing-completion")!.endTime).toEqual([1235, 0])+ expect(spans.find(s => s.name === "navigation")!.startTime).toEqual(observationTime(300))+ expect(spans.find(s => s.name === "navigation")!.endTime).toEqual(observationTime(900))+ await processor.shutdown()+})diff --git a/src/web/src/lib/observability/clock-tracing.ts b/src/web/src/lib/observability/clock-tracing.tsnew file mode 100644index 000000000..fffca6941--- /dev/null+++ b/src/web/src/lib/observability/clock-tracing.ts@@ -0,0 +1,55 @@+import { SpanKind, type Context, type HrTime } from "@opentelemetry/api"+import { BatchSpanProcessor, type ReadableSpan, type Span, type SpanProcessor } from "@opentelemetry/sdk-trace-web"+import { FaroMetaAttributesSpanProcessor, FaroTraceExporter, TracingInstrumentation, type TracingInstrumentationOptions } from "@grafana/faro-web-tracing"+import { observationTime, transportClockStart, transportClockEnd } from "./clock"++function nativeHttp(span: ReadableSpan) {+ return span.kind === SpanKind.CLIENT && ["@opentelemetry/instrumentation-fetch", "@opentelemetry/instrumentation-xml-http-request"].includes(span.instrumentationScope.name)+}++export class ObservationClockProcessor implements SpanProcessor {+ constructor(private readonly next: SpanProcessor) {}++ onStart(span: Span, parentContext: Context) {+ if (nativeHttp(span)) span.setAttribute(transportClockStart, performance.now())+ this.next.onStart(span, parentContext)+ }++ onEnd(span: ReadableSpan) {+ const start = span.attributes[transportClockStart], end = span.attributes[transportClockEnd]+ if (!nativeHttp(span) || typeof start !== "number" || typeof end !== "number" || !Number.isFinite(start) || !Number.isFinite(end) || start < 0 || end < start) {+ this.next.onEnd(span)+ return+ }+ const startTime = observationTime(start), endTime = observationTime(end)+ const duration: HrTime = [endTime[0] - startTime[0], endTime[1] - startTime[1]]+ if (duration[1] < 0) { duration[0]--; duration[1] += 1e9 }+ const projected: ReadableSpan = {+ name: span.name, kind: span.kind, spanContext: () => span.spanContext(), parentSpanContext: span.parentSpanContext,+ startTime, endTime, duration, status: span.status, attributes: span.attributes, links: span.links, events: span.events,+ ended: span.ended, resource: span.resource, instrumentationScope: span.instrumentationScope,+ droppedAttributesCount: span.droppedAttributesCount, droppedEventsCount: span.droppedEventsCount, droppedLinksCount: span.droppedLinksCount,+ }+ this.next.onEnd(projected)+ }++ forceFlush() { return this.next.forceFlush() }+ shutdown() { return this.next.shutdown() }+}++export class ObservationTracingInstrumentation extends TracingInstrumentation {+ private readonly nativeOptions: TracingInstrumentationOptions++ constructor(options: Omit<TracingInstrumentationOptions, "spanProcessor">) {+ const nativeOptions: TracingInstrumentationOptions = { ...options }+ super(nativeOptions)+ this.nativeOptions = nativeOptions+ }++ override initialize() {+ this.nativeOptions.spanProcessor = new FaroMetaAttributesSpanProcessor(new ObservationClockProcessor(new BatchSpanProcessor(new FaroTraceExporter({ api: this.api }), {+ scheduledDelayMillis: TracingInstrumentation.SCHEDULED_BATCH_DELAY_MS, maxExportBatchSize: 30,+ })), this.metas)+ super.initialize()+ }+}diff --git a/src/web/src/lib/observability/clock.ts b/src/web/src/lib/observability/clock.tsindex 17d24c26b..721d69d64 100644--- a/src/web/src/lib/observability/clock.ts+++ b/src/web/src/lib/observability/clock.ts@@ -1,4 +1,11 @@-import type { HrTime } from "@opentelemetry/api"+import type { HrTime, Span } from "@opentelemetry/api"++export const transportClockStart = "alook.internal.http.start_ms"+export const transportClockEnd = "alook.internal.http.end_ms"++export function finishTransportClock(span: Span) {+ span.setAttribute(transportClockEnd, performance.now())+}export function observationEpoch(now = performance.now()) {return performance.timeOrigin + nowdiff --git a/src/web/src/lib/observability/navigation-ready-trace.dom.test.tsx b/src/web/src/lib/observability/navigation-ready-trace.dom.test.tsxindex 2d89ad2ce..df3c34988 100644--- a/src/web/src/lib/observability/navigation-ready-trace.dom.test.tsx+++ b/src/web/src/lib/observability/navigation-ready-trace.dom.test.tsx@@ -25,10 +25,12 @@ it("binds the initial navigation before ready and parents a real native HTTP spavi.stubEnv("NEXT_PUBLIC_FARO_COLLECTOR_URL", "https://collector.example/collect/public")let now = 240vi.spyOn(performance, "now").mockImplementation(() => now)+ vi.setSystemTime(performance.timeOrigin + now + 230_000)vi.spyOn(performance, "getEntriesByType").mockReturnValue([])const sent: unknown[] = []vi.stubGlobal("fetch", vi.fn(async (url: unknown, options?: RequestInit) => {if (String(url) === "https://collector.example/collect/public" && options?.body) sent.push(JSON.parse(String(options.body)))+ else { now = 1012; vi.setSystemTime(Date.now() - 120_000) }return new Response(null, { status: 204 })}))document.cookie = "alook_analytics_consent=v1.granted; path=/"@@ -81,6 +83,12 @@ it("binds the initial navigation before ready and parents a real native HTTP spaexpect(ready).toHaveLength(1)expect(ready[0]?.attributes).toMatchObject({ navigation_kind: "document", start_ms: "0", duration_ms: "1250", trace_id: parent.traceId, span_id: parent.spanId, action_id: navigation.id })const http = spans.find(span => span.parentSpanId === parent.spanId)!+ expect(Number(http.startTimeUnixNano) / 1e6 - performance.timeOrigin).toBeCloseTo(900, 2)+ expect(Number(http.endTimeUnixNano) / 1e6 - performance.timeOrigin).toBeCloseTo(1012, 2)+ const mirrors = events.filter(event => event.name === "faro.tracing.fetch")+ expect(mirrors).toHaveLength(1)+ expect(Number(mirrors[0]!.attributes.duration_ms)).toBeCloseTo(112, 2)+ expect(JSON.stringify(sent)).not.toContain("alook.internal.http")const requests = events.filter(event => event.name.startsWith("request."))expect(requests.map(event => event.name)).toEqual(["request.start", "request.headers", "request.finish"])expect(requests[0]?.attributes).toMatchObject({ trace_id: parent.traceId, span_id: parent.spanId })diff --git a/src/web/src/lib/observability/requests.ts b/src/web/src/lib/observability/requests.tsindex f332ea6ab..05bd0af4a 100644--- a/src/web/src/lib/observability/requests.ts+++ b/src/web/src/lib/observability/requests.ts@@ -3,6 +3,7 @@ import { routeTemplate } from "./coverage"import { emitTelemetry, isTelemetryEligible, telemetryGeneration } from "./telemetry"import { cleanAttributes, type Attributes } from "./schema"import { context, trace, createContextKey, type Span } from "@opentelemetry/api"+import { finishTransportClock } from "./clock"export type RequestObservation = { id: string; start: number; generation: number; fields: Attributes; done: boolean; action?: Action }const responses = new WeakMap<Response, RequestObservation>()@@ -33,6 +34,7 @@ export function observeTransportSpan(span: Span) {}export function finishTransportSpan(span: Span, result: unknown) {+ finishTransportClock(span)const request = transportRequests.get(span)transportRequests.delete(span)if (request?.fields.request_kind !== "rsc") returndiff --git a/src/web/src/lib/observability/sanitize.test.ts b/src/web/src/lib/observability/sanitize.test.tsindex 299f35bf4..0c7f9d259 100644--- a/src/web/src/lib/observability/sanitize.test.ts+++ b/src/web/src/lib/observability/sanitize.test.ts@@ -101,6 +101,24 @@ describe("outbound whitelist", () => {expect(sanitizeItem(old, session, origin)).toBeNull()})+ it("uses canonical admission for both HTTP exports while retaining wall-time checks for other SDK payloads", () => {+ const mirror = { type: "event", meta, payload: { name: "faro.tracing.fetch", timestamp: "1970-01-01T00:00:02Z", attributes: { "session.id": session, duration_ns: "1000000000", "alook.internal.http.start_ms": "SECRET" } } } as TransportItem+ const span = { traceId: "a".repeat(32), spanId: "b".repeat(16), name: "GET", kind: 3, startTimeUnixNano: "1000000000", endTimeUnixNano: "2000000000", attributes: [{ key: "session.id", value: { stringValue: session } }, { key: "alook.internal.http.start_ms", value: { stringValue: "SECRET" } }] }+ const trace = { type: "trace", meta, payload: { resourceSpans: [{ scopeSpans: [{ spans: [span] }] }] } } as TransportItem+ for (const item of [mirror, trace]) {+ expect(sanitizeItem(item, session, origin, undefined, 230_000, true, 500)).not.toBeNull()+ expect(JSON.stringify(sanitizeItem(item, session, origin, undefined, 230_000, true, 500))).not.toContain("SECRET")+ expect(sanitizeItem(item, session, origin, undefined, 230_000, true, 1500)).toBeNull()+ expect(sanitizeItem(item, "retired-session", origin, undefined, 230_000, true, 500)).toBeNull()+ }+ for (const item of [+ { type: "event", meta, payload: { name: "faro.performance.resource", timestamp: "1970-01-01T00:00:02Z", attributes: { duration: "1" } } },+ { type: "exception", meta, payload: { type: "Error", value: "SECRET", timestamp: "1970-01-01T00:00:02Z" } },+ { type: "measurement", meta, payload: { type: "web-vitals", timestamp: "1970-01-01T00:00:02Z", values: { LCP: 1 } } },+ { type: "event", meta, payload: { name: "faro.user.action", timestamp: "1970-01-01T00:00:02Z", attributes: { userActionName: "ui_interaction", userActionStartTime: "1000" } } },+ ]) expect(sanitizeItem(item as TransportItem, session, origin, undefined, 230_000, true, 500)).toBeNull()+ })+it("retains only known native action names and finite nonnegative action timings", () => {const item = (attributes: Record<string, string>) => ({ type: "event", meta, payload: { name: "faro.user.action", timestamp: "2026-10-05T00:00:00Z", attributes } }) as TransportItemconst clean = sanitizeItem(item({ userActionName: "ui_interaction", userActionDuration: "12", userActionStartTime: "0", userActionEndTime: "Infinity", private: "SECRET" }), session, origin)!diff --git a/src/web/src/lib/observability/sanitize.ts b/src/web/src/lib/observability/sanitize.tsindex 3a086f397..bfc30909e 100644--- a/src/web/src/lib/observability/sanitize.ts+++ b/src/web/src/lib/observability/sanitize.ts@@ -65,7 +65,7 @@ export function sanitizeTrace(input: unknown, sessionId: string, origin: string,return resources.length ? { resourceSpans: resources } : null}-export function sanitizeItem(item: TransportItem, sessionId: string, origin: string, identity?: Partial<FrontendIdentity>, since = 0, documentVitalsEligible = true): TransportItem | null {+export function sanitizeItem(item: TransportItem, sessionId: string, origin: string, identity?: Partial<FrontendIdentity>, since = 0, documentVitalsEligible = true, spanSince = since): TransportItem | null {if (item.meta.session?.id !== sessionId) return nullconst sdk = item.meta.sdkif (sdk?.name !== "faro-web" || !/^\d{1,3}\.\d{1,3}\.\d{1,3}(?:-[a-zA-Z0-9.-]{1,32})?$/.test(sdk.version ?? "")) return null@@ -100,7 +100,7 @@ export function sanitizeItem(item: TransportItem, sessionId: string, origin: str}if (payload.name.startsWith("faro.tracing.")) {const fields = payload.attributes ?? {}- if (!(Date.parse(payload.timestamp) - Number(fields.duration_ns) / 1e6 >= since)) return null+ if (!(Date.parse(payload.timestamp) - Number(fields.duration_ns) / 1e6 >= spanSince)) return nullconst url = String(fields["url.full"] ?? fields["http.url"] ?? "")let kind = "unknown"try { const parsed = new URL(url, origin); kind = parsed.origin !== origin ? "external" : parsed.searchParams.has("_rsc") ? "rsc" : parsed.pathname.startsWith("/api/") ? "api" : "resource" } catch {}@@ -137,7 +137,7 @@ export function sanitizeItem(item: TransportItem, sessionId: string, origin: strreturn Object.keys(values).length ? { ...item, meta: documentMeta, payload: { type: payload.type, timestamp: payload.timestamp, values } } : null}if (item.type === "trace") {- const payload = sanitizeTrace(item.payload, sessionId, origin, { ...identity, release: item.meta.app?.release, environment: item.meta.app?.environment }, since)+ const payload = sanitizeTrace(item.payload, sessionId, origin, { ...identity, release: item.meta.app?.release, environment: item.meta.app?.environment }, spanSince)return payload ? { ...item, meta, payload: payload as TraceEvent } : null}return null