observability-toolkit 1.8.2 → 1.8.5

package/dist/backends/local-jsonl.js

@@ -12,6 +12,7 @@ import { listFiles, streamJsonl, parseDateFromFilename, getDateString, paginateR
 import { QueryCache, makeCacheKey } from '../lib/cache.js';
 import { getIndexPath, readIndex, isIndexStale, queryIndex, readLinesByNumber, } from '../lib/indexer.js';
 import { sanitizePath } from '../lib/error-sanitizer.js';
+import { CircuitBreaker } from '../lib/circuit-breaker.js';
 import { existsSync } from 'fs';
 function startTiming() {
     const start = performance.now();
@@ -20,6 +21,38 @@ function startTiming() {
     };
 }
 const SLOW_QUERY_THRESHOLD_MS = 500;
+/**
+ * LRU regex cache to avoid recompiling frequently-used patterns.
+ * Maximum 100 patterns cached; uses Map insertion order for LRU eviction.
+ */
+const regexCache = new Map();
+const MAX_CACHED_REGEX_PATTERNS = 100;
+/**
+ * Get a cached regex or compile and cache a new one.
+ * Returns null for invalid patterns (logs warning).
+ */
+function getCachedRegex(pattern) {
+    const cached = regexCache.get(pattern);
+    if (cached) {
+        return cached;
+    }
+    try {
+        const regex = new RegExp(pattern);
+        // LRU eviction: remove oldest entry if at capacity
+        if (regexCache.size >= MAX_CACHED_REGEX_PATTERNS) {
+            const firstKey = regexCache.keys().next().value;
+            if (firstKey !== undefined) {
+                regexCache.delete(firstKey);
+            }
+        }
+        regexCache.set(pattern, regex);
+        return regex;
+    }
+    catch {
+        console.warn(`Invalid regex pattern: ${pattern}`);
+        return null;
+    }
+}
 /**
  * Insert item into a sorted array, maintaining sort order and max size.
  * More efficient than sort+slice for top-K selection (O(n) vs O(n log n)).
@@ -29,6 +62,8 @@ function insertSortedBounded(arr, item, maxSize, compareFn) {
     let low = 0;
     let high = arr.length;
     while (low < high) {
+        // Use unsigned right shift (>>>) to compute midpoint without integer overflow
+        // when (low + high) exceeds Number.MAX_SAFE_INTEGER
         const mid = (low + high) >>> 1;
         if (compareFn(arr[mid], item) <= 0) {
             low = mid + 1;
@@ -431,9 +466,23 @@ export class LocalJsonlBackend {
     llmEventCache = new QueryCache();
     evaluationCache = new QueryCache();
     useIndexes;
+    circuitBreaker;
     constructor(telemetryDir, useIndexes = true) {
         this.telemetryDir = telemetryDir || TELEMETRY_DIR;
         this.useIndexes = useIndexes;
+        this.circuitBreaker = new CircuitBreaker({ name: 'local-file-io' });
+    }
+    /**
+     * Get circuit breaker state (for health check and testing)
+     */
+    getCircuitBreakerState() {
+        return this.circuitBreaker.getState();
+    }
+    /**
+     * Reset circuit breaker (for testing)
+     */
+    resetCircuitBreaker() {
+        this.circuitBreaker.reset();
     }
     /**
      * Clear all query caches
@@ -479,6 +528,11 @@ export class LocalJsonlBackend {
                 console.warn(`[obs-toolkit] Slow query: queryTraces took ${durationMs.toFixed(1)}ms`);
             }
         };
+        // Check circuit breaker - fail fast if open
+        if (!this.circuitBreaker.canRequest()) {
+            logTiming();
+            return [];
+        }
         // Check cache first
         const cacheKey = makeCacheKey('traces', options);
         const cached = this.traceCache.get(cacheKey);
@@ -490,16 +544,10 @@ export class LocalJsonlBackend {
         const results = [];
         const limit = options.limit || 100;
         const offset = options.offset || 0;
-        // Compile regex once outside the loop, handling invalid patterns gracefully
-        let spanNameRegex = null;
-        if (options.spanNameRegex) {
-            try {
-                spanNameRegex = new RegExp(options.spanNameRegex);
-            }
-            catch {
-                console.warn(`Invalid spanNameRegex pattern: ${options.spanNameRegex}`);
-            }
-        }
+        // Use cached regex to avoid recompilation for frequently-used patterns
+        const spanNameRegex = options.spanNameRegex
+            ? getCachedRegex(options.spanNameRegex)
+            : null;
         // Build index query options for indexable filters
         const indexOptions = {
             traceId: options.traceId,
@@ -558,59 +606,69 @@ export class LocalJsonlBackend {
                 return false;
             return true;
         };
-        for (const file of files) {
-            // Try to use index for pre-filtering
-            const matchingLines = this.tryUseIndex(file, 'traces', indexOptions);
-            if (matchingLines !== null) {
-                // Use indexed query - read only matching lines
-                const rawRecords = await readLinesByNumber(file, matchingLines);
-                for (const raw of rawRecords) {
-                    const span = normalizeSpan(raw);
-                    if (!span)
-                        continue;
-                    if (!applyFilters(span))
-                        continue;
-                    results.push(span);
-                    if (hasReachedLimit(results.length, offset, limit)) {
-                        const paginated = paginateResults(results, offset, limit);
-                        this.traceCache.set(cacheKey, paginated);
-                        logTiming();
-                        return paginated;
+        try {
+            for (const file of files) {
+                // Try to use index for pre-filtering
+                const matchingLines = this.tryUseIndex(file, 'traces', indexOptions);
+                if (matchingLines !== null) {
+                    // Use indexed query - read only matching lines
+                    const rawRecords = await readLinesByNumber(file, matchingLines);
+                    for (const raw of rawRecords) {
+                        const span = normalizeSpan(raw);
+                        if (!span)
+                            continue;
+                        if (!applyFilters(span))
+                            continue;
+                        results.push(span);
+                        if (hasReachedLimit(results.length, offset, limit)) {
+                            const paginated = paginateResults(results, offset, limit);
+                            this.traceCache.set(cacheKey, paginated);
+                            this.circuitBreaker.recordSuccess();
+                            logTiming();
+                            return paginated;
+                        }
                     }
                 }
-            }
-            else {
-                // Fall back to full file scan
-                for await (const raw of streamJsonl(file)) {
-                    const span = normalizeSpan(raw);
-                    if (!span)
-                        continue;
-                    // Apply indexable filters (since no index was used)
-                    if (options.traceId && span.traceId !== options.traceId)
-                        continue;
-                    if (options.spanName && !span.name.includes(options.spanName))
-                        continue;
-                    if (options.serviceName) {
-                        const svc = span.attributes?.['service.name'];
-                        if (svc !== options.serviceName)
+                else {
+                    // Fall back to full file scan
+                    for await (const raw of streamJsonl(file)) {
+                        const span = normalizeSpan(raw);
+                        if (!span)
                             continue;
-                    }
-                    if (!applyFilters(span))
-                        continue;
-                    results.push(span);
-                    if (hasReachedLimit(results.length, offset, limit)) {
-                        const paginated = paginateResults(results, offset, limit);
-                        this.traceCache.set(cacheKey, paginated);
-                        logTiming();
-                        return paginated;
+                        // Apply indexable filters (since no index was used)
+                        if (options.traceId && span.traceId !== options.traceId)
+                            continue;
+                        if (options.spanName && !span.name.includes(options.spanName))
+                            continue;
+                        if (options.serviceName) {
+                            const svc = span.attributes?.['service.name'];
+                            if (svc !== options.serviceName)
+                                continue;
+                        }
+                        if (!applyFilters(span))
+                            continue;
+                        results.push(span);
+                        if (hasReachedLimit(results.length, offset, limit)) {
+                            const paginated = paginateResults(results, offset, limit);
+                            this.traceCache.set(cacheKey, paginated);
+                            this.circuitBreaker.recordSuccess();
+                            logTiming();
+                            return paginated;
+                        }
                     }
                 }
             }
+            const paginated = paginateResults(results, offset, limit);
+            this.traceCache.set(cacheKey, paginated);
+            this.circuitBreaker.recordSuccess();
+            logTiming();
+            return paginated;
+        }
+        catch (error) {
+            this.circuitBreaker.recordFailure();
+            logTiming();
+            throw error;
         }
-        const paginated = paginateResults(results, offset, limit);
-        this.traceCache.set(cacheKey, paginated);
-        logTiming();
-        return paginated;
     }
     async queryLogs(options) {
         const timer = startTiming();
@@ -620,6 +678,11 @@ export class LocalJsonlBackend {
                 console.warn(`[obs-toolkit] Slow query: queryLogs took ${durationMs.toFixed(1)}ms`);
             }
         };
+        // Check circuit breaker - fail fast if open
+        if (!this.circuitBreaker.canRequest()) {
+            logTiming();
+            return [];
+        }
         // Check cache first
         const cacheKey = makeCacheKey('logs', options);
         const cached = this.logCache.get(cacheKey);
@@ -678,54 +741,64 @@ export class LocalJsonlBackend {
             }
             return true;
         };
-        for (const file of files) {
-            // Try to use index for pre-filtering
-            const matchingLines = this.tryUseIndex(file, 'logs', indexOptions);
-            if (matchingLines !== null) {
-                // Use indexed query - read only matching lines
-                const rawRecords = await readLinesByNumber(file, matchingLines);
-                for (const raw of rawRecords) {
-                    const log = normalizeLog(raw, options.extractFields);
-                    if (!log)
-                        continue;
-                    if (!applyFilters(log))
-                        continue;
-                    results.push(log);
-                    if (hasReachedLimit(results.length, offset, limit)) {
-                        const paginated = paginateResults(results, offset, limit);
-                        this.logCache.set(cacheKey, paginated);
-                        logTiming();
-                        return paginated;
+        try {
+            for (const file of files) {
+                // Try to use index for pre-filtering
+                const matchingLines = this.tryUseIndex(file, 'logs', indexOptions);
+                if (matchingLines !== null) {
+                    // Use indexed query - read only matching lines
+                    const rawRecords = await readLinesByNumber(file, matchingLines);
+                    for (const raw of rawRecords) {
+                        const log = normalizeLog(raw, options.extractFields);
+                        if (!log)
+                            continue;
+                        if (!applyFilters(log))
+                            continue;
+                        results.push(log);
+                        if (hasReachedLimit(results.length, offset, limit)) {
+                            const paginated = paginateResults(results, offset, limit);
+                            this.logCache.set(cacheKey, paginated);
+                            this.circuitBreaker.recordSuccess();
+                            logTiming();
+                            return paginated;
+                        }
                     }
                 }
-            }
-            else {
-                // Fall back to full file scan
-                for await (const raw of streamJsonl(file)) {
-                    const log = normalizeLog(raw, options.extractFields);
-                    if (!log)
-                        continue;
-                    // Apply indexable filters (since no index was used)
-                    if (options.severity && log.severity.toUpperCase() !== options.severity.toUpperCase())
-                        continue;
-                    if (options.traceId && log.traceId !== options.traceId)
-                        continue;
-                    if (!applyFilters(log))
-                        continue;
-                    results.push(log);
-                    if (hasReachedLimit(results.length, offset, limit)) {
-                        const paginated = paginateResults(results, offset, limit);
-                        this.logCache.set(cacheKey, paginated);
-                        logTiming();
-                        return paginated;
+                else {
+                    // Fall back to full file scan
+                    for await (const raw of streamJsonl(file)) {
+                        const log = normalizeLog(raw, options.extractFields);
+                        if (!log)
+                            continue;
+                        // Apply indexable filters (since no index was used)
+                        if (options.severity && log.severity.toUpperCase() !== options.severity.toUpperCase())
+                            continue;
+                        if (options.traceId && log.traceId !== options.traceId)
+                            continue;
+                        if (!applyFilters(log))
+                            continue;
+                        results.push(log);
+                        if (hasReachedLimit(results.length, offset, limit)) {
+                            const paginated = paginateResults(results, offset, limit);
+                            this.logCache.set(cacheKey, paginated);
+                            this.circuitBreaker.recordSuccess();
+                            logTiming();
+                            return paginated;
+                        }
                     }
                 }
             }
+            const paginated = paginateResults(results, offset, limit);
+            this.logCache.set(cacheKey, paginated);
+            this.circuitBreaker.recordSuccess();
+            logTiming();
+            return paginated;
+        }
+        catch (error) {
+            this.circuitBreaker.recordFailure();
+            logTiming();
+            throw error;
         }
-        const paginated = paginateResults(results, offset, limit);
-        this.logCache.set(cacheKey, paginated);
-        logTiming();
-        return paginated;
     }
     async queryMetrics(options) {
         const timer = startTiming();
@@ -735,6 +808,11 @@ export class LocalJsonlBackend {
                 console.warn(`[obs-toolkit] Slow query: queryMetrics took ${durationMs.toFixed(1)}ms`);
             }
         };
+        // Check circuit breaker - fail fast if open
+        if (!this.circuitBreaker.canRequest()) {
+            logTiming();
+            return [];
+        }
         // Check cache first
         const cacheKey = makeCacheKey('metrics', options);
         const cached = this.metricCache.get(cacheKey);
@@ -750,49 +828,58 @@ export class LocalJsonlBackend {
         const indexOptions = {
             metricName: options.metricName,
         };
-        outer: for (const file of files) {
-            // Try to use index for pre-filtering
-            const matchingLines = this.tryUseIndex(file, 'metrics', indexOptions);
-            if (matchingLines !== null) {
-                // Use indexed query - read only matching lines
-                const rawRecords = await readLinesByNumber(file, matchingLines);
-                for (const raw of rawRecords) {
-                    const point = normalizeMetric(raw);
-                    if (!point)
-                        continue;
-                    results.push(point);
-                    if (hasReachedLimit(results.length, offset, limit)) {
-                        break outer;
+        try {
+            outer: for (const file of files) {
+                // Try to use index for pre-filtering
+                const matchingLines = this.tryUseIndex(file, 'metrics', indexOptions);
+                if (matchingLines !== null) {
+                    // Use indexed query - read only matching lines
+                    const rawRecords = await readLinesByNumber(file, matchingLines);
+                    for (const raw of rawRecords) {
+                        const point = normalizeMetric(raw);
+                        if (!point)
+                            continue;
+                        results.push(point);
+                        if (hasReachedLimit(results.length, offset, limit)) {
+                            break outer;
+                        }
                     }
                 }
-            }
-            else {
-                // Fall back to full file scan
-                for await (const raw of streamJsonl(file)) {
-                    const point = normalizeMetric(raw);
-                    if (!point)
-                        continue;
-                    // Apply filters (since no index was used)
-                    if (options.metricName && !point.name.includes(options.metricName))
-                        continue;
-                    results.push(point);
-                    if (hasReachedLimit(results.length, offset, limit)) {
-                        break outer;
+                else {
+                    // Fall back to full file scan
+                    for await (const raw of streamJsonl(file)) {
+                        const point = normalizeMetric(raw);
+                        if (!point)
+                            continue;
+                        // Apply filters (since no index was used)
+                        if (options.metricName && !point.name.includes(options.metricName))
+                            continue;
+                        results.push(point);
+                        if (hasReachedLimit(results.length, offset, limit)) {
+                            break outer;
+                        }
                     }
                 }
             }
+            // Apply aggregation if requested
+            if (options.aggregation && results.length > 0) {
+                const aggregated = this.aggregate(results, options.aggregation, options.groupBy, options.timeBucket);
+                this.metricCache.set(cacheKey, aggregated);
+                this.circuitBreaker.recordSuccess();
+                logTiming();
+                return aggregated;
+            }
+            const paginated = paginateResults(results, offset, limit);
+            this.metricCache.set(cacheKey, paginated);
+            this.circuitBreaker.recordSuccess();
+            logTiming();
+            return paginated;
         }
-        // Apply aggregation if requested
-        if (options.aggregation && results.length > 0) {
-            const aggregated = this.aggregate(results, options.aggregation, options.groupBy, options.timeBucket);
-            this.metricCache.set(cacheKey, aggregated);
+        catch (error) {
+            this.circuitBreaker.recordFailure();
             logTiming();
-            return aggregated;
+            throw error;
         }
-        const paginated = paginateResults(results, offset, limit);
-        this.metricCache.set(cacheKey, paginated);
-        logTiming();
-        return paginated;
     }
     aggregate(points, aggregation, groupBy, timeBucket) {
         // Parse time bucket if provided
@@ -907,6 +994,11 @@ export class LocalJsonlBackend {
                 console.warn(`[obs-toolkit] Slow query: queryLLMEvents took ${durationMs.toFixed(1)}ms`);
             }
         };
+        // Check circuit breaker - fail fast if open
+        if (!this.circuitBreaker.canRequest()) {
+            logTiming();
+            return [];
+        }
         // Check cache first
         const cacheKey = makeCacheKey('llm-events', options);
         const cached = this.llmEventCache.get(cacheKey);
@@ -955,58 +1047,68 @@ export class LocalJsonlBackend {
             }
             return true;
         };
-        for (const file of files) {
-            // Try to use index for pre-filtering
-            const matchingLines = this.tryUseIndex(file, 'llm-events', indexOptions);
-            if (matchingLines !== null) {
-                // Use indexed query - read only matching lines
-                const rawRecords = await readLinesByNumber(file, matchingLines);
-                for (const event of rawRecords) {
-                    if (!event.timestamp || !event.name)
-                        continue;
-                    if (!applyFilters(event))
-                        continue;
-                    results.push({
-                        timestamp: event.timestamp,
-                        name: event.name,
-                        attributes: event.attributes,
-                    });
-                    if (hasReachedLimit(results.length, offset, limit)) {
-                        const paginated = paginateResults(results, offset, limit);
-                        this.llmEventCache.set(cacheKey, paginated);
-                        logTiming();
-                        return paginated;
+        try {
+            for (const file of files) {
+                // Try to use index for pre-filtering
+                const matchingLines = this.tryUseIndex(file, 'llm-events', indexOptions);
+                if (matchingLines !== null) {
+                    // Use indexed query - read only matching lines
+                    const rawRecords = await readLinesByNumber(file, matchingLines);
+                    for (const event of rawRecords) {
+                        if (!event.timestamp || !event.name)
+                            continue;
+                        if (!applyFilters(event))
+                            continue;
+                        results.push({
+                            timestamp: event.timestamp,
+                            name: event.name,
+                            attributes: event.attributes,
+                        });
+                        if (hasReachedLimit(results.length, offset, limit)) {
+                            const paginated = paginateResults(results, offset, limit);
+                            this.llmEventCache.set(cacheKey, paginated);
+                            this.circuitBreaker.recordSuccess();
+                            logTiming();
+                            return paginated;
+                        }
                     }
                 }
-            }
-            else {
-                // Fall back to full file scan
-                for await (const event of streamJsonl(file)) {
-                    if (!event.timestamp || !event.name)
-                        continue;
-                    // Apply indexable filters (since no index was used)
-                    if (options.eventName && !event.name.includes(options.eventName))
-                        continue;
-                    if (!applyFilters(event))
-                        continue;
-                    results.push({
-                        timestamp: event.timestamp,
-                        name: event.name,
-                        attributes: event.attributes,
-                    });
-                    if (hasReachedLimit(results.length, offset, limit)) {
-                        const paginated = paginateResults(results, offset, limit);
-                        this.llmEventCache.set(cacheKey, paginated);
-                        logTiming();
-                        return paginated;
+                else {
+                    // Fall back to full file scan
+                    for await (const event of streamJsonl(file)) {
+                        if (!event.timestamp || !event.name)
+                            continue;
+                        // Apply indexable filters (since no index was used)
+                        if (options.eventName && !event.name.includes(options.eventName))
+                            continue;
+                        if (!applyFilters(event))
+                            continue;
+                        results.push({
+                            timestamp: event.timestamp,
+                            name: event.name,
+                            attributes: event.attributes,
+                        });
+                        if (hasReachedLimit(results.length, offset, limit)) {
+                            const paginated = paginateResults(results, offset, limit);
+                            this.llmEventCache.set(cacheKey, paginated);
+                            this.circuitBreaker.recordSuccess();
+                            logTiming();
+                            return paginated;
+                        }
                     }
                 }
             }
+            const paginated = paginateResults(results, offset, limit);
+            this.llmEventCache.set(cacheKey, paginated);
+            this.circuitBreaker.recordSuccess();
+            logTiming();
+            return paginated;
+        }
+        catch (error) {
+            this.circuitBreaker.recordFailure();
+            logTiming();
+            throw error;
         }
-        const paginated = paginateResults(results, offset, limit);
-        this.llmEventCache.set(cacheKey, paginated);
-        logTiming();
-        return paginated;
     }
     async queryEvaluations(options) {
         const timer = startTiming();
@@ -1016,6 +1118,11 @@ export class LocalJsonlBackend {
                 console.warn(`[obs-toolkit] Slow query: queryEvaluations took ${durationMs.toFixed(1)}ms`);
             }
         };
+        // Check circuit breaker - fail fast if open
+        if (!this.circuitBreaker.canRequest()) {
+            logTiming();
+            return [];
+        }
         // Check cache first
         const cacheKey = makeCacheKey('evaluations', options);
         const cached = this.evaluationCache.get(cacheKey);
@@ -1057,62 +1164,76 @@ export class LocalJsonlBackend {
             }
             return true;
         };
-        for (const file of files) {
-            // Try to use index for pre-filtering
-            const matchingLines = this.tryUseIndex(file, 'evaluations', indexOptions);
-            if (matchingLines !== null) {
-                // Use indexed query - read only matching lines
-                const rawRecords = await readLinesByNumber(file, matchingLines);
-                for (const raw of rawRecords) {
-                    const evaluation = normalizeEvaluation(raw);
-                    if (!evaluation)
-                        continue;
-                    if (!applyFilters(evaluation))
-                        continue;
-                    results.push(evaluation);
-                    if (hasReachedLimit(results.length, offset, limit)) {
-                        const paginated = paginateResults(results, offset, limit);
-                        this.evaluationCache.set(cacheKey, paginated);
-                        logTiming();
-                        return paginated;
+        try {
+            for (const file of files) {
+                // Try to use index for pre-filtering
+                const matchingLines = this.tryUseIndex(file, 'evaluations', indexOptions);
+                if (matchingLines !== null) {
+                    // Use indexed query - read only matching lines
+                    const rawRecords = await readLinesByNumber(file, matchingLines);
+                    for (const raw of rawRecords) {
+                        const evaluation = normalizeEvaluation(raw);
+                        if (!evaluation)
+                            continue;
+                        if (!applyFilters(evaluation))
+                            continue;
+                        results.push(evaluation);
+                        if (hasReachedLimit(results.length, offset, limit)) {
+                            const paginated = paginateResults(results, offset, limit);
+                            this.evaluationCache.set(cacheKey, paginated);
+                            this.circuitBreaker.recordSuccess();
+                            logTiming();
+                            return paginated;
+                        }
                     }
                 }
-            }
-            else {
-                // Fall back to full file scan
-                for await (const raw of streamJsonl(file)) {
-                    const evaluation = normalizeEvaluation(raw);
-                    if (!evaluation)
-                        continue;
-                    // Apply indexable filters (since no index was used)
-                    if (options.traceId && evaluation.traceId !== options.traceId)
-                        continue;
-                    if (options.evaluationName && !evaluation.evaluationName.includes(options.evaluationName))
-                        continue;
-                    if (options.scoreLabel && evaluation.scoreLabel !== options.scoreLabel)
-                        continue;
-                    if (options.responseId && evaluation.responseId !== options.responseId)
-                        continue;
-                    if (options.evaluator && evaluation.evaluator !== options.evaluator)
-                        continue;
-                    if (!applyFilters(evaluation))
-                        continue;
-                    results.push(evaluation);
-                    if (hasReachedLimit(results.length, offset, limit)) {
-                        const paginated = paginateResults(results, offset, limit);
-                        this.evaluationCache.set(cacheKey, paginated);
-                        logTiming();
-                        return paginated;
+                else {
+                    // Fall back to full file scan
+                    for await (const raw of streamJsonl(file)) {
+                        const evaluation = normalizeEvaluation(raw);
+                        if (!evaluation)
+                            continue;
+                        // Apply indexable filters (since no index was used)
+                        if (options.traceId && evaluation.traceId !== options.traceId)
+                            continue;
+                        if (options.evaluationName && !evaluation.evaluationName.includes(options.evaluationName))
+                            continue;
+                        if (options.scoreLabel && evaluation.scoreLabel !== options.scoreLabel)
+                            continue;
+                        if (options.responseId && evaluation.responseId !== options.responseId)
+                            continue;
+                        if (options.evaluator && evaluation.evaluator !== options.evaluator)
+                            continue;
+                        if (!applyFilters(evaluation))
+                            continue;
+                        results.push(evaluation);
+                        if (hasReachedLimit(results.length, offset, limit)) {
+                            const paginated = paginateResults(results, offset, limit);
+                            this.evaluationCache.set(cacheKey, paginated);
+                            this.circuitBreaker.recordSuccess();
+                            logTiming();
+                            return paginated;
+                        }
                     }
                 }
             }
+            const paginated = paginateResults(results, offset, limit);
+            this.evaluationCache.set(cacheKey, paginated);
+            this.circuitBreaker.recordSuccess();
+            logTiming();
+            return paginated;
+        }
+        catch (error) {
+            this.circuitBreaker.recordFailure();
+            logTiming();
+            throw error;
         }
-        const paginated = paginateResults(results, offset, limit);
-        this.evaluationCache.set(cacheKey, paginated);
-        logTiming();
-        return paginated;
     }
     async healthCheck() {
+        // Check circuit breaker state
+        if (this.circuitBreaker.getState() === 'open') {
+            return { status: 'error', message: 'Circuit breaker open - file I/O temporarily unavailable' };
+        }
         if (!existsSync(this.telemetryDir)) {
             // Security: sanitize path to prevent information disclosure
             return { status: 'error', message: `Telemetry directory not found: ${sanitizePath(this.telemetryDir)}` };