@codemation/host 0.2.5 → 0.3.0

package/src/application/runs/WorkflowRunRetentionPruneScheduler.ts

@@ -5,15 +5,23 @@ import type { Logger } from "../logging/Logger";
 import { ApplicationTokens } from "../../applicationTokens";
 import type { AppConfig } from "../../presentation/config/AppConfig";
 import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
+import type {
+  TelemetryArtifactStore,
+  TelemetryMetricPointStore,
+  TelemetrySpanStore,
+} from "../../domain/telemetry/TelemetryContracts";
 import { ServerLoggerFactory } from "../../infrastructure/logging/ServerLoggerFactory";
 
 /**
  * Periodically deletes terminal workflow runs whose age exceeds the effective retention
  * (`policySnapshot.retentionSeconds` or `CODEMATION_RUN_RETENTION_DEFAULT_SECONDS`),
- * and removes binary blobs referenced from run state via {@link BinaryStorage}.
+ * removes binary blobs referenced from run state via {@link BinaryStorage}, and
+ * independently prunes spans, artifacts, and metric points once their own retention
+ * timestamps expire.
  */
 @injectable()
 export class WorkflowRunRetentionPruneScheduler {
+  private static readonly defaultIntervalMs = 60 * 60 * 1_000;
   private timer: ReturnType<typeof setInterval> | undefined;
   private readonly logger: Logger;
 
@@ -21,6 +29,10 @@ export class WorkflowRunRetentionPruneScheduler {
     @inject(ApplicationTokens.Clock) private readonly clock: Clock,
     @inject(ApplicationTokens.WorkflowRunRepository) private readonly runs: WorkflowRunRepository,
     @inject(CoreTokens.BinaryStorage) private readonly binaryStorage: BinaryStorage,
+    @inject(ApplicationTokens.TelemetrySpanStore) private readonly telemetrySpanStore: TelemetrySpanStore,
+    @inject(ApplicationTokens.TelemetryArtifactStore) private readonly telemetryArtifactStore: TelemetryArtifactStore,
+    @inject(ApplicationTokens.TelemetryMetricPointStore)
+    private readonly telemetryMetricPointStore: TelemetryMetricPointStore,
     @inject(ApplicationTokens.AppConfig) private readonly appConfig: AppConfig,
     @inject(ServerLoggerFactory) loggerFactory: ServerLoggerFactory,
   ) {
@@ -28,17 +40,21 @@ export class WorkflowRunRetentionPruneScheduler {
   }
 
   start(): void {
-    if (this.appConfig.env.CODEMATION_RUN_PRUNE_ENABLED === "false") {
+    if (
+      this.appConfig.env.CODEMATION_RUN_PRUNE_ENABLED === "false" &&
+      this.appConfig.env.CODEMATION_TELEMETRY_PRUNE_ENABLED === "false"
+    ) {
       return;
     }
     if (this.timer) {
       return;
     }
-    const intervalMs = Number(this.appConfig.env.CODEMATION_RUN_PRUNE_INTERVAL_MS ?? 60_000);
+    const intervalMs = Number(
+      this.appConfig.env.CODEMATION_RUN_PRUNE_INTERVAL_MS ?? WorkflowRunRetentionPruneScheduler.defaultIntervalMs,
+    );
+    void this.runScheduledTick();
     this.timer = setInterval(() => {
-      void this.runOnce().catch((error: unknown) => {
-        this.logger.warn(`Run retention prune tick failed: ${error instanceof Error ? error.message : String(error)}`);
-      });
+      void this.runScheduledTick();
     }, intervalMs);
   }
 
@@ -51,35 +67,64 @@ export class WorkflowRunRetentionPruneScheduler {
 
   /** Exposed for tests; production path is the interval started by {@link start}. */
   async runOnce(): Promise<void> {
-    this.logger.debug("Run retention prune: starting check");
     const defaultRetentionSec = Number(this.appConfig.env.CODEMATION_RUN_RETENTION_DEFAULT_SECONDS ?? 86_400);
-    const beforeIso = new Date(this.clock.now().getTime() - defaultRetentionSec * 1000).toISOString();
-    const summaries = await this.runs.listRunsOlderThan?.({ beforeIso, limit: 500 });
-    const candidates =
-      summaries ??
-      (await this.runs.listRuns({ limit: 500 })).filter(
-        (summary) => summary.status === "completed" || summary.status === "failed",
-      );
-
+    const nowIso = this.clock.now().toISOString();
     let foundCount = 0;
     let prunedCount = 0;
-    for (const candidate of candidates) {
-      const runId = candidate.runId as RunId;
-      const workflowId = candidate.workflowId as WorkflowId;
-      foundCount += 1;
+    if (this.appConfig.env.CODEMATION_RUN_PRUNE_ENABLED !== "false") {
+      const summaries = await this.runs.listRunsOlderThan?.({
+        nowIso,
+        defaultRetentionSeconds: defaultRetentionSec,
+        limit: 500,
+      });
+      const candidates =
+        summaries ??
+        (await this.runs.listRuns({ limit: 500 })).filter(
+          (summary) => summary.status === "completed" || summary.status === "failed",
+        );
+      for (const candidate of candidates) {
+        const runId = candidate.runId as RunId;
+        const workflowId = candidate.workflowId as WorkflowId;
+        foundCount += 1;
 
-      const storageKeys =
-        (await this.runs.listBinaryStorageKeys?.(runId)) ?? (await this.loadStorageKeysFromRunStateFallback(runId));
-      for (const key of storageKeys) {
-        await this.binaryStorage.delete(key);
+        const storageKeys =
+          (await this.runs.listBinaryStorageKeys?.(runId)) ?? (await this.loadStorageKeysFromRunStateFallback(runId));
+        for (const key of storageKeys) {
+          await this.binaryStorage.delete(key);
+        }
+        await this.runs.deleteRun(runId);
+        prunedCount += 1;
+        this.logger.debug(`Run retention prune: pruned run ${runId} for workflow ${workflowId}`);
       }
-      await this.runs.deleteRun(runId);
-      prunedCount += 1;
-      this.logger.debug(`Run retention prune: pruned run ${runId} for workflow ${workflowId}`);
     }
 
+    let prunedSpanCount = 0;
+    let prunedArtifactCount = 0;
+    let prunedMetricCount = 0;
+    if (this.appConfig.env.CODEMATION_TELEMETRY_PRUNE_ENABLED !== "false") {
+      const telemetryLimit = Number(this.appConfig.env.CODEMATION_TELEMETRY_PRUNE_LIMIT ?? 2_000);
+      prunedSpanCount = await this.telemetrySpanStore.pruneExpired({ nowIso, limit: telemetryLimit });
+      prunedArtifactCount = await this.telemetryArtifactStore.pruneExpired({ nowIso, limit: telemetryLimit });
+      prunedMetricCount = await this.telemetryMetricPointStore.pruneExpired({ nowIso, limit: telemetryLimit });
+    }
+
+    const totalPruned = foundCount + prunedCount + prunedSpanCount + prunedArtifactCount + prunedMetricCount;
+    if (totalPruned === 0) {
+      return;
+    }
     this.logger.info(`Run retention prune: found ${foundCount} run(s) to prune`);
     this.logger.info(`Run retention prune: pruned ${prunedCount} run(s)`);
+    this.logger.info(`Run retention prune: pruned ${prunedSpanCount} telemetry span(s)`);
+    this.logger.info(`Run retention prune: pruned ${prunedArtifactCount} telemetry artifact(s)`);
+    this.logger.info(`Run retention prune: pruned ${prunedMetricCount} telemetry metric point(s)`);
+  }
+
+  private async runScheduledTick(): Promise<void> {
+    try {
+      await this.runOnce();
+    } catch (error) {
+      this.logger.warn(`Run retention prune tick failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
 
   private async loadStorageKeysFromRunStateFallback(runId: RunId): Promise<ReadonlyArray<string>> {

package/src/application/telemetry/CompositeTelemetryExporter.ts

@@ -0,0 +1,13 @@
+import { injectable } from "@codemation/core";
+import type { TelemetryExporter, TelemetrySpanRecord } from "../../domain/telemetry/TelemetryContracts";
+
+@injectable()
+export class CompositeTelemetryExporter implements TelemetryExporter {
+  constructor(private readonly exporters: ReadonlyArray<TelemetryExporter>) {}
+
+  async exportSpans(spans: ReadonlyArray<TelemetrySpanRecord>): Promise<void> {
+    for (const exporter of this.exporters) {
+      await exporter.exportSpans(spans);
+    }
+  }
+}

package/src/application/telemetry/LazyExecutionTelemetryFactory.ts

@@ -0,0 +1,21 @@
+import type {
+  ExecutionTelemetry,
+  ExecutionTelemetryFactory,
+  ParentExecutionRef,
+  PersistedRunPolicySnapshot,
+} from "@codemation/core";
+
+export class LazyExecutionTelemetryFactory implements ExecutionTelemetryFactory {
+  constructor(private readonly resolveFactory: () => ExecutionTelemetryFactory) {}
+
+  create(
+    args: Readonly<{
+      runId: string;
+      workflowId: string;
+      parent?: ParentExecutionRef;
+      policySnapshot?: PersistedRunPolicySnapshot;
+    }>,
+  ): ExecutionTelemetry {
+    return this.resolveFactory().create(args);
+  }
+}

package/src/application/telemetry/NoOpTelemetryExporter.ts

@@ -0,0 +1,7 @@
+import { injectable } from "@codemation/core";
+import type { TelemetryExporter, TelemetrySpanRecord } from "../../domain/telemetry/TelemetryContracts";
+
+@injectable()
+export class NoOpTelemetryExporter implements TelemetryExporter {
+  async exportSpans(_: ReadonlyArray<TelemetrySpanRecord>): Promise<void> {}
+}

package/src/application/telemetry/OtelExecutionTelemetry.types.ts

@@ -0,0 +1,41 @@
+import type { PersistedRunPolicySnapshot, TelemetryAttributes } from "@codemation/core";
+import type {
+  RunTraceContextRepository,
+  TelemetryArtifactStore,
+  TelemetryMetricPointStore,
+  TelemetrySpanStore,
+} from "../../domain/telemetry/TelemetryContracts";
+import { OtelIdentityFactory } from "./OtelIdentityFactory";
+import { TelemetryEnricherChain } from "./TelemetryEnricherChain";
+import { TelemetryPrivacyPolicy } from "./TelemetryPrivacyPolicy";
+import { TelemetryRetentionTimestampFactory } from "./TelemetryRetentionTimestampFactory";
+
+export type StoredExecutionTelemetryDeps = Readonly<{
+  traceId: string;
+  rootSpanId: string;
+  runId: string;
+  workflowId: string;
+  policySnapshot?: PersistedRunPolicySnapshot;
+  runTraceContextRepository: RunTraceContextRepository;
+  telemetrySpanStore: TelemetrySpanStore;
+  telemetryArtifactStore: TelemetryArtifactStore;
+  telemetryMetricPointStore: TelemetryMetricPointStore;
+  telemetryEnricherChain: TelemetryEnricherChain;
+  telemetryPrivacyPolicy: TelemetryPrivacyPolicy;
+  telemetryRetentionTimestampFactory: TelemetryRetentionTimestampFactory;
+  otelIdentityFactory: OtelIdentityFactory;
+}>;
+
+export type StoredSpanScopeArgs = StoredExecutionTelemetryDeps &
+  Readonly<{
+    spanId: string;
+    parentSpanId?: string;
+    nodeId?: string;
+    activationId?: string;
+    spanName: string;
+    spanKind: "internal" | "client";
+    initialAttributes?: TelemetryAttributes;
+    initialStartTime?: Date;
+    connectionInvocationId?: string;
+    modelName?: string;
+  }>;

package/src/application/telemetry/OtelExecutionTelemetryFactory.ts

@@ -0,0 +1,56 @@
+import type { ExecutionTelemetry, ExecutionTelemetryFactory, PersistedRunPolicySnapshot } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
+import { ApplicationTokens } from "../../applicationTokens";
+import type {
+  RunTraceContextRepository,
+  TelemetryArtifactStore,
+  TelemetryMetricPointStore,
+  TelemetrySpanStore,
+} from "../../domain/telemetry/TelemetryContracts";
+import { OtelIdentityFactory } from "./OtelIdentityFactory";
+import { StoredExecutionTelemetry } from "./StoredExecutionTelemetry";
+import { TelemetryEnricherChain } from "./TelemetryEnricherChain";
+import { TelemetryPrivacyPolicy } from "./TelemetryPrivacyPolicy";
+import { TelemetryRetentionTimestampFactory } from "./TelemetryRetentionTimestampFactory";
+
+@injectable()
+export class OtelExecutionTelemetryFactory implements ExecutionTelemetryFactory {
+  constructor(
+    @inject(ApplicationTokens.RunTraceContextRepository)
+    private readonly runTraceContextRepository: RunTraceContextRepository,
+    @inject(ApplicationTokens.TelemetrySpanStore)
+    private readonly telemetrySpanStore: TelemetrySpanStore,
+    @inject(ApplicationTokens.TelemetryArtifactStore)
+    private readonly telemetryArtifactStore: TelemetryArtifactStore,
+    @inject(ApplicationTokens.TelemetryMetricPointStore)
+    private readonly telemetryMetricPointStore: TelemetryMetricPointStore,
+    @inject(TelemetryEnricherChain)
+    private readonly telemetryEnricherChain: TelemetryEnricherChain,
+    @inject(TelemetryPrivacyPolicy)
+    private readonly telemetryPrivacyPolicy: TelemetryPrivacyPolicy,
+    @inject(TelemetryRetentionTimestampFactory)
+    private readonly telemetryRetentionTimestampFactory: TelemetryRetentionTimestampFactory,
+    @inject(OtelIdentityFactory)
+    private readonly otelIdentityFactory: OtelIdentityFactory,
+  ) {}
+
+  create(
+    args: Readonly<{ runId: string; workflowId: string; policySnapshot?: PersistedRunPolicySnapshot }>,
+  ): ExecutionTelemetry {
+    return new StoredExecutionTelemetry({
+      traceId: this.otelIdentityFactory.createTraceId(args.runId),
+      rootSpanId: this.otelIdentityFactory.createRootSpanId(args.runId),
+      runId: args.runId,
+      workflowId: args.workflowId,
+      policySnapshot: args.policySnapshot,
+      runTraceContextRepository: this.runTraceContextRepository,
+      telemetrySpanStore: this.telemetrySpanStore,
+      telemetryArtifactStore: this.telemetryArtifactStore,
+      telemetryMetricPointStore: this.telemetryMetricPointStore,
+      telemetryEnricherChain: this.telemetryEnricherChain,
+      telemetryPrivacyPolicy: this.telemetryPrivacyPolicy,
+      telemetryRetentionTimestampFactory: this.telemetryRetentionTimestampFactory,
+      otelIdentityFactory: this.otelIdentityFactory,
+    });
+  }
+}

package/src/application/telemetry/OtelIdentityFactory.ts

@@ -0,0 +1,41 @@
+import { createHash, randomBytes } from "node:crypto";
+import { injectable } from "@codemation/core";
+
+@injectable()
+export class OtelIdentityFactory {
+  createTraceId(runId: string): string {
+    return this.hashToHex(runId, 32);
+  }
+
+  createRootSpanId(runId: string): string {
+    return this.hashToHex(`run:${runId}`, 16);
+  }
+
+  createNodeSpanId(activationId: string): string {
+    return this.hashToHex(`activation:${activationId}`, 16);
+  }
+
+  createConnectionInvocationSpanId(invocationId: string): string {
+    return this.hashToHex(`invocation:${invocationId}`, 16);
+  }
+
+  createArtifactId(): string {
+    return randomBytes(16).toString("hex");
+  }
+
+  createEphemeralSpanId(): string {
+    return randomBytes(8).toString("hex");
+  }
+
+  private hashToHex(value: string, length: number): string {
+    const hex = createHash("sha256").update(value).digest("hex").slice(0, length);
+    return this.ensureNonZeroHex(hex, length);
+  }
+
+  private ensureNonZeroHex(hex: string, length: number): string {
+    if (!/^0+$/.test(hex)) {
+      return hex;
+    }
+    return `${"0".repeat(Math.max(0, length - 1))}1`;
+  }
+}

package/src/application/telemetry/RunEventBusTelemetryReporter.ts

@@ -0,0 +1,188 @@
+import type { RunEvent, RunEventBus, RunEventSubscription } from "@codemation/core";
+import { CoreTokens, inject, injectable } from "@codemation/core";
+import type {
+  RunTraceContextRepository,
+  TelemetrySpanStore,
+  TelemetrySpanUpsert,
+} from "../../domain/telemetry/TelemetryContracts";
+import { ApplicationTokens } from "../../applicationTokens";
+import type { WorkflowRunRepository } from "../../domain/runs/WorkflowRunRepository";
+import { OtelIdentityFactory } from "./OtelIdentityFactory";
+import { TelemetryEnricherChain } from "./TelemetryEnricherChain";
+import { TelemetryRetentionTimestampFactory } from "./TelemetryRetentionTimestampFactory";
+
+@injectable()
+export class RunEventBusTelemetryReporter {
+  private subscription: RunEventSubscription | null = null;
+
+  constructor(
+    @inject(CoreTokens.RunEventBus)
+    private readonly runEventBus: RunEventBus,
+    @inject(ApplicationTokens.RunTraceContextRepository)
+    private readonly runTraceContextRepository: RunTraceContextRepository,
+    @inject(ApplicationTokens.WorkflowRunRepository)
+    private readonly workflowRunRepository: WorkflowRunRepository,
+    @inject(ApplicationTokens.TelemetrySpanStore)
+    private readonly telemetrySpanStore: TelemetrySpanStore,
+    @inject(TelemetryEnricherChain)
+    private readonly telemetryEnricherChain: TelemetryEnricherChain,
+    @inject(TelemetryRetentionTimestampFactory)
+    private readonly telemetryRetentionTimestampFactory: TelemetryRetentionTimestampFactory,
+    @inject(OtelIdentityFactory)
+    private readonly otelIdentityFactory: OtelIdentityFactory,
+  ) {}
+
+  async start(): Promise<void> {
+    if (this.subscription) {
+      return;
+    }
+    this.subscription = await this.runEventBus.subscribe(async (event) => {
+      try {
+        await this.handleEvent(event);
+      } catch {
+        // Telemetry must remain best-effort so workflow execution does not fail on observer persistence races.
+      }
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (!this.subscription) {
+      return;
+    }
+    await this.subscription.close();
+    this.subscription = null;
+  }
+
+  private async handleEvent(event: RunEvent): Promise<void> {
+    switch (event.kind) {
+      case "runCreated":
+        await this.handleRunCreated(event);
+        return;
+      case "runSaved":
+        await this.handleRunSaved(event);
+        return;
+      case "nodeQueued":
+      case "nodeStarted":
+      case "nodeCompleted":
+      case "nodeFailed":
+        await this.handleNodeSnapshot(event);
+        return;
+    }
+  }
+
+  private async handleRunCreated(event: Extract<RunEvent, { kind: "runCreated" }>): Promise<void> {
+    const trace = await this.runTraceContextRepository.getOrCreate({
+      runId: event.runId,
+      workflowId: event.workflowId,
+      serviceName: "codemation.workflow",
+    });
+    const policySnapshot = await this.loadPolicySnapshot(event.runId);
+    await this.runTraceContextRepository.upsertExpiry({
+      runId: event.runId,
+      expiresAt: this.telemetryRetentionTimestampFactory.createTraceContextExpiry(policySnapshot, new Date(event.at)),
+    });
+    const enrichment = await this.telemetryEnricherChain.enrichRun(event.workflowId);
+    await this.telemetrySpanStore.upsert({
+      traceId: trace.traceId,
+      spanId: trace.rootSpanId,
+      runId: event.runId,
+      workflowId: event.workflowId,
+      name: "workflow.run",
+      kind: "internal",
+      status: "running",
+      startTime: event.at,
+      workflowFolder: enrichment.workflowFolder,
+      retentionExpiresAt: this.telemetryRetentionTimestampFactory.createSpanExpiry(policySnapshot, new Date(event.at)),
+    });
+  }
+
+  private async handleRunSaved(event: Extract<RunEvent, { kind: "runSaved" }>): Promise<void> {
+    const trace = await this.runTraceContextRepository.getOrCreate({
+      runId: event.runId,
+      workflowId: event.workflowId,
+      serviceName: "codemation.workflow",
+    });
+    const policySnapshot = await this.loadPolicySnapshot(event.runId);
+    const observedAt = new Date(event.state.finishedAt ?? event.at);
+    await this.runTraceContextRepository.upsertExpiry({
+      runId: event.runId,
+      expiresAt: this.telemetryRetentionTimestampFactory.createTraceContextExpiry(policySnapshot, observedAt),
+    });
+    const enrichment = await this.telemetryEnricherChain.enrichRun(event.workflowId);
+    const isTerminal = event.state.status === "completed" || event.state.status === "failed";
+    await this.telemetrySpanStore.upsert({
+      traceId: trace.traceId,
+      spanId: trace.rootSpanId,
+      runId: event.runId,
+      workflowId: event.workflowId,
+      name: "workflow.run",
+      kind: "internal",
+      status: event.state.status === "failed" ? "failed" : isTerminal ? "completed" : "running",
+      startTime: event.state.startedAt,
+      endTime: isTerminal ? (event.state.finishedAt ?? event.at) : undefined,
+      workflowFolder: enrichment.workflowFolder,
+      retentionExpiresAt: this.telemetryRetentionTimestampFactory.createSpanExpiry(policySnapshot, observedAt),
+    });
+  }
+
+  private async handleNodeSnapshot(
+    event: Extract<RunEvent, { kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed" }>,
+  ): Promise<void> {
+    const trace = await this.runTraceContextRepository.getOrCreate({
+      runId: event.runId,
+      workflowId: event.workflowId,
+      serviceName: "codemation.workflow",
+    });
+    const policySnapshot = await this.loadPolicySnapshot(event.runId);
+    await this.runTraceContextRepository.upsertExpiry({
+      runId: event.runId,
+      expiresAt: this.telemetryRetentionTimestampFactory.createTraceContextExpiry(policySnapshot, new Date(event.at)),
+    });
+    const enrichment = await this.telemetryEnricherChain.enrichNode({
+      workflowId: event.workflowId,
+      nodeId: event.snapshot.nodeId,
+    });
+    await this.telemetrySpanStore.upsert(
+      this.createNodeSpanUpsert(event, trace.traceId, trace.rootSpanId, enrichment, policySnapshot),
+    );
+  }
+
+  private createNodeSpanUpsert(
+    event: Extract<RunEvent, { kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed" }>,
+    traceId: string,
+    rootSpanId: string,
+    enrichment: Readonly<{ workflowFolder?: string; nodeType?: string; nodeRole?: string }>,
+    policySnapshot: Awaited<ReturnType<RunEventBusTelemetryReporter["loadPolicySnapshot"]>>,
+  ): TelemetrySpanUpsert {
+    const snapshot = event.snapshot;
+    const status = event.kind === "nodeFailed" ? "failed" : snapshot.finishedAt ? "completed" : "running";
+    const observedAt = new Date(snapshot.finishedAt ?? snapshot.startedAt ?? snapshot.queuedAt ?? event.at);
+    return {
+      traceId,
+      spanId: this.otelIdentityFactory.createNodeSpanId(snapshot.activationId ?? snapshot.nodeId),
+      parentSpanId: rootSpanId,
+      runId: event.runId,
+      workflowId: event.workflowId,
+      nodeId: snapshot.nodeId,
+      activationId: snapshot.activationId,
+      name: "workflow.node",
+      kind: "internal",
+      status,
+      statusMessage: snapshot.error?.message,
+      startTime: snapshot.startedAt ?? snapshot.queuedAt ?? event.at,
+      endTime: snapshot.finishedAt,
+      workflowFolder: enrichment.workflowFolder,
+      nodeType: enrichment.nodeType,
+      nodeRole: enrichment.nodeRole,
+      retentionExpiresAt: this.telemetryRetentionTimestampFactory.createSpanExpiry(policySnapshot, observedAt),
+      attributes: {
+        usedPinnedOutput: snapshot.usedPinnedOutput ?? undefined,
+      },
+    };
+  }
+
+  private async loadPolicySnapshot(runId: string) {
+    const state = await this.workflowRunRepository.load(runId);
+    return state?.policySnapshot;
+  }
+}

package/src/application/telemetry/StoredExecutionTelemetry.ts

@@ -0,0 +1,56 @@
+import type {
+  ExecutionTelemetry,
+  NodeExecutionTelemetry,
+  TelemetryArtifactAttachment,
+  TelemetryArtifactReference,
+  TelemetryMetricRecord,
+  TelemetrySpanEventRecord,
+} from "@codemation/core";
+import { StoredNodeExecutionTelemetry } from "./StoredNodeExecutionTelemetry";
+import { StoredTelemetrySpanScope } from "./StoredTelemetrySpanScope";
+import type { StoredExecutionTelemetryDeps } from "./OtelExecutionTelemetry.types";
+
+export class StoredExecutionTelemetry implements ExecutionTelemetry {
+  readonly traceId: string;
+  readonly spanId: string;
+
+  constructor(private readonly deps: StoredExecutionTelemetryDeps) {
+    this.traceId = deps.traceId;
+    this.spanId = deps.rootSpanId;
+  }
+
+  async addSpanEvent(args: TelemetrySpanEventRecord): Promise<void> {
+    await this.createRunScope().addSpanEvent(args);
+  }
+
+  async recordMetric(args: TelemetryMetricRecord): Promise<void> {
+    await this.createRunScope().recordMetric(args);
+  }
+
+  async attachArtifact(args: TelemetryArtifactAttachment): Promise<TelemetryArtifactReference> {
+    return await this.createRunScope().attachArtifact(args);
+  }
+
+  forNode(args: Readonly<{ nodeId: string; activationId: string }>): NodeExecutionTelemetry {
+    // eslint-disable-next-line codemation/no-manual-di-new
+    return new StoredNodeExecutionTelemetry({
+      ...this.deps,
+      spanId: this.deps.otelIdentityFactory.createNodeSpanId(args.activationId),
+      parentSpanId: this.deps.rootSpanId,
+      nodeId: args.nodeId,
+      activationId: args.activationId,
+      spanName: "workflow.node",
+      spanKind: "internal",
+    });
+  }
+
+  private createRunScope(): StoredTelemetrySpanScope {
+    // eslint-disable-next-line codemation/no-manual-di-new
+    return new StoredTelemetrySpanScope({
+      ...this.deps,
+      spanId: this.deps.rootSpanId,
+      spanName: "workflow.run",
+      spanKind: "internal",
+    });
+  }
+}

package/src/application/telemetry/StoredNodeExecutionTelemetry.ts

@@ -0,0 +1,35 @@
+import type { NodeExecutionTelemetry, TelemetryChildSpanStart, TelemetrySpanScope } from "@codemation/core";
+import { GenAiTelemetryAttributeNames } from "@codemation/core";
+import type { StoredSpanScopeArgs } from "./OtelExecutionTelemetry.types";
+import { StoredTelemetrySpanScope } from "./StoredTelemetrySpanScope";
+
+export class StoredNodeExecutionTelemetry extends StoredTelemetrySpanScope implements NodeExecutionTelemetry {
+  constructor(args: StoredSpanScopeArgs) {
+    super(args);
+  }
+
+  forNode(_: Readonly<{ nodeId: string; activationId: string }>): NodeExecutionTelemetry {
+    return this;
+  }
+
+  startChildSpan(args: TelemetryChildSpanStart): TelemetrySpanScope {
+    // eslint-disable-next-line codemation/no-manual-di-new
+    const span = new StoredTelemetrySpanScope({
+      ...this.deps,
+      spanId: this.deps.otelIdentityFactory.createEphemeralSpanId(),
+      parentSpanId: this.spanId,
+      nodeId: this.nodeId,
+      activationId: this.activationId,
+      spanName: args.name,
+      spanKind: args.kind ?? "internal",
+      initialAttributes: args.attributes,
+      initialStartTime: args.startedAt,
+      connectionInvocationId: this.toStringAttribute(
+        args.attributes?.["codemation.connection.invocation_id"] ?? args.attributes?.["connection.invocation_id"],
+      ),
+      modelName: this.toStringAttribute(args.attributes?.[GenAiTelemetryAttributeNames.requestModel]),
+    });
+    void span.markStarted();
+    return span;
+  }
+}