@deeptracer/core 0.6.2 → 0.6.4

package/README.md

@@ -74,7 +74,7 @@ const result = await logger.startSpan("fetch-user", async (span) => {
 })
 
 // Flush before shutdown
-logger.destroy()
+await logger.destroy()
 ```
 
 ## Configuration
@@ -90,7 +90,7 @@ const logger = createLogger({
 
   // Optional
   batchSize: 50,                 // Logs to buffer before sending (default: 50)
-  flushIntervalMs: 5000,         // Max ms between flushes (default: 5000)
+  flushIntervalMs: 5000,         // Max ms between flushes (default: 5000 — 200 in serverless environments, auto-detected via VERCEL or AWS_LAMBDA_FUNCTION_NAME)
   debug: false,                  // Mirror logs to console (default: false)
 })
 ```
@@ -104,7 +104,7 @@ const logger = createLogger({
 | `service` | `string` | `"server"` | Service name (e.g., `"api"`, `"worker"`, `"web"`) |
 | `environment` | `string` | `NODE_ENV` / `"production"` | Deployment environment |
 | `batchSize` | `number` | `50` | Number of log entries to buffer before flushing |
-| `flushIntervalMs` | `number` | `5000` | Milliseconds between automatic flushes |
+| `flushIntervalMs` | `number` | `5000 (200 in serverless environments — auto-detected via VERCEL or AWS_LAMBDA_FUNCTION_NAME)` | Milliseconds between automatic flushes |
 | `debug` | `boolean` | `false` | When `true`, all log calls also print to the console |
 
 ## API Reference
@@ -364,7 +364,7 @@ logger.llmUsage({
 
 #### `forRequest(request)`
 
-Create a request-scoped logger that extracts distributed trace context from incoming HTTP headers. The returned logger attaches `trace_id`, `span_id`, `request_id`, and `vercel_id` to all subsequent logs, errors, and spans.
+Create a request-scoped logger that extracts distributed trace context from incoming HTTP headers. The returned logger attaches `trace_id`, `span_id`, `request_id`, and `vercel_id` to all subsequent logs, errors, and spans. Child loggers share the same transport as the root logger — logs from children are flushed together with the parent.
 
 ```ts
 const reqLogger = logger.forRequest(request: Request): Logger
@@ -396,7 +396,7 @@ app.get("/api/users", async (c) => {
 
 #### `withContext(name)`
 
-Create a new logger that includes a context name in every log entry. Useful for distinguishing logs from different modules or subsystems.
+Create a new logger that includes a context name in every log entry. Useful for distinguishing logs from different modules or subsystems. Child loggers share the same transport as the root logger — logs from children are flushed together with the parent.
 
 ```ts
 const dbLogger = logger.withContext("database")
@@ -411,12 +411,12 @@ authLogger.info("Token refreshed")            // context: "auth"
 
 ### Lifecycle
 
-#### `flush()`
+#### `flush(): Promise<void>`
 
 Immediately send all buffered log entries. Call this before your process exits or when you want to ensure logs are delivered.
 
 ```ts
-logger.flush()
+await logger.flush()
 ```
 
 #### `destroy()`
@@ -424,12 +424,14 @@ logger.flush()
 Stop the internal batch timer and flush any remaining log entries. Call this during graceful shutdown.
 
 ```ts
-process.on("SIGTERM", () => {
-  logger.destroy()
+process.on("SIGTERM", async () => {
+  await logger.destroy()
   process.exit(0)
 })
 ```
 
+> **Note on child loggers:** Calling `destroy()` on a child logger (returned by `withContext()` or `forRequest()`) flushes the shared buffer and drains in-flight requests, but does **not** stop the root logger's batch timer. Only calling `destroy()` on the root logger stops the timer.
+
 ## Type Reference
 
 ### LoggerConfig
@@ -441,7 +443,7 @@ interface LoggerConfig {
   endpoint: string
   apiKey: string
   batchSize?: number          // default: 50
-  flushIntervalMs?: number    // default: 5000
+  flushIntervalMs?: number    // default: 5000 (200 in serverless environments — auto-detected via VERCEL or AWS_LAMBDA_FUNCTION_NAME)
   debug?: boolean             // default: false
 }
 ```
@@ -571,6 +573,25 @@ Log entries are buffered and sent in batches to reduce network overhead:
 
 Error reports (`captureError`) and span data (`startSpan`, `startInactiveSpan`) are **not batched** -- they are sent immediately.
 
+### Serverless environments (Vercel, AWS Lambda)
+
+In serverless functions, the execution context may freeze immediately after the HTTP response is sent, before the automatic flush timer fires. DeepTracer handles this in two ways:
+
+- **Auto-detected interval**: When `VERCEL` or `AWS_LAMBDA_FUNCTION_NAME` is set, the default `flushIntervalMs` drops to 200ms.
+- **Explicit flush**: Call `await logger.flush()` before returning a response to guarantee delivery.
+
+For **`@deeptracer/nextjs`** users, `withRouteHandler` works with any handler function including third-party ones (Auth.js, Better Auth, Stripe webhooks) — just wrap the exported handler. Only use `waitUntil` if the library doesn't export individual `GET`/`POST` functions:
+
+```ts
+import { waitUntil } from "@vercel/functions"
+
+export const POST = async (req: Request) => {
+  const response = await thirdPartyHandler(req)
+  waitUntil(logger.flush()) // extends function lifetime, non-blocking
+  return response
+}
+```
+
 ## Transport
 
 The transport layer sends data to four DeepTracer ingestion endpoints:
@@ -587,7 +608,7 @@ All requests include:
 - `Content-Type: application/json` header
 - `service` and `environment` fields in the JSON body
 
-If a request fails, a warning is logged to the console. The SDK does not retry failed requests -- it is designed to be non-blocking and never crash your application.
+If a request fails with a network error or a 5xx response, the SDK retries up to **3 times** with exponential backoff (1s → 2s → 4s, +20% jitter). 4xx errors (bad auth, invalid payload) are not retried. After all retries are exhausted, a single warning is logged to the console — subsequent failures for the same endpoint are suppressed to avoid console spam. The SDK never throws on transport errors.
 
 ## Monorepo
 

package/dist/{chunk-DHFWC5TL.js → chunk-QAJHHVX4.js}

@@ -1,5 +1,5 @@
 // src/version.ts
-var SDK_VERSION = "0.6.2";
+var SDK_VERSION = "0.6.4";
 var SDK_NAME = "core";
 
 // src/transport.ts
@@ -172,7 +172,8 @@ var Batcher = class {
   constructor(config, onFlush) {
     this.onFlush = onFlush;
     this.batchSize = config.batchSize ?? 50;
-    this.flushIntervalMs = config.flushIntervalMs ?? 5e3;
+    const isServerless = typeof process !== "undefined" && !!(process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME);
+    this.flushIntervalMs = config.flushIntervalMs ?? (isServerless ? 200 : 5e3);
     this.startTimer();
   }
   buffer = [];
@@ -265,30 +266,34 @@ var _originalConsole = {
 var Logger = class _Logger {
   batcher;
   transport;
+  isRoot;
   effectiveLevel;
   contextName;
   config;
   state;
   requestMeta;
-  constructor(config, contextName, requestMeta, state) {
+  constructor(config, contextName, requestMeta, state, sharedBatcher, sharedTransport) {
     this.config = config;
     this.contextName = contextName;
     this.requestMeta = requestMeta;
     this.state = state ?? createLoggerState(config.maxBreadcrumbs ?? 20);
-    const hasKey = !!config.apiKey;
-    const hasEndpoint = !!config.endpoint;
-    if (!hasKey && !hasEndpoint) {
-      _originalConsole.warn(
-        "[@deeptracer/core] No API key or endpoint configured. Running in local-only mode (logging methods work, but events are not sent). Set DEEPTRACER_KEY and DEEPTRACER_ENDPOINT to enable."
-      );
-    } else if (!hasKey) {
-      _originalConsole.warn("[@deeptracer/core] No `apiKey` provided. Events will not be sent.");
-    } else if (!hasEndpoint) {
-      _originalConsole.warn("[@deeptracer/core] No `endpoint` provided. Events will not be sent.");
+    this.isRoot = !sharedBatcher;
+    if (this.isRoot) {
+      const hasKey = !!config.apiKey;
+      const hasEndpoint = !!config.endpoint;
+      if (!hasKey && !hasEndpoint) {
+        _originalConsole.warn(
+          "[@deeptracer/core] No API key or endpoint configured. Running in local-only mode (logging methods work, but events are not sent). Set DEEPTRACER_KEY and DEEPTRACER_ENDPOINT to enable."
+        );
+      } else if (!hasKey) {
+        _originalConsole.warn("[@deeptracer/core] No `apiKey` provided. Events will not be sent.");
+      } else if (!hasEndpoint) {
+        _originalConsole.warn("[@deeptracer/core] No `endpoint` provided. Events will not be sent.");
+      }
     }
     this.effectiveLevel = LOG_LEVEL_VALUES[config.level ?? (config.environment === "production" ? "info" : "debug")];
-    this.transport = new Transport(config);
-    this.batcher = new Batcher(
+    this.transport = sharedTransport ?? new Transport(config);
+    this.batcher = sharedBatcher ?? new Batcher(
       { batchSize: config.batchSize, flushIntervalMs: config.flushIntervalMs },
       (entries) => {
         this.transport.sendLogs(entries);
@@ -476,7 +481,14 @@ var Logger = class _Logger {
   // ---------------------------------------------------------------------------
   /** Create a context-scoped logger. All logs include the context name. Gets an independent copy of state. */
   withContext(name) {
-    return new _Logger(this.config, name, this.requestMeta, cloneState(this.state));
+    return new _Logger(
+      this.config,
+      name,
+      this.requestMeta,
+      cloneState(this.state),
+      this.batcher,
+      this.transport
+    );
   }
   /** Create a request-scoped logger that extracts trace context from headers. Gets an independent copy of state. */
   forRequest(request) {
@@ -503,7 +515,9 @@ var Logger = class _Logger {
         request_id: requestId || (vercelId ? vercelId.split("::").pop() : void 0),
         vercel_id: vercelId
       },
-      cloneState(this.state)
+      cloneState(this.state),
+      this.batcher,
+      this.transport
     );
   }
   // ---------------------------------------------------------------------------
@@ -638,11 +652,25 @@ var Logger = class _Logger {
         this.transport.sendTrace(hookResult.data);
       },
       startSpan: (childOp, fn) => {
-        const childLogger = new _Logger(this.config, this.contextName, childMeta, this.state);
+        const childLogger = new _Logger(
+          this.config,
+          this.contextName,
+          childMeta,
+          this.state,
+          this.batcher,
+          this.transport
+        );
         return childLogger.startSpan(childOp, fn);
       },
       startInactiveSpan: (childOp) => {
-        const childLogger = new _Logger(this.config, this.contextName, childMeta, this.state);
+        const childLogger = new _Logger(
+          this.config,
+          this.contextName,
+          childMeta,
+          this.state,
+          this.batcher,
+          this.transport
+        );
         return childLogger.startInactiveSpan(childOp);
       },
       getHeaders: () => {
@@ -667,9 +695,19 @@ var Logger = class _Logger {
   // ---------------------------------------------------------------------------
   // Lifecycle
   // ---------------------------------------------------------------------------
-  /** Immediately flush all batched log entries. */
-  flush() {
+  /**
+   * Flush all batched log entries and wait for in-flight HTTP requests to complete.
+   *
+   * @returns Promise that resolves when all pending logs have been sent.
+   *
+   * @example
+   * ```ts
+   * await logger.flush() // ensure logs are sent before response is returned
+   * ```
+   */
+  async flush() {
     this.batcher.flush();
+    await this.transport.drain();
   }
   /**
    * Stop the batch timer, flush remaining logs, and wait for in-flight requests.
@@ -684,7 +722,11 @@ var Logger = class _Logger {
    * ```
    */
   async destroy(timeoutMs) {
-    await this.batcher.destroy();
+    if (this.isRoot) {
+      await this.batcher.destroy();
+    } else {
+      this.batcher.flush();
+    }
     await this.transport.drain(timeoutMs);
   }
 };

package/dist/index.cjs

@@ -33,7 +33,8 @@ var Batcher = class {
   constructor(config, onFlush) {
     this.onFlush = onFlush;
     this.batchSize = config.batchSize ?? 50;
-    this.flushIntervalMs = config.flushIntervalMs ?? 5e3;
+    const isServerless = typeof process !== "undefined" && !!(process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME);
+    this.flushIntervalMs = config.flushIntervalMs ?? (isServerless ? 200 : 5e3);
     this.startTimer();
   }
   buffer = [];
@@ -63,7 +64,7 @@ var Batcher = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.6.2";
+var SDK_VERSION = "0.6.4";
 var SDK_NAME = "core";
 
 // src/transport.ts
@@ -295,30 +296,34 @@ var _originalConsole = {
 var Logger = class _Logger {
   batcher;
   transport;
+  isRoot;
   effectiveLevel;
   contextName;
   config;
   state;
   requestMeta;
-  constructor(config, contextName, requestMeta, state) {
+  constructor(config, contextName, requestMeta, state, sharedBatcher, sharedTransport) {
     this.config = config;
     this.contextName = contextName;
     this.requestMeta = requestMeta;
     this.state = state ?? createLoggerState(config.maxBreadcrumbs ?? 20);
-    const hasKey = !!config.apiKey;
-    const hasEndpoint = !!config.endpoint;
-    if (!hasKey && !hasEndpoint) {
-      _originalConsole.warn(
-        "[@deeptracer/core] No API key or endpoint configured. Running in local-only mode (logging methods work, but events are not sent). Set DEEPTRACER_KEY and DEEPTRACER_ENDPOINT to enable."
-      );
-    } else if (!hasKey) {
-      _originalConsole.warn("[@deeptracer/core] No `apiKey` provided. Events will not be sent.");
-    } else if (!hasEndpoint) {
-      _originalConsole.warn("[@deeptracer/core] No `endpoint` provided. Events will not be sent.");
+    this.isRoot = !sharedBatcher;
+    if (this.isRoot) {
+      const hasKey = !!config.apiKey;
+      const hasEndpoint = !!config.endpoint;
+      if (!hasKey && !hasEndpoint) {
+        _originalConsole.warn(
+          "[@deeptracer/core] No API key or endpoint configured. Running in local-only mode (logging methods work, but events are not sent). Set DEEPTRACER_KEY and DEEPTRACER_ENDPOINT to enable."
+        );
+      } else if (!hasKey) {
+        _originalConsole.warn("[@deeptracer/core] No `apiKey` provided. Events will not be sent.");
+      } else if (!hasEndpoint) {
+        _originalConsole.warn("[@deeptracer/core] No `endpoint` provided. Events will not be sent.");
+      }
     }
     this.effectiveLevel = LOG_LEVEL_VALUES[config.level ?? (config.environment === "production" ? "info" : "debug")];
-    this.transport = new Transport(config);
-    this.batcher = new Batcher(
+    this.transport = sharedTransport ?? new Transport(config);
+    this.batcher = sharedBatcher ?? new Batcher(
       { batchSize: config.batchSize, flushIntervalMs: config.flushIntervalMs },
       (entries) => {
         this.transport.sendLogs(entries);
@@ -506,7 +511,14 @@ var Logger = class _Logger {
   // ---------------------------------------------------------------------------
   /** Create a context-scoped logger. All logs include the context name. Gets an independent copy of state. */
   withContext(name) {
-    return new _Logger(this.config, name, this.requestMeta, cloneState(this.state));
+    return new _Logger(
+      this.config,
+      name,
+      this.requestMeta,
+      cloneState(this.state),
+      this.batcher,
+      this.transport
+    );
   }
   /** Create a request-scoped logger that extracts trace context from headers. Gets an independent copy of state. */
   forRequest(request) {
@@ -533,7 +545,9 @@ var Logger = class _Logger {
         request_id: requestId || (vercelId ? vercelId.split("::").pop() : void 0),
         vercel_id: vercelId
       },
-      cloneState(this.state)
+      cloneState(this.state),
+      this.batcher,
+      this.transport
     );
   }
   // ---------------------------------------------------------------------------
@@ -668,11 +682,25 @@ var Logger = class _Logger {
         this.transport.sendTrace(hookResult.data);
       },
       startSpan: (childOp, fn) => {
-        const childLogger = new _Logger(this.config, this.contextName, childMeta, this.state);
+        const childLogger = new _Logger(
+          this.config,
+          this.contextName,
+          childMeta,
+          this.state,
+          this.batcher,
+          this.transport
+        );
         return childLogger.startSpan(childOp, fn);
       },
       startInactiveSpan: (childOp) => {
-        const childLogger = new _Logger(this.config, this.contextName, childMeta, this.state);
+        const childLogger = new _Logger(
+          this.config,
+          this.contextName,
+          childMeta,
+          this.state,
+          this.batcher,
+          this.transport
+        );
         return childLogger.startInactiveSpan(childOp);
       },
       getHeaders: () => {
@@ -697,9 +725,19 @@ var Logger = class _Logger {
   // ---------------------------------------------------------------------------
   // Lifecycle
   // ---------------------------------------------------------------------------
-  /** Immediately flush all batched log entries. */
-  flush() {
+  /**
+   * Flush all batched log entries and wait for in-flight HTTP requests to complete.
+   *
+   * @returns Promise that resolves when all pending logs have been sent.
+   *
+   * @example
+   * ```ts
+   * await logger.flush() // ensure logs are sent before response is returned
+   * ```
+   */
+  async flush() {
     this.batcher.flush();
+    await this.transport.drain();
   }
   /**
    * Stop the batch timer, flush remaining logs, and wait for in-flight requests.
@@ -714,7 +752,11 @@ var Logger = class _Logger {
    * ```
    */
   async destroy(timeoutMs) {
-    await this.batcher.destroy();
+    if (this.isRoot) {
+      await this.batcher.destroy();
+    } else {
+      this.batcher.flush();
+    }
     await this.transport.drain(timeoutMs);
   }
 };
@@ -771,7 +813,7 @@ var noopLogger = {
   startInactiveSpan: () => NOOP_INACTIVE_SPAN,
   wrap: (_operation, fn) => fn,
   // Lifecycle — resolve immediately
-  flush: noop,
+  flush: () => Promise.resolve(),
   destroy: () => Promise.resolve()
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { L as Logger } from './logger-CzZg2_vM.cjs';
-export { B as BeforeSendEvent, a as Breadcrumb, E as ErrorReport, I as InactiveSpan, b as LLMUsageReport, c as LogEntry, d as LogLevel, e as LoggerConfig, M as MiddlewareOptions, S as Span, f as SpanData, U as User, g as createLogger } from './logger-CzZg2_vM.cjs';
+import { L as Logger } from './logger-DyJENLNA.cjs';
+export { B as BeforeSendEvent, a as Breadcrumb, E as ErrorReport, I as InactiveSpan, b as LLMUsageReport, c as LogEntry, d as LogLevel, e as LoggerConfig, M as MiddlewareOptions, S as Span, f as SpanData, U as User, g as createLogger } from './logger-DyJENLNA.cjs';
 
 /**
  * A Logger-compatible object where every method is a silent no-op.
@@ -18,7 +18,7 @@ export { B as BeforeSendEvent, a as Breadcrumb, E as ErrorReport, I as InactiveS
 declare const noopLogger: Logger;
 
 /** SDK version. Update on each release. */
-declare const SDK_VERSION = "0.6.2";
+declare const SDK_VERSION = "0.6.4";
 declare const SDK_NAME = "core";
 
 export { Logger, SDK_NAME, SDK_VERSION, noopLogger };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { L as Logger } from './logger-CzZg2_vM.js';
-export { B as BeforeSendEvent, a as Breadcrumb, E as ErrorReport, I as InactiveSpan, b as LLMUsageReport, c as LogEntry, d as LogLevel, e as LoggerConfig, M as MiddlewareOptions, S as Span, f as SpanData, U as User, g as createLogger } from './logger-CzZg2_vM.js';
+import { L as Logger } from './logger-DyJENLNA.js';
+export { B as BeforeSendEvent, a as Breadcrumb, E as ErrorReport, I as InactiveSpan, b as LLMUsageReport, c as LogEntry, d as LogLevel, e as LoggerConfig, M as MiddlewareOptions, S as Span, f as SpanData, U as User, g as createLogger } from './logger-DyJENLNA.js';
 
 /**
  * A Logger-compatible object where every method is a silent no-op.
@@ -18,7 +18,7 @@ export { B as BeforeSendEvent, a as Breadcrumb, E as ErrorReport, I as InactiveS
 declare const noopLogger: Logger;
 
 /** SDK version. Update on each release. */
-declare const SDK_VERSION = "0.6.2";
+declare const SDK_VERSION = "0.6.4";
 declare const SDK_NAME = "core";
 
 export { Logger, SDK_NAME, SDK_VERSION, noopLogger };

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   SDK_NAME,
   SDK_VERSION,
   createLogger
-} from "./chunk-DHFWC5TL.js";
+} from "./chunk-QAJHHVX4.js";
 
 // src/noop-logger.ts
 var NOOP_INACTIVE_SPAN = {
@@ -54,7 +54,7 @@ var noopLogger = {
   startInactiveSpan: () => NOOP_INACTIVE_SPAN,
   wrap: (_operation, fn) => fn,
   // Lifecycle — resolve immediately
-  flush: noop,
+  flush: () => Promise.resolve(),
   destroy: () => Promise.resolve()
 };
 export {

package/dist/internal.cjs

@@ -33,7 +33,8 @@ var Batcher = class {
   constructor(config, onFlush) {
     this.onFlush = onFlush;
     this.batchSize = config.batchSize ?? 50;
-    this.flushIntervalMs = config.flushIntervalMs ?? 5e3;
+    const isServerless = typeof process !== "undefined" && !!(process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME);
+    this.flushIntervalMs = config.flushIntervalMs ?? (isServerless ? 200 : 5e3);
     this.startTimer();
   }
   buffer = [];
@@ -63,7 +64,7 @@ var Batcher = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.6.2";
+var SDK_VERSION = "0.6.4";
 var SDK_NAME = "core";
 
 // src/transport.ts
@@ -295,30 +296,34 @@ var _originalConsole = {
 var Logger = class _Logger {
   batcher;
   transport;
+  isRoot;
   effectiveLevel;
   contextName;
   config;
   state;
   requestMeta;
-  constructor(config, contextName, requestMeta, state) {
+  constructor(config, contextName, requestMeta, state, sharedBatcher, sharedTransport) {
     this.config = config;
     this.contextName = contextName;
     this.requestMeta = requestMeta;
     this.state = state ?? createLoggerState(config.maxBreadcrumbs ?? 20);
-    const hasKey = !!config.apiKey;
-    const hasEndpoint = !!config.endpoint;
-    if (!hasKey && !hasEndpoint) {
-      _originalConsole.warn(
-        "[@deeptracer/core] No API key or endpoint configured. Running in local-only mode (logging methods work, but events are not sent). Set DEEPTRACER_KEY and DEEPTRACER_ENDPOINT to enable."
-      );
-    } else if (!hasKey) {
-      _originalConsole.warn("[@deeptracer/core] No `apiKey` provided. Events will not be sent.");
-    } else if (!hasEndpoint) {
-      _originalConsole.warn("[@deeptracer/core] No `endpoint` provided. Events will not be sent.");
+    this.isRoot = !sharedBatcher;
+    if (this.isRoot) {
+      const hasKey = !!config.apiKey;
+      const hasEndpoint = !!config.endpoint;
+      if (!hasKey && !hasEndpoint) {
+        _originalConsole.warn(
+          "[@deeptracer/core] No API key or endpoint configured. Running in local-only mode (logging methods work, but events are not sent). Set DEEPTRACER_KEY and DEEPTRACER_ENDPOINT to enable."
+        );
+      } else if (!hasKey) {
+        _originalConsole.warn("[@deeptracer/core] No `apiKey` provided. Events will not be sent.");
+      } else if (!hasEndpoint) {
+        _originalConsole.warn("[@deeptracer/core] No `endpoint` provided. Events will not be sent.");
+      }
     }
     this.effectiveLevel = LOG_LEVEL_VALUES[config.level ?? (config.environment === "production" ? "info" : "debug")];
-    this.transport = new Transport(config);
-    this.batcher = new Batcher(
+    this.transport = sharedTransport ?? new Transport(config);
+    this.batcher = sharedBatcher ?? new Batcher(
       { batchSize: config.batchSize, flushIntervalMs: config.flushIntervalMs },
       (entries) => {
         this.transport.sendLogs(entries);
@@ -506,7 +511,14 @@ var Logger = class _Logger {
   // ---------------------------------------------------------------------------
   /** Create a context-scoped logger. All logs include the context name. Gets an independent copy of state. */
   withContext(name) {
-    return new _Logger(this.config, name, this.requestMeta, cloneState(this.state));
+    return new _Logger(
+      this.config,
+      name,
+      this.requestMeta,
+      cloneState(this.state),
+      this.batcher,
+      this.transport
+    );
   }
   /** Create a request-scoped logger that extracts trace context from headers. Gets an independent copy of state. */
   forRequest(request) {
@@ -533,7 +545,9 @@ var Logger = class _Logger {
         request_id: requestId || (vercelId ? vercelId.split("::").pop() : void 0),
         vercel_id: vercelId
       },
-      cloneState(this.state)
+      cloneState(this.state),
+      this.batcher,
+      this.transport
     );
   }
   // ---------------------------------------------------------------------------
@@ -668,11 +682,25 @@ var Logger = class _Logger {
         this.transport.sendTrace(hookResult.data);
       },
       startSpan: (childOp, fn) => {
-        const childLogger = new _Logger(this.config, this.contextName, childMeta, this.state);
+        const childLogger = new _Logger(
+          this.config,
+          this.contextName,
+          childMeta,
+          this.state,
+          this.batcher,
+          this.transport
+        );
         return childLogger.startSpan(childOp, fn);
       },
       startInactiveSpan: (childOp) => {
-        const childLogger = new _Logger(this.config, this.contextName, childMeta, this.state);
+        const childLogger = new _Logger(
+          this.config,
+          this.contextName,
+          childMeta,
+          this.state,
+          this.batcher,
+          this.transport
+        );
         return childLogger.startInactiveSpan(childOp);
       },
       getHeaders: () => {
@@ -697,9 +725,19 @@ var Logger = class _Logger {
   // ---------------------------------------------------------------------------
   // Lifecycle
   // ---------------------------------------------------------------------------
-  /** Immediately flush all batched log entries. */
-  flush() {
+  /**
+   * Flush all batched log entries and wait for in-flight HTTP requests to complete.
+   *
+   * @returns Promise that resolves when all pending logs have been sent.
+   *
+   * @example
+   * ```ts
+   * await logger.flush() // ensure logs are sent before response is returned
+   * ```
+   */
+  async flush() {
     this.batcher.flush();
+    await this.transport.drain();
   }
   /**
    * Stop the batch timer, flush remaining logs, and wait for in-flight requests.
@@ -714,7 +752,11 @@ var Logger = class _Logger {
    * ```
    */
   async destroy(timeoutMs) {
-    await this.batcher.destroy();
+    if (this.isRoot) {
+      await this.batcher.destroy();
+    } else {
+      this.batcher.flush();
+    }
     await this.transport.drain(timeoutMs);
   }
 };

package/dist/internal.d.cts

@@ -1,72 +1,4 @@
-import { e as LoggerConfig, c as LogEntry, E as ErrorReport, f as SpanData } from './logger-CzZg2_vM.cjs';
-export { L as Logger, h as LoggerState, M as MiddlewareOptions, _ as _originalConsole, p as parseTraceparent } from './logger-CzZg2_vM.cjs';
-
-/**
- * HTTP transport for sending data to the DeepTracer ingestion API.
- *
- * Features:
- * - Automatic retry with exponential backoff (3 retries, 1s/2s/4s + jitter)
- * - Only retries on network errors and 5xx (not 4xx client errors)
- * - SDK version header on every request (`x-deeptracer-sdk: core/0.3.0`)
- * - In-flight request tracking for graceful shutdown via `drain()`
- * - Silent no-op when no API key or endpoint is configured (no retries, no console noise)
- * - Warn-once per failure type — first failure for each send type (logs, error, trace)
- *   logs a warning, subsequent identical failures are silently dropped
- */
-declare class Transport {
-    private config;
-    private inFlightRequests;
-    /**
-     * When true, all send methods become silent no-ops.
-     * Set automatically when no auth key or no endpoint is configured.
-     * This prevents pointless network requests and console noise during
-     * local development without API keys.
-     */
-    private readonly disabled;
-    /**
-     * Tracks which send types (logs, error, trace, LLM usage) have already
-     * logged a failure warning. After the first failure for a given type,
-     * subsequent failures are silently dropped to prevent console spam
-     * (e.g., when the ingestion endpoint is unreachable during development).
-     */
-    private warnedLabels;
-    constructor(config: Pick<LoggerConfig, "endpoint" | "apiKey" | "service" | "environment">);
-    private get authKey();
-    /**
-     * Send a request with automatic retry and exponential backoff.
-     * Retries up to `maxRetries` times on network errors and 5xx responses.
-     * Does NOT retry on 4xx (client errors — bad payload, auth failure, etc.).
-     *
-     * After the first total failure for a given label, subsequent failures
-     * are silently dropped (no more console warnings).
-     */
-    private sendWithRetry;
-    /** Add +/- 20% jitter to a delay to prevent thundering herd. */
-    private jitter;
-    private sleep;
-    /** Track an in-flight request and remove it when done. */
-    private track;
-    sendLogs(logs: LogEntry[]): Promise<void>;
-    sendError(error: ErrorReport): Promise<void>;
-    sendTrace(span: SpanData): Promise<void>;
-    sendLLMUsage(report: {
-        model: string;
-        provider: string;
-        operation: string;
-        input_tokens: number;
-        output_tokens: number;
-        cost_usd: number;
-        latency_ms: number;
-        metadata?: Record<string, unknown>;
-    }): Promise<void>;
-    /**
-     * Wait for all in-flight requests to complete, with a timeout.
-     * Used by `logger.destroy()` to ensure data is sent before process exit.
-     *
-     * @param timeoutMs - Maximum time to wait (default: 2000ms)
-     */
-    drain(timeoutMs?: number): Promise<void>;
-}
+export { L as Logger, e as LoggerConfig, h as LoggerState, M as MiddlewareOptions, T as Transport, _ as _originalConsole, p as parseTraceparent } from './logger-DyJENLNA.cjs';
 
 /**
  * Parse console.log/info/warn/error arguments into a structured `{ message, metadata }` pair.
@@ -82,4 +14,4 @@ declare function parseConsoleArgs(args: unknown[]): {
     metadata?: Record<string, unknown>;
 };
 
-export { LoggerConfig, Transport, parseConsoleArgs };
+export { parseConsoleArgs };

package/dist/internal.d.ts

@@ -1,72 +1,4 @@
-import { e as LoggerConfig, c as LogEntry, E as ErrorReport, f as SpanData } from './logger-CzZg2_vM.js';
-export { L as Logger, h as LoggerState, M as MiddlewareOptions, _ as _originalConsole, p as parseTraceparent } from './logger-CzZg2_vM.js';
-
-/**
- * HTTP transport for sending data to the DeepTracer ingestion API.
- *
- * Features:
- * - Automatic retry with exponential backoff (3 retries, 1s/2s/4s + jitter)
- * - Only retries on network errors and 5xx (not 4xx client errors)
- * - SDK version header on every request (`x-deeptracer-sdk: core/0.3.0`)
- * - In-flight request tracking for graceful shutdown via `drain()`
- * - Silent no-op when no API key or endpoint is configured (no retries, no console noise)
- * - Warn-once per failure type — first failure for each send type (logs, error, trace)
- *   logs a warning, subsequent identical failures are silently dropped
- */
-declare class Transport {
-    private config;
-    private inFlightRequests;
-    /**
-     * When true, all send methods become silent no-ops.
-     * Set automatically when no auth key or no endpoint is configured.
-     * This prevents pointless network requests and console noise during
-     * local development without API keys.
-     */
-    private readonly disabled;
-    /**
-     * Tracks which send types (logs, error, trace, LLM usage) have already
-     * logged a failure warning. After the first failure for a given type,
-     * subsequent failures are silently dropped to prevent console spam
-     * (e.g., when the ingestion endpoint is unreachable during development).
-     */
-    private warnedLabels;
-    constructor(config: Pick<LoggerConfig, "endpoint" | "apiKey" | "service" | "environment">);
-    private get authKey();
-    /**
-     * Send a request with automatic retry and exponential backoff.
-     * Retries up to `maxRetries` times on network errors and 5xx responses.
-     * Does NOT retry on 4xx (client errors — bad payload, auth failure, etc.).
-     *
-     * After the first total failure for a given label, subsequent failures
-     * are silently dropped (no more console warnings).
-     */
-    private sendWithRetry;
-    /** Add +/- 20% jitter to a delay to prevent thundering herd. */
-    private jitter;
-    private sleep;
-    /** Track an in-flight request and remove it when done. */
-    private track;
-    sendLogs(logs: LogEntry[]): Promise<void>;
-    sendError(error: ErrorReport): Promise<void>;
-    sendTrace(span: SpanData): Promise<void>;
-    sendLLMUsage(report: {
-        model: string;
-        provider: string;
-        operation: string;
-        input_tokens: number;
-        output_tokens: number;
-        cost_usd: number;
-        latency_ms: number;
-        metadata?: Record<string, unknown>;
-    }): Promise<void>;
-    /**
-     * Wait for all in-flight requests to complete, with a timeout.
-     * Used by `logger.destroy()` to ensure data is sent before process exit.
-     *
-     * @param timeoutMs - Maximum time to wait (default: 2000ms)
-     */
-    drain(timeoutMs?: number): Promise<void>;
-}
+export { L as Logger, e as LoggerConfig, h as LoggerState, M as MiddlewareOptions, T as Transport, _ as _originalConsole, p as parseTraceparent } from './logger-DyJENLNA.js';
 
 /**
  * Parse console.log/info/warn/error arguments into a structured `{ message, metadata }` pair.
@@ -82,4 +14,4 @@ declare function parseConsoleArgs(args: unknown[]): {
     metadata?: Record<string, unknown>;
 };
 
-export { LoggerConfig, Transport, parseConsoleArgs };
+export { parseConsoleArgs };

package/dist/internal.js

@@ -3,7 +3,7 @@ import {
   Transport,
   _originalConsole,
   parseTraceparent
-} from "./chunk-DHFWC5TL.js";
+} from "./chunk-QAJHHVX4.js";
 
 // src/internal.ts
 function safeStringify(value) {

package/dist/{logger-CzZg2_vM.d.cts → logger-DyJENLNA.d.cts}

@@ -209,6 +209,89 @@ type BeforeSendEvent = {
     data: LLMUsageReport;
 };
 
+declare class Batcher {
+    private onFlush;
+    private buffer;
+    private timer;
+    private batchSize;
+    private flushIntervalMs;
+    constructor(config: {
+        batchSize?: number;
+        flushIntervalMs?: number;
+    }, onFlush: (entries: LogEntry[]) => void);
+    add(entry: LogEntry): void;
+    flush(): void;
+    private startTimer;
+    destroy(): Promise<void>;
+}
+
+/**
+ * HTTP transport for sending data to the DeepTracer ingestion API.
+ *
+ * Features:
+ * - Automatic retry with exponential backoff (3 retries, 1s/2s/4s + jitter)
+ * - Only retries on network errors and 5xx (not 4xx client errors)
+ * - SDK version header on every request (`x-deeptracer-sdk: core/0.3.0`)
+ * - In-flight request tracking for graceful shutdown via `drain()`
+ * - Silent no-op when no API key or endpoint is configured (no retries, no console noise)
+ * - Warn-once per failure type — first failure for each send type (logs, error, trace)
+ *   logs a warning, subsequent identical failures are silently dropped
+ */
+declare class Transport {
+    private config;
+    private inFlightRequests;
+    /**
+     * When true, all send methods become silent no-ops.
+     * Set automatically when no auth key or no endpoint is configured.
+     * This prevents pointless network requests and console noise during
+     * local development without API keys.
+     */
+    private readonly disabled;
+    /**
+     * Tracks which send types (logs, error, trace, LLM usage) have already
+     * logged a failure warning. After the first failure for a given type,
+     * subsequent failures are silently dropped to prevent console spam
+     * (e.g., when the ingestion endpoint is unreachable during development).
+     */
+    private warnedLabels;
+    constructor(config: Pick<LoggerConfig, "endpoint" | "apiKey" | "service" | "environment">);
+    private get authKey();
+    /**
+     * Send a request with automatic retry and exponential backoff.
+     * Retries up to `maxRetries` times on network errors and 5xx responses.
+     * Does NOT retry on 4xx (client errors — bad payload, auth failure, etc.).
+     *
+     * After the first total failure for a given label, subsequent failures
+     * are silently dropped (no more console warnings).
+     */
+    private sendWithRetry;
+    /** Add +/- 20% jitter to a delay to prevent thundering herd. */
+    private jitter;
+    private sleep;
+    /** Track an in-flight request and remove it when done. */
+    private track;
+    sendLogs(logs: LogEntry[]): Promise<void>;
+    sendError(error: ErrorReport): Promise<void>;
+    sendTrace(span: SpanData): Promise<void>;
+    sendLLMUsage(report: {
+        model: string;
+        provider: string;
+        operation: string;
+        input_tokens: number;
+        output_tokens: number;
+        cost_usd: number;
+        latency_ms: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * Wait for all in-flight requests to complete, with a timeout.
+     * Used by `logger.destroy()` to ensure data is sent before process exit.
+     *
+     * @param timeoutMs - Maximum time to wait (default: 2000ms)
+     */
+    drain(timeoutMs?: number): Promise<void>;
+}
+
 /**
  * Mutable state for a Logger instance.
  * The root Logger creates this; `withContext()` and `forRequest()` clone it
@@ -276,6 +359,7 @@ declare const _originalConsole: {
 declare class Logger {
     private batcher;
     private transport;
+    private readonly isRoot;
     private effectiveLevel;
     protected contextName?: string;
     protected config: LoggerConfig;
@@ -291,7 +375,7 @@ declare class Logger {
         span_id?: string;
         request_id?: string;
         vercel_id?: string;
-    }, state?: LoggerState);
+    }, state?: LoggerState, sharedBatcher?: Batcher, sharedTransport?: Transport);
     /**
      * Set the current user context. Attached to all subsequent logs, errors, spans, and LLM reports.
      * Only affects this logger instance — child loggers created via `withContext()` or `forRequest()`
@@ -378,8 +462,17 @@ declare class Logger {
     startInactiveSpan(operation: string): InactiveSpan;
     /** Wrap a function with automatic tracing and error capture. */
     wrap<TArgs extends unknown[], TReturn>(operation: string, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-    /** Immediately flush all batched log entries. */
-    flush(): void;
+    /**
+     * Flush all batched log entries and wait for in-flight HTTP requests to complete.
+     *
+     * @returns Promise that resolves when all pending logs have been sent.
+     *
+     * @example
+     * ```ts
+     * await logger.flush() // ensure logs are sent before response is returned
+     * ```
+     */
+    flush(): Promise<void>;
     /**
      * Stop the batch timer, flush remaining logs, and wait for in-flight requests.
      *
@@ -397,4 +490,4 @@ declare class Logger {
 /** Create a new DeepTracer logger instance. */
 declare function createLogger(config: LoggerConfig): Logger;
 
-export { type BeforeSendEvent as B, type ErrorReport as E, type InactiveSpan as I, Logger as L, type MiddlewareOptions as M, type Span as S, type User as U, _originalConsole as _, type Breadcrumb as a, type LLMUsageReport as b, type LogEntry as c, type LogLevel as d, type LoggerConfig as e, type SpanData as f, createLogger as g, type LoggerState as h, parseTraceparent as p };
+export { type BeforeSendEvent as B, type ErrorReport as E, type InactiveSpan as I, Logger as L, type MiddlewareOptions as M, type Span as S, Transport as T, type User as U, _originalConsole as _, type Breadcrumb as a, type LLMUsageReport as b, type LogEntry as c, type LogLevel as d, type LoggerConfig as e, type SpanData as f, createLogger as g, type LoggerState as h, parseTraceparent as p };

package/dist/{logger-CzZg2_vM.d.ts → logger-DyJENLNA.d.ts}

@@ -209,6 +209,89 @@ type BeforeSendEvent = {
     data: LLMUsageReport;
 };
 
+declare class Batcher {
+    private onFlush;
+    private buffer;
+    private timer;
+    private batchSize;
+    private flushIntervalMs;
+    constructor(config: {
+        batchSize?: number;
+        flushIntervalMs?: number;
+    }, onFlush: (entries: LogEntry[]) => void);
+    add(entry: LogEntry): void;
+    flush(): void;
+    private startTimer;
+    destroy(): Promise<void>;
+}
+
+/**
+ * HTTP transport for sending data to the DeepTracer ingestion API.
+ *
+ * Features:
+ * - Automatic retry with exponential backoff (3 retries, 1s/2s/4s + jitter)
+ * - Only retries on network errors and 5xx (not 4xx client errors)
+ * - SDK version header on every request (`x-deeptracer-sdk: core/0.3.0`)
+ * - In-flight request tracking for graceful shutdown via `drain()`
+ * - Silent no-op when no API key or endpoint is configured (no retries, no console noise)
+ * - Warn-once per failure type — first failure for each send type (logs, error, trace)
+ *   logs a warning, subsequent identical failures are silently dropped
+ */
+declare class Transport {
+    private config;
+    private inFlightRequests;
+    /**
+     * When true, all send methods become silent no-ops.
+     * Set automatically when no auth key or no endpoint is configured.
+     * This prevents pointless network requests and console noise during
+     * local development without API keys.
+     */
+    private readonly disabled;
+    /**
+     * Tracks which send types (logs, error, trace, LLM usage) have already
+     * logged a failure warning. After the first failure for a given type,
+     * subsequent failures are silently dropped to prevent console spam
+     * (e.g., when the ingestion endpoint is unreachable during development).
+     */
+    private warnedLabels;
+    constructor(config: Pick<LoggerConfig, "endpoint" | "apiKey" | "service" | "environment">);
+    private get authKey();
+    /**
+     * Send a request with automatic retry and exponential backoff.
+     * Retries up to `maxRetries` times on network errors and 5xx responses.
+     * Does NOT retry on 4xx (client errors — bad payload, auth failure, etc.).
+     *
+     * After the first total failure for a given label, subsequent failures
+     * are silently dropped (no more console warnings).
+     */
+    private sendWithRetry;
+    /** Add +/- 20% jitter to a delay to prevent thundering herd. */
+    private jitter;
+    private sleep;
+    /** Track an in-flight request and remove it when done. */
+    private track;
+    sendLogs(logs: LogEntry[]): Promise<void>;
+    sendError(error: ErrorReport): Promise<void>;
+    sendTrace(span: SpanData): Promise<void>;
+    sendLLMUsage(report: {
+        model: string;
+        provider: string;
+        operation: string;
+        input_tokens: number;
+        output_tokens: number;
+        cost_usd: number;
+        latency_ms: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * Wait for all in-flight requests to complete, with a timeout.
+     * Used by `logger.destroy()` to ensure data is sent before process exit.
+     *
+     * @param timeoutMs - Maximum time to wait (default: 2000ms)
+     */
+    drain(timeoutMs?: number): Promise<void>;
+}
+
 /**
  * Mutable state for a Logger instance.
  * The root Logger creates this; `withContext()` and `forRequest()` clone it
@@ -276,6 +359,7 @@ declare const _originalConsole: {
 declare class Logger {
     private batcher;
     private transport;
+    private readonly isRoot;
     private effectiveLevel;
     protected contextName?: string;
     protected config: LoggerConfig;
@@ -291,7 +375,7 @@ declare class Logger {
         span_id?: string;
         request_id?: string;
         vercel_id?: string;
-    }, state?: LoggerState);
+    }, state?: LoggerState, sharedBatcher?: Batcher, sharedTransport?: Transport);
     /**
      * Set the current user context. Attached to all subsequent logs, errors, spans, and LLM reports.
      * Only affects this logger instance — child loggers created via `withContext()` or `forRequest()`
@@ -378,8 +462,17 @@ declare class Logger {
     startInactiveSpan(operation: string): InactiveSpan;
     /** Wrap a function with automatic tracing and error capture. */
     wrap<TArgs extends unknown[], TReturn>(operation: string, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-    /** Immediately flush all batched log entries. */
-    flush(): void;
+    /**
+     * Flush all batched log entries and wait for in-flight HTTP requests to complete.
+     *
+     * @returns Promise that resolves when all pending logs have been sent.
+     *
+     * @example
+     * ```ts
+     * await logger.flush() // ensure logs are sent before response is returned
+     * ```
+     */
+    flush(): Promise<void>;
     /**
      * Stop the batch timer, flush remaining logs, and wait for in-flight requests.
      *
@@ -397,4 +490,4 @@ declare class Logger {
 /** Create a new DeepTracer logger instance. */
 declare function createLogger(config: LoggerConfig): Logger;
 
-export { type BeforeSendEvent as B, type ErrorReport as E, type InactiveSpan as I, Logger as L, type MiddlewareOptions as M, type Span as S, type User as U, _originalConsole as _, type Breadcrumb as a, type LLMUsageReport as b, type LogEntry as c, type LogLevel as d, type LoggerConfig as e, type SpanData as f, createLogger as g, type LoggerState as h, parseTraceparent as p };
+export { type BeforeSendEvent as B, type ErrorReport as E, type InactiveSpan as I, Logger as L, type MiddlewareOptions as M, type Span as S, Transport as T, type User as U, _originalConsole as _, type Breadcrumb as a, type LLMUsageReport as b, type LogEntry as c, type LogLevel as d, type LoggerConfig as e, type SpanData as f, createLogger as g, type LoggerState as h, parseTraceparent as p };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeptracer/core",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Core SDK for DeepTracer — Logger class, types, transport, batcher, tracing",
   "type": "module",
   "main": "dist/index.cjs",