Multiplayer agent harness for work.
Add sampled Sentry performance tracing (#1410)
Regan Bell62e07918a572
diff --git a/docs/error-reporting.md b/docs/error-reporting.mdindex 475142495..579405392 100644--- a/docs/error-reporting.md+++ b/docs/error-reporting.md@@ -6,8 +6,16 @@ Use a separate project for deployments with different operators or data boundariReporting captures uncaught exceptions, unhandled promise rejections, HTTP handler and authentication delivery failures, and the core's operator error records. Recorded failures carry `error_code` and a matching grouping fingerprint. Recorded exceptions preserve their original stack; records without an exception carry the recording call's stack. Repeated capture of the same error object is deduplicated by the SDK. Ordinary console logs and expected failures outside these boundaries are not reported.-Only error events are enabled. Tracing, profiling, logs, replay, request instrumentation, and breadcrumbs are disabled. Before transmission, an allowlist retains timestamps, release/environment, service/deployment, internal failure codes, built-in exception type, stack filenames, function names and line/column numbers, and handled status. Raw error messages, request bodies and headers, URLs, users, local variables, source context, ambient tags, and extras are discarded. Full error details remain in existing application logs. Deployment labels and release values must not contain secrets or personal data.+Only error events are enabled by default. Profiling, logs, replay, request instrumentation, and breadcrumbs are disabled. Sampled performance tracing is described below. Before transmission, an allowlist retains timestamps, release/environment, service/deployment, internal failure codes, built-in exception type, stack filenames, function names and line/column numbers, and handled status. Raw error messages, request bodies and headers, URLs, users, local variables, source context, ambient tags, and extras are discarded. Full error details remain in existing application logs. Deployment labels and release values must not contain secrets or personal data.The SDK preserves existing fatal-error drain handlers. When no rejection handler exists it flushes and exits unsuccessfully. Core's explicit shutdown paths and web startup failures allow up to two seconds for pending error delivery. Delivery is best effort and never a substitute for application logs or infrastructure health alarms.After deployment, verify a synthetic backend failure reaches the intended project with the expected release, environment, deployment and service. Check that its stack is readable and its payload contains no application content. Test alerts against that event before relying on notifications. Disable reporting by removing `SENTRY_DSN` and redeploying; retain the prior immutable application candidate for code rollback.++## Optional performance tracing++Set `SENTRY_TRACES_SAMPLE_RATE` (a fraction between 0 and 1; unset, 0, or an invalid value keeps tracing off) on a backend service that already has `SENTRY_DSN` to sample transactions. Start with `0.1`. Tracing enables the SDK's OpenTelemetry tracer for manual spans only; no automatic HTTP, database, model, or tool instrumentation is registered, so transactions contain no child spans and no trace headers are propagated to other services.++The core reports one transaction per sampled HTTP request except `/healthz` (`http.server`, named by the registered route template such as `GET /v1/sessions/:id`; unregistered or pattern-matched paths are reported as `METHOD /*` and deployment subdomain proxying as `/deployment-proxy/*`) and one per terminal run (`queue.task` `run`, with a `queue_wait` measurement and `surface` and `origin` tags drawn from fixed lists). Every transaction is rebuilt from an allowlist before transmission: timestamps, release, environment, service, deployment, the fixed name, span status, an HTTP status code, and millisecond measurements. Raw URLs, query strings, headers, bodies, user identifiers, host names, and span attributes are discarded.++Browser timing uses `SENTRY_BROWSER_TRACES_SAMPLE_RATE` on the web server together with `SENTRY_BROWSER_DSN`; see the web-ui README.diff --git a/plugins/chassis/src/error-reporting.ts b/plugins/chassis/src/error-reporting.tsindex 6ac1cdc31..c1f1d1cbd 100644--- a/plugins/chassis/src/error-reporting.ts+++ b/plugins/chassis/src/error-reporting.ts@@ -1,5 +1,7 @@import type * as Sentry from "@sentry/node";import { basename } from "node:path";+import { finishTiming, parseSampleRate, sanitizeTransactionEvent, type TimingResult } from "./timing.ts";+import { swallow } from "./errors.ts";const FLUSH_MS = 2_000;const ERROR_TYPES = new Set([@@ -13,6 +15,7 @@ const ERROR_TYPES = new Set(["AggregateError",]);let client: typeof Sentry | undefined;+let tracing = false;export function sanitizeErrorEvent(event: Sentry.ErrorEvent): Sentry.ErrorEvent {const frames = (items: Sentry.StackFrame[] | undefined) =>@@ -61,6 +64,7 @@ export function initializeErrorReporting(env: NodeJS.ProcessEnv = process.env,): void {if (!env.SENTRY_DSN || client) return;+ const tracesSampleRate = parseSampleRate(env.SENTRY_TRACES_SAMPLE_RATE);sdk.init({dsn: env.SENTRY_DSN,environment: env.SENTRY_ENVIRONMENT ?? env.NODE_ENV ?? "development",@@ -68,16 +72,20 @@ export function initializeErrorReporting(serverName: "",defaultIntegrations: false,integrations: [sdk.onUncaughtExceptionIntegration()],- skipOpenTelemetrySetup: true,+ skipOpenTelemetrySetup: tracesSampleRate === 0,+ ...(tracesSampleRate > 0 ? { tracesSampleRate } : {}),+ tracePropagationTargets: [],sendDefaultPii: false,maxBreadcrumbs: 0,attachStacktrace: true,sendClientReports: false,initialScope: { tags: { service, deployment: env.SENTRY_DEPLOYMENT ?? env.ORG_ID ?? env.CORE_ORG_ID } },beforeSend: sanitizeErrorEvent,+ beforeSendTransaction: (event) => sanitizeTransactionEvent(event, "node"),shutdownTimeout: FLUSH_MS,});client = sdk;+ tracing = tracesSampleRate > 0;process.on("unhandledRejection", (reason: unknown) => {sdk.captureException(reason, {captureContext: { level: "fatal" },@@ -94,6 +102,19 @@ export function reportBackendError(error: unknown, code?: string): void {client?.captureException(error, { tags: code && /^[a-zA-Z0-9_.:-]{1,120}$/.test(code) ? { error_code: code } : {} });}+export type FinishTiming = (result: TimingResult) => void;++export function startTiming(op: string, name: string, startMs = Date.now()): FinishTiming | undefined {+ if (!client || !tracing) return undefined;+ try {+ const span = client.startInactiveSpan({ op, name, startTime: startMs, attributes: { "sentry.source": "route" } });+ return (result) => finishTiming(client!, span, result);+ } catch (error) {+ swallow("timing", error);+ return undefined;+ }+}+export async function flushErrorReporting(): Promise<void> {try {await client?.flush(FLUSH_MS);diff --git a/plugins/chassis/src/timing.ts b/plugins/chassis/src/timing.tsnew file mode 100644index 000000000..4c9550a4b--- /dev/null+++ b/plugins/chassis/src/timing.ts@@ -0,0 +1,177 @@+import type * as Sentry from "@sentry/node";+import { swallow } from "./errors.ts";++export type TransactionEvent = Sentry.Event & { type: "transaction" };++export type TimingStatus =+ | "ok"+ | "cancelled"+ | "unauthenticated"+ | "permission_denied"+ | "not_found"+ | "resource_exhausted"+ | "invalid_argument"+ | "internal_error";++export interface TimingResult {+ name?: string;+ status: TimingStatus;+ endMs?: number;+ data?: Record<string, string | undefined>;+ measurements?: Record<string, number | undefined>;+}++export type TimingSdk = Pick<typeof Sentry, "setMeasurement">;+const SPAN_STATUS_OK = 1;+const SPAN_STATUS_ERROR = 2;++const NAME = /^[A-Z]{3,7} (\/(v[0-9]{1,3}|[a-z][a-z-]{0,31}|:[a-zA-Z]{1,32}|\*)){1,10}$|^(run|pageload)$/;+const OPS = new Set(["http.server", "http.client", "queue.task", "pageload"]);+const STATUSES = new Set<string>([+ "ok",+ "cancelled",+ "unauthenticated",+ "permission_denied",+ "not_found",+ "resource_exhausted",+ "invalid_argument",+ "internal_error",+]);+const TAG_KEYS = new Set(["service", "deployment"]);+const TAG_VALUE = /^[a-zA-Z0-9_.:-]{1,64}$/;+const HTTP_STATUS = /^([1-5][0-9]{2}|network)$/;+const setHas = (values: string[]) => {+ const set = new Set(values);+ return (value: string) => set.has(value);+};+const BUCKETS: Record<string, (value: string) => boolean> = {+ surface: setHas([+ "core",+ "cron",+ "external",+ "inbound_file",+ "keychain-ask",+ "loop",+ "monitor",+ "secret-drop",+ "shared_skill",+ "slack",+ "steer",+ "swarm",+ "web",+ "webhook",+ ]),+ origin: setHas(["direct", "human", "ambient", "automation"]),+ page: setHas([+ "calendar",+ "chats",+ "contexts",+ "crons",+ "deploys",+ "files",+ "inbox",+ "keychain",+ "loops",+ "memory",+ "settings",+ "skills",+ "webhooks",+ ]),+ http_status: (value) => HTTP_STATUS.test(value),+};+const MEASUREMENTS = new Set(["queue_wait", "ttfb", "dom_content_loaded", "load", "fcp", "lcp"]);+const HEX = /^[a-f0-9]+$/;++export function parseSampleRate(value: string | undefined): number {+ const rate = Number(value ?? 0);+ return Number.isFinite(rate) && rate >= 0 && rate <= 1 ? rate : 0;+}++export function traceStatus(httpStatus: number): TimingStatus {+ if (httpStatus < 400) return "ok";+ if (httpStatus === 401) return "unauthenticated";+ if (httpStatus === 403) return "permission_denied";+ if (httpStatus === 404) return "not_found";+ if (httpStatus === 429) return "resource_exhausted";+ if (httpStatus < 500) return "invalid_argument";+ return "internal_error";+}++export function finishTiming(sdk: TimingSdk, span: Sentry.Span, result: TimingResult): void {+ try {+ if (result.name) span.updateName(result.name);+ span.setStatus(+ result.status === "ok" ? { code: SPAN_STATUS_OK } : { code: SPAN_STATUS_ERROR, message: result.status },+ );+ for (const [key, value] of Object.entries(result.data ?? {}))+ if (value !== undefined) span.setAttribute(key, value);+ for (const [key, value] of Object.entries(result.measurements ?? {}))+ if (value !== undefined && Number.isFinite(value) && value >= 0)+ sdk.setMeasurement(key, Math.round(value), "millisecond", span);+ span.end(result.endMs ?? Date.now());+ } catch (error) {+ swallow("timing", error);+ }+}++function scopeTags(tags: Record<string, unknown>): Record<string, string> {+ return Object.fromEntries(+ Object.entries(tags).filter(+ ([key, value]) => TAG_KEYS.has(key) && typeof value === "string" && TAG_VALUE.test(value),+ ),+ ) as Record<string, string>;+}++function bucketed(data: Record<string, unknown>): Record<string, string> {+ return Object.fromEntries(+ Object.entries(data)+ .filter(([key, value]) => Object.hasOwn(BUCKETS, key) && typeof value === "string")+ .map(([key, value]) => [key, BUCKETS[key]!(value as string) ? (value as string) : "other"]),+ );+}++export function sanitizeTransactionEvent(+ event: TransactionEvent,+ platform: "node" | "javascript",+): TransactionEvent | null {+ const trace = event.contexts?.trace;+ const measurements: NonNullable<Sentry.Event["measurements"]> = event.measurements ?? {};+ const start = event.start_timestamp;+ const end = event.timestamp;+ if (+ !NAME.test(event.transaction ?? "") ||+ typeof start !== "number" ||+ typeof end !== "number" ||+ !Number.isFinite(start) ||+ !Number.isFinite(end) ||+ end < start ||+ !trace ||+ !HEX.test(trace.trace_id ?? "") ||+ !HEX.test(trace.span_id ?? "") ||+ !OPS.has(trace.op ?? "") ||+ !STATUSES.has(trace.status ?? "")+ )+ return null;+ return {+ type: "transaction",+ event_id: HEX.test(event.event_id ?? "") ? event.event_id : undefined,+ transaction: event.transaction,+ transaction_info: { source: "route" },+ start_timestamp: start,+ timestamp: end,+ platform,+ environment: event.environment,+ release: event.release,+ tags: { ...scopeTags(event.tags ?? {}), ...bucketed(trace.data ?? {}) },+ contexts: {+ trace: { trace_id: trace.trace_id, span_id: trace.span_id, op: trace.op, status: trace.status, origin: "manual" },+ },+ measurements: Object.fromEntries(+ Object.entries(measurements).filter(+ ([key, measurement]) =>+ MEASUREMENTS.has(key) && Number.isFinite(measurement.value) && measurement.unit === "millisecond",+ ),+ ),+ spans: [],+ };+}diff --git a/plugins/web-ui/README.md b/plugins/web-ui/README.mdindex 7d026866f..e625a3635 100644--- a/plugins/web-ui/README.md+++ b/plugins/web-ui/README.md@@ -339,6 +339,19 @@ and tracing are excluded. A final transport gate rejects unsanitized SDK failureand non-event envelopes. Requests omit cookies and referrers. The ingestionserver can still see the network source IP. Delivery is best effort.+### Browser performance timing++Set `SENTRY_BROWSER_TRACES_SAMPLE_RATE` (0 to 1, default 0) alongside `SENTRY_BROWSER_DSN` to sample+browser timings; `0.1` is a reasonable start. Each timing is sampled independently at that rate+and carries its own random trace id. A page reports one `pageload` transaction (time to first+byte, DOM content loaded, load, first and largest contentful paint, and a `page` tag drawn from+the fixed list of application views) and one `http.client` transaction per same-origin request+made through the web client's shared fetch helper, measured to response headers and named by a+fixed `/api/<resource>` allowlist (`GET /api/sessions/*`) with the HTTP status. At most 200+timings are sent per page. URLs, query strings, identifiers, and request or response content are+never included; timings stop with error reporting on sign-out, authentication failure, and+impersonation.+## Personal AI accountsOpen **Settings → AI access**, or use the account label beside the model picker.diff --git a/plugins/web-ui/server/browser-error-config.ts b/plugins/web-ui/server/browser-error-config.tsindex a0a383e15..c1d46f582 100644--- a/plugins/web-ui/server/browser-error-config.ts+++ b/plugins/web-ui/server/browser-error-config.ts@@ -1,4 +1,8 @@-export function browserErrorConfig(env: NodeJS.ProcessEnv): { dsn: string; release?: string } | undefined {+import { parseSampleRate } from "../../chassis/src/timing.ts";++export function browserErrorConfig(+ env: NodeJS.ProcessEnv,+): { dsn: string; release?: string; tracesSampleRate?: number } | undefined {const dsn = env.SENTRY_BROWSER_DSN?.trim();if (!dsn) return undefined;const invalid = () => new Error("SENTRY_BROWSER_DSN must be a public HTTPS DSN without a secret key");@@ -19,8 +23,10 @@ export function browserErrorConfig(env: NodeJS.ProcessEnv): { dsn: string; releathrow invalid();}const release = env.SENTRY_RELEASE ?? env.GIT_SHA;+ const tracesSampleRate = parseSampleRate(env.SENTRY_BROWSER_TRACES_SAMPLE_RATE);return {dsn: url.href,...(release && /^[a-zA-Z0-9_.@+-]{1,128}$/.test(release) ? { release } : {}),+ ...(tracesSampleRate ? { tracesSampleRate } : {}),};}diff --git a/plugins/web-ui/src/browser-errors.ts b/plugins/web-ui/src/browser-errors.tsindex 8a64c098b..8a86a6447 100644--- a/plugins/web-ui/src/browser-errors.ts+++ b/plugins/web-ui/src/browser-errors.ts@@ -1,5 +1,14 @@+import type * as Browser from "@sentry/browser";import type { init, ErrorEvent, StackFrame } from "@sentry/browser";import type { Me } from "./shell-state";+import { parseDeepLink, UI_BASE } from "./deep-link.ts";+import {+ finishTiming,+ sanitizeTransactionEvent,+ traceStatus,+ type TimingResult,+ type TransactionEvent,+} from "../../chassis/src/timing.ts";const ERROR_TYPES = new Set(["Error",@@ -12,8 +21,46 @@ const ERROR_TYPES = new Set(["AggregateError","UnhandledRejection",]);+const MAX_TIMINGS_PER_PAGE = 200;+const API_RESOURCES = new Set([+ "approvals",+ "blobs",+ "channel-header-pin",+ "composio",+ "connectors",+ "contexts",+ "crons",+ "deliveries",+ "deployments",+ "directory",+ "files",+ "inbox",+ "keychain",+ "loops",+ "memory",+ "playgrounds",+ "projects",+ "resources",+ "runs",+ "runtime-config",+ "scope-resources",+ "search",+ "sessions",+ "skills",+ "slack-installation",+ "suggested-activities",+ "surface-config",+ "turn",+ "ui-state",+ "user-model-auth",+ "webhooks",+]);let client: ReturnType<typeof init>;+let sdk: typeof Browser | undefined;let generation = 0;+let timingBudget = 0;+let largestContentfulPaint: number | undefined;+let pageLoadReported = false;function safeFrame(frame: StackFrame, origin: string): StackFrame[] {try {@@ -67,8 +114,91 @@ export function sanitizeBrowserError(event: ErrorEvent, origin: string, release?return sanitized;}+function timing(op: string, name: string, startMs: number, result: TimingResult): void {+ if (!client || !sdk || timingBudget <= 0) return;+ timingBudget--;+ try {+ sdk.getCurrentScope().setPropagationContext({ traceId: hex(16), sampleRand: Math.random() });+ const span = sdk.startInactiveSpan({ op, name, startTime: startMs, attributes: { "sentry.source": "route" } });+ finishTiming(sdk, span, result);+ } catch {+ return;+ }+}++function hex(bytes: number): string {+ return Array.from(crypto.getRandomValues(new Uint8Array(bytes)), (b) => b.toString(16).padStart(2, "0")).join("");+}++export function apiRouteName(pathname: string): string {+ const segments = pathname.split("/").filter(Boolean);+ const api = segments.indexOf("api");+ const resource = segments[api + 1];+ if (api < 0 || !resource || !API_RESOURCES.has(resource)) return "/*";+ return `/api/${resource}${segments.length > api + 2 ? "/*" : ""}`;+}++export function reportRequestTiming(url: string, method: string, startMs: number, status: number | null): void {+ if (!client) return;+ let target: URL;+ try {+ target = new URL(url, window.location.origin);+ } catch {+ return;+ }+ if (target.origin !== window.location.origin) return;+ timing("http.client", `${/^[A-Z]{3,7}$/.test(method) ? method : "GET"} ${apiRouteName(target.pathname)}`, startMs, {+ status: status === null ? "internal_error" : traceStatus(status),+ data: { http_status: status === null ? "network" : String(status) },+ });+}++function reportPageLoad(): void {+ try {+ const navigation = performance.getEntriesByType("navigation")[0] as PerformanceNavigationTiming | undefined;+ if (!navigation?.loadEventEnd) return;+ const paint = (name: string) => performance.getEntriesByName(name)[0]?.startTime;+ const { view } = parseDeepLink(UI_BASE, window.location.pathname, "");+ timing("pageload", "pageload", performance.timeOrigin, {+ status: "ok",+ endMs: performance.timeOrigin + navigation.loadEventEnd,+ data: { page: view ?? "other" },+ measurements: {+ ttfb: navigation.responseStart,+ dom_content_loaded: navigation.domContentLoadedEventEnd,+ load: navigation.loadEventEnd,+ fcp: paint("first-contentful-paint"),+ lcp: largestContentfulPaint,+ },+ });+ } catch {+ return;+ }+}++function startTiming(rate: number): void {+ timingBudget = rate > 0 ? MAX_TIMINGS_PER_PAGE : 0;+ if (!timingBudget || pageLoadReported) return;+ pageLoadReported = true;+ try {+ new PerformanceObserver((list) => {+ for (const entry of list.getEntries()) largestContentfulPaint = entry.startTime;+ }).observe({ type: "largest-contentful-paint", buffered: true });+ } catch {+ largestContentfulPaint = undefined;+ }+ try {+ const report = () => setTimeout(reportPageLoad, 500);+ if (document.readyState === "complete") report();+ else window.addEventListener("load", report, { once: true });+ } catch {+ return;+ }+}+export function stopBrowserErrors(): void {generation++;+ timingBudget = 0;if (client) client.getOptions().enabled = false;client = undefined;}@@ -77,26 +207,28 @@ export async function initializeBrowserErrors(me: Me): Promise<void> {stopBrowserErrors();if (!me.browserErrors?.dsn || me.impersonatedBy) return;const current = generation;- const { dsn, release } = me.browserErrors;+ const { dsn, release, tracesSampleRate } = me.browserErrors;+ const rate = tracesSampleRate && tracesSampleRate > 0 && tracesSampleRate <= 1 ? tracesSampleRate : 0;try {- const sdk = await import("@sentry/browser");+ const browser = await import("@sentry/browser");if (current !== generation) return;- const safeEvents = new WeakSet<ErrorEvent>();- client = sdk.init({+ sdk = browser;+ const safeEvents = new WeakSet<ErrorEvent | TransactionEvent>();+ client = browser.init({dsn,release,defaultIntegrations: false,- integrations: [sdk.globalHandlersIntegration()],+ integrations: [browser.globalHandlersIntegration()],sendDefaultPii: false,maxBreadcrumbs: 0,attachStacktrace: true,sendClientReports: false,enableLogs: false,- tracesSampleRate: 0,+ tracesSampleRate: rate,tracePropagationTargets: [],transportOptions: { fetchOptions: { credentials: "omit", referrerPolicy: "no-referrer" } },transport: (options) => {- const transport = sdk.makeFetchTransport(options);+ const transport = browser.makeFetchTransport(options);return {flush: (timeout) => transport.flush(timeout),send: (envelope) => {@@ -104,8 +236,8 @@ export async function initializeBrowserErrors(me: Me): Promise<void> {if (current !== generation ||envelope[1].length !== 1 ||- item?.[0].type !== "event" ||- !safeEvents.has(item[1] as ErrorEvent)+ (item?.[0].type !== "event" && item?.[0].type !== "transaction") ||+ !safeEvents.has(item[1] as ErrorEvent | TransactionEvent))return Promise.resolve({});return transport.send(envelope);@@ -119,8 +251,15 @@ export async function initializeBrowserErrors(me: Me): Promise<void> {safeEvents.add(sanitized);return sanitized;},+ beforeSendTransaction: (event) => {+ if (current !== generation) return null;+ const sanitized = sanitizeTransactionEvent(event, "javascript");+ if (sanitized) safeEvents.add(sanitized);+ return sanitized;+ },});} catch {if (current === generation) client = undefined;}+ if (client) startTiming(rate);}diff --git a/plugins/web-ui/src/core-bridge.ts b/plugins/web-ui/src/core-bridge.tsindex 3d6e9680d..706f06b50 100644--- a/plugins/web-ui/src/core-bridge.ts+++ b/plugins/web-ui/src/core-bridge.ts@@ -1,4 +1,4 @@-import { stopBrowserErrors } from "./browser-errors.ts";+import { reportRequestTiming, stopBrowserErrors } from "./browser-errors.ts";import { captureMessage, stopAnalytics } from "./product-analytics.ts";import { streamedAnswer } from "./timeline.ts";import { EventType } from "@tanstack/ai/client";@@ -674,7 +674,18 @@ export function reportSigninRequired(detail: SigninRequired): void {}export async function webFetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {- const response = await fetch(input, init);+ const startMs = Date.now();+ const request = input instanceof Request ? input : null;+ const url = request?.url ?? String(input);+ const method = init?.method ?? request?.method ?? "GET";+ let response: Response;+ try {+ response = await fetch(input, init);+ } catch (error) {+ reportRequestTiming(url, method, startMs, null);+ throw error;+ }+ reportRequestTiming(url, method, startMs, response.status);if (response.status !== 401) return response;stopBrowserErrors();stopAnalytics();diff --git a/plugins/web-ui/src/shell-state.ts b/plugins/web-ui/src/shell-state.tsindex 8e2abeda3..390bbed9a 100644--- a/plugins/web-ui/src/shell-state.ts+++ b/plugins/web-ui/src/shell-state.ts@@ -3,7 +3,7 @@ import type { SuggestedActivity } from "../../chassis/src/suggested-activities.texport type AuthMode = "portal" | "dev";export interface Me {- browserErrors?: { dsn: string; release?: string };+ browserErrors?: { dsn: string; release?: string; tracesSampleRate?: number };analytics?: { apiKey: string; host: string };companyName?: string | null;welcomeCohort?: string;diff --git a/plugins/web-ui/test/browser-timing.test.ts b/plugins/web-ui/test/browser-timing.test.tsnew file mode 100644index 000000000..4565051dc--- /dev/null+++ b/plugins/web-ui/test/browser-timing.test.ts@@ -0,0 +1,199 @@+import assert from "node:assert/strict";+import { test } from "node:test";+import {+ apiRouteName,+ initializeBrowserErrors,+ reportRequestTiming,+ stopBrowserErrors,+} from "../src/browser-errors.ts";+import { browserErrorConfig } from "../server/browser-error-config.ts";++const origin = "https://app.example.com";++test("browser request names come from a static resource allowlist, never the path", () => {+ assert.equal(apiRouteName("/api/sessions/0f3a9c1e-1d2b-4c5d-8e9f-abcdef012345/entries"), "/api/sessions/*");+ assert.equal(apiRouteName("/web/api/ui-state"), "/api/ui-state");+ assert.equal(apiRouteName("/api/private-resource/id"), "/*");+ assert.equal(apiRouteName("/d/private-app/"), "/*");+ assert.equal(apiRouteName("/"), "/*");+});++test("browser trace sampling is opt-in, bounded, and omitted when zero", () => {+ const env = { SENTRY_BROWSER_DSN: "https://[email protected]/1" };+ assert.equal(browserErrorConfig(env)?.tracesSampleRate, undefined);+ assert.equal(browserErrorConfig({ ...env, SENTRY_BROWSER_TRACES_SAMPLE_RATE: "0.1" })?.tracesSampleRate, 0.1);+ for (const rate of ["2", "-1", "nope", ""])+ assert.equal(browserErrorConfig({ ...env, SENTRY_BROWSER_TRACES_SAMPLE_RATE: rate })?.tracesSampleRate, undefined);+});++const sent: Record<string, any>[][] = [];+const collectingFetch: typeof fetch = async (_input, init) => {+ sent.push(+ String(init?.body)+ .split("\n")+ .filter(Boolean)+ .map((line) => JSON.parse(line)),+ );+ return new Response("{}", { status: 200 });+};++async function withBrowser(run: (sent: Record<string, any>[][]) => Promise<void>): Promise<void> {+ const realFetch = globalThis.fetch;+ const globals = ["window", "document", "performance", "PerformanceObserver"].map(+ (name) => [name, Object.getOwnPropertyDescriptor(globalThis, name)] as const,+ );+ sent.length = 0;+ globalThis.fetch = collectingFetch;+ const navigation = {+ entryType: "navigation",+ responseStart: 120.4,+ domContentLoadedEventEnd: 800,+ loadEventEnd: 1500,+ name: `${origin}/s/private-session?token=private`,+ };+ const define = (name: string, value: unknown) =>+ Object.defineProperty(globalThis, name, { configurable: true, value });+ define("window", {+ location: { origin, pathname: "/s/private-session-id", search: "" },+ addEventListener() {},+ });+ define("document", { readyState: "complete", addEventListener() {} });+ define("performance", {+ timeOrigin: 1_700_000_000_000,+ now: () => Date.now() - 1_700_000_000_000,+ getEntriesByType: (type: string) => (type === "navigation" ? [navigation] : []),+ getEntriesByName: (name: string) => (name === "first-contentful-paint" ? [{ startTime: 640 }] : []),+ });+ define(+ "PerformanceObserver",+ class {+ callback: (list: { getEntries(): { startTime: number }[] }) => void;+ constructor(callback: (list: { getEntries(): { startTime: number }[] }) => void) {+ this.callback = callback;+ }+ observe() {+ this.callback({ getEntries: () => [{ startTime: 900 }] });+ }+ },+ );+ try {+ await run(sent);+ } finally {+ stopBrowserErrors();+ globalThis.fetch = realFetch;+ for (const [name, descriptor] of globals) {+ if (descriptor) Object.defineProperty(globalThis, name, descriptor);+ else Reflect.deleteProperty(globalThis, name);+ }+ }+}++const me = (tracesSampleRate?: number) => ({+ user: "private-user",+ org: "private-org",+ browserErrors: { dsn: "https://[email protected]/1", release: "release-1", tracesSampleRate },+});++test("real browser SDK sends sanitized page load and request timings when sampled", async () => {+ await withBrowser(async (sent) => {+ await initializeBrowserErrors(me(1));+ const sdk = await import("@sentry/browser");+ await new Promise((resolve) => setTimeout(resolve, 600));+ reportRequestTiming(+ `${origin}/api/sessions/0f3a9c1e-1d2b-4c5d-8e9f-abcdef012345/entries?after=private`,+ "GET",+ Date.now() - 40,+ 200,+ );+ reportRequestTiming("/api/ui-state?key=private", "PUT", Date.now() - 5, 409);+ reportRequestTiming("/api/runs", "POST", Date.now() - 5, null);+ reportRequestTiming("https://other.example.com/private", "GET", Date.now(), 200);+ sdk.captureEvent({+ type: "transaction",+ transaction: "GET /api/private/1234",+ start_timestamp: 1,+ timestamp: 2,+ contexts: { trace: { trace_id: "a".repeat(32), span_id: "b".repeat(16), op: "http.client", status: "ok" } },+ });+ sdk.captureEvent({+ type: "transaction",+ transaction: "GET /api/direct",+ start_timestamp: 1,+ timestamp: 2,+ user: { id: "private-user" },+ request: { url: "private" },+ spans: [{ span_id: "1", trace_id: "2", description: "private", start_timestamp: 1, timestamp: 2, data: {} }],+ tags: { private: "private" },+ contexts: {+ trace: {+ trace_id: "a".repeat(32),+ span_id: "b".repeat(16),+ op: "http.client",+ status: "ok",+ data: { private: 1 },+ },+ },+ });+ await sdk.flush(1000);+ const payload = JSON.stringify(sent);+ assert.equal(payload.includes("private"), false);+ assert.equal(payload.includes("0f3a9c1e"), false);+ const items = sent.map((envelope) => [envelope[1]!.type, envelope[2]!.transaction, envelope[2]]);+ assert.deepEqual(+ items.map(([type, name]) => [type, name]),+ [+ ["transaction", "pageload"],+ ["transaction", "GET /api/sessions/*"],+ ["transaction", "PUT /api/ui-state"],+ ["transaction", "POST /api/runs"],+ ["transaction", "GET /api/direct"],+ ],+ );+ const pageload = items[0]![2]!;+ assert.deepEqual(pageload.tags, { page: "chats" });+ assert.equal(pageload.contexts.trace.data, undefined);+ assert.deepEqual(pageload.measurements, {+ ttfb: { value: 120, unit: "millisecond" },+ dom_content_loaded: { value: 800, unit: "millisecond" },+ load: { value: 1500, unit: "millisecond" },+ fcp: { value: 640, unit: "millisecond" },+ lcp: { value: 900, unit: "millisecond" },+ });+ assert.equal(pageload.timestamp - pageload.start_timestamp, 1.5);+ assert.equal(pageload.release, "release-1");+ assert.equal(pageload.platform, "javascript");+ assert.equal(items[1]![2]!.contexts.trace.status, "ok");+ assert.equal(items[2]![2]!.contexts.trace.status, "invalid_argument");+ assert.deepEqual(items[3]![2]!.tags, { http_status: "network" });+ assert.equal(items[3]![2]!.contexts.trace.status, "internal_error");+ assert.deepEqual(items[4]![2]!.spans, []);+ assert.deepEqual(items[4]![2]!.tags, {});+ const traceIds = new Set(items.slice(0, 4).map(([, , event]) => event!.contexts.trace.trace_id));+ assert.equal(traceIds.size, 4);+ for (const [, , event] of items) {+ assert.equal(event!.user, undefined);+ assert.equal(event!.request, undefined);+ assert.equal(event!.breadcrumbs, undefined);+ assert.deepEqual(Object.keys(sent[0]![0]!).sort(), ["event_id", "sdk", "sent_at"]);+ }+ assert.doesNotMatch(JSON.stringify(sent.map((envelope) => envelope[0]!.trace)), /private|user|segment/);+ });+});++test("unsampled and stopped browsers send no timings and error reporting stays intact", async () => {+ await withBrowser(async (sent) => {+ await initializeBrowserErrors(me());+ const sdk = await import("@sentry/browser");+ await new Promise((resolve) => setTimeout(resolve, 10));+ reportRequestTiming("/api/runs", "GET", Date.now(), 200);+ sdk.captureException(new Error("private failure"));+ await sdk.flush(1000);+ assert.equal(sent.length, 1);+ assert.equal(sent[0]![1]!.type, "event");+ await initializeBrowserErrors(me(1));+ stopBrowserErrors();+ reportRequestTiming("/api/runs", "GET", Date.now(), 200);+ await sdk.flush(1000);+ assert.equal(sent.length, 1);+ });+});diff --git a/src/api/routes/route.ts b/src/api/routes/route.tsindex 14065189e..542b0e5be 100644--- a/src/api/routes/route.ts+++ b/src/api/routes/route.ts@@ -39,10 +39,3 @@ export async function run<C extends BaseCtx>(route: Route<C>, params: Record<strctx.params = params;await route.handle(ctx);}--export async function dispatch<C extends BaseCtx>(routes: ReadonlyArray<Route<C>>, ctx: C): Promise<boolean> {- const found = findRoute(routes, ctx.method, ctx.pathname);- if (!found) return false;- await run(found.route, found.params, ctx);- return true;-}diff --git a/src/api/server.ts b/src/api/server.tsindex a845566ce..68b9616c6 100644--- a/src/api/server.ts+++ b/src/api/server.ts@@ -1,4 +1,5 @@-import { reportBackendError } from "../../plugins/chassis/src/error-reporting.ts";+import { reportBackendError, startTiming } from "../../plugins/chassis/src/error-reporting.ts";+import { traceStatus } from "../../plugins/chassis/src/timing.ts";import {createServer as createHttpServer,type IncomingMessage,@@ -30,7 +31,7 @@ import {sendJson,verifyOrReject,} from "./http.ts";-import { dispatch, findRoute, run, type ApiCtx, type BaseCtx, type Route, type RouteAuth } from "./routes/route.ts";+import { findRoute, run, type ApiCtx, type BaseCtx, type Route, type RouteAuth } from "./routes/route.ts";import { apiRoutes, rawRoutes } from "./routes/index.ts";import { proxyDeploymentSubdomain } from "./routes/deployments.ts";import { CAPABILITY_HEADER } from "./contract.ts";@@ -488,7 +489,17 @@ function buildServer(app: App, deps: ServerOptions, allowUnsignedSourceAuth: boorequirePortalIdentity,allowUnsignedSourceAuth,};+ const requestNames = new WeakMap<IncomingMessage, string>();const server = createHttpServer((req, res) => {+ const finishTiming = req.url === "/healthz" ? undefined : startTiming("http.server", `${req.method ?? "GET"} /*`);+ if (finishTiming)+ res.once("close", () =>+ finishTiming({+ name: `${req.method ?? "GET"} ${requestNames.get(req) ?? "/*"}`,+ status: res.writableFinished ? traceStatus(res.statusCode) : "cancelled",+ data: { http_status: res.writableFinished ? String(res.statusCode) : undefined },+ }),+ );req.on("error", () => res.destroy());res.on("error", () => res.destroy());void front(req, res).catch((err: unknown) => respondError(req, res, err));@@ -504,9 +515,18 @@ function buildServer(app: App, deps: ServerOptions, allowUnsignedSourceAuth: booasync function front(req: IncomingMessage, res: ServerResponse): Promise<void> {armBodyDeadline(req, 30_000);const base = baseCtx(req, res, wiring);- if (await proxyDeploymentSubdomain(base)) return;- if (await dispatch(rawRoutes, base)) return;+ if (await proxyDeploymentSubdomain(base)) {+ requestNames.set(req, "/deployment-proxy/*");+ return;+ }+ const raw = findRoute(rawRoutes, base.method, base.pathname);+ if (raw) {+ if ("path" in raw.route) requestNames.set(req, raw.route.path);+ await run(raw.route, raw.params, base);+ return;+ }const matched = findRoute(apiRoutes, base.method, base.pathname);+ if (matched && "path" in matched.route) requestNames.set(req, matched.route.path);const routeAuth = matched?.route.auth;const acceptsSourceAuth = !matched || routeAuth === "source" || routeAuth === "either";if (wiring.secret && !capabilityFromHeaders(req) && routeAuth !== "public" && acceptsSourceAuth) {diff --git a/src/wiring.ts b/src/wiring.tsindex 8395a02b4..05167f29c 100644--- a/src/wiring.ts+++ b/src/wiring.ts@@ -1,5 +1,7 @@-import { flushErrorReporting } from "../plugins/chassis/src/error-reporting.ts";+import { flushErrorReporting, startTiming } from "../plugins/chassis/src/error-reporting.ts";+import type { TimingStatus } from "../plugins/chassis/src/timing.ts";import { createProductAnalytics } from "./util/product-analytics.ts";+import { resolveTurnOrigin } from "./core/turn-origin.ts";import { createAdmittedWork } from "./util/admitted-work.ts";import { runSessionSmoke } from "./deployment/postdeploy-smoke.ts";import {@@ -1460,6 +1462,17 @@ export function buildApp(const productAnalytics = createProductAnalytics(config.orgId, config.productAnalytics);runs.onTerminal((run) => {void productAnalytics.responseFinished(run);+ const startedAt = run.startedAt ?? run.finishedAt ?? Date.now();+ const finishTiming = startTiming("queue.task", "run", startedAt);+ let status: TimingStatus = "internal_error";+ if (run.result?.stopped) status = "cancelled";+ else if (run.status === "done") status = "ok";+ finishTiming?.({+ status,+ endMs: run.finishedAt ?? Date.now(),+ data: { surface: run.request.surface, origin: resolveTurnOrigin(run.request).kind },+ measurements: { queue_wait: startedAt - run.createdAt },+ });});const ledger = runStore.ledger;diff --git a/test/error-reporting.test.ts b/test/error-reporting.test.tsindex ca27e16cc..ceedf4ef1 100644--- a/test/error-reporting.test.ts+++ b/test/error-reporting.test.ts@@ -4,6 +4,7 @@ import { spawn } from "node:child_process";import { createServer } from "node:http";import { once } from "node:events";import { sanitizeErrorEvent } from "../plugins/chassis/src/error-reporting.ts";+import { sanitizeTransactionEvent, traceStatus } from "../plugins/chassis/src/timing.ts";test("error event allowlist excludes content, credentials, paths and ambient scope", () => {const clean = sanitizeErrorEvent({@@ -51,14 +52,21 @@ test("error event allowlist excludes content, credentials, paths and ambient scoassert.deepEqual(clean.fingerprint, ["{{ default }}", "run:failed"]);});-async function runReporting(body: string, enabled = true) {+async function runReporting(body: string, enabled = true, env: Record<string, string> = {}) {const events: Record<string, any>[] = [];+ const transactions: Record<string, any>[] = [];const collector = createServer(async (req, res) => {const chunks = [];for await (const chunk of req) chunks.push(chunk);const lines = Buffer.concat(chunks).toString().split("\n");+ if (req.url?.includes("outbound")) {+ res.end("{}");+ return;+ }for (let i = 1; i + 1 < lines.length; i += 2) {- if (JSON.parse(lines[i]!).type === "event") events.push(JSON.parse(lines[i + 1]!));+ const type = JSON.parse(lines[i]!).type;+ if (type === "event") events.push(JSON.parse(lines[i + 1]!));+ if (type === "transaction") transactions.push(JSON.parse(lines[i + 1]!));}res.end("{}");});@@ -73,7 +81,7 @@ async function runReporting(body: string, enabled = true) {"-e",`import * as Sentry from '@sentry/node';- import { initializeErrorReporting, reportBackendError, flushErrorReporting } from './plugins/chassis/src/error-reporting.ts';+ import { initializeErrorReporting, reportBackendError, startTiming, flushErrorReporting } from './plugins/chassis/src/error-reporting.ts';initializeErrorReporting(Sentry, 'test');${body}`,@@ -86,6 +94,8 @@ async function runReporting(body: string, enabled = true) {SENTRY_ENVIRONMENT: "verification",SENTRY_RELEASE: "test-release",SENTRY_DEPLOYMENT: "test-deployment",+ COLLECTOR_PORT: String(address.port),+ ...env,},},);@@ -97,7 +107,7 @@ async function runReporting(body: string, enabled = true) {const timeout = setTimeout(() => child.kill("SIGKILL"), 10_000);try {const [code, signal] = await once(child, "exit");- return { events, code, signal, output };+ return { events, transactions, code, signal, output };} finally {clearTimeout(timeout);collector.closeAllConnections();@@ -174,6 +184,175 @@ test("operator error records retain local details and send one classified eventassert.doesNotMatch(JSON.stringify(events), /private-/);});+test("transaction allowlist keeps timing shape only and rejects unsafe names", () => {+ const clean = sanitizeTransactionEvent(+ {+ type: "transaction",+ event_id: "b".repeat(32),+ transaction: "GET /v1/sessions/:id",+ transaction_info: { source: "url" },+ start_timestamp: 10,+ timestamp: 10.5,+ environment: "verification",+ release: "test-release",+ user: { id: "private-user" },+ request: { url: "https://private-host/v1/sessions/private-id", headers: { authorization: "private-token" } },+ breadcrumbs: [{ message: "private-breadcrumb" }],+ extra: { sql: "private-sql" },+ server_name: "private-host",+ spans: [+ { span_id: "1", trace_id: "2", description: "SELECT private", start_timestamp: 10, timestamp: 10.1, data: {} },+ ],+ tags: { service: "core", http_status: "private", private: "private-tag", surface: "private-tag" },+ measurements: { queue_wait: { value: 5, unit: "millisecond" }, private: { value: 1, unit: "millisecond" } },+ contexts: {+ trace: {+ trace_id: "a".repeat(32),+ span_id: "c".repeat(16),+ op: "http.server",+ status: "ok",+ data: { private: 1, http_status: "200", surface: "web", page: "private id", "sentry.sample_rate": 1 },+ },+ otel: { resource: { "service.name": "private-host" } },+ runtime: { name: "node" },+ private: { value: "private-context" },+ },+ },+ "node",+ );+ assert.doesNotMatch(JSON.stringify(clean), /private/);+ assert.equal(clean?.transaction, "GET /v1/sessions/:id");+ assert.deepEqual(clean?.transaction_info, { source: "route" });+ assert.deepEqual(clean?.tags, { service: "core", http_status: "200", surface: "web", page: "other" });+ assert.deepEqual(clean?.measurements, { queue_wait: { value: 5, unit: "millisecond" } });+ assert.deepEqual(clean?.spans, []);+ assert.deepEqual(clean?.contexts?.trace, {+ trace_id: "a".repeat(32),+ span_id: "c".repeat(16),+ op: "http.server",+ status: "ok",+ origin: "manual",+ });+ const base = {+ type: "transaction" as const,+ start_timestamp: 1,+ timestamp: 2,+ contexts: { trace: { trace_id: "a".repeat(32), span_id: "c".repeat(16), op: "queue.task", status: "ok" } },+ };+ for (const transaction of ["GET /v1/sessions/1234?token=private", "private text", "GET https://x/", undefined])+ assert.equal(sanitizeTransactionEvent({ ...base, transaction }, "node"), null);+ assert.equal(sanitizeTransactionEvent({ ...base, transaction: "run", timestamp: 0 }, "node"), null);+ assert.equal(sanitizeTransactionEvent({ ...base, transaction: "run", contexts: {} }, "node"), null);+ const traced = (op: string, status: string) => ({+ ...base,+ transaction: "run",+ contexts: { trace: { ...base.contexts.trace, op, status } },+ });+ assert.equal(sanitizeTransactionEvent(traced("private.op", "ok"), "node"), null);+ assert.equal(sanitizeTransactionEvent(traced("queue.task", "private status"), "node"), null);+ assert.equal(sanitizeTransactionEvent(traced("queue.task", "ok"), "node")?.contexts?.trace?.op, "queue.task");+ const bucketed = sanitizeTransactionEvent(+ {+ ...traced("queue.task", "ok"),+ contexts: {+ trace: {+ ...base.contexts.trace,+ op: "queue.task",+ status: "ok",+ data: { surface: "private-surface", origin: "private-origin", http_status: "private", page: "private" },+ },+ },+ },+ "node",+ );+ assert.deepEqual(bucketed?.tags, { surface: "other", origin: "other", http_status: "other", page: "other" });+ const inherited = sanitizeTransactionEvent(+ {+ ...traced("queue.task", "ok"),+ contexts: {+ trace: {+ ...base.contexts.trace,+ op: "queue.task",+ status: "ok",+ data: { toString: "private prompt", constructor: "private-user", hasOwnProperty: "private" },+ },+ },+ },+ "node",+ );+ assert.deepEqual(inherited?.tags, {});+});++test("trace statuses map HTTP outcomes", () => {+ assert.deepEqual([200, 302, 401, 403, 404, 429, 422, 500].map(traceStatus), [+ "ok",+ "ok",+ "unauthenticated",+ "permission_denied",+ "not_found",+ "resource_exhausted",+ "invalid_argument",+ "internal_error",+ ]);+});++test("real SDK sends sanitized sampled transactions only when a sample rate is configured", async () => {+ const body = `+ startTiming('queue.task', 'run', Date.now() - 500)?.({ status: 'ok', endMs: Date.now(),+ data: { surface: 'web', origin: 'human', private: 'private-tag', page: 'private-page' },+ measurements: { queue_wait: 20, private: 5 } });+ const finish = startTiming('http.server', 'GET /*');+ finish?.({ name: 'GET /v1/sessions/:id', status: 'not_found', data: { http_status: '404' } });+ reportBackendError(new Error('private-error'));+ await fetch('http://127.0.0.1:' + process.env.COLLECTOR_PORT + '/private-outbound').catch(() => {});+ await flushErrorReporting();+ `;+ const off = await runReporting(body);+ assert.equal(off.code, 0);+ assert.equal(off.transactions.length, 0);+ assert.equal(off.events.length, 1);+ const invalid = await runReporting(body, true, { SENTRY_TRACES_SAMPLE_RATE: "5" });+ assert.equal(invalid.transactions.length, 0);+ const on = await runReporting(body, true, { SENTRY_TRACES_SAMPLE_RATE: "1" });+ assert.equal(on.code, 0);+ assert.equal(on.events.length, 1);+ assert.equal(on.transactions.length, 2);+ assert.doesNotMatch(JSON.stringify(on.transactions), /private/);+ const [run, request] = on.transactions;+ assert.equal(run!.transaction, "run");+ assert.ok(Math.abs(run!.timestamp - run!.start_timestamp - 0.5) < 0.05);+ assert.deepEqual(run!.tags, {+ service: "test",+ deployment: "test-deployment",+ surface: "web",+ origin: "human",+ page: "other",+ });+ assert.deepEqual(run!.measurements, { queue_wait: { value: 20, unit: "millisecond" } });+ assert.equal(run!.contexts.trace.op, "queue.task");+ assert.equal(run!.release, "test-release");+ assert.equal(run!.environment, "verification");+ assert.equal(request!.transaction, "GET /v1/sessions/:id");+ assert.equal(request!.contexts.trace.status, "not_found");+ assert.equal(request!.tags.http_status, "404");+ assert.deepEqual(Object.keys(run!).sort(), [+ "contexts",+ "environment",+ "event_id",+ "measurements",+ "platform",+ "release",+ "sdk",+ "spans",+ "start_timestamp",+ "tags",+ "timestamp",+ "transaction",+ "transaction_info",+ "type",+ ]);+});+test("reportFailure sends one classified event per distinct failure and skips cancellations and recorded errors", async () => {const { events, code } = await runReporting(`const { reportFailure } = await import('./src/util/errors.ts');diff --git a/test/request-timing.test.ts b/test/request-timing.test.tsnew file mode 100644index 000000000..2d97b0340--- /dev/null+++ b/test/request-timing.test.ts@@ -0,0 +1,108 @@+import "./support/auto-fake-sprites.ts";++import { after, test } from "node:test";+import assert from "node:assert/strict";+import { mkdtempSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import type { AddressInfo } from "node:net";+import { createServer } from "node:http";+import { once } from "node:events";+import * as Sentry from "@sentry/node";+import { flushErrorReporting, initializeErrorReporting } from "../plugins/chassis/src/error-reporting.ts";+import { createInsecureTestServer } from "../src/api/server.ts";+import { buildApp } from "../src/wiring.ts";+import { testConfig } from "./support/test-config.ts";++const captured: Record<string, any>[] = [];+const collector = createServer(async (req, res) => {+ const chunks = [];+ for await (const chunk of req) chunks.push(chunk);+ const lines = Buffer.concat(chunks).toString().split("\n");+ for (let i = 1; i + 1 < lines.length; i += 2) {+ if (JSON.parse(lines[i]!).type === "transaction") captured.push(JSON.parse(lines[i + 1]!));+ }+ res.end("{}");+});+collector.listen(0, "127.0.0.1");+await once(collector, "listening");+initializeErrorReporting(Sentry, "core", {+ SENTRY_DSN: `http://[email protected]:${(collector.address() as AddressInfo).port}/1`,+ SENTRY_TRACES_SAMPLE_RATE: "1",+});+after(async () => {+ collector.closeAllConnections();+ await new Promise<void>((resolve) => collector.close(() => resolve()));+});++test("core request timings carry registered route templates, never raw paths, and runs report queue wait", async () => {+ const built = buildApp(testConfig({ dataDir: mkdtempSync(join(tmpdir(), "timing-")) }));+ const server = createInsecureTestServer(built.app);+ server.listen(0);+ const base = `http://localhost:${(server.address() as AddressInfo).port}`;+ try {+ await fetch(`${base}/healthz`);+ await fetch(`${base}/v1/sessions/private-session-id?token=private-token`);+ await fetch(`${base}/v1/no-such-route/private-segment-9f3a/deep`, { method: "POST" });+ await fetch(`${base}/v1/blobs/private-blob-id`);+ const settle = async (expected: number) => {+ for (let i = 0; i < 40 && captured.length < expected; i++) {+ await flushErrorReporting();+ await new Promise((resolve) => setTimeout(resolve, 50));+ }+ };+ await settle(3);+ const requests = captured.filter((event) => event.contexts?.trace?.op === "http.server");+ assert.equal(requests.length, 3);+ assert.doesNotMatch(JSON.stringify(requests), /private/);+ assert.deepEqual(+ requests.map((event) => [event.transaction, event.contexts?.trace?.status, event.tags?.http_status]),+ [+ ["GET /v1/sessions/:id", "invalid_argument", "400"],+ ["POST /*", "not_found", "404"],+ ["GET /v1/blobs/:id", "internal_error", "501"],+ ],+ );+ for (const event of requests) {+ assert.equal(event.type, "transaction");+ assert.equal(event.tags?.service, "core");+ assert.ok(event.timestamp! >= event.start_timestamp!);+ assert.match(event.contexts!.trace!.trace_id!, /^[a-f0-9]{32}$/);+ assert.equal(event.server_name, undefined);+ assert.equal(event.contexts.otel, undefined);+ assert.equal(event.contexts.trace.data, undefined);+ assert.deepEqual(event.spans, []);+ }+ const { run } = await built.runs.enqueue({+ sessionId: "private-thread",+ request: {+ actor: { id: "private-person", type: "internal" },+ conversation: { kind: "dm", threadRef: "private-thread", audience: [] },+ origin: { kind: "human" },+ surface: "web",+ text: "private prompt",+ },+ });+ const claimed = await built.runs.claim("worker", 10_000);+ assert.equal(claimed?.id, run.id);+ await built.runs.complete(run.id, claimed!.leaseToken!, { status: "ok" });+ await settle(4);+ const runs = captured.filter((event) => event.contexts?.trace?.op === "queue.task");+ assert.equal(runs.length, 1);+ assert.doesNotMatch(JSON.stringify(runs), /private/);+ assert.equal(runs[0]!.transaction, "run");+ assert.deepEqual(runs[0]!.tags, { service: "core", surface: "web", origin: "human" });+ assert.equal(runs[0]!.contexts?.trace?.status, "ok");+ assert.equal(runs[0]!.measurements?.queue_wait?.unit, "millisecond");+ assert.ok(runs[0]!.measurements!.queue_wait!.value >= 0);+ const stopped = await built.runs.enqueue({ sessionId: "private-thread-2", request: run.request });+ const stoppedClaim = await built.runs.claim("worker", 10_000);+ assert.equal(stoppedClaim?.id, stopped.run.id);+ await built.runs.complete(stopped.run.id, stoppedClaim!.leaseToken!, { status: "silent", stopped: true });+ await settle(5);+ const cancelled = captured.filter((event) => event.contexts?.trace?.op === "queue.task").at(-1)!;+ assert.equal(cancelled.contexts.trace.status, "cancelled");+ } finally {+ await new Promise<void>((r) => server.close(() => r()));+ }+});