apm-optima 0.0.1

package/dist/core/telemetry/collector.service.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectorService = void 0;
+const storage_1 = require("../storage");
+const collectors_1 = require("./collectors");
+const config_1 = require("../../config");
+class CollectorService {
+    cpuCollector;
+    memoryCollector;
+    eventLoopCollector;
+    gcCollector;
+    handlesCollector;
+    runtimeCollector;
+    constructor(cpuCollector, memoryCollector, eventLoopCollector, gcCollector, handlesCollector, runtimeCollector) {
+        this.cpuCollector = cpuCollector;
+        this.memoryCollector = memoryCollector;
+        this.eventLoopCollector = eventLoopCollector;
+        this.gcCollector = gcCollector;
+        this.handlesCollector = handlesCollector;
+        this.runtimeCollector = runtimeCollector;
+    }
+    getSystemStaticInfo() {
+        return storage_1.storage.system.get();
+    }
+    getDashboardData() {
+        return storage_1.storage.dashboard.get();
+    }
+    getAnalyticsData() {
+        return storage_1.storage.analytics.get();
+    }
+    getHealthData() {
+        return storage_1.storage.health.get();
+    }
+    tick() {
+        const cpuData = this.cpuCollector.collect();
+        storage_1.storage.health.updateCPU({
+            usageRate: cpuData.totalPercent,
+            numberOfCores: cpuData.numberOfCores,
+            perCoreUsage: cpuData.perCoreUsage,
+            userUsage: cpuData.userPercent,
+            systemUsage: cpuData.systemPercent,
+            idleUsage: cpuData.idlePercent
+        });
+        const memoryData = this.memoryCollector.collect();
+        storage_1.storage.health.updateMemory({
+            heapUsage: memoryData.heapUsage,
+            heapSize: memoryData.heapSize,
+            rssMemory: memoryData.rssMemory,
+            rssMemoryTotal: memoryData.rssMemoryTotal,
+            externalMemory: memoryData.externalMemory,
+        });
+        const eventLoopData = this.eventLoopCollector.collect();
+        storage_1.storage.health.updateEventLoop({
+            lag: eventLoopData.meanMs,
+            threshold: this.eventLoopCollector.thresholdMs,
+        });
+        const handlesData = this.handlesCollector.collect();
+        storage_1.storage.health.updateHandles({
+            activeHandles: handlesData.activeHandles,
+            activeHandlesTimers: handlesData.activeHandlesTimers,
+            activeHandlesSockets: handlesData.activeHandlesSockets,
+            activeLibuvHandles: handlesData.activeLibuvHandles,
+            timers: handlesData.timers,
+            fileDescriptors: handlesData.fileDescriptors
+        });
+        const gcData = this.gcCollector.collect();
+        storage_1.storage.health.updateGC({
+            gcCount: gcData.gcCount,
+            gcTime: gcData.gcTime,
+            gcPauseAverage: gcData.gcPauseAverage,
+            minorGC: gcData.minorGC,
+            majorGC: gcData.majorGC,
+            incrementalGC: gcData.incrementalGC,
+            heapSpaces: gcData.heapSpaces,
+            gcTotals: gcData.gcTotals
+        });
+        const runtimeData = this.runtimeCollector.collect();
+        storage_1.storage.health.updateRuntime({
+            pid: runtimeData.pid,
+            platform: runtimeData.platform,
+            nodeVersion: runtimeData.nodeVersion,
+            v8Version: runtimeData.v8Version,
+            libuvVersion: runtimeData.libuvVersion,
+            openSSLVersion: runtimeData.openSSLVersion,
+            threadPoolSize: runtimeData.threadPoolSize,
+            activeThreads: runtimeData.activeThreads,
+            startup: runtimeData.startup
+        });
+        storage_1.storage.tick();
+    }
+}
+exports.collectorService = new CollectorService(new collectors_1.CPUCollector(), new collectors_1.MemoryCollector(), new collectors_1.EventLoopCollector((0, config_1.getConfig)().publisher.eventLoopResolutionMs, (0, config_1.getConfig)().publisher.eventLoopLagThresholdMs), new collectors_1.GCCollector(), new collectors_1.HandlesCollector(), new collectors_1.RuntimeCollector());

package/dist/core/telemetry/collectors/cpu.collector.d.ts

@@ -0,0 +1,22 @@
+import { ICollector } from './interface';
+type CPUUsageResult = {
+    numberOfCores: number;
+    userPercent: number;
+    systemPercent: number;
+    totalPercent: number;
+    idlePercent: number;
+    perCoreUsage: number[];
+};
+declare class CPUCollector implements ICollector<CPUUsageResult> {
+    private lastCpuSample;
+    private lastTimeSample;
+    collect(): {
+        numberOfCores: number;
+        userPercent: number;
+        systemPercent: number;
+        totalPercent: number;
+        idlePercent: number;
+        perCoreUsage: number[];
+    };
+}
+export { CPUCollector, CPUUsageResult };

package/dist/core/telemetry/collectors/cpu.collector.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CPUCollector = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const node_process_1 = __importDefault(require("node:process"));
+const utility_1 = require("../../utility");
+class CPUCollector {
+    lastCpuSample = node_process_1.default.cpuUsage();
+    lastTimeSample = node_process_1.default.hrtime.bigint();
+    collect() {
+        const currentCpuUsage = node_process_1.default.cpuUsage(this.lastCpuSample);
+        const currentSampleTime = node_process_1.default.hrtime.bigint();
+        const elapsedTimeInNs = currentSampleTime - this.lastTimeSample;
+        const elapsedTimeInMicros = Number(elapsedTimeInNs) / 1000;
+        this.lastCpuSample = node_process_1.default.cpuUsage();
+        this.lastTimeSample = currentSampleTime;
+        const userPercent = (0, utility_1.toPercentage)(currentCpuUsage.user, elapsedTimeInMicros);
+        const systemPercent = (0, utility_1.toPercentage)(currentCpuUsage.system, elapsedTimeInMicros);
+        const idlePercent = Math.max(0, 100 - (userPercent + systemPercent));
+        const cpus = node_os_1.default.cpus();
+        const perCoreUsage = cpus.map((core, index) => {
+            const coreTotalTime = Object.values(core.times).reduce((a, b) => a + b, 0);
+            return coreTotalTime > 0 ? (0, utility_1.toPercentage)((coreTotalTime - core.times.idle), coreTotalTime) : 0;
+        });
+        return {
+            numberOfCores: cpus.length,
+            userPercent: userPercent,
+            systemPercent: systemPercent,
+            totalPercent: (0, utility_1.clamp)(userPercent + systemPercent, 0, 100),
+            idlePercent: idlePercent,
+            perCoreUsage: perCoreUsage,
+        };
+    }
+    ;
+}
+exports.CPUCollector = CPUCollector;

package/dist/core/telemetry/collectors/event-loop.collector.d.ts

@@ -0,0 +1,22 @@
+import { ICollector } from './interface';
+type EventLoopUsageResult = {
+    minMs: number;
+    maxMs: number;
+    meanMs: number;
+    p50Ms: number;
+    p99Ms: number;
+};
+declare class EventLoopCollector implements ICollector<EventLoopUsageResult> {
+    readonly resolutionMs: number;
+    readonly thresholdMs: number;
+    private histogram;
+    constructor(resolutionMs?: number, thresholdMs?: number);
+    collect(): {
+        minMs: number;
+        maxMs: number;
+        meanMs: number;
+        p50Ms: number;
+        p99Ms: number;
+    };
+}
+export { EventLoopCollector, EventLoopUsageResult };

package/dist/core/telemetry/collectors/event-loop.collector.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventLoopCollector = void 0;
+const perf_hooks_1 = require("perf_hooks");
+const utility_1 = require("../../utility");
+class EventLoopCollector {
+    resolutionMs;
+    thresholdMs;
+    histogram;
+    constructor(resolutionMs = 20, thresholdMs = 100) {
+        this.resolutionMs = resolutionMs;
+        this.thresholdMs = thresholdMs;
+        this.histogram = (0, perf_hooks_1.monitorEventLoopDelay)({ resolution: this.resolutionMs });
+        this.histogram.enable();
+    }
+    collect() {
+        const toMs = (ns) => (0, utility_1.convertNanoseconds)(ns, 'ms');
+        return {
+            minMs: toMs(this.histogram.min),
+            maxMs: toMs(this.histogram.max),
+            meanMs: toMs(this.histogram.mean),
+            p50Ms: toMs(this.histogram.percentile(50)),
+            p99Ms: toMs(this.histogram.percentile(99))
+        };
+    }
+}
+exports.EventLoopCollector = EventLoopCollector;

package/dist/core/telemetry/collectors/gc.collector.d.ts

@@ -0,0 +1,61 @@
+import { ICollector } from './interface';
+type GCUsageResult = {
+    gcCount: number;
+    gcTime: number;
+    gcPauseAverage: number;
+    minorGC: {
+        runCount: number;
+        averageTime: number;
+    };
+    majorGC: {
+        runCount: number;
+        averageTime: number;
+    };
+    incrementalGC: {
+        runCount: number;
+        averageTime: number;
+    };
+    heapSpaces: {
+        label: string;
+        used: number;
+    }[];
+    gcTotals: {
+        totalPauseTime: number;
+        freedMemory: number;
+        promotions: number;
+        tenuredSize: number;
+    };
+};
+declare class GCCollector implements ICollector<GCUsageResult> {
+    private gcStats;
+    private gcObserver;
+    constructor();
+    collect(): {
+        gcCount: number;
+        gcTime: number;
+        gcPauseAverage: number;
+        minorGC: {
+            runCount: number;
+            averageTime: number;
+        };
+        majorGC: {
+            runCount: number;
+            averageTime: number;
+        };
+        incrementalGC: {
+            runCount: number;
+            averageTime: number;
+        };
+        heapSpaces: {
+            label: string;
+            used: number;
+        }[];
+        gcTotals: {
+            totalPauseTime: number;
+            freedMemory: number;
+            promotions: number;
+            tenuredSize: number;
+        };
+    };
+}
+export { GCCollector, GCUsageResult };

package/dist/core/telemetry/collectors/gc.collector.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GCCollector = void 0;
+const node_v8_1 = __importDefault(require("node:v8"));
+const node_perf_hooks_1 = require("node:perf_hooks");
+const utility_1 = require("../../utility");
+class GCCollector {
+    gcStats;
+    gcObserver = new node_perf_hooks_1.PerformanceObserver((list) => {
+        const entries = list.getEntries();
+        for (const entry of entries) {
+            const duration = entry.duration;
+            this.gcStats.gcCount++;
+            this.gcStats.gcTime += duration;
+            const detail = entry.detail;
+            const kind = detail ? detail.kind : 0;
+            if (kind === 1) { // Minor GC
+                this.gcStats.minorGC.runCount++;
+                this.gcStats.minorGC.totalTime += duration;
+            }
+            else if (kind === 2) { // Major GC
+                this.gcStats.majorGC.runCount++;
+                this.gcStats.majorGC.totalTime += duration;
+            }
+            else { // Incremental GC
+                this.gcStats.incrementalGC.runCount++;
+                this.gcStats.incrementalGC.totalTime += duration;
+            }
+            if (detail) {
+                if (detail.freedMemory)
+                    this.gcStats.freedMemory += detail.freedMemory;
+            }
+        }
+    });
+    constructor() {
+        this.gcStats = {
+            gcCount: 0,
+            gcTime: 0,
+            gcPauseAverage: 0,
+            minorGC: { runCount: 0, totalTime: 0 },
+            majorGC: { runCount: 0, totalTime: 0 },
+            incrementalGC: { runCount: 0, totalTime: 0 },
+            freedMemory: 0
+        };
+        this.gcObserver.observe({ entryTypes: ['gc'], buffered: true });
+    }
+    collect() {
+        const spaceStats = node_v8_1.default.getHeapSpaceStatistics();
+        const heapSpaces = spaceStats.map(space => ({
+            label: space.space_name,
+            used: space.space_used_size / 1024 / 1024
+        }));
+        const tenuredSpace = spaceStats.find(s => s.space_name === 'old_space');
+        const parseFloatFixed = (value) => parseFloat(value.toFixed(2));
+        const parseFloatSafe = (value, condition) => condition ? parseFloatFixed(value) : 0;
+        return {
+            gcCount: this.gcStats.gcCount,
+            gcTime: parseFloatFixed(this.gcStats.gcTime),
+            gcPauseAverage: parseFloatSafe(this.gcStats.gcTime / this.gcStats.gcCount, this.gcStats.gcCount > 0),
+            minorGC: {
+                runCount: this.gcStats.minorGC.runCount,
+                averageTime: parseFloatSafe(this.gcStats.minorGC.totalTime / this.gcStats.minorGC.runCount, this.gcStats.minorGC.runCount > 0)
+            },
+            majorGC: {
+                runCount: this.gcStats.majorGC.runCount,
+                averageTime: parseFloatSafe(this.gcStats.majorGC.totalTime / this.gcStats.majorGC.runCount, this.gcStats.majorGC.runCount > 0)
+            },
+            incrementalGC: {
+                runCount: this.gcStats.incrementalGC.runCount,
+                averageTime: parseFloatSafe(this.gcStats.incrementalGC.totalTime / this.gcStats.incrementalGC.runCount, this.gcStats.incrementalGC.runCount > 0)
+            },
+            heapSpaces,
+            gcTotals: {
+                totalPauseTime: parseFloatFixed(this.gcStats.gcTime),
+                freedMemory: (0, utility_1.convertBytes)(this.gcStats.freedMemory, 'MB'),
+                promotions: this.gcStats.majorGC.runCount,
+                tenuredSize: tenuredSpace ? tenuredSpace.space_used_size / 1024 / 1024 : 0
+            }
+        };
+    }
+}
+exports.GCCollector = GCCollector;
+;

package/dist/core/telemetry/collectors/handles.collector.d.ts

@@ -0,0 +1,20 @@
+import { ICollector } from './interface';
+type HandleUsageResult = {
+    activeHandles: number;
+    activeHandlesTimers: number;
+    activeHandlesSockets: number;
+    activeLibuvHandles: number;
+    timers: number;
+    fileDescriptors: number;
+};
+declare class HandlesCollector implements ICollector<HandleUsageResult> {
+    collect(): {
+        activeHandles: any;
+        activeHandlesTimers: number;
+        activeHandlesSockets: number;
+        activeLibuvHandles: any;
+        timers: number;
+        fileDescriptors: any;
+    };
+}
+export { HandlesCollector, HandleUsageResult };

package/dist/core/telemetry/collectors/handles.collector.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandlesCollector = void 0;
+class HandlesCollector {
+    collect() {
+        const handles = process._getActiveHandles ? process._getActiveHandles() : [];
+        let timers = 0;
+        let sockets = 0;
+        for (const h of handles) {
+            if (h.constructor && h.constructor.name === 'Timeout')
+                timers++;
+            if (h.constructor && (h.constructor.name === 'Socket' || h.constructor.name === 'TCPSocket'))
+                sockets++;
+        }
+        return {
+            activeHandles: handles.length,
+            activeHandlesTimers: timers,
+            activeHandlesSockets: sockets,
+            activeLibuvHandles: handles.length,
+            timers,
+            fileDescriptors: handles.length
+        };
+    }
+}
+exports.HandlesCollector = HandlesCollector;
+;

package/dist/core/telemetry/collectors/index.d.ts

@@ -0,0 +1,6 @@
+export * from './cpu.collector';
+export * from './memory.collector';
+export * from './event-loop.collector';
+export * from './gc.collector';
+export * from './handles.collector';
+export * from './runtime.collector';

package/dist/core/telemetry/collectors/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cpu.collector"), exports);
+__exportStar(require("./memory.collector"), exports);
+__exportStar(require("./event-loop.collector"), exports);
+__exportStar(require("./gc.collector"), exports);
+__exportStar(require("./handles.collector"), exports);
+__exportStar(require("./runtime.collector"), exports);

package/dist/core/telemetry/collectors/interface.d.ts

@@ -0,0 +1,3 @@
+export interface ICollector<T> {
+    collect(): T;
+}

package/dist/core/telemetry/collectors/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/telemetry/collectors/memory.collector.d.ts

@@ -0,0 +1,18 @@
+import { ICollector } from './interface';
+type MemoryUsageResult = {
+    heapUsage: number;
+    heapSize: number;
+    rssMemory: number;
+    rssMemoryTotal: number;
+    externalMemory: number;
+};
+declare class MemoryCollector implements ICollector<MemoryUsageResult> {
+    collect(): {
+        heapUsage: number;
+        heapSize: number;
+        rssMemory: number;
+        rssMemoryTotal: number;
+        externalMemory: number;
+    };
+}
+export { MemoryCollector, MemoryUsageResult };

package/dist/core/telemetry/collectors/memory.collector.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCollector = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const node_process_1 = __importDefault(require("node:process"));
+const utility_1 = require("../../utility");
+class MemoryCollector {
+    collect() {
+        const toMB = (bytes) => (0, utility_1.convertBytes)(bytes, 'MB');
+        const memoryUsage = node_process_1.default.memoryUsage();
+        const totalMemory = node_os_1.default.totalmem();
+        return {
+            heapUsage: toMB(memoryUsage.heapUsed),
+            heapSize: toMB(memoryUsage.heapTotal),
+            rssMemory: toMB(memoryUsage.rss),
+            rssMemoryTotal: toMB(totalMemory),
+            externalMemory: toMB(memoryUsage.external),
+        };
+    }
+}
+exports.MemoryCollector = MemoryCollector;

package/dist/core/telemetry/collectors/runtime.collector.d.ts

@@ -0,0 +1,32 @@
+import { ICollector } from './interface';
+type RuntimeUsageResult = {
+    pid: number;
+    platform: NodeJS.Platform;
+    nodeVersion: string;
+    v8Version: string;
+    libuvVersion: string;
+    openSSLVersion: string;
+    threadPoolSize: number;
+    activeThreads: number;
+    startup: {
+        bootstrapTime: number;
+        requiredModules: number;
+    };
+};
+declare class RuntimeCollector implements ICollector<RuntimeUsageResult> {
+    collect(): {
+        pid: number;
+        platform: NodeJS.Platform;
+        nodeVersion: string;
+        v8Version: string;
+        libuvVersion: string;
+        openSSLVersion: string;
+        threadPoolSize: number;
+        activeThreads: any;
+        startup: {
+            bootstrapTime: number;
+            requiredModules: number;
+        };
+    };
+}
+export { RuntimeCollector, RuntimeUsageResult };

package/dist/core/telemetry/collectors/runtime.collector.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeCollector = void 0;
+const node_process_1 = __importDefault(require("node:process"));
+class RuntimeCollector {
+    collect() {
+        const threadPoolSize = node_process_1.default.env.UV_THREADPOOL_SIZE ? parseInt(node_process_1.default.env.UV_THREADPOOL_SIZE) : 4;
+        const activeThreads = node_process_1.default._getActiveRequests().length ?? 0;
+        return {
+            pid: node_process_1.default.pid,
+            platform: node_process_1.default.platform,
+            nodeVersion: node_process_1.default.version,
+            v8Version: node_process_1.default.versions.v8,
+            libuvVersion: node_process_1.default.versions.uv,
+            openSSLVersion: node_process_1.default.versions.openssl,
+            threadPoolSize: threadPoolSize,
+            activeThreads: activeThreads,
+            startup: {
+                bootstrapTime: performance.now(),
+                requiredModules: Object.keys(require.cache).length,
+            }
+        };
+    }
+}
+exports.RuntimeCollector = RuntimeCollector;
+;

package/dist/core/telemetry/correlation.service.d.ts

@@ -0,0 +1,9 @@
+declare class CorrelationService {
+    private readonly sampleSize;
+    constructor();
+    tick(): void;
+    private testCorrelation;
+    private handleReport;
+}
+export declare const correlationService: CorrelationService;
+export {};

package/dist/core/telemetry/correlation.service.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.correlationService = void 0;
+const local_repository_1 = require("../storage/local.repository");
+const statistics_1 = require("../utility/statistics");
+class CorrelationService {
+    sampleSize;
+    constructor() {
+        this.sampleSize =
+            (0, statistics_1.calculateSampleSizeProportion)(0.05, 0.95); //! This maybe from config?
+    }
+    tick() {
+        const totalHistory = local_repository_1.storage.bucket.getHistory();
+        const size = totalHistory.length;
+        if (size < this.sampleSize) {
+            return;
+        }
+        const rps = totalHistory.map(e => e.rps.count);
+        const errorRate = totalHistory.map(e => e.error.rate);
+        const heapUsage = totalHistory.map(e => e.health.memory.heapUsage);
+        const p95Latency = totalHistory.map(e => e.latency.p95);
+        const eventLoopLag = totalHistory.map(e => e.health.eventLoop.lag);
+        const averageLatency = totalHistory.map(e => e.latency.average);
+        // 1. eventLoopLag <-> p95 latency
+        this.handleReport(this.testCorrelation(eventLoopLag, p95Latency));
+        // 2. eventLoopLag <-> average latency
+        this.handleReport(this.testCorrelation(eventLoopLag, averageLatency));
+        // 3. heapUsage <-> eventLoopLag
+        this.handleReport(this.testCorrelation(heapUsage, eventLoopLag));
+        // 4. heapUsage <-> p95 latency
+        this.handleReport(this.testCorrelation(heapUsage, p95Latency));
+        // 5. rps <-> errorRate
+        this.handleReport(this.testCorrelation(rps, errorRate));
+        // 6. rps <-> latency
+        this.handleReport(this.testCorrelation(rps, averageLatency));
+    }
+    testCorrelation(x, y) {
+        const pearsonR = (0, statistics_1.pearsonCorrelation)(x, y);
+        const spearmanR = (0, statistics_1.spearmanCorrelation)(x, y);
+        const { determination, alienation } = (0, statistics_1.determinationAndAlienation)(pearsonR);
+        if (Math.abs(spearmanR) > 0.7 && Math.abs(pearsonR) <= 0.6) {
+            return {
+                status: 'NON_LINEAR_BURST',
+                recommendation: 'Kritično! Detektovan nelinearan (eksponencijalni) skok. Sistem ulazi u zonu zasićenja resursa.'
+            };
+        }
+        else if (spearmanR > 0.7 && determination > 0.5) {
+            if (alienation > 0.4) {
+                return {
+                    status: 'EXTERNAL_INFLUENCE',
+                    recommendation: `Uočena je povezanost (r=${spearmanR.toFixed(2)}), ali eksterni faktori utiču sa ${(alienation * 100).toFixed(1)}%. Ne donositi ishitren zaključak o uzročnosti.`
+                };
+            }
+            else {
+                return {
+                    status: 'SYSTEMIC_LINEAR_DEGRADATION',
+                    recommendation: `Linearna degradacija. Varijable zajednički rastu.`
+                };
+            }
+        }
+        return {
+            status: 'STABLE',
+            recommendation: 'Sistem je stabilan. Nema detektovanih uzročnih veza između posmatranih varijabli.'
+        };
+    }
+    handleReport(report) {
+        if (report.status === 'STABLE')
+            return;
+        local_repository_1.storage.alerts.warning(report.recommendation);
+    }
+}
+exports.correlationService = new CorrelationService();

package/dist/core/telemetry/logger.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response } from 'express';
+declare class Logger {
+    private static readonly RESET;
+    private static readonly BOLD;
+    private static readonly DIM;
+    private static readonly COLORS;
+    static log(req: Request, res: Response, duration: number): void;
+    static debug(message: string): void;
+    static duration(message: string, duration: number): void;
+}
+export default Logger;