@codemation/host 0.2.5 → 0.3.0

package/src/application/telemetry/TelemetryRetentionTimestampFactory.ts

@@ -0,0 +1,40 @@
+import type { PersistedRunPolicySnapshot } from "@codemation/core";
+import { injectable } from "@codemation/core";
+
+@injectable()
+export class TelemetryRetentionTimestampFactory {
+  createSpanExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string | undefined {
+    return this.createExpiry(policySnapshot?.telemetrySpanRetentionSeconds, observedAt);
+  }
+
+  createArtifactExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string | undefined {
+    return this.createExpiry(policySnapshot?.telemetryArtifactRetentionSeconds, observedAt);
+  }
+
+  createMetricExpiry(policySnapshot: PersistedRunPolicySnapshot | undefined, observedAt: Date): string | undefined {
+    return this.createExpiry(policySnapshot?.telemetryMetricRetentionSeconds, observedAt);
+  }
+
+  createTraceContextExpiry(
+    policySnapshot: PersistedRunPolicySnapshot | undefined,
+    observedAt: Date,
+  ): string | undefined {
+    const candidates = [
+      policySnapshot?.telemetrySpanRetentionSeconds,
+      policySnapshot?.telemetryArtifactRetentionSeconds,
+      policySnapshot?.telemetryMetricRetentionSeconds,
+    ].filter((value): value is number => typeof value === "number" && value > 0);
+    if (candidates.length === 0) {
+      return undefined;
+    }
+    const maxSeconds = Math.max(...candidates);
+    return this.createExpiry(maxSeconds, observedAt);
+  }
+
+  private createExpiry(retentionSeconds: number | undefined, observedAt: Date): string | undefined {
+    if (!retentionSeconds || retentionSeconds <= 0) {
+      return undefined;
+    }
+    return new Date(observedAt.getTime() + retentionSeconds * 1000).toISOString();
+  }
+}

package/src/applicationTokens.ts

@@ -12,6 +12,13 @@ import type { QueryHandler } from "./application/bus/QueryHandler";
 import type { Logger, LoggerFactory } from "./application/logging/Logger";
 import type { WorkflowWebsocketPublisher } from "./application/websocket/WorkflowWebsocketPublisher";
 import type { CredentialStore } from "./domain/credentials/CredentialServices";
+import type {
+  RunTraceContextRepository,
+  TelemetryArtifactStore,
+  TelemetryExporter,
+  TelemetryMetricPointStore,
+  TelemetrySpanStore,
+} from "./domain/telemetry/TelemetryContracts";
 import type { WorkflowRunRepository } from "./domain/runs/WorkflowRunRepository";
 import type { WorkflowDebuggerOverlayRepository } from "./domain/workflows/WorkflowDebuggerOverlayRepository";
 import type { WorkflowDefinitionRepository } from "./domain/workflows/WorkflowDefinitionRepository";
@@ -66,6 +73,17 @@ export const ApplicationTokens = {
    */
   PerformanceDiagnosticsLogger: Symbol.for("codemation.application.PerformanceDiagnosticsLogger") as TypeToken<Logger>,
   CredentialStore: Symbol.for("codemation.application.CredentialStore") as TypeToken<CredentialStore>,
+  RunTraceContextRepository: Symbol.for(
+    "codemation.application.RunTraceContextRepository",
+  ) as TypeToken<RunTraceContextRepository>,
+  TelemetrySpanStore: Symbol.for("codemation.application.TelemetrySpanStore") as TypeToken<TelemetrySpanStore>,
+  TelemetryArtifactStore: Symbol.for(
+    "codemation.application.TelemetryArtifactStore",
+  ) as TypeToken<TelemetryArtifactStore>,
+  TelemetryMetricPointStore: Symbol.for(
+    "codemation.application.TelemetryMetricPointStore",
+  ) as TypeToken<TelemetryMetricPointStore>,
+  TelemetryExporter: Symbol.for("codemation.application.TelemetryExporter") as TypeToken<TelemetryExporter>,
   PrismaClient: Symbol.for("codemation.application.PrismaClient") as TypeToken<PrismaDatabaseClient>,
   SessionVerifier: Symbol.for("codemation.application.SessionVerifier") as TypeToken<SessionVerifier>,
   Clock: Symbol.for("codemation.application.Clock") as TypeToken<Clock>,

package/src/bootstrap/AppContainerFactory.ts

@@ -9,8 +9,10 @@ import {
   SystemClock,
   container as tsyringeContainer,
   type WorkflowDefinition,
+  type WorkflowPolicyRuntimeDefaults,
 } from "@codemation/core";
 import {
+  CatalogBackedCostTrackingTelemetryFactory,
   ConfigDrivenOffloadPolicy,
   DefaultDrivingScheduler,
   DefaultExecutionContextFactory,
@@ -18,6 +20,7 @@ import {
   InMemoryRunDataFactory,
   InlineDrivingScheduler,
   PersistedWorkflowTokenRegistry,
+  StaticCostCatalog,
   WorkflowRepositoryWebhookTriggerMatcher,
 } from "@codemation/core/bootstrap";
 import { AIAgentConnectionWorkflowExpander, ConnectionCredentialNodeConfigFactory } from "@codemation/core-nodes";
@@ -60,6 +63,11 @@ import {
 } from "../application/queries/UserAccountQueryHandlers";
 import {
   GetRunBinaryAttachmentQueryHandler,
+  GetTelemetryDashboardDimensionsQueryHandler,
+  GetTelemetryDashboardRunsQueryHandler,
+  GetTelemetryRunTraceQueryHandler,
+  GetTelemetryDashboardSummaryQueryHandler,
+  GetTelemetryDashboardTimeseriesQueryHandler,
   GetRunStateQueryHandler,
   GetWorkflowDebuggerOverlayQueryHandler,
   GetWorkflowDetailQueryHandler,
@@ -72,6 +80,17 @@ import { OpenAiApiKeyCredentialHealthTester } from "../infrastructure/credential
 import { OpenAiApiKeyCredentialTypeFactory } from "../infrastructure/credentials/OpenAiApiKeyCredentialTypeFactory";
 import { CodemationPluginRegistrar } from "../infrastructure/config/CodemationPluginRegistrar";
 import { WorkflowRunEventWebsocketRelay } from "../application/websocket/WorkflowRunEventWebsocketRelay";
+import { FrameworkCostCatalogEntries } from "../application/cost/FrameworkCostCatalogEntries";
+import { CompositeTelemetryExporter } from "../application/telemetry/CompositeTelemetryExporter";
+import { LazyExecutionTelemetryFactory } from "../application/telemetry/LazyExecutionTelemetryFactory";
+import { NoOpTelemetryExporter } from "../application/telemetry/NoOpTelemetryExporter";
+import { OtelExecutionTelemetryFactory } from "../application/telemetry/OtelExecutionTelemetryFactory";
+import { OtelIdentityFactory } from "../application/telemetry/OtelIdentityFactory";
+import { RunEventBusTelemetryReporter } from "../application/telemetry/RunEventBusTelemetryReporter";
+import { TelemetryEnricherChain } from "../application/telemetry/TelemetryEnricherChain";
+import { TelemetryPrivacyPolicy } from "../application/telemetry/TelemetryPrivacyPolicy";
+import { TelemetryQueryService } from "../application/telemetry/TelemetryQueryService";
+import { TelemetryRetentionTimestampFactory } from "../application/telemetry/TelemetryRetentionTimestampFactory";
 import { ApplicationTokens } from "../applicationTokens";
 import type { CredentialType } from "../domain/credentials/CredentialServices";
 import {
@@ -117,6 +136,7 @@ import { CredentialHonoApiRouteRegistrar } from "../presentation/http/hono/regis
 import { DevHonoApiRouteRegistrar } from "../presentation/http/hono/registrars/DevHonoApiRouteRegistrar";
 import { OAuth2HonoApiRouteRegistrar } from "../presentation/http/hono/registrars/OAuth2HonoApiRouteRegistrar";
 import { RunHonoApiRouteRegistrar } from "../presentation/http/hono/registrars/RunHonoApiRouteRegistrar";
+import { TelemetryHonoApiRouteRegistrar } from "../presentation/http/hono/registrars/TelemetryHonoApiRouteRegistrar";
 import { UserHonoApiRouteRegistrar } from "../presentation/http/hono/registrars/UserHonoApiRouteRegistrar";
 import { WebhookHonoApiRouteRegistrar } from "../presentation/http/hono/registrars/WebhookHonoApiRouteRegistrar";
 import { WhitelabelHonoApiRouteRegistrar } from "../presentation/http/hono/registrars/WhitelabelHonoApiRouteRegistrar";
@@ -145,6 +165,10 @@ import {
   PrismaCredentialStore,
 } from "../infrastructure/persistence/CredentialPersistenceStore";
 import { InMemoryTriggerSetupStateRepository } from "../infrastructure/persistence/InMemoryTriggerSetupStateRepository";
+import { InMemoryRunTraceContextRepository } from "../infrastructure/persistence/InMemoryRunTraceContextRepository";
+import { InMemoryTelemetryArtifactStore } from "../infrastructure/persistence/InMemoryTelemetryArtifactStore";
+import { InMemoryTelemetryMetricPointStore } from "../infrastructure/persistence/InMemoryTelemetryMetricPointStore";
+import { InMemoryTelemetrySpanStore } from "../infrastructure/persistence/InMemoryTelemetrySpanStore";
 import { InMemoryWorkflowActivationRepository } from "../infrastructure/persistence/InMemoryWorkflowActivationRepository";
 import { InMemoryWorkflowDebuggerOverlayRepository } from "../infrastructure/persistence/InMemoryWorkflowDebuggerOverlayRepository";
 import { InMemoryWorkflowRunRepository } from "../infrastructure/persistence/InMemoryWorkflowRunRepository";
@@ -154,6 +178,10 @@ import {
 } from "../infrastructure/persistence/PrismaDatabaseClient";
 import { PrismaClientFactory } from "../infrastructure/persistence/PrismaClientFactory";
 import { PrismaTriggerSetupStateRepository } from "../infrastructure/persistence/PrismaTriggerSetupStateRepository";
+import { PrismaRunTraceContextRepository } from "../infrastructure/persistence/PrismaRunTraceContextRepository";
+import { PrismaTelemetryArtifactStore } from "../infrastructure/persistence/PrismaTelemetryArtifactStore";
+import { PrismaTelemetryMetricPointStore } from "../infrastructure/persistence/PrismaTelemetryMetricPointStore";
+import { PrismaTelemetrySpanStore } from "../infrastructure/persistence/PrismaTelemetrySpanStore";
 import { PrismaWorkflowActivationRepository } from "../infrastructure/persistence/PrismaWorkflowActivationRepository";
 import { PrismaWorkflowDebuggerOverlayRepository } from "../infrastructure/persistence/PrismaWorkflowDebuggerOverlayRepository";
 import { PrismaWorkflowRunRepository } from "../infrastructure/persistence/PrismaWorkflowRunRepository";
@@ -169,6 +197,7 @@ import { LocalFilesystemBinaryStorage } from "../infrastructure/binary/LocalFile
 import { InMemoryBinaryStorage } from "@codemation/core/bootstrap";
 import { RedisRunEventBus } from "@codemation/eventbus-redis";
 import { AppContainerLifecycle } from "./AppContainerLifecycle";
+import { WorkflowRunRetentionPruneScheduler } from "../application/runs/WorkflowRunRetentionPruneScheduler";
 import { DatabaseMigrations } from "./runtime/DatabaseMigrations";
 import { FrontendRuntime } from "./runtime/FrontendRuntime";
 import { WorkerRuntime } from "./runtime/WorkerRuntime";
@@ -194,6 +223,11 @@ export class AppContainerFactory {
     ListUserAccountsQueryHandler,
     VerifyUserInviteQueryHandler,
     GetRunBinaryAttachmentQueryHandler,
+    GetTelemetryDashboardDimensionsQueryHandler,
+    GetTelemetryDashboardRunsQueryHandler,
+    GetTelemetryRunTraceQueryHandler,
+    GetTelemetryDashboardSummaryQueryHandler,
+    GetTelemetryDashboardTimeseriesQueryHandler,
     GetRunStateQueryHandler,
     GetWorkflowRunDetailQueryHandler,
     GetWorkflowDebuggerOverlayQueryHandler,
@@ -231,6 +265,7 @@ export class AppContainerFactory {
     DevHonoApiRouteRegistrar,
     OAuth2HonoApiRouteRegistrar,
     RunHonoApiRouteRegistrar,
+    TelemetryHonoApiRouteRegistrar,
     UserHonoApiRouteRegistrar,
     WebhookHonoApiRouteRegistrar,
     WhitelabelHonoApiRouteRegistrar,
@@ -356,6 +391,7 @@ export class AppContainerFactory {
     container.registerInstance(CoreTokens.WorkflowActivationPolicy, runtimeWorkflowActivationPolicy);
     new EngineRuntimeRegistrar().register(container, {
       resolveEngineExecutionLimits: () => inputs.appConfig.engineExecutionLimits,
+      workflowPolicyRuntimeDefaults: this.createWorkflowPolicyRuntimeDefaults(inputs.appConfig),
       webhookTriggerMatcherProvider: {
         createMatcher: (dependencyContainer) => {
           const webhookRoutingLogger = dependencyContainer
@@ -528,6 +564,26 @@ export class AppContainerFactory {
   }
 
   private registerRepositoriesAndBuses(container: Container): void {
+    container.register(OtelIdentityFactory, { useClass: OtelIdentityFactory });
+    container.register(TelemetryPrivacyPolicy, { useClass: TelemetryPrivacyPolicy });
+    container.register(TelemetryEnricherChain, { useClass: TelemetryEnricherChain });
+    container.register(TelemetryRetentionTimestampFactory, { useClass: TelemetryRetentionTimestampFactory });
+    container.register(TelemetryQueryService, { useClass: TelemetryQueryService });
+    container.register(NoOpTelemetryExporter, { useClass: NoOpTelemetryExporter });
+    container.register(CompositeTelemetryExporter, {
+      useFactory: instanceCachingFactory(
+        (dependencyContainer) => new CompositeTelemetryExporter([dependencyContainer.resolve(NoOpTelemetryExporter)]),
+      ),
+    });
+    container.register(OtelExecutionTelemetryFactory, { useClass: OtelExecutionTelemetryFactory });
+    container.register(InMemoryRunTraceContextRepository, { useClass: InMemoryRunTraceContextRepository });
+    container.register(InMemoryTelemetrySpanStore, { useClass: InMemoryTelemetrySpanStore });
+    container.register(InMemoryTelemetryArtifactStore, { useClass: InMemoryTelemetryArtifactStore });
+    container.register(InMemoryTelemetryMetricPointStore, { useClass: InMemoryTelemetryMetricPointStore });
+    container.register(PrismaRunTraceContextRepository, { useClass: PrismaRunTraceContextRepository });
+    container.register(PrismaTelemetrySpanStore, { useClass: PrismaTelemetrySpanStore });
+    container.register(PrismaTelemetryArtifactStore, { useClass: PrismaTelemetryArtifactStore });
+    container.register(PrismaTelemetryMetricPointStore, { useClass: PrismaTelemetryMetricPointStore });
     container.register(WorkflowDefinitionRepositoryAdapter, { useClass: WorkflowDefinitionRepositoryAdapter });
     container.register(InMemoryWorkflowRunRepository, { useClass: InMemoryWorkflowRunRepository });
     container.register(InMemoryTriggerSetupStateRepository, { useClass: InMemoryTriggerSetupStateRepository });
@@ -565,6 +621,11 @@ export class AppContainerFactory {
     container.register(ApplicationTokens.DomainEventBus, {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryDomainEventBus)),
     });
+    container.register(ApplicationTokens.TelemetryExporter, {
+      useFactory: instanceCachingFactory((dependencyContainer) =>
+        dependencyContainer.resolve(CompositeTelemetryExporter),
+      ),
+    });
   }
 
   private registerApplicationServicesAndRoutes(container: Container): void {
@@ -585,6 +646,8 @@ export class AppContainerFactory {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(WorkflowWebsocketServer)),
     });
     container.register(WorkflowRunEventWebsocketRelay, { useClass: WorkflowRunEventWebsocketRelay });
+    container.register(RunEventBusTelemetryReporter, { useClass: RunEventBusTelemetryReporter });
+    container.register(WorkflowRunRetentionPruneScheduler, { useClass: WorkflowRunRetentionPruneScheduler });
   }
 
   private async registerRuntimeInfrastructure(container: Container, appConfig: AppConfig): Promise<PrismaOwnership> {
@@ -597,7 +660,6 @@ export class AppContainerFactory {
     const binaryStorage = this.createBinaryStorage(appConfig.repoRoot);
     container.registerInstance(CoreTokens.RunDataFactory, new InMemoryRunDataFactory());
     container.registerInstance(CoreTokens.BinaryStorage, binaryStorage);
-    container.registerInstance(CoreTokens.ExecutionContextFactory, new DefaultExecutionContextFactory(binaryStorage));
     container.registerInstance(ApplicationTokens.Clock, new SystemClock());
 
     if (appConfig.persistence.kind === "none") {
@@ -620,6 +682,27 @@ export class AppContainerFactory {
         container.resolve(InMemoryWorkflowActivationRepository),
       );
       container.registerInstance(ApplicationTokens.CredentialStore, container.resolve(InMemoryCredentialStore));
+      container.registerInstance(
+        ApplicationTokens.RunTraceContextRepository,
+        container.resolve(InMemoryRunTraceContextRepository),
+      );
+      container.registerInstance(ApplicationTokens.TelemetrySpanStore, container.resolve(InMemoryTelemetrySpanStore));
+      container.registerInstance(
+        ApplicationTokens.TelemetryArtifactStore,
+        container.resolve(InMemoryTelemetryArtifactStore),
+      );
+      container.registerInstance(
+        ApplicationTokens.TelemetryMetricPointStore,
+        container.resolve(InMemoryTelemetryMetricPointStore),
+      );
+      container.registerInstance(
+        CoreTokens.ExecutionContextFactory,
+        new DefaultExecutionContextFactory(
+          binaryStorage,
+          new LazyExecutionTelemetryFactory(() => container.resolve(OtelExecutionTelemetryFactory)),
+          new CatalogBackedCostTrackingTelemetryFactory(new StaticCostCatalog(FrameworkCostCatalogEntries)),
+        ),
+      );
       this.registerRuntimeNodeActivationScheduler(container);
       return {
         ownedPrismaClient: null,
@@ -632,6 +715,10 @@ export class AppContainerFactory {
     const workflowRunRepository = childContainer.resolve(PrismaWorkflowRunRepository);
     const triggerSetupStateRepository = childContainer.resolve(PrismaTriggerSetupStateRepository);
     const workflowDebuggerOverlayRepository = childContainer.resolve(PrismaWorkflowDebuggerOverlayRepository);
+    const runTraceContextRepository = childContainer.resolve(PrismaRunTraceContextRepository);
+    const telemetrySpanStore = childContainer.resolve(PrismaTelemetrySpanStore);
+    const telemetryArtifactStore = childContainer.resolve(PrismaTelemetryArtifactStore);
+    const telemetryMetricPointStore = childContainer.resolve(PrismaTelemetryMetricPointStore);
     container.registerInstance(PrismaDatabaseClientToken, prismaOwnership.prismaClient);
     container.registerInstance(ApplicationTokens.PrismaClient, prismaOwnership.prismaClient);
     container.registerInstance(
@@ -649,6 +736,18 @@ export class AppContainerFactory {
       container.resolve(PrismaWorkflowActivationRepository),
     );
     container.registerInstance(ApplicationTokens.CredentialStore, container.resolve(PrismaCredentialStore));
+    container.registerInstance(ApplicationTokens.RunTraceContextRepository, runTraceContextRepository);
+    container.registerInstance(ApplicationTokens.TelemetrySpanStore, telemetrySpanStore);
+    container.registerInstance(ApplicationTokens.TelemetryArtifactStore, telemetryArtifactStore);
+    container.registerInstance(ApplicationTokens.TelemetryMetricPointStore, telemetryMetricPointStore);
+    container.registerInstance(
+      CoreTokens.ExecutionContextFactory,
+      new DefaultExecutionContextFactory(
+        binaryStorage,
+        new LazyExecutionTelemetryFactory(() => container.resolve(OtelExecutionTelemetryFactory)),
+        new CatalogBackedCostTrackingTelemetryFactory(new StaticCostCatalog(FrameworkCostCatalogEntries)),
+      ),
+    );
     if (appConfig.scheduler.kind === "bullmq") {
       container.registerInstance(
         ApplicationTokens.WorkerRuntimeScheduler,
@@ -705,6 +804,22 @@ export class AppContainerFactory {
     });
   }
 
+  private createWorkflowPolicyRuntimeDefaults(appConfig: AppConfig): WorkflowPolicyRuntimeDefaults {
+    return {
+      retentionSeconds: this.readPositiveInteger(appConfig.env.CODEMATION_RUN_RETENTION_DEFAULT_SECONDS),
+      binaryRetentionSeconds: this.readPositiveInteger(appConfig.env.CODEMATION_BINARY_RETENTION_DEFAULT_SECONDS),
+      telemetrySpanRetentionSeconds: this.readPositiveInteger(
+        appConfig.env.CODEMATION_TELEMETRY_SPAN_RETENTION_DEFAULT_SECONDS,
+      ),
+      telemetryArtifactRetentionSeconds: this.readPositiveInteger(
+        appConfig.env.CODEMATION_TELEMETRY_ARTIFACT_RETENTION_DEFAULT_SECONDS,
+      ),
+      telemetryMetricRetentionSeconds: this.readPositiveInteger(
+        appConfig.env.CODEMATION_TELEMETRY_METRIC_RETENTION_DEFAULT_SECONDS,
+      ),
+    };
+  }
+
   private createBinaryStorage(repoRoot: string): InMemoryBinaryStorage | LocalFilesystemBinaryStorage {
     if (!repoRoot) {
       return new InMemoryBinaryStorage();
@@ -730,6 +845,14 @@ export class AppContainerFactory {
     return redisUrl;
   }
 
+  private readPositiveInteger(value: string | undefined): number | undefined {
+    if (!value) {
+      return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+  }
+
   private synchronizeLiveWorkflowRepository(container: Container, workflows: ReadonlyArray<WorkflowDefinition>): void {
     const liveWorkflowRepository = container.resolve(CoreTokens.LiveWorkflowRepository);
     liveWorkflowRepository.setWorkflows(workflows);

package/src/bootstrap/AppContainerLifecycle.ts

@@ -1,5 +1,7 @@
 import type { Container } from "@codemation/core";
 import { Engine } from "@codemation/core/bootstrap";
+import { RunEventBusTelemetryReporter } from "../application/telemetry/RunEventBusTelemetryReporter";
+import { WorkflowRunRetentionPruneScheduler } from "../application/runs/WorkflowRunRetentionPruneScheduler";
 import type { PrismaDatabaseClient } from "../infrastructure/persistence/PrismaDatabaseClient";
 import { WorkflowRunEventWebsocketRelay } from "../application/websocket/WorkflowRunEventWebsocketRelay";
 import { WorkflowWebsocketServer } from "../presentation/websocket/WorkflowWebsocketServer";
@@ -17,6 +19,12 @@ export class AppContainerLifecycle {
     if (this.container.isRegistered(WorkflowRunEventWebsocketRelay, true)) {
       await this.container.resolve(WorkflowRunEventWebsocketRelay).stop();
     }
+    if (this.container.isRegistered(RunEventBusTelemetryReporter, true)) {
+      await this.container.resolve(RunEventBusTelemetryReporter).stop();
+    }
+    if (this.container.isRegistered(WorkflowRunRetentionPruneScheduler, true)) {
+      this.container.resolve(WorkflowRunRetentionPruneScheduler).stop();
+    }
     if (args?.stopWebsocketServer !== false && this.container.isRegistered(WorkflowWebsocketServer, true)) {
       await this.container.resolve(WorkflowWebsocketServer).stop();
     }

package/src/bootstrap/runtime/FrontendRuntime.ts

@@ -3,10 +3,12 @@ import { Engine } from "@codemation/core/bootstrap";
 import { ApplicationTokens } from "../../applicationTokens";
 import type { AppConfig } from "../../presentation/config/AppConfig";
 import { RuntimeWorkflowActivationPolicy } from "../../infrastructure/persistence/RuntimeWorkflowActivationPolicy";
+import { RunEventBusTelemetryReporter } from "../../application/telemetry/RunEventBusTelemetryReporter";
 import { WorkflowRunEventWebsocketRelay } from "../../application/websocket/WorkflowRunEventWebsocketRelay";
 import { WorkflowWebsocketServer } from "../../presentation/websocket/WorkflowWebsocketServer";
 import { DatabaseMigrations } from "./DatabaseMigrations";
 import type { WorkflowActivationRepository } from "../../domain/workflows/WorkflowActivationRepository";
+import { WorkflowRunRetentionPruneScheduler } from "../../application/runs/WorkflowRunRetentionPruneScheduler";
 
 @injectable()
 export class FrontendRuntime {
@@ -25,6 +27,10 @@ export class FrontendRuntime {
     private readonly workflowWebsocketServer: WorkflowWebsocketServer,
     @inject(WorkflowRunEventWebsocketRelay)
     private readonly workflowRunEventWebsocketRelay: WorkflowRunEventWebsocketRelay,
+    @inject(RunEventBusTelemetryReporter)
+    private readonly runEventBusTelemetryReporter: RunEventBusTelemetryReporter,
+    @inject(WorkflowRunRetentionPruneScheduler)
+    private readonly workflowRunRetentionPruneScheduler: WorkflowRunRetentionPruneScheduler,
     @inject(Engine)
     private readonly engine: Engine,
   ) {}
@@ -39,6 +45,8 @@ export class FrontendRuntime {
     }
     await this.engine.start([...this.workflowRepository.list()]);
     await this.workflowWebsocketServer.start();
+    await this.runEventBusTelemetryReporter.start();
+    this.workflowRunRetentionPruneScheduler.start();
     await this.workflowRunEventWebsocketRelay.start();
   }
 }

package/src/bootstrap/runtime/WorkerRuntime.ts

@@ -11,6 +11,8 @@ import { RuntimeWorkflowActivationPolicy } from "../../infrastructure/persistenc
 import type { WorkflowActivationRepository } from "../../domain/workflows/WorkflowActivationRepository";
 import { DatabaseMigrations } from "./DatabaseMigrations";
 import { AppContainerLifecycle } from "../AppContainerLifecycle";
+import { RunEventBusTelemetryReporter } from "../../application/telemetry/RunEventBusTelemetryReporter";
+import { WorkflowRunRetentionPruneScheduler } from "../../application/runs/WorkflowRunRetentionPruneScheduler";
 
 @injectable()
 export class WorkerRuntime {
@@ -27,6 +29,10 @@ export class WorkerRuntime {
     private readonly workflowRepository: WorkflowRepository,
     @inject(Engine)
     private readonly engine: Engine,
+    @inject(RunEventBusTelemetryReporter)
+    private readonly runEventBusTelemetryReporter: RunEventBusTelemetryReporter,
+    @inject(WorkflowRunRetentionPruneScheduler)
+    private readonly workflowRunRetentionPruneScheduler: WorkflowRunRetentionPruneScheduler,
     @inject(ApplicationTokens.WorkerRuntimeScheduler)
     private readonly scheduler: WorkerRuntimeScheduler,
     @inject(AppContainerLifecycle)
@@ -40,6 +46,8 @@ export class WorkerRuntime {
     await this.runtimeWorkflowActivationPolicy.hydrateFromRepository(this.workflowActivationRepository);
     const workflows = [...this.workflowRepository.list()];
     await this.engine.start(workflows);
+    await this.runEventBusTelemetryReporter.start();
+    this.workflowRunRetentionPruneScheduler.start();
     const worker = this.scheduler.createWorker({
       queues,
       requestHandler: this.engine,

package/src/domain/runs/WorkflowRunRepository.ts

@@ -9,7 +9,9 @@ export interface WorkflowRunRepository {
 
   listRuns(args: Readonly<{ workflowId?: string; limit?: number }>): Promise<ReadonlyArray<RunSummary>>;
 
-  listRunsOlderThan?(args: Readonly<{ beforeIso: string; limit?: number }>): Promise<ReadonlyArray<RunPruneCandidate>>;
+  listRunsOlderThan?(
+    args: Readonly<{ nowIso: string; defaultRetentionSeconds: number; limit?: number }>,
+  ): Promise<ReadonlyArray<RunPruneCandidate>>;
 
   listBinaryStorageKeys?(runId: RunId): Promise<ReadonlyArray<string>>;
 

package/src/domain/telemetry/TelemetryContracts.ts

@@ -0,0 +1,197 @@
+import type {
+  TelemetryArtifactAttachment,
+  TelemetryAttributes,
+  TelemetryMetricRecord,
+  TelemetrySpanEventRecord,
+} from "@codemation/core";
+
+export type TelemetrySpanStatus = "running" | "completed" | "failed";
+export type TelemetrySpanKind = "internal" | "client";
+
+export interface TelemetryTraceContext {
+  readonly runId: string;
+  readonly workflowId: string;
+  readonly traceId: string;
+  readonly rootSpanId: string;
+  readonly serviceName?: string;
+  readonly createdAt: string;
+  readonly expiresAt?: string;
+}
+
+export interface TelemetrySpanRecord {
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly parentSpanId?: string;
+  readonly runId: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly connectionInvocationId?: string;
+  readonly name: string;
+  readonly kind: TelemetrySpanKind;
+  readonly status?: TelemetrySpanStatus;
+  readonly statusMessage?: string;
+  readonly startTime?: string;
+  readonly endTime?: string;
+  readonly workflowFolder?: string;
+  readonly nodeType?: string;
+  readonly nodeRole?: string;
+  readonly modelName?: string;
+  readonly attributes?: TelemetryAttributes;
+  readonly events?: ReadonlyArray<TelemetrySpanEventRecord>;
+  readonly retentionExpiresAt?: string;
+}
+
+export interface TelemetrySpanUpsert {
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly parentSpanId?: string;
+  readonly runId: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly connectionInvocationId?: string;
+  readonly name?: string;
+  readonly kind?: TelemetrySpanKind;
+  readonly status?: TelemetrySpanStatus;
+  readonly statusMessage?: string;
+  readonly startTime?: string;
+  readonly endTime?: string;
+  readonly workflowFolder?: string;
+  readonly nodeType?: string;
+  readonly nodeRole?: string;
+  readonly modelName?: string;
+  readonly attributes?: TelemetryAttributes;
+  readonly events?: ReadonlyArray<TelemetrySpanEventRecord>;
+  readonly retentionExpiresAt?: string;
+}
+
+export interface TelemetryArtifactRecord {
+  readonly artifactId: string;
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly runId: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly kind: string;
+  readonly contentType: string;
+  readonly previewText?: string;
+  readonly previewJson?: unknown;
+  readonly payloadText?: string;
+  readonly payloadJson?: unknown;
+  readonly bytes?: number;
+  readonly truncated?: boolean;
+  readonly createdAt: string;
+  readonly expiresAt?: string;
+  readonly retentionExpiresAt?: string;
+}
+
+export interface TelemetryArtifactWrite extends TelemetryArtifactAttachment {
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly runId: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly retentionExpiresAt?: string;
+}
+
+export interface TelemetryMetricPointRecord {
+  readonly metricPointId: string;
+  readonly traceId?: string;
+  readonly spanId?: string;
+  readonly runId?: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly metricName: string;
+  readonly value: number;
+  readonly unit?: string;
+  readonly observedAt: string;
+  readonly workflowFolder?: string;
+  readonly nodeType?: string;
+  readonly nodeRole?: string;
+  readonly modelName?: string;
+  readonly dimensions?: TelemetryAttributes;
+  readonly retentionExpiresAt?: string;
+}
+
+export interface TelemetryMetricPointWrite extends TelemetryMetricRecord {
+  readonly traceId?: string;
+  readonly spanId?: string;
+  readonly runId?: string;
+  readonly workflowId: string;
+  readonly nodeId?: string;
+  readonly activationId?: string;
+  readonly observedAt: string;
+  readonly workflowFolder?: string;
+  readonly nodeType?: string;
+  readonly nodeRole?: string;
+  readonly modelName?: string;
+  readonly retentionExpiresAt?: string;
+}
+
+export interface TelemetrySpanListQuery {
+  readonly traceId?: string;
+  readonly runId?: string;
+  readonly runIds?: ReadonlyArray<string>;
+  readonly workflowId?: string;
+  readonly workflowIds?: ReadonlyArray<string>;
+  readonly statuses?: ReadonlyArray<TelemetrySpanStatus>;
+  readonly names?: ReadonlyArray<string>;
+  readonly modelNames?: ReadonlyArray<string>;
+  readonly startTimeGte?: string;
+  readonly endTimeLte?: string;
+  readonly limit?: number;
+}
+
+export interface TelemetryMetricPointListQuery {
+  readonly traceId?: string;
+  readonly runId?: string;
+  readonly runIds?: ReadonlyArray<string>;
+  readonly workflowId?: string;
+  readonly workflowIds?: ReadonlyArray<string>;
+  readonly nodeId?: string;
+  readonly metricNames?: ReadonlyArray<string>;
+  readonly modelNames?: ReadonlyArray<string>;
+  readonly observedAtGte?: string;
+  readonly observedAtLte?: string;
+  readonly limit?: number;
+}
+
+export interface TelemetryPruneArgs {
+  readonly nowIso: string;
+  readonly limit?: number;
+}
+
+export interface RunTraceContextRepository {
+  load(runId: string): Promise<TelemetryTraceContext | undefined>;
+  getOrCreate(
+    args: Readonly<{ runId: string; workflowId: string; serviceName?: string }>,
+  ): Promise<TelemetryTraceContext>;
+  upsertExpiry(args: Readonly<{ runId: string; expiresAt?: string }>): Promise<void>;
+}
+
+export interface TelemetrySpanStore {
+  upsert(record: TelemetrySpanUpsert): Promise<void>;
+  list(args?: TelemetrySpanListQuery): Promise<ReadonlyArray<TelemetrySpanRecord>>;
+  listByTraceId(traceId: string): Promise<ReadonlyArray<TelemetrySpanRecord>>;
+  pruneExpired(args: TelemetryPruneArgs): Promise<number>;
+}
+
+export interface TelemetryArtifactStore {
+  save(record: TelemetryArtifactWrite): Promise<TelemetryArtifactRecord>;
+  listByTraceId(traceId: string): Promise<ReadonlyArray<TelemetryArtifactRecord>>;
+  pruneExpired(args: TelemetryPruneArgs): Promise<number>;
+}
+
+export interface TelemetryMetricPointStore {
+  save(record: TelemetryMetricPointWrite): Promise<TelemetryMetricPointRecord>;
+  list(args?: TelemetryMetricPointListQuery): Promise<ReadonlyArray<TelemetryMetricPointRecord>>;
+  pruneExpired(args: TelemetryPruneArgs): Promise<number>;
+}
+
+export interface TelemetryExporter {
+  exportSpans(spans: ReadonlyArray<TelemetrySpanRecord>): Promise<void>;
+}