الـ SLI والـ SLO والـ Error Budget: إمتى تصحّي الـ on-call وإمتى تسيبه نايم

// naive.js: الطريقة اللي أغلب الناس بيبدأوا بيها
import { rows, sample } from "./traffic.js";

const avg = sample.reduce((a, b) => a + b, 0) / sample.length;
console.log(`متوسط الـ latency: ${avg.toFixed(0)}ms ← "الـ app سريع"`);

const total = rows.reduce((a, r) => a + r.total, 0);
const errors = rows.reduce((a, r) => a + r.errors, 0);
console.log(`errors في الشهر: ${errors} من ${total} ← "ده كتير ولا قليل؟ مش عارفين"`);

// alert: لو أي دقيقة الـ error rate فيها فوق واحد في المية ← صحّي الـ on-call
let pages = 0;
for (const r of rows) if (r.errors / r.total > 0.01) pages++;
console.log(`الـ on-call صحي ${pages} مرة في الشهر`);

$ node naive.js
متوسط الـ latency: 78ms ← "الـ app سريع"
errors في الشهر: 30986 من 36709996 ← "ده كتير ولا قليل؟ مش عارفين"
الـ on-call صحي 100 مرة في الشهر

// slo.js: SLIs و SLOs و error budget و burn-rate alerts

// nearest-rank: الـ p99 هو القيمة اللي تسعة وتسعين في المية من الـ samples أقل منها أو بتساويها
export function percentile(values, p) {
  if (!values.length) return NaN;
  const sorted = [...values].sort((a, b) => a - b);
  const rank = Math.ceil((p / 100) * sorted.length);
  return sorted[Math.min(sorted.length, Math.max(1, rank)) - 1];
}

const sum = (rows, k) => rows.reduce((a, r) => a + r[k], 0);

// SLI = الكويس على الكل. فاضي ← واحد (مفيش requests وحشة)
export function sli(rows) {
  const total = sum(rows, "total");
  if (!total) return { availability: 1, latency: 1 };
  return { availability: 1 - sum(rows, "errors") / total, latency: 1 - sum(rows, "slow") / total };
}

// الـ budget = الوحش المسموح بيه في الفترة كلها
export function errorBudget(rows, slo) {
  const total = sum(rows, "total");
  const allowed = Math.floor(total * (1 - slo));
  const bad = sum(rows, "errors");
  const consumed = allowed ? bad / allowed : bad ? Infinity : 0;
  return { total, allowed, bad, consumed, remaining: 1 - consumed };
}

// burn rate = سرعة استهلاك الـ budget. واحد = هيخلص بالضبط في آخر الشهر
export function burnRate(rows, slo, endMinute, windowMin) {
  const w = rows.slice(Math.max(0, endMinute - windowMin), endMinute);
  const total = sum(w, "total");
  if (!total) return 0;
  return sum(w, "errors") / total / (1 - slo);
}

// multi-window multi-burn-rate (من كتاب Google SRE):
// page: ساعة بـ burn rate فوق أربعتاشر واتنين من عشرة، وآخر خمس دقايق كمان (يعني لسه شغّال)
// ticket: ست ساعات فوق واحد، وآخر نص ساعة كمان
export function alertsAt(rows, slo, minute) {
  const br = (w) => burnRate(rows, slo, minute, w);
  return {
    page: br(60) > 14.4 && br(5) > 14.4,
    ticket: br(360) > 1 && br(30) > 1,
  };
}

$ node main.js
١) latency لـ ألف request:
   المتوسط 78ms | p50 50ms | p95 79ms | p99 1393ms

٢) SLIs على تلاتين يوم:
   availability 99.916% | أسرع من تلتمية ms 99.549%

٣) SLO 99.9%: الـ budget 36709 request وحش، استهلكنا 30986 (84%)، فاضل 16%

٤) الـ alerts:
   ساذج (error rate فوق واحد في المية في دقيقة): 100 مرة صحّينا حد
   burn rate page: 1 مرة، في الساعات: يوم 20 الساعة 14
   burn rate ticket: في الأيام 20، 25، 26، 27، 28

// main.js: الشهر ده كان كويس ولا وحش؟ وكام مرة صحّينا الـ on-call؟
import { rows, sample, DAY } from "./traffic.js";
import { percentile, sli, errorBudget, burnRate, alertsAt } from "./slo.js";

const avg = sample.reduce((a, b) => a + b, 0) / sample.length;
console.log("١) latency لـ ألف request:");
console.log(`   المتوسط ${avg.toFixed(0)}ms | p50 ${percentile(sample, 50).toFixed(0)}ms | p95 ${percentile(sample, 95).toFixed(0)}ms | p99 ${percentile(sample, 99).toFixed(0)}ms`);

const s = sli(rows);
console.log("\n٢) SLIs على تلاتين يوم:");
console.log(`   availability ${(s.availability * 100).toFixed(3)}% | أسرع من تلتمية ms ${(s.latency * 100).toFixed(3)}%`);

const SLO = 0.999;
const b = errorBudget(rows, SLO);
console.log(`\n٣) SLO ${SLO * 100}%: الـ budget ${b.allowed} request وحش، استهلكنا ${b.bad} (${(b.consumed * 100).toFixed(0)}%)، فاضل ${(b.remaining * 100).toFixed(0)}%`);

// alert ساذج: error rate أكبر من واحد في المية في آخر دقيقة
let naive = 0;
for (const r of rows) if (r.errors / r.total > 0.01) naive++;
// burn-rate alerts: بنشيك كل خمس دقايق (زي Prometheus)
const pages = new Set(), tickets = new Set();
for (let m = 60; m < rows.length; m += 5) {
  const a = alertsAt(rows, SLO, m);
  if (a.page) pages.add(Math.floor(m / 60)); // ساعة واحدة = إنذار واحد
  if (a.ticket) tickets.add(Math.floor(m / DAY));
}
console.log(`\n٤) الـ alerts:`);
console.log(`   ساذج (error rate فوق واحد في المية في دقيقة): ${naive} مرة صحّينا حد`);
console.log(`   burn rate page: ${pages.size} مرة، في الساعات: ${[...pages].map((h) => `يوم ${Math.floor(h / 24) + 1} الساعة ${h % 24}`).join("، ")}`);
console.log(`   burn rate ticket: في الأيام ${[...tickets].map((d) => d + 1).join("، ")}`);

// traffic.js: تلاتين يوم traffic متسجّلين دقيقة بدقيقة (أرقام ثابتة بـ seed، فكل مرة نفس النتيجة)
// كل دقيقة: { minute, total, errors, slow } ← errors = 5xx، و slow = أبطأ من تلتمية ms
let seed = 42;
const rand = () => ((seed = (seed * 1103515245 + 12345) % 2147483648) / 2147483648);

export const DAY = 24 * 60;
export const rows = [];
for (let m = 0; m < 30 * DAY; m++) {
  const hour = (m % DAY) / 60;
  const total = Math.round(800 + 600 * Math.sin(((hour - 8) / 24) * 2 * Math.PI) + rand() * 100);
  let errRate = 0.0003, slowRate = 0.004;
  if (rand() < 0.0008) errRate = 0.03; // blip: دقيقة واحدة وحشة كل كام ساعة (deploy، أو GC، أو retry storm صغير)
  if (m >= 19 * DAY + 14 * 60 && m < 19 * DAY + 14 * 60 + 40) errRate = 0.2; // incident: اليوم العشرين، أربعين دقيقة
  if (m >= 24 * DAY && m < 27 * DAY) errRate = 0.004; // slow burn: تلات أيام بـ error rate عالي شوية
  if (m >= 10 * DAY + 9 * 60 && m < 10 * DAY + 11 * 60) slowRate = 0.15; // database بطيئة ساعتين
  const errors = Math.round(total * errRate * (0.5 + rand()));
  const slow = Math.round(total * slowRate * (0.5 + rand()));
  rows.push({ minute: m, total, errors, slow });
}

// latency لـ ألف request في دقيقة عادية: أغلبهم سريعين، وشوية بطيئين جدًا (cache miss، أو lock)
export const sample = Array.from({ length: 1000 }, () => (rand() < 0.97 ? 20 + rand() * 60 : 400 + rand() * 1600));

import { percentile, sli, errorBudget, burnRate, alertsAt } from "./slo.js";

let ok = 0, all = 0;
const check = (name, cond, extra = "") => { all++; if (cond) ok++; console.log(cond ? "✅" : "❌", name, extra); };
const near = (a, b, eps = 1e-9) => Math.abs(a - b) < eps;
const oneTo100 = Array.from({ length: 100 }, (_, i) => i + 1);

check("p50 من واحد لمية ← خمسين", percentile(oneTo100, 50) === 50);
check("p99 ← تسعة وتسعين، و p100 ← مية", percentile(oneTo100, 99) === 99 && percentile(oneTo100, 100) === 100);
check("p0 ← أول قيمة", percentile(oneTo100, 0) === 1);
check("percentile مش متأثر بالترتيب ومش بيغيّر الأصل", (() => { const a = [5, 1, 4, 2, 3]; return percentile(a, 50) === 3 && a[0] === 5; })());
check("percentile فاضي ← NaN", Number.isNaN(percentile([], 50)));
check("p99 لعشرة samples ← أكبر واحدة", percentile([1, 2, 3, 4, 5, 6, 7, 8, 9, 1000], 99) === 1000);

const rows = [
  { total: 1000, errors: 1, slow: 10 },
  { total: 1000, errors: 3, slow: 30 },
];
const s = sli(rows);
check("availability = واحد ناقص errors على total", near(s.availability, 1 - 4 / 2000));
check("latency SLI = واحد ناقص slow على total", near(s.latency, 1 - 40 / 2000));
check("sli فاضي ← واحد", sli([]).availability === 1 && sli([]).latency === 1);
const b = errorBudget(rows, 0.999);
check("budget: allowed اتنين، bad أربعة، consumed اتنين", b.allowed === 2 && b.bad === 4 && near(b.consumed, 2) && near(b.remaining, -1));
const b2 = errorBudget([{ total: 100000, errors: 25, slow: 0 }], 0.999);
check("budget: مية ألف و SLO تلات تسعات ← مية مسموح، ربع اتصرف", b2.allowed === 100 && near(b2.consumed, 0.25) && near(b2.remaining, 0.75));

const flat = (n, err) => Array.from({ length: n }, () => ({ total: 1000, errors: err, slow: 0 }));
check("burnRate: error rate واحد في الألف و SLO تلات تسعات ← واحد", near(burnRate(flat(100, 1), 0.999, 100, 60), 1));
check("burnRate: عشرة في الألف ← عشرة", near(burnRate(flat(100, 10), 0.999, 100, 60), 10));
check("burnRate بياخد آخر windowMin دقايق قبل endMinute بس", near(burnRate([...flat(50, 0), ...flat(10, 100)], 0.999, 60, 10), 100));
check("burnRate: window أكبر من الـ data ← من الأول", near(burnRate(flat(10, 2), 0.999, 10, 60), 2));
check("burnRate: مفيش traffic ← صفر", burnRate([], 0.999, 0, 60) === 0);

const incident = [...flat(300, 0), ...flat(60, 20)];
check("incident ساعة بـ اتنين في المية ← page", alertsAt(incident, 0.999, 360).page === true);
check("نفس الـ incident بعد ما خلص بخمس دقايق ← مفيش page", alertsAt([...incident, ...flat(5, 0)], 0.999, 365).page === false);
check("blip دقيقة واحدة بـ تلاتين في المية ← مفيش page", alertsAt([...flat(359, 0), ...flat(1, 300)], 0.999, 360).page === false);
check("slow burn ست ساعات بـ اتنين في الألف ← ticket مش page", (() => { const a = alertsAt(flat(400, 2), 0.999, 400); return a.ticket === true && a.page === false; })());
check("traffic صحي واحد في العشرة آلاف ← ولا حاجة", (() => { const a = alertsAt(flat(400, 0.1), 0.999, 400); return !a.page && !a.ticket; })());
check("burnRate على
…