netra-sdk 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -49,7 +49,13 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -2333,8 +2339,8 @@ var Usage = class {
       if (!page) {
         break;
       }
-      for (const trace16 of page.traces) {
-        yield trace16;
+      for (const trace17 of page.traces) {
+        yield trace17;
       }
       if (!page.hasNextPage || !page.nextCursor) {
         break;
@@ -3417,6 +3423,10 @@ function anthropicWrapper(tracer, spanName, requestType) {
       return isPromise(result) ? result.then((value) => value) : result;
     }
     const isStreaming = args[0]?.stream === true;
+    if (process.env.NETRA_DEBUG_LOGS) {
+      const activeSpan = api.trace.getSpan(api.context.active());
+      console.log(`[Netra Debug] Anthropic invoke (${requestType}). Active TraceId: ${activeSpan?.spanContext().traceId}, SpanId: ${activeSpan?.spanContext().spanId}`);
+    }
     if (isStreaming && STREAM_ENABLED_REQUESTS.includes(requestType)) {
       const currentContext = api.context.active();
       const span2 = tracer.startSpan(
@@ -5351,6 +5361,9 @@ var NetraGroqInstrumentor = class {
 };
 var groqInstrumentor = new NetraGroqInstrumentor();
 
+// src/instrumentation/langgraph/version.ts
+var __version__4 = "1.0.0";
+
 // node_modules/@langchain/core/dist/_virtual/rolldown_runtime.js
 var __defProp2 = Object.defineProperty;
 var __export = (target, all) => {
@@ -5908,6 +5921,7 @@ function setLlmPrompts(span2, prompts) {
 }
 
 // src/instrumentation/langgraph/wrappers.ts
+var LANGGRAPH_INSTRUMENTATION_ACTIVE = api.createContextKey("netra.langgraph.active");
 var NetraLanggraphCallbackHandler = class extends BaseCallbackHandler {
   constructor(tracer, rootSpan) {
     super();
@@ -6087,13 +6101,30 @@ var LanggraphWrapper = class {
     return updatedConfig;
   }
   async invoke(originalFunc, instance, input, config2, ...rest) {
-    if (shouldSuppressInstrumentation()) {
+    if (shouldSuppressInstrumentation() || api.context.active().getValue(LANGGRAPH_INSTRUMENTATION_ACTIVE)) {
       return await originalFunc.call(instance, input, config2, ...rest);
     }
-    const span2 = this.tracer.startSpan(this.spanName, {
-      kind: api.SpanKind.CLIENT
-    });
-    return api.context.with(api.trace.setSpan(api.context.active(), span2), async () => {
+    const activeSpan = api.trace.getSpan(api.context.active());
+    if (process.env.NETRA_DEBUG_LOGS) {
+      console.log(`[Netra Debug] LangGraph invoke start. Active TraceId: ${activeSpan?.spanContext().traceId}, SpanId: ${activeSpan?.spanContext().spanId}`);
+    }
+    const span2 = this.tracer.startSpan(
+      this.spanName,
+      {
+        kind: api.SpanKind.CLIENT
+      },
+      api.context.active()
+    );
+    if (process.env.NETRA_DEBUG_LOGS) {
+      console.log(`[Netra Debug] LangGraph span created. New TraceId: ${span2.spanContext().traceId}, SpanId: ${span2.spanContext().spanId}`);
+    }
+    const ctxWithSpan = api.trace.setSpan(api.context.active(), span2);
+    const ctxWithFlag = ctxWithSpan.setValue(LANGGRAPH_INSTRUMENTATION_ACTIVE, true);
+    return api.context.with(ctxWithFlag, async () => {
+      if (process.env.NETRA_DEBUG_LOGS) {
+        const innerSpan = api.trace.getSpan(api.context.active());
+        console.log(`[Netra Debug] Inside LangGraph context. Active TraceId: ${innerSpan?.spanContext().traceId}, SpanId: ${innerSpan?.spanContext().spanId}`);
+      }
       try {
         setGraphInputAttributes(span2, input);
         const updatedConfig = this.getUpdatedConfig(config2, span2);
@@ -6114,9 +6145,15 @@ var LanggraphWrapper = class {
     });
   }
   async stream(originalFunc, instance, input, config2, ...rest) {
-    if (shouldSuppressInstrumentation()) {
+    if (shouldSuppressInstrumentation() || api.context.active().getValue(LANGGRAPH_INSTRUMENTATION_ACTIVE)) {
+      if (process.env.NETRA_DEBUG_LOGS) {
+        console.log("[Netra Debug] LangGraph stream skipped (inside instrumented call)");
+      }
       return await originalFunc.call(instance, input, config2, ...rest);
     }
+    if (process.env.NETRA_DEBUG_LOGS) {
+      console.log("[Netra Debug] LangGraph stream starting instrumentation");
+    }
     const span2 = this.tracer.startSpan(
       this.spanName,
       {
@@ -6142,22 +6179,71 @@ var LanggraphWrapper = class {
   }
 };
 
-// src/instrumentation/langgraph/version.ts
-var __version__4 = "1.0.0";
-
 // src/instrumentation/langgraph/index.ts
 var INSTRUMENTATION_NAME4 = "netra.instrumentation.langchain";
 var INSTRUMENTS4 = ["langgraph >= 1.1.1"];
 var isInstrumented4 = false;
 var LanggraphClass = null;
 var originalMethods3 = /* @__PURE__ */ new Map();
+function findModuleInCache(moduleName) {
+  if (typeof __require !== "undefined" && __require.cache) {
+    const cache = __require.cache;
+    for (const key of Object.keys(cache)) {
+      if (key.includes(moduleName.replace(/\//g, "/")) && !key.includes("netra-sdk")) {
+        if (process.env.NETRA_DEBUG_LOGS) {
+          console.log(`Found module in require.cache: ${key}`);
+        }
+        return cache[key]?.exports;
+      }
+    }
+    if (process.env.NETRA_DEBUG_LOGS) {
+      console.log(
+        `Module ${moduleName} not found in require.cache. Cache keys containing 'langgraph':`,
+        Object.keys(cache).filter((k) => k.includes("langgraph"))
+      );
+    }
+  }
+  return null;
+}
 async function resolveLanggraph() {
   if (LanggraphClass) return LanggraphClass;
   try {
-    const langgraphModule = await import('@langchain/langgraph');
-    LanggraphClass = langgraphModule.CompiledStateGraph;
+    let langgraphModule = findModuleInCache("@langchain/langgraph");
+    if (langgraphModule) {
+      if (process.env.NETRA_DEBUG_LOGS) {
+        console.log("Found @langchain/langgraph in require.cache (using app's module instance)");
+      }
+    } else {
+      langgraphModule = await import('@langchain/langgraph');
+      if (process.env.NETRA_DEBUG_LOGS) {
+        console.log("Loaded @langchain/langgraph via dynamic import");
+      }
+    }
+    if (process.env.NETRA_DEBUG_LOGS) {
+      console.log("LangGraph Module Exports:", Object.keys(langgraphModule));
+    }
+    LanggraphClass = langgraphModule.CompiledStateGraph ?? langgraphModule.StateGraph;
+    if (process.env.NETRA_DEBUG_LOGS) {
+      console.log("Resolved LanggraphClass:", !!LanggraphClass);
+      console.log("LanggraphClass name:", LanggraphClass?.name);
+      console.log("LanggraphClass.prototype keys:", LanggraphClass?.prototype ? Object.getOwnPropertyNames(LanggraphClass.prototype) : "no prototype");
+      console.log("Has invoke on prototype:", !!LanggraphClass?.prototype?.invoke);
+      console.log("Has stream on prototype:", !!LanggraphClass?.prototype?.stream);
+      console.log("Checking prototype chain for invoke location:");
+      let proto = LanggraphClass?.prototype;
+      while (proto) {
+        const hasOwn = Object.getOwnPropertyNames(proto).includes("invoke");
+        console.log(`  ${proto.constructor?.name}: hasOwnProperty('invoke')=${hasOwn}`);
+        if (hasOwn) {
+          console.log(`  -> invoke is defined on: ${proto.constructor?.name}`);
+          break;
+        }
+        proto = Object.getPrototypeOf(proto);
+      }
+    }
     return LanggraphClass;
-  } catch {
+  } catch (e) {
+    console.error("Failed to resolve LangGraph:", e);
     return null;
   }
 }
@@ -6178,6 +6264,7 @@ var NetraLanggraphInstrumentor = class {
     }
     const Langgraph = await resolveLanggraph();
     if (!Langgraph) {
+      if (process.env.NETRA_DEBUG_LOGS) console.warn("LangGraph class not found, skipping instrumentation");
       return this;
     }
     try {
@@ -6187,17 +6274,19 @@ var NetraLanggraphInstrumentor = class {
       console.error(`Failed to initialize tracer: ${error}`);
       return this;
     }
+    this._instrumentInvoke(Langgraph);
     this._instrumentStream(Langgraph);
     isInstrumented4 = true;
     return this;
   }
   async uninstrument() {
     if (!isInstrumented4) {
-      console.warn("OpenAI is not instrumented");
+      console.warn("LangGraph is not instrumented");
       return;
     }
     const Langgraph = await resolveLanggraph();
     if (Langgraph) {
+      this._uninstrumentInvoke(Langgraph);
       this._uninstrumentStream(Langgraph);
     }
     originalMethods3.clear();
@@ -6206,15 +6295,26 @@ var NetraLanggraphInstrumentor = class {
   _instrumentInvoke(Langgraph) {
     if (!this.tracer) return;
     try {
-      if (!Langgraph?.prototype?.invoke) {
+      let targetProto = Langgraph?.prototype;
+      while (targetProto && !Object.getOwnPropertyNames(targetProto).includes("invoke")) {
+        targetProto = Object.getPrototypeOf(targetProto);
+      }
+      if (!targetProto?.invoke) {
         console.error("Failed to find langgraph invoke function to instrument");
         return;
       }
-      const originalInvoke = Langgraph.prototype.invoke;
+      if (process.env.NETRA_DEBUG_LOGS) {
+        console.log(`Found invoke on prototype: ${targetProto.constructor?.name}`);
+      }
+      const originalInvoke = targetProto.invoke;
       originalMethods3.set("langgraph.graph.invoke", originalInvoke);
+      originalMethods3.set("langgraph.graph.invoke.proto", targetProto);
       const tracer = this.tracer;
       const wrapper = new LanggraphWrapper(tracer);
-      Langgraph.prototype.invoke = async function(input, config2, ...rest) {
+      const patchedInvoke = async function(input, config2, ...rest) {
+        if (process.env.NETRA_DEBUG_LOGS) {
+          console.log("[Netra Debug] LangGraph invoke intercepted!");
+        }
         return await wrapper.invoke(
           originalInvoke,
           this,
@@ -6223,6 +6323,12 @@ var NetraLanggraphInstrumentor = class {
           ...rest
         );
       };
+      patchedInvoke.__netra_patched = true;
+      targetProto.invoke = patchedInvoke;
+      if (process.env.NETRA_DEBUG_LOGS) {
+        console.log(`Successfully instrumented LangGraph invoke method on ${targetProto.constructor?.name}`);
+        console.log(`Patched Pregel class identity:`, targetProto.constructor);
+      }
     } catch (error) {
       console.error(`Failed to instrument langgraph invoke: ${error}`);
     }
@@ -6230,15 +6336,26 @@ var NetraLanggraphInstrumentor = class {
   _instrumentStream(Langgraph) {
     if (!this.tracer) return;
     try {
-      if (!Langgraph?.prototype?.stream) {
+      let targetProto = Langgraph?.prototype;
+      while (targetProto && !Object.getOwnPropertyNames(targetProto).includes("stream")) {
+        targetProto = Object.getPrototypeOf(targetProto);
+      }
+      if (!targetProto?.stream) {
         console.error("Failed to find langgraph stream function to instrument");
         return;
       }
-      const originalStream = Langgraph.prototype.stream;
+      if (process.env.NETRA_DEBUG_LOGS) {
+        console.log(`Found stream on prototype: ${targetProto.constructor?.name}`);
+      }
+      const originalStream = targetProto.stream;
       originalMethods3.set("langgraph.graph.stream", originalStream);
+      originalMethods3.set("langgraph.graph.stream.proto", targetProto);
       const tracer = this.tracer;
       const wrapper = new LanggraphWrapper(tracer);
-      Langgraph.prototype.stream = async function(input, config2, ...rest) {
+      targetProto.stream = async function(input, config2, ...rest) {
+        if (process.env.NETRA_DEBUG_LOGS) {
+          console.log("[Netra Debug] LangGraph stream intercepted!");
+        }
         return await wrapper.stream(
           originalStream,
           this,
@@ -6247,6 +6364,9 @@ var NetraLanggraphInstrumentor = class {
           ...rest
         );
       };
+      if (process.env.NETRA_DEBUG_LOGS) {
+        console.log(`Successfully instrumented LangGraph stream method on ${targetProto.constructor?.name}`);
+      }
     } catch (error) {
       console.error(`Failed to instrument langgraph stream: ${error}`);
     }
@@ -6254,8 +6374,9 @@ var NetraLanggraphInstrumentor = class {
   _uninstrumentInvoke(Langgraph) {
     try {
       const originalInvoke = originalMethods3.get("langgraph.graph.invoke");
-      if (originalInvoke && Langgraph?.prototype?.invoke) {
-        Langgraph.prototype.invoke = originalInvoke;
+      const targetProto = originalMethods3.get("langgraph.graph.invoke.proto") || Langgraph?.prototype;
+      if (originalInvoke && targetProto?.invoke) {
+        targetProto.invoke = originalInvoke;
       }
     } catch (error) {
       console.error(`Failed to uninstrument langgraph invoke: ${error}`);
@@ -6265,8 +6386,9 @@ var NetraLanggraphInstrumentor = class {
   _uninstrumentStream(Langgraph) {
     try {
       const originalStream = originalMethods3.get("langgraph.graph.stream");
-      if (originalStream && Langgraph?.prototype?.stream) {
-        Langgraph.prototype.stream = originalStream;
+      const targetProto = originalMethods3.get("langgraph.graph.stream.proto") || Langgraph?.prototype;
+      if (originalStream && targetProto?.stream) {
+        targetProto.stream = originalStream;
       }
     } catch (error) {
       console.error(`Failed to uninstrument langgraph stream: ${error}`);
@@ -8391,6 +8513,13 @@ function initInstrumentations(config2, instruments, blockInstruments) {
     customInstrumentModules.googleGenAI = true;
     customInstrumentModules.anthropic = true;
   } else if (instruments.size) {
+    instrumentModules.google_vertexai = false;
+    instrumentModules.langchain = false;
+    instrumentModules.llamaIndex = false;
+    instrumentModules.pinecone = false;
+    instrumentModules.qdrant = false;
+    instrumentModules.chromadb = false;
+    instrumentModules.together = false;
     if (instruments.has("openai" /* OPENAI */)) {
       customInstrumentModules.openai = true;
     }
@@ -8948,11 +9077,16 @@ var Netra = class {
   }
   /**
    * Initialize the Netra SDK
-   * Note: Custom instrumentations (OpenAI, Groq, MistralAI) are initialized
-   * asynchronously. Use initAsync() or await Netra.ready() to ensure
-   * instrumentations are complete before using instrumented modules.
+   *
+   * This method is async and must be awaited to ensure all instrumentations
+   * are ready before your application starts using instrumented modules.
+   *
+   * @example
+   * await Netra.init({ appName: 'my-app', instruments: new Set([NetraInstruments.OPENAI]) });
+   * // Now all instrumentations are ready
+   * const openai = new OpenAI();
    */
-  static init(config2 = {}) {
+  static async init(config2 = {}) {
     if (this._initialized) {
       console.warn(
         "Netra.init() called more than once; ignoring subsequent calls."
@@ -8982,11 +9116,9 @@ var Netra = class {
     this.dashboard = new Dashboard(cfg);
     this._initialized = true;
     console.info("Netra successfully initialized.");
-    this._initialized = true;
-    console.info("Netra successfully initialized.");
     const handleSignal = async (signal) => {
       console.log(`
-Recepived ${signal}. Shutting down Netra SDK...`);
+Received ${signal}. Shutting down Netra SDK...`);
       await this.shutdown();
       process.exit(0);
     };
@@ -9028,30 +9160,22 @@ Recepived ${signal}. Shutting down Netra SDK...`);
         );
       }
     }
+    await instrumentationsReady;
   }
   /**
-   * Initialize the Netra SDK and wait for all instrumentations to be ready.
-   * This is the recommended way to initialize Netra when using ES modules,
-   * as it ensures all async instrumentations (OpenAI, Groq, MistralAI) are
-   * complete before the application starts using the instrumented modules.
+   * @deprecated Use `Netra.init()` instead. The init method is now async by default.
    *
-   * @example
-   * await Netra.initAsync({ appName: 'my-app', instruments: new Set([NetraInstruments.OPENAI]) });
-   * // Now OpenAI is fully instrumented
-   * const openai = new OpenAI();
+   * Initialize the Netra SDK and wait for all instrumentations to be ready.
+   * This method is kept for backwards compatibility.
    */
   static async initAsync(config2 = {}) {
-    this.init(config2);
-    await instrumentationsReady;
+    await this.init(config2);
   }
   /**
-   * Returns a promise that resolves when all async instrumentations are ready.
-   * Can be called after init() to wait for instrumentations.
+   * @deprecated Since `Netra.init()` is now async and waits for instrumentations,
+   * this method is no longer necessary. It's kept for backwards compatibility.
    *
-   * @example
-   * Netra.init({ appName: 'my-app' });
-   * await Netra.ready();
-   * // Now all instrumentations are complete
+   * Returns a promise that resolves when all async instrumentations are ready.
    */
   static async ready() {
     await instrumentationsReady;