@cloudbase/agent-observability 0.0.20 → 0.0.21

package/dist/langchain.js

@@ -809,63 +809,98 @@ function createParentContext(parentSpanContext) {
   if (!parentSpanContext) return;
   return import_api4.trace.setSpanContext(import_api4.context.active(), parentSpanContext);
 }
-function startObservation(name, attributes, options) {
-  const { asType = "chain", ...observationOptions } = options || {};
-  const otelSpan = createOtelSpan({
-    name,
-    ...observationOptions
-  });
+function createNoopSpan() {
+  return import_api4.trace.wrapSpanContext(import_api4.INVALID_SPAN_CONTEXT);
+}
+function createNoopObservation(asType = "chain") {
+  const otelSpan = createNoopSpan();
   switch (asType) {
     case "llm":
-      return new ObservationLLM({
-        otelSpan,
-        attributes
-      });
+      return new ObservationLLM({ otelSpan });
     case "embedding":
-      return new ObservationEmbedding({
-        otelSpan,
-        attributes
-      });
+      return new ObservationEmbedding({ otelSpan });
     case "agent":
-      return new ObservationAgent({
-        otelSpan,
-        attributes
-      });
+      return new ObservationAgent({ otelSpan });
     case "tool":
-      return new ObservationTool({
-        otelSpan,
-        attributes
-      });
-    case "chain":
-      return new ObservationChain({
-        otelSpan,
-        attributes
-      });
+      return new ObservationTool({ otelSpan });
     case "retriever":
-      return new ObservationRetriever({
-        otelSpan,
-        attributes
-      });
+      return new ObservationRetriever({ otelSpan });
     case "reranker":
-      return new ObservationReranker({
-        otelSpan,
-        attributes
-      });
+      return new ObservationReranker({ otelSpan });
     case "evaluator":
-      return new ObservationEvaluator({
-        otelSpan,
-        attributes
-      });
+      return new ObservationEvaluator({ otelSpan });
     case "guardrail":
-      return new ObservationGuardrail({
-        otelSpan,
-        attributes
-      });
+      return new ObservationGuardrail({ otelSpan });
+    case "chain":
     default:
-      return new ObservationChain({
-        otelSpan,
-        attributes
-      });
+      return new ObservationChain({ otelSpan });
+  }
+}
+function startObservation(name, attributes, options) {
+  const { asType = "chain", ...observationOptions } = options || {};
+  try {
+    const otelSpan = createOtelSpan({
+      name,
+      ...observationOptions
+    });
+    switch (asType) {
+      case "llm":
+        return new ObservationLLM({
+          otelSpan,
+          attributes
+        });
+      case "embedding":
+        return new ObservationEmbedding({
+          otelSpan,
+          attributes
+        });
+      case "agent":
+        return new ObservationAgent({
+          otelSpan,
+          attributes
+        });
+      case "tool":
+        return new ObservationTool({
+          otelSpan,
+          attributes
+        });
+      case "chain":
+        return new ObservationChain({
+          otelSpan,
+          attributes
+        });
+      case "retriever":
+        return new ObservationRetriever({
+          otelSpan,
+          attributes
+        });
+      case "reranker":
+        return new ObservationReranker({
+          otelSpan,
+          attributes
+        });
+      case "evaluator":
+        return new ObservationEvaluator({
+          otelSpan,
+          attributes
+        });
+      case "guardrail":
+        return new ObservationGuardrail({
+          otelSpan,
+          attributes
+        });
+      default:
+        return new ObservationChain({
+          otelSpan,
+          attributes
+        });
+    }
+  } catch (err) {
+    console.warn(
+      `[Observability] Failed to create observation "${name}":`,
+      err instanceof Error ? err.message : err
+    );
+    return createNoopObservation(asType);
   }
 }
 function updateActiveTrace(attributes) {
@@ -906,67 +941,81 @@ function wrapPromise(promise, span, endOnExit) {
 }
 function startActiveObservation(name, fn, options) {
   const { asType = "chain", endOnExit, ...observationOptions } = options || {};
-  return getTracer().startActiveSpan(
-    name,
-    { startTime: observationOptions?.startTime },
-    createParentContext(observationOptions?.parentSpanContext) ?? import_api4.context.active(),
-    (span) => {
-      try {
-        let observation;
-        switch (asType) {
-          case "llm":
-            observation = new ObservationLLM({ otelSpan: span });
-            break;
-          case "embedding":
-            observation = new ObservationEmbedding({ otelSpan: span });
-            break;
-          case "agent":
-            observation = new ObservationAgent({ otelSpan: span });
-            break;
-          case "tool":
-            observation = new ObservationTool({ otelSpan: span });
-            break;
-          case "retriever":
-            observation = new ObservationRetriever({ otelSpan: span });
-            break;
-          case "reranker":
-            observation = new ObservationReranker({ otelSpan: span });
-            break;
-          case "evaluator":
-            observation = new ObservationEvaluator({ otelSpan: span });
-            break;
-          case "guardrail":
-            observation = new ObservationGuardrail({ otelSpan: span });
-            break;
-          case "chain":
-          default:
-            observation = new ObservationChain({ otelSpan: span });
-        }
-        const result = fn(observation);
-        if (result instanceof Promise) {
-          return wrapPromise(
-            result,
-            span,
-            endOnExit
-          );
-        } else {
+  let fnCalled = false;
+  try {
+    return getTracer().startActiveSpan(
+      name,
+      { startTime: observationOptions?.startTime },
+      createParentContext(observationOptions?.parentSpanContext) ?? import_api4.context.active(),
+      (span) => {
+        try {
+          let observation;
+          switch (asType) {
+            case "llm":
+              observation = new ObservationLLM({ otelSpan: span });
+              break;
+            case "embedding":
+              observation = new ObservationEmbedding({ otelSpan: span });
+              break;
+            case "agent":
+              observation = new ObservationAgent({ otelSpan: span });
+              break;
+            case "tool":
+              observation = new ObservationTool({ otelSpan: span });
+              break;
+            case "retriever":
+              observation = new ObservationRetriever({ otelSpan: span });
+              break;
+            case "reranker":
+              observation = new ObservationReranker({ otelSpan: span });
+              break;
+            case "evaluator":
+              observation = new ObservationEvaluator({ otelSpan: span });
+              break;
+            case "guardrail":
+              observation = new ObservationGuardrail({ otelSpan: span });
+              break;
+            case "chain":
+            default:
+              observation = new ObservationChain({ otelSpan: span });
+          }
+          fnCalled = true;
+          const result = fn(observation);
+          if (result instanceof Promise) {
+            return wrapPromise(
+              result,
+              span,
+              endOnExit
+            );
+          } else {
+            if (endOnExit !== false) {
+              span.end();
+            }
+            return result;
+          }
+        } catch (err) {
+          span.setStatus({
+            code: import_api4.SpanStatusCode.ERROR,
+            message: err instanceof Error ? err.message : "Unknown error"
+          });
           if (endOnExit !== false) {
             span.end();
           }
-          return result;
-        }
-      } catch (err) {
-        span.setStatus({
-          code: import_api4.SpanStatusCode.ERROR,
-          message: err instanceof Error ? err.message : "Unknown error"
-        });
-        if (endOnExit !== false) {
-          span.end();
+          throw err;
         }
-        throw err;
       }
+    );
+  } catch (err) {
+    if (fnCalled) {
+      throw err;
     }
-  );
+    console.warn(
+      `[Observability] startActiveObservation "${name}" failed, falling back to no-op:`,
+      err instanceof Error ? err.message : err
+    );
+    const noopObservation = createNoopObservation(asType);
+    return fn(noopObservation);
+  }
 }
 function updateActiveObservation(attributes) {
   const span = import_api4.trace.getActiveSpan();
@@ -992,41 +1041,59 @@ function observe(fn, options = {}) {
   } = options;
   const wrappedFunction = function(...args) {
     const name = fn.name || "anonymous-function";
-    const inputData = captureInput ? _captureArguments(args) : void 0;
-    const observation = startObservation(
-      name,
-      inputData ? { input: inputData } : {},
-      {
-        ...observationOptions,
-        asType
-      }
-    );
-    const activeContext = import_api4.trace.setSpan(import_api4.context.active(), observation.otelSpan);
-    const result = import_api4.context.with(activeContext, () => fn.apply(this, args));
-    if (result instanceof Promise) {
-      return result.then(
-        (value) => {
-          if (captureOutput) {
-            observation.update({ output: value });
-          }
-          observation.end();
-          return value;
-        },
-        (err) => {
-          observation.update({
-            level: "ERROR",
-            statusMessage: err instanceof Error ? err.message : "Unknown error"
-          });
-          observation.end();
-          throw err;
+    let observation;
+    let fnCalled = false;
+    try {
+      const inputData = captureInput ? _captureArguments(args) : void 0;
+      observation = startObservation(
+        name,
+        inputData ? { input: inputData } : {},
+        {
+          ...observationOptions,
+          asType
         }
       );
+      const activeContext = import_api4.trace.setSpan(import_api4.context.active(), observation.otelSpan);
+      fnCalled = true;
+      const result = import_api4.context.with(activeContext, () => fn.apply(this, args));
+      if (result instanceof Promise) {
+        return result.then(
+          (value) => {
+            if (captureOutput) {
+              observation.update({ output: value });
+            }
+            observation.end();
+            return value;
+          },
+          (err) => {
+            observation.update({
+              level: "ERROR",
+              statusMessage: err instanceof Error ? err.message : "Unknown error"
+            });
+            observation.end();
+            throw err;
+          }
+        );
+      }
+      if (captureOutput) {
+        observation.update({ output: result });
+      }
+      observation.end();
+      return result;
+    } catch (err) {
+      if (fnCalled) {
+        throw err;
+      }
+      console.warn(
+        `[Observability] observe "${name}" failed, falling back to direct call:`,
+        err instanceof Error ? err.message : err
+      );
+      try {
+        observation?.end();
+      } catch {
+      }
+      return fn.apply(this, args);
     }
-    if (captureOutput) {
-      observation.update({ output: result });
-    }
-    observation.end();
-    return result;
   };
   Object.defineProperty(wrappedFunction, "name", { value: fn.name });
   Object.defineProperty(wrappedFunction, "length", { value: fn.length });
@@ -1488,6 +1555,11 @@ var CallbackHandler = class extends import_base.BaseCallbackHandler {
       }
     );
     this.runMap.set(runId, observation);
+    if (this.runMap.size > 1e3) {
+      this.logger.warn?.(
+        `runMap size (${this.runMap.size}) exceeds 1000. Possible missing end callbacks.`
+      );
+    }
     return observation;
   }
   handleObservationEnd(params) {