Keith Casko
92 lines
3.5 KiB
Python
92 lines
3.5 KiB
Python
import json
|
|
import os
|
|
import time
|
|
import urllib.parse
|
|
import urllib.request
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
|
|
PROMETHEUS_URL = os.getenv("PROMETHEUS_URL", "http://host.docker.internal:9090").rstrip("/")
|
|
TIMEOUT = float(os.getenv("PROMETHEUS_TIMEOUT", "2.5"))
|
|
|
|
QUERIES = {
|
|
"cpu_percent": '100-(avg(rate(node_cpu_seconds_total{mode="idle"}[2m]))*100)',
|
|
"memory_percent": '(1-(node_memory_MemAvailable_bytes/node_memory_MemTotal_bytes))*100',
|
|
"host_uptime_seconds": 'time()-node_boot_time_seconds',
|
|
"running_containers": 'count(count by (name) (container_last_seen{name!=""}))',
|
|
}
|
|
|
|
def get_json(url):
|
|
request = urllib.request.Request(url, headers={"Accept": "application/json"})
|
|
with urllib.request.urlopen(request, timeout=TIMEOUT) as response:
|
|
return json.load(response)
|
|
|
|
def prometheus_query(expression):
|
|
url = f"{PROMETHEUS_URL}/api/v1/query?{urllib.parse.urlencode({'query': expression})}"
|
|
payload = get_json(url)
|
|
if payload.get("status") != "success":
|
|
raise RuntimeError("Prometheus query failed")
|
|
results = payload.get("data", {}).get("result", [])
|
|
if not results:
|
|
raise RuntimeError("Prometheus query returned no data")
|
|
return float(results[0]["value"][1])
|
|
|
|
def target_health():
|
|
payload = get_json(f"{PROMETHEUS_URL}/api/v1/targets")
|
|
targets = payload.get("data", {}).get("activeTargets", [])
|
|
jobs = {}
|
|
for target in targets:
|
|
job = target.get("labels", {}).get("job", "unknown")
|
|
jobs[job] = target.get("health") == "up"
|
|
return {
|
|
"up": sum(1 for target in targets if target.get("health") == "up"),
|
|
"total": len(targets),
|
|
"jobs": jobs,
|
|
}
|
|
|
|
def build_status():
|
|
values = {name: prometheus_query(query) for name, query in QUERIES.items()}
|
|
targets = target_health()
|
|
return {
|
|
"ok": True,
|
|
"source": "Prometheus / node_exporter / cAdvisor",
|
|
"sampled_at": int(time.time()),
|
|
"host": {
|
|
"cpu_percent": round(values["cpu_percent"], 1),
|
|
"memory_percent": round(values["memory_percent"], 1),
|
|
"uptime_seconds": int(values["host_uptime_seconds"]),
|
|
},
|
|
"containers": {"running": int(values["running_containers"])},
|
|
"prometheus": targets,
|
|
}
|
|
|
|
class Handler(BaseHTTPRequestHandler):
|
|
def send_json(self, status_code, payload):
|
|
body = json.dumps(payload, separators=(",", ":")).encode("utf-8")
|
|
self.send_response(status_code)
|
|
self.send_header("Content-Type", "application/json; charset=utf-8")
|
|
self.send_header("Cache-Control", "no-store, max-age=0")
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.send_header("X-Content-Type-Options", "nosniff")
|
|
self.end_headers()
|
|
self.wfile.write(body)
|
|
|
|
def do_GET(self):
|
|
if self.path == "/healthz":
|
|
self.send_json(200, {"ok": True})
|
|
return
|
|
if self.path != "/status":
|
|
self.send_json(404, {"ok": False, "error": "not_found"})
|
|
return
|
|
try:
|
|
self.send_json(200, build_status())
|
|
except Exception as exc:
|
|
self.send_json(503, {"ok": False, "sampled_at": int(time.time()), "error": type(exc).__name__})
|
|
|
|
def log_message(self, fmt, *args):
|
|
print(f"{self.address_string()} - {fmt % args}", flush=True)
|
|
|
|
if __name__ == "__main__":
|
|
server = ThreadingHTTPServer(("0.0.0.0", 8080), Handler)
|
|
print("ByteGeist status API listening on :8080", flush=True)
|
|
server.serve_forever()
|