apm-optima 0.0.1

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

@@ -0,0 +1,88 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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); }
+};
+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");
+let NestWebSocketAdapter = class NestWebSocketAdapter {
+    server;
+    init() { }
+    handleConnection(socket) {
+        console.log('[Optima] Dashboard klijent se povezao.', socket.id);
+    }
+    handleDisconnect(socket) {
+        console.log('[Optima] Dashboard klijent se odjavio.', socket.id);
+    }
+    handleSystemData(socket) {
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_SYSTEM_DATA, collector_service_1.collectorService.getSystemStaticInfo());
+    }
+    handleDashboardData(socket) {
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_DASHBOARD_DATA, collector_service_1.collectorService.getDashboardData());
+    }
+    handleAnalyticsData(socket) {
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_ANALYTICS_DATA, collector_service_1.collectorService.getAnalyticsData());
+    }
+    handleHealthData(socket) {
+        socket.emit(delivery_1.WebSocketEvents.RESPONSE_HEALTH_DATA, collector_service_1.collectorService.getHealthData());
+    }
+    broadcast(event, data) {
+        this.server.emit(event, data);
+    }
+    disconnect() {
+        this.server?.disconnectSockets(true);
+    }
+};
+exports.NestWebSocketAdapter = NestWebSocketAdapter;
+__decorate([
+    (0, websockets_1.WebSocketServer)(),
+    __metadata("design:type", Function)
+], NestWebSocketAdapter.prototype, "server", void 0);
+__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, "handleSystemData", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_DASHBOARD_DATA),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function]),
+    __metadata("design:returntype", void 0)
+], NestWebSocketAdapter.prototype, "handleDashboardData", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_ANALYTICS_DATA),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function]),
+    __metadata("design:returntype", void 0)
+], NestWebSocketAdapter.prototype, "handleAnalyticsData", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)(delivery_1.WebSocketEvents.REQUEST_HEALTH_DATA),
+    __param(0, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function]),
+    __metadata("design:returntype", void 0)
+], NestWebSocketAdapter.prototype, "handleHealthData", null);
+exports.NestWebSocketAdapter = NestWebSocketAdapter = __decorate([
+    (0, websockets_1.WebSocketGateway)({
+        transports: ['websocket'],
+        cors: {
+            origin: '*',
+            methods: ['GET', 'POST'],
+        },
+    })
+], NestWebSocketAdapter);

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

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

package/dist/nest/metrics.adapter.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestAdapter = void 0;
+class NestAdapter {
+    getRequest(context) {
+        const request = context.switchToHttp().getRequest();
+        const { body, // Parsed JSON or form data
+        params, // Route path variables
+        query, // URL query string parameters
+        headers, // HTTP request headers
+        cookies, // Parsed client browser cookies
+        method, // Executed HTTP verb (GET, POST, etc.)
+        path, // Requested URL path string
+        ip, // Remote client IP address
+        secure, // Boolean for TLS connection status
+        url, // Full requested URL string
+         } = request;
+        return {
+            method,
+            endpoint: path,
+            clientIp: ip,
+        };
+    }
+    getResponse(context) {
+        const response = context.switchToHttp().getResponse();
+        const { locals, // Request-scoped middleware variables
+        headersSent, // Boolean tracking sent HTTP headers
+        statusCode, // Current HTTP status code
+         } = response;
+        return { statusCode };
+    }
+}
+exports.NestAdapter = NestAdapter;

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

@@ -0,0 +1,13 @@
+import { OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
+import { NestWebSocketAdapter } from './metrics-websocket.adapter';
+import { type ReadonlyConfig } from '../config';
+export declare class MetricsBootstrapService implements OnApplicationBootstrap, OnApplicationShutdown {
+    private readonly websocket;
+    private readonly config;
+    private simulator;
+    private publisher;
+    private tickInterval;
+    constructor(websocket: NestWebSocketAdapter, config: ReadonlyConfig);
+    onApplicationBootstrap(): void;
+    onApplicationShutdown(): void;
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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); }
+};
+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");
+let MetricsBootstrapService = class MetricsBootstrapService {
+    websocket;
+    config;
+    simulator = null;
+    publisher = null;
+    tickInterval = null;
+    constructor(websocket, config) {
+        this.websocket = websocket;
+        this.config = config;
+    }
+    onApplicationBootstrap() {
+        const simulationConfig = this.config.simulation === false
+            ? null
+            : this.config.simulation;
+        if (simulationConfig) {
+            this.simulator = new simulation_1.TrafficSimulator();
+            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);
+        console.log('[Optima] Nest metrics bootstrap initialized.');
+    }
+    onApplicationShutdown() {
+        this.simulator?.stop();
+        this.simulator = null;
+        this.publisher?.stop();
+        this.publisher = null;
+        if (this.tickInterval) {
+            clearInterval(this.tickInterval);
+            this.tickInterval = null;
+        }
+        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])
+], MetricsBootstrapService);

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

@@ -0,0 +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';
+export declare class MetricsInterceptor implements NestInterceptor {
+    private readonly adapter;
+    private readonly telemetryService;
+    constructor(adapter: NestAdapter, telemetryService: TelemetryService);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    private record;
+}

package/dist/nest/metrics.interceptor.js

@@ -0,0 +1,57 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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) {
+        this.adapter = adapter;
+        this.telemetryService = telemetryService;
+    }
+    intercept(context, next) {
+        if (context.getType() !== 'http') {
+            return next.handle();
+        }
+        const startHrTime = process.hrtime.bigint();
+        return next.handle().pipe((0, operators_1.tap)({
+            next: () => this.record(context, startHrTime),
+            error: () => this.record(context, startHrTime),
+        }));
+    }
+    record(context, startHrTime) {
+        const requestData = this.adapter.getRequest(context);
+        const responseData = this.adapter.getResponse(context);
+        const telemetryRequest = this.telemetryService.record({
+            endpoint: requestData.endpoint,
+            method: requestData.method,
+            statusCode: responseData.statusCode,
+            clientIp: requestData.clientIp
+        }, startHrTime);
+        if (telemetryRequest !== null) {
+            logger_1.default.log(context.switchToHttp().getRequest(), context.switchToHttp().getResponse(), telemetryRequest.responseTime);
+        }
+    }
+};
+exports.MetricsInterceptor = MetricsInterceptor;
+exports.MetricsInterceptor = MetricsInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [metrics_adapter_1.NestAdapter,
+        telemetry_service_1.default])
+], MetricsInterceptor);

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

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

package/dist/nest/metrics.module.js

@@ -0,0 +1,74 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var MetricsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsModule = void 0;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const metrics_interceptor_1 = require("./metrics.interceptor");
+const metrics_adapter_1 = require("./metrics.adapter");
+const metrics_websocket_adapter_1 = require("./metrics-websocket.adapter");
+const metrics_bootstrap_service_1 = require("./metrics.bootstrap.service");
+const telemetry_service_1 = __importDefault(require("../core/telemetry/telemetry.service"));
+const config_1 = require("../config");
+let MetricsModule = MetricsModule_1 = class MetricsModule {
+    static forRoot(options) {
+        config_1.ConfigManager.getInstance().initialize(options);
+        return {
+            module: MetricsModule_1,
+            providers: [
+                {
+                    provide: 'METRICS_CONFIG',
+                    useValue: config_1.ConfigManager.getInstance().get(),
+                }
+            ],
+            exports: ['METRICS_CONFIG'],
+        };
+    }
+    configure(consumer) {
+        const config = config_1.ConfigManager.getInstance().get();
+        if (config.dashboardPath === false) {
+            return;
+        }
+        const dashboardRoute = config.dashboardPath;
+        const staticAssetsPath = path_1.default.resolve(__dirname, '../../../dashboard/out');
+        consumer
+            .apply(express_1.default.static(staticAssetsPath), (req, res, next) => {
+            // SPA Fallback
+            if (!req.path.includes('.')) {
+                return res.sendFile(path_1.default.join(staticAssetsPath, 'index.html'));
+            }
+            next();
+        })
+            .forRoutes(dashboardRoute);
+    }
+};
+exports.MetricsModule = MetricsModule;
+exports.MetricsModule = MetricsModule = MetricsModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [
+            telemetry_service_1.default,
+            metrics_adapter_1.NestAdapter,
+            metrics_websocket_adapter_1.NestWebSocketAdapter,
+            metrics_bootstrap_service_1.MetricsBootstrapService,
+            {
+                provide: core_1.APP_INTERCEPTOR,
+                useClass: metrics_interceptor_1.MetricsInterceptor
+            },
+        ],
+        exports: [
+            telemetry_service_1.default,
+        ],
+    })
+], MetricsModule);

package/dist/simulation/config.d.ts

@@ -0,0 +1,20 @@
+export type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export interface EndpointLatency {
+    normal: number;
+    p95: number;
+    p99: number;
+}
+export interface EndpointErrors {
+    client: number;
+    server: number;
+}
+export interface EndpointConfig {
+    url: string;
+    methods: Method[];
+    weight: number;
+    latency: EndpointLatency;
+    errors: EndpointErrors;
+    service: "USER" | "ORDER" | "PRODUCT" | "AUTH" | "SYSTEM";
+}
+export declare const endpoints: EndpointConfig[];
+export declare const TOTAL_WEIGHT: number;

package/dist/simulation/config.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOTAL_WEIGHT = exports.endpoints = void 0;
+exports.endpoints = [
+    {
+        url: "/api/users",
+        methods: ["GET", "POST", "PATCH"],
+        weight: 35,
+        latency: { normal: 25, p95: 120, p99: 500 },
+        errors: { client: 0.01, server: 0.005 },
+        service: "USER",
+    },
+    {
+        url: "/api/orders",
+        methods: ["GET", "POST", "PATCH"],
+        weight: 25,
+        latency: { normal: 80, p95: 350, p99: 700 },
+        errors: { client: 0.01, server: 0.01 },
+        service: "ORDER",
+    },
+    {
+        url: "/api/products",
+        methods: ["GET"],
+        weight: 20,
+        latency: { normal: 15, p95: 80, p99: 250 },
+        errors: { client: 0.005, server: 0.002 },
+        service: "PRODUCT",
+    },
+    {
+        url: "/api/auth/login",
+        methods: ["POST"],
+        weight: 10,
+        latency: { normal: 120, p95: 400, p99: 900 },
+        errors: { client: 0.02, server: 0.01 },
+        service: "AUTH",
+    },
+    {
+        url: "/health",
+        methods: ["GET"],
+        weight: 7,
+        latency: { normal: 3, p95: 10, p99: 20 },
+        errors: { client: 0, server: 0 },
+        service: "SYSTEM",
+    },
+    {
+        url: "/metrics",
+        methods: ["GET"],
+        weight: 3,
+        latency: { normal: 5, p95: 20, p99: 50 },
+        errors: { client: 0, server: 0 },
+        service: "SYSTEM",
+    },
+];
+exports.TOTAL_WEIGHT = exports.endpoints.reduce((sum, e) => sum + e.weight, 0);

package/dist/simulation/journey.d.ts

@@ -0,0 +1,7 @@
+interface UserJourney {
+    name: string;
+    probability: number;
+    endpoints: string[];
+}
+export declare function pickJourney(): UserJourney;
+export {};

package/dist/simulation/journey.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickJourney = pickJourney;
+const journeys = [
+    {
+        name: "browse",
+        probability: 0.55,
+        endpoints: [
+            "/api/products",
+            "/api/products",
+            "/api/users",
+        ]
+    },
+    {
+        name: "shopping",
+        probability: 0.30,
+        endpoints: [
+            "/api/auth/login",
+            "/api/products",
+            "/api/orders",
+        ]
+    },
+    {
+        name: "admin",
+        probability: 0.10,
+        endpoints: [
+            "/api/users",
+            "/api/orders",
+        ]
+    },
+    {
+        name: "health",
+        probability: 0.05,
+        endpoints: [
+            "/health",
+            "/metrics",
+        ]
+    }
+];
+function pickJourney() {
+    let value = Math.random();
+    for (const journey of journeys) {
+        value -= journey.probability;
+        if (value <= 0) {
+            return journey;
+        }
+    }
+    return journeys[0];
+}

package/dist/simulation/scenarios.d.ts

@@ -0,0 +1,17 @@
+export declare const scenario: {
+    trafficMultiplier: number;
+    databaseSlowUntil: number;
+    authDownUntil: number;
+    latencySpikeUntil: number;
+    memoryLeak: boolean;
+};
+export declare function updateScenarios(): void;
+type ScenarioName = "TRAFFIC_SPIKE" | "DATABASE_SLOWDOWN" | "AUTH_OUTAGE" | "MEMORY_LEAK" | "RESET";
+export declare class ScenarioController {
+    private readonly state;
+    constructor(state: typeof scenario);
+    start(name: ScenarioName): void;
+    stop(name: ScenarioName): void;
+    reset(): void;
+}
+export {};

package/dist/simulation/scenarios.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScenarioController = exports.scenario = void 0;
+exports.updateScenarios = updateScenarios;
+const utility_1 = require("./utility");
+exports.scenario = {
+    trafficMultiplier: 1,
+    databaseSlowUntil: 0,
+    authDownUntil: 0,
+    latencySpikeUntil: 0,
+    memoryLeak: false,
+};
+function updateScenarios() {
+    const now = Date.now();
+    // traffic spike
+    if (now > exports.scenario.latencySpikeUntil && (0, utility_1.probability)(0.002)) {
+        exports.scenario.trafficMultiplier = 3;
+        exports.scenario.latencySpikeUntil = now + 10000;
+        console.log("📈 Traffic spike started");
+    }
+    if (now > exports.scenario.latencySpikeUntil) {
+        exports.scenario.trafficMultiplier = 1;
+    }
+    // database slowdown
+    if (now > exports.scenario.databaseSlowUntil && (0, utility_1.probability)(0.001)) {
+        exports.scenario.databaseSlowUntil = now + 12000;
+        console.log("🐢 Database slowdown");
+    }
+    // auth outage
+    if (now > exports.scenario.authDownUntil && (0, utility_1.probability)(0.0005)) {
+        exports.scenario.authDownUntil = now + 8000;
+        console.log("🔐 Auth outage");
+    }
+    // memory leak
+    if (!exports.scenario.memoryLeak && (0, utility_1.probability)(0.0002)) {
+        exports.scenario.memoryLeak = true;
+        console.log("🧠 Memory leak started");
+    }
+}
+class ScenarioController {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    start(name) {
+        const now = Date.now();
+        switch (name) {
+            case "TRAFFIC_SPIKE":
+                this.state.trafficMultiplier = 4;
+                this.state.latencySpikeUntil = now + 30000;
+                console.log("Manual traffic spike!");
+                break;
+            case "DATABASE_SLOWDOWN":
+                this.state.databaseSlowUntil = now + 60000;
+                console.log("Manual database slowdown!");
+                break;
+            case "AUTH_OUTAGE":
+                this.state.authDownUntil = now + 30000;
+                console.log("Manual auth outage!");
+                break;
+            case "MEMORY_LEAK":
+                this.state.memoryLeak = true;
+                console.log("Manual memory leak!");
+                break;
+            case "RESET":
+                this.reset();
+                break;
+        }
+    }
+    stop(name) {
+        switch (name) {
+            case "TRAFFIC_SPIKE":
+                this.state.trafficMultiplier = 1;
+                this.state.latencySpikeUntil = 0;
+                break;
+            case "DATABASE_SLOWDOWN":
+                this.state.databaseSlowUntil = 0;
+                break;
+            case "AUTH_OUTAGE":
+                this.state.authDownUntil = 0;
+                break;
+            case "MEMORY_LEAK":
+                this.state.memoryLeak = false;
+                break;
+        }
+    }
+    reset() {
+        this.state.trafficMultiplier = 1;
+        this.state.databaseSlowUntil = 0;
+        this.state.authDownUntil = 0;
+        this.state.latencySpikeUntil = 0;
+        this.state.memoryLeak = false;
+        console.log("Scenarios reset!");
+    }
+}
+exports.ScenarioController = ScenarioController;

package/dist/simulation/simulation.d.ts

@@ -0,0 +1,24 @@
+import type { TelemetryRequest } from "../core/domain";
+export declare class TrafficSimulator {
+    private readonly repository;
+    private timer?;
+    private running;
+    constructor(repository?: {
+        readonly endpoint: import("../core/storage").EndpointStore;
+        readonly alerts: import("../core/storage").AlertStore;
+        readonly metrics: import("../core/storage").MetricsStore;
+        readonly health: import("../core/storage").HealthStore;
+        readonly bucket: import("../core/storage").BucketStore;
+        readonly dashboard: import("../core/storage").DashboardStore;
+        readonly analytics: import("../core/storage").AnalyticsStore;
+        readonly system: import("../core/storage").SystemStore;
+        record(request: TelemetryRequest): void;
+        tick(): void;
+    });
+    start(options?: {
+        intervalMs?: number;
+        requestsPerTick?: number;
+    }): void;
+    stop(): void;
+    isRunning(): boolean;
+}