@mnemonica/otel 0.1.0

package/build-cjs/providers/async-flow.provider.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncFlowProvider = void 0;
+/**
+ * Async-flow provider — the ALS backbone for dive attribution.
+ *
+ * Design: reports/async-flow-tracking-design.md (2026-09-02).
+ *
+ * One AsyncLocalStorage carrying a linked list of FlowFrames. The root
+ * frame is created per HTTP request by MnemonicaTraceMiddleware (or
+ * manually via runInScope). Every dive 'enter' hook pushes a child frame
+ * (edgeId = the entering edge); 'leave' restores the parent. ALS
+ * propagation then does the tracking for free: an UNWRAPPED async hop
+ * (setTimeout, promise continuation, async-generator suspension) fires
+ * with the scheduling frame in als.getStore() — the parental dive edge
+ * is known without wrapping anything.
+ *
+ * The scoped pin: the root frame owns a pinSet of context instances
+ * (strong refs), filled on enter/create from edge.instance. Lifetime is
+ * the request's async executions — when they die, the store and pinSet
+ * die with them. edge.instance never derefs to undefined mid-request.
+ *
+ * Node-only by design: dive imports no async_hooks (Deno/Bun), the
+ * adapter is the Node boundary where ALS is free.
+ */
+const async_hooks_1 = require("async_hooks");
+const dive_1 = require("@mnemonica/dive");
+const als = new async_hooks_1.AsyncLocalStorage();
+class AsyncFlowProvider {
+    // edgeId → the frame entered for it, so leave restores the exact parent
+    frames = new Map();
+    detachers = [];
+    /**
+     * Subscribe to dive's edge lifecycle. Idempotent: attaching twice would
+     * double every frame push. Dive's clear() wipes subscribers — re-attach
+     * after it.
+     */
+    attach() {
+        if (this.detachers.length > 0) {
+            return;
+        }
+        this.detachers.push((0, dive_1.registerHook)('enter', (payload) => {
+            this.onEnter(payload);
+        }), (0, dive_1.registerHook)('leave', (payload) => {
+            this.onLeave(payload);
+        }));
+        try {
+            this.detachers.push((0, dive_1.registerHook)('create', (payload) => {
+                this.onCreate(payload);
+            }));
+        }
+        catch {
+            // 'create' exists since dive 0.8.0; on 0.7.x registerHook throws —
+            // skipping preserves exactly the pre-subscription behavior.
+        }
+    }
+    detach() {
+        for (const detach of this.detachers) {
+            detach();
+        }
+        this.detachers = [];
+        this.frames.clear();
+    }
+    /**
+     * Establish a root frame for non-HTTP scopes (queue consumers, CLI,
+     * tests). The middleware is the HTTP root.
+     */
+    runInScope(fn) {
+        const root = {
+            edgeId: null,
+            parent: null,
+            pinSet: new Set(),
+        };
+        const result = als.run(root, fn);
+        return result;
+    }
+    /**
+     * The frame active RIGHT NOW — in an uncaughtException handler this is
+     * the failing execution's frame: the parental edge id plus every
+     * context instance pinned by the scope. Undefined outside any scope.
+     */
+    currentFrame() {
+        const frame = als.getStore();
+        if (!frame) {
+            return undefined;
+        }
+        const result = {
+            edgeId: frame.edgeId,
+            instances: [...frame.pinSet],
+        };
+        return result;
+    }
+    onEnter({ edge }) {
+        const current = als.getStore();
+        if (!current) {
+            return;
+        }
+        const frame = {
+            edgeId: edge.id,
+            parent: current,
+            pinSet: current.pinSet,
+        };
+        if (edge.instance !== undefined) {
+            frame.pinSet.add(edge.instance);
+        }
+        this.frames.set(edge.id, frame);
+        als.enterWith(frame);
+    }
+    onLeave({ edge }) {
+        const frame = this.frames.get(edge.id);
+        if (!frame) {
+            return;
+        }
+        this.frames.delete(edge.id);
+        if (frame.parent) {
+            als.enterWith(frame.parent);
+        }
+    }
+    onCreate({ edge }) {
+        const current = als.getStore();
+        if (!current) {
+            return;
+        }
+        // Constructions are one-shot edges (no leave) — no frame of their
+        // own, but the constructed instance is DATA: pin it into the scope.
+        if (edge.instance !== undefined) {
+            current.pinSet.add(edge.instance);
+        }
+    }
+}
+exports.AsyncFlowProvider = AsyncFlowProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async-flow.provider.js","sourceRoot":"","sources":["../../src/providers/async-flow.provider.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Async-flow provider — the ALS backbone for dive attribution.\n *\n * Design: reports/async-flow-tracking-design.md (2026-09-02).\n *\n * One AsyncLocalStorage carrying a linked list of FlowFrames. The root\n * frame is created per HTTP request by MnemonicaTraceMiddleware (or\n * manually via runInScope). Every dive 'enter' hook pushes a child frame\n * (edgeId = the entering edge); 'leave' restores the parent. ALS\n * propagation then does the tracking for free: an UNWRAPPED async hop\n * (setTimeout, promise continuation, async-generator suspension) fires\n * with the scheduling frame in als.getStore() — the parental dive edge\n * is known without wrapping anything.\n *\n * The scoped pin: the root frame owns a pinSet of context instances\n * (strong refs), filled on enter/create from edge.instance. Lifetime is\n * the request's async executions — when they die, the store and pinSet\n * die with them. edge.instance never derefs to undefined mid-request.\n *\n * Node-only by design: dive imports no async_hooks (Deno/Bun), the\n * adapter is the Node boundary where ALS is free.\n */\nimport { AsyncLocalStorage } from 'async_hooks';\nimport { registerHook } from '@mnemonica/dive';\nimport type {\n\tDiveCreatePayload,\n\tDiveEnterPayload,\n\tDiveLeavePayload,\n} from '@mnemonica/dive';\n\nexport type FlowFrame = {\n\t/** the dive edge this frame belongs to (null on the root frame) */\n\tedgeId   : number | null;\n\t/** the frame active when this one was entered */\n\tparent   : FlowFrame | null;\n\t/** strong pins of context instances — ONE set per scope, shared down\n\t *  the chain by reference; dies with the scope's async executions */\n\tpinSet   : Set<object>;\n};\n\n/** Read-only crash-time view of the active frame. */\nexport type CrashContext = {\n\tedgeId    : number | null;\n\tinstances : object[];\n};\n\nconst als = new AsyncLocalStorage<FlowFrame>();\n\nexport class AsyncFlowProvider {\n\t// edgeId → the frame entered for it, so leave restores the exact parent\n\tprivate frames = new Map<number, FlowFrame>();\n\tprivate detachers: Array<() => void> = [];\n\n\t/**\n\t * Subscribe to dive's edge lifecycle. Idempotent: attaching twice would\n\t * double every frame push. Dive's clear() wipes subscribers — re-attach\n\t * after it.\n\t */\n\tattach (): void {\n\t\tif (this.detachers.length > 0) {\n\t\t\treturn;\n\t\t}\n\t\tthis.detachers.push(\n\t\t\tregisterHook('enter', (payload) => {\n\t\t\t\tthis.onEnter(payload);\n\t\t\t}),\n\t\t\tregisterHook('leave', (payload) => {\n\t\t\t\tthis.onLeave(payload);\n\t\t\t}),\n\t\t);\n\t\ttry {\n\t\t\tthis.detachers.push(\n\t\t\t\tregisterHook('create', (payload) => {\n\t\t\t\t\tthis.onCreate(payload);\n\t\t\t\t}),\n\t\t\t);\n\t\t} catch {\n\t\t\t// 'create' exists since dive 0.8.0; on 0.7.x registerHook throws —\n\t\t\t// skipping preserves exactly the pre-subscription behavior.\n\t\t}\n\t}\n\n\tdetach (): void {\n\t\tfor (const detach of this.detachers) {\n\t\t\tdetach();\n\t\t}\n\t\tthis.detachers = [];\n\t\tthis.frames.clear();\n\t}\n\n\t/**\n\t * Establish a root frame for non-HTTP scopes (queue consumers, CLI,\n\t * tests). The middleware is the HTTP root.\n\t */\n\trunInScope<T> (fn: () => T): T {\n\t\tconst root: FlowFrame = {\n\t\t\tedgeId : null,\n\t\t\tparent : null,\n\t\t\tpinSet : new Set<object>(),\n\t\t};\n\t\tconst result = als.run(root, fn);\n\t\treturn result;\n\t}\n\n\t/**\n\t * The frame active RIGHT NOW — in an uncaughtException handler this is\n\t * the failing execution's frame: the parental edge id plus every\n\t * context instance pinned by the scope. Undefined outside any scope.\n\t */\n\tcurrentFrame (): CrashContext | undefined {\n\t\tconst frame = als.getStore();\n\t\tif (!frame) {\n\t\t\treturn undefined;\n\t\t}\n\t\tconst result: CrashContext = {\n\t\t\tedgeId    : frame.edgeId,\n\t\t\tinstances : [...frame.pinSet],\n\t\t};\n\t\treturn result;\n\t}\n\n\tprivate onEnter ({ edge }: DiveEnterPayload): void {\n\t\tconst current = als.getStore();\n\t\tif (!current) {\n\t\t\treturn;\n\t\t}\n\t\tconst frame: FlowFrame = {\n\t\t\tedgeId : edge.id,\n\t\t\tparent : current,\n\t\t\tpinSet : current.pinSet,\n\t\t};\n\t\tif (edge.instance !== undefined) {\n\t\t\tframe.pinSet.add(edge.instance);\n\t\t}\n\t\tthis.frames.set(edge.id, frame);\n\t\tals.enterWith(frame);\n\t}\n\n\tprivate onLeave ({ edge }: DiveLeavePayload): void {\n\t\tconst frame = this.frames.get(edge.id);\n\t\tif (!frame) {\n\t\t\treturn;\n\t\t}\n\t\tthis.frames.delete(edge.id);\n\t\tif (frame.parent) {\n\t\t\tals.enterWith(frame.parent);\n\t\t}\n\t}\n\n\tprivate onCreate ({ edge }: DiveCreatePayload): void {\n\t\tconst current = als.getStore();\n\t\tif (!current) {\n\t\t\treturn;\n\t\t}\n\t\t// Constructions are one-shot edges (no leave) — no frame of their\n\t\t// own, but the constructed instance is DATA: pin it into the scope.\n\t\tif (edge.instance !== undefined) {\n\t\t\tcurrent.pinSet.add(edge.instance);\n\t\t}\n\t}\n}\n"]}

package/build-cjs/providers/dive-otel.provider.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiveOtelProvider = void 0;
+const api_1 = require("@opentelemetry/api");
+const dive_1 = require("@mnemonica/dive");
+// Call/method/construct edges carry their callsite as `name`
+// (`/abs/file.ts:line:col`, 1-based) — surfaced as OTEL semconv code.*
+// attributes so Jaeger can link straight to the source (Wanted #4).
+const CALLSITE_RE = /^(.*):(\d+):(\d+)$/;
+// Wanted #2 (2026-09-01): the strategy push channel (an injected script,
+// see strategy/cdp-scripts/ws-server.js) cannot see OTEL spans, so the
+// adapter publishes edgeId → traceId on a bounded global map; the push
+// mapper forwards it and mnemographica's Live Trace gains the "Open in
+// Jaeger" jump. globalThis because adapter and injected script share a
+// process, not a module graph.
+const EDGE_TRACES_LIMIT = 10000;
+function edgeTraceMap() {
+    const g = globalThis;
+    if (!g.__mnemonicaDiveTraceIds) {
+        g.__mnemonicaDiveTraceIds = new Map();
+    }
+    const map = g.__mnemonicaDiveTraceIds;
+    return map;
+}
+function recordEdgeTrace(edgeId, traceId) {
+    const map = edgeTraceMap();
+    if (map.has(edgeId)) {
+        map.delete(edgeId);
+    }
+    else if (map.size >= EDGE_TRACES_LIMIT) {
+        // FIFO: the oldest entry dies first — Map iterates insertion order
+        const oldest = map.keys().next();
+        if (!oldest.done) {
+            map.delete(oldest.value);
+        }
+    }
+    map.set(edgeId, traceId);
+}
+class DiveOtelProvider {
+    tracer;
+    // open spans, keyed on dive edge id — drained by leave/settle
+    spans = new Map();
+    // edge id → parentId, for the root-edge walk (dive.root_edge_id span
+    // attribute). Never drained mid-flight: a completed edge can still
+    // parent later children (a create edge adopts the next wrapped call),
+    // so the map is bounded coarsely instead.
+    edgeParents = new Map();
+    static EDGE_PARENTS_LIMIT = 20000;
+    detachers = [];
+    constructor(tracer) {
+        this.tracer = tracer ?? api_1.trace.getTracer('@mnemonica/otel');
+    }
+    /**
+     * Subscribe to dive's edge lifecycle. Idempotent: attaching twice would
+     * double every span. Dive's clear() wipes subscribers — re-attach after it.
+     */
+    attach() {
+        if (this.detachers.length > 0) {
+            return;
+        }
+        this.detachers.push((0, dive_1.registerHook)('enter', (payload) => {
+            this.onEnter(payload);
+        }), (0, dive_1.registerHook)('leave', (payload) => {
+            this.onLeave(payload);
+        }), (0, dive_1.registerHook)('settle', (payload) => {
+            this.onSettle(payload);
+        }), (0, dive_1.registerHook)('recontext', (payload) => {
+            this.onRecontext(payload);
+        }));
+        try {
+            this.detachers.push((0, dive_1.registerHook)('create', (payload) => {
+                this.onCreate(payload);
+            }));
+        }
+        catch {
+            // The 'create' event exists since dive 0.8.0; on 0.7.x registerHook
+            // throws on the unknown event. Skipping it there preserves exactly
+            // the pre-subscription behavior (constructions stay unspanned), so
+            // the widened ^0.7.0 || ^0.8.0 peer range stays honest.
+        }
+    }
+    detach() {
+        for (const detach of this.detachers) {
+            detach();
+        }
+        this.detachers = [];
+    }
+    onEnter({ edge }) {
+        const parentSpan = this.findParentSpan(edge);
+        const ctx = parentSpan
+            ? api_1.trace.setSpan(api_1.context.active(), parentSpan)
+            : undefined;
+        const name = `dive.${edge.kind}:${edge.name}`;
+        const span = ctx
+            ? this.tracer.startSpan(name, {}, ctx)
+            : this.tracer.startSpan(name);
+        span.setAttribute('dive.edge_id', edge.id);
+        span.setAttribute('dive.kind', edge.kind);
+        span.setAttribute('dive.name', edge.name);
+        this.decorateSpan(span, edge);
+        this.spans.set(edge.id, span);
+    }
+    onLeave({ edge, result }) {
+        if (result instanceof Promise) {
+            // async work: the span closes at settle, not at the sync head —
+            // "the function returned" is not "the work is done"
+            return;
+        }
+        this.closeSpan(edge);
+    }
+    onSettle({ edge, error }) {
+        this.closeSpan(edge, error);
+    }
+    onRecontext({ edge, previousContext, context }) {
+        // One-shot span: the ownership transfer itself, parented on the OLD
+        // context's span (the handoff edge's parentId), so the trace shows
+        // where the callback's story crossed flows.
+        const parentSpan = this.findParentSpan(edge);
+        const ctx = parentSpan
+            ? api_1.trace.setSpan(api_1.context.active(), parentSpan)
+            : undefined;
+        const name = `dive.${edge.kind}:${edge.name}`;
+        const span = ctx
+            ? this.tracer.startSpan(name, {}, ctx)
+            : this.tracer.startSpan(name);
+        span.setAttribute('dive.edge_id', edge.id);
+        span.setAttribute('dive.kind', edge.kind);
+        span.setAttribute('dive.name', edge.name);
+        span.setAttribute('dive.handoff', true);
+        span.setAttribute('dive.handoff.had_previous', previousContext !== undefined);
+        span.setAttribute('dive.handoff.has_context', context !== undefined);
+        this.decorateSpan(span, edge);
+        span.end();
+    }
+    onCreate({ edge, error }) {
+        // One-shot span: the construction already completed when recordCreation
+        // fired (the hook moment IS the completion), so the span starts and
+        // ends here — same shape as recontext. findParentSpan adopts the
+        // wrapped call's span via edge.parentId, or the active request span at
+        // a boundary, so constructions join the request trace instead of
+        // opening a root trace of their own.
+        const parentSpan = this.findParentSpan(edge);
+        const ctx = parentSpan
+            ? api_1.trace.setSpan(api_1.context.active(), parentSpan)
+            : undefined;
+        const name = `dive.${edge.kind}:${edge.name}`;
+        const span = ctx
+            ? this.tracer.startSpan(name, {}, ctx)
+            : this.tracer.startSpan(name);
+        span.setAttribute('dive.edge_id', edge.id);
+        span.setAttribute('dive.kind', edge.kind);
+        span.setAttribute('dive.name', edge.name);
+        span.setAttribute('dive.status', edge.status);
+        if (edge.duration !== undefined) {
+            span.setAttribute('dive.duration_ms', edge.duration);
+        }
+        this.decorateSpan(span, edge);
+        if (edge.status === 'error') {
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR });
+            if (error instanceof Error) {
+                span.recordException(error);
+            }
+        }
+        span.end();
+    }
+    findParentSpan(edge) {
+        if (edge.parentId !== null) {
+            const own = this.spans.get(edge.parentId);
+            if (own) {
+                return own;
+            }
+        }
+        // Boundary (or evicted parent): adopt the active OTel span — the HTTP
+        // request span becomes the root of the dive branch.
+        const active = api_1.trace.getSpan(api_1.context.active());
+        return active;
+    }
+    closeSpan(edge, error) {
+        const span = this.spans.get(edge.id);
+        if (!span) {
+            return;
+        }
+        this.spans.delete(edge.id);
+        span.setAttribute('dive.status', edge.status);
+        if (edge.duration !== undefined) {
+            span.setAttribute('dive.duration_ms', edge.duration);
+        }
+        if (edge.status === 'error') {
+            // sync throws carry no error value in the leave payload — the
+            // edge's own status is the truthful signal; the exception record
+            // is available only when settle carried the rejection itself
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR });
+            if (error instanceof Error) {
+                span.recordException(error);
+            }
+        }
+        span.end();
+    }
+    /**
+     * Cross-surface attributes every span gets, on every hook path:
+     * the edge's trace root id (Jaeger link → mnemographica's Live Trace,
+     * Wanted #1), the edgeId→traceId publication for the strategy push
+     * channel (Wanted #2), and code.filepath/line/column parsed from the
+     * callsite name (Wanted #4).
+     */
+    decorateSpan(span, edge) {
+        span.setAttribute('dive.root_edge_id', this.rootEdgeIdOf(edge));
+        recordEdgeTrace(edge.id, span.spanContext().traceId);
+        if (edge.kind !== 'call' && edge.kind !== 'method' && edge.kind !== 'construct') {
+            return;
+        }
+        const match = CALLSITE_RE.exec(edge.name);
+        if (!match) {
+            return;
+        }
+        span.setAttribute('code.filepath', match[1]);
+        span.setAttribute('code.lineno', Number(match[2]));
+        span.setAttribute('code.column', Number(match[3]));
+    }
+    // Walk dive's parentage to the root edge id. Parents are recorded as
+    // edges arrive (enter fires parent-before-child), so the chain is
+    // complete for anything still in flight; an evicted/unknown parent
+    // simply ends the walk at the deepest known id.
+    rootEdgeIdOf(edge) {
+        if (this.edgeParents.size >= DiveOtelProvider.EDGE_PARENTS_LIMIT) {
+            this.edgeParents.clear();
+        }
+        this.edgeParents.set(edge.id, edge.parentId);
+        let id = edge.id;
+        let parent = edge.parentId;
+        const seen = new Set([id]);
+        while (parent !== null && !seen.has(parent)) {
+            seen.add(parent);
+            id = parent;
+            const next = this.edgeParents.get(parent);
+            parent = next === undefined ? null : next;
+        }
+        return id;
+    }
+}
+exports.DiveOtelProvider = DiveOtelProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dive-otel.provider.js","sourceRoot":"","sources":["../../src/providers/dive-otel.provider.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenTelemetry provider for dive's edge lifecycle hooks.\n *\n * Where MnemonicaOtelProvider spans CONSTRUCTIONS (mnemonica hooks), this\n * provider spans EVERY WRAPPED CALL (dive hooks): call / construct / method /\n * recontext edges each become a span, parented on the span of the edge's\n * parentId — dive's own trace parentage, not ALS. At unwrapped boundaries\n * (parentId null) the span adopts the currently ACTIVE OTel span as parent,\n * so an\n * HTTP request span adopts the whole dive branch. 'create' edges (mnemonica\n * constructions recorded via recordCreation/recordCreationError) become\n * one-shot spans on the same parentage — the construction HAS completed when\n * the hook fires, so the span starts and ends inside the handler.\n *\n * Async truthfulness: a span does NOT end at the sync close when the wrap\n * produced a tapped promise — it ends at settle, with the chain's outcome.\n * Spans are keyed on edge id; every recorded edge fires leave (and, when\n * async, settle), so the map always drains.\n */\nimport type { Span, Tracer } from '@opentelemetry/api';\nimport { SpanStatusCode, context as otelContext, trace } from '@opentelemetry/api';\nimport {\n\tregisterHook,\n\ttype DiveCreatePayload,\n\ttype DiveEnterPayload,\n\ttype DiveLeavePayload,\n\ttype DiveRecontextPayload,\n\ttype DiveSettlePayload,\n\ttype FlowEdge,\n} from '@mnemonica/dive';\n\n// Call/method/construct edges carry their callsite as `name`\n// (`/abs/file.ts:line:col`, 1-based) — surfaced as OTEL semconv code.*\n// attributes so Jaeger can link straight to the source (Wanted #4).\nconst CALLSITE_RE = /^(.*):(\\d+):(\\d+)$/;\n\n// Wanted #2 (2026-09-01): the strategy push channel (an injected script,\n// see strategy/cdp-scripts/ws-server.js) cannot see OTEL spans, so the\n// adapter publishes edgeId → traceId on a bounded global map; the push\n// mapper forwards it and mnemographica's Live Trace gains the \"Open in\n// Jaeger\" jump. globalThis because adapter and injected script share a\n// process, not a module graph.\nconst EDGE_TRACES_LIMIT = 10000;\ntype EdgeTraceMap = Map<number, string>;\nfunction edgeTraceMap (): EdgeTraceMap {\n\tconst g = globalThis as { __mnemonicaDiveTraceIds?: EdgeTraceMap };\n\tif (!g.__mnemonicaDiveTraceIds) {\n\t\tg.__mnemonicaDiveTraceIds = new Map();\n\t}\n\tconst map = g.__mnemonicaDiveTraceIds;\n\treturn map;\n}\nfunction recordEdgeTrace (edgeId: number, traceId: string): void {\n\tconst map = edgeTraceMap();\n\tif (map.has(edgeId)) {\n\t\tmap.delete(edgeId);\n\t} else if (map.size >= EDGE_TRACES_LIMIT) {\n\t\t// FIFO: the oldest entry dies first — Map iterates insertion order\n\t\tconst oldest = map.keys().next();\n\t\tif (!oldest.done) {\n\t\t\tmap.delete(oldest.value);\n\t\t}\n\t}\n\tmap.set(edgeId, traceId);\n}\n\nexport class DiveOtelProvider {\n\tprivate tracer: Tracer;\n\t// open spans, keyed on dive edge id — drained by leave/settle\n\tprivate spans = new Map<number, Span>();\n\t// edge id → parentId, for the root-edge walk (dive.root_edge_id span\n\t// attribute). Never drained mid-flight: a completed edge can still\n\t// parent later children (a create edge adopts the next wrapped call),\n\t// so the map is bounded coarsely instead.\n\tprivate edgeParents = new Map<number, number | null>();\n\tprivate static readonly EDGE_PARENTS_LIMIT = 20000;\n\tprivate detachers: Array<() => void> = [];\n\n\tconstructor (tracer?: Tracer) {\n\t\tthis.tracer = tracer ?? trace.getTracer('@mnemonica/otel');\n\t}\n\n\t/**\n\t * Subscribe to dive's edge lifecycle. Idempotent: attaching twice would\n\t * double every span. Dive's clear() wipes subscribers — re-attach after it.\n\t */\n\tattach (): void {\n\t\tif (this.detachers.length > 0) {\n\t\t\treturn;\n\t\t}\n\t\tthis.detachers.push(\n\t\t\tregisterHook('enter', (payload) => {\n\t\t\t\tthis.onEnter(payload);\n\t\t\t}),\n\t\t\tregisterHook('leave', (payload) => {\n\t\t\t\tthis.onLeave(payload);\n\t\t\t}),\n\t\t\tregisterHook('settle', (payload) => {\n\t\t\t\tthis.onSettle(payload);\n\t\t\t}),\n\t\t\tregisterHook('recontext', (payload) => {\n\t\t\t\tthis.onRecontext(payload);\n\t\t\t}),\n\t\t);\n\t\ttry {\n\t\t\tthis.detachers.push(\n\t\t\t\tregisterHook('create', (payload) => {\n\t\t\t\t\tthis.onCreate(payload);\n\t\t\t\t}),\n\t\t\t);\n\t\t} catch {\n\t\t\t// The 'create' event exists since dive 0.8.0; on 0.7.x registerHook\n\t\t\t// throws on the unknown event. Skipping it there preserves exactly\n\t\t\t// the pre-subscription behavior (constructions stay unspanned), so\n\t\t\t// the widened ^0.7.0 || ^0.8.0 peer range stays honest.\n\t\t}\n\t}\n\n\tdetach (): void {\n\t\tfor (const detach of this.detachers) {\n\t\t\tdetach();\n\t\t}\n\t\tthis.detachers = [];\n\t}\n\n\tprivate onEnter ({ edge }: DiveEnterPayload): void {\n\t\tconst parentSpan = this.findParentSpan(edge);\n\t\tconst ctx = parentSpan\n\t\t\t? trace.setSpan(otelContext.active(), parentSpan)\n\t\t\t: undefined;\n\t\tconst name = `dive.${edge.kind}:${edge.name}`;\n\t\tconst span = ctx\n\t\t\t? this.tracer.startSpan(name, {}, ctx)\n\t\t\t: this.tracer.startSpan(name);\n\n\t\tspan.setAttribute('dive.edge_id', edge.id);\n\t\tspan.setAttribute('dive.kind', edge.kind);\n\t\tspan.setAttribute('dive.name', edge.name);\n\t\tthis.decorateSpan(span, edge);\n\n\t\tthis.spans.set(edge.id, span);\n\t}\n\n\tprivate onLeave ({ edge, result }: DiveLeavePayload): void {\n\t\tif (result instanceof Promise) {\n\t\t\t// async work: the span closes at settle, not at the sync head —\n\t\t\t// \"the function returned\" is not \"the work is done\"\n\t\t\treturn;\n\t\t}\n\t\tthis.closeSpan(edge);\n\t}\n\n\tprivate onSettle ({ edge, error }: DiveSettlePayload): void {\n\t\tthis.closeSpan(edge, error);\n\t}\n\n\tprivate onRecontext ({ edge, previousContext, context }: DiveRecontextPayload): void {\n\t\t// One-shot span: the ownership transfer itself, parented on the OLD\n\t\t// context's span (the handoff edge's parentId), so the trace shows\n\t\t// where the callback's story crossed flows.\n\t\tconst parentSpan = this.findParentSpan(edge);\n\t\tconst ctx = parentSpan\n\t\t\t? trace.setSpan(otelContext.active(), parentSpan)\n\t\t\t: undefined;\n\t\tconst name = `dive.${edge.kind}:${edge.name}`;\n\t\tconst span = ctx\n\t\t\t? this.tracer.startSpan(name, {}, ctx)\n\t\t\t: this.tracer.startSpan(name);\n\n\t\tspan.setAttribute('dive.edge_id', edge.id);\n\t\tspan.setAttribute('dive.kind', edge.kind);\n\t\tspan.setAttribute('dive.name', edge.name);\n\t\tspan.setAttribute('dive.handoff', true);\n\t\tspan.setAttribute('dive.handoff.had_previous', previousContext !== undefined);\n\t\tspan.setAttribute('dive.handoff.has_context', context !== undefined);\n\t\tthis.decorateSpan(span, edge);\n\t\tspan.end();\n\t}\n\n\tprivate onCreate ({ edge, error }: DiveCreatePayload): void {\n\t\t// One-shot span: the construction already completed when recordCreation\n\t\t// fired (the hook moment IS the completion), so the span starts and\n\t\t// ends here — same shape as recontext. findParentSpan adopts the\n\t\t// wrapped call's span via edge.parentId, or the active request span at\n\t\t// a boundary, so constructions join the request trace instead of\n\t\t// opening a root trace of their own.\n\t\tconst parentSpan = this.findParentSpan(edge);\n\t\tconst ctx = parentSpan\n\t\t\t? trace.setSpan(otelContext.active(), parentSpan)\n\t\t\t: undefined;\n\t\tconst name = `dive.${edge.kind}:${edge.name}`;\n\t\tconst span = ctx\n\t\t\t? this.tracer.startSpan(name, {}, ctx)\n\t\t\t: this.tracer.startSpan(name);\n\n\t\tspan.setAttribute('dive.edge_id', edge.id);\n\t\tspan.setAttribute('dive.kind', edge.kind);\n\t\tspan.setAttribute('dive.name', edge.name);\n\t\tspan.setAttribute('dive.status', edge.status);\n\t\tif (edge.duration !== undefined) {\n\t\t\tspan.setAttribute('dive.duration_ms', edge.duration);\n\t\t}\n\t\tthis.decorateSpan(span, edge);\n\t\tif (edge.status === 'error') {\n\t\t\tspan.setStatus({ code: SpanStatusCode.ERROR });\n\t\t\tif (error instanceof Error) {\n\t\t\t\tspan.recordException(error);\n\t\t\t}\n\t\t}\n\t\tspan.end();\n\t}\n\n\tprivate findParentSpan (edge: FlowEdge): Span | undefined {\t\tif (edge.parentId !== null) {\n\t\t\tconst own = this.spans.get(edge.parentId);\n\t\t\tif (own) {\n\t\t\t\treturn own;\n\t\t\t}\n\t\t}\n\t\t// Boundary (or evicted parent): adopt the active OTel span — the HTTP\n\t\t// request span becomes the root of the dive branch.\n\t\tconst active = trace.getSpan(otelContext.active());\n\t\treturn active;\n\t}\n\n\tprivate closeSpan (edge: FlowEdge, error?: unknown): void {\n\t\tconst span = this.spans.get(edge.id);\n\t\tif (!span) {\n\t\t\treturn;\n\t\t}\n\t\tthis.spans.delete(edge.id);\n\n\t\tspan.setAttribute('dive.status', edge.status);\n\t\tif (edge.duration !== undefined) {\n\t\t\tspan.setAttribute('dive.duration_ms', edge.duration);\n\t\t}\n\t\tif (edge.status === 'error') {\n\t\t\t// sync throws carry no error value in the leave payload — the\n\t\t\t// edge's own status is the truthful signal; the exception record\n\t\t\t// is available only when settle carried the rejection itself\n\t\t\tspan.setStatus({ code: SpanStatusCode.ERROR });\n\t\t\tif (error instanceof Error) {\n\t\t\t\tspan.recordException(error);\n\t\t\t}\n\t\t}\n\t\tspan.end();\n\t}\n\n\t/**\n\t * Cross-surface attributes every span gets, on every hook path:\n\t * the edge's trace root id (Jaeger link → mnemographica's Live Trace,\n\t * Wanted #1), the edgeId→traceId publication for the strategy push\n\t * channel (Wanted #2), and code.filepath/line/column parsed from the\n\t * callsite name (Wanted #4).\n\t */\n\tprivate decorateSpan (span: Span, edge: FlowEdge): void {\n\t\tspan.setAttribute('dive.root_edge_id', this.rootEdgeIdOf(edge));\n\t\trecordEdgeTrace(edge.id, span.spanContext().traceId);\n\t\tif (edge.kind !== 'call' && edge.kind !== 'method' && edge.kind !== 'construct') {\n\t\t\treturn;\n\t\t}\n\t\tconst match = CALLSITE_RE.exec(edge.name);\n\t\tif (!match) {\n\t\t\treturn;\n\t\t}\n\t\tspan.setAttribute('code.filepath', match[1]);\n\t\tspan.setAttribute('code.lineno', Number(match[2]));\n\t\tspan.setAttribute('code.column', Number(match[3]));\n\t}\n\n\t// Walk dive's parentage to the root edge id. Parents are recorded as\n\t// edges arrive (enter fires parent-before-child), so the chain is\n\t// complete for anything still in flight; an evicted/unknown parent\n\t// simply ends the walk at the deepest known id.\n\tprivate rootEdgeIdOf (edge: FlowEdge): number {\n\t\tif (this.edgeParents.size >= DiveOtelProvider.EDGE_PARENTS_LIMIT) {\n\t\t\tthis.edgeParents.clear();\n\t\t}\n\t\tthis.edgeParents.set(edge.id, edge.parentId);\n\t\tlet id = edge.id;\n\t\tlet parent = edge.parentId;\n\t\tconst seen = new Set<number>([id]);\n\t\twhile (parent !== null && !seen.has(parent)) {\n\t\t\tseen.add(parent);\n\t\t\tid = parent;\n\t\t\tconst next = this.edgeParents.get(parent);\n\t\t\tparent = next === undefined ? null : next;\n\t\t}\n\t\treturn id;\n\t}\n}\n"]}

package/build-cjs/providers/mnemonica-otel.provider.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MnemonicaOtelProvider = void 0;
+/**
+ * OpenTelemetry provider for mnemonica lifecycle hooks.
+ *
+ * Creates spans for preCreation / postCreation / creationError,
+ * parents them along the prototype chain, and propagates
+ * context via AsyncLocalStorage.
+ */
+const async_hooks_1 = require("async_hooks");
+const api_1 = require("@opentelemetry/api");
+const SymbolParentSpan = Symbol.for('mnemonica.span.parent');
+const asyncStorage = new async_hooks_1.AsyncLocalStorage();
+class MnemonicaOtelProvider {
+    tracer;
+    // spans of constructions in flight, keyed on the per-call args array
+    // (the only value core guarantees identical between pre and post hooks)
+    pendingSpans = new WeakMap();
+    constructor(tracer) {
+        this.tracer = tracer ?? api_1.trace.getTracer('@mnemonica/otel');
+    }
+    getCurrentSpan() {
+        return asyncStorage.getStore();
+    }
+    runWithSpan(span, fn) {
+        return asyncStorage.run(span, fn);
+    }
+    attachHooks(collection) {
+        collection.registerHook('preCreation', (hookData) => {
+            const parentSpan = this.findParentSpan(hookData);
+            const ctx = parentSpan
+                ? api_1.trace.setSpan(api_1.context.active(), parentSpan)
+                : undefined;
+            const span = parentSpan
+                ? this.tracer.startSpan(`mnemonica.${hookData.TypeName}`, {}, ctx)
+                : this.tracer.startSpan(`mnemonica.${hookData.TypeName}`);
+            span.setAttribute('mnemonica.type_name', hookData.TypeName);
+            span.setAttribute('mnemonica.hook', 'preCreation');
+            // Store the pending span keyed on the construction's args array:
+            // core passes the identical args reference to preCreation and to
+            // postCreation/creationError, and it is unique per construction call.
+            // Keying on the parent instance would collide when async constructions
+            // of siblings interleave (preA, preB, postB, postA — the second
+            // preCreation would overwrite the first).
+            this.pendingSpans.set(hookData.args, span);
+        });
+        collection.registerHook('postCreation', (hookData) => {
+            const newInstance = hookData.inheritedInstance;
+            if (newInstance == null || typeof newInstance !== 'object') {
+                return;
+            }
+            // Retrieve and remove the pending span for this construction
+            let span = this.pendingSpans.get(hookData.args);
+            this.pendingSpans.delete(hookData.args);
+            if (!span) {
+                // Fallback: create span here if preCreation didn't (shouldn't happen)
+                span = this.tracer.startSpan(`mnemonica.${hookData.TypeName}`);
+                span.setAttribute('mnemonica.type_name', hookData.TypeName);
+            }
+            span.setAttribute('mnemonica.hook', 'postCreation');
+            span.end();
+            // Store on new instance so its children can find the parent span
+            Object.defineProperty(newInstance, SymbolParentSpan, {
+                value: span,
+                configurable: true,
+                enumerable: false,
+                writable: true,
+            });
+        });
+        collection.registerHook('creationError', (hookData) => {
+            const newInstance = hookData.inheritedInstance;
+            if (newInstance == null || typeof newInstance !== 'object') {
+                return;
+            }
+            // Retrieve and remove the pending span for this construction
+            let span = this.pendingSpans.get(hookData.args);
+            this.pendingSpans.delete(hookData.args);
+            if (!span) {
+                span = this.tracer.startSpan(`mnemonica.${hookData.TypeName}`);
+                span.setAttribute('mnemonica.type_name', hookData.TypeName);
+            }
+            span.setAttribute('mnemonica.hook', 'creationError');
+            span.setAttribute('error.type', 'Error');
+            span.recordException(newInstance);
+            span.end();
+            // Store on error instance for chain tracing
+            Object.defineProperty(newInstance, SymbolParentSpan, {
+                value: span,
+                configurable: true,
+                enumerable: false,
+                writable: true,
+            });
+        });
+    }
+    findParentSpan(hookData) {
+        const stored = asyncStorage.getStore();
+        if (stored) {
+            return stored;
+        }
+        const parent = hookData.existentInstance;
+        if (parent == null || typeof parent !== 'object') {
+            return undefined;
+        }
+        let current = parent;
+        while (current) {
+            const span = current[SymbolParentSpan];
+            if (span) {
+                return span;
+            }
+            current = Object.getPrototypeOf(current);
+        }
+        return undefined;
+    }
+}
+exports.MnemonicaOtelProvider = MnemonicaOtelProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mnemonica-otel.provider.js","sourceRoot":"","sources":["../../src/providers/mnemonica-otel.provider.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenTelemetry provider for mnemonica lifecycle hooks.\n *\n * Creates spans for preCreation / postCreation / creationError,\n * parents them along the prototype chain, and propagates\n * context via AsyncLocalStorage.\n */\nimport { AsyncLocalStorage } from 'async_hooks';\nimport type { Tracer, Span } from '@opentelemetry/api';\nimport { trace, context as otelContext } from '@opentelemetry/api';\nimport type { hooksOpts, TypesCollection } from 'mnemonica/module';\n\nconst SymbolParentSpan = Symbol.for('mnemonica.span.parent');\nconst asyncStorage = new AsyncLocalStorage<Span>();\n\nexport class MnemonicaOtelProvider {\n\tprivate tracer: Tracer;\n\t// spans of constructions in flight, keyed on the per-call args array\n\t// (the only value core guarantees identical between pre and post hooks)\n\tprivate pendingSpans = new WeakMap<object, Span>();\n\n\tconstructor (tracer?: Tracer) {\n\t\tthis.tracer = tracer ?? trace.getTracer('@mnemonica/otel');\n\t}\n\n\tgetCurrentSpan (): Span | undefined {\n\t\treturn asyncStorage.getStore();\n\t}\n\n\trunWithSpan<T> (span: Span, fn: () => T): T {\n\t\treturn asyncStorage.run(span, fn);\n\t}\n\n\tattachHooks (collection: TypesCollection): void {\n\t\tcollection.registerHook('preCreation', (hookData: hooksOpts) => {\n\t\t\tconst parentSpan = this.findParentSpan(hookData);\n\t\t\tconst ctx = parentSpan\n\t\t\t\t? trace.setSpan(otelContext.active(), parentSpan)\n\t\t\t\t: undefined;\n\t\t\tconst span = parentSpan\n\t\t\t\t? this.tracer.startSpan(\n\t\t\t\t\t`mnemonica.${hookData.TypeName}`,\n\t\t\t\t\t{},\n\t\t\t\t\tctx\n\t\t\t\t)\n\t\t\t\t: this.tracer.startSpan(`mnemonica.${hookData.TypeName}`);\n\n\t\t\tspan.setAttribute('mnemonica.type_name', hookData.TypeName);\n\t\t\tspan.setAttribute('mnemonica.hook', 'preCreation');\n\n\t\t\t// Store the pending span keyed on the construction's args array:\n\t\t\t// core passes the identical args reference to preCreation and to\n\t\t\t// postCreation/creationError, and it is unique per construction call.\n\t\t\t// Keying on the parent instance would collide when async constructions\n\t\t\t// of siblings interleave (preA, preB, postB, postA — the second\n\t\t\t// preCreation would overwrite the first).\n\t\t\tthis.pendingSpans.set(hookData.args, span);\n\t\t});\n\n\t\tcollection.registerHook('postCreation', (hookData: hooksOpts) => {\n\t\t\tconst newInstance = hookData.inheritedInstance;\n\t\t\tif (newInstance == null || typeof newInstance !== 'object') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Retrieve and remove the pending span for this construction\n\t\t\tlet span = this.pendingSpans.get(hookData.args);\n\t\t\tthis.pendingSpans.delete(hookData.args);\n\n\t\t\tif (!span) {\n\t\t\t\t// Fallback: create span here if preCreation didn't (shouldn't happen)\n\t\t\t\tspan = this.tracer.startSpan(`mnemonica.${hookData.TypeName}`);\n\t\t\t\tspan.setAttribute('mnemonica.type_name', hookData.TypeName);\n\t\t\t}\n\n\t\t\tspan.setAttribute('mnemonica.hook', 'postCreation');\n\t\t\tspan.end();\n\n\t\t\t// Store on new instance so its children can find the parent span\n\t\t\tObject.defineProperty(newInstance, SymbolParentSpan, {\n\t\t\t\tvalue       : span,\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable  : false,\n\t\t\t\twritable    : true,\n\t\t\t});\n\t\t});\n\n\t\tcollection.registerHook('creationError', (hookData: hooksOpts) => {\n\t\t\tconst newInstance = hookData.inheritedInstance;\n\t\t\tif (newInstance == null || typeof newInstance !== 'object') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Retrieve and remove the pending span for this construction\n\t\t\tlet span = this.pendingSpans.get(hookData.args);\n\t\t\tthis.pendingSpans.delete(hookData.args);\n\n\t\t\tif (!span) {\n\t\t\t\tspan = this.tracer.startSpan(`mnemonica.${hookData.TypeName}`);\n\t\t\t\tspan.setAttribute('mnemonica.type_name', hookData.TypeName);\n\t\t\t}\n\n\t\t\tspan.setAttribute('mnemonica.hook', 'creationError');\n\t\t\tspan.setAttribute('error.type', 'Error');\n\t\t\tspan.recordException(newInstance as Error);\n\t\t\tspan.end();\n\n\t\t\t// Store on error instance for chain tracing\n\t\t\tObject.defineProperty(newInstance, SymbolParentSpan, {\n\t\t\t\tvalue       : span,\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable  : false,\n\t\t\t\twritable    : true,\n\t\t\t});\n\t\t});\n\t}\n\n\tprivate findParentSpan (hookData: hooksOpts): Span | undefined {\n\t\tconst stored = asyncStorage.getStore();\n\t\tif (stored) {\n\t\t\treturn stored;\n\t\t}\n\n\t\tconst parent = hookData.existentInstance;\n\t\tif (parent == null || typeof parent !== 'object') {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tlet current: object | null = parent;\n\t\twhile (current) {\n\t\t\tconst span = (current as Record<symbol, unknown>)[SymbolParentSpan] as Span | undefined;\n\t\t\tif (span) {\n\t\t\t\treturn span;\n\t\t\t}\n\t\t\tcurrent = Object.getPrototypeOf(current);\n\t\t}\n\n\t\treturn undefined;\n\t}\n}\n"]}

package/build-cjs/request-scope.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInRequestScope = runInRequestScope;
+const api_1 = require("@opentelemetry/api");
+/**
+ * Start the request span, hang its ending on response 'finish', and run
+ * `fn` inside the triple scope (provider ALS + OTEL global context +
+ * async-flow root frame). `fn` is the framework's "continue" callback.
+ */
+function runInRequestScope(req, res, deps, fn) {
+    const route = req.route?.path ?? req.url;
+    const span = deps.tracer.startSpan(`HTTP ${req.method} ${route}`);
+    span.setAttribute('http.method', req.method);
+    span.setAttribute('http.url', req.url);
+    res.on('finish', () => {
+        span.setAttribute('http.status_code', res.statusCode);
+        span.end();
+    });
+    // runWithSpan covers the mnemonica-hook side (the provider's own ALS);
+    // the OTEL global context is what DiveOtelProvider reads when it looks
+    // for a parent span at wrap boundaries — without this second entry
+    // dive spans never adopt the request span and stay root traces.
+    // The async-flow root frame (when provided) is the outermost scope:
+    // every async hop of this request — wrapped or not — inherits it via
+    // ALS propagation.
+    const activeCtx = api_1.trace.setSpan(api_1.context.active(), span);
+    const run = () => {
+        deps.otel.runWithSpan(span, () => {
+            api_1.context.with(activeCtx, fn);
+        });
+    };
+    if (deps.asyncFlow) {
+        deps.asyncFlow.runInScope(run);
+        return;
+    }
+    run();
+}
+//# sourceMappingURL=data:application/json;base64,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