@geekmidas/telescope 10.0.0-alpha.99 → 10.0.0

package/dist/metrics/MetricsAggregator.mjs

@@ -1,354 +1,3 @@
-//#region src/metrics/MetricsAggregator.ts
-const DEFAULT_OPTIONS = {
-	bucketSize: 6e4,
-	maxBuckets: 1440,
-	maxSamplesPerBucket: 1e3
-};
-var MetricsAggregator = class {
-	options;
-	buckets = /* @__PURE__ */ new Map();
-	endpoints = /* @__PURE__ */ new Map();
-	endpointTimeBuckets = /* @__PURE__ */ new Map();
-	constructor(options = {}) {
-		this.options = {
-			...DEFAULT_OPTIONS,
-			...options
-		};
-	}
-	/**
-	* Record a request for metrics aggregation
-	*/
-	record(entry) {
-		const timestamp = entry.timestamp.getTime();
-		const bucketTs = this.getBucketTimestamp(timestamp);
-		this.updateBucket(bucketTs, entry);
-		this.updateEndpoint(entry);
-		this.pruneBuckets();
-	}
-	/**
-	* Get aggregated request metrics
-	*/
-	getMetrics(options = {}) {
-		const range = options.range ?? this.getDefaultRange();
-		const bucketSize = options.bucketSize ?? this.options.bucketSize;
-		const bucketsInRange = this.getBucketsInRange(range);
-		if (bucketsInRange.length === 0) return this.emptyMetrics();
-		const allDurations = [];
-		let totalRequests = 0;
-		let totalDuration = 0;
-		let totalErrors = 0;
-		for (const bucket of bucketsInRange) {
-			totalRequests += bucket.count;
-			totalDuration += bucket.durationSum;
-			totalErrors += bucket.errorCount;
-			allDurations.push(...bucket.durationSamples);
-		}
-		allDurations.sort((a, b) => a - b);
-		const p50 = this.percentile(allDurations, 50);
-		const p95 = this.percentile(allDurations, 95);
-		const p99 = this.percentile(allDurations, 99);
-		const rangeSeconds = (range.end.getTime() - range.start.getTime()) / 1e3;
-		const avgDuration = totalRequests > 0 ? totalDuration / totalRequests : 0;
-		const errorRate = totalRequests > 0 ? totalErrors / totalRequests * 100 : 0;
-		const timeSeries = this.buildTimeSeries(bucketsInRange, range, bucketSize);
-		return {
-			totalRequests,
-			avgDuration,
-			p50Duration: p50,
-			p95Duration: p95,
-			p99Duration: p99,
-			errorRate,
-			successRate: 100 - errorRate,
-			requestsPerSecond: rangeSeconds > 0 ? totalRequests / rangeSeconds : 0,
-			timeSeries
-		};
-	}
-	/**
-	* Get metrics for individual endpoints
-	*/
-	getEndpointMetrics(options = {}) {
-		const limit = options.limit ?? 50;
-		const results = [];
-		for (const [, bucket] of this.endpoints) {
-			const avgDuration = bucket.count > 0 ? bucket.durationSum / bucket.count : 0;
-			bucket.durationSamples.sort((a, b) => a - b);
-			const p95 = this.percentile(bucket.durationSamples, 95);
-			const errorRate = bucket.count > 0 ? bucket.errorCount / bucket.count * 100 : 0;
-			results.push({
-				method: bucket.method,
-				path: bucket.path,
-				count: bucket.count,
-				avgDuration,
-				p95Duration: p95,
-				errorRate,
-				lastSeen: bucket.lastSeen
-			});
-		}
-		results.sort((a, b) => b.count - a.count);
-		return results.slice(0, limit);
-	}
-	/**
-	* Get status code distribution
-	*/
-	getStatusDistribution(options = {}) {
-		const range = options.range ?? this.getDefaultRange();
-		const bucketsInRange = this.getBucketsInRange(range);
-		const distribution = {
-			"2xx": 0,
-			"3xx": 0,
-			"4xx": 0,
-			"5xx": 0
-		};
-		for (const bucket of bucketsInRange) {
-			distribution["2xx"] += bucket.statusDistribution["2xx"];
-			distribution["3xx"] += bucket.statusDistribution["3xx"];
-			distribution["4xx"] += bucket.statusDistribution["4xx"];
-			distribution["5xx"] += bucket.statusDistribution["5xx"];
-		}
-		return distribution;
-	}
-	/**
-	* Get detailed metrics for a specific endpoint
-	*/
-	getEndpointDetails(method, path, options = {}) {
-		const key = `${method}:${path}`;
-		const endpoint = this.endpoints.get(key);
-		if (!endpoint) return null;
-		const samples = [...endpoint.durationSamples].sort((a, b) => a - b);
-		const p50 = this.percentile(samples, 50);
-		const p95 = this.percentile(samples, 95);
-		const p99 = this.percentile(samples, 99);
-		const avgDuration = endpoint.count > 0 ? endpoint.durationSum / endpoint.count : 0;
-		const errorRate = endpoint.count > 0 ? endpoint.errorCount / endpoint.count * 100 : 0;
-		const endpointBuckets = this.endpointTimeBuckets.get(key);
-		const timeSeries = [];
-		const statusDistribution = {
-			"2xx": 0,
-			"3xx": 0,
-			"4xx": 0,
-			"5xx": 0
-		};
-		if (endpointBuckets) {
-			const range = options.range ?? this.getDefaultRange();
-			const startTs = range.start.getTime();
-			const endTs = range.end.getTime();
-			for (const [ts, bucket] of endpointBuckets) if (ts >= startTs && ts <= endTs) {
-				timeSeries.push({
-					timestamp: bucket.timestamp,
-					count: bucket.count,
-					avgDuration: bucket.count > 0 ? bucket.durationSum / bucket.count : 0,
-					errorCount: bucket.errorCount
-				});
-				statusDistribution["2xx"] += bucket.statusDistribution["2xx"];
-				statusDistribution["3xx"] += bucket.statusDistribution["3xx"];
-				statusDistribution["4xx"] += bucket.statusDistribution["4xx"];
-				statusDistribution["5xx"] += bucket.statusDistribution["5xx"];
-			}
-			timeSeries.sort((a, b) => a.timestamp - b.timestamp);
-		}
-		return {
-			method: endpoint.method,
-			path: endpoint.path,
-			count: endpoint.count,
-			avgDuration,
-			p50Duration: p50,
-			p95Duration: p95,
-			p99Duration: p99,
-			errorRate,
-			successRate: 100 - errorRate,
-			lastSeen: endpoint.lastSeen,
-			statusDistribution,
-			timeSeries
-		};
-	}
-	/**
-	* Reset all metrics
-	*/
-	reset() {
-		this.buckets.clear();
-		this.endpoints.clear();
-		this.endpointTimeBuckets.clear();
-	}
-	getBucketTimestamp(timestamp) {
-		return Math.floor(timestamp / this.options.bucketSize) * this.options.bucketSize;
-	}
-	updateBucket(bucketTs, entry) {
-		let bucket = this.buckets.get(bucketTs);
-		if (!bucket) {
-			bucket = this.createEmptyBucket(bucketTs);
-			this.buckets.set(bucketTs, bucket);
-		}
-		bucket.count++;
-		bucket.durationSum += entry.duration;
-		bucket.durationMin = Math.min(bucket.durationMin, entry.duration);
-		bucket.durationMax = Math.max(bucket.durationMax, entry.duration);
-		if (bucket.durationSamples.length < this.options.maxSamplesPerBucket) bucket.durationSamples.push(entry.duration);
-		else {
-			const idx = Math.floor(Math.random() * bucket.count);
-			if (idx < this.options.maxSamplesPerBucket) bucket.durationSamples[idx] = entry.duration;
-		}
-		if (entry.status >= 400) bucket.errorCount++;
-		if (entry.status >= 200 && entry.status < 300) bucket.statusDistribution["2xx"]++;
-		else if (entry.status >= 300 && entry.status < 400) bucket.statusDistribution["3xx"]++;
-		else if (entry.status >= 400 && entry.status < 500) bucket.statusDistribution["4xx"]++;
-		else if (entry.status >= 500) bucket.statusDistribution["5xx"]++;
-	}
-	updateEndpoint(entry) {
-		const key = `${entry.method}:${entry.path}`;
-		let endpoint = this.endpoints.get(key);
-		if (!endpoint) {
-			endpoint = {
-				method: entry.method,
-				path: entry.path,
-				count: 0,
-				durationSum: 0,
-				durationSamples: [],
-				errorCount: 0,
-				lastSeen: 0
-			};
-			this.endpoints.set(key, endpoint);
-		}
-		endpoint.count++;
-		endpoint.durationSum += entry.duration;
-		endpoint.lastSeen = entry.timestamp.getTime();
-		if (entry.status >= 400) endpoint.errorCount++;
-		if (endpoint.durationSamples.length < this.options.maxSamplesPerBucket) endpoint.durationSamples.push(entry.duration);
-		else {
-			const idx = Math.floor(Math.random() * endpoint.count);
-			if (idx < this.options.maxSamplesPerBucket) endpoint.durationSamples[idx] = entry.duration;
-		}
-		this.updateEndpointTimeBucket(key, entry);
-	}
-	updateEndpointTimeBucket(key, entry) {
-		const timestamp = entry.timestamp.getTime();
-		const bucketTs = this.getBucketTimestamp(timestamp);
-		let endpointBuckets = this.endpointTimeBuckets.get(key);
-		if (!endpointBuckets) {
-			endpointBuckets = /* @__PURE__ */ new Map();
-			this.endpointTimeBuckets.set(key, endpointBuckets);
-		}
-		let bucket = endpointBuckets.get(bucketTs);
-		if (!bucket) {
-			bucket = {
-				timestamp: bucketTs,
-				count: 0,
-				durationSum: 0,
-				errorCount: 0,
-				statusDistribution: {
-					"2xx": 0,
-					"3xx": 0,
-					"4xx": 0,
-					"5xx": 0
-				}
-			};
-			endpointBuckets.set(bucketTs, bucket);
-		}
-		bucket.count++;
-		bucket.durationSum += entry.duration;
-		if (entry.status >= 400) bucket.errorCount++;
-		if (entry.status >= 200 && entry.status < 300) bucket.statusDistribution["2xx"]++;
-		else if (entry.status >= 300 && entry.status < 400) bucket.statusDistribution["3xx"]++;
-		else if (entry.status >= 400 && entry.status < 500) bucket.statusDistribution["4xx"]++;
-		else if (entry.status >= 500) bucket.statusDistribution["5xx"]++;
-		if (endpointBuckets.size > this.options.maxBuckets) {
-			const timestamps = Array.from(endpointBuckets.keys()).sort((a, b) => a - b);
-			const toRemove = timestamps.slice(0, timestamps.length - this.options.maxBuckets);
-			for (const ts of toRemove) endpointBuckets.delete(ts);
-		}
-	}
-	createEmptyBucket(timestamp) {
-		return {
-			timestamp,
-			bucketSize: this.options.bucketSize,
-			count: 0,
-			durationSum: 0,
-			durationMin: Infinity,
-			durationMax: 0,
-			durationSamples: [],
-			errorCount: 0,
-			statusDistribution: {
-				"2xx": 0,
-				"3xx": 0,
-				"4xx": 0,
-				"5xx": 0
-			}
-		};
-	}
-	pruneBuckets() {
-		if (this.buckets.size <= this.options.maxBuckets) return;
-		const timestamps = Array.from(this.buckets.keys()).sort((a, b) => a - b);
-		const toRemove = timestamps.slice(0, timestamps.length - this.options.maxBuckets);
-		for (const ts of toRemove) this.buckets.delete(ts);
-	}
-	getDefaultRange() {
-		const now = /* @__PURE__ */ new Date();
-		return {
-			start: /* @__PURE__ */ new Date(now.getTime() - 36e5),
-			end: now
-		};
-	}
-	getBucketsInRange(range) {
-		const startTs = range.start.getTime();
-		const endTs = range.end.getTime();
-		const results = [];
-		for (const [ts, bucket] of this.buckets) if (ts >= startTs && ts <= endTs) results.push(bucket);
-		return results.sort((a, b) => a.timestamp - b.timestamp);
-	}
-	buildTimeSeries(buckets, _range, targetBucketSize) {
-		if (buckets.length === 0) return [];
-		if (targetBucketSize === this.options.bucketSize) return buckets.map((b) => ({
-			timestamp: b.timestamp,
-			count: b.count,
-			avgDuration: b.count > 0 ? b.durationSum / b.count : 0,
-			errorCount: b.errorCount
-		}));
-		const points = /* @__PURE__ */ new Map();
-		for (const bucket of buckets) {
-			const targetTs = Math.floor(bucket.timestamp / targetBucketSize) * targetBucketSize;
-			let point = points.get(targetTs);
-			if (!point) {
-				point = {
-					timestamp: targetTs,
-					count: 0,
-					avgDuration: 0,
-					errorCount: 0
-				};
-				points.set(targetTs, point);
-			}
-			const totalCount = point.count + bucket.count;
-			if (totalCount > 0) point.avgDuration = (point.avgDuration * point.count + (bucket.count > 0 ? bucket.durationSum / bucket.count : 0) * bucket.count) / totalCount;
-			point.count = totalCount;
-			point.errorCount += bucket.errorCount;
-		}
-		return Array.from(points.values()).sort((a, b) => a.timestamp - b.timestamp);
-	}
-	percentile(sortedValues, p) {
-		if (sortedValues.length === 0) return 0;
-		if (sortedValues.length === 1) return sortedValues[0];
-		const index = p / 100 * (sortedValues.length - 1);
-		const lower = Math.floor(index);
-		const upper = Math.ceil(index);
-		if (lower === upper) return sortedValues[lower];
-		const weight = index - lower;
-		const lowerVal = sortedValues[lower];
-		const upperVal = sortedValues[upper];
-		return lowerVal * (1 - weight) + upperVal * weight;
-	}
-	emptyMetrics() {
-		return {
-			totalRequests: 0,
-			avgDuration: 0,
-			p50Duration: 0,
-			p95Duration: 0,
-			p99Duration: 0,
-			errorRate: 0,
-			successRate: 100,
-			requestsPerSecond: 0,
-			timeSeries: []
-		};
-	}
-};
-//#endregion
-export { MetricsAggregator };
+import { MetricsAggregator } from "../MetricsAggregator-S3DQWNas.mjs";
 
-//# sourceMappingURL=MetricsAggregator.mjs.map
+export { MetricsAggregator };

package/dist/metrics/index.cjs

@@ -1,3 +1,4 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_metrics_MetricsAggregator = require("./MetricsAggregator.cjs");
-exports.MetricsAggregator = require_metrics_MetricsAggregator.MetricsAggregator;
+const require_MetricsAggregator = require('../MetricsAggregator-B7lUICdH.cjs');
+require('../metrics-fhD3l3C3.cjs');
+
+exports.MetricsAggregator = require_MetricsAggregator.MetricsAggregator;

package/dist/metrics/index.d.cts

@@ -1,2 +1,4 @@
-import { n as MetricsAggregatorOptions, t as MetricsAggregator } from "../MetricsAggregator-CnC3oT5q.cjs";
-export { MetricsAggregator, type MetricsAggregatorOptions };
+import "../types-l7Rlb5Mg.cjs";
+import { MetricsAggregator, MetricsAggregatorOptions } from "../MetricsAggregator-4SqelGcG.cjs";
+import "../index-BL32-cvv.cjs";
+export { MetricsAggregator, MetricsAggregatorOptions };

package/dist/metrics/index.d.mts

@@ -1,2 +1,4 @@
-import { n as MetricsAggregatorOptions, t as MetricsAggregator } from "../MetricsAggregator-BJdIvfEv.mjs";
-export { MetricsAggregator, type MetricsAggregatorOptions };
+import "../types-B1EIa_cQ.mjs";
+import { MetricsAggregator, MetricsAggregatorOptions } from "../MetricsAggregator-DZrW8ls6.mjs";
+import "../index-CsuikFeJ.mjs";
+export { MetricsAggregator, MetricsAggregatorOptions };

package/dist/metrics/index.mjs

@@ -1,2 +1,4 @@
-import { MetricsAggregator } from "./MetricsAggregator.mjs";
-export { MetricsAggregator };
+import { MetricsAggregator } from "../MetricsAggregator-S3DQWNas.mjs";
+import "../metrics-D5YT-Rnq.mjs";
+
+export { MetricsAggregator };

package/dist/metrics/storage/InMemoryMetricsStorage.cjs

@@ -1,241 +1,4 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_metrics_storage_types = require("./types.cjs");
-//#region src/metrics/storage/InMemoryMetricsStorage.ts
-/**
-* In-memory metrics storage for development and testing.
-*
-* Features:
-* - Buffered writes with configurable flush interval
-* - Time-bucketed aggregation
-* - Basic percentile calculation (reservoir sampling)
-* - Automatic pruning based on retention
-*
-* Not suitable for production - use a proper time-series database.
-*/
-var InMemoryMetricsStorage = class {
-	config;
-	buffer = [];
-	buckets = /* @__PURE__ */ new Map();
-	samples = /* @__PURE__ */ new Map();
-	flushTimer = null;
-	constructor(config = {}) {
-		this.config = {
-			...require_metrics_storage_types.DEFAULT_METRICS_CONFIG,
-			...config
-		};
-		if (this.config.flushInterval > 0) this.flushTimer = setInterval(() => {
-			this.flush().catch(console.error);
-		}, this.config.flushInterval);
-	}
-	async write(points) {
-		this.buffer.push(...points);
-		if (this.buffer.length >= this.config.maxBatchSize) await this.flush();
-	}
-	async flush() {
-		if (this.buffer.length === 0) return;
-		const points = this.buffer.splice(0);
-		for (const point of points) this.aggregatePoint(point);
-		if (this.config.autoRollup) await this.prune();
-	}
-	aggregatePoint(point) {
-		const bucketTime = this.getBucketTime(point.timestamp, "1m");
-		const key = this.getBucketKey(point, bucketTime);
-		const existing = this.buckets.get(key);
-		if (existing) {
-			existing.count += 1;
-			existing.sum += point.value;
-			existing.min = Math.min(existing.min, point.value);
-			existing.max = Math.max(existing.max, point.value);
-		} else this.buckets.set(key, {
-			bucket: bucketTime,
-			projectId: point.projectId,
-			service: point.service,
-			environment: point.environment,
-			name: point.name,
-			labelsHash: this.hashLabels(point.labels),
-			labels: { ...point.labels },
-			count: 1,
-			sum: point.value,
-			min: point.value,
-			max: point.value
-		});
-		const sampleKey = `${point.projectId}:${point.name}:${bucketTime.getTime()}`;
-		const samples = this.samples.get(sampleKey) ?? [];
-		if (samples.length < 1e3) samples.push(point.value);
-		else {
-			const idx = Math.floor(Math.random() * (samples.length + 1));
-			if (idx < samples.length) samples[idx] = point.value;
-		}
-		this.samples.set(sampleKey, samples);
-	}
-	async query(query) {
-		await this.flush();
-		const results = /* @__PURE__ */ new Map();
-		const startTime = query.range.start.getTime();
-		const endTime = query.range.end.getTime();
-		const interval = query.interval ?? "1m";
-		const intervalMs = this.getIntervalMs(interval);
-		for (const [, bucket] of this.buckets) {
-			if (bucket.projectId !== query.projectId) continue;
-			if (query.service && bucket.service !== query.service) continue;
-			if (query.environment && bucket.environment !== query.environment) continue;
-			if (query.name && !this.matchesPattern(bucket.name, query.name)) continue;
-			if (query.labels && !this.matchesLabels(bucket.labels, query.labels)) continue;
-			const bucketTime = bucket.bucket.getTime();
-			if (bucketTime < startTime || bucketTime > endTime) continue;
-			const groupKey = query.groupBy ? this.getGroupKey(bucket, query.groupBy) : bucket.name;
-			let result = results.get(groupKey);
-			if (!result) {
-				result = {
-					name: bucket.name,
-					labels: query.groupBy ? this.filterLabels(bucket.labels, query.groupBy) : bucket.labels,
-					timeSeries: [],
-					stats: {
-						count: 0,
-						sum: 0,
-						avg: 0,
-						min: Infinity,
-						max: -Infinity,
-						p50: 0,
-						p95: 0,
-						p99: 0
-					}
-				};
-				results.set(groupKey, result);
-			}
-			const tsIndex = Math.floor((bucketTime - startTime) / intervalMs);
-			while (result.timeSeries.length <= tsIndex) result.timeSeries.push({
-				timestamp: new Date(startTime + result.timeSeries.length * intervalMs),
-				count: 0,
-				sum: 0,
-				avg: 0,
-				min: Infinity,
-				max: -Infinity
-			});
-			const tsPoint = result.timeSeries[tsIndex];
-			if (tsPoint) {
-				tsPoint.count += bucket.count;
-				tsPoint.sum += bucket.sum;
-				tsPoint.min = Math.min(tsPoint.min, bucket.min);
-				tsPoint.max = Math.max(tsPoint.max, bucket.max);
-				tsPoint.avg = tsPoint.sum / tsPoint.count;
-			}
-			result.stats.count += bucket.count;
-			result.stats.sum += bucket.sum;
-			result.stats.min = Math.min(result.stats.min, bucket.min);
-			result.stats.max = Math.max(result.stats.max, bucket.max);
-		}
-		for (const result of results.values()) {
-			if (result.stats.count > 0) {
-				result.stats.avg = result.stats.sum / result.stats.count;
-				const allSamples = [];
-				for (const [key, samples] of this.samples) if (key.startsWith(`${query.projectId}:${result.name}:`)) allSamples.push(...samples);
-				if (allSamples.length > 0) {
-					allSamples.sort((a, b) => a - b);
-					result.stats.p50 = this.percentile(allSamples, 50);
-					result.stats.p95 = this.percentile(allSamples, 95);
-					result.stats.p99 = this.percentile(allSamples, 99);
-				}
-			}
-			if (result.stats.min === Infinity) result.stats.min = 0;
-			if (result.stats.max === -Infinity) result.stats.max = 0;
-			for (const point of result.timeSeries) {
-				if (point.min === Infinity) point.min = 0;
-				if (point.max === -Infinity) point.max = 0;
-			}
-		}
-		const resultArray = Array.from(results.values());
-		if (query.limit) return resultArray.slice(0, query.limit);
-		return resultArray;
-	}
-	async getBucket(projectId, name, bucket) {
-		await this.flush();
-		for (const [, b] of this.buckets) if (b.projectId === projectId && b.name === name && b.bucket.getTime() === bucket.getTime()) return b;
-		return null;
-	}
-	async rollup(_options) {
-		return 0;
-	}
-	async prune() {
-		const now = Date.now();
-		let deleted = 0;
-		const retentionMs = Math.min(...this.config.tiers.filter((t) => t.retention > 0).map((t) => t.retention));
-		if (retentionMs === Infinity) return 0;
-		const cutoff = now - retentionMs;
-		for (const [key, bucket] of this.buckets) if (bucket.bucket.getTime() < cutoff) {
-			this.buckets.delete(key);
-			deleted++;
-		}
-		for (const [key] of this.samples) if (parseInt(key.split(":").pop() ?? "0", 10) < cutoff) this.samples.delete(key);
-		return deleted;
-	}
-	async listPartitions(_tier) {
-		return [];
-	}
-	getConfig() {
-		return this.config;
-	}
-	async close() {
-		if (this.flushTimer) {
-			clearInterval(this.flushTimer);
-			this.flushTimer = null;
-		}
-		await this.flush();
-		this.buckets.clear();
-		this.samples.clear();
-	}
-	getBucketTime(timestamp, interval) {
-		const ms = this.getIntervalMs(interval);
-		return new Date(Math.floor(timestamp.getTime() / ms) * ms);
-	}
-	getBucketKey(point, bucketTime) {
-		return [
-			point.projectId,
-			point.service,
-			point.environment,
-			point.name,
-			this.hashLabels(point.labels),
-			bucketTime.getTime()
-		].join(":");
-	}
-	hashLabels(labels) {
-		return Object.keys(labels).sort().map((k) => `${k}=${labels[k]}`).join(",") || "_empty_";
-	}
-	getIntervalMs(interval) {
-		return {
-			"1m": 6e4,
-			"5m": 3e5,
-			"15m": 9e5,
-			"1h": 36e5,
-			"6h": 216e5,
-			"1d": 864e5
-		}[interval];
-	}
-	matchesPattern(name, pattern) {
-		if (!pattern.includes("*")) return name === pattern;
-		return new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`).test(name);
-	}
-	matchesLabels(labels, filter) {
-		for (const [key, value] of Object.entries(filter)) if (labels[key] !== value) return false;
-		return true;
-	}
-	getGroupKey(bucket, groupBy) {
-		const parts = [bucket.name];
-		for (const key of groupBy) parts.push(`${key}=${bucket.labels[key] ?? ""}`);
-		return parts.join(":");
-	}
-	filterLabels(labels, keys) {
-		const result = {};
-		for (const key of keys) if (labels[key] !== void 0) result[key] = labels[key];
-		return result;
-	}
-	percentile(sorted, p) {
-		if (sorted.length === 0) return 0;
-		const index = Math.ceil(p / 100 * sorted.length) - 1;
-		return sorted[Math.max(0, index)] ?? 0;
-	}
-};
-//#endregion
-exports.InMemoryMetricsStorage = InMemoryMetricsStorage;
+require('../../types-ZW-nfWf6.cjs');
+const require_InMemoryMetricsStorage = require('../../InMemoryMetricsStorage-D0njWUSi.cjs');
 
-//# sourceMappingURL=InMemoryMetricsStorage.cjs.map
+exports.InMemoryMetricsStorage = require_InMemoryMetricsStorage.InMemoryMetricsStorage;

package/dist/metrics/storage/InMemoryMetricsStorage.d.cts

@@ -1,43 +1,4 @@
-import { MetricBucket, MetricPoint, MetricQuery, MetricResult, MetricsStorageConfig, PartitionInfo, RollupOptions } from "./types.cjs";
-import { MetricsStorage } from "./MetricsStorage.cjs";
-//#region src/metrics/storage/InMemoryMetricsStorage.d.ts
-/**
- * In-memory metrics storage for development and testing.
- *
- * Features:
- * - Buffered writes with configurable flush interval
- * - Time-bucketed aggregation
- * - Basic percentile calculation (reservoir sampling)
- * - Automatic pruning based on retention
- *
- * Not suitable for production - use a proper time-series database.
- */
-export declare class InMemoryMetricsStorage implements MetricsStorage {
-  private config;
-  private buffer;
-  private buckets;
-  private samples;
-  private flushTimer;
-  constructor(config?: Partial<MetricsStorageConfig>);
-  write(points: MetricPoint[]): Promise<void>;
-  flush(): Promise<void>;
-  private aggregatePoint;
-  query(query: MetricQuery): Promise<MetricResult[]>;
-  getBucket(projectId: string, name: string, bucket: Date): Promise<MetricBucket | null>;
-  rollup(_options: RollupOptions): Promise<number>;
-  prune(): Promise<number>;
-  listPartitions(_tier?: string): Promise<PartitionInfo[]>;
-  getConfig(): MetricsStorageConfig;
-  close(): Promise<void>;
-  private getBucketTime;
-  private getBucketKey;
-  private hashLabels;
-  private getIntervalMs;
-  private matchesPattern;
-  private matchesLabels;
-  private getGroupKey;
-  private filterLabels;
-  private percentile;
-}
-//#endregion
-//# sourceMappingURL=InMemoryMetricsStorage.d.cts.map
+import "../../types-BS3Rx8Sk.cjs";
+import "../../MetricsStorage-B86e4131.cjs";
+import { InMemoryMetricsStorage } from "../../InMemoryMetricsStorage-TvPdZjL0.cjs";
+export { InMemoryMetricsStorage };