@volter/supercode-teams 0.2.20

package/server/otlp/transport.mjs

@@ -0,0 +1,424 @@
+import { gunzipSync } from "node:zlib";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import protobuf from "protobufjs";
+import { decodeToObject, encodeFromObject } from "./wire-codec.mjs";
+
+export const MAX_UNCOMPRESSED_BODY_BYTES = 16 * 1024 * 1024;
+
+const SIGNALS = {
+  logs: {
+    request: "opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest",
+    response: "opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse",
+    roots: "resourceLogs", scopes: "scopeLogs", records: "logRecords",
+    rejected: "rejectedLogRecords"
+  },
+  traces: {
+    request: "opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest",
+    response: "opentelemetry.proto.collector.trace.v1.ExportTraceServiceResponse",
+    roots: "resourceSpans", scopes: "scopeSpans", records: "spans",
+    rejected: "rejectedSpans"
+  },
+  metrics: {
+    request: "opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest",
+    response: "opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse",
+    roots: "resourceMetrics", scopes: "scopeMetrics", records: "metrics",
+    rejected: "rejectedDataPoints"
+  }
+};
+
+let schemaPromise;
+let schemaSources = null;
+const SCHEMA_ENTRIES = [
+  "opentelemetry/proto/collector/logs/v1/logs_service.proto",
+  "opentelemetry/proto/collector/trace/v1/trace_service.proto",
+  "opentelemetry/proto/collector/metrics/v1/metrics_service.proto",
+  "google/rpc/status.proto"
+];
+
+/**
+ * Supply the pinned .proto files as text, keyed by their path under schema/ (e.g.
+ * "google/rpc/status.proto"), for a host with no filesystem. Without it they are read from disk.
+ */
+export function setOtlpSchemaSources(sources) {
+  schemaSources = sources;
+  schemaPromise = undefined;
+}
+
+function schema() {
+  if (schemaSources) {
+    schemaPromise ??= Promise.resolve().then(() => {
+      const root = new protobuf.Root();
+      const loaded = new Set();
+      const load = (name) => {
+        if (loaded.has(name)) return;
+        loaded.add(name);
+        const text = schemaSources[name];
+        if (typeof text !== "string") throw new Error(`OTLP schema source missing: ${name}`);
+        const parsed = protobuf.parse(text, root, { keepCase: false });
+        for (const dependency of [...(parsed.imports ?? []), ...(parsed.weakImports ?? [])]) load(dependency);
+      };
+      for (const entry of SCHEMA_ENTRIES) load(entry);
+      return root.resolveAll();
+    });
+    return schemaPromise;
+  }
+  const base = path.join(path.dirname(fileURLToPath(import.meta.url)), "schema");
+  const root = new protobuf.Root();
+  root.resolvePath = (_origin, target) => path.isAbsolute(target) ? target : path.join(base, target);
+  schemaPromise ??= root.load(SCHEMA_ENTRIES.map((name) => path.join(base, name)));
+  return schemaPromise;
+}
+
+function config(signal) {
+  const value = SIGNALS[signal];
+  if (!value) throw new TypeError(`unsupported OTLP signal: ${signal}`);
+  return value;
+}
+
+function representation(value) {
+  if (value === "json" || value === "application/json") return "json";
+  if (value === "protobuf" || value === "application/x-protobuf") return "protobuf";
+  throw new TypeError(`unsupported OTLP representation: ${value}`);
+}
+
+function asBytes(input) {
+  if (input instanceof Uint8Array) return input;
+  if (typeof input === "string") return Buffer.from(input);
+  throw new TypeError("OTLP body must be a string or Uint8Array");
+}
+
+function ownArray(value, key, where) {
+  if (value[key] === undefined) return [];
+  if (!Array.isArray(value[key])) throw new TypeError(`${where}.${key} must be an array`);
+  return value[key];
+}
+
+const UINT64_MAX = (1n << 64n) - 1n;
+const INT64_MIN = -(1n << 63n), INT64_MAX = (1n << 63n) - 1n;
+const ID_LENGTHS = new Map([["traceId", 32], ["spanId", 16], ["parentSpanId", 16]]);
+function canonicalInteger(value, signed, key) {
+  if (typeof value !== "string" || !/^-?(0|[1-9][0-9]*)$/.test(value) || value.length > 21) throw new TypeError(`${key} is not a decimal 64-bit integer`);
+  const integer = BigInt(value);
+  if (signed ? integer < INT64_MIN || integer > INT64_MAX : integer < 0n || integer > UINT64_MAX) throw new TypeError(`${key} is outside its 64-bit range`);
+  return integer.toString();
+}
+function validUint64(value) {
+  if (value === undefined || value === null || value === "") return true;
+  if (typeof value === "number") return Number.isSafeInteger(value) && value >= 0;
+  if (typeof value !== "string" || !/^(0|[1-9][0-9]*)$/.test(value) || value.length > 20) return false;
+  return BigInt(value) <= UINT64_MAX;
+}
+
+class RawJsonNumber { constructor(raw) { this.raw = raw; } }
+function setData(object, key, value) { Object.defineProperty(object, key, { value, enumerable: true, configurable: true, writable: true }); }
+function parseLosslessJson(text) {
+  let index = 0;
+  const whitespace = () => { while (/\s/.test(text[index] ?? "")) index++; };
+  const value = () => {
+    whitespace(); const char = text[index];
+    if (char === '"') {
+      const start = index++;
+      while (index < text.length) { if (text[index] === "\\") index += 2; else if (text[index++] === '"') return JSON.parse(text.slice(start, index)); }
+      throw new SyntaxError("unterminated string");
+    }
+    if (char === "{") {
+      index++; const result = {}; whitespace(); if (text[index] === "}") { index++; return result; }
+      while (true) { const key = value(); if (typeof key !== "string") throw new SyntaxError("object key must be a string"); whitespace(); if (text[index++] !== ":") throw new SyntaxError("expected colon"); setData(result,key,value()); whitespace(); const next = text[index++]; if (next === "}") return result; if (next !== ",") throw new SyntaxError("expected comma"); }
+    }
+    if (char === "[") {
+      index++; const result = []; whitespace(); if (text[index] === "]") { index++; return result; }
+      while (true) { result.push(value()); whitespace(); const next = text[index++]; if (next === "]") return result; if (next !== ",") throw new SyntaxError("expected comma"); }
+    }
+    for (const [literal, result] of [["true", true], ["false", false], ["null", null]]) if (text.startsWith(literal, index)) { index += literal.length; return result; }
+    const number = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/.exec(text.slice(index));
+    if (number) { index += number[0].length; return new RawJsonNumber(number[0]); }
+    throw new SyntaxError("invalid JSON value");
+  };
+  const result = value(); whitespace(); if (index !== text.length) throw new SyntaxError("trailing JSON content"); return result;
+}
+function rawInteger(value, signed, key) {
+  if (typeof value === "string") return canonicalInteger(value, signed, key);
+  if (!(value instanceof RawJsonNumber)) throw new TypeError(`${key} is not a 64-bit integer`);
+  const match = /^(-?)([0-9]+)(?:\.([0-9]+))?(?:[eE]([+-]?[0-9]+))?$/.exec(value.raw);
+  if (!match) throw new TypeError(`${key} is not an integer number`);
+  const fraction = match[3] ?? ""; const exponent = Number(match[4] ?? 0);
+  if (!Number.isSafeInteger(exponent) || Math.abs(exponent) > 100) throw new TypeError(`${key} exponent is outside the receiver limit`);
+  let digits = `${match[2]}${fraction}`, scale = exponent - fraction.length;
+  if (scale < 0) { const cut = digits.length + scale; if (cut < 0 || !/^0*$/.test(digits.slice(Math.max(0, cut)))) throw new TypeError(`${key} is not an integer number`); digits = cut <= 0 ? "0" : digits.slice(0, cut); }
+  else digits += "0".repeat(scale);
+  digits = digits.replace(/^0+(?=\d)/, ""); return canonicalInteger(`${match[1]}${digits}`, signed, key);
+}
+function unknownJson(value) {
+  if (value instanceof RawJsonNumber) return Number(value.raw);
+  if (Array.isArray(value)) return value.map(unknownJson);
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, unknownJson(child)]));
+  return value;
+}
+const SIGNED_PROTO64 = new Set(["int64", "sint64", "sfixed64"]), UNSIGNED_PROTO64 = new Set(["uint64", "fixed64"]);
+function normalizeJsonMessage(type, input, where = type.name) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) throw new TypeError(`${where} must be an object`);
+  const result = {};
+  for (const [key, raw] of Object.entries(input)) {
+    const field = Object.hasOwn(type.fields,key) ? type.fields[key] : null;
+    if (!field) { setData(result,key,unknownJson(raw)); continue; }
+    if (raw === null) continue;
+    const normalizeOne = (item) => {
+      if (SIGNED_PROTO64.has(field.type)) return rawInteger(item, true, key);
+      if (UNSIGNED_PROTO64.has(field.type)) return rawInteger(item, false, key);
+      if (field.resolvedType instanceof protobuf.Enum) {
+        const number = item instanceof RawJsonNumber ? Number(item.raw) : item;
+        if (!Number.isInteger(number)) throw new TypeError(`${key} enum must be encoded as an integer`); return number;
+      }
+      if (field.resolvedType instanceof protobuf.Type) return normalizeJsonMessage(field.resolvedType, item, `${where}.${key}`);
+      if (field.type === "bytes" && ID_LENGTHS.has(key)) {
+        if (typeof item !== "string" || (item !== "" && (item.length !== ID_LENGTHS.get(key) || !/^[0-9a-f]+$/i.test(item)))) throw new TypeError(`${key} is not a ${ID_LENGTHS.get(key) / 2}-byte hexadecimal ID`);
+        return item.toLowerCase();
+      }
+      if (field.type === "string") { if (typeof item !== "string") throw new TypeError(`${where}.${key} must be a string`); return item; }
+      if (field.type === "bool") { if (typeof item !== "boolean") throw new TypeError(`${where}.${key} must be a boolean`); return item; }
+      if (field.type === "bytes") {
+        if (typeof item !== "string" || !/^(?:[A-Za-z0-9+/_-]{4})*(?:[A-Za-z0-9+/_-]{2}==?|[A-Za-z0-9+/_-]{3}=?)?$/.test(item)) throw new TypeError(`${where}.${key} must be base64 bytes`);
+        return item;
+      }
+      if (["double", "float"].includes(field.type)) {
+        if (typeof item === "string" && ["NaN", "Infinity", "-Infinity"].includes(item)) return item;
+        if (!(item instanceof RawJsonNumber)) throw new TypeError(`${where}.${key} must be a number`);
+        const number = Number(item.raw); if (!Number.isFinite(number)) throw new TypeError(`${where}.${key} is outside the numeric range`); return number;
+      }
+      if (["int32", "sint32", "sfixed32", "uint32", "fixed32"].includes(field.type)) {
+        if (!(item instanceof RawJsonNumber) || /[.eE]/.test(item.raw)) throw new TypeError(`${where}.${key} must be an integer number`);
+        const number = Number(item.raw), unsigned = field.type.startsWith("u") || field.type.startsWith("fixed");
+        if (!Number.isInteger(number) || number < (unsigned ? 0 : -2147483648) || number > (unsigned ? 4294967295 : 2147483647)) throw new TypeError(`${where}.${key} is outside its 32-bit range`);
+        return number;
+      }
+      if (item instanceof RawJsonNumber) return Number(item.raw);
+      return unknownJson(item);
+    };
+    if (field.repeated) { if (!Array.isArray(raw)) throw new TypeError(`${where}.${key} must be an array`); setData(result,key,raw.map(normalizeOne)); }
+    else setData(result,key,normalizeOne(raw));
+  }
+  for (const oneof of Object.values(type.oneofs ?? {})) {
+    const populated = oneof.oneof.filter((key) => result[key] !== undefined);
+    if (populated.length > 1) throw new TypeError(`${where} has conflicting oneof fields: ${populated.join(", ")}`);
+  }
+  return result;
+}
+function normalizeProtobufValue(value, key = "") {
+  if (ID_LENGTHS.has(key) && typeof value === "string") return value === "" ? "" : Buffer.from(value, "base64").toString("hex");
+  if (Array.isArray(value)) return value.map((item) => normalizeProtobufValue(item));
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([childKey, child]) => [childKey, normalizeProtobufValue(child, childKey)]));
+  return value;
+}
+const NORMALIZATION_ERROR = Symbol("otlpNormalizationError");
+function without(input, keys) { return Object.fromEntries(Object.entries(input).filter(([key]) => !keys.includes(key))); }
+function markError(value, error) { if (value && typeof value === "object") Object.defineProperty(value, NORMALIZATION_ERROR, { value: error.message }); return value; }
+function normalizeJsonEnvelope(type, c, input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) throw new TypeError("OTLP request must be an object");
+  const rootField = type.fields[c.roots];
+  const output = normalizeJsonMessage(type, without(input, [c.roots]));
+  const roots = input[c.roots] ?? []; if (!Array.isArray(roots)) throw new TypeError(`request.${c.roots} must be an array`);
+  output[c.roots] = roots.map((group, resourceIndex) => {
+    if (!group || typeof group !== "object" || Array.isArray(group)) throw new TypeError(`${c.roots}[${resourceIndex}] must be an object`);
+    const groupType = rootField.resolvedType, groupOutput = normalizeJsonMessage(groupType, without(group, [c.scopes]));
+    const scopeField = groupType.fields[c.scopes], scopes = group[c.scopes] ?? []; if (!Array.isArray(scopes)) throw new TypeError(`${c.roots}[${resourceIndex}].${c.scopes} must be an array`);
+    groupOutput[c.scopes] = scopes.map((scopeGroup, scopeIndex) => {
+      if (!scopeGroup || typeof scopeGroup !== "object" || Array.isArray(scopeGroup)) throw new TypeError(`${c.scopes}[${scopeIndex}] must be an object`);
+      const scopeType = scopeField.resolvedType, scopeOutput = normalizeJsonMessage(scopeType, without(scopeGroup, [c.records]));
+      const recordField = scopeType.fields[c.records], items = scopeGroup[c.records] ?? []; if (!Array.isArray(items)) throw new TypeError(`${c.scopes}[${scopeIndex}].${c.records} must be an array`);
+      scopeOutput[c.records] = items.map((item) => {
+        if (c.records !== "metrics") { try { return normalizeJsonMessage(recordField.resolvedType, item); } catch (error) { return markError(unknownJson(item), error); } }
+        if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+        const metricType = recordField.resolvedType, dataKeys = METRIC_DATA_KEYS.filter((key) => item[key] !== undefined && item[key] !== null);
+        if (dataKeys.length > 1) throw new TypeError("metric must contain at most one data field");
+        const metricOutput = normalizeJsonMessage(metricType, without(item, METRIC_DATA_KEYS));
+        if (!dataKeys.length) return metricOutput;
+        const dataKey = dataKeys[0], data = item[dataKey], dataField = metricType.fields[dataKey];
+        if (!data || typeof data !== "object" || Array.isArray(data)) throw new TypeError(`${dataKey} must be an object`);
+        const dataOutput = normalizeJsonMessage(dataField.resolvedType, without(data, ["dataPoints"]));
+        const pointField = dataField.resolvedType.fields.dataPoints, points = data.dataPoints ?? [];
+        if (!Array.isArray(points)) throw new TypeError(`${dataKey}.dataPoints must be an array`);
+        dataOutput.dataPoints = points.map((point) => { try { return normalizeJsonMessage(pointField.resolvedType, point); } catch (error) { return markError(unknownJson(point), error); } });
+        metricOutput[dataKey] = dataOutput; return metricOutput;
+      });
+      return scopeOutput;
+    });
+    return groupOutput;
+  });
+  return output;
+}
+function protobufInputValue(value, key = "") {
+  if (ID_LENGTHS.has(key) && typeof value === "string") return Buffer.from(value, "hex");
+  if (Array.isArray(value)) return value.map((item) => protobufInputValue(item));
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([childKey, child]) => [childKey, protobufInputValue(child, childKey)]));
+  return value;
+}
+
+function validBytes(value, length) {
+  if (value === undefined || value === null || value === "") return true;
+  return typeof value === "string" && value.length === length * 2 && /^[0-9a-f]+$/i.test(value);
+}
+
+function recordErrors(signal, record) {
+  if (!record || typeof record !== "object" || Array.isArray(record)) return ["record must be an object"];
+  const errors = [];
+  if (record.attributes !== undefined && !Array.isArray(record.attributes)) errors.push("attributes must be an array");
+  if (signal === "logs" && record.body !== undefined && (!record.body || typeof record.body !== "object" || Array.isArray(record.body))) errors.push("body must be an AnyValue object");
+  if (signal === "traces") {
+    for (const key of ["events", "links"]) if (record[key] !== undefined && !Array.isArray(record[key])) errors.push(`${key} must be an array`);
+    if (record.status !== undefined && (!record.status || typeof record.status !== "object" || Array.isArray(record.status))) errors.push("status must be an object");
+    for (const [index, event] of (Array.isArray(record.events) ? record.events : []).entries()) if (!event || typeof event !== "object" || (event.attributes !== undefined && !Array.isArray(event.attributes))) errors.push(`events[${index}] is malformed`);
+    for (const [index, link] of (Array.isArray(record.links) ? record.links : []).entries()) if (!link || typeof link !== "object" || (link.attributes !== undefined && !Array.isArray(link.attributes))) errors.push(`links[${index}] is malformed`);
+  }
+  const times = signal === "logs" ? ["timeUnixNano", "observedTimeUnixNano"] : signal === "traces" ? ["startTimeUnixNano", "endTimeUnixNano"] : [];
+  for (const key of times) if (!validUint64(record[key])) errors.push(`${key} is not a uint64`);
+  if ((signal === "logs" || signal === "traces") && !validBytes(record.traceId, 16)) errors.push("traceId is not 16 bytes");
+  if ((signal === "logs" || signal === "traces") && !validBytes(record.spanId, 8)) errors.push("spanId is not 8 bytes");
+  return errors;
+}
+
+const METRIC_DATA_KEYS = ["gauge", "sum", "histogram", "exponentialHistogram", "summary"];
+function metricEvidence(metric, context) {
+  if (!metric || typeof metric !== "object" || Array.isArray(metric)) throw new TypeError("metric must be an object");
+  const dataType = METRIC_DATA_KEYS.find((key) => metric[key] !== undefined) ?? null;
+  if (METRIC_DATA_KEYS.filter((key) => metric[key] !== undefined).length > 1) throw new TypeError("metric must contain at most one data field");
+  const { gauge, sum, histogram, exponentialHistogram, summary, ...identity } = metric;
+  if (!dataType) return { records: [{ ...context, evidenceKind: "metric_metadata", record: metric, metric: { ...identity, dataType: null, data: null } }], rejected: [] };
+  const data = metric[dataType];
+  if (!data || typeof data !== "object" || Array.isArray(data)) throw new TypeError(`${dataType} must be an object`);
+  const { dataPoints, ...container } = data;
+  if (dataPoints === undefined || (Array.isArray(dataPoints) && dataPoints.length === 0)) {
+    return { records: [{ ...context, evidenceKind: "metric_metadata", record: metric, metric: { ...identity, dataType, data: container } }], rejected: [] };
+  }
+  if (!Array.isArray(dataPoints)) throw new TypeError(`${dataType}.dataPoints must be an array`);
+  const records = [], rejected = [];
+  dataPoints.forEach((rawPoint, pointIndex) => {
+    const point = rawPoint, normalizationError = rawPoint?.[NORMALIZATION_ERROR];
+    const evidence = { ...context, evidenceKind: "metric_data_point", record: point, metric: { ...identity, dataType, data: container }, position: { ...context.position, pointIndex } };
+    const errors = [];
+    if (normalizationError) errors.push(normalizationError);
+    if (!point || typeof point !== "object" || Array.isArray(point)) errors.push("data point must be an object");
+    else {
+      for (const key of ["timeUnixNano", "startTimeUnixNano"]) if (!validUint64(point[key])) errors.push(`${key} is not a uint64`);
+      for (const key of ["attributes", "exemplars", "bucketCounts", "explicitBounds", "quantileValues"]) if (point[key] !== undefined && !Array.isArray(point[key])) errors.push(`${key} must be an array`);
+    }
+    if (errors.length) rejected.push({ evidence, error: errors.join("; ") }); else records.push(evidence);
+  });
+  return { records, rejected };
+}
+
+function flatten(signal, envelope, receivedAt) {
+  const c = config(signal);
+  const records = [];
+  const rejected = [];
+  const roots = ownArray(envelope, c.roots, "request");
+  roots.forEach((resourceGroup, resourceIndex) => {
+    if (!resourceGroup || typeof resourceGroup !== "object" || Array.isArray(resourceGroup)) throw new TypeError(`${c.roots}[${resourceIndex}] must be an object`);
+    if (resourceGroup.resource !== undefined && (!resourceGroup.resource || typeof resourceGroup.resource !== "object" || Array.isArray(resourceGroup.resource))) throw new TypeError(`${c.roots}[${resourceIndex}].resource must be an object`);
+    if (resourceGroup.resource?.attributes !== undefined && !Array.isArray(resourceGroup.resource.attributes)) throw new TypeError(`${c.roots}[${resourceIndex}].resource.attributes must be an array`);
+    const resource = resourceGroup.resource ?? null;
+    const scopes = ownArray(resourceGroup, c.scopes, `${c.roots}[${resourceIndex}]`);
+    scopes.forEach((scopeGroup, scopeIndex) => {
+      if (!scopeGroup || typeof scopeGroup !== "object" || Array.isArray(scopeGroup)) throw new TypeError(`${c.scopes}[${scopeIndex}] must be an object`);
+      if (scopeGroup.scope !== undefined && (!scopeGroup.scope || typeof scopeGroup.scope !== "object" || Array.isArray(scopeGroup.scope))) throw new TypeError(`${c.scopes}[${scopeIndex}].scope must be an object`);
+      if (scopeGroup.scope?.attributes !== undefined && !Array.isArray(scopeGroup.scope.attributes)) throw new TypeError(`${c.scopes}[${scopeIndex}].scope.attributes must be an array`);
+      const scope = scopeGroup.scope ?? null;
+      const items = ownArray(scopeGroup, c.records, `${c.scopes}[${scopeIndex}]`);
+      items.forEach((inputRecord, recordIndex) => {
+        const context = {
+          signal,
+          resource,
+          resourceSchemaUrl: resourceGroup.schemaUrl ?? null,
+          scope,
+          scopeSchemaUrl: scopeGroup.schemaUrl ?? null,
+          receivedAt,
+          position: { resourceIndex, scopeIndex, recordIndex }
+        };
+        if (signal === "metrics") {
+          const result = metricEvidence(inputRecord, context);
+          records.push(...result.records); rejected.push(...result.rejected); return;
+        }
+        const rawRecord = inputRecord, normalizationError = inputRecord?.[NORMALIZATION_ERROR];
+        const errors = recordErrors(signal, rawRecord);
+        if (normalizationError) errors.unshift(normalizationError);
+        const evidence = { ...context, evidenceKind: signal === "logs" ? "log_record" : "span", record: rawRecord };
+        if (errors.length) rejected.push({ evidence, error: errors.join("; ") }); else records.push(evidence);
+      });
+    });
+  });
+  return { records, rejected };
+}
+
+export async function decodeOtlpRequest({ signal, representation: encoding, bytes, receivedAt }) {
+  const c = config(signal);
+  const kind = representation(encoding);
+  const input = asBytes(bytes);
+  let envelope;
+  if (kind === "json") {
+    const type = await schema().then((root) => root.lookupType(c.request));
+    try { envelope = normalizeJsonEnvelope(type, c, parseLosslessJson(Buffer.from(input).toString("utf8"))); }
+    catch (error) { throw new TypeError(`malformed OTLP JSON: ${error.message}`); }
+    if (!envelope || typeof envelope !== "object" || Array.isArray(envelope)) throw new TypeError("OTLP request must be an object");
+  } else {
+    const type = (await schema()).lookupType(c.request);
+    try {
+      envelope = normalizeProtobufValue(decodeToObject(type, input));
+    } catch (error) { throw new TypeError(`malformed OTLP protobuf: ${error.message}`); }
+  }
+  return { envelope, ...flatten(signal, envelope, receivedAt ?? null) };
+}
+
+export async function encodeOtlpRequest({ signal, representation: encoding, envelope }) {
+  const c = config(signal); const kind = representation(encoding);
+  if (kind === "json") return Buffer.from(JSON.stringify(envelope));
+  const type = (await schema()).lookupType(c.request);
+  try { return Buffer.from(encodeFromObject(type, protobufInputValue(envelope))); }
+  catch (error) { throw new TypeError(`invalid OTLP request: ${error.message}`); }
+}
+
+export async function encodeOtlpResponse({ signal, representation: encoding, rejectedCount = 0, errorMessage = "" }) {
+  const c = config(signal); const kind = representation(encoding);
+  const partialSuccess = rejectedCount > 0 || errorMessage ? { [c.rejected]: String(rejectedCount), errorMessage } : undefined;
+  const value = partialSuccess ? { partialSuccess } : {};
+  if (kind === "json") return Buffer.from(JSON.stringify(value));
+  const type = (await schema()).lookupType(c.response);
+  return Buffer.from(encodeFromObject(type, value));
+}
+
+export async function encodeOtlpError({ representation: encoding, code, message }) {
+  const kind = representation(encoding); const value = { code, message };
+  if (kind === "json") return Buffer.from(JSON.stringify(value));
+  const type = (await schema()).lookupType("google.rpc.Status");
+  return Buffer.from(encodeFromObject(type, value));
+}
+
+export function decodeContentEncoding(bytes, contentEncoding, maxBytes = MAX_UNCOMPRESSED_BODY_BYTES) {
+  const input = asBytes(bytes);
+  let result;
+  if (!contentEncoding || contentEncoding === "identity") result = input;
+  else if (contentEncoding.toLowerCase() === "gzip") {
+    try { result = gunzipSync(input, { maxOutputLength: maxBytes + 1 }); }
+    catch (error) {
+      if (error?.code === "ERR_BUFFER_TOO_LARGE") throw Object.assign(new RangeError("uncompressed OTLP body exceeds limit"), { code: "BODY_TOO_LARGE" });
+      throw new TypeError(`invalid gzip OTLP body: ${error.message}`);
+    }
+  } else throw Object.assign(new TypeError(`unsupported content-encoding: ${contentEncoding}`), { code: "UNSUPPORTED_ENCODING" });
+  if (result.byteLength > maxBytes) throw Object.assign(new RangeError("uncompressed OTLP body exceeds limit"), { code: "BODY_TOO_LARGE" });
+  return result;
+}
+
+export async function readBoundedBody(body, maxBytes = MAX_UNCOMPRESSED_BODY_BYTES) {
+  if (body instanceof Uint8Array || typeof body === "string") {
+    const bytes = asBytes(body);
+    if (bytes.byteLength > maxBytes) throw Object.assign(new RangeError("compressed OTLP body exceeds limit"), { code: "BODY_TOO_LARGE" });
+    return bytes;
+  }
+  if (!body || typeof body[Symbol.asyncIterator] !== "function") throw new TypeError("OTLP body must be bytes or an async byte stream");
+  const chunks = []; let length = 0;
+  for await (const chunk of body) {
+    const bytes = asBytes(chunk); length += bytes.byteLength;
+    if (length > maxBytes) throw Object.assign(new RangeError("compressed OTLP body exceeds limit"), { code: "BODY_TOO_LARGE" });
+    chunks.push(bytes);
+  }
+  return Buffer.concat(chunks, length);
+}

package/server/otlp/wire-codec.mjs

@@ -0,0 +1,153 @@
+// Protobuf wire encoding and decoding driven by protobufjs reflection, with no
+// generated code. protobufjs compiles its encoders and decoders with `new
+// Function`, which a Cloudflare Worker refuses; parsing a schema into reflection
+// objects needs none, so this walks the parsed types directly.
+//
+// `decodeToObject` answers what `type.toObject(type.decode(bytes), { longs: String,
+// bytes: String, enums: Number, defaults: false, oneofs: false, json: true })`
+// answers: field names as parsed (camelCase), 64-bit integers as decimal strings,
+// bytes as base64, enums as numbers, only fields present on the wire.
+// `encodeFromObject` writes such an object back (a message's fields in field order).
+import protobuf from 'protobufjs';
+
+const VARINT = 0, FIXED64 = 1, BYTES = 2, FIXED32 = 5;
+const PACKABLE = new Set(['double', 'float', 'int32', 'uint32', 'sint32', 'fixed32', 'sfixed32', 'int64', 'uint64', 'sint64', 'fixed64', 'sfixed64', 'bool']);
+const utf8 = new TextDecoder('utf-8', { fatal: true });
+const utf8Encoder = new TextEncoder();
+
+class Reader {
+  constructor(bytes) { this.buf = bytes; this.pos = 0; this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength); }
+  varint() {
+    let result = 0n, shift = 0n;
+    for (;;) {
+      if (this.pos >= this.buf.length) throw new RangeError('protobuf varint runs past the end');
+      const byte = this.buf[this.pos++];
+      result |= BigInt(byte & 0x7f) << shift;
+      if (!(byte & 0x80)) return result;
+      shift += 7n;
+      if (shift > 63n) throw new RangeError('protobuf varint is longer than 10 bytes');
+    }
+  }
+  take(length) {
+    if (length < 0 || this.pos + length > this.buf.length) throw new RangeError('protobuf field runs past the end');
+    const out = this.buf.subarray(this.pos, this.pos + length); this.pos += length; return out;
+  }
+  fixed32() { const at = this.pos; this.take(4); return this.view.getUint32(at, true); }
+  fixed64() { const at = this.pos; this.take(8); return this.view.getBigUint64(at, true); }
+  skip(wire) {
+    if (wire === VARINT) this.varint();
+    else if (wire === FIXED64) this.take(8);
+    else if (wire === BYTES) this.take(Number(this.varint()));
+    else if (wire === FIXED32) this.take(4);
+    else throw new RangeError(`unsupported protobuf wire type ${wire}`);
+  }
+}
+
+const signed64 = (value) => BigInt.asIntN(64, value);
+const zigzag64 = (value) => (value >> 1n) ^ -(value & 1n);
+
+function scalar(type, wire, reader) {
+  switch (type) {
+    case 'string': return utf8.decode(reader.take(Number(reader.varint())));
+    case 'bytes': return Buffer.from(reader.take(Number(reader.varint()))).toString('base64');
+    case 'bool': return reader.varint() !== 0n;
+    case 'int32': return Number(BigInt.asIntN(32, reader.varint()));
+    case 'uint32': return Number(BigInt.asUintN(32, reader.varint()));
+    case 'sint32': return Number(zigzag64(reader.varint()));
+    case 'int64': return signed64(reader.varint()).toString();
+    case 'uint64': return BigInt.asUintN(64, reader.varint()).toString();
+    case 'sint64': return zigzag64(reader.varint()).toString();
+    case 'fixed32': return reader.fixed32();
+    case 'sfixed32': return reader.fixed32() | 0;
+    case 'float': { const at = reader.pos; reader.take(4); return reader.view.getFloat32(at, true); }
+    case 'fixed64': return reader.fixed64().toString();
+    case 'sfixed64': return signed64(reader.fixed64()).toString();
+    case 'double': { const at = reader.pos; reader.take(8); return reader.view.getFloat64(at, true); }
+    default: throw new TypeError(`unsupported protobuf scalar ${type} (wire ${wire})`);
+  }
+}
+
+function decodeMessage(type, reader, end) {
+  const out = {};
+  while (reader.pos < end) {
+    const tag = Number(reader.varint()), id = tag >>> 3, wire = tag & 7;
+    const field = type.fieldsById[id];
+    if (!field) { reader.skip(wire); continue; }
+    field.resolve();
+    const value = () => {
+      if (field.resolvedType instanceof protobuf.Type) { const length = Number(reader.varint()); return decodeMessage(field.resolvedType, reader, reader.pos + length); }
+      if (field.resolvedType instanceof protobuf.Enum) return Number(BigInt.asIntN(32, reader.varint()));
+      return scalar(field.type, wire, reader);
+    };
+    if (field.map) throw new TypeError(`protobuf map field ${field.fullName} is not supported`);
+    if (field.repeated) {
+      const list = out[field.name] ??= [];
+      if (wire === BYTES && (PACKABLE.has(field.type) || field.resolvedType instanceof protobuf.Enum)) {
+        const stop = reader.pos + Number(reader.varint());
+        while (reader.pos < stop) list.push(field.resolvedType instanceof protobuf.Enum ? Number(BigInt.asIntN(32, reader.varint())) : scalar(field.type, wire, reader));
+      } else list.push(value());
+    } else out[field.name] = value();
+  }
+  if (reader.pos !== end) throw new RangeError('protobuf message length disagrees with its fields');
+  return out;
+}
+
+export function decodeToObject(type, bytes) {
+  const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  return decodeMessage(type, new Reader(view), view.length);
+}
+
+class Writer {
+  constructor() { this.parts = []; this.length = 0; }
+  push(bytes) { this.parts.push(bytes); this.length += bytes.length; }
+  varint(value) {
+    let v = BigInt.asUintN(64, BigInt(value)); const out = [];
+    do { let byte = Number(v & 0x7fn); v >>= 7n; if (v) byte |= 0x80; out.push(byte); } while (v);
+    this.push(Uint8Array.from(out));
+  }
+  fixed(bytes, set) { const buffer = new Uint8Array(bytes); set(new DataView(buffer.buffer)); this.push(buffer); }
+  tag(id, wire) { this.varint((id << 3) | wire); }
+  finish() { const out = new Uint8Array(this.length); let at = 0; for (const part of this.parts) { out.set(part, at); at += part.length; } return out; }
+}
+
+const toBig = (value) => (typeof value === 'bigint' ? value : BigInt(typeof value === 'number' ? Math.trunc(value) : String(value)));
+
+function writeScalar(writer, type, value) {
+  switch (type) {
+    case 'string': { const bytes = utf8Encoder.encode(String(value)); writer.varint(bytes.length); writer.push(bytes); return; }
+    case 'bytes': { const bytes = typeof value === 'string' ? Buffer.from(value, 'base64') : Buffer.from(value); writer.varint(bytes.length); writer.push(bytes); return; }
+    case 'bool': writer.varint(value ? 1 : 0); return;
+    case 'int32': case 'uint32': case 'int64': case 'uint64': writer.varint(toBig(value)); return;
+    case 'sint32': case 'sint64': { const v = toBig(value); writer.varint((v << 1n) ^ (v >> 63n)); return; }
+    case 'fixed32': writer.fixed(4, (view) => view.setUint32(0, Number(value), true)); return;
+    case 'sfixed32': writer.fixed(4, (view) => view.setInt32(0, Number(value), true)); return;
+    case 'float': writer.fixed(4, (view) => view.setFloat32(0, Number(value), true)); return;
+    case 'fixed64': writer.fixed(8, (view) => view.setBigUint64(0, BigInt.asUintN(64, toBig(value)), true)); return;
+    case 'sfixed64': writer.fixed(8, (view) => view.setBigInt64(0, BigInt.asIntN(64, toBig(value)), true)); return;
+    case 'double': writer.fixed(8, (view) => view.setFloat64(0, Number(value), true)); return;
+    default: throw new TypeError(`unsupported protobuf scalar ${type}`);
+  }
+}
+
+const wireOf = (type) => (type === 'string' || type === 'bytes' ? BYTES : ['fixed64', 'sfixed64', 'double'].includes(type) ? FIXED64 : ['fixed32', 'sfixed32', 'float'].includes(type) ? FIXED32 : VARINT);
+
+function encodeMessage(type, value, writer) {
+  for (const field of type.fieldsArray) {
+    const item = value?.[field.name] ?? value?.[field.name.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`)];
+    if (item === undefined || item === null) continue;
+    field.resolve();
+    const one = (entry) => {
+      if (field.resolvedType instanceof protobuf.Type) { const inner = new Writer(); encodeMessage(field.resolvedType, entry, inner); const bytes = inner.finish(); writer.tag(field.id, BYTES); writer.varint(bytes.length); writer.push(bytes); return; }
+      if (field.resolvedType instanceof protobuf.Enum) { writer.tag(field.id, VARINT); writer.varint(typeof entry === 'string' ? field.resolvedType.values[entry] : entry); return; }
+      writer.tag(field.id, wireOf(field.type)); writeScalar(writer, field.type, entry);
+    };
+    if (field.repeated) { if (!Array.isArray(item)) throw new TypeError(`${field.fullName} must be an array`); for (const entry of item) one(entry); }
+    else one(item);
+  }
+}
+
+export function encodeFromObject(type, value) {
+  const writer = new Writer();
+  encodeMessage(type, value, writer);
+  return writer.finish();
+}