---
title: 'Hata Bütçesi Yönetimi'
source: 'https://academia.sh/tr/kurslar/devops-gozlemlenebilirlik/hata-butcesi-yonetimi'
course: 'Gözlemlenebilirlik ve İşletim'
language: tr
updated: '2026-08-17T18:09:05+00:00'
license: 'CC BY-SA 4.0'
---

# Hata Bütçesi Yönetimi

Hata bütçesinin değişim hızını düzenleyen bir kurala çevrilmesi: 360 günde 90 günlük kayan pencerede 129,6 dakikalık bütçenin tek bir ağır olayla (150 dakika, bütçenin %116'sı) bitmesi ve dört durma epizodunun dördünün de tek olayla tetiklenmesi, tam durdurmanın dağıtım sıklığını 5,9'dan 1,8'e indirirken 154'lük kuyruğu 40'lık partiler hâlinde boşaltarak kesintiyi 402'den 901 dakikaya çıkarması, kısmi durdurmanın 437 dakikada ve 3,9 kuyrukta kalması, yalnız riskli değişikliğin durdurulmasının 480 dakika vermesi ve kademeli açılışın aynı kuralı koruyup kesintiyi 437 dakikaya indirmesi.

Önceki ders eylem maddelerini saydı ve kapanmayan maddenin aynı olayı yeniden ürettiğini gösterdi.
Düzeltmelerin hepsi olay olduktan sonra çalıştı; değişimin hızını olaydan önce düzenleyen bir kural
hiç konmadı.

Hata bütçesinin kendisi M22/K01'de ölçüldü: hedeften türetilir, tek bir ağır olayın onu ne kadar
götürdüğü sayılır. Burada bütçe bir **kurala** çevrilir — tükendiğinde yeni dağıtım durur — ve
kuralın kendisi ölçülür. Ölçülen dört şey vardır: dağıtım sıklığı, kuyrukta **biriken iş**,
bütçenin **geri kazanılma süresi** ve kuralın **tek bir olayla tetiklenmesi**. Sonra kural gevşetilir
ve her gevşetmenin dağıtım sıklığı ile olay sayısına etkisi sayılır.

## Kuralın Kurulması

Örnek yine kurgu **bölgesel ölçüm ağı**dır; dağıtım hattı da olay dizisi de kurgudur.

**OY25:** 360 gün koşulur ve bütçe **kayan pencere** üzerinde işler: her gün son 90 günün kesintisi
bütçeden düşülür. Pencere bütçesi 129,6 dakikadır; türetimi M22/K01'de ölçüldü, burada girdidir.
**OY26:** her gün akışa bir değişiklik girer; parti tabanı beş, hazırlık bir gün, parti tavanı
kırktır. **OY27:** değişikliklerin dörtte biri riskli etiketlidir; kusur olasılığı riskli için 0,09,
öteki için 0,014'tür. **OY28:** kusurlu değişiklik yayına çıkarsa aynı gün olay olur; sınıflar hafif
8 dakika (pay 0,58), orta 35 dakika (0,30), ağır 150 dakika (0,12). **OY29:** parti tabanının
üstündeki her değişiklik kusur olasılığını 0,04 katsayısıyla büyütür. **OY30:** kural devredeyken
*tam durdurma* hiçbir partiyi çıkarmaz, *kısmi durdurma* hazırlığı on güne çıkarır, *yalnız riskli*
biçimi riskli etiketlileri kuyrukta bırakır, *kademeli açılış* parti tavanını ona indirir. Tohum
20260819'dur ve bütün koşumlar aynı değişiklik dizisini paylaşır.

Günler, değişiklikler ve olaylar süreç içi bir **modeldir**; gerçek bir dağıtım hattı yoktur.

```js
// butce/kural.mjs — hata butcesi kurali modeli: gercek bir dagitim hatti yok; gunler,
// degisiklikler ve olaylar veri yapisidir. Uretec kendi yazilir, tohum gorunur.

export const GUN = 360, PENCERE = 90, GUN_DK = 1440, HEDEF = 0.999, TOHUM = 20260819;
export const BUTCE = PENCERE * GUN_DK * (1 - HEDEF);   // M22/K01'de turetildi, burada girdi
export const PARTI = 5, PARTI_TAVAN = 40, HAZIRLIK = 1, KISMI_HAZIRLIK = 10;
export const BAGLASIM = 0.04;   // partideki her ek degisiklik kusur olasiligini bu kadar buyutur
export const RISK_PAY = 0.25, KUSUR_RISKLI = 0.09, KUSUR_DUZ = 0.014;
export const SINIF = [["hafif", 8, 0.58], ["orta", 35, 0.30], ["agir", 150, 0.12]];

export function uretec(tohum) {                    // dogrusal eslesmeli uretec
  let x = tohum >>> 0;
  return () => ((x = (x * 1664525 + 1013904223) >>> 0) / 2 ** 32);
}
// zarlar bastan atilir: butun kosumlar ayni degisiklik dizisini paylasir
const Z = (() => { const z = uretec(TOHUM);
  return Array.from({ length: GUN }, () => ({ risk: z(), kusur: z(), sinif: z() })); })();

export function kos({ kural = "yok", tavan = PARTI_TAVAN } = {}) {
  const D = Z.map((z, i) => {                      // her gun akisa bir degisiklik girer
    const riskli = z.risk < RISK_PAY;
    let e = 0, dk = 0;
    for (const [, sure, pay] of SINIF) { e += pay; if (dk === 0 && z.sinif < e) dk = sure; }
    return { i, riskli, zar: z.kusur, taban: riskli ? KUSUR_RISKLI : KUSUR_DUZ,
      kesinti: dk, durum: "kuyrukta", yayinGun: null };
  });
  const olaylar = [], epizotlar = [];
  const S = { yayin: 0, durgunGun: 0, kuyrukToplam: 0, enBuyukKuyruk: 0,
    partiToplam: 0, enBuyukParti: 0 };
  let aktif = null, bas = null, tek = false;

  for (let t = 0; t < GUN; t++) {
    if (aktif && aktif.bitis === t) {               // parti uretime cikar
      S.yayin++; S.partiToplam += aktif.grup.length;
      S.enBuyukParti = Math.max(S.enBuyukParti, aktif.grup.length);
      // parti buyudukce kusur olasiligi baglasim katsayisiyla buyur
      const carpan = 1 + BAGLASIM * (aktif.grup.length - PARTI);
      for (const x of aktif.grup) {
        x.durum = "bitti"; x.yayinGun = t;
        if (x.zar < x.taban * carpan) olaylar.push({ gun: t, kesinti: x.kesinti });
      }
      aktif = null;
    }
    // kayan pencere: son PENCERE gunun kesintisi butceden dusulur
    const pen = olaylar.filter((o) => o.gun > t - PENCERE);
    const kalan = BUTCE - pen.reduce((s, o) => s + o.kesinti, 0);
    const devrede = kural !== "yok" && kalan < 0;   // butce tukendi mi
    if (devrede) {
      if (bas === null) { bas = t; tek = pen.some((o) => o.kesinti >= BUTCE); }
      S.durgunGun++;
    } else if (bas !== null) { epizotlar.push({ uzunluk: t - bas, tek }); bas = null; }

    const kuyruk = D.filter((x) => x.durum === "kuyrukta" && x.i <= t);
    S.kuyrukToplam += kuyruk.length;
    S.enBuyukKuyruk = Math.max(S.enBuyukKuyruk, kuyruk.length);
    if (aktif) continue;
    let parti = PARTI, hazirlik = HAZIRLIK, aday = kuyruk;
    if (devrede) {                                  // kuralin gevsetilme bicimleri
      if (kural === "tam") aday = [];
      else if (kural === "kismi") hazirlik = KISMI_HAZIRLIK;
      else if (kural === "riskli") aday = kuyruk.filter((x) => !x.riskli);
    }
    if (aday.length < parti) continue;
    const grup = aday.slice(0, Math.min(aday.length, tavan));
    for (const x of grup) x.durum = "yayinda";
    aktif = { grup, bitis: t + hazirlik };
  }
  if (bas !== null) epizotlar.push({ uzunluk: GUN - bas, tek });
  return { D, olaylar, epizotlar, S };
}

const ort = (a) => (a.length ? (a.reduce((s, v) => s + v, 0) / a.length).toFixed(1) : "-");

export function olc(ayar) {
  const { D, olaylar, epizotlar, S } = kos(ayar);
  const U = epizotlar.map((e) => e.uzunluk);
  return { yayin: S.yayin, dagitim: (S.yayin / (GUN / 30)).toFixed(1),
    olay: olaylar.length, kesinti: olaylar.reduce((s, o) => s + o.kesinti, 0),
    agir: olaylar.filter((o) => o.kesinti === SINIF[2][1]).length,
    epizot: epizotlar.length, durgunGun: S.durgunGun,
    enUzun: U.length ? Math.max(...U) : 0, geriKazanma: ort(U),
    tekOlay: epizotlar.filter((e) => e.tek).length,
    ortKuyruk: (S.kuyrukToplam / GUN).toFixed(1), enBuyukKuyruk: S.enBuyukKuyruk,
    ortParti: (S.partiToplam / S.yayin).toFixed(1), enBuyukParti: S.enBuyukParti,
    cikmayan: D.filter((x) => x.yayinGun === null).length };
}
```

Ölçüm dosyası önce altı soruluk bir küme kurar — kural devredeyken işletimde gerçekten sorulan
sorular — ve her sorunun hangi kayıtla yanıtlandığını yazar.

```js
// butce/olc.mjs — butce bir kurala cevrilir ve bir donem kosturulur: dagitim sikligi,
// biriken is, butcenin geri kazanilma suresi ve kuralin erken tetiklenmesi sayilir.
import { GUN, PENCERE, BUTCE, HEDEF, SINIF, TOHUM, BAGLASIM, PARTI, olc } from "./kural.mjs";

const yaz = (g, ...s) => console.log(s.map((v, i) =>
  (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join(""));
const t0 = process.hrtime.bigint();

const K = { "kural yok": { kural: "yok" }, "tam durdurma": { kural: "tam" },
  "kismi durdurma": { kural: "kismi" }, "yalniz riskli durur": { kural: "riskli" },
  "tam + kademeli acilis": { kural: "tam", tavan: 10 } };
const R = Object.fromEntries(Object.entries(K).map(([a, y]) => [a, olc(y)]));
const T = R["tam durdurma"];

// soru kumesi: her sorunun yanitlanmasi icin gereken kayit, birim bayti ve birim sayisi
const SORU = [
  ["butceden su an ne kadar kaldi", "gunluk kesinti kaydi", 48, GUN],
  ["hat neden durdu", "durdurma gunlugu", 96, T.epizot],
  ["hat ne zaman yeniden acilacak", "pencere dusme takvimi", 32, T.olay],
  ["durus kac degisiklik biriktirdi", "kuyruk kaydi", 24, GUN],
  ["hangi degisiklik riskli sayildi", "risk etiketi", 8, GUN],
  ["durdurma hangi olayi onledi", "karsi olgu", 0, 0],
];

console.log(`${GUN} gun, kayan pencere ${PENCERE} gun, hedef ${(100 * HEDEF).toFixed(1)}%, ` +
  `pencere butcesi ${BUTCE.toFixed(1)} dk; tohum ${TOHUM}`);
console.log("olay siniflari: " + SINIF.map(([a, d, p]) => `${a} ${d} dk (pay ${p})`).join(", "));
console.log(`agir olay / butce = %${(100 * SINIF[2][1] / BUTCE).toFixed(0)} (tek olay butceyi ` +
  `bitirir); parti tabani ${PARTI}, baglasim katsayisi ${BAGLASIM}`);

console.log("\n1. hangi soru hangi kayitla yanitlaniyor (tam durdurma kosumu)");
const A = [-33, -23, 10, 8];
yaz(A, "soru", "gereken kayit", "bayt", "yanit");
let bayt = 0, yanit = 0;
for (const [s, k, b, n] of SORU) {
  const var_ = b > 0;
  if (var_) { bayt += b * n; yanit++; }
  yaz(A, s, k, var_ ? b * n : "-", var_ ? "evet" : "hayir");
}
console.log(`  toplam ${bayt} bayt, ${yanit}/6 soru, soru basina ` +
  `${Math.round(bayt / yanit)} bayt`);

console.log("\n2. kural degisim hizini nasil duzenliyor");
const B = [-21, 8, 12, 7, 7, 11];
yaz(B, "kosum", "yayin", "dagitim/30g", "olay", "agir", "kesinti");
for (const [ad, r] of Object.entries(R))
  yaz(B, ad, r.yayin, r.dagitim, r.olay, r.agir, r.kesinti + " dk");

console.log("\n3. durus ve butcenin geri kazanilmasi");
const C = [-21, 9, 12, 11, 15, 15];
yaz(C, "kosum", "epizot", "durgun gun", "en uzun", "geri kazanma", "tek olayla");
for (const [ad, r] of Object.entries(R))
  yaz(C, ad, r.epizot, r.durgunGun, r.enUzun + " g", r.geriKazanma + " g",
    `${r.tekOlay}/${r.epizot}`);

console.log("\n4. biriken is");
const D = [-21, 13, 15, 12, 16, 11];
yaz(D, "kosum", "ort. kuyruk", "en buyuk kuy.", "ort. parti", "en buyuk parti", "cikmayan");
for (const [ad, r] of Object.entries(R))
  yaz(D, ad, r.ortKuyruk, r.enBuyukKuyruk, r.ortParti, r.enBuyukParti, r.cikmayan);

const ms = Number(process.hrtime.bigint() - t0) / 1e6;   // ham olcum basilmaz, bant denetlenir
console.log(`\nbes kosum ve soru taramasi 2000 ms bandinda: ${ms < 2000 ? "evet" : "hayir"}`);
```

```
360 gun, kayan pencere 90 gun, hedef 99.9%, pencere butcesi 129.6 dk; tohum 20260819
olay siniflari: hafif 8 dk (pay 0.58), orta 35 dk (pay 0.3), agir 150 dk (pay 0.12)
agir olay / butce = %116 (tek olay butceyi bitirir); parti tabani 5, baglasim katsayisi 0.04

1. hangi soru hangi kayitla yanitlaniyor (tam durdurma kosumu)
soru                             gereken kayit                bayt   yanit
butceden su an ne kadar kaldi    gunluk kesinti kaydi        17280    evet
hat neden durdu                  durdurma gunlugu              384    evet
hat ne zaman yeniden acilacak    pencere dusme takvimi         576    evet
durus kac degisiklik biriktirdi  kuyruk kaydi                 8640    evet
hangi degisiklik riskli sayildi  risk etiketi                 2880    evet
durdurma hangi olayi onledi      karsi olgu                      -   hayir
  toplam 29760 bayt, 5/6 soru, soru basina 5952 bayt

2. kural degisim hizini nasil duzenliyor
kosum                   yayin dagitim/30g   olay   agir    kesinti
kural yok                  71         5.9      8      2     402 dk
tam durdurma               22         1.8     18      4     901 dk
kismi durdurma             58         4.8      9      2     437 dk
yalniz riskli durur        62         5.2     11      2     480 dk
tam + kademeli acilis      51         4.3      9      2     437 dk

3. durus ve butcenin geri kazanilmasi
kosum                   epizot  durgun gun    en uzun   geri kazanma     tek olayla
kural yok                    0           0        0 g            - g            0/0
tam durdurma                 4         274       90 g         68.5 g            4/4
kismi durdurma               1         134      134 g        134.0 g            1/1
yalniz riskli durur          2         180       90 g         90.0 g            2/2
tam + kademeli acilis        2         180       90 g         90.0 g            2/2

4. biriken is
kosum                  ort. kuyruk  en buyuk kuy.  ort. parti  en buyuk parti   cikmayan
kural yok                      3.0              5         5.0               5          5
tam durdurma                  65.6            154        14.5              40         40
kismi durdurma                 3.9             10         6.1              10          5
yalniz riskli durur            9.6             31         5.8              31          3
tam + kademeli acilis         44.4            154         7.0              10          5

bes kosum ve soru taramasi 2000 ms bandinda: evet
```

Sayılar **ölçüm** sınıfındadır; girdileri yukarıdaki varsayımlardır.

## Kuralın Sorduğu Sorular

Birinci tablo kural devredeyken sorulan altı soruyu kayda bağlar. Beşi yanıtlanır, toplam 29.760
bayt tutar; soru başına 5.952 bayt. Pahalı olan ikisi gün başına tutulur: günlük kesinti kaydı
(17.280 bayt) ve kuyruk kaydı (8.640 bayt). Ucuz olan **hat ne zaman yeniden açılacak** sorusudur:
576 bayt. Kayan pencere bu soruyu kesin bir tarihe çevirir, çünkü her olayın pencereden düşeceği gün
bellidir. Takvim yoksa soru "bilmiyoruz"la yanıtlanır ve kuyruktaki her değişiklik için yeniden
sorulur.

Yanıtsız kalan altıncısıdır: durdurma hangi olayı önledi. Burada da hiçbir kayıtla yanıtlanmaz.
Kural devredeyken **kesinti ölçülür, önlenen kesinti ölçülmez**.

## Bütçe Bir Olayda Bitiyor

Üçüncü tablo kuralın nasıl tetiklendiğini söyler. Ağır olay 150 dakika, pencere bütçesi 129,6
dakikadır: **tek bir ağır olay bütçenin %116'sını götürür**. Son sütun sonucu verir — tam durdurmada
dört duruş epizodunun **dördü de** tek olayla tetiklenmiştir; kural kesinti birikimine değil, tek
olaya tepki verir.

Geri kazanılma süresi buradan çıkar. Kayan pencerede bütçe ancak olay pencereden düştüğünde geri
gelir; ağır bir olay tek başına bütçeyi bitirdiği için hat **doksan gün** kapalı kalır — en uzun
duruş tam olarak pencere uzunluğudur. Tam durdurmada ortalama epizot 68,5 gün, durgun gün 274'tür:
360 günün dörtte üçü. Kısmi durdurmada tek epizot 134 gün sürer, çünkü yavaşlayan hat pencereye yeni
olay eklemeye devam eder.

## Kural Kesintiyi Artırıyor

İkinci tablonun okunması gereken satırı tam durdurmadır. Dağıtım sıklığı 30 günde 5,9'dan 1,8'e
iner — kuralın amaçladığı budur. Ama olay 8'den **18'e**, kesinti 402'den **901 dakikaya**, ağır olay
2'den 4'e çıkar.

Nedeni dördüncü tablodadır. Kural yokken ortalama kuyruk 3,0, ortalama parti 5,0'dır. Tam durdurmada
kuyruk ortalama 65,6'ya, en büyük 154'e çıkar ve hat açıldığında **40'lık partiler** hâlinde boşalır
— ortalama parti 14,5. Bağlaşım katsayısı 0,04 olduğu için 40'lık partide kusur olasılığı tabanın
2,4 katıdır. **Durdurma değişikliği yok etmez, biriktirir; biriken iş büyük parti olarak çıkar ve
büyük parti daha çok olay üretir.** Yeni olaylar yeni duruş tetikler: epizot 4'e çıkar ve kırk
değişiklik hiç çıkamaz.

## Gevşetmenin Üç Biçimi

Kısmi durdurma hattı durdurmaz, yavaşlatır: hazırlık on güne çıkar. Dağıtım sıklığı 4,8'de kalır,
kuyruk 3,9'u geçmez ve kesinti 437 dakikada durur — kuralsız koşumun 402 dakikasına yakın. Bedeli
134 günlük tek bir yavaşlama epizodudur.

Yalnız riskli değişikliğin durdurulması ortada durur: dağıtım sıklığı 5,2, kuyruk 9,6, kesinti 480
dakika. Kısmi durdurmadan kötüdür, çünkü bekleyen riskliler sonunda 31'lik bir partide birlikte
çıkar. Etiketin kendisi 2.880 bayttır; karşılığı kuyruğun 154 yerine 31'de kalmasıdır.

Üçüncü gevşetme kuralın kendisine değil, **açılışına** dokunur: tam durdurma korunur ama hat
açılırken parti tavanı 40'tan 10'a çekilir. Aynı kural, aynı 180 durgun gün, aynı iki epizot — ama
ortalama parti 14,5'ten 7,0'a, olay 18'den 9'a ve kesinti 901'den **437 dakikaya** iner. Dağıtım
sıklığı 1,8'den 4,3'e çıkar ve çıkmayan değişiklik 40'tan 5'e düşer. **Kuralın bedelini duruşun
uzunluğu değil, duruştan çıkışın biçimi belirler.**

## Farkın Saklandığı Yer

Fark **duruşun süresi ile duruş sonrası partinin boyu arasında** saklıdır: tam durdurma ile kademeli
açılış aynı kuralı, aynı eşiği ve aynı 180 durgun günü paylaşır, ikisinde de en büyük kuyruk 154'tür.
Bildirilen ölçüt duruş günüdür ve o ikisinde aynıdır. Bildirilmeyen kısım parti tavanıdır; kesintiyi
901 ile 437 dakika arasında ayıran tek şey odur.

Ağır olayın payı yalnız 0,12'dir ama bütçenin %116'sını tek başına götürür; kuralın devreye girip
girmemesi neredeyse tamamen o tek sınıfa bağlıdır. Kural, kesinti birikimini değil, **bir olayın
büyüklüğünü** okur.

## Özet

- Kayan pencerede bütçe 129,6, ağır olay 150 dakikadır: tek olay bütçenin %116'sını götürür; tam
  durdurmada dört epizodun dördü de tek olayla tetiklenir ve en uzun duruş 90 gündür — tam pencere
  uzunluğu.
- Tam durdurma dağıtım sıklığını 5,9'dan 1,8'e indirir, ama kuyruk 154'e çıkıp 40'lık partiler
  hâlinde boşaldığı için olay 8'den 18'e, kesinti 402'den 901 dakikaya çıkar ve 40 değişiklik hiç
  çıkamaz.
- Kısmi durdurma (hazırlık 1 → 10 gün) dağıtım sıklığını 4,8'de, kuyruğu 3,9'da ve kesintiyi 437
  dakikada tutar; bedeli 134 günlük tek bir yavaşlama epizodudur.
- Yalnız riskli değişikliğin durdurulması dağıtım sıklığını 5,2'de tutar ama kesinti 480 dakikadır,
  çünkü bekleyen riskliler 31'lik tek bir partide birlikte çıkar.
- Kural korunup açılışta parti tavanı 40'tan 10'a çekilince aynı 180 durgun günle kesinti 437
  dakikaya, olay 9'a iner ve dağıtım sıklığı 4,3'e çıkar.
- Altı sorudan beşi 29.760 baytla yanıtlanır (soru başına 5.952 bayt); "durdurma hangi olayı önledi"
  hiçbir kayıtla yanıtlanmaz.

## Sonraki Adım

Kural kondu, hat durdu, kuyruk birikti ve çıkışın biçimi kesintiyi ikiye katladı ya da yarıya
indirdi. Bu sayıların hepsi dakika ve değişiklik cinsindendir. Duran hattın, biriken kuyruğun ve
gece boyunca koşan toplu işin bir de kaynak karşılığı vardır. Sonraki ders kapasiteyi işletim
maliyeti olarak ele alır — kaynak kullanımı nasıl bir fiyata dönüşür, hangi soru bu fiyatla
yanıtlanır ve toplanan izleme verisinin kendi maliyeti ne kadardır.
