predictive-scaler

Predictive Scaler

Analyze resource usage patterns and predict future scaling needs.

When to Use

Usage

const scaler = require('./skills/predictive-scaler');
// Basic prediction
const prediction = scaler.predict(cpuHistory, {
  horizon: 60,  // Predict 60 minutes ahead
  scaleUpThreshold: 0.8,
  scaleDownThreshold: 0.3
});
console.log(prediction.recommendation);
// { action: 'scale_up', reason: 'Predicted peak 0.85 exceeds threshold 0.8' }

API

predict(data, options)

Predict future resource usage and generate scaling recommendation.

const result = scaler.predict(usageData, {
  horizon: 60,              // Prediction horizon in minutes
  minDataPoints: 5,         // Minimum data points needed
  scaleUpThreshold: 0.8,    // Threshold to recommend scale-up
  scaleDownThreshold: 0.3,  // Threshold to recommend scale-down
  confidenceThreshold: 0.7, // Minimum confidence for recommendations
  smoothingFactor: 0.3,     // Exponential smoothing factor
  windowSize: 10            // Moving average window
});

predictMulti(resources, options)

Predict for multiple resources at once.

const result = scaler.predictMulti({
  cpu: cpuHistory,
  memory: memoryHistory,
  requests: requestHistory
});
console.log(result.combinedRecommendation);
// { action: 'scale_up', scaleUpCount: 1, scaleDownCount: 0 }

predictLinear(data, steps)

Predict using linear regression.

const { predictions, confidence } = scaler.predictLinear(data, 10);

predictExponential(data, steps, factor)

Predict using exponential smoothing.

const { predictions, confidence } = scaler.predictExponential(data, 10, 0.3);

detectTrend(data)

Detect trend direction in data.

const trend = scaler.detectTrend(data);
// 'increasing' | 'decreasing' | 'stable' | 'volatile'

detectBurstyPattern(data)

Detect bursty traffic patterns.

const bursty = scaler.detectBurstyPattern(data);
// { isBursty: true, burstFactor: 0.6, spikeRatio: 0.15 }

calculateCapacityNeeded(current, predicted, targetUtilization)

Calculate capacity needed to handle predicted load.

const capacity = scaler.calculateCapacityNeeded(10, 8.5, 0.7);
// { current: 10, needed: 13, change: 3, changePercent: 30 }

analyzeScalingHistory(events)

Analyze historical scaling events.

const analysis = scaler.analyzeScalingHistory(scalingEvents);
// { scaleUpFrequency: 0.3, averageInterval: 3600000 }

Output Structure

{
  predictions: [0.65, 0.68, 0.72, ...],  // Predicted values
  confidence: 0.85,                       // Prediction confidence
  trend: 'increasing',                    // Trend direction
  bursty: {
    isBursty: false,
    burstFactor: 0.2
  },
  recommendation: {
    action: 'scale_up',                   // 'scale_up' | 'scale_down' | 'maintain'
    reason: 'Predicted peak 0.85 exceeds threshold 0.8',
    current: 0.72,
    predicted: { average: 0.78, max: 0.85, min: 0.70 }
  },
  statistics: {
    mean: 0.65,
    stdDev: 0.1,
    min: 0.45,
    max: 0.82,
    dataPoints: 30
  }
}

Scaling Actions

| Action | Description | |--------|-------------| | scale_up | Resource predicted to exceed scale-up threshold | | scale_down | Resource predicted below scale-down threshold | | maintain | Resource within normal range | | unknown | Insufficient data or error |

Examples

Basic Scaling Prediction

const scaler = require('./skills/predictive-scaler');
// CPU usage history (0-1 normalized)
const cpuHistory = [0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.72, 0.75, 0.78];
const prediction = scaler.predict(cpuHistory, {
  horizon: 30,
  scaleUpThreshold: 0.8
});
if (prediction.recommendation.action === 'scale_up') {
  console.log('Scale up recommended:', prediction.recommendation.reason);
}

Multi-Resource Prediction

const scaler = require('./skills/predictive-scaler');
const resources = {
  cpu: [0.5, 0.55, 0.6, 0.65, 0.7],
  memory: [0.3, 0.32, 0.35, 0.38, 0.4],
  requests: [100, 120, 150, 180, 200]
};
const result = scaler.predictMulti(resources, { horizon: 60 });
console.log('CPU:', result.resources.cpu.recommendation.action);
console.log('Memory:', result.resources.memory.recommendation.action);
console.log('Combined:', result.combinedRecommendation.action);

Trend Analysis

const scaler = require('./skills/predictive-scaler');
const usageData = [0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6];
const trend = scaler.detectTrend(usageData);
console.log('Trend:', trend); // 'increasing'
const bursty = scaler.detectBurstyPattern(usageData);
console.log('Bursty:', bursty.isBursty); // false

Capacity Planning

const scaler = require('./skills/predictive-scaler');
const prediction = scaler.predict(cpuHistory, { horizon: 60 });
const predictedLoad = prediction.predictions[prediction.predictions.length - 1];
const capacity = scaler.calculateCapacityNeeded(
  10,              // Current capacity (instances)
  predictedLoad,   // Predicted load
  0.7              // Target utilization
);
console.log(Need ${capacity.needed} instances (${capacity.changePercent}% change));

Scaling History Analysis

const scaler = require('./skills/predictive-scaler');
const scalingEvents = [
  { action: 'scale_up', timestamp: Date.now() - 3600000 },
  { action: 'scale_down', timestamp: Date.now() - 1800000 },
  { action: 'scale_up', timestamp: Date.now() }
];
const analysis = scaler.analyzeScalingHistory(scalingEvents);
console.log('Scale-up frequency:', analysis.scaleUpFrequency);
console.log('Average interval:', analysis.averageInterval, 'ms');

Prediction Methods

Linear Regression

Exponential Smoothing

Combined Prediction

Best Practices

1. Minimum data points: Use at least 10-15 data points for reliable predictions 2. Normalize data: Input should be 0-1 range (CPU%, memory%, etc.) 3. Set appropriate thresholds: Scale-up at 80%, scale-down at 30% is typical 4. Consider bursty patterns: Lower confidence for highly variable data 5. Combine with cooldown: Don't scale too frequently based on predictions 6. Validate predictions: Compare predictions with actual values over time

Notes

Basic Scaling Prediction

const scaler = require('./skills/predictive-scaler');
// CPU usage history (0-1 normalized)
const cpuHistory = [0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.72, 0.75, 0.78];
const prediction = scaler.predict(cpuHistory, {
  horizon: 30,
  scaleUpThreshold: 0.8
});
if (prediction.recommendation.action === 'scale_up') {
  console.log('Scale up recommended:', prediction.recommendation.reason);
}

Multi-Resource Prediction

const scaler = require('./skills/predictive-scaler');
const resources = {
  cpu: [0.5, 0.55, 0.6, 0.65, 0.7],
  memory: [0.3, 0.32, 0.35, 0.38, 0.4],
  requests: [100, 120, 150, 180, 200]
};
const result = scaler.predictMulti(resources, { horizon: 60 });
console.log('CPU:', result.resources.cpu.recommendation.action);
console.log('Memory:', result.resources.memory.recommendation.action);
console.log('Combined:', result.combinedRecommendation.action);

Trend Analysis

const scaler = require('./skills/predictive-scaler');
const usageData = [0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6];
const trend = scaler.detectTrend(usageData);
console.log('Trend:', trend); // 'increasing'
const bursty = scaler.detectBurstyPattern(usageData);
console.log('Bursty:', bursty.isBursty); // false

Capacity Planning

const scaler = require('./skills/predictive-scaler');
const prediction = scaler.predict(cpuHistory, { horizon: 60 });
const predictedLoad = prediction.predictions[prediction.predictions.length - 1];
const capacity = scaler.calculateCapacityNeeded(
  10,              // Current capacity (instances)
  predictedLoad,   // Predicted load
  0.7              // Target utilization
);
console.log(Need ${capacity.needed} instances (${capacity.changePercent}% change));

Scaling History Analysis

const scaler = require('./skills/predictive-scaler');
const scalingEvents = [
  { action: 'scale_up', timestamp: Date.now() - 3600000 },
  { action: 'scale_down', timestamp: Date.now() - 1800000 },
  { action: 'scale_up', timestamp: Date.now() }
];
const analysis = scaler.analyzeScalingHistory(scalingEvents);
console.log('Scale-up frequency:', analysis.scaleUpFrequency);
console.log('Average interval:', analysis.averageInterval, 'ms');

1. Minimum data points: Use at least 10-15 data points for reliable predictions 2. Normalize data: Input should be 0-1 range (CPU%, memory%, etc.) 3. Set appropriate thresholds: Scale-up at 80%, scale-down at 30% is typical 4. Consider bursty patterns: Lower confidence for highly variable data 5. Combine with cooldown: Don't scale too frequently based on predictions 6. Validate predictions: Compare predictions with actual values over time