P42-S.M.: Server-Monitoring-Agent als Docker-Container
Misst CPU, RAM, Swap, Platten, Netzwerk, Temperaturen und Prozesse des Hosts und liefert sie als JSON-API (/api/metrics, /api/history) für das P42-Dashboard. Nur Python-Standardbibliothek, Token-geschützt, Container ohne Root und mit schreibgeschütztem Dateisystem. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
guyg1474andClaude Opus 5.5 committed
commit
c6eef176a2
11 files changed
+727
No files matched your search
Whitespace-only changes.
@@ -0,0 +1,14 @@
|
||||
import logging
|
||||
import signal
|
||||
import sys
|
||||
|
||||
from .server import serve
|
||||
|
||||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
|
||||
# "docker stop" sendet SIGTERM – sofort sauber beenden statt 10 s auf SIGKILL zu warten
|
||||
signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
|
||||
|
||||
try:
|
||||
serve()
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
@@ -0,0 +1,311 @@
|
||||
"""Liest die Auslastung des Hosts direkt aus /proc und /sys – ohne Fremdpakete.
|
||||
|
||||
Im Container sind die Host-Verzeichnisse eingebunden (siehe docker-compose.yml):
|
||||
HOST_PROC /proc des Hosts (Standard /host/proc)
|
||||
HOST_SYS /sys des Hosts (Standard /sys – sysfs ist im Container ohnehin das des Hosts)
|
||||
HOST_ROOT / des Hosts (Standard /host/root – für Plattenbelegung und os-release)
|
||||
Lokal ohne Docker: HOST_PROC=/proc HOST_ROOT=/ setzen.
|
||||
"""
|
||||
import os
|
||||
import re
|
||||
import time
|
||||
from datetime import datetime
|
||||
|
||||
HOST_PROC = os.environ.get("HOST_PROC", "/host/proc")
|
||||
HOST_SYS = os.environ.get("HOST_SYS", "/sys")
|
||||
HOST_ROOT = os.environ.get("HOST_ROOT", "/host/root")
|
||||
|
||||
# Dateisysteme, die als echte Platten zählen. Netzlaufwerke (nfs, cifs) bewusst nicht:
|
||||
# statvfs kann dort bei Verbindungsproblemen hängen.
|
||||
DISK_FS = {"ext2", "ext3", "ext4", "xfs", "btrfs", "zfs", "vfat", "exfat", "ntfs", "ntfs3", "fuseblk", "f2fs", "jfs"}
|
||||
# Ganze Laufwerke ohne Zählwert für die Platten-Aktivität (virtuell oder doppelt gezählt)
|
||||
SKIP_BLOCK = re.compile(r"^(loop|ram|zram|sr|dm-|md)")
|
||||
# Virtuelle Netzwerk-Schnittstellen: werden gelistet, aber nicht in die Summe gerechnet,
|
||||
# sonst zählt Container-Verkehr doppelt (veth -> Bridge -> echte Karte)
|
||||
VIRTUAL_NET = re.compile(r"^(lo$|veth|docker|br-|virbr|cni|flannel|cali)")
|
||||
SECTOR = 512 # /proc/diskstats zählt immer in 512-Byte-Sektoren
|
||||
|
||||
|
||||
def _read(path: str) -> str:
|
||||
with open(path, encoding="utf-8", errors="replace") as f:
|
||||
return f.read()
|
||||
|
||||
|
||||
def _read_or(path: str, default=None):
|
||||
try:
|
||||
return _read(path).strip()
|
||||
except OSError:
|
||||
return default
|
||||
|
||||
|
||||
def _host_path(path: str) -> str:
|
||||
return os.path.join(HOST_ROOT, path.lstrip("/"))
|
||||
|
||||
|
||||
# ---------- Rohwerte (für Raten werden zwei Messungen verglichen) ----------
|
||||
|
||||
def _cpu_times() -> dict:
|
||||
"""{'cpu': (busy, total), 'cpu0': ..., ...} aus /proc/stat."""
|
||||
out = {}
|
||||
for line in _read(f"{HOST_PROC}/stat").splitlines():
|
||||
if not line.startswith("cpu"):
|
||||
continue
|
||||
name, *vals = line.split()
|
||||
v = [int(x) for x in vals[:8]] # user nice system idle iowait irq softirq steal
|
||||
total = sum(v)
|
||||
idle = v[3] + v[4]
|
||||
out[name] = (total - idle, total, v[4])
|
||||
return out
|
||||
|
||||
|
||||
def _disk_bytes() -> tuple[int, int]:
|
||||
"""Gelesene/geschriebene Bytes aller echten Laufwerke (ohne Partitionen, loop, dm)."""
|
||||
try:
|
||||
disks = {d for d in os.listdir(f"{HOST_SYS}/block") if not SKIP_BLOCK.match(d)}
|
||||
except OSError:
|
||||
disks = None
|
||||
read = write = 0
|
||||
for line in _read(f"{HOST_PROC}/diskstats").splitlines():
|
||||
f = line.split()
|
||||
if len(f) < 10:
|
||||
continue
|
||||
name = f[2]
|
||||
if disks is not None and name not in disks:
|
||||
continue
|
||||
read += int(f[5]) * SECTOR
|
||||
write += int(f[9]) * SECTOR
|
||||
return read, write
|
||||
|
||||
|
||||
def _net_bytes() -> dict:
|
||||
"""{'eth0': (rx, tx), ...} – aus dem Netz-Namespace des Hosts (PID 1), nicht des Containers."""
|
||||
path = f"{HOST_PROC}/1/net/dev"
|
||||
if not os.path.exists(path):
|
||||
path = f"{HOST_PROC}/net/dev"
|
||||
out = {}
|
||||
for line in _read(path).splitlines()[2:]:
|
||||
name, _, data = line.partition(":")
|
||||
f = data.split()
|
||||
if len(f) >= 9:
|
||||
out[name.strip()] = (int(f[0]), int(f[8]))
|
||||
return out
|
||||
|
||||
|
||||
def raw_sample() -> dict:
|
||||
return {"time": time.monotonic(), "cpu": _cpu_times(), "disk": _disk_bytes(), "net": _net_bytes()}
|
||||
|
||||
|
||||
# ---------- Momentwerte ----------
|
||||
|
||||
def _meminfo() -> dict:
|
||||
info = {}
|
||||
for line in _read(f"{HOST_PROC}/meminfo").splitlines():
|
||||
key, _, rest = line.partition(":")
|
||||
info[key] = int(rest.split()[0]) * 1024
|
||||
total = info.get("MemTotal", 0)
|
||||
available = info.get("MemAvailable", info.get("MemFree", 0))
|
||||
swap_total = info.get("SwapTotal", 0)
|
||||
swap_used = swap_total - info.get("SwapFree", 0)
|
||||
return {
|
||||
"memory": {
|
||||
"totalBytes": total,
|
||||
"usedBytes": total - available,
|
||||
"availableBytes": available,
|
||||
"cachedBytes": info.get("Cached", 0) + info.get("Buffers", 0),
|
||||
"percent": _pct(total - available, total),
|
||||
},
|
||||
"swap": {"totalBytes": swap_total, "usedBytes": swap_used, "percent": _pct(swap_used, swap_total)},
|
||||
}
|
||||
|
||||
|
||||
def _unescape_mount(path: str) -> str:
|
||||
# /proc/mounts schreibt Leerzeichen usw. als \040
|
||||
return re.sub(r"\\([0-7]{3})", lambda m: chr(int(m[1], 8)), path)
|
||||
|
||||
|
||||
def _disks() -> list[dict]:
|
||||
path = f"{HOST_PROC}/1/mounts"
|
||||
if not os.path.exists(path):
|
||||
path = f"{HOST_PROC}/mounts"
|
||||
seen, out = set(), []
|
||||
for line in _read(path).splitlines():
|
||||
f = line.split()
|
||||
if len(f) < 3 or f[2] not in DISK_FS:
|
||||
continue
|
||||
device, mount, fstype = f[0], _unescape_mount(f[1]), f[2]
|
||||
if device in seen: # btrfs-Subvolumes, Bind-Mounts: dasselbe Laufwerk nur einmal
|
||||
continue
|
||||
try:
|
||||
st = os.statvfs(_host_path(mount))
|
||||
except OSError:
|
||||
continue
|
||||
seen.add(device)
|
||||
total = st.f_blocks * st.f_frsize
|
||||
used = (st.f_blocks - st.f_bfree) * st.f_frsize
|
||||
free = st.f_bavail * st.f_frsize
|
||||
out.append({
|
||||
"mount": mount,
|
||||
"device": device,
|
||||
"fs": fstype,
|
||||
"totalBytes": total,
|
||||
"usedBytes": used,
|
||||
"freeBytes": free,
|
||||
"percent": _pct(used, used + free), # wie df: reservierte Blöcke nicht mitgezählt
|
||||
})
|
||||
return out
|
||||
|
||||
|
||||
def _temperatures() -> list[dict]:
|
||||
out = []
|
||||
base = f"{HOST_SYS}/class/hwmon"
|
||||
try:
|
||||
sensors = sorted(os.listdir(base))
|
||||
except OSError:
|
||||
return out
|
||||
for hw in sensors:
|
||||
d = os.path.join(base, hw)
|
||||
name = _read_or(f"{d}/name", hw)
|
||||
try:
|
||||
inputs = sorted(f for f in os.listdir(d) if re.fullmatch(r"temp\d+_input", f))
|
||||
except OSError:
|
||||
continue
|
||||
for inp in inputs:
|
||||
prefix = inp[: -len("_input")]
|
||||
value = _read_or(f"{d}/{inp}")
|
||||
if value is None or not value.lstrip("-").isdigit():
|
||||
continue
|
||||
crit = _read_or(f"{d}/{prefix}_crit")
|
||||
out.append({
|
||||
"sensor": name,
|
||||
"label": _read_or(f"{d}/{prefix}_label", prefix),
|
||||
"celsius": int(value) / 1000,
|
||||
"criticalCelsius": int(crit) / 1000 if crit and crit.lstrip("-").isdigit() else None,
|
||||
})
|
||||
return out
|
||||
|
||||
|
||||
def _cpu_model() -> str | None:
|
||||
for line in _read(f"{HOST_PROC}/cpuinfo").splitlines():
|
||||
if line.startswith("model name"):
|
||||
return line.partition(":")[2].strip()
|
||||
return None
|
||||
|
||||
|
||||
def _cpu_mhz() -> float | None:
|
||||
freqs = []
|
||||
try:
|
||||
cpus = os.listdir(f"{HOST_SYS}/devices/system/cpu")
|
||||
except OSError:
|
||||
return None
|
||||
for cpu in cpus:
|
||||
if re.fullmatch(r"cpu\d+", cpu):
|
||||
v = _read_or(f"{HOST_SYS}/devices/system/cpu/{cpu}/cpufreq/scaling_cur_freq")
|
||||
if v and v.isdigit():
|
||||
freqs.append(int(v) / 1000)
|
||||
return round(sum(freqs) / len(freqs)) if freqs else None
|
||||
|
||||
|
||||
def _os_name() -> str | None:
|
||||
for path in (_host_path("/etc/os-release"), _host_path("/usr/lib/os-release")):
|
||||
text = _read_or(path)
|
||||
if text:
|
||||
m = re.search(r'^PRETTY_NAME="?([^"\n]*)"?', text, re.M)
|
||||
if m:
|
||||
return m[1]
|
||||
return None
|
||||
|
||||
|
||||
def _pct(part: float, whole: float) -> float:
|
||||
return round(part / whole * 100, 1) if whole else 0.0
|
||||
|
||||
|
||||
def _rate(new: int, old: int, seconds: float) -> int:
|
||||
# Zähler können beim Neustart einer Schnittstelle zurückspringen
|
||||
return max(0, round((new - old) / seconds)) if seconds > 0 else 0
|
||||
|
||||
|
||||
# ---------- Gesamtbild ----------
|
||||
|
||||
def snapshot(prev: dict, cur: dict, interval: int) -> dict:
|
||||
"""Alle Werte zu einem JSON-fähigen Dict; Raten aus der Differenz prev -> cur."""
|
||||
seconds = cur["time"] - prev["time"]
|
||||
|
||||
cores, cpu_total, iowait = [], 0.0, 0.0
|
||||
for name, (busy, total, wait) in cur["cpu"].items():
|
||||
p_busy, p_total, p_wait = prev["cpu"].get(name, (busy, total, wait))
|
||||
pct = _pct(busy - p_busy, total - p_total)
|
||||
if name == "cpu":
|
||||
cpu_total = pct
|
||||
iowait = _pct(wait - p_wait, total - p_total)
|
||||
else:
|
||||
cores.append(pct)
|
||||
|
||||
net, rx_sum, tx_sum = [], 0, 0
|
||||
for name, (rx, tx) in sorted(cur["net"].items()):
|
||||
if name == "lo":
|
||||
continue
|
||||
p_rx, p_tx = prev["net"].get(name, (rx, tx))
|
||||
rx_rate, tx_rate = _rate(rx, p_rx, seconds), _rate(tx, p_tx, seconds)
|
||||
virtual = bool(VIRTUAL_NET.match(name))
|
||||
if not virtual:
|
||||
rx_sum += rx_rate
|
||||
tx_sum += tx_rate
|
||||
net.append({
|
||||
"interface": name,
|
||||
"virtual": virtual,
|
||||
"rxBytesPerSec": rx_rate,
|
||||
"txBytesPerSec": tx_rate,
|
||||
"rxBytesTotal": rx,
|
||||
"txBytesTotal": tx,
|
||||
})
|
||||
|
||||
load = _read(f"{HOST_PROC}/loadavg").split()
|
||||
stat = _read(f"{HOST_PROC}/stat")
|
||||
running = re.search(r"^procs_running (\d+)", stat, re.M)
|
||||
uptime = float(_read(f"{HOST_PROC}/uptime").split()[0])
|
||||
|
||||
return {
|
||||
"timestamp": datetime.now().astimezone().isoformat(timespec="seconds"),
|
||||
"intervalSeconds": interval,
|
||||
"host": {
|
||||
"hostname": _read_or(f"{HOST_PROC}/sys/kernel/hostname"),
|
||||
"os": _os_name(),
|
||||
"kernel": _read_or(f"{HOST_PROC}/sys/kernel/osrelease"),
|
||||
"uptimeSeconds": int(uptime),
|
||||
},
|
||||
"cpu": {
|
||||
"model": _cpu_model(),
|
||||
"threads": len(cores), # logische CPUs (mit Hyperthreading)
|
||||
"percent": cpu_total,
|
||||
"iowaitPercent": iowait,
|
||||
"perCorePercent": cores,
|
||||
"mhz": _cpu_mhz(),
|
||||
"load": {"1m": float(load[0]), "5m": float(load[1]), "15m": float(load[2])},
|
||||
},
|
||||
**_meminfo(),
|
||||
"disks": _disks(),
|
||||
"diskIo": {
|
||||
"readBytesPerSec": _rate(cur["disk"][0], prev["disk"][0], seconds),
|
||||
"writeBytesPerSec": _rate(cur["disk"][1], prev["disk"][1], seconds),
|
||||
},
|
||||
"network": {"rxBytesPerSec": rx_sum, "txBytesPerSec": tx_sum, "interfaces": net},
|
||||
"temperatures": _temperatures(),
|
||||
"processes": {
|
||||
"total": sum(1 for p in os.listdir(HOST_PROC) if p.isdigit()),
|
||||
"running": int(running[1]) if running else None,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def history_point(snap: dict) -> dict:
|
||||
"""Kurzform für den Verlauf (Diagramme)."""
|
||||
return {
|
||||
"timestamp": snap["timestamp"],
|
||||
"cpuPercent": snap["cpu"]["percent"],
|
||||
"memoryPercent": snap["memory"]["percent"],
|
||||
"load1m": snap["cpu"]["load"]["1m"],
|
||||
"rxBytesPerSec": snap["network"]["rxBytesPerSec"],
|
||||
"txBytesPerSec": snap["network"]["txBytesPerSec"],
|
||||
"readBytesPerSec": snap["diskIo"]["readBytesPerSec"],
|
||||
"writeBytesPerSec": snap["diskIo"]["writeBytesPerSec"],
|
||||
}
|
||||
+108
@@ -0,0 +1,108 @@
|
||||
"""HTTP-API: liefert die zuletzt gemessenen Werte als JSON.
|
||||
|
||||
GET /api/health ohne Token – für Docker-Healthcheck und Erreichbarkeitsprüfung
|
||||
GET /api/metrics aktueller Stand (Token nötig)
|
||||
GET /api/history Verlauf, optional ?minutes=N (Token nötig)
|
||||
"""
|
||||
import hmac
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
from collections import deque
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from urllib.parse import parse_qs, urlparse
|
||||
|
||||
from . import collector
|
||||
|
||||
log = logging.getLogger("p42-sm")
|
||||
|
||||
TOKEN = os.environ.get("SM_TOKEN", "").strip()
|
||||
INTERVAL = max(1, int(os.environ.get("SM_INTERVAL", "5")))
|
||||
HISTORY = max(1, int(os.environ.get("SM_HISTORY", "720"))) # 720 × 5 s = 1 Stunde
|
||||
|
||||
_lock = threading.Lock()
|
||||
_latest: dict | None = None
|
||||
_history: deque = deque(maxlen=HISTORY)
|
||||
_last_update = 0.0
|
||||
|
||||
|
||||
def _collect_loop() -> None:
|
||||
global _latest, _last_update
|
||||
prev = collector.raw_sample()
|
||||
time.sleep(1) # erste Messung schon nach 1 s, damit die API schnell Daten hat
|
||||
while True:
|
||||
try:
|
||||
cur = collector.raw_sample()
|
||||
snap = collector.snapshot(prev, cur, INTERVAL)
|
||||
with _lock:
|
||||
_latest = snap
|
||||
_history.append(collector.history_point(snap))
|
||||
_last_update = time.monotonic()
|
||||
prev = cur
|
||||
except Exception:
|
||||
log.exception("Messung fehlgeschlagen")
|
||||
time.sleep(INTERVAL)
|
||||
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
server_version = "P42-SM"
|
||||
sys_version = ""
|
||||
|
||||
def _send(self, status: int, body: dict) -> None:
|
||||
data = json.dumps(body, ensure_ascii=False).encode()
|
||||
self.send_response(status)
|
||||
self.send_header("Content-Type", "application/json; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(data)))
|
||||
self.send_header("Cache-Control", "no-store")
|
||||
self.end_headers()
|
||||
self.wfile.write(data)
|
||||
|
||||
def _authorized(self) -> bool:
|
||||
if not TOKEN:
|
||||
return True
|
||||
header = self.headers.get("Authorization", "")
|
||||
scheme, _, given = header.partition(" ")
|
||||
return scheme.lower() == "bearer" and hmac.compare_digest(given.strip().encode(), TOKEN.encode())
|
||||
|
||||
def do_GET(self) -> None:
|
||||
url = urlparse(self.path)
|
||||
with _lock:
|
||||
latest, history, age = _latest, list(_history), time.monotonic() - _last_update
|
||||
|
||||
if url.path == "/api/health":
|
||||
# Ungesund, wenn die Messung hängt (drei Intervalle ohne neue Werte)
|
||||
ok = latest is not None and age < INTERVAL * 3 + 5
|
||||
return self._send(200 if ok else 503, {"status": "ok" if ok else "starting"})
|
||||
|
||||
if url.path not in ("/api/metrics", "/api/history"):
|
||||
return self._send(404, {"error": "Nicht gefunden."})
|
||||
if not self._authorized():
|
||||
return self._send(401, {"error": "Token fehlt oder ist falsch."})
|
||||
if latest is None:
|
||||
return self._send(503, {"error": "Noch keine Messwerte – bitte gleich erneut versuchen."})
|
||||
|
||||
if url.path == "/api/metrics":
|
||||
return self._send(200, latest)
|
||||
|
||||
minutes = parse_qs(url.query).get("minutes", [""])[0]
|
||||
if minutes.isdigit():
|
||||
history = history[-max(1, int(minutes) * 60 // INTERVAL):]
|
||||
return self._send(200, {"intervalSeconds": INTERVAL, "points": history})
|
||||
|
||||
def log_message(self, fmt: str, *args) -> None:
|
||||
# Nur Fehler loggen – der Abruf alle paar Sekunden würde das Log sonst fluten
|
||||
if len(args) >= 2 and str(args[1]).startswith(("4", "5")):
|
||||
log.warning("%s %s", self.address_string(), fmt % args)
|
||||
|
||||
|
||||
def serve() -> None:
|
||||
host = os.environ.get("HOST", "0.0.0.0")
|
||||
port = int(os.environ.get("PORT", "9142"))
|
||||
if not TOKEN:
|
||||
log.warning("SM_TOKEN ist leer – die API ist ohne Anmeldung abrufbar!")
|
||||
threading.Thread(target=_collect_loop, daemon=True, name="collector").start()
|
||||
httpd = ThreadingHTTPServer((host, port), Handler)
|
||||
log.info("P42-S.M. läuft auf %s:%s (Messintervall %s s, Verlauf %s Punkte)", host, port, INTERVAL, HISTORY)
|
||||
httpd.serve_forever()
|
||||
Reference in new issue
Block a user