---
title: 'Olay Sınıflandırma'
source: 'https://academia.sh/tr/kurslar/devops-gozlemlenebilirlik/olay-siniflandirma'
course: 'Gözlemlenebilirlik ve İşletim'
language: tr
updated: '2026-08-17T18:09:05+00:00'
license: 'CC BY-SA 4.0'
---

# Olay Sınıflandırma

Önem düzeyi ve tırmandırma sayıyla: altmış olayın iki kuralla etiketlenmesi, eşik kuralının 37 doğru etiketine karşılık 4 sessiz veri kaybını d4'e düşürüp 11.040 etki-dakika üretmesi, ihtiyatlı kuralın bunu 180'e indirirken gereksiz uyandırmayı 3'ten 7'ye çıkarması, uyanık kalınan saat başına 678,8 etki-dakikalık değiş tokuş ve tırmandırma zincirini iki basamaktan üçe çıkarmanın kimseye ulaşmayan olayı 5'ten 2'ye indirmesi.

Nöbet düzeni "kim" ve "ne zaman" sorularını yanıtladı, ama her çağrının bir insanı uyandırmaya
değdiğini varsaydı. Uyandırma kararı çağrıdan önce verilir ve bu karar bir etiketle verilir.

**Önem düzeyi**, bir olayın hangi hızda ve hangi güçle karşılanacağını belirleyen etikettir;
**tırmandırma**, etiketin gerektirdiği yanıt gelmediğinde sıradaki basamağın çağrılmasıdır. Bu
dersin ölçtüğü şey etiketin kendisi değil, **yanlış etiketin iki yöndeki bedelidir**: fazla
yükseltme geceyi böler, fazla düşürme müdahaleyi geciktirir.

## Olay Kümesi, Gerçek Düzey ve İki Kural

Örnek yine kursun kurgu **bölgesel ölçüm ağı**dır: su sayacı okuma toplayıcı, doğrulayıcı,
faturalama ve iş emri servisleri, üç ortam. Ağ da olay kümesi de kurgudur.

**OY7:** Altmış olay üretilir; her olayın **gerçek** önem düzeyi ancak kapandıktan sonra bilinen
etkilenen abone sayısı ve veri kaybından çıkar — `d1` en ağır, `d4` en hafif. **OY8:** Çağrı anında
yalnız **görünür imza** vardır: ortam, servis, hata oranı, gecikme katı, gecelik toplu iş
penceresi. **OY9:** `d1` ile `d2` çağrı üretir ve gece de uyandırır; `d3` sabaha kalır, `d4` iş
listesine düşer. **OY10:** Gece düşen fazla yükseltmenin bedeli 4 saatlik toparlanma penceresidir
(nöbet dersiyle aynı birim); fazla düşürmede olay gece ise 06.00'ı bekler, üstüne `d4` etiketi 240,
`d3` etiketi 60 dakika ekler. **OY11:** Gecikmenin bedeli **etki-dakika**dır: gecikme dakikası ×
gerçek düzeyin ağırlığı (`d1` 8, `d2` 3, `d3` 1, `d4` 0). **OY12:** Tırmandırma sıralıdır; bir
basamak gündüz 0,70, gece 0,40 olasılıkla yanıt verir, yanıt gelmezse bekleme süresi sonunda
sıradaki basamak çağrılır.

```js
// olay/kural.mjs — kurgu bolgesel olcum aginin olay kumesi ve siniflandirma modeli (model):
// gercek bir olay kaydi, cagri sirasi ya da kisi yok. Uretec kendi yazildi, tohum gorunur.

export const SERVIS = ["okuma-toplayici", "dogrulayici", "faturalama", "is-emri"];
export const DUZEY = ["d1", "d2", "d3", "d4"];        // d1 en agir
export const AGIRLIK = { d1: 8, d2: 3, d3: 1, d4: 0 };  // etki-dakika carpani
export const UYANDIRAN = ["d1", "d2"];                // gece de cagri uretir
export const PENCERE = 4;                             // gereksiz uyandirmanin toparlanma penceresi
export const SABAH = 6 * 60;                          // sabaha kalan olay 06.00'da ele alinir
export const YANIT = { gunduz: 0.70, gece: 0.40 };    // bir basamagin yanit verme olasiligi

export function uretec(tohum) {
  let x = tohum >>> 0 || 1;
  return () => { x ^= x << 13; x >>>= 0; x ^= x >>> 17; x ^= x << 5; x >>>= 0;
    return x / 4294967296; };
}

// Gizli alanlar (olay kapandiktan sonra bilinir): etkilenen abone, veri kaybi -> gercek duzey.
// Gorunur imza (cagri aninda): ortam, servis, hata orani, gecikme kati, toplu is penceresi.
export function olaylar(tohum, adet = 60) {
  const r = uretec(tohum), liste = [];
  for (let i = 0; i < adet; i++) {
    const servis = SERVIS[Math.floor(r() * SERVIS.length)];
    const u = r();
    const ortam = u < 0.72 ? "uretim" : u < 0.88 ? "hazirlik" : "gelistirme";
    const dk = Math.floor(r() * 1440);
    const buyuk = r();                                // etkinin buyuklugu, uzun kuyruk
    const abone = ortam === "uretim" ? Math.floor(buyuk ** 3 * 60000) : 0;
    const veriKaybi = ortam === "uretim" && servis === "faturalama" && r() < 0.45;
    const sessiz = veriKaybi || (servis === "dogrulayici" && ortam === "uretim" && r() < 0.35);
    const hataOrani = +(sessiz ? 0.01 + r() * 0.05
      : ortam !== "uretim" ? 0.35 + r() * 0.6 : 0.04 + buyuk * 0.8).toFixed(2);
    const gecikmeKat = +(1 + (sessiz ? r() : ortam !== "uretim" ? 4 + r() * 5
      : buyuk * 8)).toFixed(1);
    const gercek = veriKaybi || abone >= 20000 ? "d1" : abone >= 5000 ? "d2"
      : abone >= 500 ? "d3" : "d4";
    liste.push({ i, servis, ortam, dk, gece: dk < SABAH, toplu: dk >= 120 && dk < 240,
      abone, veriKaybi, hataOrani, gecikmeKat, gercek });
  }
  return liste;
}

// Iki siniflandirma kurali. Ikisi de yalnizca gorunur imzaya bakar.
export const KURAL = {
  // A: esik temelli. Uretim disini eler, kalani hata orani ve gecikme katina bakarak etiketler
  A: (o) => o.ortam !== "uretim" ? "d4"
    : o.hataOrani >= 0.50 && o.gecikmeKat >= 4 ? "d1"
    : o.hataOrani >= 0.25 || o.gecikmeKat >= 3 ? "d2"
    : o.toplu ? "d3" : "d4",
  // B: ihtiyatli. Esikler dusuk; faturalama servisi sessiz bozuldugu icin taban d2'ye cekilir
  B: (o) => o.ortam !== "uretim" ? "d4"
    : o.hataOrani >= 0.30 ? "d1"
    : o.hataOrani >= 0.10 || o.gecikmeKat >= 2 ? "d2"
    : o.servis === "faturalama" ? "d2" : "d3",
};

const sira = (d) => DUZEY.indexOf(d);
export const yon = (etiket, gercek) => sira(etiket) < sira(gercek) ? "yukseltme"
  : sira(etiket) > sira(gercek) ? "dusurme" : "dogru";

// Bir etiketin bedeli. Fazla yukseltme gece gereksiz uyandirma yapar; fazla dusurme mudahaleyi
// geciktirir ve gecikme gercek duzeyin agirligiyla carpilarak etki-dakika olur.
export function bedel(o, etiket) {
  const cagirir = UYANDIRAN.includes(etiket);
  const y = yon(etiket, o.gercek);
  const uyandirma = cagirir && o.gece && y === "yukseltme" ? 1 : 0;
  const gecikme = !cagirir && UYANDIRAN.includes(o.gercek)
    ? (o.gece ? SABAH - o.dk : 0) + (etiket === "d4" ? 240 : 60) : 0;
  return { uyandirma, pencere: uyandirma * PENCERE, gecikme,
    etkiDk: gecikme * AGIRLIK[o.gercek], y, cagirir };
}

// Tirmandirma zinciri: basamak sayisi ve basamak basina bekleme dakikasi. Zar onceden uretilir,
// boylece zincir uzatildiginda ayni olay ayni cekilisleri gorur.
export function zar(tohum, adet, enCok = 6) {
  const r = uretec(tohum);
  return Array.from({ length: adet }, () => Array.from({ length: enCok }, () => r()));
}

export function tirmandir(o, z, basamak, bekle) {
  const p = o.gece ? YANIT.gece : YANIT.gunduz;
  for (let b = 0; b < basamak; b++)
    if (z[b] < p) return { ulasti: true, basamak: b + 1, dakika: b * bekle, uyanan: b + 1 };
  return { ulasti: false, basamak, dakika: basamak * bekle, uyanan: basamak };
}
```

```js
// olay/olc.mjs — siniflandirmanin iki yonlu hatasi, bedeli ve tirmandirma zinciri taramasi.
import { olaylar, KURAL, DUZEY, bedel, yon, zar, tirmandir, UYANDIRAN, PENCERE }
  from "./kural.mjs";

const TOHUM = 20260921;
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 s1 = (x) => x.toFixed(1);
const say = (a, f) => a.filter(f).length;

const O = olaylar(TOHUM);
const Z = zar(TOHUM + 1, O.length);
console.log(`tohum ${TOHUM}: ${O.length} olay, ${say(O, (o) => o.gece)} tanesi gece, ` +
  `${say(O, (o) => o.ortam !== "uretim")} tanesi uretim disi`);
console.log("gercek duzey dagilimi: " +
  DUZEY.map((d) => `${d} ${say(O, (o) => o.gercek === d)}`).join(", "));

const A = [-7, 8, 18, 16, 15, 15];
console.log("\n1. iki siniflandirma kurali ayni olay kumesinde");
yaz(A, "kural", "dogru", "fazla yukseltme", "fazla dusurme", "cagri ureten", "gercek cagri");
for (const [ad, k] of Object.entries(KURAL)) {
  const e = O.map((o) => yon(k(o), o.gercek));
  yaz(A, ad, say(e, (x) => x === "dogru"), say(e, (x) => x === "yukseltme"),
    say(e, (x) => x === "dusurme"), say(O, (o) => UYANDIRAN.includes(k(o))),
    say(O, (o) => UYANDIRAN.includes(o.gercek)));
}

const B = [-7, 17, 13, 17, 14, 14];
console.log("\n2. yanlis siniflandirmanin iki yonlu bedeli");
yaz(B, "kural", "ger. uyandirma", "kayip saat", "gec. mudahale", "gecikme dk", "etki-dakika");
const T2 = {};
for (const [ad, k] of Object.entries(KURAL)) {
  const b = O.map((o) => bedel(o, k(o)));
  const gec = b.filter((x) => x.gecikme > 0);
  T2[ad] = { saat: b.reduce((a, x) => a + x.pencere, 0),
    etki: b.reduce((a, x) => a + x.etkiDk, 0) };
  yaz(B, ad, b.reduce((a, x) => a + x.uyandirma, 0), T2[ad].saat,
    gec.length, gec.length ? s1(gec.reduce((a, x) => a + x.gecikme, 0) / gec.length) : "-",
    T2[ad].etki);
}
const dSaat = T2.B.saat - T2.A.saat, dEtki = T2.A.etki - T2.B.etki;
console.log(`A -> B degis tokusu: kayip saat +${dSaat}, etki-dakika -${dEtki} ` +
  `(uyanik kalinan saat basina ${s1(dEtki / dSaat)} etki-dakika)`);

const C = [-16, 8, 8, 8, 8];
console.log("\n3. kural A'nin karistirdigi olaylar (etiket -> gercek)");
yaz(C, "etiket \\ gercek", ...DUZEY);
for (const e of DUZEY)
  yaz(C, e, ...DUZEY.map((g) => say(O, (o) => KURAL.A(o) === e && o.gercek === g)));

const T = [-9, -9, 13, 16, 19, 14];
console.log("\n4. tirmandirma zinciri taramasi (kural B'nin cagri urettigi olaylar)");
yaz(T, "basamak", "bekleme", "ort basamak", "ort ulasma dk", "ulasilamayan olay", "uyanan kisi");
const cagri = O.filter((o) => UYANDIRAN.includes(KURAL.B(o)));
for (const basamak of [2, 3, 4])
  for (const bekle of [5, 15]) {
    const R = cagri.map((o) => tirmandir(o, Z[o.i], basamak, bekle));
    yaz(T, basamak, `${bekle} dk`, s1(R.reduce((a, x) => a + x.basamak, 0) / R.length),
      s1(R.reduce((a, x) => a + x.dakika, 0) / R.length), say(R, (x) => !x.ulasti),
      R.reduce((a, x) => a + x.uyanan, 0));
  }
console.log(`${cagri.length} cagri, ${say(cagri, (o) => o.gece)} tanesi gece; ` +
  `gereksiz uyandirmanin penceresi ${PENCERE} saat`);

const Q = [-40, 22, 8];
console.log("\n5. siniflandirmanin yanitladigi soru kumesi");
yaz(Q, "soru", "veri", "yanit");
const SORU = [
  ["bu olay birini uyandirmali mi", "gorunur imza", true],
  ["hangi onem duzeyinde", "gorunur imza", true],
  ["yanit gelmezse kim cagrilir", "tirmandirma zinciri", true],
  ["ne zaman bir sonraki basamak", "tirmandirma zinciri", true],
  ["olay gercekten kac aboneyi etkiledi", "-", false],
  ["etiket dogru muydu", "-", false],
  ["kimseye ulasmadiysa ne oldu", "-", false]];
for (const [q, d, y] of SORU) yaz(Q, q, d, y ? "evet" : "hayir");
console.log(`${SORU.length} sorudan ${say(SORU, (x) => x[2])} tanesi cagri aninda yanitlanir, ` +
  `${say(SORU, (x) => !x[2])} tanesi olay kapanmadan yanitlanamaz`);
```

```
tohum 20260921: 60 olay, 15 tanesi gece, 17 tanesi uretim disi
gercek duzey dagilimi: d1 12, d2 14, d3 13, d4 21

1. iki siniflandirma kurali ayni olay kumesinde
kural     dogru   fazla yukseltme   fazla dusurme   cagri ureten   gercek cagri
A            37                16               7             31             26
B            27                28               5             40             26

2. yanlis siniflandirmanin iki yonlu bedeli
kural     ger. uyandirma   kayip saat    gec. mudahale    gecikme dk   etki-dakika
A                      3           12                5         306.0         11040
B                      7           28                1          60.0           180
A -> B degis tokusu: kayip saat +16, etki-dakika -10860 (uyanik kalinan saat basina 678.8 etki-dakika)

3. kural A'nin karistirdigi olaylar (etiket -> gercek)
etiket \ gercek       d1      d2      d3      d4
d1                     8       6       0       0
d2                     0       7      10       0
d3                     0       0       1       0
d4                     4       1       2      21

4. tirmandirma zinciri taramasi (kural B'nin cagri urettigi olaylar)
basamak  bekleme    ort basamak   ort ulasma dk  ulasilamayan olay   uyanan kisi
2        5 dk               1.4             2.8                  5            57
2        15 dk              1.4             8.3                  5            57
3        5 dk               1.6             3.0                  2            62
3        15 dk              1.6             9.0                  2            62
4        5 dk               1.6             3.3                  2            64
4        15 dk              1.6             9.8                  2            64
40 cagri, 12 tanesi gece; gereksiz uyandirmanin penceresi 4 saat

5. siniflandirmanin yanitladigi soru kumesi
soru                                                      veri   yanit
bu olay birini uyandirmali mi                     gorunur imza    evet
hangi onem duzeyinde                              gorunur imza    evet
yanit gelmezse kim cagrilir                tirmandirma zinciri    evet
ne zaman bir sonraki basamak               tirmandirma zinciri    evet
olay gercekten kac aboneyi etkiledi                          -   hayir
etiket dogru muydu                                           -   hayir
kimseye ulasmadiysa ne oldu                                  -   hayir
7 sorudan 4 tanesi cagri aninda yanitlanir, 3 tanesi olay kapanmadan yanitlanamaz
```

Sayılar **ölçüm** sınıfındadır; girdileri OY7–OY12 varsayımlarıdır. Altmış olayın 15'i gece düşer,
17'si üretim dışı ortamdadır ve gerçekten çağrı hak eden (`d1` ya da `d2`) olay sayısı 26'dır. Eşik
kuralı A 31, ihtiyatlı kural B 40 çağrı üretir; ikisi de gerçeğin üstündedir.

## Doğruluk Bedeli Ölçmez

Birinci tablo iki kuralı doğru etiket sayısıyla karşılaştırırsa A açık ara kazanır: 60 olayın
37'sini doğru etiketler, B ise 27'sini. Fazla yükseltme A'da 16, B'de 28'dir. Bu ölçüyle bakan biri
A'yı seçer.

İkinci tablo kararı tersine çevirir. A'nın 16 fazla yükseltmesinin yalnız **3'ü** gece düşer, yani
12 saatlik toparlanma penceresi maliyeti vardır; B'nin 28 yükseltmesinin 7'si geceye denk gelir ve
28 saat götürür. Buna karşılık A'nın 5 geciken müdahalesi ortalama 306 dakika bekler ve **11.040
etki-dakika** üretir; B'nin tek geciken müdahalesi 60 dakikada 180 etki-dakika. Değiş tokuş tek
satırda okunur: A'dan B'ye geçiş 16 saatlik uykuya karşılık 10.860 etki-dakika satın alır, yani
**uyanık kalınan saat başına 678,8 etki-dakika**. **Doğru etiket oranı bir kalite ölçüsü değildir;
iki yönün bedeli farklı birimdedir ve ancak ayrı ayrı sayılırsa karşılaştırılabilir.**

## Kuralın Göremediği Sessiz Bozulma

Üçüncü tablo A'nın nerede yanıldığını gösterir. `d4` satırında dört gerçek `d1` vardır: kural bu
dört olayı iş listesine atmıştır. Dördü de aynı yerdedir — `faturalama` servisinde veri kaybı, hata
oranı 0,01 ile 0,05 arasında, gecikme katı 1,2 ile 1,8 arasında. **Sessiz bozulma görünür imzada
sağlıklı bir servisten ayırt edilemez**; 11.040 etki-dakikanın tamamı bu dört olaydan gelir.

B bu dördünü yakalar, ama bunu bir kuralla değil bir **istisnayla** yapar: `faturalama` servisinin
tabanını `d2`'ye çeker. İstisna sessizliği görmez, sessizliğin nerede olduğunu ezberler. Fiyatı da
budur — o servisin hafif olayları da çağrı üretmeye başlar ve B'nin gereksiz uyandırması 3'ten
7'ye çıkar. B'nin kaçırdığı tek olay `dogrulayici` servisindeki sessiz bir `d2`'dir: **istisna
yazılmayan yerde aynı boşluk durmaktadır.**

`d2` satırındaki on olay ters yöndedir: gerçek `d3` olan olaylar üretim ortamında 0,25 üstü hata
oranı gösterdiği için yükseltilmiştir. Bu on yükseltmenin bedeli neredeyse sıfırdır, çünkü
çoğu gündüz düşer. **Aynı sayıdaki yanlış etiket, düştüğü saate göre bedelsiz ya da dört saatliktir.**

## Zincir Kaç Basamak, Basamak Kaç Dakika

Dördüncü tablo B'nin ürettiği 40 çağrıyı tırmandırma zincirinden geçirir; 12'si gecedir ve gece
yanıt olasılığı düşüktür. İki basamaklı zincirde **5 olay kimseye ulaşmaz**. Üçüncü basamak bu
sayıyı 2'ye indirir, ortalama basamak 1,4'ten 1,6'ya çıkar ve toplam uyanan kişi 57'den 62'ye
yükselir: beş olayın üçünü kurtarmak beş ek uyandırmaya mal olur. **Dördüncü basamak hiçbir şey
kazandırmaz** — ulaşılamayan olay 2'de kalır, uyanan kişi 64'e çıkar.

Bekleme süresi ikinci eksendir ve ulaşılamayanı hiç değiştirmez: 5 dakikadan 15 dakikaya çıkarmak
ortalama ulaşmayı 2,8'den 8,3 dakikaya taşır, karşılığında tek bir olay kazandırmaz. **Zincirin
uzunluğu kaç olayın karşılandığını, bekleme süresi yalnız ne kadar geç karşılandığını belirler.**

## Özet

- Altmış olayın 26'sı gerçekten çağrı hak eder; eşik kuralı 31, ihtiyatlı kural 40 çağrı üretir ve
  her ikisi de gerçeğin üstünde kalır.
- Doğru etiket sayısı A'da 37, B'de 27'dir; buna karşılık A 11.040, B 180 etki-dakika üretir —
  doğruluk oranı iki yönün bedelini ölçmez.
- İki yön ayrı birimdedir: A'da 3 gereksiz gece uyandırma (12 saat) ve 5 geciken müdahale
  (ortalama 306 dakika); B'de 7 uyandırma (28 saat) ve 1 geciken müdahale (60 dakika). Geçişin
  fiyatı uyanık kalınan saat başına 678,8 etki-dakikadır.
- A'nın kaçırdığı dört `d1` olayının dördü de `faturalama` servisinde sessiz veri kaybıdır: hata
  oranı 0,01–0,05, gecikme katı 1,2–1,8. Görünür imza sessizliği sağlıklıdan ayıramaz.
- Tırmandırmada iki basamak 5 olayı kimseye ulaştıramaz; üçüncü basamak bunu 2'ye indirir ve 5 ek
  uyandırmaya mal olur, dördüncü basamak yalnız 2 kişi daha uyandırır.
- Bekleme süresini 5'ten 15 dakikaya çıkarmak ortalama ulaşmayı 2,8'den 8,3 dakikaya taşır,
  ulaşılamayan olay sayısını hiç değiştirmez.

## Sonraki Adım

Yedi sorudan dördü çağrı anında yanıtlanır; "olay kaç aboneyi etkiledi", "etiket doğru muydu" ve
"kimseye ulaşmadıysa ne oldu" ancak olay kapandıktan sonra yanıtlanabilir. Çağrı doğru kişiye
doğru düzeyde ulaştığında geriye tek soru kalır: **hangi adımla** kapanacak. Sonraki ders bu adımı
bir belge olarak ölçer — kaç adım, kaç karar noktası, kaçı otomatikleştirilebilir, yordamla ve
yordamsız kapanış süresi ne kadar farklı ve bir dönem sonra kaç adım geçersiz.
