@opengeni/observability 0.2.1 → 0.4.0

package/src/index.ts

@@ -1,9 +1,13 @@
+import { collectDefaultMetrics, Counter, Gauge, Histogram, Registry } from "prom-client";
+import { SandboxBackend } from "@opengeni/contracts";
+
 export type AttributeValue = string | number | boolean | null | undefined;
 export type Attributes = Record<string, AttributeValue>;
 
 export type ObservabilitySettings = {
   serviceName: string;
   environment: string;
+  deploymentRevision?: string | undefined;
   observabilityStructuredLogs: boolean;
   observabilityMetricsEnabled: boolean;
   observabilityOtlpEndpoint?: string | undefined;
@@ -22,19 +26,72 @@ export type Span = {
   end: (input?: { attributes?: Attributes; error?: unknown }) => void;
 };
 
-const histogramBuckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10];
+export type MetricLabels = Record<string, AttributeValue>;
+
+const httpHistogramBuckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10];
+const durationHistogramBuckets = [
+  0.01, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60, 120, 300, 900, 1800, 3600,
+];
+
+const SANDBOX_OPERATION_BACKENDS = new Set<string>([...SandboxBackend.options, "unprovisioned"]);
+
+const SANDBOX_OPERATION_NAMES = new Set([
+  "desktopInput",
+  "screenshot",
+  "exec",
+  "execCommand",
+  "writeStdin",
+  "cancelExecCommand",
+  "readFile",
+  "writeFile",
+  "listDir",
+  "pathExists",
+  "viewImage",
+  "materializeEntry",
+  "editor.createFile",
+  "editor.updateFile",
+  "editor.deleteFile",
+  "resolveExposedPort",
+  "serializeSessionState",
+]);
+
+export type SandboxOperationMetricObservation = {
+  backend: string;
+  op: string;
+  outcome: "ok" | "failed";
+  durationMs: number;
+};
 
-export function createObservability(settings: ObservabilitySettings, options: ObservabilityOptions): Observability {
+export function createObservability(
+  settings: ObservabilitySettings,
+  options: ObservabilityOptions,
+): Observability {
   return new Observability(settings, options);
 }
 
+type MetricRegistration = {
+  kind: "counter" | "gauge" | "histogram";
+  labelNames: string[];
+};
+
 export class Observability {
-  private readonly metrics = new MetricsRegistry();
+  private readonly registry = new Registry();
+  private readonly counters = new Map<string, Counter<string>>();
+  private readonly gauges = new Map<string, Gauge<string>>();
+  private readonly histograms = new Map<string, Histogram<string>>();
+  private readonly registrations = new Map<string, MetricRegistration>();
   private readonly now: () => number;
-  private readonly exporter: (url: string, body: unknown, headers: Record<string, string>) => Promise<void>;
+  private readonly exporter: (
+    url: string,
+    body: unknown,
+    headers: Record<string, string>,
+  ) => Promise<void>;
   private readonly resourceAttributes: Attributes;
 
-  constructor(private readonly settings: ObservabilitySettings, private readonly options: ObservabilityOptions) {
+  constructor(
+    private readonly settings: ObservabilitySettings,
+    private readonly options: ObservabilityOptions,
+  ) {
     this.now = options.now ?? Date.now;
     this.exporter = options.exporter ?? defaultExporter;
     this.resourceAttributes = {
@@ -42,6 +99,27 @@ export class Observability {
       "deployment.environment": settings.environment,
       "opengeni.component": options.component,
     };
+    this.registry.setDefaultLabels({
+      service: settings.serviceName,
+      environment: settings.environment,
+      component: options.component,
+    });
+    if (settings.observabilityMetricsEnabled) {
+      collectDefaultMetrics({ register: this.registry, prefix: "opengeni_" });
+      this.setGauge({
+        name: "opengeni_build_info",
+        help: "OpenGeni build information.",
+        labels: {
+          version: buildVersion(),
+          revision: settings.deploymentRevision ?? "dev",
+        },
+        value: 1,
+      });
+    }
+  }
+
+  debug(message: string, attributes: Attributes = {}): void {
+    this.log("debug", message, attributes);
   }
 
   info(message: string, attributes: Attributes = {}): void {
@@ -56,7 +134,11 @@ export class Observability {
     this.log("error", message, attributes);
   }
 
-  log(level: "debug" | "info" | "warn" | "error", message: string, attributes: Attributes = {}): void {
+  log(
+    level: "debug" | "info" | "warn" | "error",
+    message: string,
+    attributes: Attributes = {},
+  ): void {
     if (!this.settings.observabilityStructuredLogs) {
       const line = attributes.error ? `${message}: ${String(attributes.error)}` : message;
       if (level === "warn") {
@@ -100,7 +182,11 @@ export class Observability {
           return;
         }
         ended = true;
-        const errorAttributes = input.error ? errorToAttributes(input.error) : {};
+        const sanitizedError =
+          input.error !== undefined && input.error !== null
+            ? sanitizeSpanError(input.error)
+            : undefined;
+        const errorAttributes = sanitizedError ? errorToAttributes(sanitizedError) : {};
         this.exportSpan({
           traceId,
           spanId,
@@ -112,52 +198,195 @@ export class Observability {
             ...input.attributes,
             ...errorAttributes,
           },
-          error: input.error,
+          ...(sanitizedError ? { error: sanitizedError } : {}),
         });
       },
     };
   }
 
-  recordHttpRequest(input: { method: string; route: string; status: number; durationSeconds: number }): void {
+  recordHttpRequest(input: {
+    method: string;
+    route: string;
+    status: number;
+    durationSeconds: number;
+  }): void {
+    this.incrementCounter({
+      name: "opengeni_http_requests_total",
+      help: "Total HTTP requests handled by OpenGeni.",
+      labels: {
+        method: input.method,
+        route: input.route,
+        status: String(input.status),
+        component: this.options.component,
+      },
+    });
+    this.observeHistogram({
+      name: "opengeni_http_request_duration_seconds",
+      help: "HTTP request duration in seconds.",
+      buckets: httpHistogramBuckets,
+      value: input.durationSeconds,
+      labels: {
+        method: input.method,
+        route: input.route,
+        component: this.options.component,
+      },
+    });
+  }
+
+  recordWorkerActivity(input: { activity: string; status: string; durationSeconds: number }): void {
+    this.incrementCounter({
+      name: "opengeni_worker_activity_runs_total",
+      help: "Total worker activity executions.",
+      labels: {
+        activity: input.activity,
+        status: input.status,
+        component: this.options.component,
+      },
+    });
+    this.observeHistogram({
+      name: "opengeni_worker_activity_duration_seconds",
+      help: "Worker activity duration in seconds.",
+      buckets: durationHistogramBuckets,
+      value: input.durationSeconds,
+      labels: {
+        activity: input.activity,
+        component: this.options.component,
+      },
+    });
+  }
+
+  incrementCounter(input: {
+    name: string;
+    help?: string;
+    labels?: MetricLabels;
+    amount?: number;
+  }): void {
     if (!this.settings.observabilityMetricsEnabled) {
       return;
     }
-    const labels = {
-      method: input.method,
-      route: input.route,
-      status: String(input.status),
-      component: this.options.component,
-    };
-    this.metrics.increment("opengeni_http_requests_total", labels);
-    this.metrics.observe("opengeni_http_request_duration_seconds", histogramBuckets, input.durationSeconds, {
-      method: input.method,
-      route: input.route,
-      component: this.options.component,
-    });
+    const labels = normalizeLabels(input.labels);
+    const counter = this.counter(
+      input.name,
+      input.help ?? `${input.name} counter.`,
+      Object.keys(labels),
+    );
+    counter.inc(labels as never, input.amount ?? 1);
   }
 
-  recordWorkerActivity(input: { activity: string; status: string; durationSeconds: number }): void {
+  setGauge(input: { name: string; help?: string; labels?: MetricLabels; value: number }): void {
     if (!this.settings.observabilityMetricsEnabled) {
       return;
     }
-    const labels = {
-      activity: input.activity,
-      status: input.status,
-      component: this.options.component,
-    };
-    this.metrics.increment("opengeni_worker_activity_runs_total", labels);
-    this.metrics.observe("opengeni_worker_activity_duration_seconds", histogramBuckets, input.durationSeconds, {
-      activity: input.activity,
-      component: this.options.component,
-    });
+    const labels = normalizeLabels(input.labels);
+    const gauge = this.gauge(input.name, input.help ?? `${input.name} gauge.`, Object.keys(labels));
+    gauge.set(labels as never, input.value);
   }
 
-  prometheusMetrics(): string {
-    return this.metrics.toPrometheus({
-      service: this.settings.serviceName,
-      environment: this.settings.environment,
-      component: this.options.component,
-    });
+  incrementGauge(input: {
+    name: string;
+    help?: string;
+    labels?: MetricLabels;
+    amount?: number;
+  }): void {
+    if (!this.settings.observabilityMetricsEnabled) {
+      return;
+    }
+    const labels = normalizeLabels(input.labels);
+    const gauge = this.gauge(input.name, input.help ?? `${input.name} gauge.`, Object.keys(labels));
+    gauge.inc(labels as never, input.amount ?? 1);
+  }
+
+  observeHistogram(input: {
+    name: string;
+    help?: string;
+    labels?: MetricLabels;
+    value: number;
+    buckets?: number[];
+  }): void {
+    if (!this.settings.observabilityMetricsEnabled) {
+      return;
+    }
+    const labels = normalizeLabels(input.labels);
+    const histogram = this.histogram(
+      input.name,
+      input.help ?? `${input.name} histogram.`,
+      Object.keys(labels),
+      input.buckets ?? durationHistogramBuckets,
+    );
+    histogram.observe(labels as never, input.value);
+  }
+
+  async prometheusMetrics(): Promise<string> {
+    if (!this.settings.observabilityMetricsEnabled) {
+      return "";
+    }
+    return await this.registry.metrics();
+  }
+
+  private counter(name: string, help: string, labelNames: string[]): Counter<string> {
+    const existing = this.counters.get(name);
+    if (existing) {
+      this.assertRegistration(name, "counter", labelNames);
+      return existing;
+    }
+    this.register(name, "counter", labelNames);
+    const metric = new Counter({ name, help, labelNames, registers: [this.registry] });
+    this.counters.set(name, metric);
+    return metric;
+  }
+
+  private gauge(name: string, help: string, labelNames: string[]): Gauge<string> {
+    const existing = this.gauges.get(name);
+    if (existing) {
+      this.assertRegistration(name, "gauge", labelNames);
+      return existing;
+    }
+    this.register(name, "gauge", labelNames);
+    const metric = new Gauge({ name, help, labelNames, registers: [this.registry] });
+    this.gauges.set(name, metric);
+    return metric;
+  }
+
+  private histogram(
+    name: string,
+    help: string,
+    labelNames: string[],
+    buckets: number[],
+  ): Histogram<string> {
+    const existing = this.histograms.get(name);
+    if (existing) {
+      this.assertRegistration(name, "histogram", labelNames);
+      return existing;
+    }
+    this.register(name, "histogram", labelNames);
+    const metric = new Histogram({ name, help, labelNames, buckets, registers: [this.registry] });
+    this.histograms.set(name, metric);
+    return metric;
+  }
+
+  private register(name: string, kind: MetricRegistration["kind"], labelNames: string[]): void {
+    const sorted = [...labelNames].sort();
+    this.registrations.set(name, { kind, labelNames: sorted });
+  }
+
+  private assertRegistration(
+    name: string,
+    kind: MetricRegistration["kind"],
+    labelNames: string[],
+  ): void {
+    const registration = this.registrations.get(name);
+    const sorted = [...labelNames].sort();
+    if (
+      !registration ||
+      registration.kind !== kind ||
+      registration.labelNames.length !== sorted.length ||
+      registration.labelNames.some((label, index) => label !== sorted[index])
+    ) {
+      throw new Error(
+        `Metric ${name} was already registered as ${registration?.kind ?? "unknown"} ` +
+          `with labels [${registration?.labelNames.join(",") ?? ""}], not ${kind} [${sorted.join(",")}]`,
+      );
+    }
   }
 
   private exportSpan(span: {
@@ -167,41 +396,95 @@ export class Observability {
     startMs: number;
     endMs: number;
     attributes: Attributes;
-    error?: unknown;
+    error?: SanitizedSpanError;
   }): void {
     if (!this.settings.observabilityOtlpEndpoint) {
       return;
     }
     const endpoint = `${this.settings.observabilityOtlpEndpoint.replace(/\/$/, "")}/v1/traces`;
     const body = {
-      resourceSpans: [{
-        resource: {
-          attributes: otlpAttributes(this.resourceAttributes),
-        },
-        scopeSpans: [{
-          scope: {
-            name: "@opengeni/observability",
-            version: "0.1.0",
+      resourceSpans: [
+        {
+          resource: {
+            attributes: otlpAttributes(this.resourceAttributes),
           },
-          spans: [{
-            traceId: span.traceId,
-            spanId: span.spanId,
-            name: span.name,
-            kind: 1,
-            startTimeUnixNano: millisToNanos(span.startMs),
-            endTimeUnixNano: millisToNanos(span.endMs),
-            attributes: otlpAttributes(span.attributes),
-            status: span.error ? { code: 2, message: errorMessage(span.error) } : { code: 1 },
-          }],
-        }],
-      }],
+          scopeSpans: [
+            {
+              scope: {
+                name: "@opengeni/observability",
+                version: "0.1.0",
+              },
+              spans: [
+                {
+                  traceId: span.traceId,
+                  spanId: span.spanId,
+                  name: span.name,
+                  kind: 1,
+                  startTimeUnixNano: millisToNanos(span.startMs),
+                  endTimeUnixNano: millisToNanos(span.endMs),
+                  attributes: otlpAttributes(span.attributes),
+                  status: span.error ? { code: 2, message: span.error.statusMessage } : { code: 1 },
+                },
+              ],
+            },
+          ],
+        },
+      ],
     };
-    void this.exporter(endpoint, body, parseHeaders(this.settings.observabilityOtlpHeaders)).catch((error) => {
-      this.warn("OTLP span export failed", { error: errorMessage(error), endpoint });
-    });
+    void this.exporter(endpoint, body, parseHeaders(this.settings.observabilityOtlpHeaders)).catch(
+      (error) => {
+        this.warn("OTLP span export failed", { error: errorMessage(error), endpoint });
+      },
+    );
   }
 }
 
+/**
+ * Convert routed sandbox-provider observations into one bounded Prometheus
+ * contract shared by API-direct and worker-turn execution. Provider/session
+ * identifiers, commands, paths, and other request data can never become labels:
+ * a future backend or operation is deliberately collapsed to `unknown` until
+ * this allowlist is reviewed.
+ *
+ * The returned callback is fail-safe. Metrics must never change the provider
+ * operation's result; a registration/exporter error is counted best-effort and
+ * then swallowed at this telemetry boundary.
+ */
+export function sandboxOperationMetricObserver(
+  observability: Observability,
+): (observation: SandboxOperationMetricObservation) => void {
+  return (observation) => {
+    const backend = SANDBOX_OPERATION_BACKENDS.has(observation.backend)
+      ? observation.backend
+      : "unknown";
+    const op = SANDBOX_OPERATION_NAMES.has(observation.op) ? observation.op : "unknown";
+    try {
+      observability.incrementCounter({
+        name: "opengeni_sandbox_operations_total",
+        help: "Physical routed sandbox provider operations by backend, operation, and outcome.",
+        labels: { backend, op, outcome: observation.outcome },
+      });
+      observability.observeHistogram({
+        name: "opengeni_sandbox_operation_duration_seconds",
+        help: "Physical routed sandbox provider-operation duration in seconds.",
+        labels: { backend, op },
+        value: Math.max(0, observation.durationMs) / 1_000,
+      });
+    } catch {
+      try {
+        observability.incrementCounter({
+          name: "opengeni_observability_observer_errors_total",
+          help: "Observability observer failures isolated from product execution.",
+          labels: { observer: "sandbox_operation" },
+        });
+      } catch {
+        // The metrics registry itself is unhealthy. Product execution remains
+        // authoritative and must not inherit an observability failure.
+      }
+    }
+  };
+}
+
 export type StartupDependencyRetryEvent = {
   label: string;
   attempt: number;
@@ -210,7 +493,10 @@ export type StartupDependencyRetryEvent = {
   error: unknown;
 };
 
-export function logStartupDependencyRetry(observability: Observability, event: StartupDependencyRetryEvent): void {
+export function logStartupDependencyRetry(
+  observability: Observability,
+  event: StartupDependencyRetryEvent,
+): void {
   const message = event.error instanceof Error ? event.error.message : String(event.error);
   observability.warn("Startup dependency connection failed; retrying", {
     dependency: event.label,
@@ -221,95 +507,63 @@ export function logStartupDependencyRetry(observability: Observability, event: S
   });
 }
 
-class MetricsRegistry {
-  private readonly counters = new Map<string, number>();
-  private readonly histograms = new Map<string, { buckets: number[]; counts: number[]; sum: number; count: number; labels: Record<string, string> }>();
-
-  increment(name: string, labels: Record<string, string>, amount = 1): void {
-    const key = metricKey(name, labels);
-    this.counters.set(key, (this.counters.get(key) ?? 0) + amount);
-  }
-
-  observe(name: string, buckets: number[], value: number, labels: Record<string, string>): void {
-    const key = metricKey(name, labels);
-    const histogram = this.histograms.get(key) ?? {
-      buckets,
-      counts: buckets.map(() => 0),
-      sum: 0,
-      count: 0,
-      labels,
-    };
-    histogram.sum += value;
-    histogram.count += 1;
-    for (let index = 0; index < buckets.length; index += 1) {
-      if (value <= buckets[index]!) {
-        histogram.counts[index] = (histogram.counts[index] ?? 0) + 1;
-      }
-    }
-    this.histograms.set(key, histogram);
-  }
-
-  toPrometheus(resourceLabels: Record<string, string>): string {
-    const lines = [
-      "# HELP opengeni_http_requests_total Total HTTP requests handled by the OpenGeni API.",
-      "# TYPE opengeni_http_requests_total counter",
-    ];
-    for (const [key, value] of this.counters) {
-      const { name, labels } = parseMetricKey(key);
-      if (name.endsWith("_total")) {
-        lines.push(`${name}${formatLabels({ ...resourceLabels, ...labels })} ${value}`);
-      }
-    }
-    lines.push(
-      "# HELP opengeni_http_request_duration_seconds HTTP request duration in seconds.",
-      "# TYPE opengeni_http_request_duration_seconds histogram",
-      "# HELP opengeni_worker_activity_runs_total Total worker activity executions.",
-      "# TYPE opengeni_worker_activity_runs_total counter",
-      "# HELP opengeni_worker_activity_duration_seconds Worker activity duration in seconds.",
-      "# TYPE opengeni_worker_activity_duration_seconds histogram",
-    );
-    for (const [key, histogram] of this.histograms) {
-      const { name, labels } = parseMetricKey(key);
-      const baseLabels = { ...resourceLabels, ...labels };
-      for (let index = 0; index < histogram.buckets.length; index += 1) {
-        lines.push(`${name}_bucket${formatLabels({ ...baseLabels, le: String(histogram.buckets[index]) })} ${histogram.counts[index]}`);
-      }
-      lines.push(`${name}_bucket${formatLabels({ ...baseLabels, le: "+Inf" })} ${histogram.count}`);
-      lines.push(`${name}_sum${formatLabels(baseLabels)} ${histogram.sum}`);
-      lines.push(`${name}_count${formatLabels(baseLabels)} ${histogram.count}`);
-    }
-    return `${lines.join("\n")}\n`;
-  }
+function normalizeLabels(labels: MetricLabels = {}): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(labels)
+      .filter(([, value]) => value !== undefined && value !== null)
+      .map(([key, value]): [string, string] => [key, String(value)])
+      .sort((left, right) => left[0].localeCompare(right[0])),
+  );
 }
 
-function metricKey(name: string, labels: Record<string, string>): string {
-  return JSON.stringify({ name, labels: Object.fromEntries(Object.entries(labels).sort(([a], [b]) => a.localeCompare(b))) });
+function buildVersion(): string {
+  return process.env.OPENGENI_VERSION ?? process.env.npm_package_version ?? "dev";
 }
 
-function parseMetricKey(key: string): { name: string; labels: Record<string, string> } {
-  return JSON.parse(key) as { name: string; labels: Record<string, string> };
+function cleanAttributes(attributes: Attributes): Record<string, string | number | boolean | null> {
+  return Object.fromEntries(
+    Object.entries(attributes).filter(([, value]) => value !== undefined),
+  ) as Record<string, string | number | boolean | null>;
 }
 
-function formatLabels(labels: Record<string, string>): string {
-  const entries = Object.entries(labels).filter(([, value]) => value.length > 0);
-  if (entries.length === 0) {
-    return "";
-  }
-  return `{${entries.map(([key, value]) => `${key}="${escapeMetricLabel(value)}"`).join(",")}}`;
-}
+type SanitizedSpanError = {
+  type: string;
+  statusCode?: number;
+  statusMessage: string;
+};
 
-function escapeMetricLabel(value: string): string {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
+function sanitizeSpanError(error: unknown): SanitizedSpanError {
+  const type =
+    error instanceof Error && /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/.test(error.name)
+      ? error.name
+      : "Error";
+  const statusCode = errorStatusCode(error);
+  return {
+    type,
+    ...(statusCode === undefined ? {} : { statusCode }),
+    statusMessage: statusCode === undefined ? "operation failed" : `HTTP ${statusCode}`,
+  };
 }
 
-function cleanAttributes(attributes: Attributes): Record<string, string | number | boolean | null> {
-  return Object.fromEntries(Object.entries(attributes).filter(([, value]) => value !== undefined)) as Record<string, string | number | boolean | null>;
+function errorStatusCode(error: unknown): number | undefined {
+  if (typeof error !== "object" || error === null) return undefined;
+  const value = (error as { status?: unknown; statusCode?: unknown }).status;
+  const statusCode =
+    Number.isInteger(value) && typeof value === "number"
+      ? value
+      : (error as { statusCode?: unknown }).statusCode;
+  return Number.isInteger(statusCode) &&
+    typeof statusCode === "number" &&
+    statusCode >= 100 &&
+    statusCode <= 599
+    ? statusCode
+    : undefined;
 }
 
-function errorToAttributes(error: unknown): Attributes {
+function errorToAttributes(error: SanitizedSpanError): Attributes {
   return {
-    "error.type": error instanceof Error ? error.name : "Error",
-    "error.message": errorMessage(error),
+    "error.type": error.type,
+    ...(error.statusCode === undefined ? {} : { "error.status_code": error.statusCode }),
   };
 }
 
@@ -317,21 +571,31 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-function otlpAttributes(attributes: Attributes): Array<{ key: string; value: Record<string, string | number | boolean> }> {
+function otlpAttributes(
+  attributes: Attributes,
+): Array<{ key: string; value: Record<string, string | number | boolean> }> {
   return Object.entries(cleanAttributes(attributes)).map(([key, value]) => ({
     key,
     value: otlpValue(value),
   }));
 }
 
-function otlpValue(value: string | number | boolean | null): Record<string, string | number | boolean> {
+function otlpValue(
+  value: string | number | boolean | null,
+): Record<string, string | number | boolean> {
   if (typeof value === "number") {
     return Number.isInteger(value) ? { intValue: value } : { doubleValue: value };
   }
   if (typeof value === "boolean") {
     return { boolValue: value };
   }
-  return { stringValue: value === null ? "" : value };
+  return { stringValue: value === null ? "" : boundedOtlpString(value) };
+}
+
+function boundedOtlpString(value: string): string {
+  const bytes = new TextEncoder().encode(value);
+  if (bytes.byteLength <= 512) return value;
+  return `${new TextDecoder().decode(bytes.slice(0, 509))}…`;
 }
 
 function millisToNanos(ms: number): string {
@@ -347,17 +611,24 @@ export function parseHeaders(value: string): Record<string, string> {
   if (!value.trim()) {
     return {};
   }
-  const entries: Array<[string, string]> = value.split(",").map((pair): [string, string] => {
-    const separator = pair.indexOf("=");
-    if (separator === -1) {
-      return [pair.trim(), ""];
-    }
-    return [pair.slice(0, separator).trim(), pair.slice(separator + 1).trim()];
-  }).filter(([key]) => key.length > 0);
+  const entries: Array<[string, string]> = value
+    .split(",")
+    .map((pair): [string, string] => {
+      const separator = pair.indexOf("=");
+      if (separator === -1) {
+        return [pair.trim(), ""];
+      }
+      return [pair.slice(0, separator).trim(), pair.slice(separator + 1).trim()];
+    })
+    .filter(([key]) => key.length > 0);
   return Object.fromEntries(entries);
 }
 
-async function defaultExporter(url: string, body: unknown, headers: Record<string, string>): Promise<void> {
+async function defaultExporter(
+  url: string,
+  body: unknown,
+  headers: Record<string, string>,
+): Promise<void> {
   const response = await fetch(url, {
     method: "POST",
     headers: {