apm-optima 1.0.5 → 2.0.0

package/dist/express/metrics.bootstrap.js

@@ -5,35 +5,61 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expressMetricsBootstrap = expressMetricsBootstrap;
 const metrics_websocket_adapter_1 = require("./metrics-websocket.adapter");
-const collector_service_1 = require("../core/telemetry/collector.service");
 const simulation_1 = require("../simulation/simulation");
 const delivery_1 = require("../core/delivery");
-const correlation_service_1 = require("../core/telemetry/correlation.service");
-const config_1 = require("../config");
 const logger_1 = __importDefault(require("../core/telemetry/logger"));
-function expressMetricsBootstrap(server) {
-    const config = (0, config_1.getConfig)();
+const organizers_1 = require("../core/organizers");
+const runtime_1 = require("../runtime");
+let started = false;
+function expressMetricsBootstrap(server, dependencies) {
+    if (started)
+        return async () => { };
+    started = true;
+    const config = dependencies.config;
     let simulator = null;
     if (config.simulation) {
-        simulator = new simulation_1.TrafficSimulator();
-        simulator.start({
-            intervalMs: config.simulation.intervalMs,
-            requestsPerTick: config.simulation.requestsPerTick,
-        });
+        simulator = new simulation_1.TrafficSimulator(dependencies.storage);
+        simulator.start(config.simulation);
     }
-    const websocket = new metrics_websocket_adapter_1.ExpressWebSocketAdapter(server, collector_service_1.collectorService);
+    const websocket = new metrics_websocket_adapter_1.ExpressWebSocketAdapter(server, dependencies.collector, dependencies.persistence, dependencies.correlation, dependencies.incidents, config);
     websocket.init();
-    const publisher = new delivery_1.MetricsPublisher(collector_service_1.collectorService, websocket, config.publisher.intervalMs);
-    publisher.start();
-    const tickInterval = setInterval(() => {
-        collector_service_1.collectorService.tick();
-        correlation_service_1.correlationService.tick();
-    }, config.tickIntervalMs);
+    const eventManager = new organizers_1.ApplicationEventManager(dependencies.persistence, config.applicationVersion);
+    eventManager.start();
+    const publisher = new delivery_1.MetricsPublisher(dependencies.collector, dependencies.persistence, dependencies.correlation, dependencies.incidents, websocket);
+    const intervalManager = new organizers_1.IntervalManager({
+        tick: () => { dependencies.collector.tick(); dependencies.correlation.tick(); dependencies.incidents.tick(); },
+        publisher: () => { publisher.publish(); },
+        persistence: () => { dependencies.persistence.archiveAllCategories(); }
+    }, config);
+    intervalManager.startIntervals();
     logger_1.default.debug('Metrics bootstrap initialized successfully.');
-    return () => {
-        simulator?.stop();
-        publisher.stop();
-        clearInterval(tickInterval);
-        websocket.disconnect();
+    void organizers_1.ApplicationEventManager.instance?.emit({
+        type: 'STARTUP',
+        reason: 'Express metrics module initialized',
+    });
+    let stopping = null;
+    const stop = (options = {}) => {
+        if (stopping)
+            return stopping;
+        logger_1.default.debug('Metrics bootstrap shutdown initiated.');
+        stopping = (0, runtime_1.shutdownOptimaRuntime)(dependencies, {
+            stopIntake: () => {
+                simulator?.stop();
+                if (options.closeServer && server.listening)
+                    server.close();
+            },
+            stopProducers: () => intervalManager.stopIntervals(),
+            emitShutdownEvent: async () => {
+                await organizers_1.ApplicationEventManager.instance?.emit({
+                    type: 'SHUTDOWN',
+                    reason: 'Express metrics module shutting down',
+                });
+                eventManager.stop();
+            },
+            closeTransport: () => websocket.disconnect(),
+            drainTimeoutMs: options.drainTimeoutMs,
+        }).finally(() => { started = false; });
+        return stopping;
     };
+    return stop;
 }

package/dist/express/metrics.dashboard.d.ts

@@ -1,2 +1,3 @@
 import express from 'express';
-export declare function attachDashboard(app: express.Express, routePath?: string): void;
+import type { PersistenceRepository } from '../core/storage';
+export declare function attachDashboard(app: express.Express, routePath: string, persistence: PersistenceRepository): void;

package/dist/express/metrics.dashboard.js

@@ -8,13 +8,16 @@ const express_1 = __importDefault(require("express"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const logger_1 = __importDefault(require("../core/telemetry/logger"));
-function attachDashboard(app, routePath = '/dashboard') {
+const session_export_handler_1 = require("../adapters/session-export.handler");
+function attachDashboard(app, routePath, persistence) {
     const dashboardDir = path_1.default.join(__dirname, '../../dashboard-out');
     const indexHtmlPath = path_1.default.join(dashboardDir, 'index.html');
     if (!fs_1.default.existsSync(indexHtmlPath)) {
         logger_1.default.error(`Dashboard not found at ${indexHtmlPath}. Please build the dashboard first.`);
         return;
     }
+    const exportSession = (0, session_export_handler_1.createSessionExportHandler)(persistence);
+    app.get((0, session_export_handler_1.sessionExportRoute)(routePath), (req, res) => { void exportSession(req, res); });
     app.use(routePath, express_1.default.static(dashboardDir));
     app.get(`${routePath}*`, (req, res) => {
         res.sendFile(indexHtmlPath);

package/dist/express/metrics.middleware.d.ts

@@ -1,2 +1,3 @@
 import type { RequestHandler } from 'express';
-export declare const expressMetricsMiddleware: RequestHandler;
+import type { OptimaRuntimeDependencies } from '../runtime';
+export declare const createExpressMetricsMiddleware: (dependencies: OptimaRuntimeDependencies) => RequestHandler;

package/dist/express/metrics.middleware.js

@@ -3,27 +3,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expressMetricsMiddleware = void 0;
-const telemetry_service_1 = __importDefault(require("../core/telemetry/telemetry.service"));
+exports.createExpressMetricsMiddleware = void 0;
 const logger_1 = __importDefault(require("../core/telemetry/logger"));
 const metrics_adapter_1 = require("./metrics.adapter");
-const telemetryService = new telemetry_service_1.default();
 const adapter = new metrics_adapter_1.ExpressAdapter();
-const expressMetricsMiddleware = (req, res, next) => {
-    const startHrTime = process.hrtime.bigint();
-    res.on('finish', () => {
-        const requestData = adapter.getRequest(req);
-        const responseData = adapter.getResponse(res);
-        const telemetryRequest = telemetryService.record({
-            endpoint: requestData.endpoint,
-            method: requestData.method,
-            statusCode: responseData.statusCode,
-            clientIp: requestData.clientIp
-        }, startHrTime);
-        if (telemetryRequest !== null) {
-            logger_1.default.log(req, res, telemetryRequest.responseTime);
-        }
-    });
-    next();
+const createExpressMetricsMiddleware = (dependencies) => {
+    return (req, res, next) => {
+        const startHrTime = process.hrtime.bigint();
+        const done = dependencies.telemetry.track();
+        res.on('close', done);
+        res.on('finish', () => {
+            const requestData = adapter.getRequest(req);
+            const responseData = adapter.getResponse(res);
+            const telemetryRequest = dependencies.telemetry.record({
+                endpoint: requestData.endpoint,
+                method: requestData.method,
+                statusCode: responseData.statusCode,
+                clientIp: requestData.clientIp
+            }, startHrTime);
+            if (telemetryRequest !== null) {
+                logger_1.default.log(req, res, telemetryRequest.responseTime);
+            }
+            done();
+        });
+        next();
+    };
 };
-exports.expressMetricsMiddleware = expressMetricsMiddleware;
+exports.createExpressMetricsMiddleware = createExpressMetricsMiddleware;

package/dist/nest/metrics-websocket.adapter.d.ts

@@ -1,15 +1,31 @@
 import { OnGatewayConnection, OnGatewayDisconnect } from '@nestjs/websockets';
 import type { Socket } from 'socket.io';
 import type { WebSocketAdapter } from '../adapters/websocket.adapter';
+import type { AnalyticsFilterSettings } from '../core/domain';
+import type { OptimaRuntimeDependencies } from '../runtime';
 export declare class NestWebSocketAdapter implements WebSocketAdapter, OnGatewayConnection, OnGatewayDisconnect {
+    private readonly dependencies;
     private server;
+    constructor(dependencies: OptimaRuntimeDependencies);
     init(): void;
-    handleConnection(socket: Socket): void;
+    handleConnection(socket: Socket): Promise<void>;
     handleDisconnect(socket: Socket): void;
+    handleSessionMetadata(socket: Socket): void;
+    handleSessionSummary(socket: Socket, payload: {
+        sessionNumber: number;
+    }): Promise<void>;
     handleSystemData(socket: Socket): void;
-    handleDashboardData(socket: Socket): void;
-    handleAnalyticsData(socket: Socket): void;
+    handleAnalyticsData(socket: Socket, payload: {
+        filters: AnalyticsFilterSettings;
+    }): void;
     handleHealthData(socket: Socket): void;
+    handleCorrelationData(socket: Socket): void;
+    handleConfiguration(socket: Socket): void;
+    handleIncidents(socket: Socket): void;
+    handleDashboardBuckets(socket: Socket, payload: unknown): Promise<void>;
+    handleCorrelationReplay(socket: Socket, payload: {
+        findingId: string;
+    }): Promise<void>;
     broadcast(event: string, data: unknown): void;
     disconnect(): void;
 }

package/dist/nest/metrics-websocket.adapter.js

@@ -18,33 +18,71 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NestWebSocketAdapter = void 0;
 const websockets_1 = require("@nestjs/websockets");
 const delivery_1 = require("../core/delivery");
-const collector_service_1 = require("../core/telemetry/collector.service");
 const logger_1 = __importDefault(require("../core/telemetry/logger"));
+const common_1 = require("@nestjs/common");
+const config_1 = require("../config");
+const socket_options_1 = require("../adapters/socket.options");
 let NestWebSocketAdapter = class NestWebSocketAdapter {
+    dependencies;
     server;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
     init() { }
-    handleConnection(socket) {
+    async handleConnection(socket) {
         logger_1.default.debug('Dashboard client connected.', socket.id);
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_SESSION_METADATA, await this.dependencies.persistence.getSessionManifest());
     }
     handleDisconnect(socket) {
         logger_1.default.debug('Dashboard client disconnected.', socket.id);
     }
-    handleSystemData(socket) {
-        socket.emit(delivery_1.WebSocketEvents.RESPONSE_SYSTEM_DATA, collector_service_1.collectorService.getSystemStaticInfo());
+    handleSessionMetadata(socket) {
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_SESSION_METADATA, this.dependencies.persistence.getSessionManifest());
     }
-    handleDashboardData(socket) {
-        socket.emit(delivery_1.WebSocketEvents.RESPONSE_DASHBOARD_DATA, collector_service_1.collectorService.getDashboardData());
+    async handleSessionSummary(socket, payload) {
+        const sessionNumber = Number(payload?.sessionNumber);
+        const summary = await this.dependencies.persistence.getSessionSummary(sessionNumber);
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_SESSION_SUMMARY, summary);
     }
-    handleAnalyticsData(socket) {
-        socket.emit(delivery_1.WebSocketEvents.RESPONSE_ANALYTICS_DATA, collector_service_1.collectorService.getAnalyticsData());
+    handleSystemData(socket) {
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_SYSTEM_DATA, this.dependencies.collector.getSystemStaticInfo());
+    }
+    handleAnalyticsData(socket, payload) {
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_ANALYTICS_DATA, this.dependencies.collector.getAnalyticsData(payload?.filters ?? undefined));
     }
     handleHealthData(socket) {
-        socket.emit(delivery_1.WebSocketEvents.RESPONSE_HEALTH_DATA, collector_service_1.collectorService.getHealthData());
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_HEALTH_DATA, this.dependencies.collector.getHealthData());
+    }
+    handleCorrelationData(socket) {
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_CORRELATION_DATA, this.dependencies.correlation.pack());
+    }
+    handleConfiguration(socket) {
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_CONFIGURATION, (0, config_1.toClientConfig)(this.dependencies.config));
+    }
+    handleIncidents(socket) {
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_INCIDENTS, this.dependencies.incidents.snapshot());
+    }
+    async handleDashboardBuckets(socket, payload) {
+        const req = (0, delivery_1.parseBucketsRequest)(payload);
+        if (!req)
+            return;
+        try {
+            socket.emit(delivery_1.WebSocketEvents.RESPONSE_DASHBOARD_BUCKETS, await this.dependencies.dashboard.getBackFill(req));
+        }
+        catch (err) {
+            logger_1.default.error('Dashboard backfill failed:', err);
+        }
+    }
+    async handleCorrelationReplay(socket, payload) {
+        const findingId = String(payload?.findingId);
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_CORRELATION_REPLAY, { findingId, outcome: await this.dependencies.correlation.replay(findingId) });
     }
     broadcast(event, data) {
         this.server.emit(event, data);
     }
     disconnect() {
+        if (!this.server)
+            return;
         this.server?.disconnectSockets(true);
     }
 };
@@ -54,24 +92,33 @@ __decorate([
     __metadata("design:type", Function)
 ], NestWebSocketAdapter.prototype, "server", void 0);
 __decorate([
-    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_SYSTEM_DATA),
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_SESSION_METADATA),
     __param(0, (0, websockets_1.ConnectedSocket)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Function]),
     __metadata("design:returntype", void 0)
-], NestWebSocketAdapter.prototype, "handleSystemData", null);
+], NestWebSocketAdapter.prototype, "handleSessionMetadata", null);
 __decorate([
-    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_DASHBOARD_DATA),
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_SESSION_SUMMARY),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function, Object]),
+    __metadata("design:returntype", Promise)
+], NestWebSocketAdapter.prototype, "handleSessionSummary", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_SYSTEM_DATA),
     __param(0, (0, websockets_1.ConnectedSocket)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Function]),
     __metadata("design:returntype", void 0)
-], NestWebSocketAdapter.prototype, "handleDashboardData", null);
+], NestWebSocketAdapter.prototype, "handleSystemData", null);
 __decorate([
     (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_ANALYTICS_DATA),
     __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Function]),
+    __metadata("design:paramtypes", [Function, Object]),
     __metadata("design:returntype", void 0)
 ], NestWebSocketAdapter.prototype, "handleAnalyticsData", null);
 __decorate([
@@ -81,12 +128,45 @@ __decorate([
     __metadata("design:paramtypes", [Function]),
     __metadata("design:returntype", void 0)
 ], NestWebSocketAdapter.prototype, "handleHealthData", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_CORRELATION_DATA),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function]),
+    __metadata("design:returntype", void 0)
+], NestWebSocketAdapter.prototype, "handleCorrelationData", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_CONFIGURATION),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function]),
+    __metadata("design:returntype", void 0)
+], NestWebSocketAdapter.prototype, "handleConfiguration", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_INCIDENTS),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function]),
+    __metadata("design:returntype", void 0)
+], NestWebSocketAdapter.prototype, "handleIncidents", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_DASHBOARD_BUCKETS),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function, Object]),
+    __metadata("design:returntype", Promise)
+], NestWebSocketAdapter.prototype, "handleDashboardBuckets", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_CORRELATION_REPLAY),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __param(1, (0, websockets_1.MessageBody)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function, Object]),
+    __metadata("design:returntype", Promise)
+], NestWebSocketAdapter.prototype, "handleCorrelationReplay", null);
 exports.NestWebSocketAdapter = NestWebSocketAdapter = __decorate([
-    (0, websockets_1.WebSocketGateway)({
-        transports: ['websocket'],
-        cors: {
-            origin: '*',
-            methods: ['GET', 'POST'],
-        },
-    })
+    (0, websockets_1.WebSocketGateway)((0, socket_options_1.socketServerOptions)(config_1.DEFAULT_CONFIG.transport)),
+    __param(0, (0, common_1.Inject)('OPTIMA_RUNTIME_DEPENDENCIES')),
+    __metadata("design:paramtypes", [Object])
 ], NestWebSocketAdapter);

package/dist/nest/metrics.adapter.d.ts

@@ -1,9 +1,12 @@
 import type { ExecutionContext } from '@nestjs/common';
 import type { HttpAdapter } from '../adapters/http.adapter';
 export declare class NestAdapter implements HttpAdapter<ExecutionContext, ExecutionContext> {
+    private getEndpoint;
+    private normalizePath;
+    private joinPaths;
     getRequest(context: ExecutionContext): {
         method: any;
-        endpoint: any;
+        endpoint: string;
         clientIp: any;
     };
     getResponse(context: ExecutionContext): {

package/dist/nest/metrics.adapter.js

@@ -1,7 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NestAdapter = void 0;
+const constants_1 = require("@nestjs/common/constants");
 class NestAdapter {
+    getEndpoint(context) {
+        const controller = context.getClass();
+        const handler = context.getHandler();
+        const controllerPath = Reflect.getMetadata(constants_1.PATH_METADATA, controller);
+        const handlerPath = Reflect.getMetadata(constants_1.PATH_METADATA, handler);
+        const controllerRoute = this.normalizePath(controllerPath);
+        const route = this.normalizePath(handlerPath);
+        return this.joinPaths(controllerRoute, route);
+    }
+    normalizePath(path) {
+        if (!path) {
+            return '';
+        }
+        if (Array.isArray(path)) {
+            return path[0] ?? '';
+        }
+        return path;
+    }
+    joinPaths(...paths) {
+        const result = paths.filter(Boolean).join('/');
+        return result.startsWith('/') ? result : `/${result}`;
+    }
     getRequest(context) {
         const request = context.switchToHttp().getRequest();
         const { body, // Parsed JSON or form data
@@ -17,7 +40,7 @@ class NestAdapter {
          } = request;
         return {
             method,
-            endpoint: path,
+            endpoint: this.getEndpoint(context),
             clientIp: ip,
         };
     }

package/dist/nest/metrics.bootstrap.service.d.ts

@@ -1,13 +1,17 @@
 import { OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
 import { NestWebSocketAdapter } from './metrics-websocket.adapter';
 import { type ReadonlyConfig } from '../config';
+import { type OptimaRuntimeDependencies } from '../runtime';
 export declare class MetricsBootstrapService implements OnApplicationBootstrap, OnApplicationShutdown {
     private readonly websocket;
     private readonly config;
+    private readonly dependencies;
+    private started;
     private simulator;
     private publisher;
-    private tickInterval;
-    constructor(websocket: NestWebSocketAdapter, config: ReadonlyConfig);
+    private intervalManager;
+    private eventManager;
+    constructor(websocket: NestWebSocketAdapter, config: ReadonlyConfig, dependencies: OptimaRuntimeDependencies);
     onApplicationBootstrap(): void;
-    onApplicationShutdown(): void;
+    onApplicationShutdown(): Promise<void>;
 }

package/dist/nest/metrics.bootstrap.service.js

@@ -17,54 +17,89 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetricsBootstrapService = void 0;
 const common_1 = require("@nestjs/common");
-const collector_service_1 = require("../core/telemetry/collector.service");
-const correlation_service_1 = require("../core/telemetry/correlation.service");
 const delivery_1 = require("../core/delivery");
 const simulation_1 = require("../simulation/simulation");
 const metrics_websocket_adapter_1 = require("./metrics-websocket.adapter");
 const logger_1 = __importDefault(require("../core/telemetry/logger"));
+const organizers_1 = require("../core/organizers");
+const runtime_1 = require("../runtime");
 let MetricsBootstrapService = class MetricsBootstrapService {
     websocket;
     config;
+    dependencies;
+    started = false;
     simulator = null;
     publisher = null;
-    tickInterval = null;
-    constructor(websocket, config) {
+    intervalManager = null;
+    eventManager = null;
+    constructor(websocket, config, dependencies) {
         this.websocket = websocket;
         this.config = config;
+        this.dependencies = dependencies;
     }
     onApplicationBootstrap() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        if (!this.dependencies) {
+            logger_1.default.error('Failed to create Optima runtime dependencies.');
+            return;
+        }
         const simulationConfig = this.config.simulation === false
             ? null
             : this.config.simulation;
         if (simulationConfig) {
-            this.simulator = new simulation_1.TrafficSimulator();
+            this.simulator = new simulation_1.TrafficSimulator(this.dependencies.storage);
             this.simulator.start(simulationConfig);
         }
         this.websocket.init();
-        this.publisher = new delivery_1.MetricsPublisher(collector_service_1.collectorService, this.websocket, this.config.publisher.intervalMs);
-        this.publisher.start();
-        this.tickInterval = setInterval(() => {
-            collector_service_1.collectorService.tick();
-            correlation_service_1.correlationService.tick();
-        }, this.config.tickIntervalMs);
+        this.eventManager = new organizers_1.ApplicationEventManager(this.dependencies.persistence, this.config.applicationVersion);
+        this.eventManager.start();
+        this.publisher = new delivery_1.MetricsPublisher(this.dependencies.collector, this.dependencies.persistence, this.dependencies.correlation, this.dependencies.incidents, this.websocket);
+        this.intervalManager = new organizers_1.IntervalManager({
+            tick: () => { this.dependencies.collector.tick(); this.dependencies.correlation.tick(); this.dependencies.incidents.tick(); },
+            publisher: () => { this.publisher?.publish(); },
+            persistence: () => { this.dependencies.persistence.archiveAllCategories(); }
+        }, this.config);
+        this.intervalManager.startIntervals();
         logger_1.default.debug('Nest metrics bootstrap initialized.');
+        void organizers_1.ApplicationEventManager.instance?.emit({
+            type: 'STARTUP',
+            reason: 'Nest metrics module initialized',
+        });
     }
-    onApplicationShutdown() {
-        this.simulator?.stop();
-        this.simulator = null;
-        this.publisher?.stop();
-        this.publisher = null;
-        if (this.tickInterval) {
-            clearInterval(this.tickInterval);
-            this.tickInterval = null;
+    async onApplicationShutdown() {
+        if (!this.started) {
+            return;
         }
-        this.websocket.disconnect();
+        this.started = false;
+        await (0, runtime_1.shutdownOptimaRuntime)(this.dependencies, {
+            stopIntake: () => {
+                this.simulator?.stop();
+                this.simulator = null;
+            },
+            stopProducers: () => {
+                this.intervalManager?.stopIntervals();
+                this.intervalManager = null;
+                this.publisher = null;
+            },
+            emitShutdownEvent: async () => {
+                await organizers_1.ApplicationEventManager.instance?.emit({
+                    type: 'SHUTDOWN',
+                    reason: 'Nest metrics module shutting down',
+                });
+                this.eventManager?.stop();
+                this.eventManager = null;
+            },
+            closeTransport: () => this.websocket.disconnect(),
+        });
     }
 };
 exports.MetricsBootstrapService = MetricsBootstrapService;
 exports.MetricsBootstrapService = MetricsBootstrapService = __decorate([
     (0, common_1.Injectable)(),
     __param(1, (0, common_1.Inject)('METRICS_CONFIG')),
-    __metadata("design:paramtypes", [metrics_websocket_adapter_1.NestWebSocketAdapter, Object])
+    __param(2, (0, common_1.Inject)('OPTIMA_RUNTIME_DEPENDENCIES')),
+    __metadata("design:paramtypes", [metrics_websocket_adapter_1.NestWebSocketAdapter, Object, Object])
 ], MetricsBootstrapService);

package/dist/nest/metrics.interceptor.d.ts

@@ -1,11 +1,11 @@
 import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
 import { Observable } from 'rxjs';
-import TelemetryService from '../core/telemetry/telemetry.service';
 import { NestAdapter } from './metrics.adapter';
+import type { OptimaRuntimeDependencies } from '../runtime';
 export declare class MetricsInterceptor implements NestInterceptor {
     private readonly adapter;
-    private readonly telemetryService;
-    constructor(adapter: NestAdapter, telemetryService: TelemetryService);
+    private readonly dependencies;
+    constructor(adapter: NestAdapter, dependencies: OptimaRuntimeDependencies);
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
     private record;
 }

package/dist/nest/metrics.interceptor.js

@@ -8,6 +8,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -15,30 +18,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetricsInterceptor = void 0;
 const common_1 = require("@nestjs/common");
 const operators_1 = require("rxjs/operators");
-const telemetry_service_1 = __importDefault(require("../core/telemetry/telemetry.service"));
 const metrics_adapter_1 = require("./metrics.adapter");
 const logger_1 = __importDefault(require("../core/telemetry/logger"));
 let MetricsInterceptor = class MetricsInterceptor {
     adapter;
-    telemetryService;
-    constructor(adapter, telemetryService) {
+    dependencies;
+    constructor(adapter, dependencies) {
         this.adapter = adapter;
-        this.telemetryService = telemetryService;
+        this.dependencies = dependencies;
     }
     intercept(context, next) {
         if (context.getType() !== 'http') {
             return next.handle();
         }
         const startHrTime = process.hrtime.bigint();
+        const done = this.dependencies.telemetry.track();
         return next.handle().pipe((0, operators_1.tap)({
             next: () => this.record(context, startHrTime),
             error: () => this.record(context, startHrTime),
-        }));
+        }), (0, operators_1.finalize)(done));
     }
     record(context, startHrTime) {
         const requestData = this.adapter.getRequest(context);
         const responseData = this.adapter.getResponse(context);
-        const telemetryRequest = this.telemetryService.record({
+        const telemetryRequest = this.dependencies.telemetry.record({
             endpoint: requestData.endpoint,
             method: requestData.method,
             statusCode: responseData.statusCode,
@@ -52,6 +55,6 @@ let MetricsInterceptor = class MetricsInterceptor {
 exports.MetricsInterceptor = MetricsInterceptor;
 exports.MetricsInterceptor = MetricsInterceptor = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [metrics_adapter_1.NestAdapter,
-        telemetry_service_1.default])
+    __param(1, (0, common_1.Inject)('OPTIMA_RUNTIME_DEPENDENCIES')),
+    __metadata("design:paramtypes", [metrics_adapter_1.NestAdapter, Object])
 ], MetricsInterceptor);

package/dist/nest/metrics.module.d.ts

@@ -1,6 +1,9 @@
 import { DynamicModule, NestModule, MiddlewareConsumer } from "@nestjs/common";
 import { ConfigOptions } from '../config';
+import { type OptimaRuntimeDependencies } from '../runtime';
 export declare class MetricsModule implements NestModule {
+    private readonly dependencies;
+    constructor(dependencies: OptimaRuntimeDependencies);
     static forRoot(options?: ConfigOptions): DynamicModule;
     configure(consumer: MiddlewareConsumer): void;
 }