diff --git a/crates/analysis-prompt/src/lib.rs b/crates/analysis-prompt/src/lib.rs index 5dbfe27..d5a7d67 100644 --- a/crates/analysis-prompt/src/lib.rs +++ b/crates/analysis-prompt/src/lib.rs @@ -462,8 +462,8 @@ fn question_system(language: &str) -> String { if language == "hu" { let mut text = format!( "Tapasztalt, empatikus, lélektani szemléletű asztrológus vagy a Sorsfonalak alkalmazásban. Az olvasó már \ -megkapta a részletes elemzését (születési képletelemzést vagy éves előrejelzést), és most kérdez róla. Válaszolj a \ -kérdésére. +megkapta a részletes elemzését (születési képletelemzést, kapcsolati elemzést vagy éves előrejelzést), és most kérdez \ +róla. Válaszolj a kérdésére. Szabályok: - A válasz a megadott képletadatokon és az elemzésen alapuljon. Ne találj ki pozíciót, fényszöget, házat vagy dátumot, \ @@ -471,8 +471,10 @@ amely nincs az adatok között. Ha a kérdésre az adatok alapján nem lehet fel amit a képlet erről mutat. - Maradj összhangban az elemzéssel. Ha a kérdés olyan részletre vonatkozik, amelyet az elemzés nem tárgyalt, a \ képletadatokból egészítsd ki. -- Közvetlenül a kérdezőhöz szólj, tegező formában. Ha a kérdés két ember kapcsolatáról szól, csak abból beszélj, amit \ -az adatok mutatnak. +- Közvetlenül a kérdezőhöz szólj, tegező formában. Kapcsolati elemzésnél (két képlet összevetése) a kérdező az egyik \ +fél: ha a kérdésből nem derül ki, melyik, beszélj kettejükhöz („ti”, „kettőtök”). A feleket az adatokban Person 1 és \ +Person 2 jelöli, a szövegben „az első fél” és „a második fél”. Ne feltételezd a nemüket és a kapcsolat jellegét, és \ +csak abból beszélj, amit az adatok mutatnak. - Hangnem: meleg, őszinte, megerősítő és konkrét. Ne légy fatalista: ne jósolj betegséget, halált, balesetet, \ terhességet vagy biztos eseményeket, és ne adj orvosi, jogi vagy pénzügyi tanácsot. Ha ilyet kérdeznek, kedvesen \ tereld a választ arra, amit az asztrológia valóban mutat: hajlamokra, időszakokra, lehetőségekre. @@ -490,7 +492,8 @@ használhatsz. } format!( "You are an experienced, warm and psychologically minded astrologer in the Sorsfonalak app. The reader has \ -received their detailed analysis (a natal chart interpretation or a yearly forecast) and now asks a question about it. \ +received their detailed analysis (a natal chart interpretation, a relationship analysis or a yearly forecast) and now \ +asks a question about it. \ Answer it. Write in {lang}. @@ -499,7 +502,9 @@ Rules: - Base the answer on the chart data and the analysis given. Never invent positions, aspects, houses or dates that are \ not listed. If the data cannot answer the question, say so honestly and describe what the chart does show about it. - Stay consistent with the analysis; fill in details it did not cover from the chart data. -- Speak to the reader directly, in the informal second person. +- Speak to the reader directly, in the informal second person. On a relationship analysis the reader is one of the \ +two people (Person 1 and Person 2 in the data); when it is unclear which, speak to both. Do not assume their genders \ +or the type of relationship. - Tone: warm, honest, empowering and concrete. Not fatalistic: no predictions of illness, death, accidents, pregnancy \ or certain events, and no medical, legal or financial advice; if asked, turn gently to what astrology does show \ (tendencies, periods, opportunities). diff --git a/crates/db/migrations/0020_generation_errors.sql b/crates/db/migrations/0020_generation_errors.sql new file mode 100644 index 0000000..9bc463f --- /dev/null +++ b/crates/db/migrations/0020_generation_errors.sql @@ -0,0 +1,26 @@ +-- Every failed attempt of an analysis, an answer or a prompt test run, for the +-- admin error log. No foreign keys: the log outlives deleted items. Kept for +-- 90 days (worker cleanup). +CREATE TABLE generation_errors ( + id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, + created_at timestamptz NOT NULL DEFAULT now(), + source text NOT NULL CHECK (source IN ('analysis', 'question', 'preview')), + item_id uuid NOT NULL, + kind text NOT NULL, + model text NOT NULL, + attempt integer NOT NULL, + -- What happened next: tried again, the default model took over, or gave up. + outcome text NOT NULL CHECK (outcome IN ('retry', 'fallback', 'failed')), + error text NOT NULL, + seconds integer +); + +CREATE INDEX generation_errors_created_idx ON generation_errors (created_at DESC); +CREATE INDEX generation_errors_item_idx ON generation_errors (item_id); + +-- When the current text was asked for (a regeneration or an admin restart +-- sets it again): the waiting page counts from here. +ALTER TABLE analyses ADD COLUMN requested_at timestamptz NOT NULL DEFAULT now(); +UPDATE analyses SET requested_at = created_at; +ALTER TABLE questions ADD COLUMN requested_at timestamptz NOT NULL DEFAULT now(); +UPDATE questions SET requested_at = created_at; diff --git a/docs/kerdesek.md b/docs/kerdesek.md index 0535459..1125856 100644 --- a/docs/kerdesek.md +++ b/docs/kerdesek.md @@ -1,13 +1,14 @@ # Kérdések az elemzésekről -A kész részletes képletelemzés és éves előrejelzés alatt a felhasználó kérdezhet róla („Kérdezz az elemzésedről”). Minden kérdés egy `question` egységet használ; minden csomagban 3 jár, és külön is vehető (+5 kérdés, 1 000 Ft). Admin ingyen kérdez. +A kész részletes képletelemzés, kapcsolati elemzés és éves előrejelzés alatt a felhasználó kérdezhet róla („Kérdezz az elemzésedről”). Minden kérdés egy `question` egységet használ; minden csomagban 3 jár, és külön is vehető (+5 kérdés, 1 000 Ft). Admin ingyen kérdez. ## Hogyan készül a válasz - **Modell:** a Modellek oldalon külön beállítható kérdés-válasz modell (alapból Opus 5.5). Ha a választott modell hibára fut, az alapmodell válaszol (tartalék). -- **Amit a modell kap:** a képlet tömör adatsorát (előrejelzésnél az év adatait is), magát az elemzést, az ugyanerre az elemzésre feltett korábbi legfeljebb 6 kérdést a válasszal, és az új kérdést. Születési dátum, hely, idő és név nem megy ki. +- **Amit a modell kap:** a képlet tömör adatsorát (kapcsolati elemzésnél mindkét képletet és az összevetést, előrejelzésnél az év adatait is), magát az elemzést, az ugyanerre az elemzésre feltett korábbi legfeljebb 6 kérdést a válasszal, és az új kérdést. Születési dátum, hely, idő és név nem megy ki. - **Prompt:** az admin felületen szerkeszthető (Promptok → Kérdés-válasz). A szóhatár (`QUESTION_MAX_WORDS` = 250) a felhasználói üzenetben is benne van, így a prompt átírásától sem vész el. A kérdés legfeljebb 600 karakter. - **Szabályok:** csak a képletből és az elemzésből válaszol, nem jósol betegséget, halált, balesetet, terhességet vagy biztos eseményt, nem ad orvosi, jogi, pénzügyi tanácsot; a nem asztrológiai kérdést udvariasan elhárítja; a kérdésben lévő utasításokat nem követi. +- **Kapcsolati elemzés:** az összevetés mindkét tagja kérdezhet (a saját kérdéseiből), és mindketten látják a kérdéseket és a válaszokat. - **Egyszerre egy:** amíg egy kérdésre készül a válasz, újabb nem tehető fel ugyanarra az elemzésre (így a válaszok egymásra épülnek). - **Hiba:** a worker újrapróbálja, mint az elemzéseket; végleges hibánál a kérdést visszaadja (egyszer). - **Újragenerálás:** admin a válasz melletti ↻ gombbal újraírathatja (díjmentesen). diff --git a/services/backend/README.md b/services/backend/README.md index 0205dd6..14f6651 100644 --- a/services/backend/README.md +++ b/services/backend/README.md @@ -127,6 +127,8 @@ Hibák formátuma: `{"error": {"code", "message"}}`. A születési adatok hibái - **Fizetős rész:** a részletes elemzés darabra megy. A képletelemzés egy `natal`, a szinasztria-elemzés egy `synastry` egységet von le (`credit_ledger.unit`). Az egységek csomagvásárlásból (Stripe, később) vagy admin jóváírásból jönnek. Havi ingyenes keret nincs. - **Modell:** három beállítás az admin felületen, az OpenRouter listájából (`model_settings` tábla): az elemzések és az éves előrejelzés (képlet-, kapcsolati elemzés, előrejelzés) közös modellje, a kérdés-válasz modellje és a rövid összefoglalóé. Ha nincs beállítva, az `ANALYSIS_MODEL` / `SUMMARY_MODEL` (alapból mindkettő Opus 5.5, a 2026-11-es összevetés legjobbja, lásd `services/worker/README.md`). Csak kötött JSON-választ adó modell választható. A kliens nem választ modellt, és a modell neve felhasználónak sehol nem jelenik meg. - **Tartalék:** ha a választott modell kétszer hibára fut (végleges hibánál egyszer), a worker az alapmodellel próbálja tovább (`fallback_model`, `on_fallback`); csak ha az is elbukik, jár vissza az egység. A Modellek oldal mutatja, hány szövegnél kellett az elmúlt 30 napban. +- **Hibanapló:** a worker minden sikertelen próbálkozást a `generation_errors` táblába ír (mi, melyik modell, hányadik kísérlet, mi lett: újrapróbálás, tartalék vagy végleges hiba, mennyi ideig tartott); az admin Hibanapló oldala mutatja (`GET /v1/admin/errors?source=&outcome=`), 90 napig őrizzük. A felhasználó a várakozó oldalon látja, ha az előző próbálkozás nem sikerült és újrapróbáljuk; a számláló a kérés idejétől (`requested_at`) mér. +- **Futó generálások:** a Modellek oldalon látszik minden készülő és sorban álló elemzés és válasz, a modelljével és azzal, amivel most indulna; újraindításkor a jelenlegi beállítással indul újra (`GET /v1/admin/jobs`, `POST /v1/admin/jobs/restart`). Minden kísérlet `started_at` értéke a „jegye”: az újraindítás törli, így a workerben még futó régi kísérlet nem írhatja felül az újat, és a worker 10 másodpercen belül eldobja. - **Újragenerálás:** admin minden elemzést egyenként újraírathat (`POST /v1/admin/analyses/{id}/regenerate`): ugyanaz a sor (az azonosító és a megosztások maradnak), a jelenlegi prompttal és modellel, egységlevonás nélkül. - **Újraszámolás:** számítási változás után a `backend recalculate` parancs minden mentett képletet, összevetést és előrejelzést újraszámol, majd minden elemzést újra sorba állít (egységlevonás nélkül). - **Kérés:** a `POST .../analyses` (`{language?}`) létrehoz egy `pending` elemzést, és levon egy egységet; a szöveget a worker írja meg, általában 1–2 perc alatt. A kliens a `GET /v1/analyses/{id}` végponton kérdezi le az állapotát. Ha nincs egység, 402 `insufficient_credits` a válasz (`unit`, `balance` részletekkel). Hiba esetén a worker visszaadja az egységet. diff --git a/services/backend/src/routes/analyses.rs b/services/backend/src/routes/analyses.rs index 7eb205f..cb8cf7e 100644 --- a/services/backend/src/routes/analyses.rs +++ b/services/backend/src/routes/analyses.rs @@ -49,11 +49,16 @@ pub struct AnalysisRow { pub credits_charged: i32, pub created_at: OffsetDateTime, pub completed_at: Option, + /// Attempts so far; above 1 the page says it is being tried again. + pub attempts: i32, + pub next_attempt_at: OffsetDateTime, + /// When the current text was asked for (set again by a regeneration). + pub requested_at: OffsetDateTime, } const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, forecast_id, language, prompt_version, status, \ content, error, \ - credits_charged, created_at, completed_at"; + credits_charged, created_at, completed_at, attempts, next_attempt_at, requested_at"; impl AnalysisRow { pub fn view(&self) -> Value { @@ -71,6 +76,9 @@ impl AnalysisRow { "credits_charged": self.credits_charged, "created_at": rfc3339(self.created_at), "completed_at": rfc3339_opt(self.completed_at), + "attempts": self.attempts, + "next_attempt_at": rfc3339(self.next_attempt_at), + "requested_at": rfc3339(self.requested_at), }) } } @@ -146,7 +154,7 @@ async fn request( /// The cache key and the prompt version of a new analysis. The cache key leaves /// out the admin-edited prompt revision, so a chart keeps its analysis when the /// prompt changes; copying from another chart needs the same revision. -async fn versions( +pub(super) async fn versions( state: &AppState, kind: &str, hash: &str, @@ -359,6 +367,17 @@ pub async fn request_for_forecast( request(&state, &auth, Target::Forecast { forecast_id: forecast.id, hash: forecast.forecast_hash }, req).await } +/// The hash of what the analysis is about (chart, comparison or forecast), +/// part of its cache key; `None` when that was deleted. +pub(super) async fn target_hash(db: &PgPool, row: &AnalysisRow) -> Result, sqlx::Error> { + let (query, id) = match row.kind.as_str() { + "synastry" => ("SELECT synastry_hash FROM synastries WHERE id = $1", row.synastry_id), + "forecast" => ("SELECT forecast_hash FROM forecasts WHERE id = $1", row.forecast_id), + _ => ("SELECT chart_hash FROM charts WHERE id = $1", row.chart_id), + }; + sqlx::query_scalar(query).bind(id).fetch_optional(db).await +} + /// Admin: writes an analysis again in place (same id, so links stay), with the /// current prompt and model. Nobody is charged. pub async fn regenerate( @@ -371,27 +390,7 @@ pub async fn regenerate( return Err(ApiError::conflict("analysis_in_progress", "Ez az elemzés éppen készül.")); } let kind = Kind::parse(&row.kind).ok_or_else(|| ApiError::Internal(format!("unknown kind {}", row.kind)))?; - let hash: Option = match kind { - Kind::Question => None, - Kind::Natal | Kind::Summary => { - sqlx::query_scalar("SELECT chart_hash FROM charts WHERE id = $1") - .bind(row.chart_id) - .fetch_optional(&state.db) - .await? - } - Kind::Synastry => { - sqlx::query_scalar("SELECT synastry_hash FROM synastries WHERE id = $1") - .bind(row.synastry_id) - .fetch_optional(&state.db) - .await? - } - Kind::Forecast => { - sqlx::query_scalar("SELECT forecast_hash FROM forecasts WHERE id = $1") - .bind(row.forecast_id) - .fetch_optional(&state.db) - .await? - } - }; + let hash = target_hash(&state.db, &row).await?; let hash = hash.ok_or(ApiError::NotFound("analysis"))?; let (model, fallback) = crate::models::models_for(&state, kind).await?; let (cache_key, prompt_version) = versions(&state, kind.as_str(), &hash, &model, &row.language).await?; @@ -400,7 +399,7 @@ pub async fn regenerate( "UPDATE analyses SET status = 'pending', content = NULL, error = NULL, model_used = NULL, \ input_tokens = NULL, output_tokens = NULL, cost_usd = NULL, attempts = 0, next_attempt_at = now(), \ started_at = NULL, completed_at = NULL, model = $2, prompt_version = $3, cache_key = $4, \ - fallback_model = $5, on_fallback = false \ + fallback_model = $5, on_fallback = false, requested_at = now() \ WHERE id = $1 AND status IN ('done', 'failed') RETURNING {ANALYSIS_COLUMNS}" )) .bind(id) diff --git a/services/backend/src/routes/errors.rs b/services/backend/src/routes/errors.rs new file mode 100644 index 0000000..620008a --- /dev/null +++ b/services/backend/src/routes/errors.rs @@ -0,0 +1,73 @@ +//! Admin: the error log of the analyses, answers and prompt test runs (every +//! failed attempt, written by the worker), newest first. + +use axum::Json; +use axum::extract::{Query, State}; +use axum_extra::extract::WithRejection; +use serde::Deserialize; +use serde_json::{Value, json}; +use time::OffsetDateTime; +use uuid::Uuid; + +use super::St; +use crate::auth::AdminUser; +use crate::error::{ApiError, ApiResult}; +use crate::views::rfc3339; + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +pub struct ErrorQuery { + limit: Option, + offset: Option, + /// `analysis`, `question` or `preview`. + source: Option, + /// `retry`, `fallback` or `failed`. + outcome: Option, +} + +type Row = (i64, OffsetDateTime, String, Uuid, String, String, i32, String, String, Option, Option); + +pub async fn list( + State(state): St, + _admin: AdminUser, + WithRejection(Query(query), _): WithRejection, ApiError>, +) -> ApiResult> { + let limit = query.limit.unwrap_or(100).clamp(1, 500); + let offset = query.offset.unwrap_or(0).max(0); + // Whose text it was: the requester of the analysis or the asker. + let rows: Vec = sqlx::query_as( + "SELECT e.id, e.created_at, e.source, e.item_id, e.kind, e.model, e.attempt, e.outcome, e.error, e.seconds, \ + u.email \ + FROM generation_errors e \ + LEFT JOIN analyses a ON e.source = 'analysis' AND a.id = e.item_id \ + LEFT JOIN questions q ON e.source = 'question' AND q.id = e.item_id \ + LEFT JOIN prompt_previews p ON e.source = 'preview' AND p.id = e.item_id \ + LEFT JOIN users u ON u.id = coalesce(a.requested_by, q.asked_by, p.created_by) \ + WHERE ($1::text IS NULL OR e.source = $1) AND ($2::text IS NULL OR e.outcome = $2) \ + ORDER BY e.id DESC LIMIT $3 OFFSET $4", + ) + .bind(&query.source) + .bind(&query.outcome) + .bind(limit) + .bind(offset) + .fetch_all(&state.db) + .await?; + let (total, last_day): (i64, i64) = sqlx::query_as( + "SELECT count(*), count(*) FILTER (WHERE created_at > now() - interval '1 day') FROM generation_errors \ + WHERE ($1::text IS NULL OR source = $1) AND ($2::text IS NULL OR outcome = $2)", + ) + .bind(&query.source) + .bind(&query.outcome) + .fetch_one(&state.db) + .await?; + let errors: Vec = rows + .into_iter() + .map(|(id, at, source, item, kind, model, attempt, outcome, error, seconds, email)| { + json!({ + "id": id, "created_at": rfc3339(at), "source": source, "item_id": item, "kind": kind, "model": model, + "attempt": attempt, "outcome": outcome, "error": error, "seconds": seconds, "user": email, + }) + }) + .collect(); + Ok(Json(json!({ "errors": errors, "total": total, "last_day": last_day, "limit": limit, "offset": offset }))) +} diff --git a/services/backend/src/routes/jobs.rs b/services/backend/src/routes/jobs.rs new file mode 100644 index 0000000..74e3fd0 --- /dev/null +++ b/services/backend/src/routes/jobs.rs @@ -0,0 +1,150 @@ +//! Admin: the analyses and answers being written or waiting in the queue, +//! and restarting them with the models set now (e.g. after switching away +//! from a slow model). A restarted attempt that is still running in the +//! worker is dropped there and cannot overwrite the new one. + +use std::collections::HashMap; + +use analysis_prompt::Kind; +use axum::Json; +use axum::extract::State; +use axum_extra::extract::WithRejection; +use serde::Deserialize; +use serde_json::{Value, json}; +use time::OffsetDateTime; +use uuid::Uuid; + +use super::analyses::{find_analysis, target_hash, versions}; +use super::{Body, St}; +use crate::AppState; +use crate::auth::AdminUser; +use crate::error::ApiResult; +use crate::models::{Function, models_for}; +use crate::views::{rfc3339, rfc3339_opt}; + +type JobRow = ( + Uuid, + String, + String, + String, + Option, + bool, + i32, + Option, + OffsetDateTime, + OffsetDateTime, + Option, +); + +const COLUMNS: &str = + "id, kind, status, model, fallback_model, on_fallback, attempts, started_at, created_at, next_attempt_at, error"; + +async fn open_jobs(state: &AppState) -> Result, sqlx::Error> { + let analyses: Vec = sqlx::query_as(&format!( + "SELECT {COLUMNS} FROM analyses WHERE status IN ('pending', 'running') ORDER BY created_at" + )) + .fetch_all(&state.db) + .await?; + let questions: Vec = sqlx::query_as( + "SELECT id, 'question', status, model, fallback_model, on_fallback, attempts, started_at, created_at, \ + next_attempt_at, error \ + FROM questions WHERE status IN ('pending', 'running') ORDER BY created_at", + ) + .fetch_all(&state.db) + .await?; + Ok(analyses.into_iter().map(|r| ("analysis", r)).chain(questions.into_iter().map(|r| ("question", r))).collect()) +} + +pub async fn list(State(state): St, _admin: AdminUser) -> ApiResult> { + Ok(Json(json!({ "jobs": views(&state).await? }))) +} + +async fn views(state: &AppState) -> Result, sqlx::Error> { + // The models a restart would use, per function. + let mut next: HashMap<&'static str, (String, Option)> = HashMap::new(); + for (function, kind) in + [(Function::Summary, Kind::Summary), (Function::Analysis, Kind::Natal), (Function::Question, Kind::Question)] + { + next.insert(function.key(), models_for(state, kind).await?); + } + Ok(open_jobs(state) + .await? + .into_iter() + .map(|(table, (id, kind, status, model, fallback, on_fallback, attempts, started, created, due, error))| { + let function = Function::of(Kind::parse(&kind).unwrap_or(Kind::Natal)).key(); + let (next_model, next_fallback) = &next[function]; + let active = if on_fallback { fallback.clone().unwrap_or_else(|| model.clone()) } else { model.clone() }; + json!({ + "id": id, "type": table, "kind": kind, "status": status, "model": active, "on_fallback": on_fallback, + "next_model": next_model, "next_fallback": next_fallback, "attempts": attempts, + "started_at": rfc3339_opt(started), "created_at": rfc3339(created), "next_attempt_at": rfc3339(due), + "error": error, + }) + }) + .collect()) +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +pub struct Restart { + /// The jobs to restart; all open ones when missing. + ids: Option>, +} + +pub async fn restart( + State(state): St, + AdminUser(admin): AdminUser, + WithRejection(Json(req), _): Body, +) -> ApiResult> { + let mut restarted = 0; + for (table, (id, kind, ..)) in open_jobs(&state).await? { + if req.ids.as_ref().is_some_and(|ids| !ids.contains(&id)) { + continue; + } + let done = if table == "question" { + let language: String = sqlx::query_scalar("SELECT language FROM questions WHERE id = $1") + .bind(id) + .fetch_one(&state.db) + .await?; + let (model, fallback, prompt_version) = super::questions::model_and_version(&state, &language).await?; + sqlx::query( + "UPDATE questions SET status = 'pending', model = $2, fallback_model = $3, on_fallback = false, \ + prompt_version = $4, attempts = 0, next_attempt_at = now(), started_at = NULL, error = NULL, \ + requested_at = now() \ + WHERE id = $1 AND status IN ('pending', 'running')", + ) + .bind(id) + .bind(&model) + .bind(&fallback) + .bind(&prompt_version) + .execute(&state.db) + .await? + .rows_affected() + } else { + let Some(row) = find_analysis(&state.db, id).await? else { continue }; + let Some(hash) = target_hash(&state.db, &row).await? else { continue }; + let (model, fallback) = models_for(&state, Kind::parse(&kind).unwrap_or(Kind::Natal)).await?; + let (cache_key, prompt_version) = versions(&state, &kind, &hash, &model, &row.language).await?; + sqlx::query( + "UPDATE analyses SET status = 'pending', model = $2, fallback_model = $3, on_fallback = false, \ + cache_key = $4, prompt_version = $5, attempts = 0, next_attempt_at = now(), started_at = NULL, \ + error = NULL, requested_at = now() \ + WHERE id = $1 AND status IN ('pending', 'running')", + ) + .bind(id) + .bind(&model) + .bind(&fallback) + .bind(&cache_key) + .bind(&prompt_version) + .execute(&state.db) + .await? + .rows_affected() + }; + restarted += done; + } + if restarted > 0 { + sqlx::query("SELECT pg_notify('analyses', '')").execute(&state.db).await?; + } + tracing::info!(admin = %admin.id(), restarted, "generations restarted"); + Ok(Json(json!({ "restarted": restarted, "jobs": views(&state).await? }))) +} diff --git a/services/backend/src/routes/mod.rs b/services/backend/src/routes/mod.rs index 039e412..4661d4e 100644 --- a/services/backend/src/routes/mod.rs +++ b/services/backend/src/routes/mod.rs @@ -10,8 +10,10 @@ mod admin; mod analyses; mod auth; mod charts; +mod errors; mod forecasts; mod invitations; +mod jobs; mod models; mod payments; mod prompts; @@ -116,6 +118,9 @@ pub fn router(state: Arc) -> Router { .route("/v1/admin/prompts/{kind}/{language}", axum::routing::put(prompts::save)) .route("/v1/admin/prompts/{kind}/{language}/preview", post(prompts::start_preview)) .route("/v1/admin/previews/{id}", get(prompts::get_preview)) + .route("/v1/admin/errors", get(errors::list)) + .route("/v1/admin/jobs", get(jobs::list)) + .route("/v1/admin/jobs/restart", post(jobs::restart)) .route("/v1/admin/models", get(models::list)) .route("/v1/admin/models/catalog", get(models::catalog)) .route("/v1/admin/models/{kind}", axum::routing::put(models::save)) diff --git a/services/backend/src/routes/questions.rs b/services/backend/src/routes/questions.rs index afa4147..b0be2a8 100644 --- a/services/backend/src/routes/questions.rs +++ b/services/backend/src/routes/questions.rs @@ -1,5 +1,6 @@ -//! Questions about a finished detailed analysis: a natal chart analysis or a -//! yearly forecast. Each question uses a `question` unit (admins ask for +//! Questions about a finished detailed analysis: a natal chart analysis, a +//! relationship (synastry) analysis or a yearly forecast. On a comparison both +//! people see the questions and answers. Each question uses a `question` unit (admins ask for //! free). The worker answers with the question model of the admin page, //! seeing the chart data, the analysis and the earlier questions about it. @@ -23,7 +24,7 @@ use crate::error::{ApiError, ApiResult}; use crate::views::{rfc3339, rfc3339_opt}; /// The analyses that can be asked about. -const ASKABLE: [&str; 2] = ["natal", "forecast"]; +const ASKABLE: [&str; 3] = ["natal", "synastry", "forecast"]; /// A safety cap per analysis. const MAX_PER_ANALYSIS: i64 = 100; @@ -39,10 +40,13 @@ pub struct QuestionRow { pub credits_charged: i32, pub created_at: OffsetDateTime, pub completed_at: Option, + pub attempts: i32, + pub next_attempt_at: OffsetDateTime, + pub requested_at: OffsetDateTime, } -const QUESTION_COLUMNS: &str = - "id, analysis_id, question, status, answer, error, credits_charged, created_at, completed_at"; +const QUESTION_COLUMNS: &str = "id, analysis_id, question, status, answer, error, credits_charged, created_at, \ + completed_at, attempts, next_attempt_at, requested_at"; impl QuestionRow { pub fn view(&self) -> Value { @@ -56,6 +60,9 @@ impl QuestionRow { "credits_charged": self.credits_charged, "created_at": rfc3339(self.created_at), "completed_at": rfc3339_opt(self.completed_at), + "attempts": self.attempts, + "next_attempt_at": rfc3339(self.next_attempt_at), + "requested_at": rfc3339(self.requested_at), }) } } @@ -66,7 +73,7 @@ async fn find_question(db: &PgPool, id: Uuid) -> Result, sql /// The question model (and its fallback) and the version of the question /// prompt in force. -async fn model_and_version( +pub(super) async fn model_and_version( state: &crate::AppState, language: &str, ) -> Result<(String, Option, String), sqlx::Error> { @@ -109,7 +116,7 @@ pub async fn ask( return Err(ApiError::NotFound("analysis")); } if !ASKABLE.contains(&analysis.kind.as_str()) { - return Err(ApiError::BadRequest("questions can be asked about a natal analysis or a forecast".into())); + return Err(ApiError::BadRequest("questions can be asked about a detailed analysis or a forecast".into())); } if analysis.status != "done" { return Err(ApiError::conflict("analysis_not_ready", "Az elemzés még nem készült el.")); @@ -191,7 +198,8 @@ pub async fn regenerate( let row: QuestionRow = sqlx::query_as(&format!( "UPDATE questions SET status = 'pending', answer = NULL, error = NULL, model_used = NULL, input_tokens = NULL, \ output_tokens = NULL, cost_usd = NULL, attempts = 0, next_attempt_at = now(), started_at = NULL, \ - completed_at = NULL, model = $2, prompt_version = $3, fallback_model = $4, on_fallback = false \ + completed_at = NULL, model = $2, prompt_version = $3, fallback_model = $4, on_fallback = false, \ + requested_at = now() \ WHERE id = $1 AND status IN ('done', 'failed') RETURNING {QUESTION_COLUMNS}" )) .bind(id) diff --git a/services/backend/src/tests.rs b/services/backend/src/tests.rs index 20df951..983ec3f 100644 --- a/services/backend/src/tests.rs +++ b/services/backend/src/tests.rs @@ -761,6 +761,18 @@ async fn synastry_analyses_use_synastry_units(pool: PgPool) { app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 1, "synastry": 0, "forecast": 0, "question": 0}) ); + + // questions can be asked about the relationship analysis too + let analysis = r.body["id"].as_str().unwrap().to_string(); + sqlx::query("UPDATE analyses SET status = 'done', content = '{\"title\": \"Kettőtök\"}' WHERE kind = 'synastry'") + .execute(&app.pool) + .await + .unwrap(); + grant_units(&app, &anna, "question", 1).await; + let r = app + .post(&format!("/v1/analyses/{analysis}/questions"), Some(&anna), json!({"question": "Mire figyeljünk?"})) + .await; + assert_eq!((r.status, r.body["status"].as_str()), (StatusCode::ACCEPTED, Some("pending")), "{}", r.body); } #[sqlx::test(migrator = "db::MIGRATOR")] @@ -1639,3 +1651,100 @@ async fn questions_about_an_analysis_use_question_units(pool: PgPool) { ); assert_eq!(left().await, json!(5), "regenerating charges nobody"); } + +#[sqlx::test(migrator = "db::MIGRATOR")] +async fn admins_restart_open_generations_with_the_current_models(pool: PgPool) { + let app = TestApp::new(pool.clone()).await; + let admin = app.register("admin@example.com", "Admin").await; + let anna = app.register("anna@example.com", "Anna").await; + assert_eq!(app.get("/v1/admin/jobs", Some(&anna)).await.status, StatusCode::FORBIDDEN); + let put = |model: &str| { + let (app, admin, body) = (&app, &admin, json!({ "model": model })); + async move { app.call("PUT", "/v1/admin/models/analysis", Some(admin), Some(body)).await } + }; + assert_eq!(put("openai/gpt-x").await.status, StatusCode::OK); + let chart = app.chart(&admin, "Saját", true, "1990-03-15").await; + let chart_id = chart["id"].as_str().unwrap(); + let r = app.post(&format!("/v1/charts/{chart_id}/analyses"), Some(&admin), json!({})).await; + let id = r.body["id"].as_str().unwrap().to_string(); + // the worker is writing it with the chosen model + sqlx::query("UPDATE analyses SET status = 'running', started_at = now(), attempts = 1 WHERE id = $1::uuid") + .bind(&id) + .execute(&pool) + .await + .unwrap(); + + // after switching back to the default, the list shows what a restart would use + assert_eq!( + app.call("PUT", "/v1/admin/models/analysis", Some(&admin), Some(json!({"model": null}))).await.status, + StatusCode::OK + ); + let jobs = app.get("/v1/admin/jobs", Some(&admin)).await.body["jobs"].clone(); + let job = jobs.as_array().unwrap().iter().find(|j| j["id"] == json!(id)).expect("the analysis is listed"); + assert_eq!( + (&job["status"], &job["model"], &job["next_model"]), + (&json!("running"), &json!("openai/gpt-x"), &json!("anthropic/claude-test")) + ); + + let r = app.post("/v1/admin/jobs/restart", Some(&admin), json!({ "ids": [id] })).await; + assert_eq!((r.status, &r.body["restarted"]), (StatusCode::OK, &json!(1)), "{}", r.body); + let (status, model, fallback, started, attempts): ( + String, + String, + Option, + Option, + i32, + ) = sqlx::query_as("SELECT status, model, fallback_model, started_at, attempts FROM analyses WHERE id = $1::uuid") + .bind(&id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!( + (status.as_str(), model.as_str(), fallback, started, attempts), + ("pending", "anthropic/claude-test", None, None, 0) + ); + // finished ones are left alone + sqlx::query("UPDATE analyses SET status = 'done', content = '{}'").execute(&pool).await.unwrap(); + assert_eq!(app.post("/v1/admin/jobs/restart", Some(&admin), json!({})).await.body["restarted"], 0); +} + +#[sqlx::test(migrator = "db::MIGRATOR")] +async fn admins_read_the_error_log(pool: PgPool) { + let app = TestApp::new(pool.clone()).await; + let admin = app.register("admin@example.com", "Admin").await; + let anna = app.register("anna@example.com", "Anna").await; + let chart = app.chart(&anna, "Saját", true, "1990-03-15").await; + let chart_id = chart["id"].as_str().unwrap(); + let analysis: uuid::Uuid = sqlx::query_scalar("SELECT id FROM analyses WHERE chart_id = $1::uuid") + .bind(chart_id) + .fetch_one(&pool) + .await + .unwrap(); + for (attempt, outcome) in [(1, "retry"), (2, "failed")] { + sqlx::query( + "INSERT INTO generation_errors (source, item_id, kind, model, attempt, outcome, error, seconds) \ + VALUES ('analysis', $1, 'summary', 'cheap/model', $2, $3, 'answer cut off at the token limit', 301)", + ) + .bind(analysis) + .bind(attempt) + .bind(outcome) + .execute(&pool) + .await + .unwrap(); + } + assert_eq!(app.get("/v1/admin/errors", Some(&anna)).await.status, StatusCode::FORBIDDEN); + let r = app.get("/v1/admin/errors", Some(&admin)).await; + assert_eq!((r.status, &r.body["total"], &r.body["last_day"]), (StatusCode::OK, &json!(2), &json!(2)), "{}", r.body); + let first = &r.body["errors"][0]; + assert_eq!( + (&first["outcome"], &first["attempt"], &first["user"], &first["seconds"]), + (&json!("failed"), &json!(2), &json!("anna@example.com"), &json!(301)) + ); + let r = app.get("/v1/admin/errors?outcome=retry", Some(&admin)).await; + assert_eq!(r.body["errors"].as_array().unwrap().len(), 1); + assert_eq!(app.get("/v1/admin/errors?source=question", Some(&admin)).await.body["total"], 0); + // users see the attempts of their analysis (the page says it is tried again) + let r = app.get(&format!("/v1/analyses/{analysis}"), Some(&anna)).await; + assert_eq!(r.body["attempts"], 0); + assert!(r.body["next_attempt_at"].is_string()); +} diff --git a/services/frontend/src/app/admin/hibak/ErrorLog.tsx b/services/frontend/src/app/admin/hibak/ErrorLog.tsx new file mode 100644 index 0000000..d3060f6 --- /dev/null +++ b/services/frontend/src/app/admin/hibak/ErrorLog.tsx @@ -0,0 +1,155 @@ +"use client"; + +import { useCallback, useEffect, useState } from "react"; + +import { api, errorText } from "@/lib/api"; +import { formatDate } from "@/lib/astro"; +import type { GenerationError } from "@/lib/types"; + +const PAGE = 100; + +const SOURCES: Record = { analysis: "Elemzés", question: "Kérdés-válasz", preview: "Prompt-próba" }; +const KINDS: Record = { + summary: "összefoglaló", + natal: "képletelemzés", + synastry: "kapcsolati", + forecast: "előrejelzés", + question: "válasz", +}; +const OUTCOMES: Record = { + retry: { label: "újrapróbálva", tone: "neutral" }, + fallback: { label: "tartalék modell vette át", tone: "neutral" }, + failed: { label: "végleg sikertelen", tone: "tense" }, +}; + +interface Page { + errors: GenerationError[]; + total: number; + last_day: number; +} + +/** The admin error log with filters and paging. */ +export function ErrorLog() { + const [source, setSource] = useState(""); + const [outcome, setOutcome] = useState(""); + const [errors, setErrors] = useState(null); + const [total, setTotal] = useState(0); + const [lastDay, setLastDay] = useState(0); + const [busy, setBusy] = useState(false); + const [error, setError] = useState(null); + + const load = useCallback( + async (offset: number) => { + setBusy(true); + setError(null); + const params = new URLSearchParams({ limit: String(PAGE), offset: String(offset) }); + if (source) params.set("source", source); + if (outcome) params.set("outcome", outcome); + try { + const page = await api(`/admin/errors?${params}`); + setErrors((all) => (offset === 0 ? page.errors : [...(all ?? []), ...page.errors])); + setTotal(page.total); + setLastDay(page.last_day); + } catch (e) { + setError(errorText(e)); + } finally { + setBusy(false); + } + }, + [source, outcome], + ); + + useEffect(() => { + load(0); + }, [load]); + + return ( +
+
+
+ + +
+
+ + +
+

+ {total} bejegyzés, ebből {lastDay} az elmúlt 24 órában +

+ +
+ {error && ( +

+ {error} +

+ )} + {errors === null ? ( +

Betöltés…

+ ) : errors.length === 0 ? ( +

Nincs hiba. 🎉

+ ) : ( +
+ + + + + + + + + + + + + {errors.map((e) => ( + + + + + + + + + ))} + +
IdőpontMiModellKísérletKövetkezményHiba
{formatDate(e.created_at, true)} + {SOURCES[e.source] ?? e.source} + {e.source !== "question" && ` (${KINDS[e.kind] ?? e.kind})`} + {e.user && {e.user}} + + {e.item_id.slice(0, 8)} + + + {e.model} + + {e.attempt}.{e.seconds !== null && {e.seconds} mp} + + {OUTCOMES[e.outcome].label} + {e.error}
+
+ )} + {errors && errors.length < total && ( + + )} +
+ ); +} diff --git a/services/frontend/src/app/admin/hibak/page.tsx b/services/frontend/src/app/admin/hibak/page.tsx new file mode 100644 index 0000000..021fae9 --- /dev/null +++ b/services/frontend/src/app/admin/hibak/page.tsx @@ -0,0 +1,27 @@ +import type { Metadata } from "next"; +import { notFound } from "next/navigation"; + +import { AdminNav } from "@/components/AdminNav"; +import { requireMe } from "@/lib/server"; + +import { ErrorLog } from "./ErrorLog"; + +export const metadata: Metadata = { title: "Hibanapló" }; + +export default async function AdminErrorsPage() { + const me = await requireMe("/admin/hibak"); + if (!me.user.roles.includes("admin")) notFound(); + return ( +
+ +
+

Hibanapló

+

+ Az elemzések, válaszok és prompt-próbák minden sikertelen próbálkozása, a legújabb elöl. A worker írja; 90 napig + őrizzük. +

+
+ +
+ ); +} diff --git a/services/frontend/src/app/admin/modellek/AdminModels.tsx b/services/frontend/src/app/admin/modellek/AdminModels.tsx index 84c5748..f3e8973 100644 --- a/services/frontend/src/app/admin/modellek/AdminModels.tsx +++ b/services/frontend/src/app/admin/modellek/AdminModels.tsx @@ -6,6 +6,8 @@ import { api, errorText } from "@/lib/api"; import { formatDate } from "@/lib/astro"; import type { CatalogModel, ModelFunction } from "@/lib/types"; +import { RunningJobs } from "./RunningJobs"; + const LABELS: Record = { summary: { title: "Tömör összefoglaló", about: "Ingyenes, minden új képlethez magától elkészül. Olcsó, gyors modell elég." }, analysis: { @@ -66,6 +68,7 @@ export function AdminModels() { {functions.map((f) => ( ))} + ); } diff --git a/services/frontend/src/app/admin/modellek/RunningJobs.tsx b/services/frontend/src/app/admin/modellek/RunningJobs.tsx new file mode 100644 index 0000000..11c4a35 --- /dev/null +++ b/services/frontend/src/app/admin/modellek/RunningJobs.tsx @@ -0,0 +1,138 @@ +"use client"; + +import { useCallback, useEffect, useState } from "react"; + +import { api, errorText } from "@/lib/api"; +import type { AdminJob } from "@/lib/types"; + +const KINDS: Record = { + summary: "Összefoglaló", + natal: "Képletelemzés", + synastry: "Kapcsolati elemzés", + forecast: "Éves előrejelzés", + question: "Kérdés-válasz", +}; + +const REFRESH_MS = 10_000; + +function since(iso: string): string { + const minutes = Math.max(0, Math.round((Date.now() - new Date(iso).getTime()) / 60_000)); + return minutes < 1 ? "most" : `${minutes} perce`; +} + +/** + * Analyses and answers being written or waiting. A restart starts them again + * with the models set now; an attempt still running is dropped by the worker. + */ +export function RunningJobs() { + const [jobs, setJobs] = useState(null); + const [busy, setBusy] = useState(false); + const [asking, setAsking] = useState(false); + const [message, setMessage] = useState(null); + const [error, setError] = useState(null); + + const load = useCallback(() => { + api<{ jobs: AdminJob[] }>("/admin/jobs") + .then((d) => setJobs(d.jobs)) + .catch((e) => setError(errorText(e))); + }, []); + + useEffect(() => { + load(); + const timer = setInterval(load, REFRESH_MS); + return () => clearInterval(timer); + }, [load]); + + async function restart(ids?: string[]) { + setBusy(true); + setError(null); + setMessage(null); + try { + const r = await api<{ restarted: number; jobs: AdminJob[] }>("/admin/jobs/restart", { body: ids ? { ids } : {} }); + setJobs(r.jobs); + setMessage(r.restarted > 0 ? `${r.restarted} generálás újraindítva.` : "Nem volt mit újraindítani."); + setAsking(false); + } catch (e) { + setError(errorText(e)); + } finally { + setBusy(false); + } + } + + const changed = (jobs ?? []).filter((j) => j.model !== j.next_model).length; + return ( +
+
+
+

Futó generálások

+

+ Az éppen készülő és a sorban álló elemzések és válaszok. Újraindításkor mindegyik azzal a modellel indul újra, + ami most be van állítva; a még futó régi kérést a worker eldobja. Senkitől nem von le újabb egységet. +

+
+ {jobs && jobs.length > 0 && ( +
+ {asking ? ( + <> + + {jobs.length} generálás indul újra{changed > 0 ? `, ebből ${changed} másik modellel` : ""}. + + + + + ) : ( + + )} +
+ )} +
+ {message && ( +

+ {message} +

+ )} + {error && ( +

+ {error} +

+ )} + {jobs === null ? ( +

Betöltés…

+ ) : jobs.length === 0 ? ( +

Most semmi nem készül és semmi nem vár a sorban.

+ ) : ( +
    + {jobs.map((j) => ( +
  • + + {KINDS[j.kind]} + + {j.status === "running" && j.started_at + ? `fut, ${since(j.started_at)} indult` + : `vár (kérve ${since(j.created_at)})`} + {j.attempts > 0 ? ` · ${j.attempts}. kísérlet` : ""} + {j.on_fallback ? " · tartalék modellel" : ""} + + {j.error && utolsó hiba: {j.error}} + + + {j.model} + {j.model !== j.next_model ? → {j.next_model} : újraindítva is ez} + + +
  • + ))} +
+ )} +
+ ); +} diff --git a/services/frontend/src/app/admin/promptok/AdminPrompts.tsx b/services/frontend/src/app/admin/promptok/AdminPrompts.tsx index 96785bc..fda2371 100644 --- a/services/frontend/src/app/admin/promptok/AdminPrompts.tsx +++ b/services/frontend/src/app/admin/promptok/AdminPrompts.tsx @@ -40,7 +40,7 @@ const KINDS: { kind: PromptKind; id: string; label: string; about: string }[] = id: "kerdesek", label: "Kérdés-válasz", about: - "A kész képletelemzésre vagy előrejelzésre feltett kérdések válasza (legfeljebb 250 szó). A modell kapja a képlet adatait, az elemzést és a korábbi kérdéseket; a Modellek oldalon beállított kérdés-válasz modell válaszol.", + "A kész képletelemzésre, kapcsolati elemzésre vagy előrejelzésre feltett kérdések válasza (legfeljebb 250 szó). A modell kapja a képlet adatait, az elemzést és a korábbi kérdéseket; a Modellek oldalon beállított kérdés-válasz modell válaszol.", }, ]; diff --git a/services/frontend/src/app/csomagok/page.tsx b/services/frontend/src/app/csomagok/page.tsx index 4269fe9..37b66e1 100644 --- a/services/frontend/src/app/csomagok/page.tsx +++ b/services/frontend/src/app/csomagok/page.tsx @@ -22,7 +22,7 @@ const FAQ: [string, string][] = [ ], [ "Mit jelent a kérdés?", - "A kész részletes képletelemzésed vagy éves előrejelzésed alatt kérdezhetsz róla, például hogy mit jelent egy fényszög a munkádra nézve, vagy mire figyelj egy időszakban. A válasz a képleted és az elemzés alapján készül, legfeljebb 250 szóban. Minden csomagban 3 kérdés van, és külön is vehetsz még.", + "A kész képletelemzésed, kapcsolati elemzésed vagy éves előrejelzésed alatt kérdezhetsz róla, például hogy mit jelent egy fényszög a munkádra nézve, mire figyeljetek egy kapcsolatban, vagy mire figyelj egy időszakban. A válasz a képleted és az elemzés alapján készül, legfeljebb 250 szóban. Minden csomagban 3 kérdés van, és külön is vehetsz még.", ], [ "Mire kell a személyhely?", diff --git a/services/frontend/src/app/globals.css b/services/frontend/src/app/globals.css index 4d94d75..ccd3e72 100644 --- a/services/frontend/src/app/globals.css +++ b/services/frontend/src/app/globals.css @@ -644,3 +644,16 @@ a.pair-row:hover strong { color: var(--gold); } .qa-form { display: flex; flex-direction: column; gap: 8px; } .qa-form textarea { resize: vertical; min-height: 84px; } .hint.warn { color: var(--gold); } +.job-row { display: grid; grid-template-columns: minmax(0, 1fr) auto auto; gap: 12px; align-items: center; padding: 8px 12px; border: 1px solid var(--line); border-radius: 8px; } +.job-row > span:first-child { display: flex; flex-direction: column; min-width: 0; } +@media (max-width: 640px) { .job-row { grid-template-columns: minmax(0, 1fr) auto; } .job-row .model-price { grid-column: 1 / -1; align-items: flex-start; } } +.retry-notice { display: flex; flex-direction: column; gap: 4px; } +.retry-notice p { margin: 0; } + +/* admin: error log */ +.error-log { width: 100%; border-collapse: collapse; font-size: 14px; } +.error-log th, .error-log td { text-align: left; vertical-align: top; padding: 8px 10px; border-bottom: 1px solid var(--line); } +.error-log td > .hint, .error-log td > code { display: block; } +.error-log .error-text { overflow-wrap: anywhere; max-width: 460px; } +.error-log .outcome { white-space: nowrap; } +.error-log .outcome.tone-tense { color: var(--tense); font-weight: 600; } diff --git a/services/frontend/src/app/osszevetesek/[id]/page.tsx b/services/frontend/src/app/osszevetesek/[id]/page.tsx index 5b70446..379244e 100644 --- a/services/frontend/src/app/osszevetesek/[id]/page.tsx +++ b/services/frontend/src/app/osszevetesek/[id]/page.tsx @@ -129,6 +129,7 @@ export default async function ComparisonPage({ params }: { params: Promise<{ id: isAdmin={me.user.roles.includes("admin")} canPay={config?.mock_payments ?? false} note={`Az elemzésben az első fél: ${name1}, a második fél: ${name2}.`} + questionsLeft={me.analyses_left.question ?? 0} /> ), }, diff --git a/services/frontend/src/components/AdminNav.tsx b/services/frontend/src/components/AdminNav.tsx index d87aa0c..7d646fd 100644 --- a/services/frontend/src/components/AdminNav.tsx +++ b/services/frontend/src/components/AdminNav.tsx @@ -5,6 +5,7 @@ const PAGES = [ { href: "/admin/meghivok", label: "Meghívók" }, { href: "/admin/promptok", label: "Promptok" }, { href: "/admin/modellek", label: "Modellek" }, + { href: "/admin/hibak", label: "Hibanapló" }, ]; /** Switches between the admin pages. */ diff --git a/services/frontend/src/components/AnalysisLoading.tsx b/services/frontend/src/components/AnalysisLoading.tsx index 6e97a39..427e656 100644 --- a/services/frontend/src/components/AnalysisLoading.tsx +++ b/services/frontend/src/components/AnalysisLoading.tsx @@ -4,13 +4,31 @@ import { useEffect, useState } from "react"; import { ZodiacWheel } from "./ZodiacWheel"; -/** Slowly turning wheel with the elapsed time, while the LLM writes. */ -export function AnalysisLoading({ title, text, compact = false }: { title?: string; text: string; compact?: boolean }) { - const [seconds, setSeconds] = useState(0); +/** + * Slowly turning wheel with the elapsed time, while the LLM writes. The time + * counts from `since` (when the text was asked for), so it does not start + * again from zero after a reload; without it, from when the wheel appeared. + */ +export function AnalysisLoading({ + title, + text, + compact = false, + since, +}: { + title?: string; + text: string; + compact?: boolean; + since?: string; +}) { + const [start] = useState(() => { + const t = since ? Date.parse(since) : NaN; + return Number.isNaN(t) ? Date.now() : Math.min(t, Date.now()); + }); + const [seconds, setSeconds] = useState(() => Math.floor((Date.now() - start) / 1000)); useEffect(() => { - const t = setInterval(() => setSeconds((s) => s + 1), 1000); + const t = setInterval(() => setSeconds(Math.floor((Date.now() - start) / 1000)), 1000); return () => clearInterval(t); - }, []); + }, [start]); const elapsed = `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`; return ( @@ -21,7 +39,7 @@ export function AnalysisLoading({ title, text, compact = false }: { title?: stri

{text}

- diff --git a/services/frontend/src/components/AnalysisQuestions.tsx b/services/frontend/src/components/AnalysisQuestions.tsx index 0db7bd6..917be9c 100644 --- a/services/frontend/src/components/AnalysisQuestions.tsx +++ b/services/frontend/src/components/AnalysisQuestions.tsx @@ -8,9 +8,28 @@ import type { Question, UnitBalance } from "@/lib/types"; import { AnalysisLoading } from "./AnalysisLoading"; import { PackageChooser } from "./PackageCards"; import { RegenerateButton } from "./RegenerateButton"; +import { RetryNotice } from "./RetryNotice"; import { Paragraphs } from "./Rich"; const MAX_CHARS = 600; + +const TEXTS = { + natal: { + title: "Kérdezz az elemzésedről", + hint: "Mit jelent ez a te életedben, hogyan kapcsolódik két rész egymáshoz? A válasz a képleted és az elemzés alapján készül, legfeljebb 250 szóban.", + example: "Pl. Hogyan hat a Hold helyzete a kapcsolataimra?", + }, + synastry: { + title: "Kérdezz a kapcsolatotokról", + hint: "Hol erősítitek egymást, mire figyeljetek egy vitában, mit ad nektek a kapcsolat? A válasz a két képlet és az elemzés alapján készül, legfeljebb 250 szóban. A kérdéseket és a válaszokat mindketten látjátok.", + example: "Pl. Hogyan kezeljük jobban a nézeteltéréseinket?", + }, + forecast: { + title: "Kérdezz az előrejelzésedről", + hint: "Mire figyelj egy időszakban, mit hozhat egy tranzit a munkádban vagy a kapcsolataidban? A válasz az év adatai és az előrejelzés alapján készül, legfeljebb 250 szóban.", + example: "Pl. Mire figyeljek a nyári időszakban a munkámban?", + }, +}; const POLL_MS = 3000; const MAX_POLLS = 80; // 4 minutes @@ -24,13 +43,14 @@ export function AnalysisQuestions({ left: initialLeft, isAdmin, canPay, - forecast = false, + about, }: { analysisId: string; left: number; isAdmin: boolean; canPay: boolean; - forecast?: boolean; + /** What the analysis is about: the heading and the example question follow it. */ + about: "natal" | "synastry" | "forecast"; }) { const [questions, setQuestions] = useState(null); const [left, setLeft] = useState(initialLeft); @@ -114,11 +134,8 @@ export function AnalysisQuestions({ const canAsk = isAdmin || left > 0; return (
-

Kérdezz {forecast ? "az előrejelzésedről" : "az elemzésedről"}

-

- Mit jelent ez a te életedben, mire figyelj egy időszakban, hogyan kapcsolódik két rész egymáshoz? A válasz a képleted - és az elemzés alapján készül, legfeljebb 250 szóban. -

+

{TEXTS[about].title}

+

{TEXTS[about].hint}

{questions?.map((q) => (
@@ -139,12 +156,21 @@ export function AnalysisQuestions({ url={`/admin/questions/${q.id}/regenerate`} onStarted={replace} /> )}

- Erre most nem sikerült válaszolni{q.credits_charged > 0 ? ", a kérdést visszaadtuk" : ""}. Kérdezz újra - egy kicsit később. + Erre többszöri próbálkozás után sem sikerült válaszolni + {q.credits_charged > 0 ? ". A kérdést visszaadtuk, így ingyen újra felteheted" : ""}. Kérdezz újra egy + kicsit később.

+ {isAdmin && q.error &&

Hiba: {q.error}

} ) : ( - + <> + + + )}
))} @@ -160,9 +186,7 @@ export function AnalysisQuestions({ rows={3} maxLength={MAX_CHARS} value={text} - placeholder={ - forecast ? "Pl. Mire figyeljek a nyári időszakban a munkámban?" : "Pl. Hogyan hat a Hold helyzete a kapcsolataimra?" - } + placeholder={TEXTS[about].example} onChange={(e) => setText(e.target.value)} disabled={busy || waiting} /> diff --git a/services/frontend/src/components/ChartSummary.tsx b/services/frontend/src/components/ChartSummary.tsx index 55d46e3..4ef1d37 100644 --- a/services/frontend/src/components/ChartSummary.tsx +++ b/services/frontend/src/components/ChartSummary.tsx @@ -7,6 +7,7 @@ import type { Analysis } from "@/lib/types"; import { AnalysisLoading } from "./AnalysisLoading"; import { RegenerateButton } from "./RegenerateButton"; +import { RetryNotice } from "./RetryNotice"; import { Rich } from "./Rich"; import { openTab } from "./Tabs"; @@ -102,7 +103,21 @@ export function ChartSummary({ Az összefoglaló most nem készült el. Töltsd újra az oldalt egy kicsit később.

) : ( - + <> + + {summary && ( + + )} + )} )} diff --git a/services/frontend/src/components/DetailedAnalysis.tsx b/services/frontend/src/components/DetailedAnalysis.tsx index c1f5535..716f007 100644 --- a/services/frontend/src/components/DetailedAnalysis.tsx +++ b/services/frontend/src/components/DetailedAnalysis.tsx @@ -11,6 +11,7 @@ import { AnalysisLoading } from "./AnalysisLoading"; import { AnalysisQuestions } from "./AnalysisQuestions"; import { PackageChooser } from "./PackageCards"; import { RegenerateButton } from "./RegenerateButton"; +import { RetryNotice } from "./RetryNotice"; import { AnalysisView } from "./AnalysisView"; const POLL_MS = 5000; @@ -99,7 +100,7 @@ export function DetailedAnalysis({ canPay: boolean; /** Shown above a finished analysis (e.g. who is the first and the second person). */ note?: string; - /** Questions left; given where questions can be asked (natal analysis, forecast). */ + /** Questions left; given where questions can be asked. */ questionsLeft?: number; }) { const [analysis, setAnalysis] = useState(initial); @@ -155,13 +156,13 @@ export function DetailedAnalysis({ )} {note &&

{note}

} - {questionsLeft !== undefined && target.kind !== "synastry" && ( + {questionsLeft !== undefined && ( )}
@@ -172,7 +173,15 @@ export function DetailedAnalysis({ return (
{t.eyebrow} - + + {analysis && ( + + )}
); } @@ -186,9 +195,15 @@ export function DetailedAnalysis({

{t.about}

{AI_SHORT}

{analysis?.status === "failed" && ( -

- Az előző kérés nem sikerült{isAdmin ? "" : ", az elemzést visszaadtuk a keretedbe"}. Próbáld újra. -

+
+

+ Az elemzés többszöri próbálkozás után sem készült el. + {isAdmin || analysis.credits_charged === 0 + ? " Próbáld újra." + : " A felhasznált egységet visszaadtuk, így ingyen újra kérheted."} +

+ {isAdmin && analysis.error &&

Hiba: {analysis.error}

} +
)} {error && (

diff --git a/services/frontend/src/components/RetryNotice.tsx b/services/frontend/src/components/RetryNotice.tsx new file mode 100644 index 0000000..2298544 --- /dev/null +++ b/services/frontend/src/components/RetryNotice.tsx @@ -0,0 +1,28 @@ +/** + * Shown while a text is being written again after a failed attempt: it is + * retried on its own, nothing to do. Admins also see the error. + */ +export function RetryNotice({ + status, + error, + nextAttemptAt, + isAdmin = false, +}: { + status: string; + error?: string | null; + nextAttemptAt?: string; + isAdmin?: boolean; +}) { + if (!error || (status !== "pending" && status !== "running")) return null; + const wait = nextAttemptAt ? Math.round((Date.parse(nextAttemptAt) - Date.now()) / 60_000) : 0; + return ( +

+

+ Az előző próbálkozás nem sikerült, ezért automatikusan újrapróbáljuk. Nem kell újra kérned, és nem kerül + többe. + {status === "pending" && wait >= 1 ? ` A következő próbálkozás kb. ${wait} perc múlva indul.` : ""} +

+ {isAdmin &&

Hiba: {error}

} +
+ ); +} diff --git a/services/frontend/src/lib/types.ts b/services/frontend/src/lib/types.ts index 3fddfa3..c775533 100644 --- a/services/frontend/src/lib/types.ts +++ b/services/frontend/src/lib/types.ts @@ -77,6 +77,9 @@ export interface Question { credits_charged: number; created_at: string; completed_at: string | null; + attempts?: number; + next_attempt_at?: string; + requested_at?: string; } export interface PublicConfig { @@ -232,6 +235,26 @@ export interface Analysis { credits_charged: number; created_at: string; completed_at: string | null; + /** Attempts so far, and when the next one starts (while it is retried). */ + attempts?: number; + next_attempt_at?: string; + /** When the current text was asked for: the waiting page counts from here. */ + requested_at?: string; +} + +/** Admin: one failed attempt in the error log. */ +export interface GenerationError { + id: number; + created_at: string; + source: "analysis" | "question" | "preview"; + item_id: string; + kind: string; + model: string; + attempt: number; + outcome: "retry" | "fallback" | "failed"; + error: string; + seconds: number | null; + user: string | null; } export interface AdminUser { @@ -266,6 +289,25 @@ export interface ModelFunction { finished_30d: number; } +/** Admin: an analysis or answer being written or waiting in the queue. */ +export interface AdminJob { + id: string; + type: "analysis" | "question"; + kind: "summary" | "natal" | "synastry" | "forecast" | "question"; + status: "pending" | "running"; + /** The model of the current attempt. */ + model: string; + on_fallback: boolean; + /** What a restart would use now. */ + next_model: string; + next_fallback: string | null; + attempts: number; + started_at: string | null; + created_at: string; + next_attempt_at: string; + error: string | null; +} + /** A model OpenRouter offers; prices in USD per million tokens. */ export interface CatalogModel { id: string; diff --git a/services/worker/src/analysis/mod.rs b/services/worker/src/analysis/mod.rs index a22bded..170e1ff 100644 --- a/services/worker/src/analysis/mod.rs +++ b/services/worker/src/analysis/mod.rs @@ -47,6 +47,9 @@ pub struct Job { /// The default model, when the chosen one is another (see the module docs). pub fallback_model: Option, pub on_fallback: bool, + /// When this attempt started; also its token: an admin restart clears it, + /// so a superseded attempt neither writes its result nor keeps running. + pub started_at: time::OffsetDateTime, } impl Job { @@ -125,7 +128,7 @@ impl Analyzer { WHERE id = (SELECT id FROM analyses WHERE status = 'pending' AND next_attempt_at <= now() \ ORDER BY next_attempt_at LIMIT 1 FOR UPDATE SKIP LOCKED) \ RETURNING id, kind, chart_id, synastry_id, forecast_id, language, model, prompt_version, attempts, \ - fallback_model, on_fallback", + fallback_model, on_fallback, started_at", ) .fetch_optional(&self.db) .await?; @@ -250,6 +253,8 @@ impl Analyzer { .await } Err(e) => { + self.log_error("preview", job.id, &job.kind, &job.model, 1, "failed", e.message(), started.elapsed()) + .await; sqlx::query( "UPDATE prompt_previews SET status = 'failed', error = $2, completed_at = now() \ WHERE id = $1 AND status = 'running'", @@ -273,12 +278,21 @@ impl Analyzer { /// Writes one claimed analysis and records the outcome. pub async fn handle(&self, job: Job) { let started = Instant::now(); - let result = match self.prompt_for(&job).await { - Ok(prompt) => self.llm.complete(job.active_model(), &prompt).await.map(|mut c| { - prompt::polish(&job.language, &mut c.content); - c - }), - Err(e) => Err(e), + let work = async { + match self.prompt_for(&job).await { + Ok(prompt) => self.llm.complete(job.active_model(), &prompt).await.map(|mut c| { + prompt::polish(&job.language, &mut c.content); + c + }), + Err(e) => Err(e), + } + }; + let result = tokio::select! { + result = work => result, + () = self.superseded("analyses", job.id, job.started_at) => { + tracing::info!(id = %job.id, "analysis restarted by an admin; this attempt is dropped"); + return; + } }; if let Err(e) = self.finish(&job, result, started.elapsed()).await { tracing::error!(id = %job.id, error = %e, "saving the analysis result failed"); @@ -292,7 +306,7 @@ impl Analyzer { sqlx::query( "UPDATE analyses SET status = 'done', content = $2, model_used = $3, input_tokens = $4, \ output_tokens = $5, cost_usd = $6, error = NULL, completed_at = now() \ - WHERE id = $1 AND status = 'running'", + WHERE id = $1 AND status = 'running' AND started_at = $7", ) .bind(job.id) .bind(&c.content) @@ -300,6 +314,7 @@ impl Analyzer { .bind(c.input_tokens) .bind(c.output_tokens) .bind(c.cost_usd) + .bind(job.started_at) .execute(&self.db) .await?; tracing::info!( @@ -309,15 +324,34 @@ impl Analyzer { } Err(e) => { let can_fall_back = !job.on_fallback && job.fallback_model.is_some(); - match next_step(&e, job.attempts, self.max_attempts, can_fall_back) { + let next = next_step(&e, job.attempts, self.max_attempts, can_fall_back); + let outcome = match next { + Next::Retry(_) => "retry", + Next::Fallback => "fallback", + Next::Fail => "failed", + }; + self.log_error( + "analysis", + job.id, + &job.kind, + job.active_model(), + job.attempts, + outcome, + e.message(), + took, + ) + .await; + match next { Next::Retry(wait) => { sqlx::query( "UPDATE analyses SET status = 'pending', error = $2, \ - next_attempt_at = now() + make_interval(secs => $3) WHERE id = $1 AND status = 'running'", + next_attempt_at = now() + make_interval(secs => $3) \ + WHERE id = $1 AND status = 'running' AND started_at = $4", ) .bind(job.id) .bind(e.message()) .bind(wait.as_secs_f64()) + .bind(job.started_at) .execute(&self.db) .await?; tracing::warn!(id = %job.id, attempts = job.attempts, retry_in_secs = wait.as_secs(), error = %e.message(), "analysis will be retried"); @@ -325,10 +359,11 @@ impl Analyzer { Next::Fallback => { sqlx::query( "UPDATE analyses SET status = 'pending', error = $2, on_fallback = true, attempts = 0, \ - next_attempt_at = now() WHERE id = $1 AND status = 'running'", + next_attempt_at = now() WHERE id = $1 AND status = 'running' AND started_at = $3", ) .bind(job.id) .bind(e.message()) + .bind(job.started_at) .execute(&self.db) .await?; tracing::warn!( @@ -337,7 +372,7 @@ impl Analyzer { ); } Next::Fail => { - self.fail(job.id, e.message()).await?; + self.fail(job.id, job.started_at, e.message()).await?; tracing::error!(id = %job.id, attempts = job.attempts, error = %e.message(), "analysis failed"); } } @@ -347,14 +382,15 @@ impl Analyzer { } /// Marks the analysis failed and gives its unit back (once). - async fn fail(&self, id: Uuid, message: &str) -> Result<(), sqlx::Error> { + async fn fail(&self, id: Uuid, started_at: time::OffsetDateTime, message: &str) -> Result<(), sqlx::Error> { let mut tx = self.db.begin().await?; let row: Option<(Option, i32, String)> = sqlx::query_as( "UPDATE analyses SET status = 'failed', error = $2, completed_at = now() \ - WHERE id = $1 AND status = 'running' RETURNING requested_by, credits_charged, kind", + WHERE id = $1 AND status = 'running' AND started_at = $3 RETURNING requested_by, credits_charged, kind", ) .bind(id) .bind(message) + .bind(started_at) .fetch_optional(&mut *tx) .await?; if let Some((Some(user), units, kind)) = row @@ -407,6 +443,53 @@ impl Analyzer { Ok(result.rows_affected()) } + /// Records a failed attempt in the admin error log (a failure here is only logged). + #[allow(clippy::too_many_arguments)] + pub(crate) async fn log_error( + &self, + source: &str, + item_id: Uuid, + kind: &str, + model: &str, + attempt: i32, + outcome: &str, + error: &str, + took: Duration, + ) { + let result = sqlx::query( + "INSERT INTO generation_errors (source, item_id, kind, model, attempt, outcome, error, seconds) \ + VALUES ($1, $2, $3, $4, $5, $6, $7, $8)", + ) + .bind(source) + .bind(item_id) + .bind(kind) + .bind(model) + .bind(attempt) + .bind(outcome) + .bind(error.chars().take(2000).collect::()) + .bind(i32::try_from(took.as_secs()).unwrap_or(i32::MAX)) + .execute(&self.db) + .await; + if let Err(e) = result { + tracing::error!(error = %e, "writing the error log"); + } + } + + /// Resolves when this attempt is no longer the current one (an admin + /// restarted it); checked every 10 seconds, never on a database error. + async fn superseded(&self, table: &str, id: Uuid, started_at: time::OffsetDateTime) { + let query = format!("SELECT status = 'running' AND started_at = $2 FROM {table} WHERE id = $1"); + loop { + tokio::time::sleep(Duration::from_secs(10)).await; + match sqlx::query_scalar::<_, Option>(&query).bind(id).bind(started_at).fetch_optional(&self.db).await + { + Ok(Some(Some(true))) => {} + Ok(_) => return, + Err(_) => {} + } + } + } + /// On shutdown: analyses still being written go back to `pending` at once. async fn release_running(&self) { let ids: Vec = self.running.lock().unwrap().drain().collect(); diff --git a/services/worker/src/analysis/questions.rs b/services/worker/src/analysis/questions.rs index ea6623c..2ea8af0 100644 --- a/services/worker/src/analysis/questions.rs +++ b/services/worker/src/analysis/questions.rs @@ -27,6 +27,8 @@ pub struct QuestionJob { pub created_at: time::OffsetDateTime, pub fallback_model: Option, pub on_fallback: bool, + /// The token of this attempt (see `Job::started_at`). + pub started_at: time::OffsetDateTime, } impl Analyzer { @@ -37,7 +39,7 @@ impl Analyzer { WHERE id = (SELECT id FROM questions WHERE status = 'pending' AND next_attempt_at <= now() \ ORDER BY next_attempt_at LIMIT 1 FOR UPDATE SKIP LOCKED) \ RETURNING id, analysis_id, question, language, model, prompt_version, attempts, created_at, \ - fallback_model, on_fallback", + fallback_model, on_fallback, started_at", ) .fetch_optional(&self.db) .await?; @@ -49,8 +51,9 @@ impl Analyzer { async fn question_prompt(&self, job: &QuestionJob) -> Result { let db_err = |e: sqlx::Error| LlmError::Transient(format!("database: {e}")); - let (kind, chart_id, forecast_id, content): (String, Option, Option, Option) = - sqlx::query_as("SELECT kind, chart_id, forecast_id, content FROM analyses WHERE id = $1") + type Row = (String, Option, Option, Option, Option); + let (kind, chart_id, synastry_id, forecast_id, content): Row = + sqlx::query_as("SELECT kind, chart_id, synastry_id, forecast_id, content FROM analyses WHERE id = $1") .bind(job.analysis_id) .fetch_optional(&self.db) .await @@ -60,6 +63,7 @@ impl Analyzer { let content = content.ok_or_else(|| LlmError::Permanent("the analysis has no text".into()))?; let chart_text = match kind { Kind::Forecast => self.forecast_text(forecast_id).await?, + Kind::Synastry => self.synastry_text(synastry_id).await?, _ => self.natal_text(chart_id).await?, }; let analysis = prompt::to_markdown(kind, &job.language, &content); @@ -91,15 +95,24 @@ impl Analyzer { /// Answers one claimed question and records the outcome. pub async fn handle_question(&self, job: QuestionJob) { let started = Instant::now(); - let result = match self.question_prompt(&job).await { - Ok(p) => { - let model = active_model(&job.model, job.fallback_model.as_deref(), job.on_fallback); - self.llm.complete(model, &p).await.map(|mut c| { - prompt::polish(&job.language, &mut c.content); - c - }) + let work = async { + match self.question_prompt(&job).await { + Ok(p) => { + let model = active_model(&job.model, job.fallback_model.as_deref(), job.on_fallback); + self.llm.complete(model, &p).await.map(|mut c| { + prompt::polish(&job.language, &mut c.content); + c + }) + } + Err(e) => Err(e), + } + }; + let result = tokio::select! { + result = work => result, + () = self.superseded("questions", job.id, job.started_at) => { + tracing::info!(id = %job.id, "answer restarted by an admin; this attempt is dropped"); + return; } - Err(e) => Err(e), }; if let Err(e) = self.finish_question(&job, result, started.elapsed()).await { tracing::error!(id = %job.id, error = %e, "saving the answer failed"); @@ -119,7 +132,7 @@ impl Analyzer { sqlx::query( "UPDATE questions SET status = 'done', answer = $2, model_used = $3, input_tokens = $4, \ output_tokens = $5, cost_usd = $6, error = NULL, completed_at = now() \ - WHERE id = $1 AND status = 'running'", + WHERE id = $1 AND status = 'running' AND started_at = $7", ) .bind(job.id) .bind(&answer) @@ -127,6 +140,7 @@ impl Analyzer { .bind(c.input_tokens) .bind(c.output_tokens) .bind(c.cost_usd) + .bind(job.started_at) .execute(&self.db) .await?; tracing::info!( @@ -136,15 +150,25 @@ impl Analyzer { } Err(e) => { let can_fall_back = !job.on_fallback && job.fallback_model.is_some(); - match next_step(&e, job.attempts, self.max_attempts, can_fall_back) { + let next = next_step(&e, job.attempts, self.max_attempts, can_fall_back); + let outcome = match next { + Next::Retry(_) => "retry", + Next::Fallback => "fallback", + Next::Fail => "failed", + }; + let model = active_model(&job.model, job.fallback_model.as_deref(), job.on_fallback); + self.log_error("question", job.id, "question", model, job.attempts, outcome, e.message(), took).await; + match next { Next::Retry(wait) => { sqlx::query( "UPDATE questions SET status = 'pending', error = $2, \ - next_attempt_at = now() + make_interval(secs => $3) WHERE id = $1 AND status = 'running'", + next_attempt_at = now() + make_interval(secs => $3) \ + WHERE id = $1 AND status = 'running' AND started_at = $4", ) .bind(job.id) .bind(e.message()) .bind(wait.as_secs_f64()) + .bind(job.started_at) .execute(&self.db) .await?; tracing::warn!(id = %job.id, attempts = job.attempts, error = %e.message(), "answer will be retried"); @@ -152,10 +176,11 @@ impl Analyzer { Next::Fallback => { sqlx::query( "UPDATE questions SET status = 'pending', error = $2, on_fallback = true, attempts = 0, \ - next_attempt_at = now() WHERE id = $1 AND status = 'running'", + next_attempt_at = now() WHERE id = $1 AND status = 'running' AND started_at = $3", ) .bind(job.id) .bind(e.message()) + .bind(job.started_at) .execute(&self.db) .await?; tracing::warn!( @@ -164,7 +189,7 @@ impl Analyzer { ); } Next::Fail => { - self.fail_question(job.id, e.message()).await?; + self.fail_question(job.id, job.started_at, e.message()).await?; tracing::error!(id = %job.id, attempts = job.attempts, error = %e.message(), "answer failed"); } } @@ -174,14 +199,20 @@ impl Analyzer { } /// Marks the question failed and gives its unit back (once). - async fn fail_question(&self, id: Uuid, message: &str) -> Result<(), sqlx::Error> { + async fn fail_question( + &self, + id: Uuid, + started_at: time::OffsetDateTime, + message: &str, + ) -> Result<(), sqlx::Error> { let mut tx = self.db.begin().await?; let row: Option<(Option, i32)> = sqlx::query_as( "UPDATE questions SET status = 'failed', error = $2, completed_at = now() \ - WHERE id = $1 AND status = 'running' RETURNING asked_by, credits_charged", + WHERE id = $1 AND status = 'running' AND started_at = $3 RETURNING asked_by, credits_charged", ) .bind(id) .bind(message) + .bind(started_at) .fetch_optional(&mut *tx) .await?; if let Some((Some(user), units)) = row diff --git a/services/worker/src/cleanup.rs b/services/worker/src/cleanup.rs index 76d4e9a..fc8e3e0 100644 --- a/services/worker/src/cleanup.rs +++ b/services/worker/src/cleanup.rs @@ -8,7 +8,7 @@ use tokio::sync::watch; const INTERVAL: Duration = Duration::from_secs(3600); /// (what, statement) pairs; each returns the number of deleted rows. -const STATEMENTS: [(&str, &str); 6] = [ +const STATEMENTS: [(&str, &str); 7] = [ ("sessions", "DELETE FROM sessions WHERE expires_at < now()"), ("auth_tokens", "DELETE FROM auth_tokens WHERE expires_at < now()"), // Sent e-mails contain links with tokens; keep them a week for support. @@ -26,6 +26,7 @@ const STATEMENTS: [(&str, &str); 6] = [ OR (accepted_at IS NOT NULL AND accepted_by IS NULL)", ), ("prompt_previews", "DELETE FROM prompt_previews WHERE created_at < now() - interval '30 days'"), + ("generation_errors", "DELETE FROM generation_errors WHERE created_at < now() - interval '90 days'"), ]; pub async fn run_once(db: &PgPool) -> Result, sqlx::Error> { diff --git a/services/worker/src/tests.rs b/services/worker/src/tests.rs index bf4c9c4..2079009 100644 --- a/services/worker/src/tests.rs +++ b/services/worker/src/tests.rs @@ -212,7 +212,8 @@ async fn cleanup_removes_only_expired_data(db: PgPool) { ("emails", 1), ("invites", 0), ("invitations", 0), - ("prompt_previews", 0) + ("prompt_previews", 0), + ("generation_errors", 0) ] ); let (left,): (Vec,) = @@ -533,6 +534,18 @@ mod analyses { let (status, attempts, ..) = row(&db, id).await; assert_eq!((status.as_str(), attempts), ("failed", 3)); assert_eq!(refunds(&db, s.user).await, vec![1]); + // every failed attempt is in the admin error log + let log: Vec<(String, i32, String, String)> = sqlx::query_as( + "SELECT source, attempt, outcome, model FROM generation_errors WHERE item_id = $1 ORDER BY id", + ) + .bind(id) + .fetch_all(&db) + .await + .unwrap(); + let expected = |attempt: i32, outcome: &str| { + ("analysis".to_string(), attempt, outcome.to_string(), "test/model".to_string()) + }; + assert_eq!(log, vec![expected(1, "retry"), expected(2, "retry"), expected(3, "failed")]); } #[sqlx::test(migrator = "db::MIGRATOR")] @@ -780,5 +793,90 @@ mod analyses { let models: Vec = fake.requests.lock().unwrap().iter().map(|b| b["model"].as_str().unwrap().to_string()).collect(); assert_eq!(models, ["cheap/model", "cheap/model", "test/model"]); + let outcomes: Vec<(String, String)> = + sqlx::query_as("SELECT outcome, model FROM generation_errors WHERE item_id = $1 ORDER BY id") + .bind(id) + .fetch_all(&db) + .await + .unwrap(); + assert_eq!( + outcomes, + [("retry".to_string(), "cheap/model".to_string()), ("fallback".to_string(), "cheap/model".to_string())] + ); + } + + #[sqlx::test(migrator = "db::MIGRATOR")] + async fn a_restarted_attempt_does_not_write_its_result(db: PgPool) { + let s = setup(&db).await; + let id = request_analysis(&db, &s).await; + let (_, url) = fake_openrouter(vec![reply(&content(Kind::Natal))]).await; + let a = analyzer(&db, &url); + let job = a.claim().await.unwrap().expect("a job"); + // an admin restarts it while the worker is still writing it + sqlx::query("UPDATE analyses SET status = 'pending', started_at = NULL, attempts = 0 WHERE id = $1") + .bind(id) + .execute(&db) + .await + .unwrap(); + a.handle(job).await; + let (status, content): (String, Option) = + sqlx::query_as("SELECT status, content FROM analyses WHERE id = $1").bind(id).fetch_one(&db).await.unwrap(); + assert_eq!((status.as_str(), content), ("pending", None)); + // the new attempt writes it + assert!(run_once(&a).await); + let status: String = + sqlx::query_scalar("SELECT status FROM analyses WHERE id = $1").bind(id).fetch_one(&db).await.unwrap(); + assert_eq!(status, "done"); + } + + #[sqlx::test(migrator = "db::MIGRATOR")] + async fn answers_a_question_about_a_relationship_with_both_charts(db: PgPool) { + let s = setup(&db).await; + let response = fixture("synastry-response.json"); + let (chart2, synastry, analysis) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7()); + sqlx::query( + "INSERT INTO charts (id, owner_id, label, is_primary, kind, birth_data, result, chart_hash) \ + VALUES ($1, $2, 'Partner', false, 'person', '{}', $3, 'hash2')", + ) + .bind(chart2) + .bind(s.user) + .bind(&response["person2"]) + .execute(&db) + .await + .unwrap(); + sqlx::query( + "INSERT INTO synastries (id, owner_id, chart1_id, chart2_id, result, synastry_hash) \ + VALUES ($1, $2, $3, $4, $5, 'sh')", + ) + .bind(synastry) + .bind(s.user) + .bind(s.chart) + .bind(chart2) + .bind(&response) + .execute(&db) + .await + .unwrap(); + sqlx::query( + "INSERT INTO analyses (id, kind, synastry_id, requested_by, language, model, prompt_version, cache_key, \ + status, content) VALUES ($1, 'synastry', $2, $3, 'hu', 'test/model', 'v1', 'k', 'done', $4)", + ) + .bind(analysis) + .bind(synastry) + .bind(s.user) + .bind(content(Kind::Synastry)) + .execute(&db) + .await + .unwrap(); + let id = ask(&db, analysis, s.user, "Mire figyeljünk egy vitában?", "pending", None).await; + let (fake, url) = fake_openrouter(vec![reply(&json!({"answer": "Arra, hogy..."}))]).await; + let a = analyzer(&db, &url); + assert!(answer_once(&a).await); + let status: String = + sqlx::query_scalar("SELECT status FROM questions WHERE id = $1").bind(id).fetch_one(&db).await.unwrap(); + assert_eq!(status, "done"); + let requests = fake.requests.lock().unwrap(); + let user = requests[0]["messages"][1]["content"].as_str().unwrap(); + assert!(user.starts_with("Képletadatok:\n\nSYNASTRY") && user.contains("Person 2"), "both charts"); + assert!(!user.contains("Szeged") && !user.contains("Pécs")); } }