AegisSight/AegisSight-Monitor
3
0
Fork 0
Code Issues Pull-Requests Actions Pakete Projekte Releases Wiki Aktivität

fix(eu): Kapazitaetsengpaesse bei Bedrock aussitzen statt Schritte verlieren

Quellcode durchsuchen 
Am 01.08.2026 lieferte Bedrock waehrend eines Laufs ServiceUnavailableException.
Botocore versuchte es dreimal in fuenf Sekunden und gab auf, die
Web-Source-Selektion fiel ersatzlos aus. Im Bericht war davon nichts zu sehen,
der Lauf galt als vollstaendig. Gemessen sind es zwei betroffene Aufrufe bei
rund 340, also 0,6 Prozent, aber jeder Vorfall kostet einen ganzen
Pipeline-Schritt.

Der Fehler ist auch keiner unserer Quote. ServiceUnavailableException ist ein
503, AWS hat also gerade keine Kapazitaet fuer das Modell. Unsere Meldung
sagte trotzdem "Rate-Limit", weil der Code beide Faelle in einen Topf warf.

Aendert sich damit:

1. Geduldiges Wiederholen. Kapazitaets- (503), Kontingent- (429) und
   Verbindungsfehler werden nach 5, 15 und 30 Sekunden erneut versucht. Diese
   Dellen dauern typischerweise unter einer Minute, unsere bisherigen fuenf
   Sekunden lagen genau im ungeguenstigsten Fenster. Stufen ueber
   BEDROCK_RETRY_WAITS einstellbar.

2. Zwei Bremsen gegen lange Laeufe. Gewartet wird nur, wenn die Wartezeit ins
   Zeitbudget des Aufrufs passt (die Wartezeit zaehlt gegen dasselbe
   asyncio-Budget, und die Haiku-Planungsaufrufe haben nur 120 Sekunden), und
   nur solange das Wartebudget des Refreshs reicht (BEDROCK_RETRY_BUDGET_S,
   Vorgabe 120 Sekunden). Ein Lauf kann sich dadurch um hoechstens zwei
   Minuten verlaengern.

3. Ursachen werden getrennt benannt. Im Log steht jetzt "hat keine freie
   Kapazitaet" oder "meldet ausgeschoepftes Kontingent" statt pauschal
   "Rate-Limit". Nach aussen bleibt beides die Kategorie rate_limit, damit die
   Retry-Steuerung des Orchestrators unveraendert greift.

4. Stoerungen werden sichtbar. Waehrend einer Wartezeit meldet die Oberflaeche
   "KI-Dienst hat keine freie Kapazitaet, neuer Versuch in 15 Sekunden", sonst
   sieht die stehende Anzeige wie ein Haenger aus. Nach dem Lauf steht eine
   Zusammenfassung im Refresh-Protokoll, auch wenn der Lauf sonst glatt
   durchlief.

5. botocore laeuft im Modus 'adaptive' statt 'standard'. Es bremst sich bei
   Drosselung selbst ein und deckt die Sekunden ab, unsere Schleife die
   Zehnersekunden.

Zeitliche Wirkung, gemessen am EU-Lauf der Ceuta-Lage (252 Sekunden, 15
Bedrock-Aufrufe): im stoerungsfreien Fall null, im betroffenen Lauf rund eine
Minute mehr. Bei 0,6 Prozent Fehlerrate je Aufruf trifft das etwa jeden
elften Lauf, im Mittel ueber alle Laeufe rund zwei Prozent.

Gegenprobe mit einem echten Bedrock-Aufruf ueber den geaenderten Pfad: Antwort,
Verbrauch und Kosten unveraendert, keine Stoerung protokolliert.

Neu sind 23 Pruefungen, insgesamt laufen 179 ohne Netzzugriff und ohne Kosten.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Dieser Commit ist enthalten in:
claude-dev
2026-08-01 22:58:50 +02:00
Ursprung 3495409377
Commit 0154c0f575
5 geänderte Dateien mit 490 neuen und 25 gelöschten Zeilen
Patch-Datei herunterladen Vergleichs-Datei herunterladen Alle Dateien ausklappen Alle Dateien einklappen

249
src/agents/bedrock_client.py
Datei anzeigen

@@ -11,7 +11,9 @@ Preistabelle BEDROCK_PRICING aus config.py, damit ClaudeUsage.cost_usd gefüllt
bleibt und Statistik und Credits-Abrechnung unverändert funktionieren.
"""
import asyncio
import contextvars
import logging
import time
from config import (
BEDROCK_CACHE_READ_FACTOR,
@@ -20,6 +22,9 @@ from config import (
BEDROCK_MODEL_MAP,
BEDROCK_PRICING,
BEDROCK_REGION,
BEDROCK_RETRY_BUDGET_S,
BEDROCK_RETRY_MIN_REST_S,
BEDROCK_RETRY_WAITS,
CLAUDE_MODEL_STANDARD,
CLAUDE_TIMEOUT,
)
@@ -49,6 +54,17 @@ _RATE_LIMIT_CODES = {
"ServiceQuotaExceededException",
"ModelNotReadyException",
}
# Innerhalb der Kategorie 'rate_limit' zwei verschiedene Ursachen, die nach
# aussen gleich behandelt werden (damit die Retry-Steuerung des Orchestrators
# unveraendert greift), im Log aber auseinandergehalten gehoeren:
# Kapazitaet heisst, AWS hat gerade keine freie Rechenzeit fuer das Modell.
# Kontingent heisst, WIR haben zu viele Anfragen je Minute gestellt.
_KAPAZITAETS_CODES = {"ServiceUnavailableException", "ModelNotReadyException"}
_KONTINGENT_CODES = {
"ThrottlingException",
"TooManyRequestsException",
"ServiceQuotaExceededException",
}
_AUTH_ERROR_CODES = {
"AccessDeniedException",
"UnrecognizedClientException",
@@ -66,6 +82,93 @@ _TRANSIENT_EXC_NAMES = (
_client = None
# Klartext je Stoerungsart, genutzt in Log, Refresh-Protokoll und Oberflaeche.
_ART_TEXT = {
"kapazitaet": "hat keine freie Kapazität",
"kontingent": "meldet ausgeschöpftes Kontingent",
"verbindung": "nicht erreichbar",
}
# --- Wartebudget und Sichtbarkeit je Refresh --------------------------------
# Alle drei Variablen gelten fuer den laufenden Refresh (ContextVar, also je
# Task getrennt). Ohne gesetzten Kontext verhaelt sich der Client wie bisher,
# nur mit Wiederholung: das Budget startet dann beim Standardwert und die
# Meldungen gehen ausschliesslich ins Log.
_wartebudget_var: contextvars.ContextVar[list] = contextvars.ContextVar("bedrock_wartebudget")
_stoerungen_var: contextvars.ContextVar[list] = contextvars.ContextVar("bedrock_stoerungen")
# Rueckmeldung an die Oberflaeche waehrend einer Wartezeit. Der Orchestrator
# setzt hier eine Funktion (art, sekunden) -> None, damit die Pipeline-Anzeige
# nicht wie ein Haenger aussieht.
_wartemelder_var: contextvars.ContextVar = contextvars.ContextVar("bedrock_wartemelder")
def refresh_kontext_starten() -> None:
"""Setzt Wartebudget und Stoerungsliste fuer einen neuen Refresh zurueck."""
_wartebudget_var.set([BEDROCK_RETRY_BUDGET_S])
_stoerungen_var.set([])
def stoerungen() -> list[dict]:
"""Stoerungen des laufenden Refreshs, aelteste zuerst."""
return list(_stoerungen_var.get([]) or [])
def stoerungen_zusammenfassen() -> str:
"""Einzeiler ueber die Stoerungen des Laufs, leer wenn es keine gab.
Landet im Refresh-Protokoll, damit ein Lauf mit Aussetzern nicht wie ein
vollstaendiger aussieht.
"""
eintraege = stoerungen()
if not eintraege:
return ""
je_art: dict[str, int] = {}
gewartet = 0.0
for e in eintraege:
je_art[e["art"]] = je_art.get(e["art"], 0) + 1
gewartet += e["wartezeit"]
teile = [f"{anzahl}x {_ART_TEXT.get(art, art)}" for art, anzahl in sorted(je_art.items())]
return f"KI-Dienst: {', '.join(teile)}, insgesamt {gewartet:.0f}s gewartet"
def wartemelder_setzen(melder) -> None:
"""Hinterlegt die Rueckmeldung an die Oberflaeche fuer diesen Refresh."""
_wartemelder_var.set(melder)
def _budget_rest() -> float:
behaelter = _wartebudget_var.get(None)
if behaelter is None:
behaelter = [BEDROCK_RETRY_BUDGET_S]
_wartebudget_var.set(behaelter)
return behaelter[0]
def _budget_verbrauchen(sekunden: float) -> None:
behaelter = _wartebudget_var.get(None)
if behaelter is not None:
behaelter[0] = max(0.0, behaelter[0] - sekunden)
def merke_stoerung(art: str, modell: str, wartezeit: float) -> None:
"""Haelt eine wiederholte Stoerung fuer das Refresh-Protokoll fest."""
liste = _stoerungen_var.get(None)
if liste is None:
liste = []
_stoerungen_var.set(liste)
liste.append({"art": art, "modell": modell, "wartezeit": wartezeit})
def _melde_wartezeit(art: str, sekunden: float) -> None:
"""Meldet eine laufende Wartezeit an die Oberflaeche, wenn eingerichtet."""
melder = _wartemelder_var.get(None)
if melder is None:
return
try:
melder(art, sekunden)
except Exception as e: # Anzeige darf den Lauf nie gefaehrden
logger.debug("Wartemeldung fehlgeschlagen: %s", e)
def _get_client():
"""Erzeugt den bedrock-runtime-Client einmalig. Lazy Import, damit die App
@@ -86,18 +189,27 @@ def _get_client():
config=Config(
connect_timeout=10,
read_timeout=CLAUDE_TIMEOUT,
retries={"max_attempts": 2, "mode": "standard"},
# 'adaptive' bremst sich bei Drosselung selbst ein, statt
# stur nachzuschieben. Die Versuchszahl bleibt klein, weil das
# geduldige Warten in call_bedrock sitzt: botocore deckt die
# Sekunden ab, unsere Schleife die Zehnersekunden.
retries={"max_attempts": 3, "mode": "adaptive"},
),
)
return _client
def _classify_bedrock_error(exc: Exception) -> str:
"""Ordnet einer botocore-Exception eine error_type-Kategorie zu."""
code = ""
def _fehlercode(exc: Exception) -> str:
"""Botocore-Fehlercode einer Exception, leer wenn keiner vorliegt."""
response = getattr(exc, "response", None)
if isinstance(response, dict):
code = response.get("Error", {}).get("Code", "") or ""
return response.get("Error", {}).get("Code", "") or ""
return ""
def _classify_bedrock_error(exc: Exception) -> str:
"""Ordnet einer botocore-Exception eine error_type-Kategorie zu."""
code = _fehlercode(exc)
if code in _RATE_LIMIT_CODES:
return "rate_limit"
if code in _AUTH_ERROR_CODES:
@@ -105,6 +217,22 @@ def _classify_bedrock_error(exc: Exception) -> str:
return "cli_error"
def stoerungsart(exc: Exception) -> str | None:
"""Benennt die Ursache einer wiederholbaren Stoerung, sonst None.
'kapazitaet' = AWS hat keine freie Rechenzeit fuer das Modell (HTTP 503).
'kontingent' = unsere Anfragen je Minute sind ausgeschoepft (HTTP 429).
"""
code = _fehlercode(exc)
if code in _KAPAZITAETS_CODES:
return "kapazitaet"
if code in _KONTINGENT_CODES:
return "kontingent"
if type(exc).__name__ in _TRANSIENT_EXC_NAMES:
return "verbindung"
return None
def _cost_usd(
cli_model: str,
input_tokens: int,
@@ -138,6 +266,10 @@ async def call_bedrock(
Gleicher Vertrag wie call_claude mit tools=None. Fehler kommen als
ClaudeCliError mit denselben error_type-Kategorien, Timeouts als
TimeoutError, Abbrüche als CancelledError.
Bei Kapazitäts- und Kontingentfehlern wird nach BEDROCK_RETRY_WAITS erneut
versucht, begrenzt durch das Zeitbudget dieses Aufrufs und das
Wartebudget des laufenden Refreshs.
"""
cli_model = model or CLAUDE_MODEL_STANDARD
bedrock_model = BEDROCK_MODEL_MAP.get(cli_model)
@@ -170,6 +302,89 @@ async def call_bedrock(
if not raw_text:
kwargs["system"] = [{"text": _JSON_ONLY_SYSTEM}]
beginn = time.monotonic()
versuch = 0
while True:
try:
response = await _converse_einmal(
client, kwargs, effective_timeout - (time.monotonic() - beginn), cancel_event
)
break
except (asyncio.CancelledError, TimeoutError):
raise
except Exception as e:
art = stoerungsart(e)
wartezeit = _wartezeit(
art, versuch, rest=effective_timeout - (time.monotonic() - beginn)
)
if wartezeit is None:
_protokolliere_fehler(e, cli_model, versuch)
if type(e).__name__ in _TRANSIENT_EXC_NAMES:
raise TimeoutError(f"Bedrock Verbindungsfehler ({type(e).__name__}). {e}") from e
raise ClaudeCliError(
_classify_bedrock_error(e), f"{type(e).__name__}. {e}"
) from e
versuch += 1
_budget_verbrauchen(wartezeit)
merke_stoerung(art, cli_model, wartezeit)
logger.warning(
"Bedrock %s (%s, %s): Versuch %d in %.0fs",
_ART_TEXT.get(art, art), type(e).__name__, cli_model, versuch + 1, wartezeit,
)
_melde_wartezeit(art, wartezeit)
await asyncio.sleep(wartezeit)
if cancel_event and cancel_event.is_set():
raise asyncio.CancelledError("Cancel angefordert")
return _auswerten(response, cli_model, bedrock_model)
def _wartezeit(art: str | None, versuch: int, rest: float) -> float | None:
"""Wartezeit vor dem nächsten Versuch, None wenn nicht wiederholt wird.
Drei Bedingungen müssen zusammenkommen: die Störung ist wiederholbar, es
gibt noch eine Wartestufe, und die Wartezeit passt sowohl in das
Zeitbudget dieses Aufrufs als auch in das Wartebudget des Refreshs.
"""
if not art or versuch >= len(BEDROCK_RETRY_WAITS):
return None
wartezeit = BEDROCK_RETRY_WAITS[versuch]
if rest < wartezeit + BEDROCK_RETRY_MIN_REST_S:
logger.warning(
"Bedrock: keine Wiederholung, Zeitbudget des Aufrufs reicht nicht "
"(%.0fs übrig, %.0fs Wartezeit plus %.0fs Reserve nötig)",
max(rest, 0), wartezeit, BEDROCK_RETRY_MIN_REST_S,
)
return None
if _budget_rest() < wartezeit:
logger.warning(
"Bedrock: keine Wiederholung, Wartebudget des Laufs erschöpft (%.0fs übrig)",
_budget_rest(),
)
return None
return wartezeit
def _protokolliere_fehler(e: Exception, cli_model: str, versuch: int) -> None:
"""Schreibt den endgültigen Fehler mit seiner Ursache ins Log."""
exc_name = type(e).__name__
zusatz = f" nach {versuch + 1} Versuchen" if versuch else ""
art = stoerungsart(e)
if art:
logger.warning(
"Bedrock %s (%s, %s)%s. %s", _ART_TEXT.get(art, art), exc_name, cli_model, zusatz, e
)
elif _classify_bedrock_error(e) == "auth_error":
logger.error("Bedrock Auth-Fehler (%s). %s", exc_name, e)
else:
logger.error("Bedrock-Fehler (%s). %s", exc_name, e)
async def _converse_einmal(client, kwargs: dict, rest_timeout: float, cancel_event):
"""Führt genau einen Converse-Aufruf aus und gibt die Antwort zurück."""
if rest_timeout <= 0:
raise TimeoutError("Bedrock Timeout: Zeitbudget vor dem Aufruf aufgebraucht")
call_task = asyncio.create_task(asyncio.to_thread(client.converse, **kwargs))
wait_tasks = [call_task]
cancel_wait_task = None
@@ -178,7 +393,7 @@ async def call_bedrock(
wait_tasks.append(cancel_wait_task)
done, pending = await asyncio.wait(
wait_tasks, timeout=effective_timeout, return_when=asyncio.FIRST_COMPLETED
wait_tasks, timeout=rest_timeout, return_when=asyncio.FIRST_COMPLETED
)
for p in pending:
p.cancel()
@@ -192,23 +407,15 @@ async def call_bedrock(
)
if cancel_wait_task is not None and cancel_wait_task in done:
raise asyncio.CancelledError("Cancel angefordert")
raise TimeoutError(f"Bedrock Timeout nach {effective_timeout}s")
raise TimeoutError(f"Bedrock Timeout nach {rest_timeout:.0f}s")
try:
response = call_task.result()
except Exception as e:
exc_name = type(e).__name__
if exc_name in _TRANSIENT_EXC_NAMES:
raise TimeoutError(f"Bedrock Verbindungsfehler ({exc_name}). {e}") from e
error_type = _classify_bedrock_error(e)
if error_type == "rate_limit":
logger.warning(f"Bedrock Rate-Limit ({exc_name}). {e}")
elif error_type == "auth_error":
logger.error(f"Bedrock Auth-Fehler ({exc_name}). {e}")
else:
logger.error(f"Bedrock-Fehler ({exc_name}). {e}")
raise ClaudeCliError(error_type, f"{exc_name}. {e}") from e
# Fehler werden hier NICHT behandelt, das entscheidet die Wiederholung in
# call_bedrock anhand der Stoerungsart.
return call_task.result()
def _auswerten(response: dict, cli_model: str, bedrock_model: str) -> tuple[str, ClaudeUsage]:
"""Wandelt die Converse-Antwort in (Text, Verbrauch) um."""
out_msg = response.get("output", {}).get("message", {})
parts = [c.get("text", "") for c in out_msg.get("content", []) if "text" in c]
result_text = "".join(parts).strip()

31
src/agents/orchestrator.py
Datei anzeigen

@@ -12,6 +12,7 @@ from urllib.parse import urlparse, urlunparse, quote_plus
import httpx
from agents.claude_client import UsageAccumulator, _cancel_event_var, _ai_backend_var
from agents import bedrock_client
from agents.factchecker import find_matching_claim, deduplicate_new_facts, TWOPHASE_MIN_FACTS
from source_rules import (
_detect_category,
@@ -878,6 +879,24 @@ class AgentOrchestrator:
_ai_backend_var.set(ai_backend)
if ai_backend != "cli":
logger.info("Lage %s läuft über KI-Backend '%s'", incident_id, ai_backend)
# Wartebudget des EU-Wegs zuruecksetzen und die Oberflaeche an die
# Wartemeldungen anschliessen. Ohne diesen Hinweis sieht eine
# Wiederholung nach einem Kapazitaetsengpass wie ein Haenger aus,
# weil die Anzeige waehrend der Wartezeit stillsteht.
bedrock_client.refresh_kontext_starten()
if self._ws_manager:
def _warte_melden(art: str, sekunden: float, _iid=incident_id,
_vis=visibility, _cb=created_by, _tid=tenant_id) -> None:
text = bedrock_client._ART_TEXT.get(art, art)
asyncio.create_task(self._ws_manager.broadcast_for_incident({
"type": "status_update",
"incident_id": _iid,
"data": {
"status": "running",
"detail": f"KI-Dienst {text}, neuer Versuch in {sekunden:.0f} Sekunden...",
},
}, _vis, _cb, _tid))
bedrock_client.wartemelder_setzen(_warte_melden)
output_language_iso = await get_org_language(db, tenant_id) if tenant_id else "de"
output_language = language_display(output_language_iso)
# research_language steuert nur den WebSearch-Prompt ("suche in Sprache X").
@@ -2200,18 +2219,24 @@ class AgentOrchestrator:
if _missing_key not in _started_keys:
await _pipe_skip(_missing_key)
# Refresh-Log abschließen (mit Token-Statistiken)
# Refresh-Log abschließen (mit Token-Statistiken). Störungen des
# KI-Dienstes werden auch bei einem erfolgreichen Lauf vermerkt,
# sonst sieht ein Durchlauf mit Aussetzern aus wie ein glatter.
stoerungshinweis = bedrock_client.stoerungen_zusammenfassen() or None
if stoerungshinweis:
logger.info("Refresh-Protokoll Lage %s: %s", incident_id, stoerungshinweis)
await db.execute(
"""UPDATE refresh_log SET
completed_at = ?, articles_found = ?, status = 'completed',
input_tokens = ?, output_tokens = ?,
cache_creation_tokens = ?, cache_read_tokens = ?,
total_cost_usd = ?, api_calls = ?
total_cost_usd = ?, api_calls = ?, error_message = ?
WHERE id = ?""",
(datetime.now(TIMEZONE).strftime('%Y-%m-%d %H:%M:%S'), new_count,
usage_acc.input_tokens, usage_acc.output_tokens,
usage_acc.cache_creation_tokens, usage_acc.cache_read_tokens,
round(usage_acc.total_cost_usd, 7), usage_acc.call_count, log_id),
round(usage_acc.total_cost_usd, 7), usage_acc.call_count,
stoerungshinweis, log_id),
)
await db.commit()
logger.info(