Update app.py

app.py

@@ -11,14 +11,23 @@ from fastapi import FastAPI
 from fastapi.responses import JSONResponse, PlainTextResponse
 from transformers import pipeline
 
-# === Импорт логировщика ===
+# === Импорт логирования + метрик + FailSafe ===
 from core.alert_core import log_alert
 from core.metrics_core import save_metrics
+from core.alerters import ConsoleAlerter, FileAlerter
+from core.alert_manager import AlertManager
+from core.failsafe_core import failsafe
 import time
 
-# === Настройка имен моделей ===
+# === Настройка моделей для логики ===
 PRIMARY_MODEL = "microsoft/phi-3-mini-instruct"
-FALLBACK_MODEL = "tiny-gpt2"
+FALLBACK_MODEL = "sshleifer/tiny-gpt2"
+
+# Настройка AlertManager
+alert_manager = AlertManager([
+    ConsoleAlerter(),
+    FileAlerter("alerts_log.json")
+])
 
 HF_TOKEN = os.getenv("HF_TOKEN", "")
 ROUTER_URL = "https://api-inference.huggingface.co/models"
@@ -153,22 +162,139 @@ async def metrics():
 
 @app.post("/inference")
 async def inference(data: dict):
-    text, model = data.get("prompt", ""), data.get("model", "microsoft/phi-3-mini-4k-instruct")
-    res = await client.infer(model, text)
-    if "error" in res:
-        fb = await fallback.generate(text)
-        return {"source": "fallback", "response": fb, "note": res["error"]}
-    return {"source": "router", "response": res}
+
+    prompt = data.get("prompt", "")
+    model = data.get("model", PRIMARY_MODEL)
+
+    start_time = time.time()
+
+    # FailSafe wrapper for primary inference
+    @failsafe(alert_manager)
+    async def run_primary(p, m):
+        return await client.infer(m, p)
+
+    try:
+        res = await run_primary(prompt, model)
+
+        duration = int((time.time() - start_time) * 1000)
+
+        # Метрики
+        save_metrics({
+            "endpoint": "/inference",
+            "model": model,
+            "latency_ms": duration
+        })
+
+        # Лог — успешный ответ
+        log_alert(
+            source="agent",
+            level="INFO",
+            message=f"Inference OK (model={model})",
+            extra={"prompt_len": len(prompt), "latency": duration}
+        )
+
+        # Если ошибка в ответе
+        if isinstance(res, dict) and "error" in res:
+            raise Exception(res["error"])
+
+        return {"source": "router", "response": res}
+
+    except Exception as primary_err:
+
+        log_alert(
+            source="agent",
+            level="ERROR",
+            message=f"Primary inference failed: {primary_err}",
+            extra={"error": str(primary_err)}
+        )
+
+        # Fallback через FailSafe
+        @failsafe(alert_manager)
+        async def run_fallback(p):
+            return await fallback.generate(p)
+
+        try:
+            fb = await run_fallback(prompt)
+            duration = int((time.time() - start_time) * 1000)
+
+            # Fallback метрики
+            save_metrics({
+                "endpoint": "/inference",
+                "model": FALLBACK_MODEL,
+                "latency_ms": duration,
+                "fallback_used": True
+            })
+
+            log_alert(
+                source="fallback",
+                level="WARNING",
+                message=f"Fallback inference OK (model={FALLBACK_MODEL})",
+                extra={"latency": duration}
+            )
+
+            return {"source": "fallback", "response": fb}
+
+        except Exception as fb_err:
+            log_alert(
+                source="fallback",
+                level="ERROR",
+                message=f"Fallback failed: {fb_err}",
+                extra={"error": str(fb_err)}
+            )
+            return {"error": "Inference failure on both primary and fallback"}
+
 
 # ================= GRADIO UI =================
 def gradio_infer(prompt, model_choice):
-    result = asyncio.run(client.infer(model_choice, prompt))
-    if "error" in result:
+
+    start_time = time.time()
+    model = model_choice or PRIMARY_MODEL
+
+    @failsafe(alert_manager)
+    def run_model(p, m):
+        return asyncio.run(client.infer(m, p))
+
+    try:
+        result = run_model(prompt, model)
+
+        duration = int((time.time() - start_time) * 1000)
+
+        # Metрики Gradio
+        save_metrics({
+            "interface": "gradio",
+            "prompt_len": len(prompt),
+            "model": model,
+            "latency_ms": duration
+        })
+
+        log_alert(
+            source="gradio",
+            level="INFO",
+            message=f"Gradio inference success (model={model})",
+            extra={"latency": duration}
+        )
+
+        if isinstance(result, dict) and "error" in result:
+            raise Exception(result["error"])
+
+        if isinstance(result, list):
+            return result[0].get("generated_text", str(result))
+
+        return str(result)
+
+    except Exception as ui_err:
+
+        log_alert(
+            source="gradio",
+            level="ERROR",
+            message=f"Gradio inference error: {ui_err}",
+            extra={"error": str(ui_err)}
+        )
+
+        # fallback
         fb = asyncio.run(fallback.generate(prompt))
-        return f"⚠️ Router failed ({result['error']})\n\n🧠 Fallback:\n{fb}"
-    if isinstance(result, list):
-        return result[0].get("generated_text", str(result))
-    return str(result)
+        return f"⚠️ Error: {ui_err}\n\n🧠 Fallback: {fb}"
+
 
 def show_dashboard():
     mem = psutil.virtual_memory().percent