@fml-inc/panopticon 0.1.0

package/dist/chunk-XLTCUH5A.js

@@ -0,0 +1,1072 @@
+import {
+  insertOtelLogs,
+  insertOtelMetrics,
+  insertOtelSpans,
+  upsertSession
+} from "./chunk-BVOE7A2Z.js";
+import {
+  captureException
+} from "./chunk-CF4GPWLI.js";
+import {
+  log
+} from "./chunk-7Q3BJMLG.js";
+import {
+  refreshIfStale
+} from "./chunk-3TZAKV3M.js";
+import {
+  allTargets
+} from "./chunk-QVK6VGCV.js";
+import {
+  config
+} from "./chunk-K7YUPLES.js";
+
+// src/otlp/server.ts
+import http from "http";
+
+// src/otlp/proto.ts
+import protobuf from "protobufjs";
+var root = protobuf.Root.fromJSON({
+  nested: {
+    opentelemetry: {
+      nested: {
+        proto: {
+          nested: {
+            common: {
+              nested: {
+                v1: {
+                  nested: {
+                    AnyValue: {
+                      oneofs: {
+                        value: {
+                          oneof: [
+                            "stringValue",
+                            "boolValue",
+                            "intValue",
+                            "doubleValue",
+                            "arrayValue",
+                            "kvlistValue",
+                            "bytesValue"
+                          ]
+                        }
+                      },
+                      fields: {
+                        stringValue: { type: "string", id: 1 },
+                        boolValue: { type: "bool", id: 2 },
+                        intValue: { type: "int64", id: 3 },
+                        doubleValue: { type: "double", id: 4 },
+                        arrayValue: {
+                          type: "ArrayValue",
+                          id: 5
+                        },
+                        kvlistValue: {
+                          type: "KeyValueList",
+                          id: 6
+                        },
+                        bytesValue: { type: "bytes", id: 7 }
+                      }
+                    },
+                    ArrayValue: {
+                      fields: {
+                        values: {
+                          rule: "repeated",
+                          type: "AnyValue",
+                          id: 1
+                        }
+                      }
+                    },
+                    KeyValueList: {
+                      fields: {
+                        values: {
+                          rule: "repeated",
+                          type: "KeyValue",
+                          id: 1
+                        }
+                      }
+                    },
+                    KeyValue: {
+                      fields: {
+                        key: { type: "string", id: 1 },
+                        value: { type: "AnyValue", id: 2 }
+                      }
+                    },
+                    InstrumentationScope: {
+                      fields: {
+                        name: { type: "string", id: 1 },
+                        version: { type: "string", id: 2 },
+                        attributes: {
+                          rule: "repeated",
+                          type: "KeyValue",
+                          id: 3
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            resource: {
+              nested: {
+                v1: {
+                  nested: {
+                    Resource: {
+                      fields: {
+                        attributes: {
+                          rule: "repeated",
+                          type: "opentelemetry.proto.common.v1.KeyValue",
+                          id: 1
+                        },
+                        droppedAttributesCount: {
+                          type: "uint32",
+                          id: 2
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            logs: {
+              nested: {
+                v1: {
+                  nested: {
+                    ExportLogsServiceRequest: {
+                      fields: {
+                        resourceLogs: {
+                          rule: "repeated",
+                          type: "ResourceLogs",
+                          id: 1
+                        }
+                      }
+                    },
+                    ResourceLogs: {
+                      fields: {
+                        resource: {
+                          type: "opentelemetry.proto.resource.v1.Resource",
+                          id: 1
+                        },
+                        scopeLogs: {
+                          rule: "repeated",
+                          type: "ScopeLogs",
+                          id: 2
+                        },
+                        schemaUrl: { type: "string", id: 3 }
+                      }
+                    },
+                    ScopeLogs: {
+                      fields: {
+                        scope: {
+                          type: "opentelemetry.proto.common.v1.InstrumentationScope",
+                          id: 1
+                        },
+                        logRecords: {
+                          rule: "repeated",
+                          type: "LogRecord",
+                          id: 2
+                        },
+                        schemaUrl: { type: "string", id: 3 }
+                      }
+                    },
+                    LogRecord: {
+                      fields: {
+                        timeUnixNano: {
+                          type: "fixed64",
+                          id: 1
+                        },
+                        severityNumber: { type: "int32", id: 2 },
+                        severityText: { type: "string", id: 3 },
+                        body: {
+                          type: "opentelemetry.proto.common.v1.AnyValue",
+                          id: 5
+                        },
+                        attributes: {
+                          rule: "repeated",
+                          type: "opentelemetry.proto.common.v1.KeyValue",
+                          id: 6
+                        },
+                        droppedAttributesCount: {
+                          type: "uint32",
+                          id: 7
+                        },
+                        flags: { type: "fixed32", id: 8 },
+                        traceId: { type: "bytes", id: 9 },
+                        spanId: { type: "bytes", id: 10 },
+                        observedTimeUnixNano: {
+                          type: "fixed64",
+                          id: 11
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            metrics: {
+              nested: {
+                v1: {
+                  nested: {
+                    ExportMetricsServiceRequest: {
+                      fields: {
+                        resourceMetrics: {
+                          rule: "repeated",
+                          type: "ResourceMetrics",
+                          id: 1
+                        }
+                      }
+                    },
+                    ResourceMetrics: {
+                      fields: {
+                        resource: {
+                          type: "opentelemetry.proto.resource.v1.Resource",
+                          id: 1
+                        },
+                        scopeMetrics: {
+                          rule: "repeated",
+                          type: "ScopeMetrics",
+                          id: 2
+                        },
+                        schemaUrl: { type: "string", id: 3 }
+                      }
+                    },
+                    ScopeMetrics: {
+                      fields: {
+                        scope: {
+                          type: "opentelemetry.proto.common.v1.InstrumentationScope",
+                          id: 1
+                        },
+                        metrics: {
+                          rule: "repeated",
+                          type: "Metric",
+                          id: 2
+                        },
+                        schemaUrl: { type: "string", id: 3 }
+                      }
+                    },
+                    Metric: {
+                      oneofs: {
+                        data: {
+                          oneof: ["gauge", "sum", "histogram"]
+                        }
+                      },
+                      fields: {
+                        name: { type: "string", id: 1 },
+                        description: { type: "string", id: 2 },
+                        unit: { type: "string", id: 3 },
+                        gauge: { type: "Gauge", id: 5 },
+                        sum: { type: "Sum", id: 7 },
+                        histogram: { type: "Histogram", id: 9 }
+                      }
+                    },
+                    Gauge: {
+                      fields: {
+                        dataPoints: {
+                          rule: "repeated",
+                          type: "NumberDataPoint",
+                          id: 1
+                        }
+                      }
+                    },
+                    Sum: {
+                      fields: {
+                        dataPoints: {
+                          rule: "repeated",
+                          type: "NumberDataPoint",
+                          id: 1
+                        },
+                        aggregationTemporality: {
+                          type: "int32",
+                          id: 2
+                        },
+                        isMonotonic: { type: "bool", id: 3 }
+                      }
+                    },
+                    Histogram: {
+                      fields: {
+                        dataPoints: {
+                          rule: "repeated",
+                          type: "HistogramDataPoint",
+                          id: 1
+                        },
+                        aggregationTemporality: {
+                          type: "int32",
+                          id: 2
+                        }
+                      }
+                    },
+                    NumberDataPoint: {
+                      oneofs: {
+                        value: {
+                          oneof: ["asDouble", "asInt"]
+                        }
+                      },
+                      fields: {
+                        attributes: {
+                          rule: "repeated",
+                          type: "opentelemetry.proto.common.v1.KeyValue",
+                          id: 7
+                        },
+                        startTimeUnixNano: {
+                          type: "fixed64",
+                          id: 2
+                        },
+                        timeUnixNano: {
+                          type: "fixed64",
+                          id: 3
+                        },
+                        asDouble: { type: "double", id: 4 },
+                        asInt: { type: "sfixed64", id: 6 }
+                      }
+                    },
+                    HistogramDataPoint: {
+                      fields: {
+                        attributes: {
+                          rule: "repeated",
+                          type: "opentelemetry.proto.common.v1.KeyValue",
+                          id: 9
+                        },
+                        startTimeUnixNano: {
+                          type: "fixed64",
+                          id: 2
+                        },
+                        timeUnixNano: {
+                          type: "fixed64",
+                          id: 3
+                        },
+                        count: { type: "fixed64", id: 4 },
+                        sum: { type: "double", id: 5 },
+                        bucketCounts: {
+                          rule: "repeated",
+                          type: "fixed64",
+                          id: 6,
+                          options: { packed: true }
+                        },
+                        explicitBounds: {
+                          rule: "repeated",
+                          type: "double",
+                          id: 7,
+                          options: { packed: true }
+                        },
+                        min: { type: "double", id: 11 },
+                        max: { type: "double", id: 12 }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            trace: {
+              nested: {
+                v1: {
+                  nested: {
+                    Span: {
+                      fields: {
+                        traceId: { type: "bytes", id: 1 },
+                        spanId: { type: "bytes", id: 2 },
+                        traceState: { type: "string", id: 3 },
+                        parentSpanId: { type: "bytes", id: 4 },
+                        name: { type: "string", id: 5 },
+                        kind: { type: "int32", id: 6 },
+                        startTimeUnixNano: {
+                          type: "fixed64",
+                          id: 7
+                        },
+                        endTimeUnixNano: {
+                          type: "fixed64",
+                          id: 8
+                        },
+                        attributes: {
+                          rule: "repeated",
+                          type: "opentelemetry.proto.common.v1.KeyValue",
+                          id: 9
+                        },
+                        status: { type: "Status", id: 15 }
+                      }
+                    },
+                    Status: {
+                      fields: {
+                        message: { type: "string", id: 2 },
+                        code: { type: "int32", id: 3 }
+                      }
+                    },
+                    ResourceSpans: {
+                      fields: {
+                        resource: {
+                          type: "opentelemetry.proto.resource.v1.Resource",
+                          id: 1
+                        },
+                        scopeSpans: {
+                          rule: "repeated",
+                          type: "ScopeSpans",
+                          id: 2
+                        },
+                        schemaUrl: { type: "string", id: 3 }
+                      }
+                    },
+                    ScopeSpans: {
+                      fields: {
+                        scope: {
+                          type: "opentelemetry.proto.common.v1.InstrumentationScope",
+                          id: 1
+                        },
+                        spans: {
+                          rule: "repeated",
+                          type: "Span",
+                          id: 2
+                        },
+                        schemaUrl: { type: "string", id: 3 }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            collector: {
+              nested: {
+                logs: {
+                  nested: {
+                    v1: {
+                      nested: {
+                        ExportLogsServiceRequest: {
+                          fields: {
+                            resourceLogs: {
+                              rule: "repeated",
+                              type: "opentelemetry.proto.logs.v1.ResourceLogs",
+                              id: 1
+                            }
+                          }
+                        },
+                        ExportLogsServiceResponse: {
+                          fields: {}
+                        }
+                      }
+                    }
+                  }
+                },
+                metrics: {
+                  nested: {
+                    v1: {
+                      nested: {
+                        ExportMetricsServiceRequest: {
+                          fields: {
+                            resourceMetrics: {
+                              rule: "repeated",
+                              type: "opentelemetry.proto.metrics.v1.ResourceMetrics",
+                              id: 1
+                            }
+                          }
+                        },
+                        ExportMetricsServiceResponse: {
+                          fields: {}
+                        }
+                      }
+                    }
+                  }
+                },
+                trace: {
+                  nested: {
+                    v1: {
+                      nested: {
+                        ExportTracesServiceRequest: {
+                          fields: {
+                            resourceSpans: {
+                              rule: "repeated",
+                              type: "opentelemetry.proto.trace.v1.ResourceSpans",
+                              id: 1
+                            }
+                          }
+                        },
+                        ExportTracesServiceResponse: {
+                          fields: {}
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+});
+var ExportLogsServiceRequest = root.lookupType(
+  "opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest"
+);
+var ExportMetricsServiceRequest = root.lookupType(
+  "opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest"
+);
+var ExportLogsServiceResponse = root.lookupType(
+  "opentelemetry.proto.collector.logs.v1.ExportLogsServiceResponse"
+);
+var ExportMetricsServiceResponse = root.lookupType(
+  "opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceResponse"
+);
+var ExportTracesServiceRequest = root.lookupType(
+  "opentelemetry.proto.collector.trace.v1.ExportTracesServiceRequest"
+);
+var ExportTracesServiceResponse = root.lookupType(
+  "opentelemetry.proto.collector.trace.v1.ExportTracesServiceResponse"
+);
+function extractAnyValue(v) {
+  if (!v) return null;
+  if (v.stringValue != null) return v.stringValue;
+  if (v.intValue != null) {
+    return typeof v.intValue === "object" && v.intValue.toNumber ? v.intValue.toNumber() : Number(v.intValue);
+  }
+  if (v.doubleValue != null) return v.doubleValue;
+  if (v.boolValue != null) return v.boolValue;
+  if (v.bytesValue != null) return Buffer.from(v.bytesValue).toString("hex");
+  if (v.arrayValue?.values)
+    return v.arrayValue.values.map(extractAnyValue);
+  if (v.kvlistValue?.values) return attrsToMap(v.kvlistValue.values);
+  return null;
+}
+function attrsToMap(kvs) {
+  const out = {};
+  if (!kvs) return out;
+  for (const kv of kvs) {
+    if (kv.key) {
+      out[kv.key] = extractAnyValue(kv.value);
+    }
+  }
+  return out;
+}
+function longToNumber(val) {
+  if (val == null) return 0;
+  if (typeof val === "number") return val;
+  if (typeof val === "bigint") return Number(val);
+  if (typeof val.toNumber === "function") return val.toNumber();
+  return Number(val);
+}
+function bytesToHex(val) {
+  if (!val || val.length === 0) return "";
+  return Buffer.from(val).toString("hex");
+}
+
+// src/otlp/decode-logs.ts
+function decodeLogs(buf) {
+  const message = ExportLogsServiceRequest.decode(buf);
+  const rows = [];
+  for (const resourceLog of message.resourceLogs ?? []) {
+    const resourceAttrs = attrsToMap(resourceLog.resource?.attributes);
+    const resourceSessionId = resourceAttrs["session.id"] ?? resourceAttrs["conversation.id"] ?? resourceAttrs["service.instance.id"] ?? void 0;
+    for (const scopeLog of resourceLog.scopeLogs ?? []) {
+      for (const record of scopeLog.logRecords ?? []) {
+        const attrs = attrsToMap(record.attributes);
+        const rawBody = extractAnyValue(record.body);
+        const body = typeof rawBody === "string" ? rawBody : rawBody != null ? JSON.stringify(rawBody) : attrs["event.name"] ?? void 0;
+        let timestamp_ns = longToNumber(record.timeUnixNano);
+        if (!timestamp_ns && typeof attrs["event.timestamp"] === "string") {
+          timestamp_ns = new Date(attrs["event.timestamp"]).getTime() * 1e6;
+        }
+        rows.push({
+          timestamp_ns,
+          observed_timestamp_ns: longToNumber(record.observedTimeUnixNano) || void 0,
+          severity_number: record.severityNumber ?? void 0,
+          severity_text: record.severityText || void 0,
+          body,
+          attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+          resource_attributes: Object.keys(resourceAttrs).length > 0 ? resourceAttrs : void 0,
+          session_id: attrs["session.id"] ?? attrs["conversation.id"] ?? resourceSessionId,
+          prompt_id: attrs["prompt.id"] ?? attrs.prompt_id,
+          trace_id: bytesToHex(record.traceId) || void 0,
+          span_id: bytesToHex(record.spanId) || void 0
+        });
+      }
+    }
+  }
+  return rows;
+}
+
+// src/otlp/decode-metrics.ts
+function decodeMetrics(buf) {
+  const message = ExportMetricsServiceRequest.decode(buf);
+  const rows = [];
+  for (const resourceMetric of message.resourceMetrics ?? []) {
+    const resourceAttrs = attrsToMap(resourceMetric.resource?.attributes);
+    const resourceSessionId = resourceAttrs["session.id"] ?? resourceAttrs["conversation.id"] ?? resourceAttrs["service.instance.id"] ?? void 0;
+    for (const scopeMetric of resourceMetric.scopeMetrics ?? []) {
+      for (const metric of scopeMetric.metrics ?? []) {
+        const name = metric.name;
+        const unit = metric.unit || void 0;
+        let metricType;
+        let dataPoints = [];
+        if (metric.gauge) {
+          metricType = "gauge";
+          dataPoints = metric.gauge.dataPoints ?? [];
+        } else if (metric.sum) {
+          metricType = "sum";
+          dataPoints = metric.sum.dataPoints ?? [];
+        } else if (metric.histogram) {
+          metricType = "histogram";
+          for (const dp of metric.histogram.dataPoints ?? []) {
+            const attrs = attrsToMap(dp.attributes);
+            rows.push({
+              timestamp_ns: longToNumber(dp.timeUnixNano),
+              name,
+              value: dp.sum ?? 0,
+              metric_type: "histogram",
+              unit,
+              attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+              resource_attributes: Object.keys(resourceAttrs).length > 0 ? resourceAttrs : void 0,
+              session_id: attrs["session.id"] ?? attrs["conversation.id"] ?? resourceSessionId
+            });
+          }
+          continue;
+        }
+        for (const dp of dataPoints) {
+          const attrs = attrsToMap(dp.attributes);
+          const value = dp.asDouble != null ? dp.asDouble : dp.asInt != null ? longToNumber(dp.asInt) : 0;
+          rows.push({
+            timestamp_ns: longToNumber(dp.timeUnixNano),
+            name,
+            value,
+            metric_type: metricType,
+            unit,
+            attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+            resource_attributes: Object.keys(resourceAttrs).length > 0 ? resourceAttrs : void 0,
+            session_id: attrs["session.id"] ?? resourceSessionId
+          });
+        }
+      }
+    }
+  }
+  return rows;
+}
+
+// src/otlp/decode-traces.ts
+function extractConversationId(promptName) {
+  if (typeof promptName !== "string") return void 0;
+  const sep = promptName.indexOf("########");
+  if (sep === -1) return void 0;
+  const uuid = promptName.slice(0, sep);
+  if (uuid.length === 36 && uuid[8] === "-") return uuid;
+  return void 0;
+}
+function decodeTraces(buf) {
+  const message = ExportTracesServiceRequest.decode(buf);
+  const rows = [];
+  for (const resourceSpan of message.resourceSpans ?? []) {
+    const resourceAttrs = attrsToMap(resourceSpan.resource?.attributes);
+    const resourceSessionId = resourceAttrs["session.id"] ?? resourceAttrs["conversation.id"] ?? resourceAttrs["service.instance.id"] ?? void 0;
+    const traceConversation = /* @__PURE__ */ new Map();
+    for (const scopeSpan of resourceSpan.scopeSpans ?? []) {
+      for (const span of scopeSpan.spans ?? []) {
+        const attrs = attrsToMap(span.attributes);
+        const convId = extractConversationId(attrs["gen_ai.prompt.name"]);
+        if (convId) {
+          traceConversation.set(bytesToHex(span.traceId), convId);
+        }
+      }
+    }
+    for (const scopeSpan of resourceSpan.scopeSpans ?? []) {
+      for (const span of scopeSpan.spans ?? []) {
+        const attrs = attrsToMap(span.attributes);
+        const traceId = bytesToHex(span.traceId);
+        const conversationId = traceConversation.get(traceId);
+        rows.push({
+          trace_id: traceId,
+          span_id: bytesToHex(span.spanId),
+          parent_span_id: bytesToHex(span.parentSpanId) || void 0,
+          name: span.name ?? "",
+          kind: span.kind ?? void 0,
+          start_time_ns: longToNumber(span.startTimeUnixNano),
+          end_time_ns: longToNumber(span.endTimeUnixNano),
+          status_code: span.status?.code ?? void 0,
+          status_message: span.status?.message || void 0,
+          attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+          resource_attributes: Object.keys(resourceAttrs).length > 0 ? resourceAttrs : void 0,
+          session_id: conversationId ?? attrs["session.id"] ?? attrs["conversation.id"] ?? resourceSessionId
+        });
+      }
+    }
+  }
+  return rows;
+}
+
+// src/otlp/server.ts
+function collectBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+var _serviceNameMap = null;
+function serviceNameMap() {
+  if (!_serviceNameMap) {
+    _serviceNameMap = /* @__PURE__ */ new Map();
+    for (const t of allTargets()) {
+      if (t.otel?.serviceName) {
+        _serviceNameMap.set(t.otel.serviceName, t.id);
+      }
+    }
+  }
+  return _serviceNameMap;
+}
+function ensureSessionsFromOtel(rows) {
+  const sessions = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const sid = row.session_id;
+    if (!sid) continue;
+    if (!sessions.has(sid)) {
+      const serviceName = row.resource_attributes?.["service.name"];
+      const target = typeof serviceName === "string" ? serviceNameMap().get(serviceName) : void 0;
+      sessions.set(sid, {
+        target,
+        otelInput: 0,
+        otelOutput: 0,
+        otelCacheRead: 0,
+        otelCacheCreation: 0
+      });
+    }
+    const sess = sessions.get(sid);
+    if (row.timestamp_ns && row.timestamp_ns > 0) {
+      const ms = Math.floor(row.timestamp_ns / 1e6);
+      if (!sess.minTimestampMs || ms < sess.minTimestampMs) {
+        sess.minTimestampMs = ms;
+      }
+    }
+    if (!sess.model && row.attributes) {
+      const m = row.attributes.model ?? row.attributes["gen_ai.response.model"];
+      if (typeof m === "string") sess.model = m;
+    }
+    if (row.name && typeof row.value === "number" && row.name.includes("token")) {
+      const tokenType = row.attributes?.type ?? row.attributes?.["gen_ai.token.type"] ?? row.attributes?.token_type;
+      if (tokenType === "input") sess.otelInput += row.value;
+      else if (tokenType === "output") sess.otelOutput += row.value;
+      else if (tokenType === "cacheRead" || tokenType === "cache_read")
+        sess.otelCacheRead += row.value;
+      else if (tokenType === "cacheCreation" || tokenType === "cache_write")
+        sess.otelCacheCreation += row.value;
+    }
+  }
+  for (const [sessionId, sess] of sessions) {
+    if (!sess.target) continue;
+    upsertSession({
+      session_id: sessionId,
+      target: sess.target,
+      started_at_ms: sess.minTimestampMs,
+      model: sess.model,
+      otel_input_tokens: sess.otelInput || void 0,
+      otel_output_tokens: sess.otelOutput || void 0,
+      otel_cache_read_tokens: sess.otelCacheRead || void 0,
+      otel_cache_creation_tokens: sess.otelCacheCreation || void 0,
+      has_otel: 1
+    });
+  }
+}
+function isProtobuf(req) {
+  const ct = req.headers["content-type"] ?? "";
+  return ct.includes("application/x-protobuf") || ct.includes("application/protobuf");
+}
+function isJson(req) {
+  const ct = req.headers["content-type"] ?? "";
+  return ct.includes("application/json");
+}
+function detectSignal(url) {
+  if (url.includes("/logs")) return "logs";
+  if (url.includes("/metrics")) return "metrics";
+  if (url.includes("/traces")) return "traces";
+  return null;
+}
+function sniffSignalFromBody(body, protobuf2) {
+  if (protobuf2) {
+    try {
+      const rows = decodeLogs(body);
+      if (rows.length > 0) return "logs";
+    } catch {
+    }
+    try {
+      const rows = decodeMetrics(body);
+      if (rows.length > 0) return "metrics";
+    } catch {
+    }
+    try {
+      const rows = decodeTraces(body);
+      if (rows.length > 0) return "traces";
+    } catch {
+    }
+    return null;
+  }
+  try {
+    const data = JSON.parse(body.toString("utf-8"));
+    if (data.resourceLogs) return "logs";
+    if (data.resourceMetrics) return "metrics";
+    if (data.resourceSpans) return "traces";
+  } catch {
+  }
+  return null;
+}
+async function handleOtlpRequest(req, res) {
+  const url = req.url ?? "";
+  try {
+    const body = await collectBody(req);
+    let signal = detectSignal(url);
+    if (!signal && (url === "/" || url === "")) {
+      signal = sniffSignalFromBody(body, isProtobuf(req));
+    }
+    if (signal === "logs") {
+      if (isProtobuf(req)) {
+        const rows = decodeLogs(body);
+        if (rows.length > 0) {
+          insertOtelLogs(rows);
+          ensureSessionsFromOtel(rows);
+        }
+        const respBytes = ExportLogsServiceResponse.encode(
+          ExportLogsServiceResponse.create({})
+        ).finish();
+        res.writeHead(200, { "Content-Type": "application/x-protobuf" });
+        res.end(Buffer.from(respBytes));
+      } else if (isJson(req)) {
+        const data = JSON.parse(body.toString("utf-8"));
+        const rows = jsonLogsToRows(data);
+        if (rows.length > 0) {
+          insertOtelLogs(rows);
+          ensureSessionsFromOtel(rows);
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end("{}");
+      } else {
+        res.writeHead(415);
+        res.end();
+      }
+    } else if (signal === "metrics") {
+      refreshIfStale().catch(() => {
+      });
+      if (isProtobuf(req)) {
+        const rows = decodeMetrics(body);
+        if (rows.length > 0) {
+          insertOtelMetrics(rows);
+          ensureSessionsFromOtel(rows);
+        }
+        const respBytes = ExportMetricsServiceResponse.encode(
+          ExportMetricsServiceResponse.create({})
+        ).finish();
+        res.writeHead(200, { "Content-Type": "application/x-protobuf" });
+        res.end(Buffer.from(respBytes));
+      } else if (isJson(req)) {
+        const data = JSON.parse(body.toString("utf-8"));
+        const rows = jsonMetricsToRows(data);
+        if (rows.length > 0) {
+          insertOtelMetrics(rows);
+          ensureSessionsFromOtel(rows);
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end("{}");
+      } else {
+        res.writeHead(415);
+        res.end();
+      }
+    } else if (signal === "traces") {
+      if (isProtobuf(req)) {
+        const rows = decodeTraces(body);
+        if (rows.length > 0) {
+          insertOtelSpans(rows);
+          ensureSessionsFromOtel(
+            rows.map((r) => ({
+              session_id: r.session_id,
+              timestamp_ns: r.start_time_ns,
+              resource_attributes: r.resource_attributes,
+              attributes: r.attributes
+            }))
+          );
+        }
+        const respBytes = ExportTracesServiceResponse.encode(
+          ExportTracesServiceResponse.create({})
+        ).finish();
+        res.writeHead(200, { "Content-Type": "application/x-protobuf" });
+        res.end(Buffer.from(respBytes));
+      } else if (isJson(req)) {
+        const data = JSON.parse(body.toString("utf-8"));
+        const rows = jsonTracesToRows(data);
+        if (rows.length > 0) {
+          insertOtelSpans(rows);
+          ensureSessionsFromOtel(
+            rows.map((r) => ({
+              session_id: r.session_id,
+              timestamp_ns: r.start_time_ns,
+              resource_attributes: r.resource_attributes,
+              attributes: r.attributes
+            }))
+          );
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end("{}");
+      } else {
+        res.writeHead(415);
+        res.end();
+      }
+    } else {
+      res.writeHead(404);
+      res.end();
+    }
+  } catch (err) {
+    log.otlp.error("OTLP handler error:", err);
+    captureException(err, { component: "otlp", url });
+    if (!res.headersSent) {
+      res.writeHead(500);
+      res.end();
+    }
+  }
+}
+function createOtlpServer() {
+  return http.createServer(async (req, res) => {
+    const url = req.url ?? "";
+    const method = req.method ?? "";
+    if (url === "/health" && method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok" }));
+      return;
+    }
+    if (method !== "POST") {
+      res.writeHead(405);
+      res.end();
+      return;
+    }
+    await handleOtlpRequest(req, res);
+  });
+}
+function jsonLogsToRows(data) {
+  const rows = [];
+  for (const rl of data.resourceLogs ?? []) {
+    const resourceAttrs = kvListToMap(rl.resource?.attributes);
+    const resourceSessionId = resourceAttrs["session.id"] ?? resourceAttrs["conversation.id"] ?? resourceAttrs["service.instance.id"];
+    for (const sl of rl.scopeLogs ?? []) {
+      for (const lr of sl.logRecords ?? []) {
+        const attrs = kvListToMap(lr.attributes);
+        const rawBody = extractJsonAnyValue(lr.body);
+        const body = rawBody ?? attrs["event.name"] ?? void 0;
+        let timestamp_ns = parseInt(lr.timeUnixNano ?? "0", 10);
+        if (!timestamp_ns && typeof attrs["event.timestamp"] === "string") {
+          timestamp_ns = new Date(attrs["event.timestamp"]).getTime() * 1e6;
+        }
+        rows.push({
+          timestamp_ns,
+          observed_timestamp_ns: lr.observedTimeUnixNano ? parseInt(lr.observedTimeUnixNano, 10) : void 0,
+          severity_number: lr.severityNumber,
+          severity_text: lr.severityText,
+          body,
+          attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+          resource_attributes: Object.keys(resourceAttrs).length > 0 ? resourceAttrs : void 0,
+          session_id: attrs["session.id"] ?? attrs["conversation.id"] ?? resourceSessionId,
+          prompt_id: attrs["prompt.id"] ?? attrs.prompt_id,
+          trace_id: lr.traceId,
+          span_id: lr.spanId
+        });
+      }
+    }
+  }
+  return rows;
+}
+function jsonMetricsToRows(data) {
+  const rows = [];
+  for (const rm of data.resourceMetrics ?? []) {
+    const resourceAttrs = kvListToMap(rm.resource?.attributes);
+    const resourceSessionId = resourceAttrs["session.id"] ?? resourceAttrs["conversation.id"] ?? resourceAttrs["service.instance.id"];
+    for (const sm of rm.scopeMetrics ?? []) {
+      for (const m of sm.metrics ?? []) {
+        const dps = m.gauge?.dataPoints ?? m.sum?.dataPoints ?? m.histogram?.dataPoints ?? [];
+        const metricType = m.gauge ? "gauge" : m.sum ? "sum" : m.histogram ? "histogram" : void 0;
+        for (const dp of dps) {
+          const attrs = kvListToMap(dp.attributes);
+          const value = dp.asDouble ?? dp.asInt ?? dp.sum ?? dp.count ?? 0;
+          rows.push({
+            timestamp_ns: parseInt(dp.timeUnixNano ?? "0", 10),
+            name: m.name,
+            value: Number(value),
+            metric_type: metricType,
+            unit: m.unit || void 0,
+            attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+            resource_attributes: Object.keys(resourceAttrs).length > 0 ? resourceAttrs : void 0,
+            session_id: attrs["session.id"] ?? attrs["conversation.id"] ?? resourceSessionId
+          });
+        }
+      }
+    }
+  }
+  return rows;
+}
+function extractJsonConversationId(promptName) {
+  if (typeof promptName !== "string") return void 0;
+  const sep = promptName.indexOf("########");
+  if (sep === -1) return void 0;
+  const uuid = promptName.slice(0, sep);
+  if (uuid.length === 36 && uuid[8] === "-") return uuid;
+  return void 0;
+}
+function jsonTracesToRows(data) {
+  const rows = [];
+  for (const rs of data.resourceSpans ?? []) {
+    const resourceAttrs = kvListToMap(rs.resource?.attributes);
+    const resourceSessionId = resourceAttrs["session.id"] ?? resourceAttrs["conversation.id"] ?? resourceAttrs["service.instance.id"];
+    const traceConversation = /* @__PURE__ */ new Map();
+    for (const ss of rs.scopeSpans ?? []) {
+      for (const span of ss.spans ?? []) {
+        const attrs = kvListToMap(span.attributes);
+        const convId = extractJsonConversationId(attrs["gen_ai.prompt.name"]);
+        if (convId && span.traceId) {
+          traceConversation.set(span.traceId, convId);
+        }
+      }
+    }
+    for (const ss of rs.scopeSpans ?? []) {
+      for (const span of ss.spans ?? []) {
+        const attrs = kvListToMap(span.attributes);
+        const conversationId = traceConversation.get(span.traceId ?? "");
+        rows.push({
+          trace_id: span.traceId ?? "",
+          span_id: span.spanId ?? "",
+          parent_span_id: span.parentSpanId || void 0,
+          name: span.name ?? "",
+          kind: span.kind ?? void 0,
+          start_time_ns: parseInt(span.startTimeUnixNano ?? "0", 10),
+          end_time_ns: parseInt(span.endTimeUnixNano ?? "0", 10),
+          status_code: span.status?.code ?? void 0,
+          status_message: span.status?.message || void 0,
+          attributes: Object.keys(attrs).length > 0 ? attrs : void 0,
+          resource_attributes: Object.keys(resourceAttrs).length > 0 ? resourceAttrs : void 0,
+          session_id: conversationId ?? attrs["session.id"] ?? attrs["conversation.id"] ?? resourceSessionId
+        });
+      }
+    }
+  }
+  return rows;
+}
+function kvListToMap(kvs) {
+  const out = {};
+  if (!kvs) return out;
+  for (const kv of kvs) {
+    out[kv.key] = extractJsonAnyValue(kv.value);
+  }
+  return out;
+}
+function extractJsonAnyValue(v) {
+  if (!v) return null;
+  if (v.stringValue !== void 0) return v.stringValue;
+  if (v.intValue !== void 0) return Number(v.intValue);
+  if (v.doubleValue !== void 0) return v.doubleValue;
+  if (v.boolValue !== void 0) return v.boolValue;
+  return JSON.stringify(v);
+}
+var entryScript = process.argv[1]?.replaceAll("\\", "/") ?? "";
+if (entryScript.endsWith("/otlp/server.js") || entryScript.endsWith("/otlp/server.ts")) {
+  const server = createOtlpServer();
+  server.listen(config.otlpPort, config.otlpHost, () => {
+    log.otlp.info(`Listening on ${config.otlpHost}:${config.otlpPort}`);
+  });
+  const shutdown = () => {
+    server.close();
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  process.on("SIGHUP", shutdown);
+}
+
+export {
+  handleOtlpRequest,
+  createOtlpServer
+};
+//# sourceMappingURL=chunk-XLTCUH5A.js.map