داربست — خودآموز MLOps و مهندسی سامانه‌های هوش مصنوعی (پیشرفته)

فصل ۷ از ۸

پیشرفت ترم
۰٪

در این فصل چه یاد می‌گیری#

یک حادثهٔ واقعی را با ساعتِ مجازی بازپخش می‌کنیم: روزِ ۸۰ ساعتِ ۹ صبح یک نسخهٔ تازه مستقر می‌شود که مسیرِ پیش‌پردازشش هر تیکت را به پنجاه نویسهٔ آخرش می‌بُرد. خطِ زمانی را کد می‌سازد، نه حافظهٔ کسی.

بعد دو تصمیم را جدا از هم اندازه می‌گیریم و هر دو گران‌اند:

  • کدام آشکارساز؟ سیگنالِ بی‌نیاز از برچسب در ۷ ساعت خبر می‌دهد و متریکِ برچسب‌خواه در ۲٫۶۲ روز. ۴ کاربرِ آسیب‌دیده در برابرِ ۴۰.
  • اول مهار یا اول ریشه‌یابی؟ مهارِ اول ۷٫۸ ساعت و ۴ آسیب‌دیده؛ ریشه‌یابیِ اول ۱٫۳۱ روز و ۲۳ آسیب‌دیده — ۵٫۷۵ برابر.

و بدترین ترکیبِ ممکن — آشکارسازِ کند به‌علاوهٔ ریشه‌یابیِ اول — ۳٫۶۵ روز، ۴۳۸ درخواست، ۶۳ کاربرِ آسیب‌دیده: نزدیک به شانزده برابرِ بهترین حالت، با همان باگ و همان تیم.

شیرِ قطعِ اضطراری کنارِ درِ بازِ یک محفظهٔ بازرسی

آخر این فصل می‌توانی:

  • خطِ زمانیِ حادثه را از پیشامدها بسازی، نه از یادِ آدم‌ها
  • زمان تا تشخیص و زمان تا مهار را جدا اندازه بگیری و بدانی هرکدام را چه چیزی کوتاه می‌کند
  • گزارشِ بدونِ سرزنش بنویسی که هر بندش به یک آزمونِ اجراشدنی وصل باشد
  • بگویی چرا در دقایقِ اول «چرا» سؤالِ اشتباهی است

قبل از شروع#

از فصلِ ۴: آشکارسازِ برندهٔ آنجا (آستانهٔ ۰٫۸۵ با پایداریِ ۳ از ۵) اینجا دوباره می‌آید و این بار زمانِ واقعی‌اش را می‌شماریم.

از فصلِ ۳: نرخِ کم‌اطمینان برای رانشِ مفهوم بی‌فایده بود. این فصل نشان می‌دهد برای خرابیِ مسیرِ داده بهترین چیزی است که داری — و این تفاوت اتفاقی نیست: وقتی ورودیِ مدل خراب شود، مدل واقعاً کمتر مطمئن می‌شود؛ وقتی جوابِ درست عوض شود، نمی‌شود.

از ترمِ ۴ فصلِ ۴: ساعتِ مجازی. کلِ خطِ زمانیِ این فصل روی همان ساعت ساخته می‌شود.

📓 نوت‌بوک: نوت‌بوک این فصل را در Colab باز کن — همهٔ کدهای این فصل آماده و به‌ترتیب داخلش هست.

اجرا زمانِ تقریبی
کلِ نوت‌بوک روی CPU حدودِ یک دقیقه
GPU لازم نیست

۱. حادثه، و دو نشانه‌اش#

import random
import statistics

MODEL = fit_model(TRAIN)
FIRST_DAY, LAST_DAY = 78, 86
STREAM = span(FIRST_DAY, LAST_DAY, "N")        # یک درخواست هر ۷۲۰ ثانیه
GAP = 86400 / DAY_SIZE
DEPLOY_AT = 80 * 86400 + 9 * 3600              # روزِ ۸۰، ساعتِ ۹ صبح
LOW_CONF = 0.90


def stamp(seconds):
    day, rest = divmod(int(seconds), 86400)
    return f"روزِ {day} · {rest // 3600:02d}:{(rest % 3600) // 60:02d}"


def prepare(text, broken):
    """نسخهٔ خراب متن را به پنجاه نویسهٔ آخرش می‌بُرد — یک باگِ برشِ ساده."""
    clean = normalise(text)
    return clean[-50:] if broken else clean


HEALTHY = [prepare(r["text"], False) for r in STREAM]
BROKEN = [prepare(r["text"], True) for r in STREAM]
OK_SAYS = list(MODEL.predict(HEALTHY))
BAD_SAYS = list(MODEL.predict(BROKEN))
OK_CONF = [float(max(p)) for p in MODEL.predict_proba(HEALTHY)]
BAD_CONF = [float(max(p)) for p in MODEL.predict_proba(BROKEN)]
print("درخواست‌ها:", len(STREAM), "· فاصلهٔ هر درخواست:", int(GAP), "ثانیه")
print("لحظهٔ استقرارِ خراب:", stamp(DEPLOY_AT))
print(f"سالم : دقت {sum(a == r['category'] for a, r in zip(OK_SAYS, STREAM)) / len(STREAM):.4f}"
      f" · اطمینان {statistics.mean(OK_CONF):.4f}"
      f" · نرخِ زیرِ ۰٫۹ {sum(c < LOW_CONF for c in OK_CONF) / len(OK_CONF):.4f}")
print(f"خراب : دقت {sum(a == r['category'] for a, r in zip(BAD_SAYS, STREAM)) / len(STREAM):.4f}"
      f" · اطمینان {statistics.mean(BAD_CONF):.4f}"
      f" · نرخِ زیرِ ۰٫۹ {sum(c < LOW_CONF for c in BAD_CONF) / len(BAD_CONF):.4f}")
درخواست‌ها: 960 · فاصلهٔ هر درخواست: 720 ثانیه
لحظهٔ استقرارِ خراب: روزِ 80 · 09:00
سالم : دقت 0.8760 · اطمینان 0.8979 · نرخِ زیرِ ۰٫۹ 0.2052
خراب : دقت 0.7552 · اطمینان 0.8004 · نرخِ زیرِ ۰٫۹ 0.5135

نرخِ کم‌اطمینان از ۰٫۲۱ به ۰٫۵۱ می‌رود — بیش از دو برابر — و هیچ برچسبی لازم ندارد.

دقت هم دوازده واحد می‌افتد ولی دیدنش برچسب می‌خواهد. در فصلِ ۳ همین نرخِ کم‌اطمینان روی رانشِ مفهوم همبستگیِ صفر داشت. اینجا بهترین سیگنالِ ماست، چون این بار خرابی در ورودیِ مدل است نه در جوابِ درست، و مدل واقعاً کمتر می‌داند.

۲. بازپخش، و خطِ زمانی که کد می‌نویسدش#

WINDOW = 40                                    # درخواست، برای سیگنالِ بی‌نیاز از برچسب
FIRE_AT = 0.40
NEED_WINDOWS = 2
DAILY_LIMIT = 0.85                             # همان آستانهٔ فصلِ ۴
DAILY_NEED = 3                                 # ۳ روز از ۵ روز
AUDIT = 60
ACK_DELAY = 30 * 60                            # فرض: کشیک نیم ساعت بعد جواب می‌دهد
ROLLBACK_TIME = 15 * 60                        # فرض: برگشت یک ربع طول می‌کشد
INVESTIGATE_TIME = 24 * 3600                   # فرض: ریشه‌یابی یک شبانه‌روز


def replay(detector="کم‌اطمینان", contain_first=True):
    """حادثه را با ساعتِ مجازی بازپخش می‌کند و خطِ زمانی‌اش را خودش می‌سازد."""
    clock, log = Clock(start=FIRST_DAY * 86400), []
    deployed, alert, acked, fixed = False, None, None, None
    window, hits, harmed, broken_n = [], 0, 0, 0
    per_day, daily = {}, []

    def note(text):
        log.append((clock.now(), text))

    note("سرویس سالم · نسخهٔ ۱٫۰٫۰")
    for index, row in enumerate(STREAM):
        now = clock.jump_to(FIRST_DAY * 86400 + index * GAP)
        day = int(now // 86400)
        if not deployed and now >= DEPLOY_AT:
            deployed = True
            note("استقرارِ نسخهٔ ۱٫۱٫۰ · مسیرِ پیش‌پردازش عوض شد")
        broken = deployed and (fixed is None or now < fixed)
        said = BAD_SAYS[index] if broken else OK_SAYS[index]
        conf = BAD_CONF[index] if broken else OK_CONF[index]
        if broken:
            broken_n += 1
            harmed += said != row["category"] and OK_SAYS[index] == row["category"]
        per_day.setdefault(day, []).append(said == row["category"])
        window.append(conf < LOW_CONF)
        window[:] = window[-WINDOW:]

        if alert is None and detector == "کم‌اطمینان" and index % 10 == 0 and len(window) == WINDOW:
            share = sum(window) / WINDOW
            hits = hits + 1 if share > FIRE_AT else 0
            if hits >= NEED_WINDOWS:
                alert, acked = now, now + ACK_DELAY
                note(f"هشدار: نرخِ کم‌اطمینان {share:.2f} در {WINDOW} درخواستِ آخر")

        if alert is None and detector == "دقتِ روزانه" and day - 1 in per_day and \
                len(per_day[day]) == 1:
            picker = random.Random(f"audit:{day - 1}")
            hitlist = per_day[day - 1]
            picked = picker.sample(range(len(hitlist)), min(AUDIT, len(hitlist)))
            daily.append((day - 1, sum(hitlist[i] for i in picked) / len(picked)))
            recent = daily[-5:]
            if sum(v < DAILY_LIMIT for _, v in recent) >= DAILY_NEED:
                alert, acked = now, now + ACK_DELAY
                note("هشدار: دقتِ نمونهٔ برچسب‌خورده، ۳ روز از ۵ روزِ آخر زیرِ ۰٫۸۵")

        if acked is not None and now >= acked:
            note("کشیک تأیید کرد · شروعِ رسیدگی")
            wait = ROLLBACK_TIME if contain_first else INVESTIGATE_TIME
            fixed = acked + wait
            note(("مهار: برگشت به نسخهٔ ۱٫۰٫۰ در " if contain_first
                  else "ریشه‌یابی اول · رفعِ اشکال در ") + stamp(fixed))
            acked = None
        if fixed is not None and now >= fixed and log[-1][1] != "سرویس به حالتِ سالم برگشت":
            note("سرویس به حالتِ سالم برگشت")
    note("پایانِ بازپخش")
    return {"log": log, "alert": alert, "fixed": fixed, "daily": daily,
            "harmed": harmed, "broken": broken_n}


FAST = replay()
for moment, text in FAST["log"]:
    print(f"[{stamp(moment)}] {text}")
[روزِ 78 · 00:00] سرویس سالم · نسخهٔ ۱٫۰٫۰
[روزِ 80 · 09:00] استقرارِ نسخهٔ ۱٫۱٫۰ · مسیرِ پیش‌پردازش عوض شد
[روزِ 80 · 16:00] هشدار: نرخِ کم‌اطمینان 0.50 در 40 درخواستِ آخر
[روزِ 80 · 16:36] کشیک تأیید کرد · شروعِ رسیدگی
[روزِ 80 · 16:36] مهار: برگشت به نسخهٔ ۱٫۰٫۰ در روزِ 80 · 16:45
[روزِ 80 · 16:48] سرویس به حالتِ سالم برگشت
[روزِ 85 · 23:48] پایانِ بازپخش

این هفت سطر محصولِ اصلیِ فصل‌اند و هیچ‌کدامشان را آدمی ننوشته.

هر سطر یک زمان دارد که از ساعتِ مجازی می‌آید، پس فردا هر کسی نوت‌بوک را اجرا کند همین هفت سطر را می‌گیرد. این تفاوتِ «خطِ زمانی» و «آنچه یادمان می‌آید» است — و در جلسهٔ بررسیِ حادثه، تنها چیزی که کسی نمی‌تواند دربارهٔ آن بحث کند همین است.

دو فرضِ صریح در کد نوشته شده‌اند تا کسی آن‌ها را با اندازه‌گیری اشتباه نگیرد: کشیک نیم ساعت بعد جواب می‌دهد و برگشت یک ربع طول می‌کشد. این‌ها را ما گذاشتیم، نه اینکه سنجیده باشیم. در تیمِ خودت این دو عدد را باید از سیاههٔ حادثه‌های واقعی دربیاوری، و اگر نداری‌شان، اولین اقدامِ اصلاحی‌ات همین است.

۳. سه عدد که هر حادثه دارد#

def span_of(seconds):
    return f"{seconds / 3600:.1f} ساعت" if seconds < 86400 else f"{seconds / 86400:.2f} روز"


print(f"{'شاخص':<36}{'مقدار':>14}")
print(f"{'زمان تا تشخیص':<36}{span_of(FAST['alert'] - DEPLOY_AT):>14}")
print(f"{'زمان از تشخیص تا مهار':<36}{span_of(FAST['fixed'] - FAST['alert']):>14}")
print(f"{'زمان تا بازیابی':<36}{span_of(FAST['fixed'] - DEPLOY_AT):>14}")
print(f"{'درخواستِ سروشده با نسخهٔ خراب':<36}{FAST['broken']:>14}")
print(f"{'کاربرانِ آسیب‌دیده':<36}{FAST['harmed']:>14}")
شاخص                                         مقدار
زمان تا تشخیص                             7.0 ساعت
زمان از تشخیص تا مهار                     0.8 ساعت
زمان تا بازیابی                           7.8 ساعت
درخواستِ سروشده با نسخهٔ خراب                   39
کاربرانِ آسیب‌دیده                               4

۷ ساعت از ۷٫۸ ساعت را تشخیص خورد. یعنی نودِ درصدِ کلِ حادثه پیش از آن بود که کسی بفهمد اتفاقی افتاده.

این تقسیم‌بندی مهم‌تر از عددِ کل است. اگر فقط «۷٫۸ ساعت طول کشید» را گزارش کنی، جلسه دربارهٔ سرعتِ برگشت بحث می‌کند — که سریع‌ترین بخشِ ماجرا بود. عددِ قابلِ بهبود، عددِ تشخیص است، و بخشِ بعد نشان می‌دهد چقدر می‌شود بهترش کرد یا بدترش.

۴. انتخابِ آشکارساز، با قیمتش#

SLOW_DETECT = replay(detector="دقتِ روزانه")
print(f"{'آشکارساز':<20}{'برچسب لازم دارد؟':>20}{'زمان تا تشخیص':>18}"
      f"{'درخواستِ خراب':>16}{'آسیب‌دیده':>12}")
for name, run, needs in (("نرخِ کم‌اطمینان", FAST, "نه"),
                         ("دقتِ روزانه", SLOW_DETECT, "بله")):
    print(f"{name:<20}{needs:>20}{span_of(run['alert'] - DEPLOY_AT):>18}"
          f"{run['broken']:>16}{run['harmed']:>12}")
print("دقتِ روزانه‌ای که آشکارسازِ دوم دید:",
      [(d, round(v, 3)) for d, v in SLOW_DETECT["daily"]])
آشکارساز                برچسب لازم دارد؟     زمان تا تشخیص   درخواستِ خراب   آسیب‌دیده
نرخِ کم‌اطمینان                       نه          7.0 ساعت              39           4
دقتِ روزانه                          بله          2.62 روز             319          40
دقتِ روزانه‌ای که آشکارسازِ دوم دید: [(78, 0.883), (79, 0.833), (80, 0.867), (81, 0.75), (82, 0.783)]

۷ ساعت در برابرِ ۲٫۶۲ روز. ده برابر کاربرِ آسیب‌دیده.

فهرستِ دقتِ روزانه توضیحش را می‌دهد. روزِ ۸۰ فقط از ساعتِ ۹ صبح خراب بود، پس دقتش ۰٫۸۶۷ ماند و از آستانه رد نشد. روزِ ۸۱ کاملاً خراب بود (۰٫۷۵۰) و روزِ ۸۲ هم (۰٫۷۸۳) — و شرطِ «۳ روز از ۵ روز» تازه آن‌وقت برقرار شد، آن هم صبحِ روزِ بعد، چون برچسبِ هر روز فردایش می‌رسد. روزِ سومی که شرط را پر کرد روزِ ۷۹ بود (۰٫۸۳۳)، یک روزِ کاملاً سالمِ پیش از استقرار که از شانس زیرِ آستانه افتاده بود.

هیچ‌کدام از این تأخیرها باگ نیستند؛ همه‌شان طراحی‌اند — و هر کدام را می‌شود جدا کوتاه کرد: پنجرهٔ کوچک‌ترِ ارزیابی، برچسبِ سریع‌تر، یا رفتن سراغِ سیگنالی که اصلاً برچسب نمی‌خواهد.

✅ چک کن: برای سرویسِ خودت این سؤال را جواب بده: «اگر همین حالا نسخهٔ خرابی مستقر شود، چند ساعت طول می‌کشد تا اولین هشدار بیاید؟» جوابت باید یک عدد باشد. اگر جوابت «بستگی دارد» است، احتمالاً هیچ آشکارسازِ بی‌نیاز از برچسبی نداری و در بهترین حالت تا فردای برچسب‌ها منتظری.

۵. اول مهار کن، بعد بفهم چرا#

SLOW_FIX = replay(contain_first=False)
print(f"{'استراتژی':<22}{'زمان تا بازیابی':>18}{'درخواستِ خراب':>16}{'آسیب‌دیده':>12}")
for name, run in (("مهارِ اول", FAST), ("ریشه‌یابیِ اول", SLOW_FIX)):
    print(f"{name:<22}{span_of(run['fixed'] - DEPLOY_AT):>18}"
          f"{run['broken']:>16}{run['harmed']:>12}")
print("نسبتِ آسیب:", round(SLOW_FIX["harmed"] / FAST["harmed"], 2), "برابر")
worst = replay(detector="دقتِ روزانه", contain_first=False)
print("بدترین ترکیب (آشکارسازِ کند + ریشه‌یابیِ اول):",
      span_of(worst["fixed"] - DEPLOY_AT), "·", worst["broken"], "درخواست ·",
      worst["harmed"], "آسیب‌دیده")
استراتژی                 زمان تا بازیابی   درخواستِ خراب   آسیب‌دیده
مهارِ اول                       7.8 ساعت              39           4
ریشه‌یابیِ اول                  1.31 روز             158          23
نسبتِ آسیب: 5.75 برابر
بدترین ترکیب (آشکارسازِ کند + ریشه‌یابیِ اول): 3.65 روز · 438 درخواست · 63 آسیب‌دیده

۴ در برابرِ ۲۳، و در بدترین ترکیب ۶۳.

قاعدهٔ مهار در یک جمله: در دقایقِ اولِ حادثه، «چرا» سؤالِ اشتباهی است. سؤالِ درست «چطور جلوی ادامه‌اش را بگیرم» است، و جوابش تقریباً همیشه برگشت به نسخهٔ قبلی است. ریشه‌یابی بعد از مهار هم دقیقاً همان‌قدر ممکن است — با این تفاوت که دیگر کسی آسیب نمی‌بیند و می‌شود با خیالِ راحت انجامش داد.

و همان استدلال یک استثنا دارد که باید صریح گفته شود: اگر برگشت خودش خطرناک باشد — مثلاً نسخهٔ تازه ساختارِ داده را عوض کرده باشد — مهارِ سریع دیگر رایگان نیست. آنجا مهار یعنی خاموش کردنِ همان قابلیت یا رفتن به مسیرِ پشتیبان، نه لزوماً برگشتِ نسخه. این همان قاعدهٔ «تغییرِ ساختار فقط افزایشی» است که ترمِ ۴ فصلِ ۹ به آن رسید.

📏 اندازه بگیر: با چه چیزی مقایسه شد؟ با همان حادثه، همان ترافیک و همان مدل؛ تنها متغیر آشکارساز و استراتژیِ مهار بود. روی کدام داده؟ هشت روز ترافیک از روزِ ۷۸ تا ۸۵، ۹۶۰ درخواست، یکسان در هر چهار بازپخش. با چند seed؟ یکی — و اینجا اصلاً تصادفی در کار نیست: ساعت مجازی است، قرعهٔ نمونهٔ برچسب از شمارهٔ روز می‌آید، و همهٔ جواب‌های مدل از پیش محاسبه شده‌اند. هر چهار بازپخش روی هر ماشینی همین عددها را می‌دهند.

۶. گزارشِ بدونِ سرزنش#

ACTIONS = [
    ("مسیرِ پیش‌پردازش تستِ ناوردایی نداشت",
     "تستی که طولِ متنِ خروجی را با ورودی مقایسه کند", "ترمِ ۱ فصلِ ۳"),
    ("انتشار مرحلهٔ سایه نداشت",
     "اختلافِ جواب با نسخهٔ زنده روی هزار درخواست، پیش از هر ترافیکی", "ترمِ ۴ فصلِ ۶"),
    ("هشدار فقط روی متریکِ برچسب‌خواه بود",
     "نرخِ کم‌اطمینان به‌عنوان هشدارِ درجه‌یک، با آستانه از نویزِ خودش", "فصلِ ۴"),
    ("برگشت تمرین‌نشده بود",
     "تمرینِ ماهانهٔ برگشت با هدفِ زیرِ پنج دقیقه", "ترمِ ۴ فصلِ ۹"),
]


def report(run):
    lines = ["## گزارشِ حادثه — استقرارِ نسخهٔ ۱٫۱٫۰", "",
             f"**اثر:** {run['broken']} درخواست با نسخهٔ خراب سرو شد و {run['harmed']}"
             " کاربر جوابی گرفتند که نسخهٔ قبلی درست جواب داده بود.",
             f"**زمان تا تشخیص:** {span_of(run['alert'] - DEPLOY_AT)} پس از استقرار.",
             f"**زمان تا بازیابی:** {span_of(run['fixed'] - DEPLOY_AT)} پس از استقرار.", "",
             "**خطِ زمانی:**"]
    lines += [f"- {stamp(t)} — {text}" for t, text in run["log"]]
    lines += ["", "**علتِ فنی:** مسیرِ پیش‌پردازش متن را به پنجاه نویسهٔ آخر بُرید.",
              "", "**اقدامِ اصلاحی:**"]
    lines += [f"- {gap} → **{fix}** ({where})" for gap, fix, where in ACTIONS]
    return "\n".join(lines)


print(report(FAST))
## گزارشِ حادثه — استقرارِ نسخهٔ ۱٫۱٫۰

**اثر:** 39 درخواست با نسخهٔ خراب سرو شد و 4 کاربر جوابی گرفتند که نسخهٔ قبلی درست جواب داده بود.
**زمان تا تشخیص:** 7.0 ساعت پس از استقرار.
**زمان تا بازیابی:** 7.8 ساعت پس از استقرار.

**خطِ زمانی:**
- روزِ 78 · 00:00 — سرویس سالم · نسخهٔ ۱٫۰٫۰
- روزِ 80 · 09:00 — استقرارِ نسخهٔ ۱٫۱٫۰ · مسیرِ پیش‌پردازش عوض شد
- روزِ 80 · 16:00 — هشدار: نرخِ کم‌اطمینان 0.50 در 40 درخواستِ آخر
- روزِ 80 · 16:36 — کشیک تأیید کرد · شروعِ رسیدگی
- روزِ 80 · 16:36 — مهار: برگشت به نسخهٔ ۱٫۰٫۰ در روزِ 80 · 16:45
- روزِ 80 · 16:48 — سرویس به حالتِ سالم برگشت
- روزِ 85 · 23:48 — پایانِ بازپخش

**علتِ فنی:** مسیرِ پیش‌پردازش متن را به پنجاه نویسهٔ آخر بُرید.

**اقدامِ اصلاحی:**
- مسیرِ پیش‌پردازش تستِ ناوردایی نداشت → **تستی که طولِ متنِ خروجی را با ورودی مقایسه کند** (ترمِ ۱ فصلِ ۳)
- انتشار مرحلهٔ سایه نداشت → **اختلافِ جواب با نسخهٔ زنده روی هزار درخواست، پیش از هر ترافیکی** (ترمِ ۴ فصلِ ۶)
- هشدار فقط روی متریکِ برچسب‌خواه بود → **نرخِ کم‌اطمینان به‌عنوان هشدارِ درجه‌یک، با آستانه از نویزِ خودش** (فصلِ ۴)
- برگشت تمرین‌نشده بود → **تمرینِ ماهانهٔ برگشت با هدفِ زیرِ پنج دقیقه** (ترمِ ۴ فصلِ ۹)

در کلِ این گزارش هیچ اسمی نیست، و این یک تصمیمِ طراحی است نه ادب.

دلیلش عملی است: اگر گزارشِ حادثه جای پیدا کردنِ مقصر باشد، دفعهٔ بعد حادثه دیرتر گزارش می‌شود — و تأخیرِ گزارش دقیقاً همان چیزی است که بخشِ ۴ نشان داد چقدر گران است. گزارشِ بدونِ سرزنش سازوکارِ ارزان‌تری برای رسیدن به همان اطلاعات است، نه یک ژستِ اخلاقی.

و ستونِ اقدامِ اصلاحی شکلِ خاصی دارد: هر بند یک شکاف را به یک آزمونِ اجراشدنی وصل می‌کند. «دقت بیشتری می‌کنیم» اقدامِ اصلاحی نیست، چون هیچ‌وقت نمی‌شود گفت انجام شد یا نه.

۷. آزمونِ خودِ گزارش#

BLAME = ["مقصر", "کوتاهی", "حواسش نبود", "باید دقت می‌کرد", "تقصیر"]
TEXT = report(FAST)
print("کلمه‌های سرزنش‌آمیز در گزارش:", [w for w in BLAME if w in TEXT])
print("سطرهای خطِ زمانی:", len(FAST["log"]))
print("اقدامِ اصلاحی:", len(ACTIONS),
      "· آن‌هایی که یک آزمونِ اجراشدنی دارند:",
      sum(1 for _, fix, _ in ACTIONS
          if any(k in fix for k in ("تست", "اختلاف", "آستانه", "تمرین"))))
undetected = {"alert": None}                   # حادثه‌ای که هیچ‌وقت هشدار نداد
try:
    span_of(undetected["alert"] - DEPLOY_AT)
except TypeError as exc:
    print("TypeError:", exc)
کلمه‌های سرزنش‌آمیز در گزارش: []
سطرهای خطِ زمانی: 7
اقدامِ اصلاحی: 4 · آن‌هایی که یک آزمونِ اجراشدنی دارند: 4
TypeError: unsupported operand type(s) for -: 'NoneType' and 'int'

چهار اقدام، چهارتایشان قابلِ اجرا و قابلِ بستن. هر کدام هم به فصلی وصل است که سازوکارش را ساخته — یعنی هیچ‌کدامشان کارِ تازه‌ای نیستند؛ کارهایی‌اند که می‌دانستیم و نکرده بودیم. این معمولاً درست‌ترین یافتهٔ یک بررسیِ حادثه است.

🔧 اگر کار نکرد: اگر «زمان تا تشخیص» را برای حادثه‌ای حساب کنی که هیچ‌وقت هشدار نداد، این را می‌گیری: TypeError: unsupported operand type(s) for -: 'NoneType' and 'int'. و این خطا از یک عددِ قشنگ بهتر است. وسوسه‌ای که باید مقاومت کنی این است که در چنین حالتی صفر یا «کلِ مدت» بگذاری؛ هر دو داشبوردت را دربارهٔ بدترین دستهٔ حادثه — آن‌هایی که خودت پیدایشان نکردی و کاربر خبرت کرد — دروغ‌گو می‌کند. حالتِ درست یک دستهٔ جداست: «تشخیص از بیرون».

🤖 از دستیارت بپرس: «تفاوتِ incident commander و subject matter expert در مدیریتِ حادثه چیست و چرا این دو نقش را به یک نفر نمی‌دهند؟» بعد این را بپرس: «چطور تصمیم بگیرم یک حادثه چه درجه‌ای دارد، وقتی هنوز نمی‌دانم علتش چیست؟» — جوابِ درست به معیارهای مبتنی بر اثر می‌رسد (چند کاربر، کدام قابلیت)، نه بر علت.

واژه‌های تازهٔ این فصل#

کلمه تلفظ به حروف فارسی یعنی چه
incident اینسیدنت خرابی‌ای که به کاربر می‌رسد و رسیدگیِ فوری می‌خواهد
detection time دیتکشن تایم فاصلهٔ شروعِ خرابی تا اولین هشدارِ درست
mitigation میتیگیشن متوقف کردنِ آسیب، پیش از فهمیدنِ علت
recovery time ریکاوری تایم فاصلهٔ شروعِ خرابی تا برگشتِ سرویس به حالتِ سالم
blameless postmortem بلیملس پست‌مورتم گزارشی که به‌جای آدم، سازوکارِ ناقص را نام می‌برد
corrective action کورکتیو اکشن کارِ مشخصی که تکرارِ همان خرابی را سخت‌تر می‌کند
timeline تایم‌لاین فهرستِ زمان‌دارِ اتفاق‌ها، ساخته‌شده از پیشامدها

تمرین‌ها

اول خودت فکر کن یا امتحان کن — بعد اینجا را باز کن.

در فصل بعد#

ترمِ ۵ تمام می‌شود، با پروژه. همهٔ هفت فصل را در یک خطِ کامل کنارِ هم می‌گذاریم: رانشِ ساختگی می‌سازیم، پایشش می‌کنیم، هشدار می‌گیریم، بازآموزی می‌کنیم، و گزارشی تولید می‌کنیم که کد نوشته باشدش.

و در همان یک اجرا، هزینهٔ هر تصمیم را جدا می‌شماریم: برچسب، هشدار، روزِ بد، و کاربرِ آسیب‌دیده.

به آخر این فصل رسیدی!

اگر ساختی و جواب داد، این دکمه مال توست.