@telemetry-dev/otel 0.1.0

package/src/transport.ts

@@ -0,0 +1,244 @@
+import { ExportResultCode } from "@opentelemetry/core";
+import {
+  ProtobufLogsSerializer,
+  ProtobufMetricsSerializer,
+  ProtobufTraceSerializer,
+} from "@opentelemetry/otlp-transformer";
+import type { LogRecordExporter, ReadableLogRecord } from "@opentelemetry/sdk-logs";
+import {
+  AggregationTemporality,
+  type PushMetricExporter,
+  type ResourceMetrics,
+} from "@opentelemetry/sdk-metrics";
+import type { ReadableSpan, SpanExporter } from "@opentelemetry/sdk-trace-base";
+
+import { reportError } from "./debug.ts";
+
+export interface Transport {
+  fetchImpl: typeof fetch;
+  onError?: (error: unknown) => void;
+}
+
+export interface OtlpTarget {
+  url: string;
+  headers: Record<string, string>;
+}
+
+const RETRY_DELAYS_MS = [100, 500] as const;
+
+const RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);
+
+const isRetryableStatus = (status: number) => RETRYABLE_STATUSES.has(status);
+
+const delay = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+const cancelBody = async (res: Response) => {
+  try {
+    await res.body?.cancel();
+  } catch {}
+};
+
+export const postOtlp = async ({
+  fetchImpl,
+  url,
+  headers,
+  body,
+}: {
+  fetchImpl: typeof fetch;
+  url: string;
+  headers: Record<string, string>;
+  body: Uint8Array;
+}) => {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      const res = await fetchImpl(url, {
+        method: "POST",
+        headers,
+        body: body as RequestInit["body"],
+      });
+      if (res.ok || !isRetryableStatus(res.status) || attempt === RETRY_DELAYS_MS.length) {
+        await cancelBody(res);
+        return res;
+      }
+      await cancelBody(res);
+    } catch (error) {
+      if (attempt === RETRY_DELAYS_MS.length) throw error;
+    }
+
+    await delay(RETRY_DELAYS_MS[attempt]!);
+  }
+};
+
+const GZIP_THRESHOLD_BYTES = 1024;
+
+export async function maybeGzip(
+  body: Uint8Array,
+): Promise<{ body: Uint8Array; contentEncoding?: "gzip" }> {
+  if (body.byteLength <= GZIP_THRESHOLD_BYTES || typeof CompressionStream === "undefined") {
+    return { body };
+  }
+  try {
+    const stream = new Blob([body as Uint8Array<ArrayBuffer>])
+      .stream()
+      .pipeThrough(new CompressionStream("gzip"));
+    const compressed = new Uint8Array(await new Response(stream).arrayBuffer());
+    return { body: compressed, contentEncoding: "gzip" };
+  } catch {
+    // Fail-open: ship uncompressed rather than lose the batch.
+    return { body };
+  }
+}
+
+// Stay under the ingest's 4 MiB raw body limit with headroom; oversized batches are halved.
+const MAX_BODY_BYTES = 3_500_000;
+
+interface Serializer<T> {
+  serializeRequest(items: T[]): Uint8Array | undefined;
+}
+
+function createOtlpBatchSender<T>(
+  serializer: Serializer<T>,
+  target: OtlpTarget,
+  transport: Transport,
+  label: string,
+): (items: T[]) => Promise<void> {
+  const send = async (items: T[]): Promise<void> => {
+    const body = serializer.serializeRequest(items);
+    if (!body || body.byteLength === 0) return;
+    if (body.byteLength > MAX_BODY_BYTES) {
+      if (items.length > 1) {
+        const mid = Math.ceil(items.length / 2);
+        await send(items.slice(0, mid));
+        await send(items.slice(mid));
+        return;
+      }
+      // A single record beyond the limit can never be accepted; drop it instead of wedging the batch.
+      reportError(
+        transport.onError,
+        new Error(`telemetry.dev: ${label} record exceeds max export size, dropped`),
+      );
+      return;
+    }
+    const { body: finalBody, contentEncoding } = await maybeGzip(body);
+    const headers = contentEncoding
+      ? { ...target.headers, "content-encoding": contentEncoding }
+      : target.headers;
+    const res = await postOtlp({
+      fetchImpl: transport.fetchImpl,
+      url: target.url,
+      headers,
+      body: finalBody,
+    });
+    if (!res.ok) {
+      throw new Error(`telemetry.dev ${label} ingest failed: ${res.status}`);
+    }
+  };
+  return send;
+}
+
+export function createTraceExporter(target: OtlpTarget, transport: Transport): SpanExporter {
+  const send = createOtlpBatchSender<ReadableSpan>(
+    ProtobufTraceSerializer,
+    target,
+    transport,
+    "trace",
+  );
+  return {
+    export(spans, resultCallback) {
+      send(spans).then(
+        () => resultCallback({ code: ExportResultCode.SUCCESS }),
+        (error: unknown) => {
+          reportError(transport.onError, error);
+          resultCallback({
+            code: ExportResultCode.FAILED,
+            error: error instanceof Error ? error : undefined,
+          });
+        },
+      );
+    },
+    forceFlush: () => Promise.resolve(),
+    shutdown: () => Promise.resolve(),
+  };
+}
+
+export function createLogExporter(target: OtlpTarget, transport: Transport): LogRecordExporter {
+  const send = createOtlpBatchSender<ReadableLogRecord>(
+    ProtobufLogsSerializer,
+    target,
+    transport,
+    "log",
+  );
+  return {
+    export(logs, resultCallback) {
+      send(logs).then(
+        () => resultCallback({ code: ExportResultCode.SUCCESS }),
+        (error: unknown) => {
+          reportError(transport.onError, error);
+          resultCallback({
+            code: ExportResultCode.FAILED,
+            error: error instanceof Error ? error : undefined,
+          });
+        },
+      );
+    },
+    forceFlush: () => Promise.resolve(),
+    shutdown: () => Promise.resolve(),
+  };
+}
+
+export function createMetricExporter(target: OtlpTarget, transport: Transport): PushMetricExporter {
+  const { fetchImpl, onError } = transport;
+  return {
+    export(resourceMetrics: ResourceMetrics, resultCallback) {
+      // Quiet intervals produce metric envelopes with zero data points; the ingest 400s empty
+      // payloads, so skip the POST entirely.
+      const hasData = resourceMetrics.scopeMetrics.some((scope) =>
+        scope.metrics.some((metric) => metric.dataPoints.length > 0),
+      );
+      if (!hasData) {
+        resultCallback({ code: 0 });
+        return;
+      }
+      const body = ProtobufMetricsSerializer.serializeRequest(resourceMetrics);
+      if (!body || body.byteLength === 0) {
+        resultCallback({ code: 0 });
+        return;
+      }
+      // DELTA metric batches are not idempotent; a retry after an already-ingested response would double-count.
+      maybeGzip(body)
+        .then(({ body: finalBody, contentEncoding }) => {
+          const headers = contentEncoding
+            ? { ...target.headers, "content-encoding": contentEncoding }
+            : target.headers;
+          return fetchImpl(target.url, {
+            method: "POST",
+            headers,
+            body: finalBody as RequestInit["body"],
+          });
+        })
+        .then((res) => {
+          if (!res.ok) {
+            const error = new Error(`telemetry.dev metric ingest failed: ${res.status}`);
+            reportError(onError, error);
+            resultCallback({ code: 1, error });
+            return;
+          }
+          resultCallback({ code: 0 });
+        })
+        .catch((error: unknown) => {
+          reportError(onError, error);
+          resultCallback({ code: 1, error: error instanceof Error ? error : undefined });
+        });
+    },
+    selectAggregationTemporality: () => AggregationTemporality.DELTA,
+    forceFlush: () => Promise.resolve(),
+    shutdown: () => Promise.resolve(),
+  };
+}
+
+export function otlpHeaders(apiKey: string): Record<string, string> {
+  return {
+    "content-type": "application/x-protobuf",
+    authorization: `Bearer ${apiKey}`,
+  };
+}