@mnemonica/otel 0.1.0

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

@@ -0,0 +1,238 @@
+import { SpanStatusCode, context as otelContext, trace } from '@opentelemetry/api';
+import { registerHook, } from '@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);
+}
+export 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 ?? 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(registerHook('enter', (payload) => {
+            this.onEnter(payload);
+        }), registerHook('leave', (payload) => {
+            this.onLeave(payload);
+        }), registerHook('settle', (payload) => {
+            this.onSettle(payload);
+        }), registerHook('recontext', (payload) => {
+            this.onRecontext(payload);
+        }));
+        try {
+            this.detachers.push(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
+            ? trace.setSpan(otelContext.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
+            ? trace.setSpan(otelContext.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
+            ? trace.setSpan(otelContext.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: 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 = trace.getSpan(otelContext.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: 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;
+    }
+}
+//# 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/providers/mnemonica-otel.provider.d.ts

@@ -0,0 +1,12 @@
+import type { Tracer, Span } from '@opentelemetry/api';
+import type { TypesCollection } from 'mnemonica/module';
+export declare class MnemonicaOtelProvider {
+    private tracer;
+    private pendingSpans;
+    constructor(tracer?: Tracer);
+    getCurrentSpan(): Span | undefined;
+    runWithSpan<T>(span: Span, fn: () => T): T;
+    attachHooks(collection: TypesCollection): void;
+    private findParentSpan;
+}
+//# sourceMappingURL=mnemonica-otel.provider.d.ts.map

package/build/providers/mnemonica-otel.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonica-otel.provider.d.ts","sourceRoot":"","sources":["../../src/providers/mnemonica-otel.provider.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,KAAK,EAAa,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKnE,qBAAa,qBAAqB;IACjC,OAAO,CAAC,MAAM,CAAS;IAGvB,OAAO,CAAC,YAAY,CAA+B;gBAEtC,MAAM,CAAC,EAAE,MAAM;IAI5B,cAAc,IAAK,IAAI,GAAG,SAAS;IAInC,WAAW,CAAC,CAAC,EAAG,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAI3C,WAAW,CAAE,UAAU,EAAE,eAAe,GAAG,IAAI;IAoF/C,OAAO,CAAC,cAAc;CAsBtB"}

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

@@ -0,0 +1,113 @@
+/**
+ * OpenTelemetry provider for mnemonica lifecycle hooks.
+ *
+ * Creates spans for preCreation / postCreation / creationError,
+ * parents them along the prototype chain, and propagates
+ * context via AsyncLocalStorage.
+ */
+import { AsyncLocalStorage } from 'async_hooks';
+import { trace, context as otelContext } from '@opentelemetry/api';
+const SymbolParentSpan = Symbol.for('mnemonica.span.parent');
+const asyncStorage = new AsyncLocalStorage();
+export 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 ?? 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
+                ? trace.setSpan(otelContext.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;
+    }
+}
+//# 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/request-scope.d.ts

@@ -0,0 +1,41 @@
+/**
+ * HTTP request scope — the framework-free half of the adapter's trace
+ * middleware: one OTel span per HTTP request, visible to mnemonica hooks
+ * through the provider's own ALS AND to dive spans through the OTEL global
+ * context, with the async-flow root frame outermost when provided.
+ *
+ * Framework mapping notes:
+ *  - Express-style middleware: call with (req, res, deps, () => next()).
+ *  - Fastify: onRequest hook — call with (request.raw, reply.raw, deps,
+ *    () => done()); reply.raw is the underlying ServerResponse.
+ *  - raw http: wrap the request listener; ServerResponse emits 'finish'.
+ */
+import type { Tracer } from '@opentelemetry/api';
+import { MnemonicaOtelProvider } from './providers/mnemonica-otel.provider.js';
+import { AsyncFlowProvider } from './providers/async-flow.provider.js';
+/** Structural minimum of the request. */
+export interface HttpRequestLike {
+    method: string;
+    url: string;
+    /** Express exposes the matched route as req.route.path */
+    route?: {
+        path?: string;
+    };
+}
+/** Structural minimum of the response: a 'finish' event + statusCode. */
+export interface HttpResponseLike {
+    statusCode: number;
+    on(event: 'finish', listener: () => void): unknown;
+}
+export interface RequestScopeDeps {
+    tracer: Tracer;
+    otel: MnemonicaOtelProvider;
+    asyncFlow?: AsyncFlowProvider;
+}
+/**
+ * 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.
+ */
+export declare function runInRequestScope(req: HttpRequestLike, res: HttpResponseLike, deps: RequestScopeDeps, fn: () => void): void;
+//# sourceMappingURL=request-scope.d.ts.map

package/build/request-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-scope.d.ts","sourceRoot":"","sources":["../src/request-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAEvE,yCAAyC;AACzC,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAG,MAAM,CAAC;IAChB,GAAG,EAAM,MAAM,CAAC;IAChB,0DAA0D;IAC1D,KAAK,CAAC,EAAG;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3B;AAED,yEAAyE;AACzE,MAAM,WAAW,gBAAgB;IAChC,UAAU,EAAG,MAAM,CAAC;IACpB,EAAE,CAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC;CACpD;AAED,MAAM,WAAW,gBAAgB;IAChC,MAAM,EAAO,MAAM,CAAC;IACpB,IAAI,EAAS,qBAAqB,CAAC;IACnC,SAAS,CAAC,EAAG,iBAAiB,CAAC;CAC/B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAChC,GAAG,EAAI,eAAe,EACtB,GAAG,EAAI,gBAAgB,EACvB,IAAI,EAAG,gBAAgB,EACvB,EAAE,EAAK,MAAM,IAAI,GACf,IAAI,CA6BN"}

package/build/request-scope.js

@@ -0,0 +1,35 @@
+import { context as otelContext, trace } from '@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.
+ */
+export 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 = trace.setSpan(otelContext.active(), span);
+    const run = () => {
+        deps.otel.runWithSpan(span, () => {
+            otelContext.with(activeCtx, fn);
+        });
+    };
+    if (deps.asyncFlow) {
+        deps.asyncFlow.runInScope(run);
+        return;
+    }
+    run();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/thunderstruck/feed-from-request.d.ts

@@ -0,0 +1,21 @@
+/** Structural minimum of an HTTP request any framework can satisfy. */
+export interface RequestLike {
+    method: string;
+    url: string;
+    params?: unknown;
+    query?: unknown;
+    body?: unknown;
+    headers?: unknown;
+}
+export interface FeedPreRootOptions {
+    /**
+     * Link the raw request object into the pre-root record (`raw.request`)
+     * AND stamp it as a correlation key, so getPreRoot(req) resolves from
+     * anywhere the request is reachable — e.g. an error boundary holding
+     * only the request. Retention is unchanged: the record dies with the
+     * request.
+     */
+    storeRequest?: boolean;
+}
+export declare function feedPreRootFromRequest(req: RequestLike, options?: FeedPreRootOptions): void;
+//# sourceMappingURL=feed-from-request.d.ts.map

package/build/thunderstruck/feed-from-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feed-from-request.d.ts","sourceRoot":"","sources":["../../src/thunderstruck/feed-from-request.ts"],"names":[],"mappings":"AAoBA,uEAAuE;AACvE,MAAM,WAAW,WAAW;IAC3B,MAAM,EAAK,MAAM,CAAC;IAClB,GAAG,EAAQ,MAAM,CAAC;IAClB,MAAM,CAAC,EAAI,OAAO,CAAC;IACnB,KAAK,CAAC,EAAK,OAAO,CAAC;IACnB,IAAI,CAAC,EAAM,OAAO,CAAC;IACnB,OAAO,CAAC,EAAG,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IAClC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,wBAAgB,sBAAsB,CAAE,GAAG,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAa5F"}

package/build/thunderstruck/feed-from-request.js

@@ -0,0 +1,34 @@
+/**
+ * Thunderstruck boundary helper — the framework-free half of what a
+ * framework's interceptor/middleware does: shape any HTTP framework's
+ * request into the
+ * raw pre-root payload and stamp its part objects, so pipes and construct
+ * handlers correlate the payload by OBJECT IDENTITY (see pre-root.ts for
+ * the store's lifetime and correlation semantics).
+ *
+ * Framework mapping notes:
+ *  - Express: pass `req` directly — method/url/params(→req.params)/
+ *    query/body/headers all sit on it.
+ *  - Fastify: pass the FastifyRequest — it exposes params/query/body/
+ *    headers; `method`/`url` exist on it since Fastify v4 (fall back to
+ *    `req.raw` if you target older majors).
+ *  - raw http: `url`/`method` are on IncomingMessage; body/query/params
+ *    are yours to parse first (or omit — primitives and missing parts
+ *    simply don't correlate, the feed still records).
+ */
+import { feedPreRoot } from './pre-root.js';
+export function feedPreRootFromRequest(req, options) {
+    const raw = {
+        method: req.method,
+        url: req.url,
+        params: req.params,
+        query: req.query,
+        body: req.body,
+        headers: req.headers,
+    };
+    if (options?.storeRequest === true) {
+        raw.request = req;
+    }
+    feedPreRoot(raw);
+}
+//# sourceMappingURL=data:application/json;base64,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