@dollhousemcp/mcp-server 2.0.0-rc.6 → 2.0.0

package/dist/metrics/MetricsManager.js

@@ -0,0 +1,232 @@
+/**
+ * Central coordinator for the Metrics Collection System.
+ *
+ * Registers collectors and sinks, runs periodic collection cycles,
+ * assembles immutable MetricSnapshot objects, and dispatches them
+ * to all registered sinks.
+ */
+export class MetricsManager {
+    collectors = [];
+    sinks = [];
+    config;
+    logger;
+    timer = null;
+    snapshotCounter = 0;
+    collectionsCompleted = 0;
+    collectorErrorsTotal = 0;
+    sinkErrorsTotal = 0;
+    lastCollectionDurationMs = 0;
+    closed = false;
+    processStartTime;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        this.processStartTime = new Date().toISOString();
+    }
+    // ---------------------------------------------------------------------------
+    // Public API
+    // ---------------------------------------------------------------------------
+    registerCollector(collector) {
+        this.assertOpen();
+        this.collectors.push({
+            collector,
+            consecutiveFailures: 0,
+            disabled: false,
+        });
+    }
+    registerSink(sink) {
+        this.assertOpen();
+        this.sinks.push(sink);
+    }
+    start() {
+        this.assertOpen();
+        if (this.timer !== null) {
+            this.logger.warn('MetricsManager.start() called but timer already running');
+            return;
+        }
+        if (this.config.collectionIntervalMs > 0) {
+            this.timer = setInterval(() => {
+                void this.collectNow();
+            }, this.config.collectionIntervalMs);
+            // Allow the process to exit even if the timer is still running
+            if (this.timer && typeof this.timer === 'object' && 'unref' in this.timer) {
+                this.timer.unref();
+            }
+        }
+    }
+    async collectNow() {
+        this.assertOpen();
+        const startTime = performance.now();
+        const { entries, errors } = await this.collectFromCollectors();
+        entries.push(...this.buildSelfMonitoringMetrics());
+        const durationMs = performance.now() - startTime;
+        const snapshot = {
+            id: `SNAP-${Date.now()}-${this.snapshotCounter++}`,
+            timestamp: new Date().toISOString(),
+            metrics: entries,
+            errors,
+            durationMs,
+        };
+        this.warnIfOversized(snapshot);
+        this.warnIfSlow(snapshot, durationMs);
+        this.deepFreezeSnapshot(snapshot);
+        this.dispatchToSinks(snapshot);
+        this.collectionsCompleted++;
+        this.lastCollectionDurationMs = durationMs;
+        return snapshot;
+    }
+    async collectFromCollectors() {
+        const entries = [];
+        const errors = [];
+        for (const record of this.collectors) {
+            if (record.disabled)
+                continue;
+            try {
+                const result = await Promise.resolve(record.collector.collect());
+                record.consecutiveFailures = 0;
+                entries.push(...result);
+            }
+            catch (err) {
+                record.consecutiveFailures++;
+                this.collectorErrorsTotal++;
+                const message = err instanceof Error ? err.message : String(err);
+                errors.push(`${record.collector.name}: ${message}`);
+                this.logger.warn(`Collector "${record.collector.name}" failed (${record.consecutiveFailures}/${this.config.collectorFailureThreshold})`, { error: message });
+                if (record.consecutiveFailures >= this.config.collectorFailureThreshold) {
+                    record.disabled = true;
+                    this.logger.error(`Collector "${record.collector.name}" disabled after ${record.consecutiveFailures} consecutive failures`);
+                }
+            }
+        }
+        return { entries, errors };
+    }
+    warnIfOversized(snapshot) {
+        const serializedSize = JSON.stringify(snapshot).length;
+        if (serializedSize > this.config.maxSnapshotSize) {
+            this.logger.warn(`Snapshot size ${serializedSize} bytes exceeds limit ${this.config.maxSnapshotSize}`, { snapshotId: snapshot.id, size: serializedSize });
+        }
+    }
+    warnIfSlow(snapshot, durationMs) {
+        if (durationMs > this.config.collectionDurationWarnMs && this.collectionsCompleted >= 3) {
+            this.logger.warn(`Collection took ${durationMs.toFixed(1)}ms (threshold: ${this.config.collectionDurationWarnMs}ms)`, { snapshotId: snapshot.id });
+        }
+    }
+    deepFreezeSnapshot(snapshot) {
+        Object.freeze(snapshot.metrics);
+        for (const entry of snapshot.metrics) {
+            if (entry.value !== null && typeof entry.value === 'object') {
+                Object.freeze(entry.value);
+            }
+            Object.freeze(entry);
+        }
+        Object.freeze(snapshot.errors);
+        Object.freeze(snapshot);
+    }
+    dispatchToSinks(snapshot) {
+        for (const sink of this.sinks) {
+            try {
+                sink.onSnapshot(snapshot);
+            }
+            catch (err) {
+                this.sinkErrorsTotal++;
+                const message = err instanceof Error ? err.message : String(err);
+                this.logger.warn(`Sink "${sink.name}" failed: ${message}`);
+            }
+        }
+    }
+    async close() {
+        if (this.closed)
+            return;
+        // Stop timer
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        try {
+            // Final collection — best-effort, should not prevent cleanup
+            await this.collectNow();
+        }
+        finally {
+            this.closed = true;
+            // Flush and close all sinks
+            await Promise.allSettled(this.sinks.map(s => s.flush()));
+            await Promise.allSettled(this.sinks.map(s => s.close()));
+        }
+    }
+    getManagerStats() {
+        return {
+            collectionsCompleted: this.collectionsCompleted,
+            collectorErrorsTotal: this.collectorErrorsTotal,
+            sinkErrorsTotal: this.sinkErrorsTotal,
+            lastCollectionDurationMs: this.lastCollectionDurationMs,
+            collectorsRegistered: this.collectors.length,
+            sinksRegistered: this.sinks.length,
+            disabledCollectors: this.collectors.filter(r => r.disabled).length,
+            processStartTime: this.processStartTime,
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Internals
+    // ---------------------------------------------------------------------------
+    assertOpen() {
+        if (this.closed) {
+            throw new Error('MetricsManager is closed');
+        }
+    }
+    buildSelfMonitoringMetrics() {
+        const source = 'MetricsManager';
+        const unit = 'count';
+        return [
+            {
+                type: 'gauge',
+                name: 'metrics.manager.collectors_registered',
+                source,
+                unit,
+                value: this.collectors.length,
+            },
+            {
+                type: 'gauge',
+                name: 'metrics.manager.sinks_registered',
+                source,
+                unit,
+                value: this.sinks.length,
+            },
+            {
+                type: 'counter',
+                name: 'metrics.manager.collector_errors_total',
+                source,
+                unit,
+                value: this.collectorErrorsTotal,
+            },
+            {
+                type: 'counter',
+                name: 'metrics.manager.sink_errors_total',
+                source,
+                unit,
+                value: this.sinkErrorsTotal,
+            },
+            {
+                type: 'gauge',
+                name: 'metrics.manager.last_collection_duration_ms',
+                source,
+                unit: 'milliseconds',
+                value: this.lastCollectionDurationMs,
+            },
+            {
+                type: 'counter',
+                name: 'metrics.manager.snapshots_taken_total',
+                source,
+                unit,
+                value: this.snapshotCounter,
+            },
+            {
+                type: 'gauge',
+                name: 'metrics.manager.disabled_collectors',
+                source,
+                unit,
+                value: this.collectors.filter(r => r.disabled).length,
+            },
+        ];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MetricsManager.js","sourceRoot":"","sources":["../../src/metrics/MetricsManager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAiBH,MAAM,OAAO,cAAc;IACR,UAAU,GAAsB,EAAE,CAAC;IACnC,KAAK,GAAmB,EAAE,CAAC;IAC3B,MAAM,CAAuB;IAC7B,MAAM,CAAU;IAEzB,KAAK,GAA0C,IAAI,CAAC;IACpD,eAAe,GAAG,CAAC,CAAC;IACpB,oBAAoB,GAAG,CAAC,CAAC;IACzB,oBAAoB,GAAG,CAAC,CAAC;IACzB,eAAe,GAAG,CAAC,CAAC;IACpB,wBAAwB,GAAG,CAAC,CAAC;IAC7B,MAAM,GAAG,KAAK,CAAC;IACN,gBAAgB,CAAS;IAE1C,YAAY,MAA4B,EAAE,MAAe;QACvD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,gBAAgB,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACnD,CAAC;IAED,8EAA8E;IAC9E,aAAa;IACb,8EAA8E;IAE9E,iBAAiB,CAAC,SAA2B;QAC3C,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YACnB,SAAS;YACT,mBAAmB,EAAE,CAAC;YACtB,QAAQ,EAAE,KAAK;SAChB,CAAC,CAAC;IACL,CAAC;IAED,YAAY,CAAC,IAAkB;QAC7B,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,UAAU,EAAE,CAAC;QAClB,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;YAC5E,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,CAAC,oBAAoB,GAAG,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE;gBAC5B,KAAK,IAAI,CAAC,UAAU,EAAE,CAAC;YACzB,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;YAErC,+DAA+D;YAC/D,IAAI,IAAI,CAAC,KAAK,IAAI,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ,IAAI,OAAO,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBAC1E,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;YACrB,CAAC;QACH,CAAC;IACH,CAAC;IAED,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,UAAU,EAAE,CAAC;QAElB,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC/D,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,0BAA0B,EAAE,CAAC,CAAC;QAEnD,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;QACjD,MAAM,QAAQ,GAAmB;YAC/B,EAAE,EAAE,QAAQ,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,eAAe,EAAE,EAAE;YAClD,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACnC,OAAO,EAAE,OAAO;YAChB,MAAM;YACN,UAAU;SACX,CAAC;QAEF,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;QAC/B,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QACtC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC;QAClC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;QAE/B,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,wBAAwB,GAAG,UAAU,CAAC;QAE3C,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,KAAK,CAAC,qBAAqB;QACjC,MAAM,OAAO,GAAkB,EAAE,CAAC;QAClC,MAAM,MAAM,GAAa,EAAE,CAAC;QAE5B,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACrC,IAAI,MAAM,CAAC,QAAQ;gBAAE,SAAS;YAE9B,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;gBACjE,MAAM,CAAC,mBAAmB,GAAG,CAAC,CAAC;gBAC/B,OAAO,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;YAC1B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,mBAAmB,EAAE,CAAC;gBAC7B,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBAC5B,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACjE,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC;gBAEpD,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,cAAc,MAAM,CAAC,SAAS,CAAC,IAAI,aAAa,MAAM,CAAC,mBAAmB,IAAI,IAAI,CAAC,MAAM,CAAC,yBAAyB,GAAG,EACtH,EAAE,KAAK,EAAE,OAAO,EAAE,CACnB,CAAC;gBAEF,IAAI,MAAM,CAAC,mBAAmB,IAAI,IAAI,CAAC,MAAM,CAAC,yBAAyB,EAAE,CAAC;oBACxE,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;oBACvB,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,cAAc,MAAM,CAAC,SAAS,CAAC,IAAI,oBAAoB,MAAM,CAAC,mBAAmB,uBAAuB,CACzG,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAC7B,CAAC;IAEO,eAAe,CAAC,QAAwB;QAC9C,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC;QACvD,IAAI,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC;YACjD,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,iBAAiB,cAAc,wBAAwB,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE,EACpF,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE,CAClD,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,UAAU,CAAC,QAAwB,EAAE,UAAkB;QAC7D,IAAI,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,wBAAwB,IAAI,IAAI,CAAC,oBAAoB,IAAI,CAAC,EAAE,CAAC;YACxF,IAAI,CAAC,MAAM,CAAC,IAAI,CACd,mBAAmB,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,kBAAkB,IAAI,CAAC,MAAM,CAAC,wBAAwB,KAAK,EACnG,EAAE,UAAU,EAAE,QAAQ,CAAC,EAAE,EAAE,CAC5B,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,kBAAkB,CAAC,QAAwB;QACjD,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAChC,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;YACrC,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC5D,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC;YACD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;QACD,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC/B,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC1B,CAAC;IAEO,eAAe,CAAC,QAAwB;QAC9C,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC9B,IAAI,CAAC;gBACH,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;YAC5B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACjE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,aAAa,OAAO,EAAE,CAAC,CAAC;YAC7D,CAAC;QACH,CAAC;IACH,CAAC;IAED,KAAK,CAAC,KAAK;QACT,IAAI,IAAI,CAAC,MAAM;YAAE,OAAO;QAExB,aAAa;QACb,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;YACxB,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC1B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QACpB,CAAC;QAED,IAAI,CAAC;YACH,6DAA6D;YAC7D,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;QAC1B,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YAEnB,4BAA4B;YAC5B,MAAM,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YACzD,MAAM,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC3D,CAAC;IACH,CAAC;IAED,eAAe;QAUb,OAAO;YACL,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,wBAAwB,EAAE,IAAI,CAAC,wBAAwB;YACvD,oBAAoB,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM;YAC5C,eAAe,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM;YAClC,kBAAkB,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM;YAClE,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;SACxC,CAAC;IACJ,CAAC;IAED,8EAA8E;IAC9E,YAAY;IACZ,8EAA8E;IAEtE,UAAU;QAChB,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;IAEO,0BAA0B;QAChC,MAAM,MAAM,GAAG,gBAAgB,CAAC;QAChC,MAAM,IAAI,GAAG,OAAgB,CAAC;QAE9B,OAAO;YACL;gBACE,IAAI,EAAE,OAAgB;gBACtB,IAAI,EAAE,uCAAuC;gBAC7C,MAAM;gBACN,IAAI;gBACJ,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM;aAC9B;YACD;gBACE,IAAI,EAAE,OAAgB;gBACtB,IAAI,EAAE,kCAAkC;gBACxC,MAAM;gBACN,IAAI;gBACJ,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM;aACzB;YACD;gBACE,IAAI,EAAE,SAAkB;gBACxB,IAAI,EAAE,wCAAwC;gBAC9C,MAAM;gBACN,IAAI;gBACJ,KAAK,EAAE,IAAI,CAAC,oBAAoB;aACjC;YACD;gBACE,IAAI,EAAE,SAAkB;gBACxB,IAAI,EAAE,mCAAmC;gBACzC,MAAM;gBACN,IAAI;gBACJ,KAAK,EAAE,IAAI,CAAC,eAAe;aAC5B;YACD;gBACE,IAAI,EAAE,OAAgB;gBACtB,IAAI,EAAE,6CAA6C;gBACnD,MAAM;gBACN,IAAI,EAAE,cAAuB;gBAC7B,KAAK,EAAE,IAAI,CAAC,wBAAwB;aACrC;YACD;gBACE,IAAI,EAAE,SAAkB;gBACxB,IAAI,EAAE,uCAAuC;gBAC7C,MAAM;gBACN,IAAI;gBACJ,KAAK,EAAE,IAAI,CAAC,eAAe;aAC5B;YACD;gBACE,IAAI,EAAE,OAAgB;gBACtB,IAAI,EAAE,qCAAqC;gBAC3C,MAAM;gBACN,IAAI;gBACJ,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM;aACtD;SACF,CAAC;IACJ,CAAC;CACF","sourcesContent":["/**\n * Central coordinator for the Metrics Collection System.\n *\n * Registers collectors and sinks, runs periodic collection cycles,\n * assembles immutable MetricSnapshot objects, and dispatches them\n * to all registered sinks.\n */\n\nimport type { ILogger } from '../types/ILogger.js';\nimport type {\n  IMetricCollector,\n  IMetricsSink,\n  MetricEntry,\n  MetricSnapshot,\n  MetricsManagerConfig,\n} from './types.js';\n\ninterface CollectorRecord {\n  collector: IMetricCollector;\n  consecutiveFailures: number;\n  disabled: boolean;\n}\n\nexport class MetricsManager {\n  private readonly collectors: CollectorRecord[] = [];\n  private readonly sinks: IMetricsSink[] = [];\n  private readonly config: MetricsManagerConfig;\n  private readonly logger: ILogger;\n\n  private timer: ReturnType<typeof setInterval> | null = null;\n  private snapshotCounter = 0;\n  private collectionsCompleted = 0;\n  private collectorErrorsTotal = 0;\n  private sinkErrorsTotal = 0;\n  private lastCollectionDurationMs = 0;\n  private closed = false;\n  private readonly processStartTime: string;\n\n  constructor(config: MetricsManagerConfig, logger: ILogger) {\n    this.config = config;\n    this.logger = logger;\n    this.processStartTime = new Date().toISOString();\n  }\n\n  // ---------------------------------------------------------------------------\n  // Public API\n  // ---------------------------------------------------------------------------\n\n  registerCollector(collector: IMetricCollector): void {\n    this.assertOpen();\n    this.collectors.push({\n      collector,\n      consecutiveFailures: 0,\n      disabled: false,\n    });\n  }\n\n  registerSink(sink: IMetricsSink): void {\n    this.assertOpen();\n    this.sinks.push(sink);\n  }\n\n  start(): void {\n    this.assertOpen();\n    if (this.timer !== null) {\n      this.logger.warn('MetricsManager.start() called but timer already running');\n      return;\n    }\n\n    if (this.config.collectionIntervalMs > 0) {\n      this.timer = setInterval(() => {\n        void this.collectNow();\n      }, this.config.collectionIntervalMs);\n\n      // Allow the process to exit even if the timer is still running\n      if (this.timer && typeof this.timer === 'object' && 'unref' in this.timer) {\n        this.timer.unref();\n      }\n    }\n  }\n\n  async collectNow(): Promise<MetricSnapshot> {\n    this.assertOpen();\n\n    const startTime = performance.now();\n    const { entries, errors } = await this.collectFromCollectors();\n    entries.push(...this.buildSelfMonitoringMetrics());\n\n    const durationMs = performance.now() - startTime;\n    const snapshot: MetricSnapshot = {\n      id: `SNAP-${Date.now()}-${this.snapshotCounter++}`,\n      timestamp: new Date().toISOString(),\n      metrics: entries,\n      errors,\n      durationMs,\n    };\n\n    this.warnIfOversized(snapshot);\n    this.warnIfSlow(snapshot, durationMs);\n    this.deepFreezeSnapshot(snapshot);\n    this.dispatchToSinks(snapshot);\n\n    this.collectionsCompleted++;\n    this.lastCollectionDurationMs = durationMs;\n\n    return snapshot;\n  }\n\n  private async collectFromCollectors(): Promise<{ entries: MetricEntry[]; errors: string[] }> {\n    const entries: MetricEntry[] = [];\n    const errors: string[] = [];\n\n    for (const record of this.collectors) {\n      if (record.disabled) continue;\n\n      try {\n        const result = await Promise.resolve(record.collector.collect());\n        record.consecutiveFailures = 0;\n        entries.push(...result);\n      } catch (err) {\n        record.consecutiveFailures++;\n        this.collectorErrorsTotal++;\n        const message = err instanceof Error ? err.message : String(err);\n        errors.push(`${record.collector.name}: ${message}`);\n\n        this.logger.warn(\n          `Collector \"${record.collector.name}\" failed (${record.consecutiveFailures}/${this.config.collectorFailureThreshold})`,\n          { error: message },\n        );\n\n        if (record.consecutiveFailures >= this.config.collectorFailureThreshold) {\n          record.disabled = true;\n          this.logger.error(\n            `Collector \"${record.collector.name}\" disabled after ${record.consecutiveFailures} consecutive failures`,\n          );\n        }\n      }\n    }\n\n    return { entries, errors };\n  }\n\n  private warnIfOversized(snapshot: MetricSnapshot): void {\n    const serializedSize = JSON.stringify(snapshot).length;\n    if (serializedSize > this.config.maxSnapshotSize) {\n      this.logger.warn(\n        `Snapshot size ${serializedSize} bytes exceeds limit ${this.config.maxSnapshotSize}`,\n        { snapshotId: snapshot.id, size: serializedSize },\n      );\n    }\n  }\n\n  private warnIfSlow(snapshot: MetricSnapshot, durationMs: number): void {\n    if (durationMs > this.config.collectionDurationWarnMs && this.collectionsCompleted >= 3) {\n      this.logger.warn(\n        `Collection took ${durationMs.toFixed(1)}ms (threshold: ${this.config.collectionDurationWarnMs}ms)`,\n        { snapshotId: snapshot.id },\n      );\n    }\n  }\n\n  private deepFreezeSnapshot(snapshot: MetricSnapshot): void {\n    Object.freeze(snapshot.metrics);\n    for (const entry of snapshot.metrics) {\n      if (entry.value !== null && typeof entry.value === 'object') {\n        Object.freeze(entry.value);\n      }\n      Object.freeze(entry);\n    }\n    Object.freeze(snapshot.errors);\n    Object.freeze(snapshot);\n  }\n\n  private dispatchToSinks(snapshot: MetricSnapshot): void {\n    for (const sink of this.sinks) {\n      try {\n        sink.onSnapshot(snapshot);\n      } catch (err) {\n        this.sinkErrorsTotal++;\n        const message = err instanceof Error ? err.message : String(err);\n        this.logger.warn(`Sink \"${sink.name}\" failed: ${message}`);\n      }\n    }\n  }\n\n  async close(): Promise<void> {\n    if (this.closed) return;\n\n    // Stop timer\n    if (this.timer !== null) {\n      clearInterval(this.timer);\n      this.timer = null;\n    }\n\n    try {\n      // Final collection — best-effort, should not prevent cleanup\n      await this.collectNow();\n    } finally {\n      this.closed = true;\n\n      // Flush and close all sinks\n      await Promise.allSettled(this.sinks.map(s => s.flush()));\n      await Promise.allSettled(this.sinks.map(s => s.close()));\n    }\n  }\n\n  getManagerStats(): {\n    collectionsCompleted: number;\n    collectorErrorsTotal: number;\n    sinkErrorsTotal: number;\n    lastCollectionDurationMs: number;\n    collectorsRegistered: number;\n    sinksRegistered: number;\n    disabledCollectors: number;\n    processStartTime: string;\n  } {\n    return {\n      collectionsCompleted: this.collectionsCompleted,\n      collectorErrorsTotal: this.collectorErrorsTotal,\n      sinkErrorsTotal: this.sinkErrorsTotal,\n      lastCollectionDurationMs: this.lastCollectionDurationMs,\n      collectorsRegistered: this.collectors.length,\n      sinksRegistered: this.sinks.length,\n      disabledCollectors: this.collectors.filter(r => r.disabled).length,\n      processStartTime: this.processStartTime,\n    };\n  }\n\n  // ---------------------------------------------------------------------------\n  // Internals\n  // ---------------------------------------------------------------------------\n\n  private assertOpen(): void {\n    if (this.closed) {\n      throw new Error('MetricsManager is closed');\n    }\n  }\n\n  private buildSelfMonitoringMetrics(): MetricEntry[] {\n    const source = 'MetricsManager';\n    const unit = 'count' as const;\n\n    return [\n      {\n        type: 'gauge' as const,\n        name: 'metrics.manager.collectors_registered',\n        source,\n        unit,\n        value: this.collectors.length,\n      },\n      {\n        type: 'gauge' as const,\n        name: 'metrics.manager.sinks_registered',\n        source,\n        unit,\n        value: this.sinks.length,\n      },\n      {\n        type: 'counter' as const,\n        name: 'metrics.manager.collector_errors_total',\n        source,\n        unit,\n        value: this.collectorErrorsTotal,\n      },\n      {\n        type: 'counter' as const,\n        name: 'metrics.manager.sink_errors_total',\n        source,\n        unit,\n        value: this.sinkErrorsTotal,\n      },\n      {\n        type: 'gauge' as const,\n        name: 'metrics.manager.last_collection_duration_ms',\n        source,\n        unit: 'milliseconds' as const,\n        value: this.lastCollectionDurationMs,\n      },\n      {\n        type: 'counter' as const,\n        name: 'metrics.manager.snapshots_taken_total',\n        source,\n        unit,\n        value: this.snapshotCounter,\n      },\n      {\n        type: 'gauge' as const,\n        name: 'metrics.manager.disabled_collectors',\n        source,\n        unit,\n        value: this.collectors.filter(r => r.disabled).length,\n      },\n    ];\n  }\n}\n"]}

package/dist/metrics/OperationMetricsTracker.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Lightweight in-memory accumulator for MCP-AQL operation metrics.
+ *
+ * Records operation counts, durations, and error rates. The companion
+ * OperationMetricsCollector reads from this tracker each collection cycle.
+ */
+export interface OperationMetrics {
+    totalOps: number;
+    failedOps: number;
+    durations: number[];
+    byEndpoint: Map<string, number>;
+    byOperation: Map<string, number>;
+}
+export declare class OperationMetricsTracker {
+    private totalOps;
+    private failedOps;
+    private readonly durations;
+    private readonly byEndpoint;
+    private readonly byOperation;
+    record(operation: string, endpoint: string, durationMs: number, success: boolean): void;
+    getMetrics(): OperationMetrics;
+    /** Compute duration percentiles from the ring buffer. */
+    static percentiles(durations: number[]): {
+        count: number;
+        sum: number;
+        avg: number;
+        p50: number;
+        p95: number;
+        p99: number;
+    };
+}
+//# sourceMappingURL=OperationMetricsTracker.d.ts.map

package/dist/metrics/OperationMetricsTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationMetricsTracker.d.ts","sourceRoot":"","sources":["../../src/metrics/OperationMetricsTracker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IAEzD,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAcvF,UAAU,IAAI,gBAAgB;IAU9B,yDAAyD;IACzD,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG;QACvC,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACb;CAgBF"}

package/dist/metrics/OperationMetricsTracker.js

@@ -0,0 +1,53 @@
+/**
+ * Lightweight in-memory accumulator for MCP-AQL operation metrics.
+ *
+ * Records operation counts, durations, and error rates. The companion
+ * OperationMetricsCollector reads from this tracker each collection cycle.
+ */
+const DURATION_RING_SIZE = 1000;
+export class OperationMetricsTracker {
+    totalOps = 0;
+    failedOps = 0;
+    durations = [];
+    byEndpoint = new Map();
+    byOperation = new Map();
+    record(operation, endpoint, durationMs, success) {
+        this.totalOps++;
+        if (!success)
+            this.failedOps++;
+        // Bounded duration history (evicts oldest when full)
+        this.durations.push(durationMs);
+        if (this.durations.length > DURATION_RING_SIZE) {
+            this.durations.shift();
+        }
+        this.byEndpoint.set(endpoint, (this.byEndpoint.get(endpoint) ?? 0) + 1);
+        this.byOperation.set(operation, (this.byOperation.get(operation) ?? 0) + 1);
+    }
+    getMetrics() {
+        return {
+            totalOps: this.totalOps,
+            failedOps: this.failedOps,
+            durations: [...this.durations],
+            byEndpoint: new Map(this.byEndpoint),
+            byOperation: new Map(this.byOperation),
+        };
+    }
+    /** Compute duration percentiles from the ring buffer. */
+    static percentiles(durations) {
+        if (durations.length === 0) {
+            return { count: 0, sum: 0, avg: 0, p50: 0, p95: 0, p99: 0 };
+        }
+        const sorted = [...durations].sort((a, b) => a - b);
+        const sum = sorted.reduce((s, v) => s + v, 0);
+        const pct = (p) => sorted[Math.min(Math.ceil(sorted.length * p) - 1, sorted.length - 1)];
+        return {
+            count: sorted.length,
+            sum,
+            avg: sum / sorted.length,
+            p50: pct(0.5),
+            p95: pct(0.95),
+            p99: pct(0.99),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/metrics/collectors/DefaultElementProviderCollector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Collector for DefaultElementProvider buffer pool metrics.
+ *
+ * Reads buffer pool performance stats via a configurable stats function
+ * (defaults to `DefaultElementProvider.getPerformanceStats`) and exposes
+ * hit/miss/created totals, hit rate, current pool size, and max pool size.
+ */
+import type { IMetricCollector, MetricEntry } from '../types.js';
+interface PerformanceStats {
+    bufferPool: {
+        hits: number;
+        misses: number;
+        created: number;
+        hitRate: number;
+        poolSize: number;
+        maxPoolSize: number;
+    };
+}
+export declare class DefaultElementProviderCollector implements IMetricCollector {
+    readonly name = "element-provider";
+    readonly description = "Buffer pool metrics from DefaultElementProvider.";
+    private readonly statsFn;
+    constructor(statsFn?: () => PerformanceStats);
+    collect(): MetricEntry[];
+}
+export {};
+//# sourceMappingURL=DefaultElementProviderCollector.d.ts.map

package/dist/metrics/collectors/DefaultElementProviderCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultElementProviderCollector.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/DefaultElementProviderCollector.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAGjE,UAAU,gBAAgB;IACxB,UAAU,EAAE;QACV,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,qBAAa,+BAAgC,YAAW,gBAAgB;IACtE,QAAQ,CAAC,IAAI,sBAAsB;IACnC,QAAQ,CAAC,WAAW,sDAAsD;IAE1E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;gBAErC,OAAO,CAAC,EAAE,MAAM,gBAAgB;IAI5C,OAAO,IAAI,WAAW,EAAE;CA2DzB"}

package/dist/metrics/collectors/DefaultElementProviderCollector.js

@@ -0,0 +1,69 @@
+import { DefaultElementProvider } from '../../portfolio/DefaultElementProvider.js';
+export class DefaultElementProviderCollector {
+    name = 'element-provider';
+    description = 'Buffer pool metrics from DefaultElementProvider.';
+    statsFn;
+    constructor(statsFn) {
+        this.statsFn = statsFn ?? DefaultElementProvider.getPerformanceStats.bind(DefaultElementProvider);
+    }
+    collect() {
+        try {
+            const stats = this.statsFn();
+            const bp = stats.bufferPool;
+            return [
+                {
+                    type: 'counter',
+                    name: 'portfolio.buffer_pool.hits_total',
+                    source: 'DefaultElementProvider',
+                    unit: 'count',
+                    description: 'Total number of buffer pool hits.',
+                    value: bp.hits,
+                },
+                {
+                    type: 'counter',
+                    name: 'portfolio.buffer_pool.misses_total',
+                    source: 'DefaultElementProvider',
+                    unit: 'count',
+                    description: 'Total number of buffer pool misses.',
+                    value: bp.misses,
+                },
+                {
+                    type: 'counter',
+                    name: 'portfolio.buffer_pool.created_total',
+                    source: 'DefaultElementProvider',
+                    unit: 'count',
+                    description: 'Total number of buffers created (pool was empty).',
+                    value: bp.created,
+                },
+                {
+                    type: 'gauge',
+                    name: 'portfolio.buffer_pool.hit_rate',
+                    source: 'DefaultElementProvider',
+                    unit: 'ratio',
+                    description: 'Buffer pool hit rate (0–1).',
+                    value: bp.hitRate,
+                },
+                {
+                    type: 'gauge',
+                    name: 'portfolio.buffer_pool.size_current',
+                    source: 'DefaultElementProvider',
+                    unit: 'count',
+                    description: 'Current number of buffers held in the pool.',
+                    value: bp.poolSize,
+                },
+                {
+                    type: 'gauge',
+                    name: 'portfolio.buffer_pool.size_max',
+                    source: 'DefaultElementProvider',
+                    unit: 'count',
+                    description: 'Maximum configured buffer pool size.',
+                    value: bp.maxPoolSize,
+                },
+            ];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/metrics/collectors/FileLockManagerCollector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Collector for FileLockManager metrics.
+ *
+ * Exposes lock request totals, active lock count, timeout count, and
+ * concurrent-wait count sourced from `FileLockManager.getMetrics()`.
+ */
+import type { IMetricCollector, MetricEntry } from '../types.js';
+import type { FileLockManager } from '../../security/fileLockManager.js';
+export declare class FileLockManagerCollector implements IMetricCollector {
+    private readonly lockManager;
+    readonly name = "file-lock";
+    readonly description = "Metrics from the FileLockManager: requests, active locks, timeouts, and concurrent waits.";
+    constructor(lockManager: FileLockManager);
+    collect(): MetricEntry[];
+}
+//# sourceMappingURL=FileLockManagerCollector.d.ts.map

package/dist/metrics/collectors/FileLockManagerCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileLockManagerCollector.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/FileLockManagerCollector.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAEzE,qBAAa,wBAAyB,YAAW,gBAAgB;IAInD,OAAO,CAAC,QAAQ,CAAC,WAAW;IAHxC,QAAQ,CAAC,IAAI,eAAe;IAC5B,QAAQ,CAAC,WAAW,+FAA+F;gBAEtF,WAAW,EAAE,eAAe;IAEzD,OAAO,IAAI,WAAW,EAAE;CA0CzB"}

package/dist/metrics/collectors/FileLockManagerCollector.js

@@ -0,0 +1,51 @@
+export class FileLockManagerCollector {
+    lockManager;
+    name = 'file-lock';
+    description = 'Metrics from the FileLockManager: requests, active locks, timeouts, and concurrent waits.';
+    constructor(lockManager) {
+        this.lockManager = lockManager;
+    }
+    collect() {
+        try {
+            const m = this.lockManager.getMetrics();
+            return [
+                {
+                    type: 'counter',
+                    name: 'lock.file.requests_total',
+                    source: 'FileLockManager',
+                    unit: 'count',
+                    description: 'Total number of file lock requests.',
+                    value: m.totalRequests,
+                },
+                {
+                    type: 'gauge',
+                    name: 'lock.file.active_current',
+                    source: 'FileLockManager',
+                    unit: 'count',
+                    description: 'Number of currently active file locks.',
+                    value: m.activeLocksCount,
+                },
+                {
+                    type: 'counter',
+                    name: 'lock.file.timeouts_total',
+                    source: 'FileLockManager',
+                    unit: 'count',
+                    description: 'Total number of file lock timeouts.',
+                    value: m.timeouts,
+                },
+                {
+                    type: 'counter',
+                    name: 'lock.file.concurrent_waits_total',
+                    source: 'FileLockManager',
+                    unit: 'count',
+                    description: 'Total number of concurrent lock wait events.',
+                    value: m.concurrentWaits,
+                },
+            ];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/metrics/collectors/GatekeeperMetricsCollector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Collector for Gatekeeper policy enforcement metrics.
+ *
+ * Reads from GatekeeperMetricsTracker and emits counter and gauge
+ * metric entries for the MetricsManager pipeline.
+ */
+import type { IMetricCollector, MetricEntry } from '../types.js';
+import type { GatekeeperMetricsTracker } from '../GatekeeperMetricsTracker.js';
+export declare class GatekeeperMetricsCollector implements IMetricCollector {
+    private readonly tracker;
+    readonly name = "gatekeeper-metrics";
+    readonly description = "Gatekeeper policy enforcement: allowed/denied/confirmed, policy sources, permission levels.";
+    constructor(tracker: GatekeeperMetricsTracker);
+    collect(): MetricEntry[];
+}
+//# sourceMappingURL=GatekeeperMetricsCollector.d.ts.map

package/dist/metrics/collectors/GatekeeperMetricsCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GatekeeperMetricsCollector.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/GatekeeperMetricsCollector.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAE/E,qBAAa,0BAA2B,YAAW,gBAAgB;IAIrD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,QAAQ,CAAC,IAAI,wBAAwB;IACrC,QAAQ,CAAC,WAAW,iGAAiG;gBAExF,OAAO,EAAE,wBAAwB;IAE9D,OAAO,IAAI,WAAW,EAAE;CAsEzB"}