Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(web): align native HTTP spans with the frontend observation clock

Gener95d67f6c092c
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 77d44074e..52e7b08db 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -322,6 +322,9 @@ importers:
'@opentelemetry/api':
specifier: 1.9.0
version: 1.9.0
+ '@opentelemetry/sdk-trace-web':
+ specifier: 2.11.0
+ version: 2.11.0(@opentelemetry/[email protected])
'@shikijs/core':
specifier: 4.5.0
version: 4.5.0
diff --git a/src/web/package.json b/src/web/package.json
index 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.ts
index 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 | undefined
try { 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 = transport
faro = 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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 + now
diff --git a/src/web/src/lib/observability/navigation-ready-trace.dom.test.tsx b/src/web/src/lib/observability/navigation-ready-trace.dom.test.tsx
index 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 spa
vi.stubEnv("NEXT_PUBLIC_FARO_COLLECTOR_URL", "https://collector.example/collect/public")
let now = 240
vi.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 spa
expect(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.ts
index 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") return
diff --git a/src/web/src/lib/observability/sanitize.test.ts b/src/web/src/lib/observability/sanitize.test.ts
index 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 TransportItem
const 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.ts
index 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 null
const sdk = item.meta.sdk
if (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 null
const 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: str
return 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