@codemation/host 0.2.5 → 0.3.0

package/src/infrastructure/persistence/InMemoryRunTraceContextRepository.ts

@@ -0,0 +1,56 @@
+import { inject, injectable } from "@codemation/core";
+import { OtelIdentityFactory } from "../../application/telemetry/OtelIdentityFactory";
+import type { RunTraceContextRepository, TelemetryTraceContext } from "../../domain/telemetry/TelemetryContracts";
+
+@injectable()
+export class InMemoryRunTraceContextRepository implements RunTraceContextRepository {
+  private readonly rows = new Map<string, TelemetryTraceContext>();
+
+  constructor(@inject(OtelIdentityFactory) private readonly otelIdentityFactory: OtelIdentityFactory) {}
+
+  async load(runId: string): Promise<TelemetryTraceContext | undefined> {
+    return this.rows.get(decodeURIComponent(runId));
+  }
+
+  async getOrCreate(
+    args: Readonly<{ runId: string; workflowId: string; serviceName?: string }>,
+  ): Promise<TelemetryTraceContext> {
+    const key = decodeURIComponent(args.runId);
+    const existing = this.rows.get(key);
+    if (existing) {
+      return existing;
+    }
+    const created: TelemetryTraceContext = {
+      runId: key,
+      workflowId: decodeURIComponent(args.workflowId),
+      traceId: this.otelIdentityFactory.createTraceId(key),
+      rootSpanId: this.otelIdentityFactory.createRootSpanId(key),
+      serviceName: args.serviceName,
+      createdAt: new Date().toISOString(),
+    };
+    this.rows.set(key, created);
+    return created;
+  }
+
+  async upsertExpiry(args: Readonly<{ runId: string; expiresAt?: string }>): Promise<void> {
+    const key = decodeURIComponent(args.runId);
+    const existing = this.rows.get(key);
+    if (!existing) {
+      return;
+    }
+    this.rows.set(key, {
+      ...existing,
+      expiresAt: this.resolveLaterExpiry(existing.expiresAt, args.expiresAt),
+    });
+  }
+
+  private resolveLaterExpiry(current: string | undefined, candidate: string | undefined): string | undefined {
+    if (!current) {
+      return candidate;
+    }
+    if (!candidate) {
+      return current;
+    }
+    return current >= candidate ? current : candidate;
+  }
+}

package/src/infrastructure/persistence/InMemoryTelemetryArtifactStore.ts

@@ -0,0 +1,56 @@
+import { inject, injectable } from "@codemation/core";
+import { OtelIdentityFactory } from "../../application/telemetry/OtelIdentityFactory";
+import type {
+  TelemetryArtifactRecord,
+  TelemetryArtifactStore,
+  TelemetryArtifactWrite,
+} from "../../domain/telemetry/TelemetryContracts";
+
+@injectable()
+export class InMemoryTelemetryArtifactStore implements TelemetryArtifactStore {
+  private readonly rows = new Map<string, TelemetryArtifactRecord>();
+
+  constructor(@inject(OtelIdentityFactory) private readonly otelIdentityFactory: OtelIdentityFactory) {}
+
+  async save(record: TelemetryArtifactWrite): Promise<TelemetryArtifactRecord> {
+    const created: TelemetryArtifactRecord = {
+      artifactId: this.otelIdentityFactory.createArtifactId(),
+      traceId: record.traceId,
+      spanId: record.spanId,
+      runId: record.runId,
+      workflowId: record.workflowId,
+      nodeId: record.nodeId,
+      activationId: record.activationId,
+      kind: record.kind,
+      contentType: record.contentType,
+      previewText: record.previewText,
+      previewJson: record.previewJson,
+      payloadText: record.payloadText,
+      payloadJson: record.payloadJson,
+      bytes: record.bytes,
+      truncated: record.truncated,
+      createdAt: new Date().toISOString(),
+      expiresAt: record.expiresAt?.toISOString(),
+      retentionExpiresAt: record.retentionExpiresAt,
+    };
+    this.rows.set(created.artifactId, created);
+    return created;
+  }
+
+  async listByTraceId(traceId: string): Promise<ReadonlyArray<TelemetryArtifactRecord>> {
+    return [...this.rows.values()]
+      .filter((row) => row.traceId === traceId)
+      .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+  }
+
+  async pruneExpired(args: Readonly<{ nowIso: string; limit?: number }>): Promise<number> {
+    const candidates = [...this.rows.entries()]
+      .filter(([, row]) => row.retentionExpiresAt !== undefined && row.retentionExpiresAt <= args.nowIso)
+      .sort((left, right) => (left[1].retentionExpiresAt ?? "").localeCompare(right[1].retentionExpiresAt ?? ""))
+      .slice(0, args.limit ?? Number.MAX_SAFE_INTEGER);
+    for (const [key] of candidates) {
+      this.rows.delete(key);
+    }
+    return candidates.length;
+  }
+}

package/src/infrastructure/persistence/InMemoryTelemetryMetricPointStore.ts

@@ -0,0 +1,97 @@
+import { inject, injectable } from "@codemation/core";
+import { OtelIdentityFactory } from "../../application/telemetry/OtelIdentityFactory";
+import type {
+  TelemetryMetricPointListQuery,
+  TelemetryMetricPointRecord,
+  TelemetryMetricPointStore,
+  TelemetryMetricPointWrite,
+} from "../../domain/telemetry/TelemetryContracts";
+
+@injectable()
+export class InMemoryTelemetryMetricPointStore implements TelemetryMetricPointStore {
+  private readonly rows = new Map<string, TelemetryMetricPointRecord>();
+
+  constructor(@inject(OtelIdentityFactory) private readonly otelIdentityFactory: OtelIdentityFactory) {}
+
+  async save(record: TelemetryMetricPointWrite): Promise<TelemetryMetricPointRecord> {
+    const created: TelemetryMetricPointRecord = {
+      metricPointId: this.otelIdentityFactory.createArtifactId(),
+      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,
+    };
+    this.rows.set(created.metricPointId, created);
+    return created;
+  }
+
+  async list(args: TelemetryMetricPointListQuery = {}): Promise<ReadonlyArray<TelemetryMetricPointRecord>> {
+    return [...this.rows.values()]
+      .filter((row) => this.matches(row, args))
+      .sort((left, right) => {
+        const observedCompare = left.observedAt.localeCompare(right.observedAt);
+        if (observedCompare !== 0) {
+          return observedCompare;
+        }
+        return left.metricPointId.localeCompare(right.metricPointId);
+      })
+      .slice(0, args.limit ?? Number.MAX_SAFE_INTEGER);
+  }
+
+  async pruneExpired(args: Readonly<{ nowIso: string; limit?: number }>): Promise<number> {
+    const candidates = [...this.rows.entries()]
+      .filter(([, row]) => row.retentionExpiresAt !== undefined && row.retentionExpiresAt <= args.nowIso)
+      .sort((left, right) => (left[1].retentionExpiresAt ?? "").localeCompare(right[1].retentionExpiresAt ?? ""))
+      .slice(0, args.limit ?? Number.MAX_SAFE_INTEGER);
+    for (const [key] of candidates) {
+      this.rows.delete(key);
+    }
+    return candidates.length;
+  }
+
+  private matches(row: TelemetryMetricPointRecord, args: TelemetryMetricPointListQuery): boolean {
+    if (args.traceId && row.traceId !== args.traceId) {
+      return false;
+    }
+    if (args.runId && row.runId !== args.runId) {
+      return false;
+    }
+    if (args.runIds && args.runIds.length > 0 && (!row.runId || !args.runIds.includes(row.runId))) {
+      return false;
+    }
+    if (args.workflowId && row.workflowId !== args.workflowId) {
+      return false;
+    }
+    if (args.workflowIds && args.workflowIds.length > 0 && !args.workflowIds.includes(row.workflowId)) {
+      return false;
+    }
+    if (args.nodeId && row.nodeId !== args.nodeId) {
+      return false;
+    }
+    if (args.metricNames && args.metricNames.length > 0 && !args.metricNames.includes(row.metricName)) {
+      return false;
+    }
+    if (args.modelNames && args.modelNames.length > 0 && (!row.modelName || !args.modelNames.includes(row.modelName))) {
+      return false;
+    }
+    if (args.observedAtGte && row.observedAt < args.observedAtGte) {
+      return false;
+    }
+    if (args.observedAtLte && row.observedAt > args.observedAtLte) {
+      return false;
+    }
+    return true;
+  }
+}

package/src/infrastructure/persistence/InMemoryTelemetrySpanStore.ts

@@ -0,0 +1,113 @@
+import { injectable } from "@codemation/core";
+import type {
+  TelemetrySpanListQuery,
+  TelemetrySpanRecord,
+  TelemetrySpanStore,
+  TelemetrySpanUpsert,
+} from "../../domain/telemetry/TelemetryContracts";
+
+@injectable()
+export class InMemoryTelemetrySpanStore implements TelemetrySpanStore {
+  private readonly rows = new Map<string, TelemetrySpanRecord>();
+
+  async upsert(record: TelemetrySpanUpsert): Promise<void> {
+    const key = this.createKey(record.traceId, record.spanId);
+    const existing = this.rows.get(key);
+    this.rows.set(key, this.merge(existing, record));
+  }
+
+  async list(args: TelemetrySpanListQuery = {}): Promise<ReadonlyArray<TelemetrySpanRecord>> {
+    return [...this.rows.values()]
+      .filter((row) => this.matches(row, args))
+      .sort((left, right) => {
+        const startCompare = (left.startTime ?? "").localeCompare(right.startTime ?? "");
+        if (startCompare !== 0) {
+          return startCompare;
+        }
+        return left.spanId.localeCompare(right.spanId);
+      })
+      .slice(0, args.limit ?? Number.MAX_SAFE_INTEGER);
+  }
+
+  async listByTraceId(traceId: string): Promise<ReadonlyArray<TelemetrySpanRecord>> {
+    return await this.list({ traceId });
+  }
+
+  private createKey(traceId: string, spanId: string): string {
+    return `${traceId}:${spanId}`;
+  }
+
+  private merge(existing: TelemetrySpanRecord | undefined, update: TelemetrySpanUpsert): TelemetrySpanRecord {
+    return {
+      traceId: update.traceId,
+      spanId: update.spanId,
+      parentSpanId: update.parentSpanId ?? existing?.parentSpanId,
+      runId: update.runId,
+      workflowId: update.workflowId,
+      nodeId: update.nodeId ?? existing?.nodeId,
+      activationId: update.activationId ?? existing?.activationId,
+      connectionInvocationId: update.connectionInvocationId ?? existing?.connectionInvocationId,
+      name: update.name ?? existing?.name ?? "codemation.span",
+      kind: update.kind ?? existing?.kind ?? "internal",
+      status: update.status ?? existing?.status,
+      statusMessage: update.statusMessage ?? existing?.statusMessage,
+      startTime: update.startTime ?? existing?.startTime,
+      endTime: update.endTime ?? existing?.endTime,
+      workflowFolder: update.workflowFolder ?? existing?.workflowFolder,
+      nodeType: update.nodeType ?? existing?.nodeType,
+      nodeRole: update.nodeRole ?? existing?.nodeRole,
+      modelName: update.modelName ?? existing?.modelName,
+      attributes: {
+        ...(existing?.attributes ?? {}),
+        ...(update.attributes ?? {}),
+      },
+      events: [...(existing?.events ?? []), ...(update.events ?? [])],
+      retentionExpiresAt: update.retentionExpiresAt ?? existing?.retentionExpiresAt,
+    };
+  }
+
+  private matches(row: TelemetrySpanRecord, args: TelemetrySpanListQuery): boolean {
+    if (args.traceId && row.traceId !== args.traceId) {
+      return false;
+    }
+    if (args.runId && row.runId !== args.runId) {
+      return false;
+    }
+    if (args.runIds && args.runIds.length > 0 && !args.runIds.includes(row.runId)) {
+      return false;
+    }
+    if (args.workflowId && row.workflowId !== args.workflowId) {
+      return false;
+    }
+    if (args.workflowIds && args.workflowIds.length > 0 && !args.workflowIds.includes(row.workflowId)) {
+      return false;
+    }
+    if (args.statuses && args.statuses.length > 0 && (!row.status || !args.statuses.includes(row.status))) {
+      return false;
+    }
+    if (args.names && args.names.length > 0 && !args.names.includes(row.name)) {
+      return false;
+    }
+    if (args.modelNames && args.modelNames.length > 0 && (!row.modelName || !args.modelNames.includes(row.modelName))) {
+      return false;
+    }
+    if (args.startTimeGte && row.startTime && row.startTime < args.startTimeGte) {
+      return false;
+    }
+    if (args.endTimeLte && row.endTime && row.endTime > args.endTimeLte) {
+      return false;
+    }
+    return true;
+  }
+
+  async pruneExpired(args: Readonly<{ nowIso: string; limit?: number }>): Promise<number> {
+    const candidates = [...this.rows.entries()]
+      .filter(([, row]) => row.retentionExpiresAt !== undefined && row.retentionExpiresAt <= args.nowIso)
+      .sort((left, right) => (left[1].retentionExpiresAt ?? "").localeCompare(right[1].retentionExpiresAt ?? ""))
+      .slice(0, args.limit ?? Number.MAX_SAFE_INTEGER);
+    for (const [key] of candidates) {
+      this.rows.delete(key);
+    }
+    return candidates.length;
+  }
+}

package/src/infrastructure/persistence/InMemoryWorkflowRunRepository.ts

@@ -160,14 +160,16 @@ export class InMemoryWorkflowRunRepository implements WorkflowRunRepository, Wor
   }
 
   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 out: RunPruneCandidate[] = [];
     for (const s of this.runs.values()) {
       if (s.status !== "completed" && s.status !== "failed") continue;
       const finishedAt = RunFinishedAtFactory.resolveIso(s);
-      if (!finishedAt || finishedAt >= args.beforeIso) continue;
+      const retentionSeconds = s.policySnapshot?.retentionSeconds ?? args.defaultRetentionSeconds;
+      const cutoffIso = new Date(new Date(args.nowIso).getTime() - retentionSeconds * 1000).toISOString();
+      if (!finishedAt || finishedAt >= cutoffIso) continue;
       out.push({
         runId: s.runId,
         workflowId: s.workflowId,

package/src/infrastructure/persistence/PrismaRunTraceContextRepository.ts

@@ -0,0 +1,92 @@
+import { inject, injectable } from "@codemation/core";
+import { OtelIdentityFactory } from "../../application/telemetry/OtelIdentityFactory";
+import type { RunTraceContextRepository, TelemetryTraceContext } from "../../domain/telemetry/TelemetryContracts";
+import { PrismaDatabaseClientToken, type PrismaDatabaseClient } from "./PrismaDatabaseClient";
+
+@injectable()
+export class PrismaRunTraceContextRepository implements RunTraceContextRepository {
+  constructor(
+    @inject(PrismaDatabaseClientToken)
+    private readonly prisma: PrismaDatabaseClient,
+    @inject(OtelIdentityFactory)
+    private readonly otelIdentityFactory: OtelIdentityFactory,
+  ) {}
+
+  async load(runId: string): Promise<TelemetryTraceContext | undefined> {
+    const row = await this.prisma.runTraceContext.findUnique({
+      where: { runId: decodeURIComponent(runId) },
+    });
+    if (!row) {
+      return undefined;
+    }
+    return {
+      runId: row.runId,
+      workflowId: row.workflowId,
+      traceId: row.traceId,
+      rootSpanId: row.rootSpanId,
+      serviceName: row.serviceName ?? undefined,
+      createdAt: row.createdAt,
+      expiresAt: row.expiresAt ?? undefined,
+    };
+  }
+
+  async getOrCreate(
+    args: Readonly<{ runId: string; workflowId: string; serviceName?: string }>,
+  ): Promise<TelemetryTraceContext> {
+    const existing = await this.load(args.runId);
+    if (existing) {
+      return existing;
+    }
+    const created: TelemetryTraceContext = {
+      runId: decodeURIComponent(args.runId),
+      workflowId: decodeURIComponent(args.workflowId),
+      traceId: this.otelIdentityFactory.createTraceId(args.runId),
+      rootSpanId: this.otelIdentityFactory.createRootSpanId(args.runId),
+      serviceName: args.serviceName,
+      createdAt: new Date().toISOString(),
+    };
+    await this.prisma.runTraceContext.create({
+      data: {
+        runId: created.runId,
+        workflowId: created.workflowId,
+        traceId: created.traceId,
+        rootSpanId: created.rootSpanId,
+        serviceName: created.serviceName ?? null,
+        createdAt: created.createdAt,
+        expiresAt: null,
+      },
+    });
+    return created;
+  }
+
+  async upsertExpiry(args: Readonly<{ runId: string; expiresAt?: string }>): Promise<void> {
+    if (!args.expiresAt) {
+      return;
+    }
+    const runId = decodeURIComponent(args.runId);
+    const existing = await this.prisma.runTraceContext.findUnique({
+      where: { runId },
+      select: { expiresAt: true },
+    });
+    if (!existing) {
+      return;
+    }
+    const expiresAt = this.resolveLaterExpiry(existing.expiresAt ?? undefined, args.expiresAt);
+    await this.prisma.runTraceContext.update({
+      where: { runId },
+      data: {
+        expiresAt: expiresAt ?? null,
+      },
+    });
+  }
+
+  private resolveLaterExpiry(current: string | undefined, candidate: string | undefined): string | undefined {
+    if (!current) {
+      return candidate;
+    }
+    if (!candidate) {
+      return current;
+    }
+    return current >= candidate ? current : candidate;
+  }
+}

package/src/infrastructure/persistence/PrismaTelemetryArtifactStore.ts

@@ -0,0 +1,125 @@
+import { inject, injectable } from "@codemation/core";
+import { OtelIdentityFactory } from "../../application/telemetry/OtelIdentityFactory";
+import type {
+  TelemetryArtifactRecord,
+  TelemetryArtifactStore,
+  TelemetryArtifactWrite,
+} from "../../domain/telemetry/TelemetryContracts";
+import { PrismaDatabaseClientToken, type PrismaDatabaseClient } from "./PrismaDatabaseClient";
+
+@injectable()
+export class PrismaTelemetryArtifactStore implements TelemetryArtifactStore {
+  constructor(
+    @inject(PrismaDatabaseClientToken)
+    private readonly prisma: PrismaDatabaseClient,
+    @inject(OtelIdentityFactory)
+    private readonly otelIdentityFactory: OtelIdentityFactory,
+  ) {}
+
+  async save(record: TelemetryArtifactWrite): Promise<TelemetryArtifactRecord> {
+    const artifactId = this.otelIdentityFactory.createArtifactId();
+    const createdAt = new Date().toISOString();
+    await this.prisma.telemetryArtifact.create({
+      data: {
+        artifactId,
+        traceId: record.traceId,
+        spanId: record.spanId,
+        runId: record.runId,
+        workflowId: record.workflowId,
+        nodeId: record.nodeId ?? null,
+        activationId: record.activationId ?? null,
+        kind: record.kind,
+        contentType: record.contentType,
+        previewText: record.previewText ?? null,
+        previewJson: record.previewJson !== undefined ? JSON.stringify(record.previewJson) : null,
+        payloadText: record.payloadText ?? null,
+        payloadJson: record.payloadJson !== undefined ? JSON.stringify(record.payloadJson) : null,
+        bytes: record.bytes ?? null,
+        truncated: record.truncated ?? null,
+        createdAt,
+        expiresAt: record.expiresAt?.toISOString() ?? null,
+        retentionExpiresAt: record.retentionExpiresAt ?? null,
+      },
+    });
+    return {
+      artifactId,
+      traceId: record.traceId,
+      spanId: record.spanId,
+      runId: record.runId,
+      workflowId: record.workflowId,
+      nodeId: record.nodeId,
+      activationId: record.activationId,
+      kind: record.kind,
+      contentType: record.contentType,
+      previewText: record.previewText,
+      previewJson: record.previewJson,
+      payloadText: record.payloadText,
+      payloadJson: record.payloadJson,
+      bytes: record.bytes,
+      truncated: record.truncated,
+      createdAt,
+      expiresAt: record.expiresAt?.toISOString(),
+      retentionExpiresAt: record.retentionExpiresAt,
+    };
+  }
+
+  async listByTraceId(traceId: string): Promise<ReadonlyArray<TelemetryArtifactRecord>> {
+    const rows = await this.prisma.telemetryArtifact.findMany({
+      where: { traceId },
+      orderBy: [{ createdAt: "asc" }, { artifactId: "asc" }],
+    });
+    return rows.map((row) => ({
+      artifactId: row.artifactId,
+      traceId: row.traceId,
+      spanId: row.spanId,
+      runId: row.runId,
+      workflowId: row.workflowId,
+      nodeId: row.nodeId ?? undefined,
+      activationId: row.activationId ?? undefined,
+      kind: row.kind,
+      contentType: row.contentType,
+      previewText: row.previewText ?? undefined,
+      previewJson: this.parseJson(row.previewJson),
+      payloadText: row.payloadText ?? undefined,
+      payloadJson: this.parseJson(row.payloadJson),
+      bytes: row.bytes ?? undefined,
+      truncated: row.truncated ?? undefined,
+      createdAt: row.createdAt,
+      expiresAt: row.expiresAt ?? undefined,
+      retentionExpiresAt: row.retentionExpiresAt ?? undefined,
+    }));
+  }
+
+  async pruneExpired(args: Readonly<{ nowIso: string; limit?: number }>): Promise<number> {
+    const rows = await this.prisma.telemetryArtifact.findMany({
+      where: {
+        retentionExpiresAt: {
+          lte: args.nowIso,
+        },
+      },
+      select: {
+        artifactId: true,
+      },
+      orderBy: [{ retentionExpiresAt: "asc" }, { artifactId: "asc" }],
+      ...(args.limit ? { take: args.limit } : {}),
+    });
+    if (rows.length === 0) {
+      return 0;
+    }
+    const result = await this.prisma.telemetryArtifact.deleteMany({
+      where: {
+        artifactId: {
+          in: rows.map((row) => row.artifactId),
+        },
+      },
+    });
+    return result.count;
+  }
+
+  private parseJson(value: string | null): unknown {
+    if (!value) {
+      return undefined;
+    }
+    return JSON.parse(value);
+  }
+}