mirror of
https://github.com/pewdiepie-archdaemon/odysseus.git
synced 2026-06-15 17:25:26 -04:00
Sheikh Rahat Mahmud
9180847c0e
* Add consolidated service health endpoint for degraded-state reporting
ROADMAP (High Priority) asks for "Better degraded-state reporting for
ChromaDB, SearXNG, email, ntfy, and provider probes." Until now there was no
single readout of which subsystems are actually working: /api/health is only a
liveness ping and each subsystem's signal lives in a different module, so a
misconfigured self-host install gives no consolidated picture.
This adds an admin-only GET /api/diagnostics/services endpoint backed by a new
src/service_health.py aggregator. Each subsystem reports a uniform
{name, status, detail, meta} where status is ok | degraded | down | disabled,
and the response rolls up an overall verdict (worst non-disabled status).
Probes are deliberately non-intrusive and safe to poll:
- ChromaDB: reads the .healthy flags on the RAG and memory vector stores.
- SearXNG: GET /healthz (2xx), falling back to the instance root (<500). No
search query is run.
- ntfy: GET the server's built-in /v1/health. No test notification is sent.
- email: short IMAP connect+logout per configured account (no credentials in
meta).
- providers: probe each enabled ModelEndpoint's model list (no api_key in meta).
Probe functions take their inputs as parameters and isolate the network call to
injectable callables, so they unit-test without touching the network (same
pattern as the merged provider-endpoint tests). Network probes run concurrently
off the event loop via asyncio.to_thread with bounded per-probe timeouts.
memory_vector is now passed into setup_diagnostics_routes (new optional param,
backward-compatible) so ChromaDB's vector-memory store can be reported too.
Tests: tests/test_service_health.py — 29 tests covering every status mapping
per subsystem, the overall rollup, and that no secrets leak into meta.
Verification:
python -m pytest tests/test_service_health.py -q # 29 passed
python -m py_compile src/service_health.py routes/diagnostics_routes.py app.py
python -m pytest tests/test_endpoint_resolver.py tests/test_provider_endpoints.py -q
Backend + tests only; an Admin/Settings UI badge that renders this endpoint is
a natural follow-up.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
* fix(diagnostics): bound service-health wall-clock and redact secrets
Addresses review on #964.
Blocker 1 — genuinely bounded wall-clock:
- providers_health and email_health now fan out per-item probes across a
bounded thread pool (_bounded_map) with a hard total budget (_FANOUT_BUDGET),
instead of probing endpoints/accounts sequentially. Stragglers are reported
as a controlled `timeout` and never block; the pool is shut down with
wait=False so the response returns on time regardless of endpoint/account
count.
- The IMAP connect path now honors the service-health budget: _imap_connect
gained a pass-through `timeout` param and the probe calls it with
_PROBE_TIMEOUT instead of the default 15s.
- collect_service_health runs the four network subsystems concurrently, each
under a per-subsystem deadline (_SUBSYSTEM_DEADLINE), with an overall
wait_for ceiling (_AGGREGATE_DEADLINE) as a backstop.
Blocker 2 — no secret/raw-error leakage in the response:
- _safe_url strips userinfo, query, and fragment from every URL surfaced in
meta (searxng instance, ntfy base, provider name fallback), keeping only
scheme/host/port/path.
- _classify_error maps every probe failure to a controlled category token
(timeout, connection_refused, dns_error, tls_error, network_error,
http_error, auth_or_protocol_error, …) — raw str(exception), which can embed
credentialed URLs or server text, is never returned.
Tests (tests/test_service_health.py, +tests/test_diagnostics_service_route.py):
- URL userinfo/query redaction for searxng/ntfy/providers.
- secret-bearing exception strings map to categories and don't leak.
- multiple slow providers/accounts stay bounded (single + 25-endpoint cases).
- subsystems run concurrently; aggregate deadline yields a controlled result.
- route-level unauthenticated (401) / non-admin (403) / admin (200) coverage.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
* test(diagnostics): isolate route tests so they don't leak module globals
The new route tests replaced src.service_health.collect_service_health and
routes.diagnostics_routes.require_admin via direct assignment, which persisted
for the rest of the pytest session. In CI's full alphabetical run that fake
collector (returning services=[]) leaked into the later collect_service_health
tests and failed them. Switch to monkeypatch.setattr so both are restored after
each test. No production code change.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
Co-authored-by: Alexandre Teixeira <111787685+alteixeira20@users.noreply.github.com>
86 lines
3.3 KiB
Python
86 lines
3.3 KiB
Python
"""Diagnostics routes — /api/db/stats, /api/rag/stats, /api/test/youtube, /api/test-research."""
|
|
|
|
import logging
|
|
from typing import Dict, Any
|
|
|
|
from fastapi import APIRouter, HTTPException, Form, Request
|
|
|
|
from services.youtube.youtube_handler import extract_youtube_id, extract_transcript_async
|
|
from core.constants import DEFAULT_HOST
|
|
from core.middleware import require_admin
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def setup_diagnostics_routes(
|
|
rag_manager,
|
|
rag_available: bool,
|
|
research_handler,
|
|
memory_vector=None,
|
|
) -> APIRouter:
|
|
router = APIRouter(tags=["diagnostics"])
|
|
|
|
@router.get("/api/diagnostics/services")
|
|
async def get_service_health(request: Request) -> Dict[str, Any]:
|
|
"""Consolidated degraded-state report for ChromaDB, SearXNG, email,
|
|
ntfy, and provider endpoints. Non-intrusive probes — safe to poll."""
|
|
require_admin(request)
|
|
from src.service_health import collect_service_health
|
|
return await collect_service_health(rag_manager, memory_vector)
|
|
|
|
@router.get("/api/db/stats")
|
|
async def get_database_stats(request: Request) -> Dict[str, Any]:
|
|
require_admin(request)
|
|
try:
|
|
from core.database import get_detailed_stats
|
|
return get_detailed_stats()
|
|
except Exception as e:
|
|
logger.error(f"DB stats error: {e}")
|
|
raise HTTPException(500, "Failed to retrieve database statistics")
|
|
|
|
@router.get("/api/rag/stats")
|
|
async def get_rag_stats(request: Request) -> Dict[str, Any]:
|
|
require_admin(request)
|
|
if rag_available and rag_manager:
|
|
return rag_manager.get_stats()
|
|
return {"error": "RAG system not available"}
|
|
|
|
@router.get("/api/test/youtube")
|
|
async def test_youtube(request: Request, url: str) -> Dict[str, Any]:
|
|
require_admin(request)
|
|
try:
|
|
video_id = extract_youtube_id(url)
|
|
if not video_id:
|
|
return {"error": "Invalid YouTube URL"}
|
|
|
|
data = await extract_transcript_async(url, video_id)
|
|
return {
|
|
"video_id": video_id,
|
|
"transcript_success": data.get("success", False),
|
|
"transcript_length": len(data.get("transcript", "")) if data.get("success") else 0,
|
|
"transcript_preview": (data.get("transcript", "")[:500] + "...")
|
|
if data.get("success") and len(data.get("transcript", "")) > 500
|
|
else data.get("transcript", ""),
|
|
"error": data.get("error") if not data.get("success") else None,
|
|
}
|
|
except Exception as e:
|
|
return {"error": str(e)}
|
|
|
|
@router.post("/api/test-research")
|
|
async def test_research(request: Request, query: str = Form("What is machine learning?")) -> Dict[str, Any]:
|
|
require_admin(request)
|
|
try:
|
|
endpoint = f"http://{DEFAULT_HOST}:8000/v1/chat/completions"
|
|
model = "gpt-oss-120b"
|
|
result = await research_handler.call_research_service(query, endpoint, model)
|
|
return {
|
|
"status": "success",
|
|
"query": query,
|
|
"result_preview": result[:200] + "..." if len(result) > 200 else result,
|
|
"result_length": len(result),
|
|
}
|
|
except Exception as e:
|
|
return {"status": "error", "error": str(e), "query": query}
|
|
|
|
return router
|