@bitfab/sdk 0.34.0 → 0.34.2

package/dist/index.cjs

@@ -42,7 +42,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.34.0";
+    __version__ = "0.34.2";
   }
 });
 
@@ -420,32 +420,30 @@ function spanToOtlp(span) {
   }
   return result;
 }
-function buildOtlpRequest(first, spans) {
+function byteLength(value) {
+  return textEncoder ? textEncoder.encode(value).length : value.length;
+}
+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) => {
@@ -495,10 +493,6 @@ function isRetryable(error) {
   }
   return RETRYABLE_STATUSES.has(status) || status >= 500;
 }
-function normalizeCollectorEndpoint(endpoint) {
-  const trimmed = endpoint.replace(/\/+$/, "");
-  return trimmed.endsWith("/v1/traces") ? trimmed : `${trimmed}/v1/traces`;
-}
 function endSpan(span, endTime) {
   span.end(endTime);
 }
@@ -535,7 +529,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,
@@ -570,7 +563,7 @@ function shutdownOtelTransports(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
     (transport, remaining) => transport.shutdown(remaining)
   );
 }
-var import_api, import_core, import_resources, import_sdk_trace_base, OPERATION_ATTRIBUTE, PAYLOAD_ATTRIBUTE, OTLP_TRACES_ENDPOINT, MAX_EXPORT_REQUEST_BYTES, MAX_REQUEST_BYTES_ENV, EXPORT_CONCURRENCY_ENV, COLLECTOR_ENDPOINT_ENV, MAX_QUEUE_SIZE, DIRECT_MAX_EXPORT_BATCH_SIZE, COLLECTOR_MAX_EXPORT_BATCH_SIZE, DIRECT_MAX_REQUEST_BATCH_SIZE, DEFAULT_EXPORT_CONCURRENCY, MAX_EXPORT_CONCURRENCY, SCHEDULE_DELAY_MILLIS, EXPORT_TIMEOUT_MILLIS, RETRY_DELAY_MILLIS, MAX_SEND_ATTEMPTS, DEFAULT_LIFECYCLE_TIMEOUT_MS, RETRYABLE_STATUSES, liveTransports, traceSubmissionSpanIds, replayTraceSubmissions, submissionCounter, OtlpPayloadTooLargeError, OtlpPartialSuccessError, BitfabSpanExporter, CollectorSpanExporter, DeliveryTrackingExporter, OtelBatchTransport;
+var import_api, import_core, import_resources, import_sdk_trace_base, OPERATION_ATTRIBUTE, PAYLOAD_ATTRIBUTE, OTLP_TRACES_ENDPOINT, MAX_EXPORT_REQUEST_BYTES, MAX_REQUEST_BYTES_ENV, EXPORT_CONCURRENCY_ENV, MAX_QUEUE_SIZE, DIRECT_MAX_EXPORT_BATCH_SIZE, DIRECT_MAX_REQUEST_BATCH_SIZE, DEFAULT_EXPORT_CONCURRENCY, MAX_EXPORT_CONCURRENCY, SCHEDULE_DELAY_MILLIS, EXPORT_TIMEOUT_MILLIS, RETRY_DELAY_MILLIS, MAX_SEND_ATTEMPTS, DEFAULT_LIFECYCLE_TIMEOUT_MS, RETRYABLE_STATUSES, liveTransports, traceSubmissionSpanIds, replayTraceSubmissions, submissionCounter, textEncoder, SPAN_SEPARATOR_BYTES, OtlpPayloadTooLargeError, OtlpPartialSuccessError, BitfabSpanExporter, DeliveryTrackingExporter, OtelBatchTransport;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
@@ -590,10 +583,8 @@ var init_otel = __esm({
     MAX_EXPORT_REQUEST_BYTES = 3e6;
     MAX_REQUEST_BYTES_ENV = "BITFAB_OTEL_MAX_REQUEST_BYTES";
     EXPORT_CONCURRENCY_ENV = "BITFAB_OTEL_EXPORT_CONCURRENCY";
-    COLLECTOR_ENDPOINT_ENV = "BITFAB_OTEL_EXPORTER_ENDPOINT";
     MAX_QUEUE_SIZE = 8192;
     DIRECT_MAX_EXPORT_BATCH_SIZE = 512;
-    COLLECTOR_MAX_EXPORT_BATCH_SIZE = 32;
     DIRECT_MAX_REQUEST_BATCH_SIZE = 8;
     DEFAULT_EXPORT_CONCURRENCY = 32;
     MAX_EXPORT_CONCURRENCY = 64;
@@ -607,6 +598,8 @@ var init_otel = __esm({
     traceSubmissionSpanIds = /* @__PURE__ */ new Map();
     replayTraceSubmissions = /* @__PURE__ */ new Set();
     submissionCounter = 0;
+    textEncoder = typeof TextEncoder === "undefined" ? void 0 : new TextEncoder();
+    SPAN_SEPARATOR_BYTES = 1;
     OtlpPayloadTooLargeError = class extends Error {
     };
     OtlpPartialSuccessError = class extends Error {
@@ -635,57 +628,55 @@ var init_otel = __esm({
           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;
           }
@@ -709,12 +700,12 @@ var init_otel = __esm({
        * 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);
@@ -745,115 +736,6 @@ var init_otel = __esm({
       async forceFlush() {
       }
     };
-    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 ? import_core.ExportResultCode.SUCCESS : import_core.ExportResultCode.FAILED
-            });
-          },
-          (error) => {
-            resultCallback({ code: import_core.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 === import_core.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?.();
-      }
-    };
     DeliveryTrackingExporter = class {
       constructor(exporter) {
         this.exporter = exporter;
@@ -896,27 +778,22 @@ var init_otel = __esm({
     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 import_sdk_trace_base.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
         });
@@ -1133,8 +1010,7 @@ var init_http = __esm({
         }
         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
             })
           });
@@ -1204,11 +1080,6 @@ var init_http = __esm({
        * @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 {
@@ -1218,6 +1089,19 @@ var init_http = __esm({
           } 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,
@@ -2430,6 +2314,7 @@ __export(index_exports, {
   BitfabOpenAITracingProcessor: () => BitfabOpenAITracingProcessor,
   BitfabVercelAiHandler: () => BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL: () => DEFAULT_SERVICE_URL,
+  HttpClient: () => HttpClient,
   SUPPORTED_PROVIDERS: () => SUPPORTED_PROVIDERS,
   __version__: () => __version__,
   finalizers: () => finalizers,
@@ -6006,6 +5891,7 @@ init_replay();
   BitfabOpenAITracingProcessor,
   BitfabVercelAiHandler,
   DEFAULT_SERVICE_URL,
+  HttpClient,
   SUPPORTED_PROVIDERS,
   __version__,
   finalizers,