@mastra/duckdb 1.0.1 → 1.1.0-alpha.0

package/dist/observability-W2QRBK56.cjs

@@ -0,0 +1,1677 @@
+'use strict';
+
+var chunkS2AWBPTS_cjs = require('./chunk-S2AWBPTS.cjs');
+var storage = require('@mastra/core/storage');
+var observability = require('@mastra/core/observability');
+var utils = require('@mastra/core/utils');
+
+// src/storage/domains/observability/ddl.ts
+var SPAN_EVENTS_DDL = `
+CREATE TABLE IF NOT EXISTS span_events (
+  -- Event metadata
+  eventType VARCHAR NOT NULL,
+  timestamp TIMESTAMP NOT NULL,
+
+  -- IDs
+  traceId VARCHAR NOT NULL,
+  spanId VARCHAR NOT NULL,
+  parentSpanId VARCHAR,
+  experimentId VARCHAR,
+
+  -- Entity
+  entityType VARCHAR,
+  entityId VARCHAR,
+  entityName VARCHAR,
+
+  -- Context
+  userId VARCHAR,
+  organizationId VARCHAR,
+  resourceId VARCHAR,
+  runId VARCHAR,
+  sessionId VARCHAR,
+  threadId VARCHAR,
+  requestId VARCHAR,
+  environment VARCHAR,
+  source VARCHAR,
+  serviceName VARCHAR,
+  requestContext JSON,
+
+  -- Span-specific scalars
+  name VARCHAR,
+  spanType VARCHAR,
+  isEvent BOOLEAN,
+  endedAt TIMESTAMP,
+
+  -- JSON fields
+  attributes JSON,
+  metadata JSON,
+  tags JSON,
+  scope JSON,
+  links JSON,
+  input JSON,
+  output JSON,
+  error JSON
+)`;
+var METRIC_EVENTS_DDL = `
+CREATE TABLE IF NOT EXISTS metric_events (
+  -- Event metadata
+  timestamp TIMESTAMP NOT NULL,
+
+  -- IDs
+  traceId VARCHAR,
+  spanId VARCHAR,
+  experimentId VARCHAR,
+
+  -- Entity hierarchy
+  entityType VARCHAR,
+  entityId VARCHAR,
+  entityName VARCHAR,
+  parentEntityType VARCHAR,
+  parentEntityId VARCHAR,
+  parentEntityName VARCHAR,
+  rootEntityType VARCHAR,
+  rootEntityId VARCHAR,
+  rootEntityName VARCHAR,
+
+  -- Context
+  userId VARCHAR,
+  organizationId VARCHAR,
+  resourceId VARCHAR,
+  runId VARCHAR,
+  sessionId VARCHAR,
+  threadId VARCHAR,
+  requestId VARCHAR,
+  environment VARCHAR,
+  source VARCHAR,
+  serviceName VARCHAR,
+
+  -- Metric-specific scalars
+  name VARCHAR NOT NULL,
+  value DOUBLE NOT NULL,
+  provider VARCHAR,
+  model VARCHAR,
+  estimatedCost DOUBLE,
+  costUnit VARCHAR,
+
+  -- JSON fields
+  tags JSON,
+  labels JSON,
+  costMetadata JSON,
+  metadata JSON,
+  scope JSON
+)`;
+var LOG_EVENTS_DDL = `
+CREATE TABLE IF NOT EXISTS log_events (
+  -- Event metadata
+  timestamp TIMESTAMP NOT NULL,
+
+  -- IDs
+  traceId VARCHAR,
+  spanId VARCHAR,
+  experimentId VARCHAR,
+
+  -- Entity hierarchy
+  entityType VARCHAR,
+  entityId VARCHAR,
+  entityName VARCHAR,
+  parentEntityType VARCHAR,
+  parentEntityId VARCHAR,
+  parentEntityName VARCHAR,
+  rootEntityType VARCHAR,
+  rootEntityId VARCHAR,
+  rootEntityName VARCHAR,
+
+  -- Context
+  userId VARCHAR,
+  organizationId VARCHAR,
+  resourceId VARCHAR,
+  runId VARCHAR,
+  sessionId VARCHAR,
+  threadId VARCHAR,
+  requestId VARCHAR,
+  environment VARCHAR,
+  source VARCHAR,
+  serviceName VARCHAR,
+
+  -- Log-specific scalars
+  level VARCHAR NOT NULL,
+  message VARCHAR NOT NULL,
+
+  -- JSON fields
+  data JSON,
+  tags JSON,
+  metadata JSON,
+  scope JSON
+)`;
+var SCORE_EVENTS_DDL = `
+CREATE TABLE IF NOT EXISTS score_events (
+  -- Event metadata
+  timestamp TIMESTAMP NOT NULL,
+
+  -- IDs
+  traceId VARCHAR NOT NULL,
+  spanId VARCHAR,
+  experimentId VARCHAR,
+  scoreTraceId VARCHAR,
+
+  -- Score-specific scalars
+  scorerId VARCHAR NOT NULL,
+  scorerVersion VARCHAR,
+  source VARCHAR,
+  score DOUBLE NOT NULL,
+  reason VARCHAR,
+
+  -- JSON fields
+  metadata JSON
+)`;
+var FEEDBACK_EVENTS_DDL = `
+CREATE TABLE IF NOT EXISTS feedback_events (
+  -- Event metadata
+  timestamp TIMESTAMP NOT NULL,
+
+  -- IDs
+  traceId VARCHAR NOT NULL,
+  spanId VARCHAR,
+  experimentId VARCHAR,
+  userId VARCHAR,
+  sourceId VARCHAR,
+
+  -- Feedback-specific scalars
+  source VARCHAR NOT NULL,
+  feedbackType VARCHAR NOT NULL,
+  value VARCHAR NOT NULL,
+  comment VARCHAR,
+
+  -- JSON fields
+  metadata JSON
+)`;
+var ALL_DDL = [SPAN_EVENTS_DDL, METRIC_EVENTS_DDL, LOG_EVENTS_DDL, SCORE_EVENTS_DDL, FEEDBACK_EVENTS_DDL];
+function unionDistinctQueries(selects, orderBy) {
+  return `${selects.join("\nUNION\n")}
+ORDER BY ${orderBy}`;
+}
+async function getEntityTypes(db, _args) {
+  const rows = await db.query(
+    unionDistinctQueries(
+      [
+        `SELECT entityType FROM span_events WHERE entityType IS NOT NULL`,
+        `SELECT entityType FROM metric_events WHERE entityType IS NOT NULL`,
+        `SELECT entityType FROM log_events WHERE entityType IS NOT NULL`
+      ],
+      "entityType"
+    )
+  );
+  const validTypes = new Set(Object.values(observability.EntityType));
+  const typeSet = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (row.entityType && validTypes.has(row.entityType)) {
+      typeSet.add(row.entityType);
+    }
+  }
+  return { entityTypes: Array.from(typeSet).sort() };
+}
+async function getEntityNames(db, args) {
+  const buildSelect = (table) => {
+    const conditions = [`entityName IS NOT NULL`];
+    if (args.entityType) {
+      conditions.push(`entityType = ?`);
+    }
+    return `SELECT entityName FROM ${table} WHERE ${conditions.join(" AND ")}`;
+  };
+  const params = args.entityType ? [args.entityType, args.entityType, args.entityType] : [];
+  const rows = await db.query(
+    unionDistinctQueries(
+      [buildSelect("span_events"), buildSelect("metric_events"), buildSelect("log_events")],
+      "entityName"
+    ),
+    params
+  );
+  return { names: rows.map((r) => r.entityName) };
+}
+async function getServiceNames(db, _args) {
+  const rows = await db.query(
+    unionDistinctQueries(
+      [
+        `SELECT serviceName FROM span_events WHERE serviceName IS NOT NULL`,
+        `SELECT serviceName FROM metric_events WHERE serviceName IS NOT NULL`,
+        `SELECT serviceName FROM log_events WHERE serviceName IS NOT NULL`
+      ],
+      "serviceName"
+    )
+  );
+  return { serviceNames: rows.map((r) => r.serviceName) };
+}
+async function getEnvironments(db, _args) {
+  const rows = await db.query(
+    unionDistinctQueries(
+      [
+        `SELECT environment FROM span_events WHERE environment IS NOT NULL`,
+        `SELECT environment FROM metric_events WHERE environment IS NOT NULL`,
+        `SELECT environment FROM log_events WHERE environment IS NOT NULL`
+      ],
+      "environment"
+    )
+  );
+  return { environments: rows.map((r) => r.environment) };
+}
+async function getTags(db, args) {
+  const buildSelect = (table) => {
+    const conditions = [`tags IS NOT NULL`];
+    if (args.entityType) {
+      conditions.push(`entityType = ?`);
+    }
+    return `SELECT unnest(CAST(tags AS VARCHAR[])) AS tag FROM ${table} WHERE ${conditions.join(" AND ")}`;
+  };
+  const params = args.entityType ? [args.entityType, args.entityType, args.entityType] : [];
+  const rows = await db.query(
+    unionDistinctQueries([buildSelect("span_events"), buildSelect("metric_events"), buildSelect("log_events")], "tag"),
+    params
+  );
+  return { tags: rows.map((r) => r.tag) };
+}
+function buildJsonPath(key) {
+  try {
+    return `$.${utils.parseFieldKey(key)}`;
+  } catch {
+    const escaped = key.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return `$."${escaped}"`;
+  }
+}
+function normalizeJsonFilterValue(value) {
+  if (value === void 0) return null;
+  if (typeof value === "string") return value;
+  const json = JSON.stringify(value);
+  return json ?? null;
+}
+function sanitizeColumn(column) {
+  return utils.parseFieldKey(column);
+}
+function buildWhereClause(filters, fieldMappings) {
+  if (!filters) return { clause: "", params: [] };
+  const conditions = [];
+  const params = [];
+  for (const [key, value] of Object.entries(filters)) {
+    if (value === void 0 || value === null) continue;
+    const column = sanitizeColumn(key);
+    if (key === "timestamp" || key === "startedAt" || key === "endedAt") {
+      const dateRange = value;
+      if (dateRange.start) {
+        const op = dateRange.startExclusive ? ">" : ">=";
+        conditions.push(`${column} ${op} ?`);
+        params.push(dateRange.start);
+      }
+      if (dateRange.end) {
+        const op = dateRange.endExclusive ? "<" : "<=";
+        conditions.push(`${column} ${op} ?`);
+        params.push(dateRange.end);
+      }
+      continue;
+    }
+    if (key === "labels") {
+      const labelsObj = value;
+      for (const [labelKey, labelValue] of Object.entries(labelsObj)) {
+        conditions.push(`json_extract_string(${column}, ?) = ?`);
+        params.push(buildJsonPath(labelKey), labelValue);
+      }
+      continue;
+    }
+    if (key === "tags") {
+      const tags = value;
+      for (const tag of tags) {
+        conditions.push(`list_contains(CAST(${column} AS VARCHAR[]), ?)`);
+        params.push(tag);
+      }
+      continue;
+    }
+    if (key === "status") {
+      const status = value;
+      if (status === "error") {
+        conditions.push(`error IS NOT NULL`);
+      } else if (status === "running") {
+        conditions.push(`endedAt IS NULL AND error IS NULL`);
+      } else if (status === "success") {
+        conditions.push(`endedAt IS NOT NULL AND error IS NULL`);
+      }
+      continue;
+    }
+    if (key === "hasChildError") {
+      continue;
+    }
+    if (key === "metadata" || key === "scope") {
+      const jsonObj = value;
+      for (const [jsonKey, jsonValue] of Object.entries(jsonObj)) {
+        const normalized = normalizeJsonFilterValue(jsonValue);
+        if (normalized === null) continue;
+        conditions.push(`json_extract_string(${column}, ?) = ?`);
+        params.push(buildJsonPath(jsonKey), normalized);
+      }
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) continue;
+      const placeholders = value.map(() => "?").join(", ");
+      conditions.push(`${column} IN (${placeholders})`);
+      params.push(...value);
+      continue;
+    }
+    conditions.push(`${column} = ?`);
+    params.push(value);
+  }
+  const clause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  return { clause, params };
+}
+function buildOrderByClause(orderBy) {
+  if (!orderBy) return "";
+  const dir = orderBy.direction.toUpperCase();
+  if (dir !== "ASC" && dir !== "DESC") {
+    throw new Error(`Invalid sort direction: ${orderBy.direction}`);
+  }
+  const field = utils.parseFieldKey(orderBy.field);
+  return `ORDER BY ${field} ${dir}`;
+}
+function buildPaginationClause(pagination) {
+  if (!pagination) return { clause: "", params: [] };
+  if (!Number.isInteger(pagination.page) || pagination.page < 0) {
+    throw new Error(`Invalid page: ${pagination.page}`);
+  }
+  if (!Number.isInteger(pagination.perPage) || pagination.perPage <= 0) {
+    throw new Error(`Invalid perPage: ${pagination.perPage}`);
+  }
+  const offset = pagination.page * pagination.perPage;
+  return {
+    clause: `LIMIT ? OFFSET ?`,
+    params: [pagination.perPage, offset]
+  };
+}
+
+// src/storage/domains/observability/helpers.ts
+var v = chunkS2AWBPTS_cjs.DuckDBConnection.sqlValue;
+function jsonV(val) {
+  if (val === null || val === void 0) return "NULL";
+  return chunkS2AWBPTS_cjs.DuckDBConnection.sqlValue(JSON.stringify(val));
+}
+function toDate(val) {
+  if (val === null || val === void 0) {
+    throw new Error("Expected date value but received null/undefined");
+  }
+  const date = val instanceof Date ? val : new Date(String(val));
+  if (Number.isNaN(date.getTime())) {
+    throw new Error("Expected valid date but received invalid date");
+  }
+  return date;
+}
+function toDateOrNull(val) {
+  if (val === null || val === void 0) return null;
+  return val instanceof Date ? val : new Date(String(val));
+}
+function parseJson(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function parseJsonArray(value) {
+  if (value === null || value === void 0) return null;
+  const parsed = parseJson(value);
+  return Array.isArray(parsed) ? parsed : null;
+}
+
+// src/storage/domains/observability/feedback.ts
+async function createFeedback(db, args) {
+  const f = args.feedback;
+  await db.execute(
+    `INSERT INTO feedback_events (timestamp, traceId, spanId, experimentId, userId, sourceId, source, feedbackType, value, comment, metadata)
+     VALUES (${[
+      v(f.timestamp),
+      v(f.traceId),
+      v(f.spanId ?? null),
+      v(f.experimentId ?? null),
+      v(f.userId ?? null),
+      v(f.sourceId ?? null),
+      v(f.source),
+      v(f.feedbackType),
+      v(String(f.value)),
+      v(f.comment ?? null),
+      jsonV(f.metadata)
+    ].join(", ")})`
+  );
+}
+async function batchCreateFeedback(db, args) {
+  if (args.feedbacks.length === 0) return;
+  const tuples = args.feedbacks.map(
+    (f) => `(${[
+      v(f.timestamp),
+      v(f.traceId),
+      v(f.spanId ?? null),
+      v(f.experimentId ?? null),
+      v(f.userId ?? null),
+      v(f.sourceId ?? null),
+      v(f.source),
+      v(f.feedbackType),
+      v(String(f.value)),
+      v(f.comment ?? null),
+      jsonV(f.metadata)
+    ].join(", ")})`
+  );
+  await db.execute(
+    `INSERT INTO feedback_events (timestamp, traceId, spanId, experimentId, userId, sourceId, source, feedbackType, value, comment, metadata)
+     VALUES ${tuples.join(",\n       ")}`
+  );
+}
+async function listFeedback(db, args) {
+  const filters = args.filters ?? {};
+  const page = Number(args.pagination?.page ?? 0);
+  const perPage = Number(args.pagination?.perPage ?? 10);
+  const orderBy = { field: args.orderBy?.field ?? "timestamp", direction: args.orderBy?.direction ?? "DESC" };
+  const { clause: filterClause, params: filterParams } = buildWhereClause(filters);
+  const orderByClause = buildOrderByClause(orderBy);
+  const { clause: paginationClause, params: paginationParams } = buildPaginationClause({ page, perPage });
+  const countResult = await db.query(
+    `SELECT COUNT(*) as total FROM feedback_events ${filterClause}`,
+    filterParams
+  );
+  const total = Number(countResult[0]?.total ?? 0);
+  const rows = await db.query(`SELECT * FROM feedback_events ${filterClause} ${orderByClause} ${paginationClause}`, [
+    ...filterParams,
+    ...paginationParams
+  ]);
+  const feedback = rows.map((row) => {
+    const r = row;
+    const rawValue = r.value;
+    let value = rawValue;
+    const numValue = Number(rawValue);
+    if (!isNaN(numValue)) value = numValue;
+    return {
+      timestamp: toDate(r.timestamp),
+      traceId: r.traceId,
+      spanId: r.spanId ?? null,
+      experimentId: r.experimentId ?? null,
+      userId: r.userId ?? null,
+      sourceId: r.sourceId ?? null,
+      source: r.source,
+      feedbackType: r.feedbackType,
+      value,
+      comment: r.comment ?? null,
+      metadata: parseJson(r.metadata)
+    };
+  });
+  return {
+    pagination: { total, page, perPage, hasMore: (page + 1) * perPage < total },
+    feedback
+  };
+}
+
+// src/storage/domains/observability/logs.ts
+var COLUMNS = [
+  "timestamp",
+  "level",
+  "message",
+  "data",
+  "traceId",
+  "spanId",
+  "entityType",
+  "entityId",
+  "entityName",
+  "parentEntityType",
+  "parentEntityId",
+  "parentEntityName",
+  "rootEntityType",
+  "rootEntityId",
+  "rootEntityName",
+  "userId",
+  "organizationId",
+  "resourceId",
+  "runId",
+  "sessionId",
+  "threadId",
+  "requestId",
+  "environment",
+  "source",
+  "serviceName",
+  "experimentId",
+  "tags",
+  "metadata",
+  "scope"
+];
+var COLUMNS_SQL = COLUMNS.join(", ");
+function rowToLogRecord(row) {
+  return {
+    timestamp: toDate(row.timestamp),
+    level: row.level,
+    message: row.message,
+    data: parseJson(row.data),
+    traceId: row.traceId ?? null,
+    spanId: row.spanId ?? null,
+    entityType: row.entityType ?? null,
+    entityId: row.entityId ?? null,
+    entityName: row.entityName ?? null,
+    parentEntityType: row.parentEntityType ?? null,
+    parentEntityId: row.parentEntityId ?? null,
+    parentEntityName: row.parentEntityName ?? null,
+    rootEntityType: row.rootEntityType ?? null,
+    rootEntityId: row.rootEntityId ?? null,
+    rootEntityName: row.rootEntityName ?? null,
+    userId: row.userId ?? null,
+    organizationId: row.organizationId ?? null,
+    resourceId: row.resourceId ?? null,
+    runId: row.runId ?? null,
+    sessionId: row.sessionId ?? null,
+    threadId: row.threadId ?? null,
+    requestId: row.requestId ?? null,
+    environment: row.environment ?? null,
+    source: row.source ?? null,
+    serviceName: row.serviceName ?? null,
+    experimentId: row.experimentId ?? null,
+    tags: parseJsonArray(row.tags),
+    metadata: parseJson(row.metadata),
+    scope: parseJson(row.scope)
+  };
+}
+async function batchCreateLogs(db, args) {
+  if (args.logs.length === 0) return;
+  const tuples = args.logs.map((log) => {
+    return `(${[
+      v(log.timestamp),
+      v(log.level),
+      v(log.message),
+      jsonV(log.data),
+      v(log.traceId ?? null),
+      v(log.spanId ?? null),
+      v(log.entityType ?? null),
+      v(log.entityId ?? null),
+      v(log.entityName ?? null),
+      v(log.parentEntityType ?? null),
+      v(log.parentEntityId ?? null),
+      v(log.parentEntityName ?? null),
+      v(log.rootEntityType ?? null),
+      v(log.rootEntityId ?? null),
+      v(log.rootEntityName ?? null),
+      v(log.userId ?? null),
+      v(log.organizationId ?? null),
+      v(log.resourceId ?? null),
+      v(log.runId ?? null),
+      v(log.sessionId ?? null),
+      v(log.threadId ?? null),
+      v(log.requestId ?? null),
+      v(log.environment ?? null),
+      v(log.source ?? null),
+      v(log.serviceName ?? null),
+      v(log.experimentId ?? null),
+      jsonV(log.tags),
+      jsonV(log.metadata),
+      jsonV(log.scope)
+    ].join(", ")})`;
+  });
+  await db.execute(`INSERT INTO log_events (${COLUMNS_SQL}) VALUES ${tuples.join(",\n")}`);
+}
+async function listLogs(db, args) {
+  const filters = args.filters ?? {};
+  const page = Number(args.pagination?.page ?? 0);
+  const perPage = Number(args.pagination?.perPage ?? 10);
+  const orderBy = { field: args.orderBy?.field ?? "timestamp", direction: args.orderBy?.direction ?? "DESC" };
+  const { clause: filterClause, params: filterParams } = buildWhereClause(filters);
+  const orderByClause = buildOrderByClause(orderBy);
+  const { clause: paginationClause, params: paginationParams } = buildPaginationClause({ page, perPage });
+  const countResult = await db.query(
+    `SELECT COUNT(*) as total FROM log_events ${filterClause}`,
+    filterParams
+  );
+  const total = Number(countResult[0]?.total ?? 0);
+  const rows = await db.query(`SELECT * FROM log_events ${filterClause} ${orderByClause} ${paginationClause}`, [
+    ...filterParams,
+    ...paginationParams
+  ]);
+  const logs = rows.map((row) => rowToLogRecord(row));
+  return {
+    pagination: { total, page, perPage, hasMore: (page + 1) * perPage < total },
+    logs
+  };
+}
+function getAggregationSql(aggregation, measure = "value") {
+  switch (aggregation) {
+    case "sum":
+      return `SUM(${measure})`;
+    case "avg":
+      return `AVG(${measure})`;
+    case "min":
+      return `MIN(${measure})`;
+    case "max":
+      return `MAX(${measure})`;
+    case "count":
+      return `CAST(COUNT(${measure}) AS DOUBLE)`;
+    case "last":
+      return `arg_max(${measure}, timestamp)`;
+    default:
+      return `SUM(${measure})`;
+  }
+}
+function getIntervalSql(interval) {
+  switch (interval) {
+    case "1m":
+      return "1 minute";
+    case "5m":
+      return "5 minutes";
+    case "15m":
+      return "15 minutes";
+    case "1h":
+      return "1 hour";
+    case "1d":
+      return "1 day";
+    default:
+      return "1 hour";
+  }
+}
+function buildMetricNameFilter(name) {
+  if (Array.isArray(name)) {
+    const placeholders = name.map(() => "?").join(", ");
+    return { clause: `name IN (${placeholders})`, params: name };
+  }
+  return { clause: `name = ?`, params: [name] };
+}
+var METRIC_COLUMNS = [
+  "timestamp",
+  "name",
+  "value",
+  "traceId",
+  "spanId",
+  "entityType",
+  "entityId",
+  "entityName",
+  "parentEntityType",
+  "parentEntityId",
+  "parentEntityName",
+  "rootEntityType",
+  "rootEntityId",
+  "rootEntityName",
+  "userId",
+  "organizationId",
+  "resourceId",
+  "runId",
+  "sessionId",
+  "threadId",
+  "requestId",
+  "environment",
+  "source",
+  "serviceName",
+  "experimentId",
+  "provider",
+  "model",
+  "estimatedCost",
+  "costUnit",
+  "tags",
+  "labels",
+  "costMetadata",
+  "metadata",
+  "scope"
+];
+var METRIC_COLUMNS_SQL = METRIC_COLUMNS.join(", ");
+var METRIC_COLUMN_SET = new Set(METRIC_COLUMNS);
+var METRIC_LABEL_ONLY_GROUP_BY_EXCLUDED = /* @__PURE__ */ new Set(["metadata", "scope", "costMetadata", "tags"]);
+function buildGroupByAlias(index) {
+  return `group_by_${index}`;
+}
+function toSeriesDisplayValue(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+function getCostSummarySelect(prefix = "") {
+  const ref = (column) => `${prefix}${column}`;
+  return [
+    `SUM(${ref("estimatedCost")}) FILTER (WHERE ${ref("estimatedCost")} IS NOT NULL) AS estimatedCost`,
+    `,`,
+    `CASE`,
+    `  WHEN COUNT(DISTINCT ${ref("costUnit")}) FILTER (WHERE ${ref("costUnit")} IS NOT NULL) = 1`,
+    `  THEN MIN(${ref("costUnit")}) FILTER (WHERE ${ref("costUnit")} IS NOT NULL)`,
+    `  ELSE NULL`,
+    `END AS costUnit`
+  ].join(" ");
+}
+function normalizeCostSummaryRow(row) {
+  return {
+    estimatedCost: row.estimatedCost === null || row.estimatedCost === void 0 ? null : Number(row.estimatedCost),
+    costUnit: row.costUnit === null || row.costUnit === void 0 ? null : String(row.costUnit)
+  };
+}
+function buildCombinedWhereClause(nameClause, nameParams, filterClause, filterParams) {
+  const conditions = [nameClause];
+  const params = [...nameParams];
+  if (filterClause) {
+    conditions.push(filterClause.replace("WHERE ", ""));
+    params.push(...filterParams);
+  }
+  return { clause: `WHERE ${conditions.join(" AND ")}`, params };
+}
+function resolveGroupBy(groupBy) {
+  return groupBy.map((key, index) => {
+    if (METRIC_COLUMN_SET.has(key)) {
+      const parsed = utils.parseFieldKey(key);
+      if (METRIC_LABEL_ONLY_GROUP_BY_EXCLUDED.has(parsed)) {
+        throw new Error(`Invalid groupBy column(s): ${key}`);
+      }
+      return {
+        kind: "column",
+        key,
+        selectSql: `${parsed} AS "${key}"`,
+        groupSql: parsed,
+        resultKey: key
+      };
+    }
+    const labelPath = buildJsonPath(key).replace(/'/g, "''");
+    const labelExpr = `json_extract_string(labels, '${labelPath}')`;
+    const alias = buildGroupByAlias(index);
+    return {
+      kind: "label",
+      key,
+      selectSql: `${labelExpr} AS ${alias}`,
+      groupSql: alias,
+      resultKey: alias
+    };
+  });
+}
+function rowToMetricRecord(row) {
+  return {
+    timestamp: toDate(row.timestamp),
+    name: row.name,
+    value: Number(row.value),
+    traceId: row.traceId ?? null,
+    spanId: row.spanId ?? null,
+    entityType: row.entityType ?? null,
+    entityId: row.entityId ?? null,
+    entityName: row.entityName ?? null,
+    parentEntityType: row.parentEntityType ?? null,
+    parentEntityId: row.parentEntityId ?? null,
+    parentEntityName: row.parentEntityName ?? null,
+    rootEntityType: row.rootEntityType ?? null,
+    rootEntityId: row.rootEntityId ?? null,
+    rootEntityName: row.rootEntityName ?? null,
+    userId: row.userId ?? null,
+    organizationId: row.organizationId ?? null,
+    resourceId: row.resourceId ?? null,
+    runId: row.runId ?? null,
+    sessionId: row.sessionId ?? null,
+    threadId: row.threadId ?? null,
+    requestId: row.requestId ?? null,
+    environment: row.environment ?? null,
+    source: row.source ?? null,
+    serviceName: row.serviceName ?? null,
+    experimentId: row.experimentId ?? null,
+    provider: row.provider ?? null,
+    model: row.model ?? null,
+    estimatedCost: row.estimatedCost === null || row.estimatedCost === void 0 ? null : Number(row.estimatedCost),
+    costUnit: row.costUnit ?? null,
+    costMetadata: parseJson(row.costMetadata),
+    tags: parseJsonArray(row.tags),
+    labels: parseJson(row.labels) ?? {},
+    metadata: parseJson(row.metadata),
+    scope: parseJson(row.scope)
+  };
+}
+async function batchCreateMetrics(db, args) {
+  if (args.metrics.length === 0) return;
+  const tuples = args.metrics.map((m) => {
+    return `(${[
+      v(m.timestamp),
+      v(m.name),
+      v(m.value),
+      v(m.traceId ?? null),
+      v(m.spanId ?? null),
+      v(m.entityType ?? null),
+      v(m.entityId ?? null),
+      v(m.entityName ?? null),
+      v(m.parentEntityType ?? null),
+      v(m.parentEntityId ?? null),
+      v(m.parentEntityName ?? null),
+      v(m.rootEntityType ?? null),
+      v(m.rootEntityId ?? null),
+      v(m.rootEntityName ?? null),
+      v(m.userId ?? null),
+      v(m.organizationId ?? null),
+      v(m.resourceId ?? null),
+      v(m.runId ?? null),
+      v(m.sessionId ?? null),
+      v(m.threadId ?? null),
+      v(m.requestId ?? null),
+      v(m.environment ?? null),
+      v(m.source ?? null),
+      v(m.serviceName ?? null),
+      v(m.experimentId ?? null),
+      v(m.provider ?? null),
+      v(m.model ?? null),
+      v(m.estimatedCost ?? null),
+      v(m.costUnit ?? null),
+      jsonV(m.tags ?? null),
+      v(JSON.stringify(m.labels ?? {})),
+      jsonV(m.costMetadata ?? null),
+      jsonV(m.metadata ?? null),
+      jsonV(m.scope ?? null)
+    ].join(", ")})`;
+  });
+  await db.execute(`INSERT INTO metric_events (${METRIC_COLUMNS_SQL}) VALUES ${tuples.join(",\n")}`);
+}
+async function listMetrics(db, args) {
+  const filters = args.filters ?? {};
+  const page = Number(args.pagination?.page ?? 0);
+  const perPage = Number(args.pagination?.perPage ?? 10);
+  const orderBy = { field: args.orderBy?.field ?? "timestamp", direction: args.orderBy?.direction ?? "DESC" };
+  const { clause: filterClause, params: filterParams } = buildWhereClause(filters);
+  const orderByClause = buildOrderByClause(orderBy);
+  const { clause: paginationClause, params: paginationParams } = buildPaginationClause({ page, perPage });
+  const countResult = await db.query(
+    `SELECT COUNT(*) AS total FROM metric_events ${filterClause}`,
+    filterParams
+  );
+  const total = Number(countResult[0]?.total ?? 0);
+  const rows = await db.query(
+    `SELECT * FROM metric_events ${filterClause} ${orderByClause} ${paginationClause}`,
+    [...filterParams, ...paginationParams]
+  );
+  return {
+    pagination: { total, page, perPage, hasMore: (page + 1) * perPage < total },
+    metrics: rows.map((row) => rowToMetricRecord(row))
+  };
+}
+async function getMetricAggregate(db, args) {
+  const aggSql = getAggregationSql(args.aggregation);
+  const { clause: nameClause, params: nameParams } = buildMetricNameFilter(args.name);
+  const { clause: filterClause, params: filterParams } = buildWhereClause(
+    args.filters
+  );
+  const { clause: whereClause, params: allParams } = buildCombinedWhereClause(
+    nameClause,
+    nameParams,
+    filterClause,
+    filterParams
+  );
+  const sql = `SELECT ${aggSql} AS value, ${getCostSummarySelect()} FROM metric_events ${whereClause}`;
+  const result = await db.query(sql, allParams);
+  const row = result[0] ?? {};
+  const value = row.value === null || row.value === void 0 ? null : Number(row.value);
+  const costSummary = normalizeCostSummaryRow(row);
+  if (args.comparePeriod && args.filters?.timestamp) {
+    const ts = args.filters.timestamp;
+    if (ts.start && ts.end) {
+      const duration = ts.end.getTime() - ts.start.getTime();
+      let prevStart;
+      let prevEnd;
+      switch (args.comparePeriod) {
+        case "previous_period":
+          prevStart = new Date(ts.start.getTime() - duration);
+          prevEnd = new Date(ts.end.getTime() - duration);
+          break;
+        case "previous_day":
+          prevStart = new Date(ts.start.getTime() - 864e5);
+          prevEnd = new Date(ts.end.getTime() - 864e5);
+          break;
+        case "previous_week":
+          prevStart = new Date(ts.start.getTime() - 6048e5);
+          prevEnd = new Date(ts.end.getTime() - 6048e5);
+          break;
+        default:
+          prevStart = new Date(ts.start.getTime() - duration);
+          prevEnd = new Date(ts.end.getTime() - duration);
+      }
+      const prevFilters = {
+        ...args.filters ?? {},
+        timestamp: {
+          start: prevStart,
+          end: prevEnd,
+          startExclusive: ts.startExclusive,
+          endExclusive: ts.endExclusive
+        }
+      };
+      const { clause: prevFilterClause, params: prevFilterParams } = buildWhereClause(
+        prevFilters
+      );
+      const { clause: prevWhereClause, params: prevParams } = buildCombinedWhereClause(
+        nameClause,
+        nameParams,
+        prevFilterClause,
+        prevFilterParams
+      );
+      const prevSql = `SELECT ${aggSql} AS value, ${getCostSummarySelect()} FROM metric_events ${prevWhereClause}`;
+      const prevResult = await db.query(prevSql, prevParams);
+      const prevRow = prevResult[0] ?? {};
+      const previousValue = prevRow.value === null || prevRow.value === void 0 ? null : Number(prevRow.value);
+      const previousCostSummary = normalizeCostSummaryRow(prevRow);
+      let changePercent = null;
+      if (previousValue !== null && previousValue !== 0 && value !== null) {
+        changePercent = (value - previousValue) / Math.abs(previousValue) * 100;
+      }
+      let costChangePercent = null;
+      if (previousCostSummary.estimatedCost !== null && previousCostSummary.estimatedCost !== 0 && costSummary.estimatedCost !== null) {
+        costChangePercent = (costSummary.estimatedCost - previousCostSummary.estimatedCost) / Math.abs(previousCostSummary.estimatedCost) * 100;
+      }
+      return {
+        value,
+        estimatedCost: costSummary.estimatedCost,
+        costUnit: costSummary.costUnit,
+        previousValue,
+        previousEstimatedCost: previousCostSummary.estimatedCost,
+        changePercent,
+        costChangePercent
+      };
+    }
+  }
+  return { value, estimatedCost: costSummary.estimatedCost, costUnit: costSummary.costUnit };
+}
+async function getMetricBreakdown(db, args) {
+  const aggSql = getAggregationSql(args.aggregation);
+  const { clause: nameClause, params: nameParams } = buildMetricNameFilter(args.name);
+  const { clause: filterClause, params: filterParams } = buildWhereClause(
+    args.filters
+  );
+  const { clause: whereClause, params: allParams } = buildCombinedWhereClause(
+    nameClause,
+    nameParams,
+    filterClause,
+    filterParams
+  );
+  const resolvedGroupBy = resolveGroupBy(args.groupBy);
+  const selectGroupBy = resolvedGroupBy.map((entry) => entry.selectSql).join(", ");
+  const groupByCols = resolvedGroupBy.map((entry) => entry.groupSql).join(", ");
+  const sql = `SELECT ${selectGroupBy}, ${aggSql} AS value, ${getCostSummarySelect()} FROM metric_events ${whereClause} GROUP BY ${groupByCols} ORDER BY value DESC`;
+  const rows = await db.query(sql, allParams);
+  const groups = rows.map((row) => {
+    const dimensions = {};
+    for (const entry of resolvedGroupBy) {
+      const value = row[entry.resultKey];
+      dimensions[entry.key] = value === null || value === void 0 ? null : String(value);
+    }
+    const costSummary = normalizeCostSummaryRow(row);
+    return {
+      dimensions,
+      value: Number(row.value ?? 0),
+      estimatedCost: costSummary.estimatedCost,
+      costUnit: costSummary.costUnit
+    };
+  });
+  return { groups };
+}
+async function getMetricTimeSeries(db, args) {
+  const aggSql = getAggregationSql(args.aggregation);
+  const intervalSql = getIntervalSql(args.interval);
+  const { clause: nameClause, params: nameParams } = buildMetricNameFilter(args.name);
+  const { clause: filterClause, params: filterParams } = buildWhereClause(
+    args.filters
+  );
+  const { clause: whereClause, params: allParams } = buildCombinedWhereClause(
+    nameClause,
+    nameParams,
+    filterClause,
+    filterParams
+  );
+  if (args.groupBy && args.groupBy.length > 0) {
+    const resolvedGroupBy = resolveGroupBy(args.groupBy);
+    const selectGroupBy = resolvedGroupBy.map((entry) => entry.selectSql).join(", ");
+    const groupByCols = resolvedGroupBy.map((entry) => entry.groupSql).join(", ");
+    const sql2 = `
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             ${selectGroupBy},
+             ${aggSql} AS value,
+             ${getCostSummarySelect()}
+      FROM metric_events ${whereClause}
+      GROUP BY bucket, ${groupByCols}
+      ORDER BY bucket
+    `;
+    const rows2 = await db.query(sql2, allParams);
+    const seriesMap = /* @__PURE__ */ new Map();
+    for (const row of rows2) {
+      const dimensionValues = resolvedGroupBy.map((entry) => row[entry.resultKey]);
+      const seriesKey = JSON.stringify(dimensionValues);
+      const name = dimensionValues.map(toSeriesDisplayValue).join("|");
+      const costSummary = normalizeCostSummaryRow(row);
+      if (!seriesMap.has(seriesKey)) {
+        seriesMap.set(seriesKey, {
+          name,
+          costUnits: /* @__PURE__ */ new Set(),
+          points: []
+        });
+      }
+      if (costSummary.costUnit) {
+        seriesMap.get(seriesKey).costUnits.add(costSummary.costUnit);
+      }
+      seriesMap.get(seriesKey).points.push({
+        timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+        value: Number(row.value ?? 0),
+        estimatedCost: costSummary.estimatedCost
+      });
+    }
+    return {
+      series: Array.from(seriesMap.values()).map((series) => ({
+        name: series.name,
+        costUnit: series.costUnits.size === 1 ? Array.from(series.costUnits)[0] : null,
+        points: series.points
+      }))
+    };
+  }
+  const sql = `
+    SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+           ${aggSql} AS value,
+           ${getCostSummarySelect()}
+    FROM metric_events ${whereClause}
+    GROUP BY bucket
+    ORDER BY bucket
+  `;
+  const rows = await db.query(sql, allParams);
+  const metricName = Array.isArray(args.name) ? args.name.join(",") : args.name;
+  const overallCostUnits = new Set(
+    rows.map((row) => row.costUnit).filter((value) => typeof value === "string")
+  );
+  return {
+    series: [
+      {
+        name: metricName,
+        costUnit: overallCostUnits.size === 1 ? Array.from(overallCostUnits)[0] : null,
+        points: rows.map((row) => {
+          const costSummary = normalizeCostSummaryRow(row);
+          return {
+            timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+            value: Number(row.value ?? 0),
+            estimatedCost: costSummary.estimatedCost
+          };
+        })
+      }
+    ]
+  };
+}
+async function getMetricPercentiles(db, args) {
+  const intervalSql = getIntervalSql(args.interval);
+  const { clause: filterClause, params: filterParams } = buildWhereClause(
+    args.filters
+  );
+  const allConditions = [`name = ?`];
+  const allParams = [args.name];
+  if (filterClause) {
+    allConditions.push(filterClause.replace("WHERE ", ""));
+    allParams.push(...filterParams);
+  }
+  const whereClause = `WHERE ${allConditions.join(" AND ")}`;
+  const series = [];
+  for (const p of args.percentiles) {
+    const sql = `
+      SELECT time_bucket(INTERVAL '${intervalSql}', timestamp) AS bucket,
+             percentile_cont(${p}) WITHIN GROUP (ORDER BY value) AS pvalue
+      FROM metric_events ${whereClause}
+      GROUP BY bucket
+      ORDER BY bucket
+    `;
+    const rows = await db.query(sql, allParams);
+    series.push({
+      percentile: p,
+      points: rows.map((row) => ({
+        timestamp: row.bucket instanceof Date ? row.bucket : new Date(String(row.bucket)),
+        value: Number(row.pvalue ?? 0)
+      }))
+    });
+  }
+  return { series };
+}
+async function getMetricNames(db, args) {
+  const conditions = [];
+  const params = [];
+  if (args.prefix) {
+    conditions.push(`name LIKE ?`);
+    params.push(`${args.prefix}%`);
+  }
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limitClause = args.limit ? `LIMIT ?` : "";
+  if (args.limit) params.push(args.limit);
+  const rows = await db.query(
+    `SELECT DISTINCT name FROM metric_events ${whereClause} ORDER BY name ${limitClause}`,
+    params
+  );
+  return { names: rows.map((r) => r.name) };
+}
+async function getMetricLabelKeys(db, args) {
+  const rows = await db.query(
+    `SELECT DISTINCT unnest(json_keys(labels)) AS key FROM metric_events WHERE name = ? AND labels IS NOT NULL`,
+    [args.metricName]
+  );
+  return { keys: rows.map((r) => r.key) };
+}
+async function getMetricLabelValues(db, args) {
+  const labelPath = buildJsonPath(args.labelKey);
+  const conditions = [`name = ?`, `json_extract_string(labels, ?) IS NOT NULL`];
+  const params = [args.metricName, labelPath];
+  if (args.prefix) {
+    conditions.push(`json_extract_string(labels, ?) LIKE ?`);
+    params.push(labelPath, `${args.prefix}%`);
+  }
+  const limitClause = args.limit ? `LIMIT ?` : "";
+  if (args.limit) params.push(args.limit);
+  const rows = await db.query(
+    `SELECT DISTINCT json_extract_string(labels, ?) AS val FROM metric_events WHERE ${conditions.join(" AND ")} ORDER BY val ${limitClause}`,
+    [labelPath, ...params]
+  );
+  return { values: rows.map((r) => r.val) };
+}
+
+// src/storage/domains/observability/scores.ts
+async function createScore(db, args) {
+  const s = args.score;
+  await db.execute(
+    `INSERT INTO score_events (timestamp, traceId, spanId, scorerId, scorerVersion, source, score, reason, experimentId, scoreTraceId, metadata)
+     VALUES (${[
+      v(s.timestamp),
+      v(s.traceId),
+      v(s.spanId ?? null),
+      v(s.scorerId),
+      v(s.scorerVersion ?? null),
+      v(s.source ?? null),
+      v(s.score),
+      v(s.reason ?? null),
+      v(s.experimentId ?? null),
+      v(s.scoreTraceId ?? null),
+      jsonV(s.metadata)
+    ].join(", ")})`
+  );
+}
+async function batchCreateScores(db, args) {
+  if (args.scores.length === 0) return;
+  const tuples = args.scores.map(
+    (s) => `(${[
+      v(s.timestamp),
+      v(s.traceId),
+      v(s.spanId ?? null),
+      v(s.scorerId),
+      v(s.scorerVersion ?? null),
+      v(s.source ?? null),
+      v(s.score),
+      v(s.reason ?? null),
+      v(s.experimentId ?? null),
+      v(s.scoreTraceId ?? null),
+      jsonV(s.metadata)
+    ].join(", ")})`
+  );
+  await db.execute(
+    `INSERT INTO score_events (timestamp, traceId, spanId, scorerId, scorerVersion, source, score, reason, experimentId, scoreTraceId, metadata)
+     VALUES ${tuples.join(",\n       ")}`
+  );
+}
+async function listScores(db, args) {
+  const filters = args.filters ?? {};
+  const page = Number(args.pagination?.page ?? 0);
+  const perPage = Number(args.pagination?.perPage ?? 10);
+  const orderBy = { field: args.orderBy?.field ?? "timestamp", direction: args.orderBy?.direction ?? "DESC" };
+  const { clause: filterClause, params: filterParams } = buildWhereClause(filters);
+  const orderByClause = buildOrderByClause(orderBy);
+  const { clause: paginationClause, params: paginationParams } = buildPaginationClause({ page, perPage });
+  const countResult = await db.query(
+    `SELECT COUNT(*) as total FROM score_events ${filterClause}`,
+    filterParams
+  );
+  const total = Number(countResult[0]?.total ?? 0);
+  const rows = await db.query(`SELECT * FROM score_events ${filterClause} ${orderByClause} ${paginationClause}`, [
+    ...filterParams,
+    ...paginationParams
+  ]);
+  const scores = rows.map((row) => {
+    const r = row;
+    return {
+      timestamp: toDate(r.timestamp),
+      traceId: r.traceId,
+      spanId: r.spanId ?? null,
+      scorerId: r.scorerId,
+      scorerVersion: r.scorerVersion ?? null,
+      source: r.source ?? null,
+      score: Number(r.score),
+      reason: r.reason ?? null,
+      experimentId: r.experimentId ?? null,
+      scoreTraceId: r.scoreTraceId ?? null,
+      metadata: parseJson(r.metadata)
+    };
+  });
+  return {
+    pagination: { total, page, perPage, hasMore: (page + 1) * perPage < total },
+    scores
+  };
+}
+var COLUMNS2 = [
+  "eventType",
+  "timestamp",
+  "traceId",
+  "spanId",
+  "parentSpanId",
+  "name",
+  "spanType",
+  "isEvent",
+  "endedAt",
+  "experimentId",
+  "entityType",
+  "entityId",
+  "entityName",
+  "userId",
+  "organizationId",
+  "resourceId",
+  "runId",
+  "sessionId",
+  "threadId",
+  "requestId",
+  "environment",
+  "source",
+  "serviceName",
+  "attributes",
+  "metadata",
+  "tags",
+  "scope",
+  "links",
+  "input",
+  "output",
+  "error",
+  "requestContext"
+];
+var COLUMNS_SQL2 = COLUMNS2.join(", ");
+function argMaxNonNull(col) {
+  return `arg_max(${col}, timestamp) FILTER (WHERE ${col} IS NOT NULL) as ${col}`;
+}
+var SPAN_RECONSTRUCT_SELECT = `
+  SELECT
+    traceId, spanId,
+    ${argMaxNonNull("name")},
+    ${argMaxNonNull("spanType")},
+    ${argMaxNonNull("parentSpanId")},
+    ${argMaxNonNull("isEvent")},
+    coalesce(min(timestamp) FILTER (WHERE eventType = 'start'), min(timestamp)) as startedAt,
+    ${argMaxNonNull("endedAt")},
+    ${argMaxNonNull("experimentId")},
+    ${argMaxNonNull("entityType")},
+    ${argMaxNonNull("entityId")},
+    ${argMaxNonNull("entityName")},
+    ${argMaxNonNull("userId")},
+    ${argMaxNonNull("organizationId")},
+    ${argMaxNonNull("resourceId")},
+    ${argMaxNonNull("runId")},
+    ${argMaxNonNull("sessionId")},
+    ${argMaxNonNull("threadId")},
+    ${argMaxNonNull("requestId")},
+    ${argMaxNonNull("environment")},
+    ${argMaxNonNull("source")},
+    ${argMaxNonNull("serviceName")},
+    ${argMaxNonNull("attributes")},
+    ${argMaxNonNull("metadata")},
+    ${argMaxNonNull("tags")},
+    ${argMaxNonNull("scope")},
+    ${argMaxNonNull("links")},
+    ${argMaxNonNull("input")},
+    ${argMaxNonNull("output")},
+    ${argMaxNonNull("error")},
+    ${argMaxNonNull("requestContext")}
+  FROM span_events
+`;
+function rowToSpanRecord(row) {
+  return {
+    traceId: row.traceId,
+    spanId: row.spanId,
+    name: row.name,
+    spanType: row.spanType,
+    parentSpanId: row.parentSpanId ?? null,
+    isEvent: row.isEvent,
+    startedAt: toDate(row.startedAt),
+    endedAt: toDateOrNull(row.endedAt),
+    experimentId: row.experimentId ?? null,
+    entityType: row.entityType ?? null,
+    entityId: row.entityId ?? null,
+    entityName: row.entityName ?? null,
+    userId: row.userId ?? null,
+    organizationId: row.organizationId ?? null,
+    resourceId: row.resourceId ?? null,
+    runId: row.runId ?? null,
+    sessionId: row.sessionId ?? null,
+    threadId: row.threadId ?? null,
+    requestId: row.requestId ?? null,
+    environment: row.environment ?? null,
+    source: row.source ?? null,
+    serviceName: row.serviceName ?? null,
+    attributes: parseJson(row.attributes),
+    metadata: parseJson(row.metadata),
+    tags: parseJsonArray(row.tags),
+    scope: parseJson(row.scope),
+    links: parseJsonArray(row.links),
+    input: parseJson(row.input),
+    output: parseJson(row.output),
+    error: parseJson(row.error),
+    requestContext: parseJson(row.requestContext),
+    createdAt: toDate(row.startedAt),
+    updatedAt: null
+  };
+}
+function buildHasChildErrorClause(hasChildError) {
+  if (hasChildError === void 0) return "";
+  const base = `SELECT 1 FROM reconstructed_spans c WHERE c.traceId = root_spans.traceId AND c.spanId != root_spans.spanId AND c.error IS NOT NULL`;
+  return hasChildError ? `EXISTS (${base})` : `NOT EXISTS (${base})`;
+}
+function toValuesTuple(row) {
+  return [
+    v(row.eventType),
+    v(row.timestamp),
+    v(row.traceId),
+    v(row.spanId),
+    v(row.parentSpanId),
+    v(row.name),
+    v(row.spanType),
+    v(row.isEvent),
+    v(row.endedAt),
+    v(row.experimentId),
+    v(row.entityType),
+    v(row.entityId),
+    v(row.entityName),
+    v(row.userId),
+    v(row.organizationId),
+    v(row.resourceId),
+    v(row.runId),
+    v(row.sessionId),
+    v(row.threadId),
+    v(row.requestId),
+    v(row.environment),
+    v(row.source),
+    v(row.serviceName),
+    jsonV(row.attributes),
+    jsonV(row.metadata),
+    jsonV(row.tags),
+    jsonV(row.scope),
+    jsonV(row.links),
+    jsonV(row.input),
+    jsonV(row.output),
+    jsonV(row.error),
+    jsonV(row.requestContext)
+  ].join(", ");
+}
+async function insertSpanEvents(db, rows) {
+  if (rows.length === 0) return;
+  const tuples = rows.map((row) => `(${toValuesTuple(row)})`).join(",\n");
+  await db.execute(`INSERT INTO span_events (${COLUMNS_SQL2}) VALUES ${tuples}`);
+}
+function createStartSpanRow(s) {
+  return {
+    eventType: "start",
+    timestamp: s.startedAt,
+    traceId: s.traceId,
+    spanId: s.spanId,
+    parentSpanId: s.parentSpanId ?? null,
+    name: s.name,
+    spanType: s.spanType,
+    isEvent: s.isEvent,
+    endedAt: null,
+    experimentId: s.experimentId ?? null,
+    entityType: s.entityType ?? null,
+    entityId: s.entityId ?? null,
+    entityName: s.entityName ?? null,
+    userId: s.userId ?? null,
+    organizationId: s.organizationId ?? null,
+    resourceId: s.resourceId ?? null,
+    runId: s.runId ?? null,
+    sessionId: s.sessionId ?? null,
+    threadId: s.threadId ?? null,
+    requestId: s.requestId ?? null,
+    environment: s.environment ?? null,
+    source: s.source ?? null,
+    serviceName: s.serviceName ?? null,
+    attributes: s.attributes ?? null,
+    metadata: s.metadata ?? null,
+    tags: s.tags ?? null,
+    scope: s.scope ?? null,
+    links: null,
+    input: s.input ?? null,
+    output: null,
+    error: null,
+    requestContext: s.requestContext ?? null
+  };
+}
+function createEndSpanRow(s) {
+  return {
+    eventType: "end",
+    timestamp: s.endedAt,
+    traceId: s.traceId,
+    spanId: s.spanId,
+    parentSpanId: s.parentSpanId ?? null,
+    name: s.name,
+    spanType: s.spanType,
+    isEvent: s.isEvent,
+    endedAt: s.endedAt ?? null,
+    experimentId: s.experimentId ?? null,
+    entityType: s.entityType ?? null,
+    entityId: s.entityId ?? null,
+    entityName: s.entityName ?? null,
+    userId: s.userId ?? null,
+    organizationId: s.organizationId ?? null,
+    resourceId: s.resourceId ?? null,
+    runId: s.runId ?? null,
+    sessionId: s.sessionId ?? null,
+    threadId: s.threadId ?? null,
+    requestId: s.requestId ?? null,
+    environment: s.environment ?? null,
+    source: s.source ?? null,
+    serviceName: s.serviceName ?? null,
+    attributes: s.attributes ?? null,
+    metadata: s.metadata ?? null,
+    tags: s.tags ?? null,
+    scope: s.scope ?? null,
+    links: s.links ?? null,
+    input: s.input ?? null,
+    output: s.output ?? null,
+    error: s.error ?? null,
+    requestContext: s.requestContext ?? null
+  };
+}
+async function createSpan(db, args) {
+  const rows = [createStartSpanRow(args.span)];
+  if (args.span.endedAt) {
+    rows.push(createEndSpanRow(args.span));
+  }
+  await insertSpanEvents(db, rows);
+}
+async function batchCreateSpans(db, args) {
+  if (args.records.length === 0) return;
+  const rows = args.records.flatMap((record) => {
+    const events = [createStartSpanRow(record)];
+    if (record.endedAt) {
+      events.push(createEndSpanRow(record));
+    }
+    return events;
+  });
+  await insertSpanEvents(db, rows);
+}
+async function batchDeleteTraces(db, args) {
+  if (args.traceIds.length === 0) return;
+  const placeholders = args.traceIds.map(() => "?").join(", ");
+  await db.execute(`DELETE FROM span_events WHERE traceId IN (${placeholders})`, args.traceIds);
+}
+async function getSpan(db, args) {
+  const rows = await db.query(`${SPAN_RECONSTRUCT_SELECT} WHERE traceId = ? AND spanId = ? GROUP BY traceId, spanId`, [
+    args.traceId,
+    args.spanId
+  ]);
+  if (rows.length === 0) return null;
+  return { span: rowToSpanRecord(rows[0]) };
+}
+async function getRootSpan(db, args) {
+  const rows = await db.query(
+    `${SPAN_RECONSTRUCT_SELECT} WHERE traceId = ? GROUP BY traceId, spanId HAVING arg_max(parentSpanId, timestamp) IS NULL LIMIT 1`,
+    [args.traceId]
+  );
+  if (rows.length === 0) return null;
+  return { span: rowToSpanRecord(rows[0]) };
+}
+async function getTrace(db, args) {
+  const rows = await db.query(`${SPAN_RECONSTRUCT_SELECT} WHERE traceId = ? GROUP BY traceId, spanId`, [args.traceId]);
+  if (rows.length === 0) return null;
+  return {
+    traceId: args.traceId,
+    spans: rows.map((row) => rowToSpanRecord(row))
+  };
+}
+async function listTraces(db, args) {
+  const filters = args.filters ?? {};
+  const page = Number(args.pagination?.page ?? 0);
+  const perPage = Number(args.pagination?.perPage ?? 10);
+  const orderBy = { field: args.orderBy?.field ?? "startedAt", direction: args.orderBy?.direction ?? "DESC" };
+  const { clause: filterClause, params: filterParams } = buildWhereClause(filters);
+  const orderByClause = buildOrderByClause(orderBy);
+  const { clause: paginationClause, params: paginationParams } = buildPaginationClause({ page, perPage });
+  const filterParts = [];
+  if (filterClause) filterParts.push(filterClause.replace(/^WHERE\s+/i, ""));
+  const hasChildError = typeof filters.hasChildError === "boolean" ? filters.hasChildError : void 0;
+  const childErrorClause = buildHasChildErrorClause(hasChildError);
+  if (childErrorClause) filterParts.push(childErrorClause);
+  const combinedFilterClause = filterParts.length > 0 ? `WHERE ${filterParts.join(" AND ")}` : "";
+  const cteSql = `
+    WITH reconstructed_spans AS (
+      ${SPAN_RECONSTRUCT_SELECT}
+      GROUP BY traceId, spanId
+    ),
+    root_spans AS (
+      SELECT * FROM reconstructed_spans
+      WHERE parentSpanId IS NULL
+    )
+  `;
+  const countSql = `
+    ${cteSql}
+    SELECT COUNT(*) as total FROM root_spans ${combinedFilterClause}
+  `;
+  const countResult = await db.query(countSql, filterParams);
+  const total = Number(countResult[0]?.total ?? 0);
+  const dataSql = `
+    ${cteSql}
+    SELECT * FROM root_spans ${combinedFilterClause} ${orderByClause} ${paginationClause}
+  `;
+  const rows = await db.query(dataSql, [...filterParams, ...paginationParams]);
+  const spans = rows.map((row) => rowToSpanRecord(row));
+  return {
+    pagination: {
+      total,
+      page,
+      perPage,
+      hasMore: (page + 1) * perPage < total
+    },
+    spans: storage.toTraceSpans(spans)
+  };
+}
+
+// src/storage/domains/observability/index.ts
+var ObservabilityStorageDuckDB = class extends storage.ObservabilityStorage {
+  db;
+  constructor(config) {
+    super();
+    this.db = config.db;
+  }
+  /** Create all observability tables if they don't exist. */
+  async init() {
+    for (const ddl of ALL_DDL) {
+      await this.db.execute(ddl);
+    }
+  }
+  /** Delete all rows from every observability table. Use with caution. */
+  async dangerouslyClearAll() {
+    for (const table of ["span_events", "metric_events", "log_events", "score_events", "feedback_events"]) {
+      await this.db.execute(`TRUNCATE TABLE ${table}`);
+    }
+  }
+  get observabilityStrategy() {
+    return {
+      preferred: "event-sourced",
+      supported: ["event-sourced"]
+    };
+  }
+  // Tracing
+  async createSpan(args) {
+    return createSpan(this.db, args);
+  }
+  async batchCreateSpans(args) {
+    return batchCreateSpans(this.db, args);
+  }
+  async batchDeleteTraces(args) {
+    return batchDeleteTraces(this.db, args);
+  }
+  async getSpan(args) {
+    return getSpan(this.db, args);
+  }
+  async getRootSpan(args) {
+    return getRootSpan(this.db, args);
+  }
+  async getTrace(args) {
+    return getTrace(this.db, args);
+  }
+  async listTraces(args) {
+    return listTraces(this.db, args);
+  }
+  // Logs
+  async batchCreateLogs(args) {
+    return batchCreateLogs(this.db, args);
+  }
+  async listLogs(args) {
+    return listLogs(this.db, args);
+  }
+  // Metrics
+  async batchCreateMetrics(args) {
+    return batchCreateMetrics(this.db, args);
+  }
+  async listMetrics(args) {
+    return listMetrics(this.db, args);
+  }
+  async getMetricAggregate(args) {
+    return getMetricAggregate(this.db, args);
+  }
+  async getMetricBreakdown(args) {
+    return getMetricBreakdown(this.db, args);
+  }
+  async getMetricTimeSeries(args) {
+    return getMetricTimeSeries(this.db, args);
+  }
+  async getMetricPercentiles(args) {
+    return getMetricPercentiles(this.db, args);
+  }
+  // Metric Discovery
+  async getMetricNames(args) {
+    return getMetricNames(this.db, args);
+  }
+  async getMetricLabelKeys(args) {
+    return getMetricLabelKeys(this.db, args);
+  }
+  async getMetricLabelValues(args) {
+    return getMetricLabelValues(this.db, args);
+  }
+  // Span Discovery
+  async getEntityTypes(args) {
+    return getEntityTypes(this.db);
+  }
+  async getEntityNames(args) {
+    return getEntityNames(this.db, args);
+  }
+  async getServiceNames(args) {
+    return getServiceNames(this.db);
+  }
+  async getEnvironments(args) {
+    return getEnvironments(this.db);
+  }
+  async getTags(args) {
+    return getTags(this.db, args);
+  }
+  // Scores
+  async createScore(args) {
+    return createScore(this.db, args);
+  }
+  async batchCreateScores(args) {
+    return batchCreateScores(this.db, args);
+  }
+  async listScores(args) {
+    return listScores(this.db, args);
+  }
+  // Feedback
+  async createFeedback(args) {
+    return createFeedback(this.db, args);
+  }
+  async batchCreateFeedback(args) {
+    return batchCreateFeedback(this.db, args);
+  }
+  async listFeedback(args) {
+    return listFeedback(this.db, args);
+  }
+};
+
+exports.ObservabilityStorageDuckDB = ObservabilityStorageDuckDB;
+//# sourceMappingURL=observability-W2QRBK56.cjs.map
+//# sourceMappingURL=observability-W2QRBK56.cjs.map