bitfab 0.54.14 → 0.57.1

package/dist/{chunk-SV5FYJQ4.js → chunk-AEF2SRQC.js}

@@ -17,9 +17,10 @@ import {
   serializeValue,
   toJsonSafe,
   toJsonSafeReport
-} from "./chunk-X6JOFMNV.js";
+} from "./chunk-6C2SC7HK.js";
 import {
   BitfabError,
+  CONTENT_OFF_KEY,
   DEFAULT_SERVICE_URL,
   HttpClient,
   MixedTracingError,
@@ -28,12 +29,15 @@ import {
   callerTraceMetadata,
   getReplayContext,
   gitRunner,
+  isFrameworkInstrumentation,
   makeSpanOrigin,
   readEnv,
   recordCallerTraceMetadata,
+  recordedByFramework,
   retireTraceMetadata,
+  traceIdOf,
   warnOnce
-} from "./chunk-NIGVK5V7.js";
+} from "./chunk-OBZQSMPQ.js";
 import {
   __privateAdd,
   __privateGet,
@@ -3707,6 +3711,25 @@ var BitfabVercelAiHandler = class {
 
 // src/client.ts
 var activeTraceStates = /* @__PURE__ */ new Map();
+function fitsTraceSpanBudget(payload) {
+  if (!recordedByFramework(payload)) {
+    return true;
+  }
+  const traceId = traceIdOf(payload);
+  const spanBudget = traceId === void 0 ? void 0 : activeTraceStates.get(traceId)?.spanBudget;
+  if (spanBudget === void 0) {
+    return true;
+  }
+  if (spanBudget.spansUsed >= spanBudget.maxSpans) {
+    spanBudget.truncate();
+    return false;
+  }
+  spanBudget.spansUsed += 1;
+  return true;
+}
+function rootTraceFunctionKeyOfTrace(traceId, fallback) {
+  return activeTraceStates.get(traceId)?.traceFunctionKey ?? fallback;
+}
 function rootTraceFunctionKeyOf(payload) {
   const captured = payload[ROOT_TRACE_FUNCTION_KEY_FIELD];
   if (typeof captured === "string") {
@@ -4082,7 +4105,8 @@ function readBooleanEnv(name) {
   return void 0;
 }
 var DEFAULT_AUTO_TRACE_MAX_DEPTH = 30;
-var DEFAULT_AUTO_TRACE_MAX_SPANS = 500;
+var DEFAULT_AUTO_TRACE_MAX_SPANS = 2048;
+var DEFAULT_AUTO_TRACE_MAX_CAPTURED_SUBTREE_SPANS = 512;
 var AUTO_TRACE_PROTOCOL = "ts-auto-v1";
 function spanOwnerName(receiver) {
   if (typeof receiver === "function") {
@@ -4153,6 +4177,9 @@ var Bitfab = class {
     this.httpClient.externalTraceTransform = (payload, submit) => this.simulationPlan.sendTrace(payload, submit);
     this.httpClient.releaseHeldExternalSpans = (timeoutMs) => this.simulationPlan.release(timeoutMs);
     this.httpClient.stopSimulationPlan = () => this.simulationPlan.stop();
+    if (this.findApiKey(false) !== void 0) {
+      this.simulationPlan.refresh();
+    }
     this.datasets = new DatasetsClient(this.httpClient);
     this.assertionCategories = new AssertionCategoriesClient(this.httpClient);
     this.traces = new TracesClient(this.httpClient);
@@ -4309,10 +4336,23 @@ var Bitfab = class {
       options.maxDepth,
       DEFAULT_AUTO_TRACE_MAX_DEPTH
     );
+    if (options.maxSpans !== void 0 && options.maxSpans < 1) {
+      throw new BitfabError(
+        `maxSpans must be at least 1 because the root span counts toward it (got ${options.maxSpans})`
+      );
+    }
     const maxSpans = autoTraceLimit(
       options.maxSpans,
       DEFAULT_AUTO_TRACE_MAX_SPANS
     );
+    const maxCapturedSubtreeSpans = Math.min(
+      autoTraceLimit(
+        options.maxCapturedSubtreeSpans,
+        DEFAULT_AUTO_TRACE_MAX_CAPTURED_SUBTREE_SPANS
+      ),
+      maxSpans
+    );
+    const rootIsAsync = fn.constructor.name === "AsyncFunction";
     const excluded = new Set(options.exclude ?? []);
     const includeWrappers = options.includeWrappers ?? false;
     const rootNameFor = (receiver) => options.name ?? (fn.name !== "" ? qualifiedSpanName(receiver, name) ?? name : name);
@@ -4328,7 +4368,7 @@ var Bitfab = class {
       spanOptions,
       function(...args) {
         self.simulationPlan.refresh();
-        let spansUsed = 0;
+        let capturedSubtreeCount = 0;
         let truncated = false;
         const warnTruncated = () => {
           if (!truncated) {
@@ -4338,15 +4378,27 @@ var Bitfab = class {
                 protocol: AUTO_TRACE_PROTOCOL,
                 truncated: true,
                 maxDepth,
-                maxSpans
+                maxSpans,
+                maxCapturedSubtreeSpans
               }
             });
           }
           warnOnce(
             `auto-trace-truncated:${traceFunctionKey}`,
-            `"${traceFunctionKey}" hit an automatic subtree capture limit (maxDepth=${maxDepth}, maxSpans=${maxSpans}); its trace is incomplete. Raise the limits or narrow the subtree with exclude.`
+            `"${traceFunctionKey}" hit an automatic subtree capture limit (maxDepth=${maxDepth}, maxCapturedSubtreeSpans=${maxCapturedSubtreeSpans}, maxSpans=${maxSpans}); its trace is incomplete. Raise the limits, declare the calls you need with node(), or narrow the subtree with exclude.`
           );
         };
+        const rootSpanStack = getSpanStack();
+        const spanBudget = {
+          spansUsed: 1,
+          maxSpans,
+          truncate: () => runWithSpanStack(rootSpanStack, warnTruncated)
+        };
+        const rootSpan = rootSpanStack[rootSpanStack.length - 1];
+        const rootTraceState = rootSpan === void 0 ? void 0 : activeTraceStates.get(rootSpan.traceId);
+        if (rootTraceState !== void 0 && rootTraceState.spanBudget === void 0) {
+          rootTraceState.spanBudget = spanBudget;
+        }
         const spanStackOf = (entry) => entry.spanStack;
         const openChild = (entry, childOptions, inputs, isAsync, invokeFn) => {
           const runInside = () => runWithAutoTraceEntry(
@@ -4375,12 +4427,25 @@ var Bitfab = class {
             return tracedChild(...inputs);
           });
         };
-        const overBudget = (entry) => {
-          if (entry.depth < maxDepth && spansUsed < maxSpans) {
-            return false;
+        const rootTraceFunctionKeyOfEntry = (entry) => {
+          const stack = spanStackOf(entry);
+          const innermost = stack[stack.length - 1];
+          return innermost === void 0 ? traceFunctionKey : rootTraceFunctionKeyOfTrace(innermost.traceId, traceFunctionKey);
+        };
+        const recordsSpan = (entry, spanName, declared) => {
+          const countsTowardCapturedSubtree = !declared && !self.simulationPlan.contentOffNow(
+            rootTraceFunctionKeyOfEntry(entry),
+            spanName
+          );
+          if (entry.depth < maxDepth && spanBudget.spansUsed < maxSpans && (!countsTowardCapturedSubtree || capturedSubtreeCount < maxCapturedSubtreeSpans)) {
+            spanBudget.spansUsed += 1;
+            if (countsTowardCapturedSubtree) {
+              capturedSubtreeCount += 1;
+            }
+            return true;
           }
           runWithSpanStack(spanStackOf(entry), warnTruncated);
-          return true;
+          return false;
         };
         const autoTraceContext = {
           traceFunctionKey,
@@ -4394,13 +4459,13 @@ var Bitfab = class {
             if (nodeConfiguration?.capture === false) {
               return clearAutoTraceNodeConfiguration(invokeFn);
             }
-            if (overBudget(entry)) {
+            const spanName = nodeConfiguration?.name ?? definition.name;
+            if (!recordsSpan(entry, spanName, nodeConfiguration !== void 0)) {
               return invokeWithoutNode();
             }
-            spansUsed += 1;
             const mockOnReplay = nodeConfiguration?.mockOnReplay ?? options.mockOnReplayDefault;
             const childOptions = {
-              name: nodeConfiguration?.name ?? definition.name,
+              name: spanName,
               type: nodeConfiguration?.type ?? "function",
               captureWhen: "nested",
               surface: "opt-out",
@@ -4427,10 +4492,9 @@ var Bitfab = class {
             );
           },
           invokeNestedRoot(nestedName, nestedFunctionName, inputs, invokeFn, entry, link) {
-            if (excluded.has(nestedName) || excluded.has(nestedFunctionName) || overBudget(entry)) {
+            if (excluded.has(nestedName) || excluded.has(nestedFunctionName) || !recordsSpan(entry, nestedName, true)) {
               return invokeFn();
             }
-            spansUsed += 1;
             const childOptions = {
               name: nestedName,
               type: "function",
@@ -4457,6 +4521,12 @@ var Bitfab = class {
       }
       const enclosing = currentAutoTraceEntries();
       if (enclosing.length === 0) {
+        const firstPlanRead = rootIsAsync ? self.simulationPlan.waitForFirstRead() : void 0;
+        if (firstPlanRead !== void 0) {
+          return firstPlanRead.then(
+            () => tracedRoot.apply(this, args)
+          );
+        }
         return tracedRoot.apply(this, args);
       }
       const link = getReplayContext() || inSeedScope() ? void 0 : { traceFunctionKey };
@@ -4503,6 +4573,9 @@ var Bitfab = class {
     return autoTraceRoot;
   }
   applySimulationPlan(payload, submit) {
+    if (!fitsTraceSpanBudget(payload)) {
+      return;
+    }
     this.simulationPlan.send(payload, rootTraceFunctionKeyOf(payload), submit);
   }
   /**
@@ -4537,15 +4610,24 @@ var Bitfab = class {
    * from the environment. Once a non-empty key is found it is cached, so an
    * early resolve that found nothing never poisons a later one.
    */
-  resolveApiKey() {
+  findApiKey(callsKeyFunction) {
     if (this.resolvedApiKey !== void 0) {
       return this.resolvedApiKey;
     }
+    if (typeof this.apiKeyConfig === "function" && !callsKeyFunction) {
+      return void 0;
+    }
     const fromConfig = typeof this.apiKeyConfig === "function" ? this.apiKeyConfig() : this.apiKeyConfig;
     const candidate = fromConfig && fromConfig.trim() !== "" ? fromConfig : readEnv2("BITFAB_API_KEY");
     const key = candidate && candidate.trim() !== "" ? candidate : void 0;
     if (key) {
       this.resolvedApiKey = key;
+    }
+    return key;
+  }
+  resolveApiKey() {
+    const key = this.findApiKey(true);
+    if (key) {
       return key;
     }
     if (this.strict) {
@@ -5165,7 +5247,10 @@ var Bitfab = class {
         self.httpClient.traceCompletion.start(traceId, spanId);
         startedSpan = { traceId, spanId };
         const functionName = fn.name !== "" ? fn.name : void 0;
-        const rootTraceFunctionKey = activeTraceStates.get(traceId)?.traceFunctionKey ?? traceFunctionKey;
+        const rootTraceFunctionKey = rootTraceFunctionKeyOfTrace(
+          traceId,
+          traceFunctionKey
+        );
         const baseSpanParams = {
           traceFunctionKey,
           rootTraceFunctionKey,
@@ -5687,14 +5772,25 @@ var Bitfab = class {
       ...params.testRunId && { testRunId: params.testRunId }
     });
   }
+  contentOffBySimulationPlan(params) {
+    if (params.rootTraceFunctionKey === void 0 || isFrameworkInstrumentation(params.instrumentation)) {
+      return false;
+    }
+    return this.simulationPlan.contentOffNow(
+      params.rootTraceFunctionKey,
+      params.spanName
+    ) || params.parentSpanId !== null && this.simulationPlan.unavailableNow();
+  }
   /**
    * Send a wrapper span from function execution.
    * Internal method to record spans when using withSpan.
    * Queued on the client's span transport; delivery is the transport's job.
    */
   sendWrapperSpan(params) {
-    const serializedInputs = params.captureContent ? serializeValue(params.inputs) : void 0;
-    const serializedResult = params.captureContent ? serializeValue(params.result) : void 0;
+    const contentOff = this.contentOffBySimulationPlan(params);
+    const buildsContent = params.captureContent && !contentOff;
+    const serializedInputs = buildsContent ? serializeValue(params.inputs) : void 0;
+    const serializedResult = buildsContent ? serializeValue(params.result) : void 0;
     const externalSpan = {
       id: params.spanId,
       trace_id: params.traceId,
@@ -5745,7 +5841,8 @@ var Bitfab = class {
         ...params.captureContent && params.contexts && params.contexts.length > 0 && {
           contexts: params.contexts
         },
-        ...params.captureContent && params.prompt !== void 0 && { prompt: params.prompt }
+        ...params.captureContent && params.prompt !== void 0 && { prompt: params.prompt },
+        ...contentOff && { [CONTENT_OFF_KEY]: true }
       }
     };
     if (params.parentSpanId) {
@@ -5911,7 +6008,7 @@ var Bitfab = class {
       await runWithSeedContext({ traceId }, async () => target(...args));
     } finally {
       try {
-        const { flushTraces: flushTraces2 } = await import("./http-HM2SNB6L.js");
+        const { flushTraces: flushTraces2 } = await import("./http-HPTD7HW6.js");
         await flushTraces2(3e4);
       } finally {
         unrecorded = activeTraceStates.delete(traceId);
@@ -5970,7 +6067,7 @@ var Bitfab = class {
         `Function is wrapped with trace function key '${wrappedKey}' but replay was called with '${traceFunctionKey}'. Pass matching keys, or pass the unwrapped function to replay it under the explicit key.`
       );
     }
-    const { replay: doReplay } = await import("./replay-XCXNPWMC.js");
+    const { replay: doReplay } = await import("./replay-FESLQSMD.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -6290,7 +6387,7 @@ async function seedFromRegistry(registry, pipeline, cases, options = {}) {
       sessionId: seedCase.sessionId
     })
   );
-  const { flushTraces: flushTraces2 } = await import("./http-HM2SNB6L.js");
+  const { flushTraces: flushTraces2 } = await import("./http-HPTD7HW6.js");
   await flushTraces2(3e4);
   return { pipeline, traceFunctionKey, traceIds };
 }
@@ -6329,4 +6426,4 @@ export {
   reseedFromRegistry,
   seedFromRegistry
 };
-//# sourceMappingURL=chunk-SV5FYJQ4.js.map
+//# sourceMappingURL=chunk-AEF2SRQC.js.map