@codemation/host 0.2.5 → 0.3.1

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,
@@ -330,7 +365,7 @@ export class AppContainerFactory {
         dependencyContainer.resolve(CredentialTypeRegistryImpl),
       ),
     });
-    container.register(CodemationIdFactory, { useClass: CodemationIdFactory });
+    container.registerSingleton(CodemationIdFactory, CodemationIdFactory);
     container.register(CoreTokens.RunIdFactory, {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(CodemationIdFactory)),
     });
@@ -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
@@ -384,7 +420,7 @@ export class AppContainerFactory {
       },
     });
     container.registerInstance(LogLevelPolicyFactory, logLevelPolicyFactory);
-    container.register(ServerLoggerFactory, { useClass: ServerLoggerFactory });
+    container.registerSingleton(ServerLoggerFactory, ServerLoggerFactory);
     container.register(ApplicationTokens.LoggerFactory, {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(ServerLoggerFactory)),
     });
@@ -405,43 +441,41 @@ export class AppContainerFactory {
         );
       }),
     });
-    container.register(PrismaClientFactory, { useClass: PrismaClientFactory });
-    container.register(WorkflowPolicyUiPresentationFactory, { useClass: WorkflowPolicyUiPresentationFactory });
-    container.register(WorkflowDefinitionMapper, { useClass: WorkflowDefinitionMapper });
-    container.register(RequestToWebhookItemMapper, { useClass: RequestToWebhookItemMapper });
-    container.register(WebhookEndpointPathValidator, { useClass: WebhookEndpointPathValidator });
-    container.register(CredentialSecretCipher, { useClass: CredentialSecretCipher });
-    container.register(CredentialMaterialResolver, { useClass: CredentialMaterialResolver });
-    container.register(CredentialFieldEnvOverlayService, { useClass: CredentialFieldEnvOverlayService });
-    container.register(CredentialRuntimeMaterialService, { useClass: CredentialRuntimeMaterialService });
-    container.register(WorkflowCredentialNodeResolver, { useClass: WorkflowCredentialNodeResolver });
-    container.register(CredentialInstanceService, { useClass: CredentialInstanceService });
-    container.register(CredentialBindingService, { useClass: CredentialBindingService });
-    container.register(WorkflowActivationPreflightRules, { useClass: WorkflowActivationPreflightRules });
-    container.register(WorkflowActivationPreflight, { useClass: WorkflowActivationPreflight });
-    container.register(CredentialTestService, { useClass: CredentialTestService });
-    container.register(CredentialSessionServiceImpl, { useClass: CredentialSessionServiceImpl });
+    container.registerSingleton(PrismaClientFactory, PrismaClientFactory);
+    container.registerSingleton(WorkflowPolicyUiPresentationFactory, WorkflowPolicyUiPresentationFactory);
+    container.registerSingleton(WorkflowDefinitionMapper, WorkflowDefinitionMapper);
+    container.registerSingleton(RequestToWebhookItemMapper, RequestToWebhookItemMapper);
+    container.registerSingleton(WebhookEndpointPathValidator, WebhookEndpointPathValidator);
+    container.registerSingleton(CredentialSecretCipher, CredentialSecretCipher);
+    container.registerSingleton(CredentialMaterialResolver, CredentialMaterialResolver);
+    container.registerSingleton(CredentialFieldEnvOverlayService, CredentialFieldEnvOverlayService);
+    container.registerSingleton(CredentialRuntimeMaterialService, CredentialRuntimeMaterialService);
+    container.registerSingleton(WorkflowCredentialNodeResolver, WorkflowCredentialNodeResolver);
+    container.registerSingleton(CredentialInstanceService, CredentialInstanceService);
+    container.registerSingleton(CredentialBindingService, CredentialBindingService);
+    container.registerSingleton(WorkflowActivationPreflightRules, WorkflowActivationPreflightRules);
+    container.registerSingleton(WorkflowActivationPreflight, WorkflowActivationPreflight);
+    container.registerSingleton(CredentialTestService, CredentialTestService);
+    container.registerSingleton(CredentialSessionServiceImpl, CredentialSessionServiceImpl);
     if (!inputs.appConfig.hasConfiguredCredentialSessionServiceRegistration) {
       container.register(CoreTokens.CredentialSessionService, { useToken: CredentialSessionServiceImpl });
     }
-    container.register(OAuth2ProviderRegistry, { useClass: OAuth2ProviderRegistry });
-    container.register(OAuth2ConnectService, { useClass: OAuth2ConnectService });
-    container.register(CodemationFrontendAuthSnapshotFactory, { useClass: CodemationFrontendAuthSnapshotFactory });
-    container.register(FrontendAppConfigFactory, { useClass: FrontendAppConfigFactory });
-    container.register(PublicFrontendBootstrapFactory, { useClass: PublicFrontendBootstrapFactory });
-    container.register(InternalAuthBootstrapFactory, { useClass: InternalAuthBootstrapFactory });
-    container.register(DatabaseMigrations, { useClass: DatabaseMigrations });
-    container.register(FrontendRuntime, { useClass: FrontendRuntime });
-    container.register(WorkerRuntime, { useClass: WorkerRuntime });
-    container.register(DevelopmentSessionBypassVerifier, { useClass: DevelopmentSessionBypassVerifier });
-    container.register(SecureRequestDetector, { useClass: SecureRequestDetector });
-    container.register(InAppCallbackUrlPolicy, { useClass: InAppCallbackUrlPolicy });
-    container.register(AuthSessionCookieFactory, { useClass: AuthSessionCookieFactory });
-    container.register(CodemationBetterAuthBcryptPasswordCodec, { useClass: CodemationBetterAuthBcryptPasswordCodec });
-    container.register(CodemationBetterAuthDatabaseOptionsFactory, {
-      useClass: CodemationBetterAuthDatabaseOptionsFactory,
-    });
-    container.register(UserAccountSessionPolicy, { useClass: UserAccountSessionPolicy });
+    container.registerSingleton(OAuth2ProviderRegistry, OAuth2ProviderRegistry);
+    container.registerSingleton(OAuth2ConnectService, OAuth2ConnectService);
+    container.registerSingleton(CodemationFrontendAuthSnapshotFactory, CodemationFrontendAuthSnapshotFactory);
+    container.registerSingleton(FrontendAppConfigFactory, FrontendAppConfigFactory);
+    container.registerSingleton(PublicFrontendBootstrapFactory, PublicFrontendBootstrapFactory);
+    container.registerSingleton(InternalAuthBootstrapFactory, InternalAuthBootstrapFactory);
+    container.registerSingleton(DatabaseMigrations, DatabaseMigrations);
+    container.registerSingleton(FrontendRuntime, FrontendRuntime);
+    container.registerSingleton(WorkerRuntime, WorkerRuntime);
+    container.registerSingleton(DevelopmentSessionBypassVerifier, DevelopmentSessionBypassVerifier);
+    container.registerSingleton(SecureRequestDetector, SecureRequestDetector);
+    container.registerSingleton(InAppCallbackUrlPolicy, InAppCallbackUrlPolicy);
+    container.registerSingleton(AuthSessionCookieFactory, AuthSessionCookieFactory);
+    container.registerSingleton(CodemationBetterAuthBcryptPasswordCodec, CodemationBetterAuthBcryptPasswordCodec);
+    container.registerSingleton(CodemationBetterAuthDatabaseOptionsFactory, CodemationBetterAuthDatabaseOptionsFactory);
+    container.registerSingleton(UserAccountSessionPolicy, UserAccountSessionPolicy);
     container.register(CodemationBetterAuthBaseUrlPolicy, {
       useFactory: instanceCachingFactory(
         (dependencyContainer) =>
@@ -488,7 +522,7 @@ export class AppContainerFactory {
         return new BetterAuthApiSessionVerifier(runtime, eligibility);
       }),
     });
-    container.register(CodemationSessionVerifier, { useClass: CodemationSessionVerifier });
+    container.registerSingleton(CodemationSessionVerifier, CodemationSessionVerifier);
     container.register(ApplicationTokens.SessionVerifier, {
       useFactory: instanceCachingFactory((dependencyContainer) => {
         const appConfig = dependencyContainer.resolve<AppConfig>(ApplicationTokens.AppConfig);
@@ -528,33 +562,51 @@ export class AppContainerFactory {
   }
 
   private registerRepositoriesAndBuses(container: Container): void {
-    container.register(WorkflowDefinitionRepositoryAdapter, { useClass: WorkflowDefinitionRepositoryAdapter });
-    container.register(InMemoryWorkflowRunRepository, { useClass: InMemoryWorkflowRunRepository });
-    container.register(InMemoryTriggerSetupStateRepository, { useClass: InMemoryTriggerSetupStateRepository });
-    container.register(InMemoryCredentialStore, { useClass: InMemoryCredentialStore });
-    container.register(SqlWorkflowRunRepository, { useClass: SqlWorkflowRunRepository });
-    container.register(InMemoryWorkflowDebuggerOverlayRepository, {
-      useClass: InMemoryWorkflowDebuggerOverlayRepository,
+    container.registerSingleton(OtelIdentityFactory, OtelIdentityFactory);
+    container.registerSingleton(TelemetryPrivacyPolicy, TelemetryPrivacyPolicy);
+    container.registerSingleton(TelemetryEnricherChain, TelemetryEnricherChain);
+    container.registerSingleton(TelemetryRetentionTimestampFactory, TelemetryRetentionTimestampFactory);
+    container.registerSingleton(TelemetryQueryService, TelemetryQueryService);
+    container.registerSingleton(NoOpTelemetryExporter, NoOpTelemetryExporter);
+    container.register(CompositeTelemetryExporter, {
+      useFactory: instanceCachingFactory(
+        (dependencyContainer) => new CompositeTelemetryExporter([dependencyContainer.resolve(NoOpTelemetryExporter)]),
+      ),
     });
-    container.register(PrismaTriggerSetupStateRepository, { useClass: PrismaTriggerSetupStateRepository });
-    container.register(PrismaWorkflowDebuggerOverlayRepository, { useClass: PrismaWorkflowDebuggerOverlayRepository });
-    container.register(PrismaWorkflowActivationRepository, { useClass: PrismaWorkflowActivationRepository });
-    container.register(InMemoryWorkflowActivationRepository, { useClass: InMemoryWorkflowActivationRepository });
-    container.register(PrismaCredentialStore, { useClass: PrismaCredentialStore });
+    container.registerSingleton(OtelExecutionTelemetryFactory, OtelExecutionTelemetryFactory);
+    container.registerSingleton(InMemoryRunTraceContextRepository, InMemoryRunTraceContextRepository);
+    container.registerSingleton(InMemoryTelemetrySpanStore, InMemoryTelemetrySpanStore);
+    container.registerSingleton(InMemoryTelemetryArtifactStore, InMemoryTelemetryArtifactStore);
+    container.registerSingleton(InMemoryTelemetryMetricPointStore, InMemoryTelemetryMetricPointStore);
+    container.registerSingleton(PrismaRunTraceContextRepository, PrismaRunTraceContextRepository);
+    container.registerSingleton(PrismaTelemetrySpanStore, PrismaTelemetrySpanStore);
+    container.registerSingleton(PrismaTelemetryArtifactStore, PrismaTelemetryArtifactStore);
+    container.registerSingleton(PrismaTelemetryMetricPointStore, PrismaTelemetryMetricPointStore);
+    container.registerSingleton(WorkflowDefinitionRepositoryAdapter, WorkflowDefinitionRepositoryAdapter);
+    container.registerSingleton(InMemoryWorkflowRunRepository, InMemoryWorkflowRunRepository);
+    container.registerSingleton(InMemoryTriggerSetupStateRepository, InMemoryTriggerSetupStateRepository);
+    container.registerSingleton(InMemoryCredentialStore, InMemoryCredentialStore);
+    container.registerSingleton(SqlWorkflowRunRepository, SqlWorkflowRunRepository);
+    container.registerSingleton(InMemoryWorkflowDebuggerOverlayRepository, InMemoryWorkflowDebuggerOverlayRepository);
+    container.registerSingleton(PrismaTriggerSetupStateRepository, PrismaTriggerSetupStateRepository);
+    container.registerSingleton(PrismaWorkflowDebuggerOverlayRepository, PrismaWorkflowDebuggerOverlayRepository);
+    container.registerSingleton(PrismaWorkflowActivationRepository, PrismaWorkflowActivationRepository);
+    container.registerSingleton(InMemoryWorkflowActivationRepository, InMemoryWorkflowActivationRepository);
+    container.registerSingleton(PrismaCredentialStore, PrismaCredentialStore);
     container.register(ApplicationTokens.WorkflowDefinitionRepository, {
       useFactory: instanceCachingFactory(
         (dependencyContainer) =>
           dependencyContainer.resolve(WorkflowDefinitionRepositoryAdapter) as unknown as WorkflowDefinitionRepository,
       ),
     });
-    container.register(InMemoryQueryBus, { useClass: InMemoryQueryBus });
-    container.register(InMemoryCommandBus, { useClass: InMemoryCommandBus });
-    container.register(InMemoryDomainEventBus, { useClass: InMemoryDomainEventBus });
+    container.registerSingleton(InMemoryQueryBus, InMemoryQueryBus);
+    container.registerSingleton(InMemoryCommandBus, InMemoryCommandBus);
+    container.registerSingleton(InMemoryDomainEventBus, InMemoryDomainEventBus);
     for (const handler of AppContainerFactory.queryHandlers) {
-      container.register(ApplicationTokens.QueryHandler, { useClass: handler });
+      container.registerSingleton(ApplicationTokens.QueryHandler, handler);
     }
     for (const handler of AppContainerFactory.commandHandlers) {
-      container.register(ApplicationTokens.CommandHandler, { useClass: handler });
+      container.registerSingleton(ApplicationTokens.CommandHandler, handler);
     }
     container.register(ApplicationTokens.QueryBus, {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(InMemoryQueryBus)),
@@ -565,26 +617,33 @@ 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 {
-    container.register(DevBootstrapSummaryAssembler, { useClass: DevBootstrapSummaryAssembler });
-    container.register(DevBootstrapSummaryHttpRouteHandler, { useClass: DevBootstrapSummaryHttpRouteHandler });
-    container.register(AuthHttpRouteHandler, { useClass: AuthHttpRouteHandler });
-    container.register(PublicFrontendBootstrapHttpRouteHandler, { useClass: PublicFrontendBootstrapHttpRouteHandler });
-    container.register(InternalAuthBootstrapHttpRouteHandler, { useClass: InternalAuthBootstrapHttpRouteHandler });
-    container.register(WhitelabelLogoHttpRouteHandler, { useClass: WhitelabelLogoHttpRouteHandler });
+    container.registerSingleton(DevBootstrapSummaryAssembler, DevBootstrapSummaryAssembler);
+    container.registerSingleton(DevBootstrapSummaryHttpRouteHandler, DevBootstrapSummaryHttpRouteHandler);
+    container.registerSingleton(AuthHttpRouteHandler, AuthHttpRouteHandler);
+    container.registerSingleton(PublicFrontendBootstrapHttpRouteHandler, PublicFrontendBootstrapHttpRouteHandler);
+    container.registerSingleton(InternalAuthBootstrapHttpRouteHandler, InternalAuthBootstrapHttpRouteHandler);
+    container.registerSingleton(WhitelabelLogoHttpRouteHandler, WhitelabelLogoHttpRouteHandler);
     for (const registrar of AppContainerFactory.honoRouteRegistrars) {
-      container.register(ApplicationTokens.HonoApiRouteRegistrar, { useClass: registrar });
+      container.registerSingleton(ApplicationTokens.HonoApiRouteRegistrar, registrar);
     }
-    container.register(CodemationHonoApiApp, { useClass: CodemationHonoApiApp });
+    container.registerSingleton(CodemationHonoApiApp, CodemationHonoApiApp);
   }
 
   private registerOperationalInfrastructure(container: Container): void {
     container.register(ApplicationTokens.WorkflowWebsocketPublisher, {
       useFactory: instanceCachingFactory((dependencyContainer) => dependencyContainer.resolve(WorkflowWebsocketServer)),
     });
-    container.register(WorkflowRunEventWebsocketRelay, { useClass: WorkflowRunEventWebsocketRelay });
+    container.registerSingleton(WorkflowRunEventWebsocketRelay, WorkflowRunEventWebsocketRelay);
+    container.registerSingleton(RunEventBusTelemetryReporter, RunEventBusTelemetryReporter);
+    container.registerSingleton(WorkflowRunRetentionPruneScheduler, WorkflowRunRetentionPruneScheduler);
   }
 
   private async registerRuntimeInfrastructure(container: Container, appConfig: AppConfig): Promise<PrismaOwnership> {
@@ -597,7 +656,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 +678,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 +711,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 +732,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 +800,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 +841,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/CodemationContainerRegistrationRegistrar.ts

@@ -18,9 +18,7 @@ export class CodemationContainerRegistrationRegistrar {
       return;
     }
     if (this.isClassRegistration(registration)) {
-      container.register(registration.token, {
-        useClass: registration.useClass as never,
-      });
+      container.registerSingleton(registration.token as never, registration.useClass as never);
       return;
     }
     container.register(registration.token, {

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>>;