kubesift 2.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- kubesift/__init__.py +3 -0
- kubesift/analysis/__init__.py +3 -0
- kubesift/analysis/changes.py +165 -0
- kubesift/analysis/correlate.py +160 -0
- kubesift/analysis/describe.py +83 -0
- kubesift/analysis/engine.py +362 -0
- kubesift/analysis/llm.py +152 -0
- kubesift/checks/__init__.py +17 -0
- kubesift/checks/base.py +150 -0
- kubesift/checks/config_refs.py +84 -0
- kubesift/checks/events.py +77 -0
- kubesift/checks/hygiene.py +264 -0
- kubesift/checks/lifecycle.py +202 -0
- kubesift/checks/network.py +325 -0
- kubesift/checks/nodes.py +183 -0
- kubesift/checks/operations.py +319 -0
- kubesift/checks/pods.py +485 -0
- kubesift/checks/storage.py +72 -0
- kubesift/checks/workloads.py +201 -0
- kubesift/cli.py +874 -0
- kubesift/cluster/__init__.py +4 -0
- kubesift/cluster/client.py +141 -0
- kubesift/cluster/snapshot.py +513 -0
- kubesift/config.py +134 -0
- kubesift/cost.py +150 -0
- kubesift/drill_scenarios/01-crashloop-missing-env.yaml +24 -0
- kubesift/drill_scenarios/02-imagepull-wrong-tag.yaml +23 -0
- kubesift/drill_scenarios/03-oomkilled-low-memory.yaml +24 -0
- kubesift/drill_scenarios/04-service-selector-mismatch.yaml +34 -0
- kubesift/drill_scenarios/05-missing-probe-crashloop.yaml +24 -0
- kubesift/drill_scenarios/06-pending-insufficient-resources.yaml +26 -0
- kubesift/drill_scenarios/07-missing-secret.yaml +28 -0
- kubesift/drill_scenarios/08-pvc-missing-storageclass.yaml +38 -0
- kubesift/drill_scenarios/09-netpol-blocks-dns.yaml +14 -0
- kubesift/drill_scenarios/10a-rollout-good.yaml +27 -0
- kubesift/drill_scenarios/10b-rollout-bad.yaml +25 -0
- kubesift/drill_scenarios/__init__.py +1 -0
- kubesift/drills.py +122 -0
- kubesift/knowledge.py +51 -0
- kubesift/leader.py +145 -0
- kubesift/lint.py +89 -0
- kubesift/mcp_server.py +193 -0
- kubesift/models.py +144 -0
- kubesift/notify.py +71 -0
- kubesift/postmortem.py +152 -0
- kubesift/preflight.py +435 -0
- kubesift/redact.py +38 -0
- kubesift/remediate.py +99 -0
- kubesift/report.py +193 -0
- kubesift/runbooks.py +58 -0
- kubesift/server/__init__.py +0 -0
- kubesift/server/app.py +480 -0
- kubesift/server/static/index.html +152 -0
- kubesift/slack.py +106 -0
- kubesift/store.py +219 -0
- kubesift/timetravel.py +156 -0
- kubesift/upgrade.py +51 -0
- kubesift/util.py +174 -0
- kubesift-2.0.0.dist-info/METADATA +192 -0
- kubesift-2.0.0.dist-info/RECORD +63 -0
- kubesift-2.0.0.dist-info/WHEEL +4 -0
- kubesift-2.0.0.dist-info/entry_points.txt +3 -0
- kubesift-2.0.0.dist-info/licenses/LICENSE +202 -0
kubesift/__init__.py
ADDED
|
@@ -0,0 +1,165 @@
|
|
|
1
|
+
"""What changed recently? Most incidents follow a change, so this is the first question to answer."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from datetime import datetime, timedelta
|
|
6
|
+
from typing import Any
|
|
7
|
+
|
|
8
|
+
from kubesift.cluster.snapshot import Snapshot, event_time
|
|
9
|
+
from kubesift.models import Change, ResourceRef
|
|
10
|
+
from kubesift.util import containers_of, meta, now, parse_time
|
|
11
|
+
|
|
12
|
+
_CONTROLLERS = ("kube-controller-manager", "kubelet", "kube-scheduler", "cert-manager-certificates-issuing")
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
def _ref(obj: dict[str, Any]) -> ResourceRef:
|
|
16
|
+
return ResourceRef(kind=obj.get("kind", "?"), name=meta(obj).get("name", ""), namespace=meta(obj).get("namespace"))
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
def last_user_update(obj: dict[str, Any]) -> tuple[datetime | None, str | None]:
|
|
20
|
+
"""Latest spec/data change (ignores status updates and controllers)."""
|
|
21
|
+
best: tuple[datetime | None, str | None] = (None, None)
|
|
22
|
+
for f in meta(obj).get("managedFields") or []:
|
|
23
|
+
if f.get("subresource") == "status" or f.get("manager") in _CONTROLLERS:
|
|
24
|
+
continue
|
|
25
|
+
t = parse_time(f.get("time"))
|
|
26
|
+
if t and (best[0] is None or t > best[0]):
|
|
27
|
+
best = (t, f.get("manager"))
|
|
28
|
+
return best
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
def _template_diff(old: dict[str, Any], new: dict[str, Any]) -> list[str]:
|
|
32
|
+
out: list[str] = []
|
|
33
|
+
o = {c.get("name"): c for c in containers_of(((old.get("spec") or {}).get("template") or {}).get("spec"))}
|
|
34
|
+
n = {c.get("name"): c for c in containers_of(((new.get("spec") or {}).get("template") or {}).get("spec"))}
|
|
35
|
+
for name, nc in n.items():
|
|
36
|
+
oc = o.get(name)
|
|
37
|
+
if oc is None:
|
|
38
|
+
out.append(f"container {name} added")
|
|
39
|
+
continue
|
|
40
|
+
if oc.get("image") != nc.get("image"):
|
|
41
|
+
out.append(f"{name}: image {oc.get('image')} -> {nc.get('image')}")
|
|
42
|
+
if (oc.get("resources") or {}) != (nc.get("resources") or {}):
|
|
43
|
+
out.append(f"{name}: resources {oc.get('resources') or {}} -> {nc.get('resources') or {}}")
|
|
44
|
+
old_env = {e.get("name"): e for e in oc.get("env") or []}
|
|
45
|
+
new_env = {e.get("name"): e for e in nc.get("env") or []}
|
|
46
|
+
added = sorted(set(new_env) - set(old_env))
|
|
47
|
+
removed = sorted(set(old_env) - set(new_env))
|
|
48
|
+
changed = sorted(k for k in set(old_env) & set(new_env) if old_env[k] != new_env[k])
|
|
49
|
+
if added:
|
|
50
|
+
out.append(f"{name}: env added {', '.join(added)}")
|
|
51
|
+
if removed:
|
|
52
|
+
out.append(f"{name}: env removed {', '.join(removed)}")
|
|
53
|
+
if changed:
|
|
54
|
+
out.append(f"{name}: env changed {', '.join(changed)}")
|
|
55
|
+
if (oc.get("envFrom") or []) != (nc.get("envFrom") or []):
|
|
56
|
+
out.append(f"{name}: envFrom changed")
|
|
57
|
+
for field in ("command", "args", "livenessProbe", "readinessProbe", "ports"):
|
|
58
|
+
if oc.get(field) != nc.get(field):
|
|
59
|
+
out.append(f"{name}: {field} changed")
|
|
60
|
+
for name in set(o) - set(n):
|
|
61
|
+
out.append(f"container {name} removed")
|
|
62
|
+
return out
|
|
63
|
+
|
|
64
|
+
|
|
65
|
+
def detect_changes(snap: Snapshot, window: timedelta = timedelta(hours=6)) -> list[Change]:
|
|
66
|
+
cutoff = now() - window
|
|
67
|
+
changes: list[Change] = []
|
|
68
|
+
|
|
69
|
+
# Deployment rollouts, from ReplicaSet revisions
|
|
70
|
+
rs_by_owner: dict[tuple[str | None, str], list[dict[str, Any]]] = {}
|
|
71
|
+
for rs in snap.all("replicasets"):
|
|
72
|
+
for o in meta(rs).get("ownerReferences") or []:
|
|
73
|
+
if o.get("kind") == "Deployment":
|
|
74
|
+
rs_by_owner.setdefault((meta(rs).get("namespace"), o.get("name")), []).append(rs)
|
|
75
|
+
for (ns, name), sets in rs_by_owner.items():
|
|
76
|
+
def rev(r: dict[str, Any]) -> int:
|
|
77
|
+
try:
|
|
78
|
+
return int((meta(r).get("annotations") or {}).get("deployment.kubernetes.io/revision", "0"))
|
|
79
|
+
except ValueError:
|
|
80
|
+
return 0
|
|
81
|
+
sets.sort(key=rev)
|
|
82
|
+
newest = sets[-1]
|
|
83
|
+
t = parse_time(meta(newest).get("creationTimestamp"))
|
|
84
|
+
if not t or t < cutoff:
|
|
85
|
+
continue
|
|
86
|
+
details = _template_diff(sets[-2], newest) if len(sets) > 1 else ["first revision"]
|
|
87
|
+
prev = rev(sets[-2]) if len(sets) > 1 else None
|
|
88
|
+
changes.append(Change(
|
|
89
|
+
time=t, kind="rollout", resource=ResourceRef(kind="Deployment", name=name, namespace=ns),
|
|
90
|
+
summary=f"Deployment {name} rolled out revision {rev(newest)}" + (f": {details[0]}" if details else ""),
|
|
91
|
+
details=details,
|
|
92
|
+
rollback_command=f"kubectl rollout undo deployment/{name} -n {ns}" + (f" --to-revision={prev}" if prev else "")
|
|
93
|
+
if prev else None,
|
|
94
|
+
))
|
|
95
|
+
|
|
96
|
+
# Spec/data edits on tracked objects
|
|
97
|
+
for key in ("configmaps", "secrets", "statefulsets", "daemonsets", "cronjobs", "services", "ingresses",
|
|
98
|
+
"networkpolicies", "hpas", "resourcequotas", "deployments"):
|
|
99
|
+
for obj in snap.all(key):
|
|
100
|
+
if key == "secrets" and obj.get("type") == "helm.sh/release.v1":
|
|
101
|
+
continue
|
|
102
|
+
t, manager = last_user_update(obj)
|
|
103
|
+
created = parse_time(meta(obj).get("creationTimestamp"))
|
|
104
|
+
if not t or t < cutoff:
|
|
105
|
+
continue
|
|
106
|
+
if key == "deployments" and any(c.resource.name == meta(obj).get("name") and c.kind == "rollout"
|
|
107
|
+
and abs((c.time - t).total_seconds()) < 120 for c in changes):
|
|
108
|
+
continue # already covered by the rollout entry
|
|
109
|
+
verb = "created" if created and abs((t - created).total_seconds()) < 5 else "updated"
|
|
110
|
+
kind = "config" if key in ("configmaps", "secrets") else "scale" if key == "hpas" else "other"
|
|
111
|
+
summary = f"{obj.get('kind')} {meta(obj).get('name')} {verb}" + (f" by {manager}" if manager else "")
|
|
112
|
+
details = []
|
|
113
|
+
if kind == "config" and verb == "updated":
|
|
114
|
+
details.append("Pods that read it through env vars keep the old values until they restart.")
|
|
115
|
+
changes.append(Change(time=t, kind=kind, resource=_ref(obj), summary=summary, details=details))
|
|
116
|
+
|
|
117
|
+
# Helm releases
|
|
118
|
+
for rel in snap.helm_releases:
|
|
119
|
+
t = parse_time(rel.get("updated"))
|
|
120
|
+
if not t or t < cutoff:
|
|
121
|
+
continue
|
|
122
|
+
r = rel.get("revision", 0)
|
|
123
|
+
changes.append(Change(
|
|
124
|
+
time=t, kind="helm", resource=ResourceRef(kind="HelmRelease", name=rel["name"], namespace=rel.get("namespace")),
|
|
125
|
+
summary=f"Helm release {rel['name']} -> revision {r} ({rel.get('chart', '?')}), status {rel.get('status')}",
|
|
126
|
+
details=[f"{x['kind']}/{x['name']}" for x in (rel.get("resources") or [])[:15]],
|
|
127
|
+
rollback_command=f"helm rollback {rel['name']} {r - 1} -n {rel.get('namespace')}" if r > 1 else None,
|
|
128
|
+
))
|
|
129
|
+
|
|
130
|
+
# Argo CD syncs
|
|
131
|
+
for app in snap.all("argoapps"):
|
|
132
|
+
op = (app.get("status") or {}).get("operationState") or {}
|
|
133
|
+
t = parse_time(op.get("finishedAt") or op.get("startedAt"))
|
|
134
|
+
if not t or t < cutoff:
|
|
135
|
+
continue
|
|
136
|
+
git_rev = ((op.get("syncResult") or {}).get("revision") or "")[:10]
|
|
137
|
+
changes.append(Change(time=t, kind="argocd", resource=_ref(app),
|
|
138
|
+
summary=f"Argo CD synced {meta(app).get('name')} to {git_rev or 'a new revision'} "
|
|
139
|
+
f"({op.get('phase')})",
|
|
140
|
+
details=[op.get("message", "")[:200]] if op.get("message") else []))
|
|
141
|
+
|
|
142
|
+
# Nodes joining
|
|
143
|
+
for node in snap.all("nodes"):
|
|
144
|
+
t = parse_time(meta(node).get("creationTimestamp"))
|
|
145
|
+
if t and t >= cutoff:
|
|
146
|
+
changes.append(Change(time=t, kind="node", resource=_ref(node), summary=f"Node {meta(node).get('name')} joined"))
|
|
147
|
+
|
|
148
|
+
# Scaling and node events
|
|
149
|
+
for e in snap.all("events"):
|
|
150
|
+
reason = e.get("reason")
|
|
151
|
+
if reason not in ("SuccessfulRescale", "NodeNotReady", "RemovingNode", "TaintManagerEviction", "Rebooted"):
|
|
152
|
+
continue
|
|
153
|
+
t = parse_time(event_time(e))
|
|
154
|
+
if not t or t < cutoff:
|
|
155
|
+
continue
|
|
156
|
+
inv = e.get("involvedObject") or {}
|
|
157
|
+
changes.append(Change(time=t, kind="scale" if reason == "SuccessfulRescale" else "node",
|
|
158
|
+
resource=ResourceRef(kind=inv.get("kind", "?"), name=inv.get("name", ""),
|
|
159
|
+
namespace=inv.get("namespace") or None),
|
|
160
|
+
summary=f"{reason}: {(e.get('message') or '')[:160]}"))
|
|
161
|
+
|
|
162
|
+
changes.sort(key=lambda c: c.time, reverse=True)
|
|
163
|
+
if snap.namespace:
|
|
164
|
+
changes = [c for c in changes if c.resource.namespace in (snap.namespace, None)]
|
|
165
|
+
return changes
|
|
@@ -0,0 +1,160 @@
|
|
|
1
|
+
"""Turn a flat list of findings into incidents: what is broken, at which layer, and what probably triggered it."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
import hashlib
|
|
6
|
+
from datetime import timedelta
|
|
7
|
+
from typing import Any
|
|
8
|
+
|
|
9
|
+
from kubesift.cluster.snapshot import Snapshot
|
|
10
|
+
from kubesift.models import Category, Change, Finding, Incident, ResourceRef, Severity
|
|
11
|
+
from kubesift.util import containers_of, meta, now, pod_spec_of
|
|
12
|
+
|
|
13
|
+
_LAYER = {
|
|
14
|
+
Category.WORKLOAD: "app", Category.CONFIG: "config", Category.RESOURCES: "app", Category.RELIABILITY: "app",
|
|
15
|
+
Category.NETWORK: "app", Category.STORAGE: "infra", Category.SCHEDULING: "infra", Category.NODE: "infra",
|
|
16
|
+
Category.PLATFORM: "platform", Category.SECURITY: "security", Category.COST: "cost", Category.UPGRADE: "platform",
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
|
|
20
|
+
# Findings that describe an effect; the pod-level finding next to them usually names the cause.
|
|
21
|
+
SYMPTOMS = {"deployment-unavailable", "statefulset-unready", "daemonset-unavailable", "deployment-rollout-stuck",
|
|
22
|
+
"pod-not-ready"}
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def _referenced_config(snap: Snapshot, owner: ResourceRef) -> set[tuple[str, str]]:
|
|
26
|
+
"""(kind, name) of ConfigMaps/Secrets the workload's template uses."""
|
|
27
|
+
key = {"Deployment": "deployments", "StatefulSet": "statefulsets", "DaemonSet": "daemonsets",
|
|
28
|
+
"CronJob": "cronjobs", "Job": "jobs", "Pod": "pods"}.get(owner.kind)
|
|
29
|
+
obj = snap.get(key, owner.namespace, owner.name) if key else None
|
|
30
|
+
spec = pod_spec_of(obj) if obj else None
|
|
31
|
+
out: set[tuple[str, str]] = set()
|
|
32
|
+
if not spec:
|
|
33
|
+
return out
|
|
34
|
+
for c in containers_of(spec, include_init=True):
|
|
35
|
+
for ef in c.get("envFrom") or []:
|
|
36
|
+
if ef.get("configMapRef"):
|
|
37
|
+
out.add(("ConfigMap", ef["configMapRef"].get("name", "")))
|
|
38
|
+
if ef.get("secretRef"):
|
|
39
|
+
out.add(("Secret", ef["secretRef"].get("name", "")))
|
|
40
|
+
for env in c.get("env") or []:
|
|
41
|
+
vf = env.get("valueFrom") or {}
|
|
42
|
+
if vf.get("configMapKeyRef"):
|
|
43
|
+
out.add(("ConfigMap", vf["configMapKeyRef"].get("name", "")))
|
|
44
|
+
if vf.get("secretKeyRef"):
|
|
45
|
+
out.add(("Secret", vf["secretKeyRef"].get("name", "")))
|
|
46
|
+
for v in spec.get("volumes") or []:
|
|
47
|
+
if v.get("configMap"):
|
|
48
|
+
out.add(("ConfigMap", v["configMap"].get("name", "")))
|
|
49
|
+
if v.get("secret"):
|
|
50
|
+
out.add(("Secret", v["secret"].get("secretName", "")))
|
|
51
|
+
return out
|
|
52
|
+
|
|
53
|
+
|
|
54
|
+
def _helm_owns(snap: Snapshot, release: ResourceRef, owner: ResourceRef) -> bool:
|
|
55
|
+
for rel in snap.helm_releases:
|
|
56
|
+
if rel["name"] == release.name and rel.get("namespace") == release.namespace:
|
|
57
|
+
return any(r["kind"] == owner.kind and r["name"] == owner.name for r in rel.get("resources") or [])
|
|
58
|
+
return False
|
|
59
|
+
|
|
60
|
+
|
|
61
|
+
def score_change(snap: Snapshot, f: Finding, c: Change, config_refs: set[tuple[str, str]]) -> int:
|
|
62
|
+
"""How strongly a change explains a finding: 0 (unrelated) to 100."""
|
|
63
|
+
owner = f.owner or f.resource
|
|
64
|
+
start = f.since or now()
|
|
65
|
+
if c.time > start + timedelta(minutes=5):
|
|
66
|
+
return 0 # changed after the problem began
|
|
67
|
+
gap_h = max((start - c.time).total_seconds() / 3600, 0)
|
|
68
|
+
recency = max(0, 20 - int(gap_h * 5))
|
|
69
|
+
if c.kind == "rollout" and c.resource.kind == owner.kind and c.resource.name == owner.name \
|
|
70
|
+
and c.resource.namespace == owner.namespace:
|
|
71
|
+
return 80 + recency
|
|
72
|
+
if c.kind == "config" and (c.resource.kind, c.resource.name) in config_refs and c.resource.namespace == owner.namespace:
|
|
73
|
+
return 70 + recency
|
|
74
|
+
if c.kind == "helm" and _helm_owns(snap, c.resource, owner):
|
|
75
|
+
return 75 + recency
|
|
76
|
+
if c.kind == "node" and f.node and c.resource.name == f.node:
|
|
77
|
+
return 70 + recency
|
|
78
|
+
if c.resource.namespace and c.resource.namespace == owner.namespace and c.kind in ("rollout", "config", "helm", "argocd"):
|
|
79
|
+
return 25 + recency
|
|
80
|
+
return 0
|
|
81
|
+
|
|
82
|
+
|
|
83
|
+
def link_changes(snap: Snapshot, findings: list[Finding], changes: list[Change]) -> None:
|
|
84
|
+
cache: dict[str, set[tuple[str, str]]] = {}
|
|
85
|
+
for f in findings:
|
|
86
|
+
if f.kind != "problem":
|
|
87
|
+
continue
|
|
88
|
+
owner = f.owner or f.resource
|
|
89
|
+
refs = cache.setdefault(str(owner), _referenced_config(snap, owner))
|
|
90
|
+
scored = [(score_change(snap, f, c, refs), c) for c in changes]
|
|
91
|
+
scored = [x for x in scored if x[0] >= 60] # only strong links; weak ones mislead
|
|
92
|
+
scored.sort(key=lambda x: -x[0])
|
|
93
|
+
f.related_changes = [c for _, c in scored[:3]]
|
|
94
|
+
|
|
95
|
+
|
|
96
|
+
def build_incidents(snap: Snapshot, findings: list[Finding]) -> list[Incident]:
|
|
97
|
+
problems = [f for f in findings if f.kind == "problem"]
|
|
98
|
+
groups: dict[str, list[Finding]] = {}
|
|
99
|
+
|
|
100
|
+
# Infra first: a broken node explains the pod failures on it.
|
|
101
|
+
bad_nodes = {f.resource.name for f in problems if f.category == Category.NODE and f.resource.kind == "Node"}
|
|
102
|
+
for f in problems:
|
|
103
|
+
if f.category == Category.NODE and f.resource.kind == "Node":
|
|
104
|
+
groups.setdefault(f"node:{f.resource.name}", []).append(f)
|
|
105
|
+
for f in problems:
|
|
106
|
+
if f.category == Category.NODE and f.resource.kind == "Node":
|
|
107
|
+
continue
|
|
108
|
+
if f.node and f.node in bad_nodes:
|
|
109
|
+
groups[f"node:{f.node}"].append(f)
|
|
110
|
+
continue
|
|
111
|
+
groups.setdefault(f"owner:{f.owner or f.resource}", []).append(f)
|
|
112
|
+
|
|
113
|
+
# Pods of a Service with no endpoints belong to the same incident as the workload behind it.
|
|
114
|
+
incidents = []
|
|
115
|
+
for key, items in groups.items():
|
|
116
|
+
items.sort(key=lambda f: (f.check in SYMPTOMS, -f.severity.rank)) # causes before symptoms
|
|
117
|
+
top = items[0]
|
|
118
|
+
sev = max((f.severity for f in items), key=lambda s: s.rank)
|
|
119
|
+
triggers = [c for f in items for c in f.related_changes]
|
|
120
|
+
layer = "infra" if key.startswith("node:") else _LAYER.get(top.category, "app")
|
|
121
|
+
if any(f.category == Category.CONFIG for f in items):
|
|
122
|
+
layer = "config"
|
|
123
|
+
root = ResourceRef(kind="Node", name=key[5:]) if key.startswith("node:") else (top.owner or top.resource)
|
|
124
|
+
incidents.append(Incident(
|
|
125
|
+
id=hashlib.sha1(key.encode()).hexdigest()[:8],
|
|
126
|
+
title=f"{root}: {top.title}",
|
|
127
|
+
severity=sev,
|
|
128
|
+
layer=layer,
|
|
129
|
+
root=root,
|
|
130
|
+
findings=items,
|
|
131
|
+
likely_trigger=triggers[0] if triggers else None,
|
|
132
|
+
summary=_summary(items, triggers[0] if triggers else None),
|
|
133
|
+
))
|
|
134
|
+
incidents.sort(key=lambda i: (-i.severity.rank, i.likely_trigger is None, -len(i.findings)))
|
|
135
|
+
return incidents
|
|
136
|
+
|
|
137
|
+
|
|
138
|
+
def _summary(items: list[Finding], trigger: Change | None) -> str:
|
|
139
|
+
text = items[0].message
|
|
140
|
+
if len(items) > 1:
|
|
141
|
+
text += f" (+{len(items) - 1} related finding{'s' if len(items) > 2 else ''})"
|
|
142
|
+
if trigger:
|
|
143
|
+
text += f" Likely trigger: {trigger.summary} at {trigger.time:%H:%M UTC}."
|
|
144
|
+
return text
|
|
145
|
+
|
|
146
|
+
|
|
147
|
+
def system_blast_radius(findings: list[Finding]) -> list[str]:
|
|
148
|
+
"""Short notes on findings that affect the whole cluster."""
|
|
149
|
+
notes = []
|
|
150
|
+
for f in findings:
|
|
151
|
+
if f.category == Category.PLATFORM and f.severity in (Severity.CRITICAL, Severity.HIGH):
|
|
152
|
+
notes.append(f"{f.title}: {f.message}")
|
|
153
|
+
return notes
|
|
154
|
+
|
|
155
|
+
|
|
156
|
+
def pod_counts(snap: Snapshot) -> dict[str, Any]:
|
|
157
|
+
pods = snap.all("pods")
|
|
158
|
+
running = sum(1 for p in pods if (p.get("status") or {}).get("phase") == "Running")
|
|
159
|
+
return {"pods": len(pods), "running": running, "nodes": len(snap.all("nodes")),
|
|
160
|
+
"namespaces": len({meta(p).get("namespace") for p in pods})}
|
|
@@ -0,0 +1,83 @@
|
|
|
1
|
+
"""Compact, LLM-friendly summaries of individual resources."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from typing import Any
|
|
6
|
+
|
|
7
|
+
from kubesift.cluster.snapshot import KIND_TO_KEY, Snapshot, event_time
|
|
8
|
+
from kubesift.util import age, containers_of, human_duration, meta, pod_spec_of
|
|
9
|
+
|
|
10
|
+
ALIASES = {
|
|
11
|
+
"po": "Pod", "pod": "Pod", "pods": "Pod", "deploy": "Deployment", "deployment": "Deployment",
|
|
12
|
+
"deployments": "Deployment", "sts": "StatefulSet", "statefulset": "StatefulSet", "ds": "DaemonSet",
|
|
13
|
+
"daemonset": "DaemonSet", "svc": "Service", "service": "Service", "ing": "Ingress", "ingress": "Ingress",
|
|
14
|
+
"job": "Job", "cj": "CronJob", "cronjob": "CronJob", "no": "Node", "node": "Node", "pvc": "PersistentVolumeClaim",
|
|
15
|
+
"hpa": "HorizontalPodAutoscaler", "cm": "ConfigMap", "configmap": "ConfigMap", "secret": "Secret",
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
def resolve(snap: Snapshot, kind: str, namespace: str | None, name: str) -> dict[str, Any] | None:
|
|
20
|
+
k = ALIASES.get(kind.lower(), kind)
|
|
21
|
+
key = KIND_TO_KEY.get(k)
|
|
22
|
+
return snap.get(key, namespace, name) if key else None
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def summarize(snap: Snapshot, obj: dict[str, Any], events: int = 8) -> dict[str, Any]:
|
|
26
|
+
kind = obj.get("kind", "")
|
|
27
|
+
m = meta(obj)
|
|
28
|
+
out: dict[str, Any] = {"kind": kind, "name": m.get("name"), "namespace": m.get("namespace"),
|
|
29
|
+
"age": human_duration(age(m.get("creationTimestamp"))),
|
|
30
|
+
"labels": m.get("labels") or {}}
|
|
31
|
+
st = obj.get("status") or {}
|
|
32
|
+
spec = obj.get("spec") or {}
|
|
33
|
+
if kind == "Pod":
|
|
34
|
+
out["phase"] = st.get("phase")
|
|
35
|
+
out["node"] = spec.get("nodeName")
|
|
36
|
+
out["containers"] = []
|
|
37
|
+
for cs in (st.get("initContainerStatuses") or []) + (st.get("containerStatuses") or []):
|
|
38
|
+
state = cs.get("state") or {}
|
|
39
|
+
sname = next(iter(state), "unknown")
|
|
40
|
+
detail = state.get(sname) or {}
|
|
41
|
+
last = (cs.get("lastState") or {}).get("terminated") or {}
|
|
42
|
+
out["containers"].append({
|
|
43
|
+
"name": cs.get("name"), "image": cs.get("image"), "ready": cs.get("ready"),
|
|
44
|
+
"restarts": cs.get("restartCount"), "state": sname, "reason": detail.get("reason"),
|
|
45
|
+
"last_exit": {"code": last.get("exitCode"), "reason": last.get("reason")} if last else None,
|
|
46
|
+
})
|
|
47
|
+
out["owner"] = str(snap.owner_of(obj))
|
|
48
|
+
elif kind in ("Deployment", "StatefulSet"):
|
|
49
|
+
out["replicas"] = {"desired": spec.get("replicas"), "ready": st.get("readyReplicas", 0),
|
|
50
|
+
"updated": st.get("updatedReplicas", 0), "available": st.get("availableReplicas", 0)}
|
|
51
|
+
out["conditions"] = [{k: c.get(k) for k in ("type", "status", "reason", "message")} for c in st.get("conditions") or []]
|
|
52
|
+
elif kind == "DaemonSet":
|
|
53
|
+
out["scheduled"] = {"desired": st.get("desiredNumberScheduled"), "ready": st.get("numberReady")}
|
|
54
|
+
elif kind == "Service":
|
|
55
|
+
out["type"] = spec.get("type")
|
|
56
|
+
out["selector"] = spec.get("selector")
|
|
57
|
+
out["ports"] = spec.get("ports")
|
|
58
|
+
elif kind == "Node":
|
|
59
|
+
out["conditions"] = [{k: c.get(k) for k in ("type", "status", "reason")} for c in st.get("conditions") or []]
|
|
60
|
+
out["allocatable"] = st.get("allocatable")
|
|
61
|
+
out["version"] = (st.get("nodeInfo") or {}).get("kubeletVersion")
|
|
62
|
+
out["unschedulable"] = spec.get("unschedulable", False)
|
|
63
|
+
elif kind in ("ConfigMap", "Secret"):
|
|
64
|
+
out["keys"] = obj.get("keys")
|
|
65
|
+
else:
|
|
66
|
+
out["status"] = {k: v for k, v in st.items() if k in ("phase", "conditions", "loadBalancer", "succeeded", "failed")}
|
|
67
|
+
pspec = pod_spec_of(obj)
|
|
68
|
+
if pspec:
|
|
69
|
+
out["template"] = [{
|
|
70
|
+
"name": c.get("name"), "image": c.get("image"), "resources": c.get("resources"),
|
|
71
|
+
"env": [e.get("name") for e in c.get("env") or []],
|
|
72
|
+
"envFrom": c.get("envFrom"), "probes": {p: bool(c.get(p)) for p in ("livenessProbe", "readinessProbe", "startupProbe")},
|
|
73
|
+
"ports": c.get("ports"),
|
|
74
|
+
} for c in containers_of(pspec, include_init=True)]
|
|
75
|
+
evs = snap.events_for(kind, m.get("namespace"), m.get("name", ""))[:events]
|
|
76
|
+
if evs:
|
|
77
|
+
out["events"] = [f"{event_time(e)} {e.get('type')} {e.get('reason')}: {(e.get('message') or '')[:200]}" for e in evs]
|
|
78
|
+
if kind == "Pod":
|
|
79
|
+
logs = {k.rsplit("/", 1)[-1]: v for k, v in snap.logs.items()
|
|
80
|
+
if k.startswith(f"{m.get('namespace')}/{m.get('name')}/")}
|
|
81
|
+
if logs:
|
|
82
|
+
out["logs"] = logs
|
|
83
|
+
return out
|