@codemation/host 0.2.5 → 0.3.0

package/src/infrastructure/persistence/PrismaTelemetryMetricPointStore.ts

@@ -0,0 +1,134 @@
+import { inject, injectable, type TelemetryAttributes } from "@codemation/core";
+import { OtelIdentityFactory } from "../../application/telemetry/OtelIdentityFactory";
+import type {
+  TelemetryMetricPointListQuery,
+  TelemetryMetricPointRecord,
+  TelemetryMetricPointStore,
+  TelemetryMetricPointWrite,
+} from "../../domain/telemetry/TelemetryContracts";
+import { PrismaDatabaseClientToken, type PrismaDatabaseClient } from "./PrismaDatabaseClient";
+
+@injectable()
+export class PrismaTelemetryMetricPointStore implements TelemetryMetricPointStore {
+  constructor(
+    @inject(PrismaDatabaseClientToken)
+    private readonly prisma: PrismaDatabaseClient,
+    @inject(OtelIdentityFactory)
+    private readonly otelIdentityFactory: OtelIdentityFactory,
+  ) {}
+
+  async save(record: TelemetryMetricPointWrite): Promise<TelemetryMetricPointRecord> {
+    const metricPointId = this.otelIdentityFactory.createArtifactId();
+    await this.prisma.telemetryMetricPoint.create({
+      data: {
+        metricPointId,
+        traceId: record.traceId ?? null,
+        spanId: record.spanId ?? null,
+        runId: record.runId ?? null,
+        workflowId: record.workflowId,
+        nodeId: record.nodeId ?? null,
+        activationId: record.activationId ?? null,
+        metricName: record.name,
+        value: record.value,
+        unit: record.unit ?? null,
+        observedAt: record.observedAt,
+        workflowFolder: record.workflowFolder ?? null,
+        nodeType: record.nodeType ?? null,
+        nodeRole: record.nodeRole ?? null,
+        modelName: record.modelName ?? null,
+        dimensionsJson: record.attributes ? JSON.stringify(record.attributes) : null,
+        retentionExpiresAt: record.retentionExpiresAt ?? null,
+      },
+    });
+    return {
+      metricPointId,
+      traceId: record.traceId,
+      spanId: record.spanId,
+      runId: record.runId,
+      workflowId: record.workflowId,
+      nodeId: record.nodeId,
+      activationId: record.activationId,
+      metricName: record.name,
+      value: record.value,
+      unit: record.unit,
+      observedAt: record.observedAt,
+      workflowFolder: record.workflowFolder,
+      nodeType: record.nodeType,
+      nodeRole: record.nodeRole,
+      modelName: record.modelName,
+      dimensions: record.attributes,
+      retentionExpiresAt: record.retentionExpiresAt,
+    };
+  }
+
+  async list(args: TelemetryMetricPointListQuery = {}): Promise<ReadonlyArray<TelemetryMetricPointRecord>> {
+    const rows = await this.prisma.telemetryMetricPoint.findMany({
+      where: {
+        ...(args.traceId ? { traceId: args.traceId } : {}),
+        ...(args.runId ? { runId: args.runId } : {}),
+        ...(args.runIds && args.runIds.length > 0 ? { runId: { in: [...args.runIds] } } : {}),
+        ...(args.workflowId ? { workflowId: args.workflowId } : {}),
+        ...(args.workflowIds && args.workflowIds.length > 0 ? { workflowId: { in: [...args.workflowIds] } } : {}),
+        ...(args.nodeId ? { nodeId: args.nodeId } : {}),
+        ...(args.metricNames && args.metricNames.length > 0 ? { metricName: { in: [...args.metricNames] } } : {}),
+        ...(args.modelNames && args.modelNames.length > 0 ? { modelName: { in: [...args.modelNames] } } : {}),
+        ...(args.observedAtGte ? { observedAt: { gte: args.observedAtGte } } : {}),
+        ...(args.observedAtLte ? { observedAt: { lte: args.observedAtLte } } : {}),
+      },
+      orderBy: [{ observedAt: "asc" }, { metricPointId: "asc" }],
+      ...(args.limit ? { take: args.limit } : {}),
+    });
+    return rows.map((row) => ({
+      metricPointId: row.metricPointId,
+      traceId: row.traceId ?? undefined,
+      spanId: row.spanId ?? undefined,
+      runId: row.runId ?? undefined,
+      workflowId: row.workflowId,
+      nodeId: row.nodeId ?? undefined,
+      activationId: row.activationId ?? undefined,
+      metricName: row.metricName,
+      value: row.value,
+      unit: row.unit ?? undefined,
+      observedAt: row.observedAt,
+      workflowFolder: row.workflowFolder ?? undefined,
+      nodeType: row.nodeType ?? undefined,
+      nodeRole: row.nodeRole ?? undefined,
+      modelName: row.modelName ?? undefined,
+      dimensions: this.parseJson<TelemetryAttributes>(row.dimensionsJson),
+      retentionExpiresAt: row.retentionExpiresAt ?? undefined,
+    }));
+  }
+
+  async pruneExpired(args: Readonly<{ nowIso: string; limit?: number }>): Promise<number> {
+    const rows = await this.prisma.telemetryMetricPoint.findMany({
+      where: {
+        retentionExpiresAt: {
+          lte: args.nowIso,
+        },
+      },
+      select: {
+        metricPointId: true,
+      },
+      orderBy: [{ retentionExpiresAt: "asc" }, { metricPointId: "asc" }],
+      ...(args.limit ? { take: args.limit } : {}),
+    });
+    if (rows.length === 0) {
+      return 0;
+    }
+    const result = await this.prisma.telemetryMetricPoint.deleteMany({
+      where: {
+        metricPointId: {
+          in: rows.map((row) => row.metricPointId),
+        },
+      },
+    });
+    return result.count;
+  }
+
+  private parseJson<T>(value: string | null): T | undefined {
+    if (!value) {
+      return undefined;
+    }
+    return JSON.parse(value) as T;
+  }
+}

package/src/infrastructure/persistence/PrismaTelemetrySpanStore.ts

@@ -0,0 +1,166 @@
+import { inject, injectable, type TelemetryAttributes, type TelemetrySpanEventRecord } from "@codemation/core";
+import type {
+  TelemetrySpanListQuery,
+  TelemetrySpanRecord,
+  TelemetrySpanStore,
+  TelemetrySpanUpsert,
+} from "../../domain/telemetry/TelemetryContracts";
+import { PrismaDatabaseClientToken, type PrismaDatabaseClient } from "./PrismaDatabaseClient";
+
+@injectable()
+export class PrismaTelemetrySpanStore implements TelemetrySpanStore {
+  constructor(
+    @inject(PrismaDatabaseClientToken)
+    private readonly prisma: PrismaDatabaseClient,
+  ) {}
+
+  async upsert(record: TelemetrySpanUpsert): Promise<void> {
+    const telemetrySpanId = this.createTelemetrySpanId(record.traceId, record.spanId);
+    const existing = await this.prisma.telemetrySpan.findUnique({
+      where: { telemetrySpanId },
+    });
+    const attributes = this.mergeAttributes(
+      this.parseJson<TelemetryAttributes>(existing?.attributesJson ?? null),
+      record.attributes,
+    );
+    const events = this.mergeEvents(
+      this.parseJson<ReadonlyArray<TelemetrySpanEventRecord>>(existing?.eventsJson ?? null),
+      record.events,
+    );
+    const data = {
+      traceId: record.traceId,
+      spanId: record.spanId,
+      parentSpanId: record.parentSpanId ?? existing?.parentSpanId ?? null,
+      runId: record.runId,
+      workflowId: record.workflowId,
+      nodeId: record.nodeId ?? existing?.nodeId ?? null,
+      activationId: record.activationId ?? existing?.activationId ?? null,
+      connectionInvocationId: record.connectionInvocationId ?? existing?.connectionInvocationId ?? null,
+      name: record.name ?? existing?.name ?? "codemation.span",
+      kind: record.kind ?? existing?.kind ?? "internal",
+      status: record.status ?? existing?.status ?? null,
+      statusMessage: record.statusMessage ?? existing?.statusMessage ?? null,
+      startTime: record.startTime ?? existing?.startTime ?? null,
+      endTime: record.endTime ?? existing?.endTime ?? null,
+      workflowFolder: record.workflowFolder ?? existing?.workflowFolder ?? null,
+      nodeType: record.nodeType ?? existing?.nodeType ?? null,
+      nodeRole: record.nodeRole ?? existing?.nodeRole ?? null,
+      modelName: record.modelName ?? existing?.modelName ?? null,
+      attributesJson: attributes ? JSON.stringify(attributes) : null,
+      eventsJson: events.length > 0 ? JSON.stringify(events) : null,
+      retentionExpiresAt: record.retentionExpiresAt ?? existing?.retentionExpiresAt ?? null,
+      updatedAt: new Date().toISOString(),
+    };
+    await this.prisma.telemetrySpan.upsert({
+      where: { telemetrySpanId },
+      create: {
+        telemetrySpanId,
+        ...data,
+      },
+      update: data,
+    });
+  }
+
+  async list(args: TelemetrySpanListQuery = {}): Promise<ReadonlyArray<TelemetrySpanRecord>> {
+    const rows = await this.prisma.telemetrySpan.findMany({
+      where: {
+        ...(args.traceId ? { traceId: args.traceId } : {}),
+        ...(args.runId ? { runId: args.runId } : {}),
+        ...(args.runIds && args.runIds.length > 0 ? { runId: { in: [...args.runIds] } } : {}),
+        ...(args.workflowId ? { workflowId: args.workflowId } : {}),
+        ...(args.workflowIds && args.workflowIds.length > 0 ? { workflowId: { in: [...args.workflowIds] } } : {}),
+        ...(args.statuses && args.statuses.length > 0 ? { status: { in: [...args.statuses] } } : {}),
+        ...(args.names && args.names.length > 0 ? { name: { in: [...args.names] } } : {}),
+        ...(args.modelNames && args.modelNames.length > 0 ? { modelName: { in: [...args.modelNames] } } : {}),
+        ...(args.startTimeGte ? { startTime: { gte: args.startTimeGte } } : {}),
+        ...(args.endTimeLte ? { endTime: { lte: args.endTimeLte } } : {}),
+      },
+      orderBy: [{ startTime: "asc" }, { spanId: "asc" }],
+      ...(args.limit ? { take: args.limit } : {}),
+    });
+    return rows.map((row) => ({
+      traceId: row.traceId,
+      spanId: row.spanId,
+      parentSpanId: row.parentSpanId ?? undefined,
+      runId: row.runId,
+      workflowId: row.workflowId,
+      nodeId: row.nodeId ?? undefined,
+      activationId: row.activationId ?? undefined,
+      connectionInvocationId: row.connectionInvocationId ?? undefined,
+      name: row.name,
+      kind: row.kind as TelemetrySpanRecord["kind"],
+      status: row.status ? (row.status as TelemetrySpanRecord["status"]) : undefined,
+      statusMessage: row.statusMessage ?? undefined,
+      startTime: row.startTime ?? undefined,
+      endTime: row.endTime ?? undefined,
+      workflowFolder: row.workflowFolder ?? undefined,
+      nodeType: row.nodeType ?? undefined,
+      nodeRole: row.nodeRole ?? undefined,
+      modelName: row.modelName ?? undefined,
+      attributes: this.parseJson<TelemetryAttributes>(row.attributesJson),
+      events: this.parseJson<ReadonlyArray<TelemetrySpanEventRecord>>(row.eventsJson) ?? [],
+      retentionExpiresAt: row.retentionExpiresAt ?? undefined,
+    }));
+  }
+
+  async listByTraceId(traceId: string): Promise<ReadonlyArray<TelemetrySpanRecord>> {
+    return await this.list({ traceId });
+  }
+
+  async pruneExpired(args: Readonly<{ nowIso: string; limit?: number }>): Promise<number> {
+    const rows = await this.prisma.telemetrySpan.findMany({
+      where: {
+        retentionExpiresAt: {
+          lte: args.nowIso,
+        },
+      },
+      select: {
+        telemetrySpanId: true,
+      },
+      orderBy: [{ retentionExpiresAt: "asc" }, { telemetrySpanId: "asc" }],
+      ...(args.limit ? { take: args.limit } : {}),
+    });
+    if (rows.length === 0) {
+      return 0;
+    }
+    const result = await this.prisma.telemetrySpan.deleteMany({
+      where: {
+        telemetrySpanId: {
+          in: rows.map((row) => row.telemetrySpanId),
+        },
+      },
+    });
+    return result.count;
+  }
+
+  private createTelemetrySpanId(traceId: string, spanId: string): string {
+    return `${traceId}:${spanId}`;
+  }
+
+  private parseJson<T>(value: string | null): T | undefined {
+    if (!value) {
+      return undefined;
+    }
+    return JSON.parse(value) as T;
+  }
+
+  private mergeAttributes(
+    existing: TelemetryAttributes | undefined,
+    update: TelemetryAttributes | undefined,
+  ): TelemetryAttributes | undefined {
+    if (!existing && !update) {
+      return undefined;
+    }
+    return {
+      ...(existing ?? {}),
+      ...(update ?? {}),
+    };
+  }
+
+  private mergeEvents(
+    existing: ReadonlyArray<TelemetrySpanEventRecord> | undefined,
+    update: ReadonlyArray<TelemetrySpanEventRecord> | undefined,
+  ): Array<TelemetrySpanEventRecord> {
+    return [...(existing ?? []), ...(update ?? [])];
+  }
+}

package/src/infrastructure/persistence/PrismaWorkflowRunRepository.ts

@@ -402,21 +402,34 @@ export class PrismaWorkflowRunRepository implements WorkflowRunRepository, Workf
   }
 
   async listRunsOlderThan(
-    args: Readonly<{ beforeIso: string; limit?: number }>,
+    args: Readonly<{ nowIso: string; defaultRetentionSeconds: number; limit?: number }>,
   ): Promise<ReadonlyArray<RunPruneCandidate>> {
     const limit = args.limit ?? 100;
     const rows = await this.prisma.run.findMany({
       where: {
         status: { in: ["completed", "failed"] },
-        OR: [
-          { AND: [{ finishedAt: { not: null } }, { finishedAt: { lt: args.beforeIso } }] },
-          { AND: [{ finishedAt: null }, { updatedAt: { lt: args.beforeIso } }] },
-        ],
+      },
+      select: {
+        runId: true,
+        workflowId: true,
+        startedAt: true,
+        finishedAt: true,
+        updatedAt: true,
+        policySnapshotJson: true,
       },
       orderBy: { updatedAt: "asc" },
-      take: limit,
+      take: limit * 4,
     });
-    return rows.map((r) => this.rowToPruneCandidate(r));
+    return rows
+      .filter((row) => {
+        const finishedAt = row.finishedAt ?? row.updatedAt;
+        const policySnapshot = this.parseJson<PersistedRunState["policySnapshot"]>(row.policySnapshotJson);
+        const retentionSeconds = policySnapshot?.retentionSeconds ?? args.defaultRetentionSeconds;
+        const cutoffIso = new Date(new Date(args.nowIso).getTime() - retentionSeconds * 1000).toISOString();
+        return finishedAt < cutoffIso;
+      })
+      .slice(0, limit)
+      .map((row) => this.rowToPruneCandidate(row));
   }
 
   private instancesToDomain(