@hazeljs/predictive-scaling 2.0.5

package/dist/metrics/prometheus-collector.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrometheusMetricsCollector = void 0;
+exports.createPrometheusMetricsCollector = createPrometheusMetricsCollector;
+/**
+ * Polls Prometheus and ingests scalar query results into a callback.
+ */
+class PrometheusMetricsCollector {
+    constructor(config, onSample) {
+        this.config = config;
+        this.onSample = onSample;
+        this.interval = null;
+    }
+    async pollOnce() {
+        const results = [];
+        for (const [metric, query] of Object.entries(this.config.queries)) {
+            if (!query) {
+                continue;
+            }
+            const sample = await this.queryMetric(metric, query);
+            if (sample) {
+                this.onSample(sample);
+                results.push(sample);
+            }
+        }
+        return results;
+    }
+    start() {
+        if (this.interval) {
+            return;
+        }
+        const pollIntervalMs = this.config.pollIntervalMs ?? 60000;
+        this.interval = setInterval(() => {
+            void this.pollOnce();
+        }, pollIntervalMs);
+        if (typeof this.interval.unref === 'function') {
+            this.interval.unref();
+        }
+        void this.pollOnce();
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    async queryMetric(metric, query) {
+        const fetchImpl = this.config.fetchImpl ?? fetch;
+        const baseUrl = this.config.baseUrl.replace(/\/$/, '');
+        const url = `${baseUrl}/api/v1/query?query=${encodeURIComponent(query)}`;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs ?? 10000);
+        try {
+            const response = await fetchImpl(url, { signal: controller.signal });
+            if (!response.ok) {
+                return null;
+            }
+            const body = (await response.json());
+            const valueTuple = body.data?.result?.[0]?.value;
+            if (!valueTuple) {
+                return null;
+            }
+            const [timestampSeconds, valueText] = valueTuple;
+            const value = Number(valueText);
+            if (!Number.isFinite(value)) {
+                return null;
+            }
+            return {
+                metric,
+                value,
+                timestamp: Math.floor(timestampSeconds * 1000),
+            };
+        }
+        catch {
+            return null;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+exports.PrometheusMetricsCollector = PrometheusMetricsCollector;
+function createPrometheusMetricsCollector(config, onSample) {
+    return new PrometheusMetricsCollector(config, onSample);
+}

package/dist/scaling/predictive-scaler.d.ts

@@ -0,0 +1,24 @@
+import { MetricsStore } from '../metrics/metrics-store';
+import { MetricName, PredictiveScalingOptions, ScalingDecision, ScalingEvent } from '../types';
+/**
+ * Orchestrates metric collection, forecasting, and proactive HPA adjustments.
+ */
+export declare class PredictiveScaler {
+    private readonly store;
+    private readonly forecastEngine;
+    private readonly options;
+    private interval;
+    private lastDecision;
+    constructor(options: PredictiveScalingOptions);
+    recordMetric(metric: MetricName, value: number, timestamp?: number): void;
+    getMetricsStore(): MetricsStore;
+    evaluate(): Promise<ScalingDecision>;
+    applyDecision(decision: ScalingDecision): Promise<ScalingEvent>;
+    runCycle(): Promise<ScalingEvent>;
+    triggerEvent(eventName: string): Promise<ScalingEvent[]>;
+    start(): void;
+    stop(): void;
+    getLastDecision(): ScalingDecision | null;
+}
+export declare function createPredictiveScaler(options: PredictiveScalingOptions): PredictiveScaler;
+//# sourceMappingURL=predictive-scaler.d.ts.map

package/dist/scaling/predictive-scaler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predictive-scaler.d.ts","sourceRoot":"","sources":["../../src/scaling/predictive-scaler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAOxD,OAAO,EAAE,UAAU,EAAE,wBAAwB,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG/F;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;IAC5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAMG;IAC3B,OAAO,CAAC,QAAQ,CAA+C;IAC/D,OAAO,CAAC,YAAY,CAAgC;gBAExC,OAAO,EAAE,wBAAwB;IAe7C,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAIzE,eAAe,IAAI,YAAY;IAIzB,QAAQ,IAAI,OAAO,CAAC,eAAe,CAAC;IAyCpC,aAAa,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC;IA8B/D,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC;IAKjC,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IA4B9D,KAAK,IAAI,IAAI;IAcb,IAAI,IAAI,IAAI;IAOZ,eAAe,IAAI,eAAe,GAAG,IAAI;CAG1C;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,wBAAwB,GAAG,gBAAgB,CAE1F"}

package/dist/scaling/predictive-scaler.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictiveScaler = void 0;
+exports.createPredictiveScaler = createPredictiveScaler;
+const metrics_store_1 = require("../metrics/metrics-store");
+const ai_forecast_provider_1 = require("../forecast/ai-forecast-provider");
+const replica_calculator_1 = require("../scaling/replica-calculator");
+const event_scaling_registry_1 = require("../events/event-scaling-registry");
+const duration_1 = require("../utils/duration");
+/**
+ * Orchestrates metric collection, forecasting, and proactive HPA adjustments.
+ */
+class PredictiveScaler {
+    constructor(options) {
+        this.store = new metrics_store_1.MetricsStore();
+        this.interval = null;
+        this.lastDecision = null;
+        this.options = {
+            model: 'time-series-forecast',
+            metrics: ['requests'],
+            horizon: '30m',
+            confidence: 0.85,
+            costOptimization: true,
+            pollIntervalMs: 60000,
+            capacityPerReplica: 100,
+            ...options,
+        };
+        this.forecastEngine = new ai_forecast_provider_1.ForecastEngine(this.options.model, this.options.forecastProvider);
+    }
+    recordMetric(metric, value, timestamp) {
+        this.store.record(metric, value, timestamp);
+    }
+    getMetricsStore() {
+        return this.store;
+    }
+    async evaluate() {
+        const horizonMs = (0, duration_1.parseDuration)(this.options.horizon ?? '30m');
+        const forecasts = await Promise.all(this.options.metrics.map(async (metric) => {
+            const samples = this.store.getSamples(metric);
+            return this.forecastEngine.forecast(metric, samples, horizonMs);
+        }));
+        const predictedLoad = Math.max(...forecasts.map((forecast) => forecast.predictedValue), 0);
+        const confidence = forecasts.reduce((sum, forecast) => sum + forecast.confidence, 0) /
+            Math.max(1, forecasts.length);
+        const primaryForecast = forecasts[0];
+        const hpa = this.options.hpa;
+        const namespace = hpa.namespace ?? 'default';
+        const currentReplicas = await hpa.client.getHpaMinReplicas(hpa.name, namespace);
+        const maxReplicas = hpa.maxReplicas ?? 100;
+        const minReplicas = hpa.minReplicasFloor ?? 1;
+        const decision = (0, replica_calculator_1.decideScaling)({
+            currentReplicas,
+            predictedLoad,
+            capacityPerReplica: this.options.capacityPerReplica,
+            maxReplicas,
+            minReplicas,
+            confidence,
+            forecast: primaryForecast,
+        }, {
+            enabled: this.options.costOptimization,
+            minConfidence: this.options.confidence,
+        });
+        this.lastDecision = decision;
+        return decision;
+    }
+    async applyDecision(decision) {
+        const hpa = this.options.hpa;
+        const namespace = hpa.namespace ?? 'default';
+        const currentReplicas = await hpa.client.getHpaMinReplicas(hpa.name, namespace);
+        if (decision.action === 'hold' || decision.targetReplicas === currentReplicas) {
+            const event = {
+                type: 'no-op',
+                fromReplicas: currentReplicas,
+                toReplicas: currentReplicas,
+                reason: decision.reason,
+                forecast: decision.forecast,
+            };
+            this.options.onScale?.(event);
+            return event;
+        }
+        await hpa.client.setHpaMinReplicas(hpa.name, namespace, decision.targetReplicas);
+        const event = {
+            type: decision.action,
+            fromReplicas: currentReplicas,
+            toReplicas: decision.targetReplicas,
+            reason: decision.reason,
+            forecast: decision.forecast,
+        };
+        this.options.onScale?.(event);
+        return event;
+    }
+    async runCycle() {
+        const decision = await this.evaluate();
+        return this.applyDecision(decision);
+    }
+    async triggerEvent(eventName) {
+        const matches = event_scaling_registry_1.EventScalingRegistry.findMatching(eventName);
+        const results = [];
+        for (const match of matches) {
+            const hpa = this.options.hpa;
+            const namespace = hpa.namespace ?? 'default';
+            const current = await hpa.client.getHpaMinReplicas(hpa.name, namespace);
+            const target = (0, event_scaling_registry_1.calculateEventBoostReplicas)(current, match);
+            if (target > current) {
+                await hpa.client.setHpaMinReplicas(hpa.name, namespace, target);
+            }
+            const event = {
+                type: 'event-boost',
+                fromReplicas: current,
+                toReplicas: target,
+                reason: `Event trigger: ${eventName}`,
+                event: eventName,
+            };
+            this.options.onScale?.(event);
+            results.push(event);
+        }
+        return results;
+    }
+    start() {
+        if (this.interval) {
+            return;
+        }
+        this.interval = setInterval(() => {
+            void this.runCycle();
+        }, this.options.pollIntervalMs);
+        if (typeof this.interval.unref === 'function') {
+            this.interval.unref();
+        }
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    getLastDecision() {
+        return this.lastDecision;
+    }
+}
+exports.PredictiveScaler = PredictiveScaler;
+function createPredictiveScaler(options) {
+    return new PredictiveScaler(options);
+}

package/dist/scaling/replica-calculator.d.ts

@@ -0,0 +1,13 @@
+import { CostOptimizationOptions, ForecastResult, ScalingDecision } from '../types';
+export interface ReplicaCalculationInput {
+    currentReplicas: number;
+    predictedLoad: number;
+    capacityPerReplica: number;
+    maxReplicas: number;
+    minReplicas: number;
+    confidence: number;
+    forecast?: ForecastResult;
+}
+export declare function calculateTargetReplicas(input: ReplicaCalculationInput): number;
+export declare function decideScaling(input: ReplicaCalculationInput, cost?: CostOptimizationOptions): ScalingDecision;
+//# sourceMappingURL=replica-calculator.d.ts.map

package/dist/scaling/replica-calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replica-calculator.d.ts","sourceRoot":"","sources":["../../src/scaling/replica-calculator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGpF,MAAM,WAAW,uBAAuB;IACtC,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,uBAAuB,GAAG,MAAM,CAG9E;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,uBAAuB,EAC9B,IAAI,GAAE,uBAA4B,GACjC,eAAe,CAqDjB"}

package/dist/scaling/replica-calculator.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateTargetReplicas = calculateTargetReplicas;
+exports.decideScaling = decideScaling;
+const duration_1 = require("../utils/duration");
+function calculateTargetReplicas(input) {
+    const needed = Math.ceil(input.predictedLoad / Math.max(1, input.capacityPerReplica));
+    return (0, duration_1.clamp)(needed, input.minReplicas, input.maxReplicas);
+}
+function decideScaling(input, cost = {}) {
+    const enabled = cost.enabled ?? true;
+    const minConfidence = cost.minConfidence ?? 0.7;
+    const headroom = cost.scaleUpHeadroom ?? 1.2;
+    const maxScaleDown = cost.maxScaleDownPerCycle ?? 1;
+    const targetReplicas = calculateTargetReplicas(input);
+    if (enabled && input.confidence < minConfidence) {
+        return {
+            action: 'hold',
+            targetReplicas: input.currentReplicas,
+            reason: `Confidence ${input.confidence.toFixed(2)} below threshold ${minConfidence}`,
+            confidence: input.confidence,
+            forecast: input.forecast,
+        };
+    }
+    const predictedThreshold = input.currentReplicas * input.capacityPerReplica * headroom;
+    if (input.predictedLoad > predictedThreshold && targetReplicas > input.currentReplicas) {
+        return {
+            action: 'scale-up',
+            targetReplicas,
+            reason: `Predicted load ${input.predictedLoad.toFixed(1)} exceeds headroom`,
+            confidence: input.confidence,
+            forecast: input.forecast,
+        };
+    }
+    if (targetReplicas < input.currentReplicas) {
+        const gradualTarget = enabled
+            ? Math.max(targetReplicas, input.currentReplicas - maxScaleDown)
+            : targetReplicas;
+        if (gradualTarget < input.currentReplicas) {
+            return {
+                action: 'scale-down',
+                targetReplicas: gradualTarget,
+                reason: 'Predicted load decreased',
+                confidence: input.confidence,
+                forecast: input.forecast,
+            };
+        }
+    }
+    return {
+        action: 'hold',
+        targetReplicas: input.currentReplicas,
+        reason: 'Within optimal range',
+        confidence: input.confidence,
+        forecast: input.forecast,
+    };
+}

package/dist/types/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Types for @hazeljs/predictive-scaling
+ */
+export type MetricName = 'cpu' | 'memory' | 'requests' | 'latency' | string;
+export type ForecastModel = 'exponential-smoothing' | 'seasonal-pattern' | 'ai' | 'time-series-forecast';
+export interface MetricSample {
+    metric: MetricName;
+    value: number;
+    timestamp: number;
+}
+export interface ForecastResult {
+    metric: MetricName;
+    predictedValue: number;
+    confidence: number;
+    horizonMs: number;
+    model: ForecastModel;
+    at: number;
+}
+export interface KubernetesScalingClient {
+    getHpaMinReplicas(hpa: string, namespace: string): Promise<number>;
+    setHpaMinReplicas(hpa: string, namespace: string, minReplicas: number): Promise<void>;
+}
+export interface HpaTargetConfig {
+    name: string;
+    namespace?: string;
+    client: KubernetesScalingClient;
+    maxReplicas?: number;
+    minReplicasFloor?: number;
+}
+export interface ScaleUpPolicy {
+    before?: string | number;
+    factor?: number;
+}
+export interface ScaleDownPolicy {
+    after?: string | number;
+    gradual?: boolean;
+}
+export interface PredictiveScalingOptions {
+    model?: ForecastModel;
+    metrics?: MetricName[];
+    horizon?: string | number;
+    confidence?: number;
+    costOptimization?: boolean;
+    pollIntervalMs?: number;
+    capacityPerReplica?: number;
+    hpa: HpaTargetConfig;
+    onScale?: (event: ScalingEvent) => void;
+    forecastProvider?: ForecastProvider;
+}
+export interface ScalePredictOptions {
+    triggers?: string[];
+    scaleUp?: ScaleUpPolicy;
+    scaleDown?: ScaleDownPolicy;
+    name?: string;
+}
+export interface ScaleOnEventOptions {
+    events: string[];
+    prediction?: 'historical-pattern' | 'manual';
+    maxScale?: number;
+    scaleFactor?: number;
+}
+export interface ScalingEvent {
+    type: 'scale-up' | 'scale-down' | 'no-op' | 'event-boost';
+    fromReplicas: number;
+    toReplicas: number;
+    reason: string;
+    forecast?: ForecastResult;
+    event?: string;
+}
+export interface ScalingDecision {
+    action: 'scale-up' | 'scale-down' | 'hold';
+    targetReplicas: number;
+    reason: string;
+    confidence: number;
+    forecast?: ForecastResult;
+}
+export interface ForecastProvider {
+    forecast(metric: MetricName, samples: MetricSample[], horizonMs: number): Promise<ForecastResult | null>;
+}
+export interface CostOptimizationOptions {
+    enabled?: boolean;
+    minConfidence?: number;
+    scaleUpHeadroom?: number;
+    maxScaleDownPerCycle?: number;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/dist/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Types for @hazeljs/predictive-scaling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/duration.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parse durations like "30m", "15m", "1h", or raw milliseconds.
+ */
+export declare function parseDuration(value: string | number): number;
+export declare function clamp(value: number, min: number, max: number): number;
+//# sourceMappingURL=duration.d.ts.map

package/dist/utils/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../src/utils/duration.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAqB5D;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE"}

package/dist/utils/duration.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDuration = parseDuration;
+exports.clamp = clamp;
+/**
+ * Parse durations like "30m", "15m", "1h", or raw milliseconds.
+ */
+function parseDuration(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    const match = value.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/i);
+    if (!match) {
+        throw new Error(`Invalid duration: ${value}`);
+    }
+    const amount = Number(match[1]);
+    const unit = (match[2] ?? 'ms').toLowerCase();
+    const multipliers = {
+        ms: 1,
+        s: 1000,
+        m: 60000,
+        h: 3600000,
+    };
+    return Math.floor(amount * multipliers[unit]);
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@hazeljs/predictive-scaling",
+  "version": "2.0.5",
+  "description": "Predictive auto-scaling for HazelJS - traffic forecasting, proactive HPA adjustments, and event-driven scaling",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --coverage --passWithNoTests",
+    "test:ci": "jest --coverage --coverageReporters=text --coverageReporters=lcov --coverageReporters=clover --no-coverage-threshold",
+    "test:watch": "jest --watch",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "reflect-metadata": "^0.2.2"
+  },
+  "peerDependencies": {
+    "@hazeljs/core": "^2.0.5",
+    "@hazeljs/self-healing": "^2.0.5",
+    "@hazeljs/ai": "^2.0.5"
+  },
+  "peerDependenciesMeta": {
+    "@hazeljs/self-healing": {
+      "optional": true
+    },
+    "@hazeljs/ai": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@hazeljs/core": "^2.0.5",
+    "@hazeljs/self-healing": "^2.0.5",
+    "@hazeljs/ai": "^2.0.5",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.19.39",
+    "@typescript-eslint/eslint-plugin": "^8.58.0",
+    "@typescript-eslint/parser": "^8.58.0",
+    "eslint": "^8.57.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.9",
+    "typescript": "^6.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hazel-js/hazeljs",
+    "directory": "packages/predictive-scaling"
+  },
+  "keywords": [
+    "hazeljs",
+    "predictive-scaling",
+    "hpa",
+    "kubernetes",
+    "autoscaling",
+    "forecasting",
+    "microservices"
+  ],
+  "author": "Muhammad Arslan <muhammad.arslan@hazeljs.ai>",
+  "license": "Apache-2.0",
+  "homepage": "https://hazeljs.ai"
+}