@bitfab/sdk 0.34.0 → 0.34.2

package/README.md

@@ -104,22 +104,6 @@ pnpm add bitfab @openai/agents
 
 The `@openai/agents` package is an optional peer dependency - the SDK works fine without it unless you need tracing functionality.
 
-### With an OpenTelemetry Collector
-
-Spans are batched and delivered through a private OpenTelemetry pipeline that
-the SDK owns. Direct delivery to Bitfab is the default and needs no extra
-configuration.
-
-To route traces through an OTel Collector instead, set the receiver URL:
-
-```bash
-BITFAB_OTEL_EXPORTER_ENDPOINT=http://localhost:4318
-```
-
-The protobuf exporter Collector mode uses ships with the SDK and is code-split,
-so it loads only when you set an endpoint. See [OpenTelemetry Transport
-Architecture](https://docs.bitfab.ai/otel-architecture) for the full model.
-
 ## Local Development
 
 ```bash
@@ -277,7 +261,6 @@ When `executeLocally: false`, the SDK:
 
 - `BITFAB_URL`: The base URL for the Bitfab API (used if `serviceUrl` is not provided)
 - `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, etc.: LLM provider API keys (required for local execution)
-- `BITFAB_OTEL_EXPORTER_ENDPOINT`: OTLP/HTTP Collector base URL; unset means batches go directly to Bitfab
 - `BITFAB_OTEL_MAX_REQUEST_BYTES`: request-size target for exports (positive integer up to `3000000`)
 - `BITFAB_OTEL_EXPORT_CONCURRENCY`: concurrent direct requests per export window (`1`-`64`, default `32`)
 

package/dist/{chunk-ESKBRHVG.js → chunk-KQB42J3S.js}

@@ -16,7 +16,7 @@ import {
   toJsonSafe,
   toJsonSafeReport,
   warnOnce
-} from "./chunk-4J36FZ4K.js";
+} from "./chunk-SBQQOFA5.js";
 
 // src/processorPayload.ts
 var SERIALIZATION_DEGRADED_STEP = "serialization_degraded";
@@ -3325,7 +3325,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-QFNYP7EY.js");
+    const { replay: doReplay } = await import("./replay-BNAXIBGN.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -3542,4 +3542,4 @@ export {
   BitfabFunction,
   finalizers
 };
-//# sourceMappingURL=chunk-ESKBRHVG.js.map
+//# sourceMappingURL=chunk-KQB42J3S.js.map

package/dist/{chunk-4J36FZ4K.js → chunk-SBQQOFA5.js}

@@ -208,7 +208,7 @@ var BitfabError = class extends Error {
 };
 
 // src/version.generated.ts
-var __version__ = "0.34.0";
+var __version__ = "0.34.2";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -418,10 +418,8 @@ var OTLP_TRACES_ENDPOINT = "/api/sdk/otel/v1/traces";
 var MAX_EXPORT_REQUEST_BYTES = 3e6;
 var MAX_REQUEST_BYTES_ENV = "BITFAB_OTEL_MAX_REQUEST_BYTES";
 var EXPORT_CONCURRENCY_ENV = "BITFAB_OTEL_EXPORT_CONCURRENCY";
-var COLLECTOR_ENDPOINT_ENV = "BITFAB_OTEL_EXPORTER_ENDPOINT";
 var MAX_QUEUE_SIZE = 8192;
 var DIRECT_MAX_EXPORT_BATCH_SIZE = 512;
-var COLLECTOR_MAX_EXPORT_BATCH_SIZE = 32;
 var DIRECT_MAX_REQUEST_BATCH_SIZE = 8;
 var DEFAULT_EXPORT_CONCURRENCY = 32;
 var MAX_EXPORT_CONCURRENCY = 64;
@@ -568,32 +566,32 @@ function spanToOtlp(span) {
   }
   return result;
 }
-function buildOtlpRequest(first, spans) {
+var textEncoder = typeof TextEncoder === "undefined" ? void 0 : new TextEncoder();
+function byteLength(value) {
+  return textEncoder ? textEncoder.encode(value).length : value.length;
+}
+var SPAN_SEPARATOR_BYTES = 1;
+function encodeSpan(span) {
+  const json = JSON.stringify(spanToOtlp(span));
+  return { json, size: byteLength(json) };
+}
+function requestEnvelope(first) {
   const scope = first.instrumentationScope;
-  return {
-    resourceSpans: [
-      {
-        resource: {
-          attributes: otlpAttributes(
-            first.resource.attributes
-          )
-        },
-        scopeSpans: [
-          {
-            scope: { name: scope.name, version: scope.version ?? "" },
-            spans
-          }
-        ]
-      }
-    ]
-  };
+  const resource = JSON.stringify({
+    attributes: otlpAttributes(
+      first.resource.attributes
+    )
+  });
+  const scopeJson = JSON.stringify({
+    name: scope.name,
+    version: scope.version ?? ""
+  });
+  const head = `{"resourceSpans":[{"resource":${resource},"scopeSpans":[{"scope":${scopeJson},"spans":[`;
+  const tail = "]}]}]}";
+  return { head, tail, size: byteLength(head) + byteLength(tail) };
 }
-function encodedSize(value) {
-  const json = JSON.stringify(value);
-  if (typeof TextEncoder !== "undefined") {
-    return new TextEncoder().encode(json).length;
-  }
-  return json.length;
+function encodeRequest(envelope, spans) {
+  return envelope.head + spans.map((span) => span.json).join(",") + envelope.tail;
 }
 function delay(ms) {
   return new Promise((resolve) => {
@@ -671,57 +669,55 @@ var BitfabSpanExporter = class {
       return true;
     }
     let encoded;
+    let envelope;
     try {
-      encoded = spans.map(spanToOtlp);
+      encoded = spans.map(encodeSpan);
+      envelope = requestEnvelope(spans[0]);
     } catch (error) {
       logError("failed to encode an OpenTelemetry span batch", error);
       return false;
     }
-    const first = spans[0];
-    const batches = this.buildRequestBatches(first, encoded);
+    const batches = this.buildRequestBatches(envelope, encoded);
     const results = await mapWithConcurrency(
       batches,
       this.exportConcurrency,
-      (batch) => this.send(first, batch)
+      (batch) => this.send(envelope, batch)
     );
     return results.every(Boolean);
   }
-  buildRequestBatches(first, spans) {
+  buildRequestBatches(envelope, spans) {
     const batches = [];
     let current = [];
+    let size = envelope.size;
     for (const span of spans) {
-      if (current.length >= this.maxRequestBatchSize) {
-        batches.push(current);
+      const addition = span.size + (current.length > 0 ? SPAN_SEPARATOR_BYTES : 0);
+      if (current.length > 0 && (current.length >= this.maxRequestBatchSize || size + addition > this.maxRequestBytes)) {
+        batches.push({ spans: current, size });
         current = [];
+        size = envelope.size;
       }
-      const candidate = [...current, span];
-      if (current.length > 0 && encodedSize(buildOtlpRequest(first, candidate)) > this.maxRequestBytes) {
-        batches.push(current);
-        current = [span];
-      } else {
-        current = candidate;
-      }
+      current.push(span);
+      size += span.size + (current.length > 1 ? SPAN_SEPARATOR_BYTES : 0);
     }
     if (current.length > 0) {
-      batches.push(current);
+      batches.push({ spans: current, size });
     }
     return batches;
   }
-  async send(first, spans) {
-    const payload = buildOtlpRequest(first, spans);
-    if (encodedSize(payload) > this.maxRequestBytes) {
+  async send(envelope, batch) {
+    if (batch.size > this.maxRequestBytes) {
       logError(
         "a single OpenTelemetry span exceeded the configured request-size target and could not be exported"
       );
       return false;
     }
     try {
-      await this.sendWithRetries(payload);
+      await this.sendWithRetries(encodeRequest(envelope, batch.spans));
       return true;
     } catch (error) {
       if (error instanceof OtlpPayloadTooLargeError) {
         logError(
-          spans.length === 1 ? "a single OpenTelemetry span exceeded the ingestion request limit and could not be exported" : "an OpenTelemetry span batch exceeded the ingestion request limit and could not be exported"
+          batch.spans.length === 1 ? "a single OpenTelemetry span exceeded the ingestion request limit and could not be exported" : "an OpenTelemetry span batch exceeded the ingestion request limit and could not be exported"
         );
         return false;
       }
@@ -745,12 +741,12 @@ var BitfabSpanExporter = class {
    * the server does not yet understand. The fix is a client-supplied
    * idempotency key that ingestion dedupes on.
    */
-  async sendWithRetries(payload) {
+  async sendWithRetries(body) {
     for (let attempt = 0; attempt < MAX_SEND_ATTEMPTS; attempt += 1) {
       try {
         const response = await this.directSender(
           OTLP_TRACES_ENDPOINT,
-          payload,
+          body,
           EXPORT_TIMEOUT_MILLIS
         );
         const partialSuccess = asRecord(response?.partialSuccess);
@@ -781,115 +777,6 @@ var BitfabSpanExporter = class {
   async forceFlush() {
   }
 };
-var CollectorSpanExporter = class {
-  constructor(endpoint, apiKey, maxRequestBytes) {
-    this.endpoint = endpoint;
-    this.apiKey = apiKey;
-    this.maxRequestBytes = maxRequestBytes;
-  }
-  /**
-   * Loaded through a dynamic import rather than a top-level one so bundlers
-   * code-split it: Collector delivery is opt-in, and a consumer who never sets
-   * an endpoint should not pay for the exporter in their initial bundle. It is
-   * a hard dependency, so this cannot fail for want of the package.
-   */
-  loadExporterModule() {
-    if (!this.pendingModule) {
-      this.pendingModule = import("@opentelemetry/exporter-trace-otlp-proto");
-    }
-    return this.pendingModule;
-  }
-  export(spans, resultCallback) {
-    void this.exportAsync(spans).then(
-      (succeeded) => {
-        resultCallback({
-          code: succeeded ? ExportResultCode.SUCCESS : ExportResultCode.FAILED
-        });
-      },
-      (error) => {
-        resultCallback({ code: ExportResultCode.FAILED, error });
-      }
-    );
-  }
-  async exportAsync(spans) {
-    if (spans.length === 0) {
-      return true;
-    }
-    let delegate;
-    try {
-      delegate = await this.resolveDelegate();
-    } catch (error) {
-      logError("failed to build the OTLP Collector exporter", error);
-      return false;
-    }
-    const results = await Promise.all(
-      this.partition(spans).map(
-        (batch) => new Promise((resolve) => {
-          try {
-            delegate.export(batch, (result) => {
-              resolve(result.code === ExportResultCode.SUCCESS);
-            });
-          } catch (error) {
-            logError("Collector export threw", error);
-            resolve(false);
-          }
-        })
-      )
-    );
-    return results.every(Boolean);
-  }
-  /**
-   * Partition by the encoded JSON size of each carrier rather than its encoded
-   * protobuf size. Protobuf is strictly smaller than the equivalent JSON for
-   * these payloads, so the JSON figure is a conservative bound that keeps every
-   * request under the target without pulling `@opentelemetry/otlp-transformer`
-   * into the dependency set purely to measure bytes.
-   */
-  partition(spans) {
-    const batches = [];
-    let current = [];
-    let currentSize = 0;
-    for (const span of spans) {
-      const size = encodedSize(spanToOtlp(span));
-      if (current.length > 0 && currentSize + size > this.maxRequestBytes) {
-        batches.push(current);
-        current = [];
-        currentSize = 0;
-      }
-      current.push(span);
-      currentSize += size;
-    }
-    if (current.length > 0) {
-      batches.push(current);
-    }
-    return batches;
-  }
-  async resolveDelegate() {
-    const apiKey = this.apiKey() ?? "";
-    if (this.delegate && this.delegateApiKey === apiKey) {
-      return this.delegate;
-    }
-    const { OTLPTraceExporter } = await this.loadExporterModule();
-    const previous = this.delegate;
-    this.delegate = new OTLPTraceExporter({
-      url: this.endpoint,
-      headers: { Authorization: `Bearer ${apiKey}` },
-      timeoutMillis: EXPORT_TIMEOUT_MILLIS
-    });
-    this.delegateApiKey = apiKey;
-    if (previous) {
-      void previous.shutdown().catch(() => {
-      });
-    }
-    return this.delegate;
-  }
-  async shutdown() {
-    await this.delegate?.shutdown();
-  }
-  async forceFlush() {
-    await this.delegate?.forceFlush?.();
-  }
-};
 var DeliveryTrackingExporter = class {
   constructor(exporter) {
     this.exporter = exporter;
@@ -932,27 +819,22 @@ var DeliveryTrackingExporter = class {
 var OtelBatchTransport = class {
   constructor(options) {
     this.closed = false;
-    const collectorEndpoint = options.collectorEndpoint;
     const maxRequestBytes = options.maxRequestBytes ?? MAX_EXPORT_REQUEST_BYTES;
     const maxRequestBatchSize = options.maxRequestBatchSize ?? DIRECT_MAX_REQUEST_BATCH_SIZE;
     if (maxRequestBatchSize <= 0) {
       throw new BitfabError("maxRequestBatchSize must be a positive integer");
     }
     this.deliveryTracker = new DeliveryTrackingExporter(
-      collectorEndpoint === void 0 ? new BitfabSpanExporter(
+      new BitfabSpanExporter(
         options.directSender,
         maxRequestBytes,
         maxRequestBatchSize,
         options.exportConcurrency ?? DEFAULT_EXPORT_CONCURRENCY
-      ) : new CollectorSpanExporter(
-        normalizeCollectorEndpoint(collectorEndpoint),
-        options.apiKey,
-        maxRequestBytes
       )
     );
     this.processor = new BatchSpanProcessor(this.deliveryTracker, {
       maxQueueSize: options.maxQueueSize ?? MAX_QUEUE_SIZE,
-      maxExportBatchSize: options.maxExportBatchSize ?? (collectorEndpoint === void 0 ? DIRECT_MAX_EXPORT_BATCH_SIZE : COLLECTOR_MAX_EXPORT_BATCH_SIZE),
+      maxExportBatchSize: options.maxExportBatchSize ?? DIRECT_MAX_EXPORT_BATCH_SIZE,
       scheduledDelayMillis: SCHEDULE_DELAY_MILLIS,
       exportTimeoutMillis: options.exportTimeoutMillis ?? EXPORT_TIMEOUT_MILLIS
     });
@@ -1037,10 +919,6 @@ var OtelBatchTransport = class {
     return flushed && shutdownCompleted;
   }
 };
-function normalizeCollectorEndpoint(endpoint) {
-  const trimmed = endpoint.replace(/\/+$/, "");
-  return trimmed.endsWith("/v1/traces") ? trimmed : `${trimmed}/v1/traces`;
-}
 function endSpan(span, endTime) {
   span.end(endTime);
 }
@@ -1077,7 +955,6 @@ function hasError(payload) {
 function createOtelTransport(options) {
   return new OtelBatchTransport({
     ...options,
-    collectorEndpoint: readEnv(COLLECTOR_ENDPOINT_ENV) || void 0,
     exportConcurrency: readBoundedIntEnv(
       EXPORT_CONCURRENCY_ENV,
       MAX_EXPORT_CONCURRENCY,
@@ -1225,8 +1102,7 @@ var HttpClient = class {
     }
     if (!this.traceTransport) {
       this.traceTransport = createTraceTransport({
-        apiKey: () => this.resolveApiKey(),
-        directSender: (endpoint, payload, timeoutMs) => this.request(endpoint, payload, {
+        directSender: (endpoint, body, timeoutMs) => this.sendEncoded(endpoint, body, {
           timeout: timeoutMs
         })
       });
@@ -1296,11 +1172,6 @@ var HttpClient = class {
    * @throws {BitfabError} If the request fails
    */
   async request(endpoint, payload, options) {
-    const url = `${this.serviceUrl}${endpoint}`;
-    const timeout = options?.timeout ?? this.timeout;
-    const method = options?.method ?? "POST";
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
     const { body, dropped } = serializePayloadBody(payload);
     if (dropped.length > 0) {
       try {
@@ -1310,6 +1181,19 @@ var HttpClient = class {
       } catch {
       }
     }
+    return this.sendEncoded(endpoint, body, options);
+  }
+  /**
+   * POST an already-encoded body. The span transport encodes its own batches,
+   * so routing them back through {@link HttpClient.request} would encode the
+   * same data twice.
+   */
+  async sendEncoded(endpoint, body, options) {
+    const url = `${this.serviceUrl}${endpoint}`;
+    const timeout = options?.timeout ?? this.timeout;
+    const method = options?.method ?? "POST";
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
     try {
       const response = await fetch(url, {
         method,
@@ -2296,4 +2180,4 @@ export {
   reportReplayProgress,
   replay
 };
-//# sourceMappingURL=chunk-4J36FZ4K.js.map
+//# sourceMappingURL=chunk-SBQQOFA5.js.map