@lensmcp/nest-instrumentation 1.18.4 → 1.18.7

package/index.js

@@ -1,9 +1 @@
-export { LensmcpModule } from './lib/lensmcp.module.js';
-export { createLensmcpNestApp, } from './lib/lensmcp-app.js';
-export { TraceMethod } from './lib/trace-method.js';
-export { LensmcpIgnore, traceWrap, isTraced, isIgnored } from './lib/instrument.js';
-export { TraceInterceptor } from './lib/trace-interceptor.js';
-export { LensmcpProviderTracker } from './lib/provider-tracker.js';
-export { TraceProvider, readTraceProvider, } from './lib/trace-provider.js';
-export { LENSMCP_CONTEXT_STORAGE, currentLensmcpContext, runInLensmcpContext, } from './lib/context.js';
-export { defaultEventSink, inMemorySink } from './lib/event-sink.js';
+"use strict";export{LensmcpModule}from"./lib/lensmcp.module.js";export{createLensmcpNestApp}from"./lib/lensmcp-app.js";export{TraceMethod}from"./lib/trace-method.js";export{LensmcpIgnore,traceWrap,isTraced,isIgnored}from"./lib/instrument.js";export{TraceInterceptor}from"./lib/trace-interceptor.js";export{LensmcpProviderTracker}from"./lib/provider-tracker.js";export{TraceProvider,readTraceProvider}from"./lib/trace-provider.js";export{LENSMCP_CONTEXT_STORAGE,currentLensmcpContext,runInLensmcpContext}from"./lib/context.js";export{defaultEventSink,inMemorySink}from"./lib/event-sink.js";

package/lib/context.js

@@ -1,8 +1 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-export const LENSMCP_CONTEXT_STORAGE = new AsyncLocalStorage();
-export function currentLensmcpContext() {
-    return LENSMCP_CONTEXT_STORAGE.getStore();
-}
-export function runInLensmcpContext(ctx, fn) {
-    return LENSMCP_CONTEXT_STORAGE.run(ctx, fn);
-}
+"use strict";var o=Object.defineProperty;var t=(e,n)=>o(e,"name",{value:n,configurable:!0});var c=Object.defineProperty,r=t((e,n)=>c(e,"name",{value:n,configurable:!0}),"r");import{AsyncLocalStorage as u}from"node:async_hooks";export const LENSMCP_CONTEXT_STORAGE=new u;export function currentLensmcpContext(){return LENSMCP_CONTEXT_STORAGE.getStore()}t(currentLensmcpContext,"currentLensmcpContext"),r(currentLensmcpContext,"currentLensmcpContext");export function runInLensmcpContext(e,n){return LENSMCP_CONTEXT_STORAGE.run(e,n)}t(runInLensmcpContext,"runInLensmcpContext"),r(runInLensmcpContext,"runInLensmcpContext");

package/lib/event-sink.js

@@ -1,110 +1,3 @@
-import { createSocket } from 'node:dgram';
-import { connect } from 'node:net';
-import { appendFile } from 'node:fs/promises';
-/**
- * Resolve an `EventSink` from env vars + caller overrides.
- *
- * Resolution order:
- *   1. `LENSMCP_EVENT_FILE` — append one JSON line per event.
- *      The Phase 3 e2e smoke uses this (no IPC plumbing needed).
- *   2. `LENSMCP_UDS` — Unix domain socket, framed NDJSON, reconnecting.
- *      The hardened transport (reliable, no datagram size cap).
- *   3. `LENSMCP_IPC_SOCKET` — UDP datagram per event (one-shot, lossy).
- *   4. fallthrough — write to stdout under a `[lensmcp]` prefix so
- *      humans can see something useful even without a session.
- *
- * The UDS client is a compact mirror of `@lensmcp/session`'s `createUdsSink`
- * (inlined to keep this app-injected lib free of the session bundle).
- */
-export function defaultEventSink() {
-    const filePath = process.env['LENSMCP_EVENT_FILE'];
-    if (filePath) {
-        return (event) => {
-            void appendFile(filePath, JSON.stringify(event) + '\n').catch(() => undefined);
-        };
-    }
-    const udsPath = process.env['LENSMCP_UDS'];
-    if (udsPath) {
-        return udsEventSink(udsPath);
-    }
-    const socketPath = process.env['LENSMCP_IPC_SOCKET'];
-    if (socketPath) {
-        const [host, portStr] = socketPath.split(':');
-        if (host && portStr) {
-            const port = Number(portStr);
-            const sock = createSocket('udp4');
-            sock.unref();
-            return (event) => {
-                try {
-                    const buf = Buffer.from(JSON.stringify(event));
-                    sock.send(buf, port, host, () => undefined);
-                }
-                catch {
-                    /* swallow */
-                }
-            };
-        }
-    }
-    return (event) => {
-        if (event.severity === 'error' || event.severity === 'fatal') {
-            console.warn(`[lensmcp] ${event.severity}: ${event.title}`);
-        }
-    };
-}
-export function inMemorySink() {
-    const events = [];
-    return { sink: (e) => events.push(e), events };
-}
-/** Reconnecting NDJSON client over a Unix domain socket (see uds.ts). */
-function udsEventSink(path) {
-    const queue = [];
-    let sock = null;
-    let connecting = false;
-    const flush = () => {
-        if (!sock || !sock.writable)
-            return;
-        while (queue.length > 0)
-            sock.write(queue.shift());
-    };
-    const open = () => {
-        if (connecting || sock)
-            return;
-        connecting = true;
-        const s = connect(path);
-        s.on('connect', () => {
-            connecting = false;
-            sock = s;
-            flush();
-        });
-        s.on('drain', flush);
-        s.on('error', () => {
-            connecting = false;
-            sock = null;
-        });
-        s.on('close', () => {
-            sock = null;
-        });
-        s.unref();
-    };
-    open();
-    return (event) => {
-        queue.push(JSON.stringify(event) + '\n');
-        while (queue.length > 10000)
-            queue.shift();
-        if (sock && sock.writable) {
-            flush();
-            return;
-        }
-        // Dead socket (server restart) — drop it so open() reconnects.
-        if (sock) {
-            try {
-                sock.destroy();
-            }
-            catch {
-                /* ignore */
-            }
-            sock = null;
-        }
-        open();
-    };
-}
+"use strict";var p=Object.defineProperty;var c=(t,e)=>p(t,"name",{value:e,configurable:!0});var S=Object.defineProperty,s=c((t,e)=>S(t,"name",{value:e,configurable:!0}),"s");import{createSocket as v}from"node:dgram";import{connect as m}from"node:net";import{appendFile as y}from"node:fs/promises";export function defaultEventSink(){const t=process.env.LENSMCP_EVENT_FILE;if(t)return r=>{y(t,JSON.stringify(r)+`
+`).catch(()=>{})};const e=process.env.LENSMCP_UDS;if(e)return u(e);const n=process.env.LENSMCP_IPC_SOCKET;if(n){const[r,i]=n.split(":");if(r&&i){const f=Number(i),o=v("udp4");return o.unref(),l=>{try{const a=Buffer.from(JSON.stringify(l));o.send(a,f,r,()=>{})}catch{}}}}return r=>{(r.severity==="error"||r.severity==="fatal")&&console.warn(`[lensmcp] ${r.severity}: ${r.title}`)}}c(defaultEventSink,"defaultEventSink"),s(defaultEventSink,"defaultEventSink");export function inMemorySink(){const t=[];return{sink:s(e=>t.push(e),"sink"),events:t}}c(inMemorySink,"inMemorySink"),s(inMemorySink,"inMemorySink");function u(t){const e=[];let n=null,r=!1;const i=s(()=>{if(!(!n||!n.writable))for(;e.length>0;)n.write(e.shift())},"flush"),f=s(()=>{if(r||n)return;r=!0;const o=m(t);o.on("connect",()=>{r=!1,n=o,i()}),o.on("drain",i),o.on("error",()=>{r=!1,n=null}),o.on("close",()=>{n=null}),o.unref()},"open");return f(),o=>{for(e.push(JSON.stringify(o)+`
+`);e.length>1e4;)e.shift();if(n&&n.writable){i();return}if(n){try{n.destroy()}catch{}n=null}f()}}c(u,"d"),s(u,"udsEventSink");

package/lib/instrument.js

@@ -1,160 +1 @@
-import { fingerprint, ulid } from '@lensmcp/core';
-import { currentLensmcpContext } from './context.js';
-import { activeOptions } from './state.js';
-/** Marks a function already wrapped by traceWrap (avoids double-wrap). */
-export const LENSMCP_TRACED = Symbol.for('@lensmcp/nest-instrumentation/traced');
-/** Marks a class/method opted out of auto-instrumentation. */
-export const LENSMCP_IGNORE = Symbol.for('@lensmcp/nest-instrumentation/ignore');
-/** `@LensmcpIgnore()` — skip a class (all methods) or a single method. */
-export function LensmcpIgnore() {
-    return ((target, propertyKey) => {
-        if (propertyKey === undefined) {
-            target[LENSMCP_IGNORE] = true;
-        }
-        else {
-            const fn = target[propertyKey];
-            if (typeof fn === 'function') {
-                fn[LENSMCP_IGNORE] = true;
-            }
-        }
-    });
-}
-export function isTraced(fn) {
-    return typeof fn === 'function' && Boolean(fn[LENSMCP_TRACED]);
-}
-export function isIgnored(target) {
-    return (!!target &&
-        (typeof target === 'function' || typeof target === 'object') &&
-        Boolean(target[LENSMCP_IGNORE]));
-}
-/**
- * Wrap `fn` with span + db-call tracing. Pure: no decorator/Nest
- * coupling, so the auto-instrumenter can apply it to any instance method.
- */
-export function traceWrap(fn, spanName, options = {}) {
-    if (isTraced(fn))
-        return fn;
-    const isDb = options.db ?? false;
-    const wrapped = function (...args) {
-        let opts;
-        try {
-            opts = activeOptions();
-        }
-        catch {
-            return fn.apply(this, args);
-        }
-        if (!opts.trace.services) {
-            return fn.apply(this, args);
-        }
-        const startedAt = Date.now();
-        const ctx = currentLensmcpContext();
-        const dbCountAtStart = ctx?.dbCallCount ?? 0;
-        const redisCountAtStart = ctx?.redisCallCount ?? 0;
-        const externalCountAtStart = ctx?.externalCallCount ?? 0;
-        const emitSpan = (status, err) => {
-            const durationMs = Date.now() - startedAt;
-            const event = {
-                id: ulid(),
-                sessionId: opts.sessionId,
-                timestamp: Date.now(),
-                source: 'nestjs',
-                category: 'backend',
-                severity: status === 'error' ? 'error' : 'info',
-                context: { sessionId: opts.sessionId, flowId: ctx?.flowId, requestId: ctx?.requestId },
-                fingerprint: fingerprint({ kind: 'method-call', identity: spanName }),
-                title: `${spanName} (${durationMs}ms)${status === 'error' ? ' ✗' : ''}`,
-                message: err instanceof Error ? err.message : undefined,
-                raw: {
-                    kind: 'span',
-                    span: {
-                        name: spanName,
-                        flowId: ctx?.flowId,
-                        requestId: ctx?.requestId,
-                        startTime: startedAt,
-                        endTime: Date.now(),
-                        durationMs,
-                        status,
-                    },
-                },
-            };
-            opts.emit(event);
-        };
-        const emitDbQuery = () => {
-            if (ctx)
-                ctx.dbCallCount = (ctx.dbCallCount ?? 0) + 1;
-            opts.emit({
-                id: ulid(),
-                sessionId: opts.sessionId,
-                timestamp: Date.now(),
-                source: 'db',
-                category: 'db',
-                severity: 'info',
-                context: { sessionId: opts.sessionId, flowId: ctx?.flowId, requestId: ctx?.requestId },
-                fingerprint: fingerprint({ kind: 'db-query', identity: spanName }),
-                title: `query ${spanName}`,
-                raw: { kind: 'db-query', query: { signature: spanName } },
-            });
-        };
-        const emitLoopIfNeeded = () => {
-            if (isDb || !ctx)
-                return;
-            const dbDelta = (ctx.dbCallCount ?? 0) - dbCountAtStart;
-            const redisDelta = (ctx.redisCallCount ?? 0) - redisCountAtStart;
-            const externalDelta = (ctx.externalCallCount ?? 0) - externalCountAtStart;
-            // One method issuing the SAME class of operation ≥3 times is the
-            // N+1 / fan-out signal (a loop of selects, a Promise.all of fetches).
-            // Two ops is normal shape (ensure + query); three starts the pattern.
-            if (dbDelta < 3 && redisDelta < 3 && externalDelta < 3)
-                return;
-            const durationMs = Date.now() - startedAt;
-            const parts = [];
-            if (dbDelta >= 3)
-                parts.push(`${dbDelta} DB calls`);
-            if (redisDelta >= 3)
-                parts.push(`${redisDelta} redis calls`);
-            if (externalDelta >= 3)
-                parts.push(`${externalDelta} external calls`);
-            opts.emit({
-                id: ulid(),
-                sessionId: opts.sessionId,
-                timestamp: Date.now(),
-                source: 'nestjs',
-                category: 'backend',
-                severity: 'warning',
-                context: { sessionId: opts.sessionId, flowId: ctx.flowId, requestId: ctx.requestId },
-                fingerprint: fingerprint({ kind: 'loop', identity: spanName }),
-                title: `loop in ${spanName} (${parts.join(', ')})`,
-                raw: {
-                    kind: 'loop',
-                    loop: {
-                        iterations: Math.max(dbDelta, redisDelta, externalDelta),
-                        durationMs,
-                        startedAt,
-                        dbCallsInsideLoop: dbDelta,
-                        redisCallsInsideLoop: redisDelta,
-                        externalCallsInsideLoop: externalDelta,
-                        awaitedOperationsInsideLoop: dbDelta + redisDelta + externalDelta,
-                    },
-                },
-            });
-        };
-        const onOk = () => { if (isDb)
-            emitDbQuery(); emitSpan('ok'); emitLoopIfNeeded(); };
-        const onErr = (err) => { if (isDb)
-            emitDbQuery(); emitSpan('error', err); emitLoopIfNeeded(); };
-        try {
-            const result = fn.apply(this, args);
-            if (result instanceof Promise) {
-                return result.then((v) => { onOk(); return v; }, (err) => { onErr(err); throw err; });
-            }
-            onOk();
-            return result;
-        }
-        catch (err) {
-            onErr(err);
-            throw err;
-        }
-    };
-    wrapped[LENSMCP_TRACED] = true;
-    return wrapped;
-}
+"use strict";var L=Object.defineProperty;var d=(e,o)=>L(e,"name",{value:o,configurable:!0});var v=Object.defineProperty,i=d((e,o)=>v(e,"name",{value:o,configurable:!0}),"i");import{fingerprint as m,ulid as y}from"@lensmcp/core";import{currentLensmcpContext as $}from"./context.js";import{activeOptions as E}from"./state.js";export const LENSMCP_TRACED=Symbol.for("@lensmcp/nest-instrumentation/traced"),LENSMCP_IGNORE=Symbol.for("@lensmcp/nest-instrumentation/ignore");export function LensmcpIgnore(){return((e,o)=>{if(o===void 0)e[LENSMCP_IGNORE]=!0;else{const l=e[o];typeof l=="function"&&(l[LENSMCP_IGNORE]=!0)}})}d(LensmcpIgnore,"LensmcpIgnore"),i(LensmcpIgnore,"LensmcpIgnore");export function isTraced(e){return typeof e=="function"&&!!e[LENSMCP_TRACED]}d(isTraced,"isTraced"),i(isTraced,"isTraced");export function isIgnored(e){return!!e&&(typeof e=="function"||typeof e=="object")&&!!e[LENSMCP_IGNORE]}d(isIgnored,"isIgnored"),i(isIgnored,"isIgnored");export function traceWrap(e,o,l={}){if(isTraced(e))return e;const p=l.db??!1,w=i(function(...f){let r;try{r=E()}catch{return e.apply(this,f)}if(!r.trace.services)return e.apply(this,f);const u=Date.now(),n=$(),q=n?.dbCallCount??0,k=n?.redisCallCount??0,D=n?.externalCallCount??0,C=i((t,s)=>{const a=Date.now()-u,I={id:y(),sessionId:r.sessionId,timestamp:Date.now(),source:"nestjs",category:"backend",severity:t==="error"?"error":"info",context:{sessionId:r.sessionId,flowId:n?.flowId,requestId:n?.requestId},fingerprint:m({kind:"method-call",identity:o}),title:`${o} (${a}ms)${t==="error"?" \u2717":""}`,message:s instanceof Error?s.message:void 0,raw:{kind:"span",span:{name:o,flowId:n?.flowId,requestId:n?.requestId,startTime:u,endTime:Date.now(),durationMs:a,status:t}}};r.emit(I)},"emitSpan"),b=i(()=>{n&&(n.dbCallCount=(n.dbCallCount??0)+1),r.emit({id:y(),sessionId:r.sessionId,timestamp:Date.now(),source:"db",category:"db",severity:"info",context:{sessionId:r.sessionId,flowId:n?.flowId,requestId:n?.requestId},fingerprint:m({kind:"db-query",identity:o}),title:`query ${o}`,raw:{kind:"db-query",query:{signature:o}}})},"emitDbQuery"),g=i(()=>{if(p||!n)return;const t=(n.dbCallCount??0)-q,s=(n.redisCallCount??0)-k,a=(n.externalCallCount??0)-D;if(t<3&&s<3&&a<3)return;const I=Date.now()-u,c=[];t>=3&&c.push(`${t} DB calls`),s>=3&&c.push(`${s} redis calls`),a>=3&&c.push(`${a} external calls`),r.emit({id:y(),sessionId:r.sessionId,timestamp:Date.now(),source:"nestjs",category:"backend",severity:"warning",context:{sessionId:r.sessionId,flowId:n.flowId,requestId:n.requestId},fingerprint:m({kind:"loop",identity:o}),title:`loop in ${o} (${c.join(", ")})`,raw:{kind:"loop",loop:{iterations:Math.max(t,s,a),durationMs:I,startedAt:u,dbCallsInsideLoop:t,redisCallsInsideLoop:s,externalCallsInsideLoop:a,awaitedOperationsInsideLoop:t+s+a}}})},"emitLoopIfNeeded"),x=i(()=>{p&&b(),C("ok"),g()},"onOk"),h=i(t=>{p&&b(),C("error",t),g()},"onErr");try{const t=e.apply(this,f);return t instanceof Promise?t.then(s=>(x(),s),s=>{throw h(s),s}):(x(),t)}catch(t){throw h(t),t}},"wrapped");return w[LENSMCP_TRACED]=!0,w}d(traceWrap,"traceWrap"),i(traceWrap,"traceWrap");

package/lib/lensmcp-app.js

@@ -1,43 +1 @@
-import { __decorate } from "tslib";
-/**
- * `createLensmcpNestApp` — a drop-in for `NestFactory.create(AppModule)`
- * that wires LensMCP with zero edits to the host's `AppModule`.
- *
- *   // main.ts
- *   import { createLensmcpNestApp } from '@lensmcp/nest-instrumentation';
- *   import { AppModule } from './app.module';
- *
- *   const app = await createLensmcpNestApp(AppModule, { projectName: 'api' });
- *   await app.listen(3100);
- *
- * It builds a wrapper module that imports `AppModule` + `LensmcpModule`,
- * and defaults `trace.autoInstrumentMethods` + `memory.scope: 'all'` on,
- * so every provider's methods + containers are instrumented without any
- * `@TraceMethod` / `@TraceProvider`.
- */
-import { Module, } from '@nestjs/common';
-import { NestFactory } from '@nestjs/core';
-import { LensmcpModule } from './lensmcp.module.js';
-export async function createLensmcpNestApp(appModule, options = {}) {
-    const { nestOptions, projectName, ...rest } = options;
-    const lensmcp = LensmcpModule.forRoot({
-        projectName: projectName ?? process.env['LENSMCP_PROJECT'] ?? 'app',
-        ...rest,
-        // Zero-config defaults: instrument everything unless the caller
-        // explicitly narrows it.
-        trace: { autoInstrumentMethods: true, ...rest.trace },
-        memory: { mode: 'light', scope: 'all', ...rest.memory },
-    });
-    // Lensmcp first → TraceInterceptor outermost (short-circuiting user
-    // interceptors must not bypass tracing).
-    let LensmcpRootModule = class LensmcpRootModule {
-    };
-    LensmcpRootModule = __decorate([
-        Module({ imports: [lensmcp, appModule] })
-    ], LensmcpRootModule);
-    // Marker for @lensmcp/node-instrumentation's NestFactory.create auto-graft:
-    // an already-wrapped root must not be wrapped a second time (duplicate
-    // interceptors → duplicate events).
-    LensmcpRootModule[Symbol.for('lensmcp.wrappedRoot')] = true;
-    return NestFactory.create(LensmcpRootModule, nestOptions);
-}
+"use strict";var n=Object.defineProperty;var r=(e,t)=>n(e,"name",{value:t,configurable:!0});var i=Object.defineProperty,a=r((e,t)=>i(e,"name",{value:t,configurable:!0}),"m");import{__decorate as l}from"tslib";import{Module as u}from"@nestjs/common";import{NestFactory as d}from"@nestjs/core";import{LensmcpModule as f}from"./lensmcp.module.js";export async function createLensmcpNestApp(e,t={}){const{nestOptions:p,projectName:c,...s}=t,m=f.forRoot({projectName:c??process.env.LENSMCP_PROJECT??"app",...s,trace:{autoInstrumentMethods:!0,...s.trace},memory:{mode:"light",scope:"all",...s.memory}});let o=class{static{r(this,"e")}static{a(this,"LensmcpRootModule")}};return o=l([u({imports:[m,e]})],o),o[Symbol.for("lensmcp.wrappedRoot")]=!0,d.create(o,p)}r(createLensmcpNestApp,"createLensmcpNestApp"),a(createLensmcpNestApp,"createLensmcpNestApp");

package/lib/lensmcp.module.js

@@ -1,70 +1 @@
-var LensmcpModule_1;
-import { __decorate } from "tslib";
-import { Module } from '@nestjs/common';
-import { APP_INTERCEPTOR } from '@nestjs/core';
-import { configureMemoryTracker } from '@lensmcp/memory-tracker';
-import { TraceInterceptor } from './trace-interceptor.js';
-import { LensmcpProviderTracker } from './provider-tracker.js';
-import { setActiveOptions } from './state.js';
-import { currentLensmcpContext } from './context.js';
-/**
- * `LensmcpModule.forRoot({ projectName: "api", … })` — the host's
- * AppModule imports this to wire LensMCP into a NestJS app.
- *
- *   import { Module } from '@nestjs/common';
- *   import { LensmcpModule } from '@lensmcp/nest-instrumentation';
- *
- *   @Module({
- *     imports: [LensmcpModule.forRoot({ projectName: 'api' })],
- *   })
- *   export class AppModule {}
- *
- * Side effects:
- *   • Registers an APP_INTERCEPTOR so every request gets a
- *     LensmcpRequestContext + a server-request span event.
- *   • Registers a provider tracker that emits `singleton-instance`
- *     events on bootstrap + lifecycle.
- *   • Calls `setActiveOptions(...)` synchronously so `@TraceMethod`
- *     decorators applied to constructor-injected providers find the
- *     options at decoration time.
- */
-let LensmcpModule = LensmcpModule_1 = class LensmcpModule {
-    static forRoot(options) {
-        // Resolve options immediately so subsequent imports and decorator
-        // applications see the populated state singleton.
-        const resolved = setActiveOptions(options);
-        // Phase 7: wire the memory tracker to the same sink + the per-request
-        // ALS context so each container mutation attributes to the active flow.
-        if (resolved.memory.mode !== 'off') {
-            configureMemoryTracker({
-                sessionId: resolved.sessionId,
-                sink: resolved.emit,
-                contextGetter: () => {
-                    const ctx = currentLensmcpContext();
-                    if (!ctx)
-                        return undefined;
-                    return {
-                        sessionId: ctx.sessionId,
-                        flowId: ctx.flowId,
-                        requestId: ctx.requestId,
-                        originNodeId: ctx.originNodeId,
-                    };
-                },
-            });
-        }
-        const providers = [
-            { provide: APP_INTERCEPTOR, useClass: TraceInterceptor },
-            LensmcpProviderTracker,
-        ];
-        return {
-            module: LensmcpModule_1,
-            providers,
-            exports: [],
-            global: true,
-        };
-    }
-};
-LensmcpModule = LensmcpModule_1 = __decorate([
-    Module({})
-], LensmcpModule);
-export { LensmcpModule };
+"use strict";var n=Object.defineProperty;var t=(r,e)=>n(r,"name",{value:e,configurable:!0});var a=Object.defineProperty,m=t((r,e)=>a(r,"name",{value:e,configurable:!0}),"t"),s;import{__decorate as c}from"tslib";import{Module as d}from"@nestjs/common";import{APP_INTERCEPTOR as p}from"@nestjs/core";import{configureMemoryTracker as f}from"@lensmcp/memory-tracker";import{TraceInterceptor as u}from"./trace-interceptor.js";import{LensmcpProviderTracker as l}from"./provider-tracker.js";import{setActiveOptions as I}from"./state.js";import{currentLensmcpContext as v}from"./context.js";let i=s=class{static{t(this,"s")}static{m(this,"LensmcpModule")}static forRoot(r){const e=I(r);return e.memory.mode!=="off"&&f({sessionId:e.sessionId,sink:e.emit,contextGetter:m(()=>{const o=v();if(o)return{sessionId:o.sessionId,flowId:o.flowId,requestId:o.requestId,originNodeId:o.originNodeId}},"contextGetter")}),{module:s,providers:[{provide:p,useClass:u},l],exports:[],global:!0}}};i=s=c([d({})],i);export{i as LensmcpModule};

package/lib/provider-tracker.js

@@ -1,348 +1 @@
-import { __decorate, __metadata } from "tslib";
-import { Injectable } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-import { fingerprint, ulid } from '@lensmcp/core';
-import { trackContainer } from '@lensmcp/memory-tracker';
-import { activeOptions, currentGeneration } from './state.js';
-import { readTraceProvider } from './trace-provider.js';
-import { traceWrap, isTraced, isIgnored } from './instrument.js';
-// Nest lifecycle hooks + base Object methods we never auto-wrap.
-const SKIP_METHODS = new Set([
-    'constructor',
-    'onModuleInit',
-    'onApplicationBootstrap',
-    'onModuleDestroy',
-    'beforeApplicationShutdown',
-    'onApplicationShutdown',
-]);
-// Framework NOISE methods — pure in-memory metadata lookups that fire dozens
-// of times per request, always at ~0ms, and never represent real work.
-// Measured (foodguard, 2026-07-29): 373 of the first 500 events in one
-// run-detail page-load flow were `DataSource.findMetadata/getMetadata/
-// hasMetadata` + `Reflector.get*` spans. Skipped at WRAP time (not at emit)
-// so the suppressed methods also skip the per-call Date.now()/ulid/event
-// allocation. Gated by `trace.suppressNoiseMethods` (default true).
-// Real work stays traced: `Repository.find`, `EntityManager.find`, driver
-// query wraps, and every app-defined provider method are unaffected.
-const NOISE_METHODS = {
-    // TypeORM DataSource — metadata table lookups + structural allocators.
-    DataSource: new Set([
-        'findMetadata', 'getMetadata', 'hasMetadata', 'getRepository',
-        'getTreeRepository', 'getMongoRepository', 'createQueryBuilder',
-        'createEntityManager', 'createQueryRunner', 'defaultReplicationModeForReads',
-    ]),
-    // TypeORM EntityManager — same structural allocators (queries stay traced).
-    EntityManager: new Set([
-        'getRepository', 'getTreeRepository', 'getCustomRepository', 'createQueryBuilder',
-    ]),
-    // Nest core Reflector — decorator-metadata reads on every guard/interceptor hop.
-    Reflector: new Set(['get', 'getAll', 'getAllAndOverride', 'getAllAndMerge']),
-};
-function isNoiseMethod(cls, name) {
-    let suppress = true;
-    try {
-        suppress = activeOptions().trace.suppressNoiseMethods;
-    }
-    catch { /* pre-bootstrap: default on */ }
-    if (!suppress)
-        return false;
-    return NOISE_METHODS[cls]?.has(name) ?? false;
-}
-// Provider "class" names that are really built-ins (value/factory providers).
-const BUILTIN_CLASS = /^(_|Object|String|Number|Array|Promise|Function|RegExp|Map|Set)$/;
-// Marks a shared prototype already auto-instrumented, so request-scoped /
-// transient providers (instantiated per request) are wrapped exactly once.
-const LENSMCP_PROTO_WRAPPED = Symbol.for('@lensmcp/nest-instrumentation/proto-wrapped');
-/**
- * On application bootstrap, walks the Nest container and emits one
- * `singleton-instance` event per provider so the `apps/nest` reducer
- * can materialise `nest://providers`. On module destroy (HMR / shutdown)
- * marks each instance as `disposed`.
- *
- * `generation` is the LensMCP module-instance counter (incremented each
- * time `LensmcpModule.forRoot` is constructed), which mirrors a hot
- * reload. Lets the agent ask "is the new gen serving requests, or did
- * an old one stick around?".
- */
-let LensmcpProviderTracker = class LensmcpProviderTracker {
-    constructor(moduleRef) {
-        this.moduleRef = moduleRef;
-        this.active = new Map(); // logicalId → instanceId
-    }
-    onApplicationBootstrap() {
-        const opts = activeOptions();
-        const gen = currentGeneration();
-        // Nest's ModuleRef doesn't expose the full provider list publicly.
-        // Phase 3 uses a small reflection trick: ModuleRef has an internal
-        // `container` accessor used by interceptors. We treat it as opaque
-        // and use the public `get` for known classes — the deeper enumeration
-        // lands in Phase 3.5 once we ship a `@TraceProvider` decorator.
-        const internalContainer = this.moduleRef.container;
-        if (!internalContainer?.getModules)
-            return;
-        for (const [, module] of internalContainer.getModules()) {
-            // Controllers live in their OWN map (module.controllers), not in
-            // providers — without this loop the trace jumps from server-request
-            // straight to the service, hiding the controller hop the request
-            // actually goes through.
-            const controllers = module?.controllers;
-            if (controllers && typeof controllers.forEach === 'function') {
-                controllers.forEach((wrapper) => {
-                    const instance = wrapper?.instance;
-                    if (!instance || typeof instance !== 'object')
-                        return;
-                    const ctor = instance.constructor;
-                    const cls = ctor?.name;
-                    if (!cls || BUILTIN_CLASS.test(cls))
-                        return;
-                    const logicalId = `nest:controller:${cls}`;
-                    const instanceId = `${cls}#gen${gen}#${shortHash(`${cls}:${gen}`)}`;
-                    this.active.set(logicalId, instanceId);
-                    opts.emit(makeProviderEvent({
-                        logicalId,
-                        instanceId,
-                        generation: gen,
-                        module: module?.metatype?.name,
-                        scope: scopeLabel(wrapper?.scope),
-                        lifecycle: 'active',
-                    }));
-                    if (opts.trace.autoInstrumentMethods && ctor) {
-                        autoInstrumentProviderMethods(instance, ctor, cls);
-                    }
-                });
-            }
-            const providers = module?.providers;
-            if (!providers || typeof providers.forEach !== 'function')
-                continue;
-            providers.forEach((wrapper) => {
-                const instance = wrapper?.instance;
-                // Request-scoped / transient providers get a fresh instance per
-                // request/injection. Nest does create a *static-context* instance at
-                // bootstrap, but wrapping that one instance wouldn't cover the
-                // per-request ones — so for any non-singleton scope we wrap the
-                // shared prototype (traceWrap keeps `this`, so every per-request
-                // instance is traced). Gate on scope, not instance presence.
-                if (scopeLabel(wrapper?.scope) !== 'SINGLETON') {
-                    this.trackScopedProvider(wrapper, module, gen, opts);
-                    return;
-                }
-                if (!instance || typeof instance !== 'object')
-                    return;
-                const ctor = instance.constructor;
-                const cls = ctor?.name;
-                if (!cls || BUILTIN_CLASS.test(cls))
-                    return;
-                const logicalId = `nest:provider:${cls}`;
-                const instanceId = `${cls}#gen${gen}#${shortHash(`${cls}:${gen}`)}`;
-                this.active.set(logicalId, instanceId);
-                opts.emit(makeProviderEvent({
-                    logicalId,
-                    instanceId,
-                    generation: gen,
-                    module: module?.metatype?.name,
-                    scope: scopeLabel(wrapper?.scope),
-                    lifecycle: 'active',
-                }));
-                // Phase 7: memory container tracking. Wrap Map/Set/Array fields
-                // on tagged providers (or all providers when scope === 'all').
-                if (opts.memory.mode !== 'off') {
-                    const tag = readTraceProvider(ctor);
-                    const shouldTrack = opts.memory.scope === 'all' || (tag?.memory ?? false);
-                    if (shouldTrack) {
-                        trackProviderContainers(instance, instanceId);
-                    }
-                }
-                // Phase 8: zero-config — auto-wrap this provider's methods with
-                // span + db-call tracing (no @TraceMethod needed). Skips methods
-                // already wrapped (@TraceMethod) or marked @LensmcpIgnore.
-                if (opts.trace.autoInstrumentMethods && ctor) {
-                    autoInstrumentProviderMethods(instance, ctor, cls);
-                }
-            });
-        }
-    }
-    onModuleDestroy() {
-        const opts = activeOptions();
-        const gen = currentGeneration();
-        for (const [logicalId, instanceId] of this.active) {
-            opts.emit(makeProviderEvent({
-                logicalId,
-                instanceId,
-                generation: gen,
-                lifecycle: 'disposed',
-            }));
-        }
-    }
-    /**
-     * Handle a provider with no bootstrap instance. Request-scoped and
-     * transient providers fall here; value/factory providers (no class
-     * `metatype`) are ignored. Wraps the class's shared prototype once and
-     * emits a provider event with the real scope.
-     */
-    trackScopedProvider(wrapper, module, gen, opts) {
-        // Prefer the class metatype; fall back to the static-context instance's
-        // constructor when the wrapper doesn't expose a metatype.
-        let ctorUnknown;
-        if (typeof wrapper?.metatype === 'function') {
-            ctorUnknown = wrapper.metatype;
-        }
-        else if (wrapper?.instance && typeof wrapper.instance === 'object') {
-            ctorUnknown = wrapper.instance.constructor;
-        }
-        if (typeof ctorUnknown !== 'function')
-            return; // value/factory provider
-        const ctor = ctorUnknown;
-        if (!ctor.prototype)
-            return;
-        const cls = ctor.name;
-        if (!cls || BUILTIN_CLASS.test(cls))
-            return;
-        const scope = scopeLabel(wrapper?.scope);
-        const logicalId = `nest:provider:${cls}`;
-        const instanceId = `${cls}#gen${gen}#${scope.toLowerCase()}`;
-        if (!this.active.has(logicalId))
-            this.active.set(logicalId, instanceId);
-        opts.emit(makeProviderEvent({
-            logicalId,
-            instanceId,
-            generation: gen,
-            module: module?.metatype?.name,
-            scope,
-            lifecycle: 'active',
-        }));
-        if (opts.trace.autoInstrumentMethods) {
-            autoInstrumentPrototypeMethods(ctor, cls);
-        }
-    }
-};
-LensmcpProviderTracker = __decorate([
-    Injectable(),
-    __metadata("design:paramtypes", [ModuleRef])
-], LensmcpProviderTracker);
-export { LensmcpProviderTracker };
-/** Normalise Nest's scope (enum number or string) to a stable label. */
-function scopeLabel(scope) {
-    if (scope === 1 || scope === 'TRANSIENT')
-        return 'TRANSIENT';
-    if (scope === 2 || scope === 'REQUEST')
-        return 'REQUEST';
-    return 'SINGLETON';
-}
-function makeProviderEvent(p) {
-    const opts = activeOptions();
-    return {
-        id: ulid(),
-        sessionId: opts.sessionId,
-        timestamp: Date.now(),
-        source: 'nestjs',
-        category: 'backend',
-        severity: 'info',
-        context: { sessionId: opts.sessionId },
-        fingerprint: fingerprint({ kind: 'nest-provider', identity: p.logicalId }),
-        title: `Nest provider ${p.logicalId} ${p.lifecycle}`,
-        raw: {
-            kind: 'singleton-instance',
-            provider: { ...p, createdAt: Date.now() },
-        },
-    };
-}
-function shortHash(input) {
-    let h = 5381;
-    for (let i = 0; i < input.length; i++)
-        h = ((h << 5) + h + input.charCodeAt(i)) | 0;
-    return (h >>> 0).toString(16).slice(0, 6);
-}
-/**
- * Scan an instance's own enumerable fields for Map/Set/Array containers
- * and wrap them so mutations emit memory-mutation events.
- */
-function trackProviderContainers(instance, ownerInstanceId) {
-    for (const fieldName of Object.keys(instance)) {
-        const value = instance[fieldName];
-        if (value instanceof Map || value instanceof Set || Array.isArray(value)) {
-            trackContainer({ ownerInstanceId, fieldName, container: value });
-        }
-    }
-}
-/**
- * Replace each of a provider's own prototype methods with a traced
- * wrapper, in place on the instance. Wraps on the instance (not the
- * shared prototype) so two providers of the same class don't collide and
- * `this` stays bound. Skips lifecycle hooks, getters/setters,
- * non-functions, already-traced (@TraceMethod), and @LensmcpIgnore.
- */
-function autoInstrumentProviderMethods(instance, ctor, cls) {
-    if (isIgnored(ctor))
-        return;
-    const proto = Object.getPrototypeOf(instance);
-    if (!proto || proto === Object.prototype)
-        return;
-    for (const name of Object.getOwnPropertyNames(proto)) {
-        if (SKIP_METHODS.has(name) || isNoiseMethod(cls, name))
-            continue;
-        const desc = Object.getOwnPropertyDescriptor(proto, name);
-        if (!desc || typeof desc.value !== 'function' || desc.get || desc.set)
-            continue;
-        const original = desc.value;
-        if (isTraced(original) || isIgnored(original))
-            continue;
-        const wrapped = traceWrap(original, `${cls}.${name}`);
-        try {
-            // Define on the instance so we don't mutate the shared prototype.
-            Object.defineProperty(instance, name, {
-                value: wrapped,
-                writable: true,
-                enumerable: false,
-                configurable: true,
-            });
-        }
-        catch {
-            /* read-only / exotic — skip */
-        }
-    }
-}
-/**
- * Auto-wrap the methods on a class's shared prototype, in place. Used for
- * request-scoped / transient providers, which have no instance at bootstrap
- * — every per-request instance resolves these methods from the prototype,
- * and `traceWrap` preserves `this`, so each call is traced correctly.
- * Marked once on the prototype so HMR generations don't re-wrap.
- */
-function autoInstrumentPrototypeMethods(metatype, cls) {
-    if (isIgnored(metatype))
-        return;
-    const proto = metatype.prototype;
-    if (!proto || proto === Object.prototype)
-        return;
-    const marker = proto;
-    if (marker[LENSMCP_PROTO_WRAPPED])
-        return;
-    const wrappedNames = [];
-    for (const name of Object.getOwnPropertyNames(proto)) {
-        if (SKIP_METHODS.has(name) || isNoiseMethod(cls, name))
-            continue;
-        const desc = Object.getOwnPropertyDescriptor(proto, name);
-        if (!desc || typeof desc.value !== 'function' || desc.get || desc.set)
-            continue;
-        const original = desc.value;
-        if (isTraced(original) || isIgnored(original))
-            continue;
-        const wrapped = traceWrap(original, `${cls}.${name}`);
-        try {
-            Object.defineProperty(proto, name, {
-                value: wrapped,
-                writable: true,
-                enumerable: false,
-                configurable: true,
-            });
-            wrappedNames.push(name);
-        }
-        catch {
-            /* read-only / exotic — skip */
-        }
-    }
-    marker[LENSMCP_PROTO_WRAPPED] = true;
-    if (process.env['LENSMCP_DEBUG']) {
-        console.error(`[lensmcp] proto-wrapped ${cls}: [${wrappedNames.join(', ')}]`);
-    }
-}
+"use strict";var N=Object.defineProperty;var f=(e,t)=>N(e,"name",{value:t,configurable:!0});var T=Object.defineProperty,u=f((e,t)=>T(e,"name",{value:t,configurable:!0}),"l");import{__decorate as k,__metadata as D}from"tslib";import{Injectable as L}from"@nestjs/common";import{ModuleRef as C}from"@nestjs/core";import{fingerprint as _,ulid as B}from"@lensmcp/core";import{trackContainer as Q}from"@lensmcp/memory-tracker";import{activeOptions as g,currentGeneration as O}from"./state.js";import{readTraceProvider as G}from"./trace-provider.js";import{traceWrap as S,isTraced as w,isIgnored as v}from"./instrument.js";const P=new Set(["constructor","onModuleInit","onApplicationBootstrap","onModuleDestroy","beforeApplicationShutdown","onApplicationShutdown"]),U={DataSource:new Set(["findMetadata","getMetadata","hasMetadata","getRepository","getTreeRepository","getMongoRepository","createQueryBuilder","createEntityManager","createQueryRunner","defaultReplicationModeForReads"]),EntityManager:new Set(["getRepository","getTreeRepository","getCustomRepository","createQueryBuilder"]),Reflector:new Set(["get","getAll","getAllAndOverride","getAllAndMerge"])};function h(e,t){let o=!0;try{o=g().trace.suppressNoiseMethods}catch{}return o?U[e]?.has(t)??!1:!1}f(h,"$"),u(h,"isNoiseMethod");const b=/^(_|Object|String|Number|Array|Promise|Function|RegExp|Map|Set)$/,j=Symbol.for("@lensmcp/nest-instrumentation/proto-wrapped");let I=class{static{f(this,"I")}static{u(this,"LensmcpProviderTracker")}constructor(e){this.moduleRef=e,this.active=new Map}onApplicationBootstrap(){const e=g(),t=O(),o=this.moduleRef.container;if(o?.getModules)for(const[,n]of o.getModules()){const c=n?.controllers;c&&typeof c.forEach=="function"&&c.forEach(r=>{const s=r?.instance;if(!s||typeof s!="object")return;const p=s.constructor,a=p?.name;if(!a||b.test(a))return;const l=`nest:controller:${a}`,d=`${a}#gen${t}#${M(`${a}:${t}`)}`;this.active.set(l,d),e.emit(y({logicalId:l,instanceId:d,generation:t,module:n?.metatype?.name,scope:m(r?.scope),lifecycle:"active"})),e.trace.autoInstrumentMethods&&p&&$(s,p,a)});const i=n?.providers;!i||typeof i.forEach!="function"||i.forEach(r=>{const s=r?.instance;if(m(r?.scope)!=="SINGLETON"){this.trackScopedProvider(r,n,t,e);return}if(!s||typeof s!="object")return;const p=s.constructor,a=p?.name;if(!a||b.test(a))return;const l=`nest:provider:${a}`,d=`${a}#gen${t}#${M(`${a}:${t}`)}`;if(this.active.set(l,d),e.emit(y({logicalId:l,instanceId:d,generation:t,module:n?.metatype?.name,scope:m(r?.scope),lifecycle:"active"})),e.memory.mode!=="off"){const A=G(p);(e.memory.scope==="all"||(A?.memory??!1))&&E(s,d)}e.trace.autoInstrumentMethods&&p&&$(s,p,a)})}}onModuleDestroy(){const e=g(),t=O();for(const[o,n]of this.active)e.emit(y({logicalId:o,instanceId:n,generation:t,lifecycle:"disposed"}))}trackScopedProvider(e,t,o,n){let c;if(typeof e?.metatype=="function"?c=e.metatype:e?.instance&&typeof e.instance=="object"&&(c=e.instance.constructor),typeof c!="function")return;const i=c;if(!i.prototype)return;const r=i.name;if(!r||b.test(r))return;const s=m(e?.scope),p=`nest:provider:${r}`,a=`${r}#gen${o}#${s.toLowerCase()}`;this.active.has(p)||this.active.set(p,a),n.emit(y({logicalId:p,instanceId:a,generation:o,module:t?.metatype?.name,scope:s,lifecycle:"active"})),n.trace.autoInstrumentMethods&&R(i,r)}};I=k([L(),D("design:paramtypes",[C])],I);export{I as LensmcpProviderTracker};function m(e){return e===1||e==="TRANSIENT"?"TRANSIENT":e===2||e==="REQUEST"?"REQUEST":"SINGLETON"}f(m,"g"),u(m,"scopeLabel");function y(e){const t=g();return{id:B(),sessionId:t.sessionId,timestamp:Date.now(),source:"nestjs",category:"backend",severity:"info",context:{sessionId:t.sessionId},fingerprint:_({kind:"nest-provider",identity:e.logicalId}),title:`Nest provider ${e.logicalId} ${e.lifecycle}`,raw:{kind:"singleton-instance",provider:{...e,createdAt:Date.now()}}}}f(y,"h"),u(y,"makeProviderEvent");function M(e){let t=5381;for(let o=0;o<e.length;o++)t=(t<<5)+t+e.charCodeAt(o)|0;return(t>>>0).toString(16).slice(0,6)}f(M,"P"),u(M,"shortHash");function E(e,t){for(const o of Object.keys(e)){const n=e[o];(n instanceof Map||n instanceof Set||Array.isArray(n))&&Q({ownerInstanceId:t,fieldName:o,container:n})}}f(E,"Q"),u(E,"trackProviderContainers");function $(e,t,o){if(v(t))return;const n=Object.getPrototypeOf(e);if(!(!n||n===Object.prototype))for(const c of Object.getOwnPropertyNames(n)){if(P.has(c)||h(o,c))continue;const i=Object.getOwnPropertyDescriptor(n,c);if(!i||typeof i.value!="function"||i.get||i.set)continue;const r=i.value;if(w(r)||v(r))continue;const s=S(r,`${o}.${c}`);try{Object.defineProperty(e,c,{value:s,writable:!0,enumerable:!1,configurable:!0})}catch{}}}f($,"N"),u($,"autoInstrumentProviderMethods");function R(e,t){if(v(e))return;const o=e.prototype;if(!o||o===Object.prototype)return;const n=o;if(n[j])return;const c=[];for(const i of Object.getOwnPropertyNames(o)){if(P.has(i)||h(t,i))continue;const r=Object.getOwnPropertyDescriptor(o,i);if(!r||typeof r.value!="function"||r.get||r.set)continue;const s=r.value;if(w(s)||v(s))continue;const p=S(s,`${t}.${i}`);try{Object.defineProperty(o,i,{value:p,writable:!0,enumerable:!1,configurable:!0}),c.push(i)}catch{}}n[j]=!0,process.env.LENSMCP_DEBUG&&console.error(`[lensmcp] proto-wrapped ${t}: [${c.join(", ")}]`)}f(R,"U"),u(R,"autoInstrumentPrototypeMethods");

package/lib/state.js

@@ -1,44 +1 @@
-import { ulid } from '@lensmcp/core';
-import { defaultEventSink } from './event-sink.js';
-/**
- * Per-process singleton holding the resolved instrumentation options.
- * Tied to `LensmcpModule.forRoot()` — Nest constructs the module once
- * per app boot, so `setActiveOptions` runs exactly once per generation.
- */
-let active;
-let generation = 0;
-export function setActiveOptions(opts) {
-    const resolved = {
-        projectName: opts.projectName,
-        sessionId: opts.sessionId ?? process.env['LENSMCP_SESSION_ID'] ?? ulid(),
-        emit: opts.emit ?? defaultEventSink(),
-        trace: {
-            requests: opts.trace?.requests ?? true,
-            guards: opts.trace?.guards ?? true,
-            controllers: opts.trace?.controllers ?? true,
-            services: opts.trace?.services ?? true,
-            db: opts.trace?.db ?? false,
-            redis: opts.trace?.redis ?? false,
-            queues: opts.trace?.queues ?? false,
-            autoInstrumentMethods: opts.trace?.autoInstrumentMethods ?? false,
-            suppressNoiseMethods: opts.trace?.suppressNoiseMethods ?? true,
-        },
-        memory: {
-            mode: opts.memory?.mode ?? 'off',
-            scope: opts.memory?.scope ?? 'tagged',
-        },
-    };
-    active = resolved;
-    generation += 1;
-    return resolved;
-}
-export function activeOptions() {
-    if (!active) {
-        throw new Error('@lensmcp/nest-instrumentation: LensmcpModule.forRoot(...) has not been registered. ' +
-            'Did you forget to add it to your AppModule?');
-    }
-    return active;
-}
-export function currentGeneration() {
-    return generation;
-}
+"use strict";var i=Object.defineProperty;var r=(e,t)=>i(e,"name",{value:t,configurable:!0});var c=Object.defineProperty,o=r((e,t)=>c(e,"name",{value:t,configurable:!0}),"t");import{ulid as u}from"@lensmcp/core";import{defaultEventSink as a}from"./event-sink.js";let s,n=0;export function setActiveOptions(e){const t={projectName:e.projectName,sessionId:e.sessionId??process.env.LENSMCP_SESSION_ID??u(),emit:e.emit??a(),trace:{requests:e.trace?.requests??!0,guards:e.trace?.guards??!0,controllers:e.trace?.controllers??!0,services:e.trace?.services??!0,db:e.trace?.db??!1,redis:e.trace?.redis??!1,queues:e.trace?.queues??!1,autoInstrumentMethods:e.trace?.autoInstrumentMethods??!1,suppressNoiseMethods:e.trace?.suppressNoiseMethods??!0},memory:{mode:e.memory?.mode??"off",scope:e.memory?.scope??"tagged"}};return s=t,n+=1,t}r(setActiveOptions,"setActiveOptions"),o(setActiveOptions,"setActiveOptions");export function activeOptions(){if(!s)throw new Error("@lensmcp/nest-instrumentation: LensmcpModule.forRoot(...) has not been registered. Did you forget to add it to your AppModule?");return s}r(activeOptions,"activeOptions"),o(activeOptions,"activeOptions");export function currentGeneration(){return n}r(currentGeneration,"currentGeneration"),o(currentGeneration,"currentGeneration");

package/lib/trace-interceptor.js

@@ -1,194 +1 @@
-import { __decorate } from "tslib";
-import { Injectable } from '@nestjs/common';
-import { Observable } from 'rxjs';
-import { catchError, tap } from 'rxjs/operators';
-import { fingerprint, ulid } from '@lensmcp/core';
-import { activeMemoryOptions, onFlowStart, onFlowSettled } from '@lensmcp/memory-tracker';
-import { LENSMCP_CONTEXT_STORAGE } from './context.js';
-import { activeOptions } from './state.js';
-/**
- * Wraps every Nest HTTP request:
- *   1. Reads `x-request-id`, `x-lensmcp-flow-id`, `x-lensmcp-origin-node-id`,
- *      `traceparent` headers from the incoming request.
- *   2. Runs the rest of the request inside a new
- *      `LensmcpRequestContext` so any `@TraceMethod`-decorated service
- *      call, DB query, or queue job downstream inherits the same flow.
- *   3. Emits a `server-request` event on completion with method, route,
- *      status, and duration.
- */
-let TraceInterceptor = class TraceInterceptor {
-    intercept(execCtx, next) {
-        const opts = activeOptions();
-        if (!opts.trace.requests)
-            return next.handle();
-        const http = execCtx.switchToHttp();
-        const req = http.getRequest();
-        const res = http.getResponse();
-        const requestId = stringHeader(req.headers?.['x-request-id']) ?? ulid();
-        const ctx = {
-            sessionId: opts.sessionId,
-            requestId,
-            flowId: stringHeader(req.headers?.['x-lensmcp-flow-id']),
-            originNodeId: stringHeader(req.headers?.['x-lensmcp-origin-node-id']),
-            traceparent: stringHeader(req.headers?.['traceparent']),
-            dbCallCount: 0,
-        };
-        const method = (req.method ?? 'GET').toUpperCase();
-        const route = req.route?.path ?? req.url ?? '<unknown>';
-        // The controller hop, by name. Wrapping controller instances at bootstrap
-        // is too late — Nest's router captured the raw method reference when the
-        // routes were mapped — so the interceptor (which brackets the handler)
-        // is the seam that can see and time the controller call.
-        const controllerCls = execCtx.getClass?.()?.name;
-        const handlerName = execCtx.getHandler?.()?.name;
-        const startedAt = Date.now();
-        // Phase 7.5: bracket the request as a memory "flow" so the
-        // suspect-leak detector can compare tracked-container sizes at
-        // request start vs after it settles. Keyed by requestId.
-        const memoryOn = opts.memory.mode !== 'off';
-        if (memoryOn)
-            onFlowStart(requestId);
-        const settleAndCheck = () => {
-            if (!memoryOn)
-                return;
-            const settleMs = activeMemoryOptions()?.settleMs ?? 1000;
-            const t = setTimeout(() => onFlowSettled(requestId), settleMs);
-            t.unref?.();
-        };
-        return new Observable((subscriber) => {
-            LENSMCP_CONTEXT_STORAGE.run(ctx, () => {
-                next
-                    .handle()
-                    .pipe(tap({
-                    next: (v) => subscriber.next(v),
-                    complete: () => {
-                        emitRequest(opts.projectName, ctx, method, route, res.statusCode ?? 200, startedAt);
-                        emitControllerSpan(ctx, controllerCls, handlerName, startedAt, 'ok');
-                        settleAndCheck();
-                        subscriber.complete();
-                    },
-                }), catchError((err) => {
-                    // The exception filter hasn't written the response yet — Nest's
-                    // default (201 for POST) is still on res.statusCode. The thrown
-                    // error knows the real status: HttpException via getStatus(),
-                    // domain errors via the `status`/`statusCode` field convention.
-                    const e = err;
-                    const errStatus = typeof e?.getStatus === 'function' ? e.getStatus()
-                        : typeof e?.status === 'number' && e.status >= 100 ? e.status
-                            : typeof e?.statusCode === 'number' && e.statusCode >= 100 ? e.statusCode
-                                : res.statusCode && res.statusCode >= 400 ? res.statusCode
-                                    : 500;
-                    emitRequest(opts.projectName, ctx, method, route, errStatus, startedAt, err);
-                    emitControllerSpan(ctx, controllerCls, handlerName, startedAt, 'error');
-                    settleAndCheck();
-                    subscriber.error(err);
-                    return new Observable();
-                }))
-                    .subscribe();
-            });
-        });
-    }
-};
-TraceInterceptor = __decorate([
-    Injectable()
-], TraceInterceptor);
-export { TraceInterceptor };
-function stringHeader(v) {
-    if (typeof v === 'string')
-        return v;
-    if (Array.isArray(v) && typeof v[0] === 'string')
-        return v[0];
-    return undefined;
-}
-/** The controller hop as a span — `CompanyController.create (12ms)`. */
-function emitControllerSpan(ctx, controllerCls, handlerName, startedAt, status) {
-    if (!controllerCls || !handlerName)
-        return;
-    const opts = activeOptions();
-    const durationMs = Date.now() - startedAt;
-    const name = `${controllerCls}.${handlerName}`;
-    opts.emit({
-        id: ulid(),
-        sessionId: ctx.sessionId,
-        timestamp: Date.now(),
-        source: 'nestjs',
-        category: 'backend',
-        severity: status === 'error' ? 'error' : 'info',
-        context: { sessionId: ctx.sessionId, flowId: ctx.flowId, requestId: ctx.requestId },
-        fingerprint: fingerprint({ kind: 'method-call', identity: name }),
-        title: `${name} (${durationMs}ms)${status === 'error' ? ' ✗' : ''}`,
-        raw: {
-            kind: 'span',
-            span: {
-                name,
-                role: 'controller',
-                flowId: ctx.flowId,
-                requestId: ctx.requestId,
-                startTime: startedAt,
-                endTime: Date.now(),
-                durationMs,
-                status,
-            },
-        },
-    });
-}
-function emitRequest(projectName, ctx, method, route, status, startedAt, err) {
-    const opts = activeOptions();
-    const durationMs = Date.now() - startedAt;
-    const isError = status >= 500 || err !== undefined;
-    const event = {
-        id: ulid(),
-        sessionId: ctx.sessionId,
-        timestamp: Date.now(),
-        source: 'nestjs',
-        category: 'backend',
-        severity: isError ? 'error' : 'info',
-        context: {
-            sessionId: ctx.sessionId,
-            flowId: ctx.flowId,
-            requestId: ctx.requestId,
-            originNodeId: ctx.originNodeId,
-            traceparent: ctx.traceparent,
-        },
-        fingerprint: fingerprint({
-            kind: 'server-request',
-            identity: `${method}:${route}:${Math.floor(status / 100)}xx`,
-        }),
-        title: `${method} ${route} → ${status} (${durationMs}ms)`,
-        message: err instanceof Error ? err.message : undefined,
-        raw: {
-            kind: 'server-request',
-            request: {
-                method,
-                route,
-                status,
-                durationMs,
-                startedAt,
-                endedAt: Date.now(),
-                flowId: ctx.flowId,
-                requestId: ctx.requestId,
-            },
-        },
-    };
-    // Also emit a span-shaped event so trace:// picks it up.
-    const spanEvent = {
-        ...event,
-        id: ulid(),
-        raw: {
-            kind: 'span',
-            span: {
-                name: `nest.request ${method} ${route}`,
-                traceId: ctx.traceparent,
-                flowId: ctx.flowId,
-                requestId: ctx.requestId,
-                startTime: startedAt,
-                endTime: Date.now(),
-                durationMs,
-                status: isError ? 'error' : 'ok',
-            },
-        },
-    };
-    void projectName; // reserved for per-project namespacing
-    opts.emit(event);
-    opts.emit(spanEvent);
-}
+"use strict";var M=Object.defineProperty;var m=(e,t)=>M(e,"name",{value:t,configurable:!0});var N=Object.defineProperty,u=m((e,t)=>N(e,"name",{value:t,configurable:!0}),"p");import{__decorate as S}from"tslib";import{Injectable as j}from"@nestjs/common";import{Observable as k}from"rxjs";import{catchError as A,tap as E}from"rxjs/operators";import{fingerprint as x,ulid as y}from"@lensmcp/core";import{activeMemoryOptions as O,onFlowStart as R,onFlowSettled as _}from"@lensmcp/memory-tracker";import{LENSMCP_CONTEXT_STORAGE as H}from"./context.js";import{activeOptions as h}from"./state.js";let C=class{static{m(this,"$")}static{u(this,"TraceInterceptor")}intercept(e,t){const s=h();if(!s.trace.requests)return t.handle();const n=e.switchToHttp(),r=n.getRequest(),a=n.getResponse(),d=w(r.headers?.["x-request-id"])??y(),o={sessionId:s.sessionId,requestId:d,flowId:w(r.headers?.["x-lensmcp-flow-id"]),originNodeId:w(r.headers?.["x-lensmcp-origin-node-id"]),traceparent:w(r.headers?.traceparent),dbCallCount:0},c=(r.method??"GET").toUpperCase(),p=r.route?.path??r.url??"<unknown>",f=e.getClass?.()?.name,g=e.getHandler?.()?.name,q=Date.now(),v=s.memory.mode!=="off";v&&R(d);const T=u(()=>{if(!v)return;const l=O()?.settleMs??1e3;setTimeout(()=>_(d),l).unref?.()},"settleAndCheck");return new k(l=>{H.run(o,()=>{t.handle().pipe(E({next:u(I=>l.next(I),"next"),complete:u(()=>{b(s.projectName,o,c,p,a.statusCode??200,q),$(o,f,g,q,"ok"),T(),l.complete()},"complete")}),A(I=>{const i=I,D=typeof i?.getStatus=="function"?i.getStatus():typeof i?.status=="number"&&i.status>=100?i.status:typeof i?.statusCode=="number"&&i.statusCode>=100?i.statusCode:a.statusCode&&a.statusCode>=400?a.statusCode:500;return b(s.projectName,o,c,p,D,q,I),$(o,f,g,q,"error"),T(),l.error(I),new k})).subscribe()})})}};C=S([j()],C);export{C as TraceInterceptor};function w(e){if(typeof e=="string")return e;if(Array.isArray(e)&&typeof e[0]=="string")return e[0]}m(w,"q"),u(w,"stringHeader");function $(e,t,s,n,r){if(!t||!s)return;const a=h(),d=Date.now()-n,o=`${t}.${s}`;a.emit({id:y(),sessionId:e.sessionId,timestamp:Date.now(),source:"nestjs",category:"backend",severity:r==="error"?"error":"info",context:{sessionId:e.sessionId,flowId:e.flowId,requestId:e.requestId},fingerprint:x({kind:"method-call",identity:o}),title:`${o} (${d}ms)${r==="error"?" \u2717":""}`,raw:{kind:"span",span:{name:o,role:"controller",flowId:e.flowId,requestId:e.requestId,startTime:n,endTime:Date.now(),durationMs:d,status:r}}})}m($,"E"),u($,"emitControllerSpan");function b(e,t,s,n,r,a,d){const o=h(),c=Date.now()-a,p=r>=500||d!==void 0,f={id:y(),sessionId:t.sessionId,timestamp:Date.now(),source:"nestjs",category:"backend",severity:p?"error":"info",context:{sessionId:t.sessionId,flowId:t.flowId,requestId:t.requestId,originNodeId:t.originNodeId,traceparent:t.traceparent},fingerprint:x({kind:"server-request",identity:`${s}:${n}:${Math.floor(r/100)}xx`}),title:`${s} ${n} \u2192 ${r} (${c}ms)`,message:d instanceof Error?d.message:void 0,raw:{kind:"server-request",request:{method:s,route:n,status:r,durationMs:c,startedAt:a,endedAt:Date.now(),flowId:t.flowId,requestId:t.requestId}}},g={...f,id:y(),raw:{kind:"span",span:{name:`nest.request ${s} ${n}`,traceId:t.traceparent,flowId:t.flowId,requestId:t.requestId,startTime:a,endTime:Date.now(),durationMs:c,status:p?"error":"ok"}}};o.emit(f),o.emit(g)}m(b,"S"),u(b,"emitRequest");

package/lib/trace-method.js

@@ -1,31 +1 @@
-import { traceWrap } from './instrument.js';
-/**
- * `@TraceMethod()` — decorate a service/controller method so every
- * invocation emits a `span` event with method name + duration. Inherits
- * the request's `flowId`/`requestId` from the `AsyncLocalStorage`
- * context set by `TraceInterceptor`.
- *
- *   @Injectable()
- *   class AuthService {
- *     @TraceMethod()                 login(dto) { … }
- *     @TraceMethod({ db: true })     findUser(id) { … }
- *   }
- *
- * Wraps sync + async methods; sync throws / async rejections become
- * `status=error` spans. Uses the same `traceWrap` the bootstrap
- * auto-instrumenter uses, so a method is never double-wrapped.
- */
-export function TraceMethod(nameOverrideOrOptions) {
-    const options = typeof nameOverrideOrOptions === 'string'
-        ? { name: nameOverrideOrOptions }
-        : nameOverrideOrOptions ?? {};
-    return function (target, propertyKey, descriptor) {
-        const fn = descriptor.value;
-        if (typeof fn !== 'function')
-            return descriptor;
-        const className = target.constructor?.name ?? 'Anonymous';
-        const spanName = options.name ?? `${className}.${String(propertyKey)}`;
-        descriptor.value = traceWrap(fn, spanName, { db: options.db });
-        return descriptor;
-    };
-}
+"use strict";var s=Object.defineProperty;var n=(e,t)=>s(e,"name",{value:t,configurable:!0});var f=Object.defineProperty,m=n((e,t)=>f(e,"name",{value:t,configurable:!0}),"u");import{traceWrap as p}from"./instrument.js";export function TraceMethod(e){const t=typeof e=="string"?{name:e}:e??{};return function(o,c,r){const a=r.value;if(typeof a!="function")return r;const u=o.constructor?.name??"Anonymous",i=t.name??`${u}.${String(c)}`;return r.value=p(a,i,{db:t.db}),r}}n(TraceMethod,"TraceMethod"),m(TraceMethod,"TraceMethod");

package/lib/trace-provider.js

@@ -1,25 +1 @@
-/**
- * `@TraceProvider({ memory: true })` — opt a provider into memory
- * container tracking. The provider tracker reads this metadata at
- * bootstrap and, for each tagged provider (or all providers when
- * `memory.scope === 'all'`), scans the instance's own enumerable
- * fields for Map / Set / Array containers and wraps them via
- * `trackContainer`.
- *
- * Implemented without `reflect-metadata` writes beyond a plain
- * property flag so it stays decoupled from Nest's metadata system.
- */
-const TRACE_PROVIDER_FLAG = Symbol.for('@lensmcp/nest-instrumentation/trace-provider');
-export function TraceProvider(options = {}) {
-    return (target) => {
-        target[TRACE_PROVIDER_FLAG] = {
-            memory: options.memory ?? true,
-        };
-    };
-}
-export function readTraceProvider(ctor) {
-    if (!ctor || (typeof ctor !== 'function' && typeof ctor !== 'object')) {
-        return undefined;
-    }
-    return ctor[TRACE_PROVIDER_FLAG];
-}
+"use strict";var c=Object.defineProperty;var o=(r,e)=>c(r,"name",{value:e,configurable:!0});var i=Object.defineProperty,t=o((r,e)=>i(r,"name",{value:e,configurable:!0}),"n");const n=Symbol.for("@lensmcp/nest-instrumentation/trace-provider");export function TraceProvider(r={}){return e=>{e[n]={memory:r.memory??!0}}}o(TraceProvider,"TraceProvider"),t(TraceProvider,"TraceProvider");export function readTraceProvider(r){if(!(!r||typeof r!="function"&&typeof r!="object"))return r[n]}o(readTraceProvider,"readTraceProvider"),t(readTraceProvider,"readTraceProvider");

package/lib/types.js

@@ -1 +1 @@
-export {};
+"use strict";export{};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lensmcp/nest-instrumentation",
-  "version": "1.18.4",
+  "version": "1.18.7",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",
@@ -14,9 +14,9 @@
     }
   },
   "dependencies": {
-    "@lensmcp/core": "1.18.4",
-    "@lensmcp/memory-tracker": "1.18.4",
-    "@lensmcp/protocol-types": "1.18.4",
+    "@lensmcp/core": "1.18.7",
+    "@lensmcp/memory-tracker": "1.18.7",
+    "@lensmcp/protocol-types": "1.18.7",
     "tslib": "^2.3.0"
   },
   "peerDependencies": {