File size: 4,252 Bytes
6655381 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | """World model: builds runtime state from a task spec, derives metrics deterministically.
Everything the agent observes is derived from state. There are no scripted metric
curves: fix the state and the metrics follow. Randomness is seeded and stable
across processes (no builtin hash()).
"""
from __future__ import annotations
import copy
import hashlib
import json
def stable_hash(*parts) -> int:
h = hashlib.sha256("|".join(str(p) for p in parts).encode("utf-8")).digest()
return int.from_bytes(h[:8], "big")
def build_world(spec: dict) -> dict:
"""Deep-copy the static spec into a mutable runtime world."""
w = copy.deepcopy(spec)
w["t"] = 0.0 # minutes since sim start; alert fires at t=0
w["restarts"] = {}
w["report"] = None
w["drained_hosts"] = []
for name, svc in w["services"].items():
svc["initial_replicas"] = svc["replicas"]
svc["initial_version"] = svc["deploys"][-1]["version"]
svc["initial_config"] = copy.deepcopy(svc["config"])
return w
def current_version(w: dict, svc: str) -> str:
return w["services"][svc]["deploys"][-1]["version"]
def replicas_on_host(w: dict, svc: str, host: str) -> int:
hosts = w["services"][svc]["hosts"]
if not hosts:
return 0
# replicas are distributed round-robin over the host list
total = w["services"][svc]["replicas"]
if host not in hosts:
return 0
return total // len(hosts) + (1 if hosts.index(host) < total % len(hosts) else 0)
def frac_on_host(w: dict, svc: str, host: str) -> float:
total = w["services"][svc]["replicas"]
if total == 0:
return 0.0
return replicas_on_host(w, svc, host) / total
def contributions(w: dict) -> list[tuple[str, dict]]:
"""Yield (label, {svc: {error_pct, p99_ms, mem_pct}}) for every fault and decoy."""
from . import faults as F
out = []
for f in w["faults"]:
cls = F.FAULT_TYPES[f["type"]]
out.append((f["type"], cls.impact(w, f["params"])))
for d in w["decoys"]:
cls = F.DECOY_ALIASES[d["type"]]
out.append(("decoy:" + d["type"], cls.impact(w, d["params"])))
return out
def agg(w: dict, svc: str, key: str) -> float:
total = 0.0
for _, contrib in contributions(w):
total += contrib.get(svc, {}).get(key, 0.0)
return total
def metrics(w: dict, svc: str) -> dict:
s = w["services"][svc]
seed = w["seed"]
err = s["base_error_pct"] + agg(w, svc, "error_pct")
err += (stable_hash(seed, svc, w["t"] // 5, "err") % 100) / 10000.0
p99 = s["base_p99_ms"] + agg(w, svc, "p99_ms")
p99 += (stable_hash(seed, svc, w["t"] // 5, "p99") % 100) / 10.0
per_replica = s["runbook"].get("rps_per_replica", 150)
cpu = 70.0 * s["rps"] / max(1, s["replicas"] * per_replica)
cpu = min(99.0, cpu) + (stable_hash(seed, svc, "cpu") % 50) / 10.0
mem = 30.0 + agg(w, svc, "mem_pct")
mem = min(99.0, mem)
if s["kind"] == "external":
return {"status": s.get("status", "up")}
return {
"error_pct": round(err, 3),
"p99_ms": round(p99, 1),
"cpu_pct": round(cpu, 1),
"mem_pct": round(mem, 1),
"rps": s["rps"],
"slo_error_pct": s["slo_error_pct"],
"degraded": err > s["slo_error_pct"],
}
def per_host_metrics(w: dict, svc: str) -> dict:
out = {}
base = w["services"][svc]["base_error_pct"]
for h in w["services"][svc]["hosts"]:
if h in w["drained_hosts"] or not w["hosts"][h]["healthy"]:
e = 55.0
else:
e = base + agg(w, svc, "error_pct")
out[h] = {"replicas": replicas_on_host(w, svc, h), "error_pct": round(e, 2)}
return out
def fmt_clock(w: dict, t: float | None = None) -> str:
t = w["t"] if t is None else t
total = int(round(t))
hh, mm = 9 + (total // 60) % 24, total % 60
return f"{hh:02d}:{mm:02d}"
def log(w: dict, svc: str, level: str, msg: str) -> None:
w["events"].append({"t": round(w["t"], 1), "svc": svc, "level": level, "msg": msg})
def to_json(obj) -> str:
return json.dumps(obj, ensure_ascii=False, separators=(",", ":"))
def is_managed(w: dict, svc: str) -> bool:
s = w["services"].get(svc)
return bool(s and s["kind"] != "external")
|