bitfab 0.52.5 → 0.52.6

package/dist/{http-UQT6QVBC.js → http-ER2NMEKI.js}

@@ -6,7 +6,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-3D7FNJ5R.js";
+} from "./chunk-GJKU7VWG.js";
 export {
   BitfabError,
   HttpClient,
@@ -16,4 +16,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-UQT6QVBC.js.map
+//# sourceMappingURL=http-ER2NMEKI.js.map

package/dist/{http-Q6UEKZRF.js → http-MGES3ZVX.js}

@@ -6,7 +6,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-CAE7HE4C.js";
+} from "./chunk-NXC6NYIY.js";
 import "./chunk-H6LZRFMN.js";
 export {
   BitfabError,
@@ -17,4 +17,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-Q6UEKZRF.js.map
+//# sourceMappingURL=http-MGES3ZVX.js.map

package/dist/index.cjs

@@ -51,7 +51,7 @@ var __version__, __packageName__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.52.5";
+    __version__ = "0.52.6";
     __packageName__ = "bitfab";
   }
 });
@@ -4207,19 +4207,18 @@ init_asyncStorage();
 // src/autoTrace.ts
 init_asyncStorage();
 var autoTraceGlobal = globalThis;
-var autoTraceState = autoTraceGlobal.__bitfabAutoTraceStateV3 ?? {
+var autoTraceState = autoTraceGlobal.__bitfabAutoTraceStateV4 ?? {
   storage: null,
   browserScope: void 0,
   capturePolicies: /* @__PURE__ */ new WeakMap(),
   activeRoots: 0
 };
-autoTraceGlobal.__bitfabAutoTraceStateV3 = autoTraceState;
+autoTraceGlobal.__bitfabAutoTraceStateV4 = autoTraceState;
 function initializeAutoTraceStorage() {
   autoTraceState.storage ?? (autoTraceState.storage = createAsyncLocalStorage());
 }
-function runWithAutoTraceContext(context, fn, depth = 0) {
+function runWithAutoTraceScope(scope, fn) {
   initializeAutoTraceStorage();
-  const scope = { context, depth };
   if (autoTraceState.storage) {
     return autoTraceState.storage.run(scope, fn);
   }
@@ -4231,41 +4230,65 @@ function runWithAutoTraceContext(context, fn, depth = 0) {
     autoTraceState.browserScope = previous;
   }
 }
+function currentAutoTraceEntries() {
+  return currentAutoTraceScope()?.entries ?? [];
+}
+function replaceEntry(entries, previous, updated) {
+  return entries.map((entry) => entry === previous ? updated : entry);
+}
+function runWithAutoTraceEntry(previous, updated, fn) {
+  const result = runWithAutoTraceScope(
+    { entries: replaceEntry(currentAutoTraceEntries(), previous, updated) },
+    fn
+  );
+  if (isAutoTraceAsyncGenerator(result)) {
+    return wrapAutoTraceEntryAsyncGenerator(previous, updated, result);
+  }
+  return result;
+}
+function wrapAutoTraceEntryAsyncGenerator(previous, updated, source) {
+  const step = (method, value) => runWithAutoTraceScope(
+    { entries: replaceEntry(currentAutoTraceEntries(), previous, updated) },
+    () => source[method](value)
+  );
+  const wrapped = {
+    next: (value) => step("next", value),
+    return: (value) => step("return", value),
+    throw: (error) => step("throw", error),
+    [Symbol.asyncIterator]: () => wrapped
+  };
+  return wrapped;
+}
+function clearAutoTraceNodeConfiguration(fn) {
+  return runWithAutoTraceScope({ entries: currentAutoTraceEntries() }, fn);
+}
 function runWithAutoTraceNodeConfiguration(nodeConfiguration, fn) {
   const scope = currentAutoTraceScope();
-  if (!scope) {
+  if (!scope || scope.entries.length === 0) {
     return fn();
   }
-  const configuredScope = { ...scope, nodeConfiguration };
-  let result;
-  if (autoTraceState.storage) {
-    result = autoTraceState.storage.run(configuredScope, fn);
-  } else {
-    const previous = autoTraceState.browserScope;
-    autoTraceState.browserScope = configuredScope;
-    try {
-      result = fn();
-    } finally {
-      autoTraceState.browserScope = previous;
-    }
-  }
+  const result = runWithAutoTraceScope({ ...scope, nodeConfiguration }, fn);
   if (isAutoTraceAsyncGenerator(result)) {
     return wrapAutoTraceNodeAsyncGenerator(nodeConfiguration, result);
   }
   return result;
 }
-function runWithAutoTraceRootContext(context, fn) {
+function runWithAutoTraceRootContext(context, spanStack, fn) {
   autoTraceState.activeRoots += 1;
+  const entries = [
+    ...currentAutoTraceEntries(),
+    { context, depth: 0, spanStack }
+  ];
   let result;
   try {
-    result = runWithAutoTraceContext(context, fn);
+    result = runWithAutoTraceScope({ entries }, fn);
   } catch (error) {
     autoTraceState.activeRoots -= 1;
     throw error;
   }
   if (isAutoTraceAsyncGenerator(result)) {
     autoTraceState.activeRoots -= 1;
-    return wrapAutoTraceAsyncGenerator(context, result);
+    return wrapAutoTraceAsyncGenerator(context, spanStack, result);
   }
   if (result instanceof Promise) {
     return result.finally(() => {
@@ -4275,6 +4298,15 @@ function runWithAutoTraceRootContext(context, fn) {
   autoTraceState.activeRoots -= 1;
   return result;
 }
+function invokeThroughAutoTraceEntries(entries, step, fn) {
+  let run = fn;
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    const next = run;
+    run = () => step(entry, next);
+  }
+  return run();
+}
 function isAutoTraceAsyncGenerator(value) {
   if (value === null || typeof value !== "object") {
     return false;
@@ -4282,8 +4314,8 @@ function isAutoTraceAsyncGenerator(value) {
   const candidate = value;
   return typeof candidate.next === "function" && typeof candidate.return === "function" && typeof candidate.throw === "function" && typeof candidate[Symbol.asyncIterator] === "function";
 }
-function wrapAutoTraceAsyncGenerator(context, source) {
-  const step = (method, value) => runWithAutoTraceRootContext(context, () => source[method](value));
+function wrapAutoTraceAsyncGenerator(context, spanStack, source) {
+  const step = (method, value) => runWithAutoTraceRootContext(context, spanStack, () => source[method](value));
   const wrapped = {
     next: (value) => step("next", value),
     return: (value) => step("return", value),
@@ -4309,7 +4341,7 @@ function __bitfabAutoTraceActive() {
   if (autoTraceState.activeRoots === 0) {
     return false;
   }
-  return currentAutoTraceScope() !== void 0;
+  return currentAutoTraceEntries().length > 0;
 }
 function currentAutoTraceScope() {
   initializeAutoTraceStorage();
@@ -7062,11 +7094,15 @@ var Bitfab = class {
       type: options.type ?? "custom",
       surface: "opt-out"
     };
-    const tracedRoot = this.withSpan(
+    const rootName = options.name ?? name;
+    const buildTracedRoot = (spanOptions) => this.withSpan(
       traceFunctionKey,
-      rootOptions,
+      spanOptions,
       function(...args) {
-        const capturePolicy = getAutoTraceCapturePolicy(self, traceFunctionKey);
+        const capturePolicy = getAutoTraceCapturePolicy(
+          self,
+          traceFunctionKey
+        );
         self.refreshAutoTraceCapturePolicy(traceFunctionKey);
         let spansUsed = 0;
         let truncated = false;
@@ -7087,19 +7123,54 @@ var Bitfab = class {
             `"${traceFunctionKey}" hit an automatic subtree capture limit (maxDepth=${maxDepth}, maxSpans=${maxSpans}); its trace is incomplete. Raise the limits or narrow the subtree with exclude.`
           );
         };
+        const spanStackOf = (entry) => entry.spanStack;
+        const openChild = (entry, childOptions, inputs, isAsync, invokeFn) => {
+          const runInside = () => runWithAutoTraceEntry(
+            entry,
+            {
+              context: autoTraceContext,
+              depth: entry.depth + 1,
+              spanStack: getSpanStack()
+            },
+            invokeFn
+          );
+          return runWithSpanStack(spanStackOf(entry), () => {
+            if (isAsync) {
+              const tracedAsyncChild = self.withSpan(
+                traceFunctionKey,
+                childOptions,
+                async (..._inputs) => await runInside()
+              );
+              return tracedAsyncChild(...inputs);
+            }
+            const tracedChild = self.withSpan(
+              traceFunctionKey,
+              childOptions,
+              (..._inputs) => runInside()
+            );
+            return tracedChild(...inputs);
+          });
+        };
+        const overBudget = (entry) => {
+          if (entry.depth < maxDepth && spansUsed < maxSpans) {
+            return false;
+          }
+          runWithSpanStack(spanStackOf(entry), warnTruncated);
+          return true;
+        };
         const autoTraceContext = {
-          invoke(definition, inputs, invokeFn, depth, nodeConfiguration) {
+          traceFunctionKey,
+          invoke(definition, inputs, invokeFn, entry, nodeConfiguration) {
             const nameParts = definition.name.split(".");
             const simpleName = nameParts[nameParts.length - 1];
-            const invokeWithoutNode = () => nodeConfiguration === void 0 ? invokeFn() : runWithAutoTraceContext(autoTraceContext, invokeFn, depth);
+            const invokeWithoutNode = () => nodeConfiguration === void 0 ? invokeFn() : clearAutoTraceNodeConfiguration(invokeFn);
             if (excluded.has(definition.name) || simpleName !== void 0 && excluded.has(simpleName) || nodeConfiguration === void 0 && definition.wrapper === true && !includeWrappers) {
               return invokeWithoutNode();
             }
             if (nodeConfiguration?.capture === false) {
-              return runWithAutoTraceContext(autoTraceContext, invokeFn, depth);
+              return clearAutoTraceNodeConfiguration(invokeFn);
             }
-            if (depth >= maxDepth || spansUsed >= maxSpans) {
-              warnTruncated();
+            if (overBudget(entry)) {
               return invokeWithoutNode();
             }
             spansUsed += 1;
@@ -7122,34 +7193,81 @@ var Bitfab = class {
                 finalize: nodeConfiguration.finalize
               }
             };
-            const invokeWithAutoTraceContext = () => runWithAutoTraceContext(autoTraceContext, invokeFn, depth + 1);
-            if (definition.async === true) {
-              const tracedAsyncChild = self.withSpan(
-                traceFunctionKey,
-                childOptions,
-                async (..._inputs) => await invokeWithAutoTraceContext()
-              );
-              return tracedAsyncChild(...inputs);
-            }
-            const tracedChild = self.withSpan(
-              traceFunctionKey,
+            return openChild(
+              entry,
               childOptions,
-              (..._inputs) => invokeWithAutoTraceContext()
+              inputs,
+              definition.async === true,
+              invokeFn
             );
-            return tracedChild(...inputs);
+          },
+          invokeNestedRoot(nestedName, nestedFunctionName, inputs, invokeFn, entry, link) {
+            if (excluded.has(nestedName) || excluded.has(nestedFunctionName) || overBudget(entry)) {
+              return invokeFn();
+            }
+            spansUsed += 1;
+            const childOptions = {
+              name: nestedName,
+              type: "function",
+              captureWhen: "nested",
+              surface: "opt-out",
+              captureContent: true,
+              ...link !== void 0 && { nestedTrace: link }
+            };
+            return openChild(entry, childOptions, inputs, false, invokeFn);
           }
         };
         return runWithAutoTraceRootContext(
           autoTraceContext,
+          getSpanStack(),
           () => fn.apply(this, args)
         );
       }
     );
+    const tracedRoot = buildTracedRoot(rootOptions);
     const autoTraceRoot = function(...args) {
       if (!self.shouldRecord()) {
         return fn.apply(this, args);
       }
-      return tracedRoot.apply(this, args);
+      const enclosing = currentAutoTraceEntries();
+      if (enclosing.length === 0) {
+        return tracedRoot.apply(this, args);
+      }
+      const link = getReplayContext() || inSeedScope() ? void 0 : { traceFunctionKey };
+      return invokeThroughAutoTraceEntries(
+        enclosing,
+        (entry, next) => entry.context.invokeNestedRoot(
+          rootName,
+          name,
+          args,
+          next,
+          entry,
+          link
+        ),
+        () => {
+          if (link === void 0) {
+            return fn.apply(this, args);
+          }
+          const innermost = enclosing[enclosing.length - 1];
+          const innermostNow = currentAutoTraceEntries().find(
+            (entry) => entry.context === innermost.context
+          ) ?? innermost;
+          const innermostStack = innermostNow.spanStack;
+          const copy = innermostStack[innermostStack.length - 1];
+          const detachedRoot = buildTracedRoot({
+            ...rootOptions,
+            ...copy !== void 0 && {
+              enclosingTrace: {
+                traceId: copy.traceId,
+                spanId: copy.spanId,
+                traceFunctionKey: innermost.context.traceFunctionKey,
+                link
+              }
+            }
+          });
+          return runWithSpanStack([], () => detachedRoot.apply(this, args));
+        }
+      );
     };
     Object.defineProperty(autoTraceRoot, "_bitfabTraceFunctionKey", {
       value: traceFunctionKey
@@ -7738,6 +7856,10 @@ var Bitfab = class {
         const spanId = randomUuid();
         const parentSpanId = parentContext?.spanId ?? null;
         const isRootSpan = parentSpanId === null;
+        if (options.enclosingTrace !== void 0) {
+          options.enclosingTrace.link.traceId = traceId;
+          options.enclosingTrace.link.rootSpanId = spanId;
+        }
         const requestedSurface = options.surface ?? DEFAULT_SURFACE;
         const surface = resolveSurface(requestedSurface, parentContext?.surface);
         assertSurfacesCompatible(
@@ -7787,7 +7909,9 @@ var Bitfab = class {
           spanType: options.type ?? "custom",
           functionId: options.functionId,
           captureContent: options.captureContent ?? true,
-          autoTraceDefinition: options.autoTraceDefinition
+          autoTraceDefinition: options.autoTraceDefinition,
+          nestedTrace: options.nestedTrace,
+          enclosingTrace: options.enclosingTrace
         };
         const sendSpan = async (params) => {
           const replayCtx = getReplayContext();
@@ -8297,6 +8421,16 @@ var Bitfab = class {
           function_line: params.autoTraceDefinition.line,
           function_column: params.autoTraceDefinition.column
         },
+        ...params.nestedTrace?.traceId !== void 0 && {
+          nested_trace_id: params.nestedTrace.traceId,
+          nested_trace_function_key: params.nestedTrace.traceFunctionKey,
+          nested_root_span_id: params.nestedTrace.rootSpanId
+        },
+        ...params.enclosingTrace !== void 0 && {
+          enclosing_trace_id: params.enclosingTrace.traceId,
+          enclosing_trace_function_key: params.enclosingTrace.traceFunctionKey,
+          enclosing_span_id: params.enclosingTrace.spanId
+        },
         ...serializedInputs !== void 0 && {
           input: serializedInputs.json,
           ...serializedInputs.meta !== void 0 && {