@tracepanel/js 0.0.0-stage → 0.3.0

package/dist/nuxt-plugin.js

@@ -0,0 +1,39 @@
+// The Nitro plugin @tracepanel/js/nuxt adds in development. Nitro bundles it into the server: it reads the process's
+// Tracepanel from globalThis and brings no OpenTelemetry of its own.
+import { captureConsole } from "./console.js";
+import { headersOnResponses } from "./headers.js";
+const KEY = Symbol.for("tracepanel.runtime");
+export default function tracepanelPlugin(nitroApp) {
+    const tracepanel = globalThis[KEY];
+    if (!tracepanel)
+        return;
+    headersOnResponses(tracepanel, "Nuxt");
+    // Nuxt's dev server replaced console with its own logger after --import wrapped it.
+    captureConsole(tracepanel.processor);
+    // h3 answers a thrown error with a 500 and records it nowhere: the request's trace gets it here.
+    // createError({ statusCode: 404 }) and the like are answers, not errors.
+    nitroApp.hooks.hook("error", (error) => {
+        const status = error.statusCode ?? 500;
+        if (status >= 500)
+            tracepanel.processor.addError(error);
+    });
+    nitroApp.hooks.hook("request", () => tracepanel.processor.setFramework("Nuxt"));
+    // The route is matched by then. The renderer's catch-all (/**) serves every page: its path names a page better.
+    nitroApp.hooks.hook("beforeResponse", (event) => {
+        const route = event.context.matchedRoute?.path;
+        if (route && !route.includes("**"))
+            tracepanel.processor.setRoute(route);
+    });
+    nitroApp.hooks.hook("render:html", (html, { event }) => {
+        const marks = tracepanel.badge({
+            method: event.method ?? "GET",
+            status: 200,
+            startedMs: performance.now(),
+            page: true,
+            framework: tracepanel.processor.framework() ?? "Nuxt",
+        });
+        if (marks?.script)
+            html.head.unshift(marks.script);
+    });
+}
+//# sourceMappingURL=nuxt-plugin.js.map

package/dist/nuxt-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nuxt-plugin.js","sourceRoot":"","sources":["../src/nuxt-plugin.ts"],"names":[],"mappings":"AAAA,qHAAqH;AACrH,qEAAqE;AAErE,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGlD,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;AAgB7C,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,QAAkB;IACzD,MAAM,UAAU,GAAI,UAAkC,CAAC,GAAG,CAAC,CAAC;IAC5D,IAAI,CAAC,UAAU;QAAE,OAAO;IACxB,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IACvC,oFAAoF;IACpF,cAAc,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IACrC,iGAAiG;IACjG,yEAAyE;IACzE,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;QACrC,MAAM,MAAM,GAAI,KAAiC,CAAC,UAAU,IAAI,GAAG,CAAC;QACpE,IAAI,MAAM,IAAI,GAAG;YAAE,UAAU,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC1D,CAAC,CAAC,CAAC;IACH,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IAChF,gHAAgH;IAChH,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,KAAK,EAAE,EAAE;QAC9C,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI,CAAC;QAC/C,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC;YAAE,UAAU,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;IACH,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;QACrD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;YAC7B,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,KAAK;YAC7B,MAAM,EAAE,GAAG;YACX,SAAS,EAAE,WAAW,CAAC,GAAG,EAAE;YAC5B,IAAI,EAAE,IAAI;YACV,SAAS,EAAE,UAAU,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,MAAM;SACtD,CAAC,CAAC;QACH,IAAI,KAAK,EAAE,MAAM;YAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/nuxt.d.ts

@@ -0,0 +1,10 @@
+interface Nuxt {
+    options: {
+        dev: boolean;
+        nitro: {
+            plugins?: string[];
+        };
+    };
+}
+export default function tracepanelModule(_options: unknown, nuxt: Nuxt): void;
+export {};

package/dist/nuxt.js

@@ -0,0 +1,16 @@
+// `modules: ["@tracepanel/js/nuxt"]` in nuxt.config: a Nitro plugin that names each request by its route, puts the badge
+// on server-rendered pages and the trace's id on every response. OpenTelemetry itself goes in before Nitro, with
+// `NODE_OPTIONS=--import=@tracepanel/js/register nuxt dev`, so it can hook the database driver as Nitro loads it.
+import { fileURLToPath } from "node:url";
+export default function tracepanelModule(_options, nuxt) {
+    if (!nuxt.options.dev)
+        return;
+    nuxt.options.nitro.plugins = [
+        ...(nuxt.options.nitro.plugins ?? []),
+        fileURLToPath(new URL("./nuxt-plugin.js", import.meta.url)),
+    ];
+}
+Object.assign(tracepanelModule, {
+    getMeta: () => Promise.resolve({ name: "tracepanel", configKey: "tracepanel" }),
+});
+//# sourceMappingURL=nuxt.js.map

package/dist/nuxt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nuxt.js","sourceRoot":"","sources":["../src/nuxt.ts"],"names":[],"mappings":"AAAA,yHAAyH;AACzH,iHAAiH;AACjH,kHAAkH;AAElH,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAMzC,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,QAAiB,EAAE,IAAU;IACpE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG;QAAE,OAAO;IAC9B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,GAAG;QAC3B,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC;QACrC,aAAa,CAAC,IAAI,GAAG,CAAC,kBAAkB,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;KAC5D,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,CAAC,gBAAgB,EAAE;IAC9B,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;CAChF,CAAC,CAAC"}

package/dist/processor.d.ts

@@ -0,0 +1,105 @@
+import { type Context } from "@opentelemetry/api";
+import type { ReadableSpan, Span as SdkSpan, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import type { Config } from "./config.js";
+import { type Log, micros, type Trace } from "./model.js";
+/** Where a trace goes once its request ends. */
+export interface Sink {
+    submit(trace: Trace): void;
+}
+/** One request's trace while its spans end. */
+interface Building {
+    trace: Trace;
+    /** OTel span id: the Tracepanel span id it is, or its nearest kept ancestor's when it is left out. */
+    ids: Map<string, string | null>;
+    origins: Map<string, string | null>;
+    queries: number;
+    dbTime: number;
+    framework: string;
+    /** performance.now() as the request's root span started. */
+    startedMs: number;
+    /** OTel span id of the request's root span here: its parent, if any, is in another process. */
+    rootSpanId: string;
+    /** The route pattern a framework named (Nitro's /api/books/:id), for a root span that has none. */
+    route: string | null;
+    /** The request as its root span started: method and target, to find it from a response sent outside its context. */
+    request: string;
+    /** Whether a response's headers have taken this trace's id already. */
+    answered: boolean;
+    /** Tracepanel ids of Nest controller spans: the exceptions they record may be HTTP answers, not errors. */
+    nestViews: Set<string>;
+    /** OTel span id: the Tracepanel id of the span's parent when it started. */
+    parents: Map<string, string | null>;
+    /** Express's anonymous route handlers that a Nest controller's span stands in for: left out, children and all. */
+    replaced: Set<string>;
+    /** OTel span id: the Express route handlers' ones, so a Nest span under one can take its place. */
+    expressHandlers: Set<string>;
+    /**
+     * The app's line behind the latest span that had one. A driver often starts its query span later, from a callback
+     * (pg's pool runs the query once it has a connection), where the stack holds none of the app's code; the
+     * connection checkout before it started right in the app's call.
+     */
+    lastOrigin: string | null;
+}
+export declare class TracepanelProcessor implements SpanProcessor {
+    private readonly config;
+    private readonly sink;
+    /** The traces being built, by their root span's OTel id. */
+    private readonly open;
+    /**
+     * OTel span id → the trace it belongs to. Not the OTel trace id: a request the app makes to itself (fetch to its own
+     * API) carries the caller's trace id, and is a trace of its own all the same.
+     */
+    private readonly owner;
+    constructor(config: Config, sink: Sink);
+    onStart(span: SdkSpan, _parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+    /** The trace being built for the active request, with the current span's Tracepanel id. */
+    current(): {
+        building: Building;
+        spanId: string | null;
+    } | undefined;
+    /** What the widget shows before the request's span ends: its id, its queries so far and their time. */
+    timing(request?: {
+        method: string;
+        url: string;
+    }): Timing | undefined;
+    private dropAbandoned;
+    /** The trace is done here: its spans no longer lead to it. */
+    private close;
+    /**
+     * The open trace of a request whose response goes out outside its context (Next.js streams a page from another
+     * async context): the latest one for this method and URL that no response has answered yet.
+     */
+    private waiting;
+    /** An error a framework caught and answered with a 500 itself, without recording it on a span (Nitro). */
+    addError(error: unknown): void;
+    addLog(log: Omit<Log, "span_id">): void;
+    /** The framework the active request runs on, unless a more specific one (Nest on Express) already said so. */
+    setFramework(name: string): void;
+    /** The route pattern the framework matched, when the root span doesn't carry one (Nitro). */
+    setRoute(route: string): void;
+    /** The framework the active request ran on, as the panel shows it. */
+    framework(): string | undefined;
+    private start;
+    /** A span as Tracepanel draws it: the request, a route handler (view), a statement (sql), an outgoing call. */
+    private convert;
+    private sqlAttrs;
+    /** Exceptions the instrumentation recorded on a span: the request's errors, with their frames. */
+    private collectErrors;
+    /** The trace from its root span: name, timing, the request's attributes. */
+    private finish;
+    /** A command (trace()) or a task (a queue's job): named as it was started, its task.* attributes kept. */
+    private finishWork;
+}
+export interface Timing {
+    id: string;
+    queries: number;
+    dbMs: number;
+    /** performance.now() as the request started. */
+    startedMs: number;
+}
+/** `Node 26 · Express`: what the panel shows next to its logo. */
+export declare function runtimeLabel(framework: string): string;
+export { micros };

package/dist/processor.js

@@ -0,0 +1,491 @@
+// The span processor: the app traces itself with OpenTelemetry (its HTTP server, Express, its database driver), and
+// each request's spans become one Tracepanel trace, sent to the agent when the request's span ends.
+import { createHash } from "node:crypto";
+import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
+import { httpCall, isMongo, isRedis, mongoCall, redisCall } from "./calls.js";
+import { withVersion } from "./frameworks.js";
+import { countDropped, limited, MAX_LOGS, micros, newId, } from "./model.js";
+import { fingerprint, spanName, statement } from "./sql.js";
+import { frames, origin } from "./stack.js";
+// A request's span can end after the response does (Express ends an async handler's span when its promise settles):
+// the trace goes out this long after the request's span ends, with the spans that ended meanwhile.
+const LATE_SPANS_MS = 25;
+// A request whose root span never ends (the client went away mid-stream and the framework didn't end it) is dropped
+// after this long, so the open traces don't grow for ever.
+const ABANDONED_MS = 10 * 60 * 1000;
+// Spans that are bookkeeping, not work: Express's middleware and routers, a driver's connection checkouts, and
+// Nest's inner handler span (the same call as its request context span, which names the controller).
+const SKIPPED_EXPRESS = new Set(["middleware", "router"]);
+const SKIPPED_NEST = new Set(["handler", "app_creation"]);
+// Next.js's own bookkeeping: finding and loading the route's modules, the first byte, metadata.
+const SKIPPED_NEXT = new Set([
+    "NextNodeServer.findPageComponents",
+    "NextNodeServer.getLayoutOrPageModule",
+    "NextNodeServer.startResponse",
+    "NextNodeServer.clientComponentLoading",
+    "NextNodeServer.createComponentTree",
+    "LoadComponents.loadRouteModule",
+    "RouteModule.prepare",
+    "ResolveMetadata.generateMetadata",
+]);
+// What runs a Next.js route: an app or pages render, a route handler, getServerSideProps.
+const NEXT_HANDLERS = new Set([
+    "AppRender.getBodyResult",
+    "AppRouteRouteHandlers.runHandler",
+    "Render.getServerSideProps",
+    "Render.renderDocument",
+]);
+// Next.js's requests for its own assets and dev tooling, not the app's.
+const NEXT_INTERNAL = /^\/(_next|__nextjs)/;
+// Prisma's own spans besides the operation: its SQL goes through the driver adapter's driver (pg, mysql2), recorded
+// there; the rest is its query engine's bookkeeping.
+const SKIPPED_NAMES = /^(pg\.connect|pg-pool\.connect|mysql2?\.connect|prisma:(?!client:operation$))/;
+function attrsOf(span) {
+    return { ...span.attributes };
+}
+function first(attrs, ...keys) {
+    for (const key of keys) {
+        if (attrs[key] !== undefined)
+            return attrs[key];
+    }
+    return undefined;
+}
+function durationUs(span) {
+    const [seconds, nanos] = span.duration;
+    return Math.round(seconds * 1e6 + nanos / 1e3);
+}
+function startUs(span) {
+    const [seconds, nanos] = span.startTime;
+    return Math.round(seconds * 1e6 + nanos / 1e3);
+}
+function skipped(span) {
+    const attrs = attrsOf(span);
+    return (SKIPPED_EXPRESS.has(String(attrs["express.type"])) ||
+        SKIPPED_NEST.has(String(attrs["nestjs.type"])) ||
+        SKIPPED_NEXT.has(String(attrs["next.span_type"])) ||
+        SKIPPED_NAMES.test(span.name));
+}
+function statementOf(attrs) {
+    const text = first(attrs, "db.query.text", "db.statement");
+    return typeof text === "string" ? text : "";
+}
+export class TracepanelProcessor {
+    config;
+    sink;
+    /** The traces being built, by their root span's OTel id. */
+    open = new Map();
+    /**
+     * OTel span id → the trace it belongs to. Not the OTel trace id: a request the app makes to itself (fetch to its own
+     * API) carries the caller's trace id, and is a trace of its own all the same.
+     */
+    owner = new Map();
+    constructor(config, sink) {
+        this.config = config;
+        this.sink = sink;
+    }
+    onStart(span, _parentContext) {
+        const context = span.spanContext();
+        const parent = span.parentSpanContext;
+        let building = parent ? this.owner.get(parent.spanId) : undefined;
+        // A request that came with a traceparent (from another app, or this one calling itself) starts a trace here.
+        const local = !parent || (parent.isRemote === true && span.kind === SpanKind.SERVER);
+        if (local) {
+            // A request, or work outside one that trace() or a task queue started: tracepanel.kind says which.
+            const kind = attrsOf(span)["tracepanel.kind"];
+            if (span.kind !== SpanKind.SERVER && kind !== "command" && kind !== "task")
+                return;
+            if (NEXT_INTERNAL.test(String(first(attrsOf(span), "http.target", "url.path") ?? "")))
+                return;
+            this.dropAbandoned();
+            building = this.start();
+            if (kind === "command" || kind === "task")
+                building.trace.kind = kind;
+            building.rootSpanId = context.spanId;
+            const rootAttrs = attrsOf(span);
+            building.request = requestKey(first(rootAttrs, "http.request.method", "http.method"), first(rootAttrs, "http.target", "url.path"));
+            this.open.set(context.spanId, building);
+        }
+        if (!building)
+            return;
+        this.owner.set(context.spanId, building);
+        const found = origin(this.config.root);
+        if (found)
+            building.lastOrigin = found;
+        if (!local && parent && skipped(span)) {
+            building.ids.set(context.spanId, building.ids.get(parent.spanId) ?? null);
+            return;
+        }
+        const attrs = attrsOf(span);
+        if (attrs["express.type"] === "request_handler")
+            building.expressHandlers.add(context.spanId);
+        if (parent && attrs["nestjs.type"] === "request_context" && building.expressHandlers.has(parent.spanId)) {
+            // Nest's router is Express's route handler: the controller's span takes its place in the tree.
+            building.replaced.add(parent.spanId);
+            building.ids.set(parent.spanId, building.parents.get(parent.spanId) ?? null);
+            building.framework = "NestJS";
+        }
+        building.parents.set(context.spanId, parent && !local ? (building.ids.get(parent.spanId) ?? null) : null);
+        if (!parent && attrs["next.span_type"] === "BaseServer.handleRequest")
+            building.framework = "Next.js";
+        building.ids.set(context.spanId, newId());
+        building.origins.set(context.spanId, found ?? building.lastOrigin);
+    }
+    onEnd(span) {
+        if (process.env.TRACEPANEL_DEBUG) {
+            process.stderr.write(`[tracepanel] ${span.name} kind=${span.kind} parent=${span.parentSpanContext?.spanId ?? "-"} ${JSON.stringify(span.attributes)}\n`);
+        }
+        const context = span.spanContext();
+        const building = this.owner.get(context.spanId);
+        if (!building)
+            return;
+        const root = context.spanId === building.rootSpanId;
+        if (building.replaced.has(context.spanId))
+            return;
+        if (root || !skipped(span))
+            this.convert(building, span, root);
+        if (!root)
+            return;
+        setTimeout(() => {
+            this.close(building);
+            this.finish(building, span);
+            this.sink.submit(limited(building.trace));
+        }, LATE_SPANS_MS).unref();
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+    /** The trace being built for the active request, with the current span's Tracepanel id. */
+    current() {
+        const span = trace.getActiveSpan();
+        if (!span)
+            return undefined;
+        const context = span.spanContext();
+        const building = this.owner.get(context.spanId);
+        return building ? { building, spanId: building.ids.get(context.spanId) ?? null } : undefined;
+    }
+    /** What the widget shows before the request's span ends: its id, its queries so far and their time. */
+    timing(request) {
+        const building = this.current()?.building ?? (request ? this.waiting(request) : undefined);
+        if (!building)
+            return undefined;
+        // A response's headers took it: another response to the same URL is another request's.
+        if (request)
+            building.answered = true;
+        return {
+            id: building.trace.id,
+            queries: building.queries,
+            dbMs: building.dbTime / 1000,
+            startedMs: building.startedMs,
+        };
+    }
+    dropAbandoned() {
+        const oldest = performance.now() - ABANDONED_MS;
+        for (const building of [...this.open.values()]) {
+            if (building.startedMs < oldest)
+                this.close(building);
+        }
+    }
+    /** The trace is done here: its spans no longer lead to it. */
+    close(building) {
+        this.open.delete(building.rootSpanId);
+        for (const spanId of building.ids.keys())
+            this.owner.delete(spanId);
+    }
+    /**
+     * The open trace of a request whose response goes out outside its context (Next.js streams a page from another
+     * async context): the latest one for this method and URL that no response has answered yet.
+     */
+    waiting(request) {
+        const key = requestKey(request.method, request.url);
+        let found;
+        for (const building of this.open.values()) {
+            if (building.request === key && !building.answered)
+                found = building;
+        }
+        return found;
+    }
+    /** An error a framework caught and answered with a 500 itself, without recording it on a span (Nitro). */
+    addError(error) {
+        const current = this.current();
+        if (!current)
+            return;
+        const thrown = error instanceof Error ? error : new Error(String(error));
+        // h3 wraps what the handler threw: the cause is the app's error.
+        const cause = thrown.cause instanceof Error ? thrown.cause : thrown;
+        current.building.trace.errors.push({
+            span_id: current.spanId,
+            time: Date.now() * 1000,
+            type: cause.name || "Error",
+            message: cause.message,
+            handled: false,
+            frames: frames(cause.stack ?? "", this.config.root),
+            chain: [],
+        });
+    }
+    addLog(log) {
+        const current = this.current();
+        if (!current)
+            return;
+        const { trace } = current.building;
+        if (trace.logs.length >= MAX_LOGS)
+            countDropped(trace, "tracepanel.dropped_logs");
+        else
+            trace.logs.push({ ...log, span_id: current.spanId });
+    }
+    /** The framework the active request runs on, unless a more specific one (Nest on Express) already said so. */
+    setFramework(name) {
+        const current = this.current();
+        if (current && current.building.framework === "node:http")
+            current.building.framework = name;
+    }
+    /** The route pattern the framework matched, when the root span doesn't carry one (Nitro). */
+    setRoute(route) {
+        const current = this.current();
+        if (current)
+            current.building.route = route;
+    }
+    /** The framework the active request ran on, as the panel shows it. */
+    framework() {
+        return this.current()?.building.framework;
+    }
+    start() {
+        return {
+            trace: {
+                id: newId(),
+                kind: "http",
+                name: "",
+                start: 0,
+                duration: 0,
+                status: "ok",
+                attrs: {},
+                spans: [],
+                logs: [],
+                errors: [],
+                links: [],
+                issues: [],
+            },
+            ids: new Map(),
+            origins: new Map(),
+            queries: 0,
+            dbTime: 0,
+            framework: "node:http",
+            startedMs: performance.now(),
+            rootSpanId: "",
+            route: null,
+            request: "",
+            answered: false,
+            replaced: new Set(),
+            nestViews: new Set(),
+            expressHandlers: new Set(),
+            parents: new Map(),
+            lastOrigin: null,
+        };
+    }
+    /** A span as Tracepanel draws it: the request, a route handler (view), a statement (sql), an outgoing call. */
+    convert(building, span, root) {
+        const context = span.spanContext();
+        const id = building.ids.get(context.spanId);
+        if (!id)
+            return;
+        const parentId = root ? null : (building.ids.get(span.parentSpanContext?.spanId ?? "") ?? null);
+        if (!root && parentId === null)
+            return;
+        const attrs = attrsOf(span);
+        const converted = {
+            id,
+            parent_id: parentId,
+            kind: "function",
+            name: span.name,
+            start: startUs(span),
+            duration: durationUs(span),
+            status: span.status.code === SpanStatusCode.ERROR ? "error" : "ok",
+            attrs: {},
+        };
+        const codeOrigin = building.origins.get(context.spanId) ?? null;
+        const sql = isRedis(attrs) || isMongo(attrs) ? "" : statementOf(attrs);
+        if (root) {
+            converted.kind = { http: "http", task: "task.run", command: "command" }[building.trace.kind];
+        }
+        else if (attrs["express.type"] === "request_handler") {
+            converted.kind = "view";
+            converted.name = String(attrs["express.name"] ?? span.name);
+            building.trace.attrs["code.view"] = converted.name;
+        }
+        else if (NEXT_HANDLERS.has(String(attrs["next.span_type"]))) {
+            converted.kind = "view";
+            converted.name = String(first(attrs, "next.route", "next.page") ?? span.name);
+            building.trace.attrs["code.view"] = converted.name;
+        }
+        else if (attrs["nestjs.type"] === "request_context") {
+            converted.kind = "view";
+            converted.name = `${attrs["nestjs.controller"] ?? "Controller"}.${attrs["nestjs.callback"] ?? span.name}`;
+            building.trace.attrs["code.view"] = converted.name;
+            building.nestViews.add(id);
+        }
+        else if (attrs["tracepanel.span_kind"] === "task.enqueue") {
+            converted.kind = "task.enqueue";
+            converted.name = String(attrs["task.name"] ?? span.name);
+            converted.attrs = {
+                ...Object.fromEntries(Object.entries(attrs).filter(([key]) => key.startsWith("task."))),
+                "code.origin": codeOrigin,
+            };
+        }
+        else if (isRedis(attrs)) {
+            const call = redisCall(attrs, span.name);
+            converted.kind = "redis";
+            converted.name = call.name;
+            converted.attrs = { ...call.attrs, "code.origin": codeOrigin };
+        }
+        else if (isMongo(attrs)) {
+            const call = mongoCall(attrs, span.name);
+            converted.kind = "mongodb";
+            converted.name = call.name;
+            converted.attrs = { ...call.attrs, "code.origin": codeOrigin };
+        }
+        else if (span.name === "prisma:client:operation") {
+            converted.name = `prisma ${attrs.model ? `${attrs.model}.` : ""}${attrs.method ?? "operation"}`;
+            converted.attrs = { "code.origin": codeOrigin };
+        }
+        else if (sql) {
+            converted.kind = "sql";
+            converted.name = spanName(sql);
+            converted.attrs = this.sqlAttrs(attrs, sql, codeOrigin);
+            building.queries += 1;
+            building.dbTime += converted.duration;
+        }
+        else if (span.kind === SpanKind.CLIENT && first(attrs, "http.request.method", "http.method")) {
+            const call = httpCall(attrs);
+            converted.kind = "http.client";
+            converted.name = call.name;
+            // The traceparent the call carried names this span: the agent links the callee's trace to it.
+            converted.attrs = { ...call.attrs, "w3c.span_id": context.spanId, "code.origin": codeOrigin };
+        }
+        else {
+            converted.attrs = { ...attrs, "code.origin": codeOrigin };
+        }
+        building.trace.spans.push(converted);
+        this.collectErrors(building, span, id);
+    }
+    sqlAttrs(attrs, sql, codeOrigin) {
+        const system = String(first(attrs, "db.system.name", "db.system") ?? "");
+        // pg reports the parameters with enhancedDatabaseReporting: the same statement with the same values is a
+        // duplicate, the same statement with other values an N+1 candidate.
+        const values = first(attrs, "db.postgresql.values", "db.query.parameter");
+        // What EXPLAIN binds back: pg's values; mysql2 writes them into the statement itself.
+        const params = Array.isArray(values) ? values : system === "mysql" ? [] : undefined;
+        return {
+            ...(params ? { "db.params": params } : {}),
+            "db.client": system === "postgresql" ? "pg" : system,
+            "db.system": system,
+            "db.vendor": system,
+            "db.alias": "default",
+            "db.statement": statement(sql),
+            "db.fingerprint": fingerprint(sql),
+            "db.params_hash": values === undefined ? null : createHash("sha1").update(JSON.stringify(values)).digest("hex").slice(0, 12),
+            "db.many": false,
+            "code.origin": codeOrigin,
+        };
+    }
+    /** Exceptions the instrumentation recorded on a span: the request's errors, with their frames. */
+    collectErrors(building, span, spanId) {
+        for (const event of span.events) {
+            if (event.name !== "exception")
+                continue;
+            const attrs = event.attributes ?? {};
+            const [seconds, nanos] = event.time;
+            building.trace.errors.push({
+                span_id: spanId,
+                time: Math.round(seconds * 1e6 + nanos / 1e3),
+                type: String(attrs["exception.type"] ?? "Error"),
+                message: String(attrs["exception.message"] ?? ""),
+                handled: false,
+                frames: frames(String(attrs["exception.stacktrace"] ?? ""), this.config.root),
+                chain: [],
+            });
+        }
+    }
+    /** The trace from its root span: name, timing, the request's attributes. */
+    finish(building, root) {
+        if (building.trace.kind !== "http") {
+            this.finishWork(building, root);
+            return;
+        }
+        const attrs = attrsOf(root);
+        const method = String(first(attrs, "http.request.method", "http.method") ?? "GET");
+        const path = String(first(attrs, "url.path", "http.target") ?? "/").split("?")[0];
+        const route = first(attrs, "http.route", "next.route") ?? building.route;
+        const status = Number(first(attrs, "http.response.status_code", "http.status_code") ?? 0);
+        const tr = building.trace;
+        if (status > 0 && status < 500) {
+            // Nest throws NotFoundException and the like to answer 404, 422…: an answer, not an error.
+            tr.errors = tr.errors.filter((error) => !building.nestViews.has(error.span_id ?? ""));
+        }
+        tr.name = `${method} ${typeof route === "string" && route ? route : path}`;
+        tr.start = startUs(root);
+        tr.duration = durationUs(root);
+        if (status >= 500 || root.status.code === SpanStatusCode.ERROR || tr.errors.length > 0)
+            tr.status = "error";
+        const rootSpan = tr.spans.find((span) => span.parent_id === null);
+        if (rootSpan)
+            rootSpan.name = tr.name;
+        tr.attrs = {
+            ...tr.attrs,
+            "http.method": method,
+            "http.path": path,
+            "http.route": typeof route === "string" ? route : null,
+            "http.status_code": status,
+            "service.name": this.config.service,
+            "service.role": "web",
+            "telemetry.sdk.language": "nodejs",
+            "process.runtime.name": process.versions.bun ? "bun" : "node",
+            "process.runtime.version": process.versions.bun ?? process.versions.node,
+            "tracepanel.framework": withVersion(building.framework),
+            // The W3C ids: the agent links this trace to the one that called it, in another app or process.
+            "w3c.trace_id": root.spanContext().traceId,
+        };
+        if (root.parentSpanContext?.isRemote)
+            tr.attrs["w3c.parent_span_id"] = root.parentSpanContext.spanId;
+    }
+    /** A command (trace()) or a task (a queue's job): named as it was started, its task.* attributes kept. */
+    finishWork(building, root) {
+        const attrs = attrsOf(root);
+        const tr = building.trace;
+        tr.name = String(attrs["tracepanel.name"] ?? root.name);
+        tr.start = startUs(root);
+        tr.duration = durationUs(root);
+        if (root.status.code === SpanStatusCode.ERROR || tr.errors.length > 0)
+            tr.status = "error";
+        const rootSpan = tr.spans.find((span) => span.parent_id === null);
+        if (rootSpan) {
+            rootSpan.name = tr.name;
+            rootSpan.attrs = {};
+        }
+        const own = Object.fromEntries(Object.entries(attrs).filter(([key]) => key.startsWith("task.")));
+        tr.attrs = {
+            ...tr.attrs,
+            ...own,
+            "service.name": this.config.service,
+            "service.role": tr.kind === "task" ? "worker" : "command",
+            "telemetry.sdk.language": "nodejs",
+            "process.runtime.name": process.versions.bun ? "bun" : "node",
+            "process.runtime.version": process.versions.bun ?? process.versions.node,
+            "w3c.trace_id": root.spanContext().traceId,
+        };
+    }
+}
+function requestKey(method, target) {
+    return `${String(method ?? "GET").toUpperCase()} ${String(target ?? "/")}`;
+}
+/** `Node 26 · Express`: what the panel shows next to its logo. */
+export function runtimeLabel(framework) {
+    const bun = process.versions.bun;
+    const named = withVersion(framework, 2);
+    if (bun)
+        return `Bun ${bun.split(".").slice(0, 2).join(".")} · ${named}`;
+    return `Node ${process.versions.node.split(".")[0]} · ${named}`;
+}
+export { micros };
+//# sourceMappingURL=processor.js.map