Compare commits
7
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9cf386d08b | ||
|
|
6e365673b8 | ||
|
|
32673007a2 | ||
|
|
e561245d4e | ||
|
|
829fbd2eba | ||
|
|
f59eee8632 | ||
|
|
7291f5d15b |
No files matched your search
@@ -3,6 +3,9 @@
|
||||
*.sh text eol=lf
|
||||
.githooks/* text eol=lf
|
||||
Dockerfile text eol=lf
|
||||
# Windows scripts and the instructions in the release zip keep CRLF (ADR 0013).
|
||||
*.cmd text eol=crlf
|
||||
deploy/windows/*.txt text eol=crlf
|
||||
*.png binary
|
||||
*.ico binary
|
||||
*.ttf binary
|
||||
|
||||
@@ -20,6 +20,7 @@ Dalla radice del repository: `./tasks.ps1 <comando>` (Windows) o `sh ./tasks.sh
|
||||
- `hooks`: attiva `.githooks/pre-commit`, che esegue `check` prima di ogni commit. Si fa una volta per copia del repository.
|
||||
- `seed-demo`: la modalità dimostrativa con i dati dell'appendice F, in una cartella e un database a parte, solo dal computer stesso.
|
||||
- `screenshots`: fotografa Panoramica, Conti, Diario e Impostazioni a 1440 px (chiaro e scuro) e a 390 px in `artifacts/screenshots/`. Usa Edge o Chrome già installati.
|
||||
- `release-win`: lo zip di prova per Windows in `artifacts/release/` (ADR 0013), da allegare alla release `v0.N.0` su Gitea.
|
||||
- `desktop-win` (Fase 10): non ancora disponibile.
|
||||
- `docker compose up --build`: l'applicazione su http://localhost:8787 con PostgreSQL, `/health` risponde `ok`. Primo accesso con `ANUBIS_ADMIN_PASSWORD` del compose.
|
||||
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
<SatelliteResourceLanguages>it;en</SatelliteResourceLanguages>
|
||||
<Company>BalboSoft</Company>
|
||||
<Product>Anubis</Product>
|
||||
<Version>0.0.1</Version>
|
||||
<Version>0.7.0</Version>
|
||||
</PropertyGroup>
|
||||
|
||||
<!-- Only the packages of ADR 0004, with versions in Directory.Packages.props and lock files committed. -->
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
@echo off
|
||||
rem Starts Anubis on this computer (desktop platform) and opens it in the browser. ADR 0013, point 6.
|
||||
cd /d "%~dp0"
|
||||
echo Anubis si avvia su http://localhost:8787
|
||||
echo Questa finestra resta aperta mentre il bot lavora. Per fermarlo premi Ctrl+C.
|
||||
start "" /b cmd /c "timeout /t 8 /nobreak >/dev/null & start http://localhost:8787"
|
||||
"%~dp0Anubis.Server.exe" --platform desktop
|
||||
if errorlevel 1 pause
|
||||
@@ -0,0 +1,44 @@
|
||||
ANUBIS - versione di prova per Windows
|
||||
======================================
|
||||
|
||||
Che cos'è
|
||||
---------
|
||||
Il bot di trading Anubis da far girare sul tuo computer per qualche giorno.
|
||||
Lavora solo in simulazione e sui conti di prova: non può usare soldi veri.
|
||||
Raccoglie da solo i dati per l'analisi (memoria, lavori, chiamate, errori),
|
||||
così chi segue lo sviluppo può capire come si è comportato.
|
||||
|
||||
Cosa serve
|
||||
----------
|
||||
Il runtime ASP.NET Core 10 di Microsoft. Se hai già l'SDK .NET 10, c'è già.
|
||||
Altrimenti lo scarichi da https://dotnet.microsoft.com/download/dotnet/10.0
|
||||
(sezione "ASP.NET Core Runtime", versione per Windows x64).
|
||||
|
||||
Come si avvia
|
||||
-------------
|
||||
1. Estrai lo zip in una cartella qualsiasi, per esempio C:\Anubis.
|
||||
2. Fai doppio clic su "Avvia Anubis.cmd".
|
||||
Si apre una finestra nera: lasciala aperta, il bot lavora lì dentro.
|
||||
Dopo qualche secondo il browser apre http://localhost:8787.
|
||||
3. La prima volta una procedura guidata ti chiede dove tenere i dati e una
|
||||
password. I dati vanno in %APPDATA%\Anubis.
|
||||
4. Per fermarlo premi Ctrl+C nella finestra nera.
|
||||
Chiudere la finestra lo ferma di colpo: funziona, ma il diario lo segnerà
|
||||
come uno spegnimento improvviso.
|
||||
|
||||
Mentre gira
|
||||
-----------
|
||||
Usalo come vuoi. Se il computer va in sospensione, il rapporto lo vedrà come
|
||||
un silenzio: va bene, ma per una prova pulita conviene lasciarlo acceso.
|
||||
|
||||
Come mandare i dati
|
||||
-------------------
|
||||
Quando hai finito (anche con il bot ancora acceso):
|
||||
- fai doppio clic su "Prepara i dati da incollare.cmd": si apre il Blocco
|
||||
note con il rapporto. Seleziona tutto (Ctrl+A), copia (Ctrl+C) e incolla
|
||||
il testo nella chat;
|
||||
- oppure, dall'interfaccia: Diario e sistema, pulsante "Scarica i dati per
|
||||
l'analisi".
|
||||
|
||||
Il rapporto copre tutto ciò che è stato raccolto, fino a 30 giorni. Non
|
||||
contiene chiavi, password né il tuo nome utente.
|
||||
@@ -0,0 +1,10 @@
|
||||
@echo off
|
||||
rem Writes the diagnostics report (issue #95) next to this file and opens it, ready to copy. It only reads.
|
||||
cd /d "%~dp0"
|
||||
"%~dp0Anubis.Server.exe" diagnostics --platform desktop --out "%~dp0anubis-diagnostica.md" >nul
|
||||
if errorlevel 1 (
|
||||
echo Non riuscito: avvia prima Anubis almeno una volta.
|
||||
pause
|
||||
exit /b 1
|
||||
)
|
||||
start "" notepad "%~dp0anubis-diagnostica.md"
|
||||
+4
-3
@@ -199,7 +199,7 @@ Il bot che lavora da solo, in simulazione, giorno e notte, e lo racconta.
|
||||
- [x] Una prova accelerata con orologio simulato copre almeno 10 giorni di mercato con guasti iniettati e termina con registro e conti riconciliati e senza ordini duplicati (`TenDaysWithFaultsEndReconciledWithoutDuplicateOrders`: 14 giorni con rete giù, risposta persa, ripartenza con un ordine a metà e database irraggiungibile, su SQLite e PostgreSQL)
|
||||
- [x] Un test blocca il ciclo principale con una vendita a metà e verifica che dopo la guardia la posizione abbia di nuovo i suoi stop e il motore sia ripartito; la stessa prova passa dentro l'immagine Docker (`ALoopBlockedWithASaleHalfwayGetsItsStopBackAndTheEngineRestarts`, `TheGuardDrillPassesWithTheRealEngineAsChildProcess`; `docker run --rm <immagine> drill` in `tasks ci` e nella CI: 7 controlli su 7)
|
||||
- [x] Un test con orologio simulato spegne il bot per 3 ore, 20 ore e 3 giorni e verifica le righe di 5.6 i cui lavori esistono (`ThreeHoursOffRecoverTheCryptoDecisionAndDropAnEntryThatMovedTooFar`, `TwentyHoursOffLetTheLateDecisionsUpdateOnlyExitsAndDropExpiredEntries`, `ThreeDaysOffAreDeclaredUntilSeenAndMissedRunsAreMadeOnce`)
|
||||
- [x] A fine fase parte una prova di durata in tempo reale di almeno 48 ore a cavallo di due sedute USA (solo crypto senza chiavi Alpaca) — partita l'11/11/2026 alle 21:44 nel container `anubis-prova`; il rapporto si verifica in Fase 7 (#55)
|
||||
- [x] A fine fase parte una prova di durata in tempo reale di almeno 48 ore a cavallo di due sedute USA (solo crypto senza chiavi Alpaca) — partita nel container `anubis-prova`, ripartita da zero il 12/11/2026 alle 21:02 dopo uno spegnimento improvviso del PC; il rapporto si verifica in Fase 7 (#55)
|
||||
- [x] In modalità dimostrativa la Panoramica corrisponde agli screen 01 (1440 px) e 09 (390 px) (`TheDemoPanoramicaShowsAccountsPositionsAndLimits`; fotografie di `tasks screenshots`, confronto nella prova di #51)
|
||||
- [x] Il Diario corrisponde allo screen 08 a 1440 px e a 390 px non scorre in orizzontale (`TheDiaryFiltersAndSearches`; a 390 px `scrollWidth` uguale alla larghezza su `/`, `/diario` e `/diario?cerca=…`)
|
||||
- [x] I comandi Telegram funzionano (o, senza token, superano i test con un finto server) — senza token, con un finto server: `TheCommandsWorkFromThePhoneThroughTheRealServer`, `FermaWantsAConfirmationWithinTwoMinutes`, `OnlyTheChatOfTheSettingsIsObeyedAndOldMessagesAreNot` e gli altri di `TelegramTests`
|
||||
@@ -212,7 +212,8 @@ Le notizie usate per evitare guai, mai per comprare.
|
||||
|
||||
**Lavori**
|
||||
|
||||
- [ ] [#55](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/55) Verifica del rapporto della prova di durata
|
||||
- [ ] [#95](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/95) Raccolta dei dati per l'analisi e release di prova su Gitea (ADR 0013)
|
||||
- [ ] [#55](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/55) Verifica del rapporto della prova di durata: dal rapporto della release incollato dall'utente (ADR 0013)
|
||||
- [ ] [#56](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/56) Raccolta, deduplica e collegamento delle notizie agli strumenti
|
||||
- [ ] [#57](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/57) Classificatore locale ONNX e regole sulle parole chiave
|
||||
- [ ] [#58](https://gitea.encke-hake.ts.net/BalboSoft/Anubis/issues/58) Analista con modello linguistico facoltativo, sicurezza e tetto di spesa
|
||||
@@ -222,7 +223,7 @@ Le notizie usate per evitare guai, mai per comprare.
|
||||
|
||||
**Criteri di accettazione**
|
||||
|
||||
- [ ] Il rapporto della prova di durata è in `docs/` e non riporta ordini duplicati né differenze non spiegate
|
||||
- [ ] Il rapporto della prova di durata è in `docs/` e non riporta ordini duplicati né differenze non spiegate (dalla release, ADR 0013)
|
||||
- [ ] Su un archivio di notizie registrate la deduplica e il collegamento superano i test
|
||||
- [ ] Un testo con istruzioni malevole non produce alcun effetto fuori dallo schema (test dedicato)
|
||||
- [ ] Senza chiave del modello linguistico tutto funziona
|
||||
|
||||
+11
-7
@@ -1,10 +1,10 @@
|
||||
# Stato del progetto
|
||||
|
||||
Aggiornato: 2026-11-11
|
||||
Aggiornato: 2026-11-14
|
||||
|
||||
## Fase corrente
|
||||
|
||||
**Fase 6 — Motore dal vivo in simulazione: completata.** La prova di durata di 48 ore è partita a fine fase, l'11 novembre 2026 alle 21:44 (ora italiana), sull'immagine Docker di questo PC (solo crypto, senza chiavi); il suo rapporto si controlla come primo passo della Fase 7 (Notizie), da iniziare con il via dell'utente. Nessuna strategia manda ordini: `crypto_trend` non ha superato il backtest e decide solo in osservazione, le due azionarie aspettano le chiavi di Alpaca.
|
||||
**Fase 7 — Notizie: in corso.** La Fase 6 è completata. La sua prova di durata di 48 ore in casa è stata interrotta più volte dal computer, mai da Anubis, e il 14 novembre l'utente ha scelto un'altra strada (ADR 0013). Ora il bot raccoglie da solo i dati per l'analisi (issue #95). L'utente fa girare la release di prova `v0.7.0` pubblicata su Gitea per il tempo che vuole, poi incolla in chat il rapporto. Il controllo della prova (#55) si fa su quel rapporto. Nessuna strategia manda ordini: `crypto_trend` non ha superato il backtest e decide solo in osservazione, le due azionarie aspettano le chiavi di Alpaca.
|
||||
|
||||
## Fatto
|
||||
|
||||
@@ -85,6 +85,10 @@ Aggiornato: 2026-11-11
|
||||
- Telegram: coda con stato, nuovi tentativi e abbandono dopo un giorno; comandi dal telefono solo dalla chat configurata e solo se recenti, `/ferma` con `/conferma`; riepilogo del mattino, stato facoltativo, segnale di vita ogni minuto. Sezione in Impostazioni.
|
||||
- Schermate Panoramica e Diario e sistema come i mockup 01, 08 e 09.
|
||||
- `anubis soak`: il rapporto di una prova di durata, letto dai registri del bot mentre lavora.
|
||||
- **Fase 7, in corso** (ADR 0013):
|
||||
- Raccolta dei dati per l'analisi (#95). Ogni 5 minuti, e a ogni avvio, il bot scrive una fotografia del processo in `diagnostic_samples`: memoria, GC, thread, handle, CPU, eccezioni, dimensione del database, avvisi ed errori dei registri, chiamate HTTP in uscita per destinazione con le durate. Ogni esecuzione di ogni lavoro va in `job_runs`. Si tiene tutto per 30 giorni.
|
||||
- Il rapporto da incollare, in Markdown fino a 60 KB e senza segreti, si ottiene in tre modi: dal pulsante «Scarica i dati per l'analisi» in Diario e sistema, da `/api/diagnostica.md` e da `anubis diagnostics`.
|
||||
- Release di prova per Windows con `tasks release-win`: uno zip con il server, `Avvia Anubis.cmd`, `Prepara i dati da incollare.cmd` e un `LEGGIMI.txt`.
|
||||
|
||||
## In corso
|
||||
|
||||
@@ -92,14 +96,14 @@ Nulla.
|
||||
|
||||
## Prossimo passo
|
||||
|
||||
1. Controllare il rapporto della prova di durata, da venerdì 13 novembre dopo le 22:45 (ora italiana), così la finestra comprende per intero le sedute USA di giovedì e venerdì. Il container è `anubis-prova`, l'ora di partenza è in `artifacts/prova-48h/inizio.txt`:
|
||||
`docker exec -u 99:100 -e HOME=/tmp anubis-prova dotnet /app/Anubis.Server.dll soak --from 2026-11-11T20:44:31Z --hours 49 --platform docker --out /tmp/prova.md`
|
||||
poi `docker cp anubis-prova:/tmp/prova.md docs/prova-di-durata-fase-6.md` (issue #55).
|
||||
2. Poi la Fase 7, notizie. Con le chiavi del conto paper di Alpaca si possono anche fare i backtest azionari (`anubis backtest base`) e chiudere i criteri delle Fasi 2 e 3 in attesa.
|
||||
1. L'utente scarica lo zip della release `v0.7.0` da Gitea (Release), lo fa girare e poi incolla il rapporto: doppio clic su `Prepara i dati da incollare.cmd`, oppure il pulsante in Diario e sistema. Il rapporto si analizza e si salva in `docs/diagnostica/`; da lì si chiude #55.
|
||||
2. Intanto la Fase 7 va avanti sul branch `fase-7`: raccolta delle notizie (#56), poi classificatore locale (#57), analista facoltativo (#58), stato per strumento (#59) e schermata (#60).
|
||||
3. Con le chiavi del conto paper di Alpaca si possono anche fare i backtest azionari (`anubis backtest base`) e chiudere i criteri delle Fasi 2 e 3 in attesa.
|
||||
|
||||
## Da sapere
|
||||
|
||||
- Le immagini .NET 10 sono su Ubuntu 24.04, non Debian (ADR 0006).
|
||||
- La prova nel container `anubis-prova` è chiusa (ADR 0013). I compiti programmati che la sorvegliavano sono spenti; il container si può fermare con `docker stop anubis-prova`.
|
||||
- La modalità dimostrativa mostra le schermate costruite fin qui. Notizie e apprendimento appaiono solo con i dati dell'appendice F: fuori dalla demo arrivano con le Fasi 7 e 8. Nella demo il motore di trading e Telegram sono spenti.
|
||||
- In Docker il processo principale è la guardia; fuori da Docker (`tasks dev`, VS Code) il server gira da solo.
|
||||
- La guardia oggi apre solo i conti di prova: avrà i conti reali con la fase dei soldi veri (ADR 0012, punto 4).
|
||||
@@ -122,7 +126,7 @@ Nulla.
|
||||
|
||||
| Cosa | Da quando serve | Senza |
|
||||
|---|---|---|
|
||||
| Via libera per la Fase 7 | Subito | Non si parte |
|
||||
| Far girare la release `v0.7.0` e incollare il rapporto in chat | Ora, per il tempo che vuoi | La prova di durata (#55) resta aperta |
|
||||
| Chiavi del conto paper di Alpaca (`ALPACA_API_KEY_DEMO`, `ALPACA_API_SECRET_DEMO`) | Già dalla Fase 2 (dati azionari) | Parte azionaria spenta; storico azionario dal 2016 e backtest delle due strategie azionarie in attesa |
|
||||
| Chiavi demo di OKX Europe, senza permesso di prelievo | Fase 3 (ordini sui conti di prova) | Batteria di conformità su risposte d'esempio; criterio della Fase 3 in attesa |
|
||||
| Un token Gitea con permesso `write:package` come segreto `REGISTRY_TOKEN` | Fase 9 (pubblicazione dell'immagine) | Pubblicazione a mano |
|
||||
|
||||
@@ -99,6 +99,8 @@ Le attività `check`, `test` e `dev` sono anche in Terminale → Esegui attivit
|
||||
|
||||
La fanno anche `tasks ci` e la CI.
|
||||
- Il rapporto di una prova di durata si legge mentre il bot lavora: `docker exec -u 99:100 -e HOME=/tmp <container> dotnet /app/Anubis.Server.dll soak --hours 48 --platform docker`, con l'utente del bot (`PUID:PGID`) perché i file del database restino suoi. Esce con 0 se tutto è regolare e con 4 se qualcosa va guardato. Senza `--from` la finestra sono le ultime `--hours` ore; con `--from` comincia lì e dura `--hours` ore, che sono anche la durata minima richiesta.
|
||||
- Docker Desktop non si avvia dalla shell dell'app Claude (`Start-Process`, `docker desktop start`): il processo resta legato all'app e si chiude con lei quando si aggiorna o si chiude. Il 12 novembre 2026 è successo durante la prova di durata. Se va avviato da lì, si passa da WMI, che lo fa partire da un servizio di Windows:
|
||||
`Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{CommandLine='"C:\Program Files\Docker\Docker\Docker Desktop.exe"'}`
|
||||
- Gli appigli per le prove (`ANUBIS_FAULT`, `ANUBIS_DRILL_OKX_URL`) non si usano mai su un'installazione vera.
|
||||
|
||||
## Pacchetti e consegne
|
||||
|
||||
@@ -0,0 +1,84 @@
|
||||
# 0013 — Raccolta dei dati per l'analisi al posto della prova di durata in casa
|
||||
|
||||
Data: 2026-11-14 · Stato: accettata · Precisa il criterio della prova di durata (SPEC 17, Fasi 6 e 7, issue #55) e aggiunge l'issue #95, senza aggiungere componenti esterni
|
||||
|
||||
## Contesto
|
||||
|
||||
La prova di durata di 48 ore della Fase 6 girava nel container `anubis-prova` di questo PC. In tre giorni il computer l'ha interrotta più volte, mai Anubis:
|
||||
- uno spegnimento improvviso del PC;
|
||||
- Docker chiuso insieme all'app Claude durante un suo aggiornamento;
|
||||
- un blocco del motore di Docker durato 18 ore.
|
||||
|
||||
Il 14 novembre 2026 l'utente ha scelto un'altra strada. Eseguirà l'ultima release pubblicata su Gitea per il tempo che vuole, sul suo computer e con il suo uso normale. Poi incollerà in chat un rapporto, da cui si analizza come si è comportato il bot. Serve quindi una raccolta di dati più ricca di quella che il rapporto `soak` legge dai soli registri del trading, e serve una release da scaricare.
|
||||
|
||||
## Decisione
|
||||
|
||||
**1. La verifica della prova di durata passa al rapporto della release.**
|
||||
- Il criterio della Fase 7 "Il rapporto della prova di durata è in `docs/` e non riporta ordini duplicati né differenze non spiegate" resta com'è.
|
||||
- Il rapporto non viene più dal container di prova. È quello che l'utente incolla dopo aver fatto girare la release, salvato in `docs/diagnostica/`.
|
||||
- Il rapporto contiene gli stessi controlli di `anubis soak` (sezione «Controlli del lavoro»). Uno spegnimento voluto dall'utente compare come ✗ della continuità e va spiegato, non è un difetto.
|
||||
- La prova nel container `anubis-prova` è chiusa. Il suo primo tratto resta in `artifacts/prova-48h/primo-tratto/`. I due compiti programmati che la sorvegliavano sono spenti o cancellati.
|
||||
|
||||
**2. Che cosa si raccoglie (issue #95).** Tutto resta nel database del bot e niente esce dal computer.
|
||||
- Ogni 5 minuti, e una volta a ogni avvio, una fotografia del processo nella tabella `diagnostic_samples`:
|
||||
- memoria (privata, di lavoro, gestita, impegnata dal GC);
|
||||
- raccolte del GC per generazione e tempo di pausa;
|
||||
- thread, handle e coda del pool;
|
||||
- tempo di processore e contese sui lock;
|
||||
- eccezioni lanciate;
|
||||
- dimensione del database;
|
||||
- righe di avviso e di errore dei registri tecnici;
|
||||
- chiamate HTTP in uscita.
|
||||
- I contatori sono totali dall'avvio del processo: il rapporto fa le differenze. Il lavoro "diagnostica" non ha recupero: un campione perso mentre il bot era spento non si rifà.
|
||||
- Ogni esecuzione di ogni lavoro pianificato va in `job_runs`, con scadenza, inizio, fine, esito ed errore. La tabella `jobs` tiene solo l'ultima esecuzione.
|
||||
- Le chiamate HTTP si misurano ascoltando lo strumento che .NET già pubblica per ogni richiesta in uscita (`System.Net.Http`, `http.client.request.duration`) con un `MeterListener`. Non serve nessun pacchetto e non cambia nessun client.
|
||||
- Si tengono per destinazione: numero, esiti, fallite.
|
||||
- Le durate stanno in fasce fisse, così i tratti si sommano senza tenere ogni chiamata.
|
||||
- Si contano anche le eccezioni di primo lancio. Molte sono normali, ma un conto che sale sempre indica un ciclo che fallisce di continuo.
|
||||
- Le due tabelle tengono 30 giorni. La pulizia gira una volta al giorno dentro lo stesso lavoro.
|
||||
- Nella modalità dimostrativa non si raccoglie nulla.
|
||||
|
||||
**3. Il rapporto.**
|
||||
- Si ottiene in tre modi:
|
||||
- dal pulsante «Scarica i dati per l'analisi» in Diario e sistema;
|
||||
- da `GET /api/diagnostica.md?ore=N`, che richiede l'accesso;
|
||||
- dal comando `anubis diagnostics [--hours N | --from … --to …] [--out file.md]`, che legge soltanto e quindi gira anche mentre il bot lavora.
|
||||
- Senza periodo indicato copre tutto ciò che è stato raccolto, fino a 30 giorni.
|
||||
- È in Markdown e pesa al massimo 60 KB. Se serve, si tagliano per prime le righe della tabella delle risorse.
|
||||
- Le sezioni:
|
||||
- **In breve**: i segnali trovati da regole fisse, per esempio memoria o handle che crescono, lavori falliti o saltati, chiamate che falliscono o sono lente, errori nei registri, silenzi a processo acceso, ripartenze e spegnimenti;
|
||||
- **Installazione**: versione, commit, sistema, runtime e motore del database;
|
||||
- **Controlli del lavoro**: quelli di `soak`;
|
||||
- **Avvii, spegnimenti e silenzi**;
|
||||
- **Lavori pianificati**: esecuzioni, fallite, ritardi e durate;
|
||||
- **Chiamate esterne**: per destinazione, con mediana, 95° percentile e massimo;
|
||||
- **Registri tecnici**: avvisi ed errori raggruppati per messaggio, con numeri e id tolti;
|
||||
- **Risorse nel tempo**: le pendenze dopo la prima mezz'ora e una tabella di al massimo 48 righe.
|
||||
|
||||
**4. Niente di riservato nel rapporto.**
|
||||
- Tutto il testo passa dal `Redactor`.
|
||||
- La cartella dell'utente diventa `%USERPROFILE%` e il suo nome nei percorsi diventa `‹utente›`.
|
||||
- Delle variabili `ANUBIS_*` si mostra il valore solo se il nome non può contenere un segreto: niente `KEY`, `SECRET`, `PASS`, `TOKEN` o `URL`.
|
||||
- Il rapporto lascia il computer solo quando l'utente lo incolla.
|
||||
|
||||
**5. Un tipo di colonna in più: `{long}`.**
|
||||
- I byte di memoria e i contatori di una lunga esecuzione superano 2^31. SQLite in modalità `STRICT` non accetta `BIGINT`.
|
||||
- Il segnaposto `{long}` diventa `BIGINT` su PostgreSQL e `INTEGER` su SQLite, che è già a 64 bit.
|
||||
- `BIGINT` scritto a mano non è più ammesso nelle migrazioni.
|
||||
|
||||
**6. Release di prova su Gitea, prima della Fase 10.**
|
||||
- Prima che esista l'installatore della Fase 10, una release `v0.N.0` porta uno zip per Windows. Dentro ci sono:
|
||||
- il server, che richiede il runtime ASP.NET Core 10;
|
||||
- `Avvia Anubis.cmd`;
|
||||
- un `LEGGIMI.txt` in italiano.
|
||||
- Il numero di versione segue la fase in corso: `0.7.0` durante la Fase 7.
|
||||
- Lo zip usa la piattaforma desktop e la cartella dei dati dell'utente (`%APPDATA%\Anubis`). Il primo avvio apre la procedura guidata.
|
||||
- Mancano le chiavi dei conti reali e non c'è modo di abilitarli (SPEC 2.2).
|
||||
- L'immagine Docker della stessa versione si costruisce dal tag con `tasks build`. La sua pubblicazione nel registro aspetta il `REGISTRY_TOKEN` (Fase 9).
|
||||
|
||||
## Conseguenze
|
||||
|
||||
- La Fase 7 non aspetta più una prova in casa: il rapporto arriva quando l'utente lo incolla.
|
||||
- Fino ad allora l'issue #55 resta aperta.
|
||||
- Le analisi future partono dal rapporto e da tre tabelle: `diagnostic_samples`, `job_runs` e `absences`.
|
||||
- Il costo è una riga ogni 5 minuti e una per esecuzione di lavoro. A un mese sono circa 9.000 campioni e qualche decina di migliaia di esecuzioni, una frazione del database.
|
||||
@@ -4,6 +4,7 @@ using Anubis.Core;
|
||||
using Anubis.Data;
|
||||
using Anubis.Db;
|
||||
using Anubis.Demo;
|
||||
using Anubis.Diagnostics;
|
||||
using Anubis.Platform;
|
||||
using Anubis.Supervision;
|
||||
using Anubis.Trading;
|
||||
@@ -72,6 +73,7 @@ internal sealed partial class AnubisHost(
|
||||
private TradingService? _trading;
|
||||
private TelegramServices? _telegram;
|
||||
private Laboratory? _lab;
|
||||
private DiagnosticSampler? _sampler;
|
||||
private volatile HostStatus _status = new(HostMode.Starting, null, null, clock.UtcNow, 0);
|
||||
private volatile AppServices? _services;
|
||||
|
||||
@@ -156,6 +158,10 @@ internal sealed partial class AnubisHost(
|
||||
LogDemo(logger, Config.Data.Root);
|
||||
}
|
||||
|
||||
// From the first moment: every exception and every outbound call of the process is counted (issue #95).
|
||||
ExceptionCounter.Start();
|
||||
_ = HttpCallMeter.Shared;
|
||||
|
||||
while (!stoppingToken.IsCancellationRequested)
|
||||
{
|
||||
Task wake;
|
||||
@@ -349,6 +355,9 @@ internal sealed partial class AnubisHost(
|
||||
: new TelegramServices(this, _db, clock, settings, secrets, Config.HeartbeatUrl, overrides?.TelegramHttp, logger);
|
||||
_services = new AppServices(_db, settings, secrets, access, backups, scheduler, _market, _trading, _lab, _telegram);
|
||||
|
||||
// The data for the analysis of a long run (issue #95, ADR 0013); the demo has nothing to analyse.
|
||||
_sampler = options.Demo ? null : new DiagnosticSampler(_db, clock, HttpCallMeter.Shared);
|
||||
|
||||
// Before the scheduler writes its first run: how long the bot was away, and which runs it missed (SPEC 5.6).
|
||||
var lastDues = new Dictionary<string, DateTimeOffset>(StringComparer.Ordinal);
|
||||
try
|
||||
@@ -363,6 +372,11 @@ internal sealed partial class AnubisHost(
|
||||
{
|
||||
lastDues[name] = due;
|
||||
}
|
||||
|
||||
if (_sampler is not null)
|
||||
{
|
||||
await _sampler.TakeAsync(SampleKinds.Start, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex is not OperationCanceledException)
|
||||
{
|
||||
@@ -494,7 +508,7 @@ internal sealed partial class AnubisHost(
|
||||
var backup = new ScheduledJob("backup", "Salvataggio del database", Schedule.Daily(new TimeOnly(3, 30), Config.TimeZone),
|
||||
async ct => await backups.TakeAsync(_db!, "notturno", ct).ConfigureAwait(false))
|
||||
{ MaxLateness = TimeSpan.FromHours(2), CatchUpWithin = TimeSpan.FromDays(3650) };
|
||||
foreach (var job in new[] { backup }.Concat(_market?.Jobs() ?? []).Concat(_trading?.Jobs() ?? []).Concat(_telegram?.Jobs() ?? []))
|
||||
foreach (var job in new[] { backup }.Concat(_sampler is { } sampler ? new[] { sampler.Job() } : []).Concat(_market?.Jobs() ?? []).Concat(_trading?.Jobs() ?? []).Concat(_telegram?.Jobs() ?? []))
|
||||
{
|
||||
scheduler.Add(job, lastDues.TryGetValue(job.Name, out var due) ? due : null);
|
||||
}
|
||||
@@ -618,6 +632,12 @@ internal sealed partial class AnubisHost(
|
||||
("id", Ids.NewId(clock)), ("n", run.Name), ("desc", description), ("d", run.DueUtc), ("s", run.StartedUtc), ("f", run.FinishedUtc),
|
||||
("o", run.Outcome.ToString().ToLowerInvariant()), ("e", run.Error)).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
// Every run, for the lateness and the durations in the diagnostics report (issue #95).
|
||||
await s.ExecuteAsync(
|
||||
"INSERT INTO job_runs (id, job, due_at, started_at, finished_at, outcome, missed, error, created_at) VALUES (@id, @n, @d, @s, @f, @o, @m, @e, @f)",
|
||||
("id", Ids.NewId(clock)), ("n", run.Name), ("d", run.DueUtc), ("s", run.StartedUtc), ("f", run.FinishedUtc),
|
||||
("o", run.Outcome.ToString().ToLowerInvariant()), ("m", run.Missed), ("e", run.Error is null ? null : Redactor.Redact(run.Error))).ConfigureAwait(false);
|
||||
}, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex) when (ex is not OperationCanceledException)
|
||||
|
||||
@@ -116,6 +116,8 @@
|
||||
}
|
||||
<p class="note">@s.Running</p>
|
||||
<a class="btn" href="/api/registri.zip" download><Icon Name="download" Size="18" />Scarica i registri tecnici</a>
|
||||
<a class="btn" href="/api/diagnostica.md" download><Icon Name="download" Size="18" />Scarica i dati per l'analisi</a>
|
||||
<p class="note">I dati per l'analisi sono un testo da incollare a chi segue lo sviluppo: risorse, lavori, chiamate ed errori, senza chiavi né password.</p>
|
||||
</section>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -0,0 +1,139 @@
|
||||
using System.Collections;
|
||||
using System.Globalization;
|
||||
using Anubis.Core;
|
||||
using Anubis.Db;
|
||||
using Anubis.Diagnostics;
|
||||
using Anubis.Platform;
|
||||
|
||||
namespace Anubis.Server;
|
||||
|
||||
/// <summary>The diagnostics report (issue #95, ADR 0013) as the command, the download and the Diario button make it.</summary>
|
||||
internal static class DiagnosticsExport
|
||||
{
|
||||
/// <summary>Thirty days: as long as the samples are kept.</summary>
|
||||
public const double MaxHours = 720;
|
||||
|
||||
/// <summary>
|
||||
/// The report over the last <paramref name="hours"/> hours up to <paramref name="to"/>, or from
|
||||
/// <paramref name="from"/>; without either, from the first sample kept, so a run of a release is covered whole.
|
||||
/// </summary>
|
||||
public static async Task<string> BuildAsync(Database db, StartupConfig config, IReadOnlyDictionary<string, string?> environment, DateTimeOffset now,
|
||||
double? hours, DateTimeOffset? from, DateTimeOffset? to, CancellationToken cancellationToken)
|
||||
{
|
||||
var end = to ?? now;
|
||||
var start = from ?? end - TimeSpan.FromHours(Math.Clamp(hours ?? MaxHours, 0.25, MaxHours));
|
||||
if (from is null && hours is null)
|
||||
{
|
||||
var first = await db.ReadAsync(s => s.FirstOrDefaultAsync("SELECT MIN(taken_at) AS t FROM diagnostic_samples", r => r.MomentOrNull("t")), cancellationToken)
|
||||
.ConfigureAwait(false);
|
||||
if (first is { } f && f > start && f < end)
|
||||
{
|
||||
start = f;
|
||||
}
|
||||
}
|
||||
|
||||
var request = new DiagnosticsRequest(start, end, config.TimeZone)
|
||||
{
|
||||
LogsFolder = config.Data.Logs,
|
||||
Setup = Setup(config, environment),
|
||||
GeneratedAt = now,
|
||||
};
|
||||
return await DiagnosticsReporter.BuildAsync(db, request, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>The startup settings, and which ANUBIS_ variables are set: values only for those that cannot hold a secret.</summary>
|
||||
internal static IReadOnlyList<KeyValuePair<string, string>> Setup(StartupConfig config, IReadOnlyDictionary<string, string?> environment)
|
||||
{
|
||||
var lines = new List<KeyValuePair<string, string>>
|
||||
{
|
||||
new("Piattaforma", config.Platform.ToString().ToLowerInvariant()),
|
||||
new("Database", config.Db?.Describe() ?? "non configurato"),
|
||||
new("Cartella dei dati", config.Data.Root),
|
||||
new("Raggiungibile da altri computer", config.AllowNetwork ? "sì" : "no"),
|
||||
new("Ordini reali consentiti", config.AllowLive ? "sì" : "no"),
|
||||
};
|
||||
var variables = environment
|
||||
.Where(e => e.Key.StartsWith(AnubisInfo.EnvironmentPrefix, StringComparison.OrdinalIgnoreCase) && !string.IsNullOrEmpty(e.Value))
|
||||
.OrderBy(e => e.Key, StringComparer.Ordinal)
|
||||
.Select(e => e.Key + (Secretive(e.Key) ? "" : "=" + e.Value))
|
||||
.ToList();
|
||||
lines.Add(new("Variabili impostate", variables.Count == 0 ? "nessuna" : string.Join(", ", variables)));
|
||||
return lines;
|
||||
}
|
||||
|
||||
private static readonly string[] _secretWords = ["KEY", "SECRET", "PASS", "TOKEN", "URL"];
|
||||
|
||||
private static bool Secretive(string name) => _secretWords.Any(word => name.Contains(word, StringComparison.OrdinalIgnoreCase));
|
||||
|
||||
public static IReadOnlyDictionary<string, string?> ProcessEnvironment() =>
|
||||
Environment.GetEnvironmentVariables().Cast<DictionaryEntry>().ToDictionary(e => (string)e.Key, e => e.Value as string, StringComparer.Ordinal);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// "anubis diagnostics": the report to paste back after a long run of a release (issue #95, ADR 0013). It only reads,
|
||||
/// so it runs while the bot works: in Docker with <c>docker exec</c>, on desktop from a second terminal.
|
||||
/// </summary>
|
||||
internal static class DiagnosticsCommand
|
||||
{
|
||||
private const string Usage =
|
||||
"Uso: anubis diagnostics [--hours 72] [--from AAAA-MM-GGTHH:MMZ] [--to AAAA-MM-GGTHH:MMZ] [--out file.md]\n" +
|
||||
" senza --hours né --from copre tutto ciò che è stato raccolto (al massimo 30 giorni).\n" +
|
||||
"Opzioni comuni: [--platform docker|desktop] [--data-dir <cartella>]";
|
||||
|
||||
/// <summary>0 when the report was made, 1 when it could not be, 2 for the usage.</summary>
|
||||
public static async Task<int> RunAsync(string[] args, TextWriter? output = null, IReadOnlyDictionary<string, string?>? environment = null, IClock? clock = null)
|
||||
{
|
||||
output ??= Console.Out;
|
||||
clock ??= new SystemClock();
|
||||
var own = new Dictionary<string, string>(StringComparer.Ordinal);
|
||||
var rest = new List<string>();
|
||||
for (var i = 0; i < args.Length; i++)
|
||||
{
|
||||
if (args[i] is "--from" or "--to" or "--hours" or "--out" && i + 1 < args.Length)
|
||||
{
|
||||
own[args[i]] = args[++i];
|
||||
}
|
||||
else if (args[i] is "--help" or "-h")
|
||||
{
|
||||
await output.WriteLineAsync(Usage).ConfigureAwait(false);
|
||||
return 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
rest.Add(args[i]);
|
||||
}
|
||||
}
|
||||
|
||||
environment ??= DiagnosticsExport.ProcessEnvironment();
|
||||
try
|
||||
{
|
||||
double? hours = own.TryGetValue("--hours", out var h) ? double.Parse(h, CultureInfo.InvariantCulture) : null;
|
||||
DateTimeOffset? to = own.TryGetValue("--to", out var t) ? DateTimeOffset.Parse(t, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal) : null;
|
||||
DateTimeOffset? from = own.TryGetValue("--from", out var f) ? DateTimeOffset.Parse(f, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal) : null;
|
||||
var options = ServerOptions.Parse([.. rest], environment);
|
||||
var config = options.LoadConfig(environment);
|
||||
if (!config.IsComplete)
|
||||
{
|
||||
await output.WriteLineAsync("La configurazione d'avvio non è completa: avvia prima il server una volta.").ConfigureAwait(false);
|
||||
return 1;
|
||||
}
|
||||
|
||||
Redactor.Register(config.Db!.Password);
|
||||
await using var db = Database.Open(config.Db!, allowCreate: false);
|
||||
var text = await DiagnosticsExport.BuildAsync(db, config, environment, clock.UtcNow, hours, from, to, CancellationToken.None).ConfigureAwait(false);
|
||||
if (own.TryGetValue("--out", out var file))
|
||||
{
|
||||
await File.WriteAllTextAsync(Path.GetFullPath(file), text).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
await output.WriteAsync(text).ConfigureAwait(false);
|
||||
return 0;
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or FormatException or ArgumentException or InvalidOperationException or SchemaException
|
||||
or System.Data.Common.DbException or UnauthorizedAccessException or TimeZoneNotFoundException)
|
||||
{
|
||||
await output.WriteLineAsync("Non riuscito: " + Redactor.Redact(ex.Message)).ConfigureAwait(false);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -183,6 +183,15 @@ internal static partial class Endpoints
|
||||
return Results.File(LogArchive(folder), "application/zip", $"anubis-registri-{day}.zip");
|
||||
});
|
||||
|
||||
// The data collected for the analysis of a long run, as one Markdown report to paste (issue #95, ADR 0013).
|
||||
api.MapGet("/diagnostica.md", async (AnubisHost host, ShellData shell, IClock clock, double? ore, CancellationToken ct) =>
|
||||
{
|
||||
var now = clock.UtcNow;
|
||||
var text = await DiagnosticsExport.BuildAsync(host.Services!.Db, host.Config, DiagnosticsExport.ProcessEnvironment(), now, ore, null, null, ct).ConfigureAwait(false);
|
||||
var day = TimeZoneInfo.ConvertTime(now, shell.Zone).ToString("yyyy-MM-dd-HHmm", System.Globalization.CultureInfo.InvariantCulture);
|
||||
return Results.File(System.Text.Encoding.UTF8.GetBytes(text), "text/markdown; charset=utf-8", $"anubis-diagnostica-{day}.md");
|
||||
});
|
||||
|
||||
// The external sources and the live feed: what is on, what is off and why (SPEC 4.4).
|
||||
api.MapGet("/data/sources", async (AnubisHost host, IClock clock, CancellationToken ct) =>
|
||||
{
|
||||
|
||||
@@ -3,6 +3,7 @@ using System.Globalization;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
using Anubis.Core;
|
||||
using Anubis.Diagnostics;
|
||||
|
||||
namespace Anubis.Server;
|
||||
|
||||
@@ -33,6 +34,7 @@ internal sealed class JsonLogProvider : ILoggerProvider
|
||||
|
||||
internal void Write(string category, LogLevel level, EventId eventId, string message, Exception? exception)
|
||||
{
|
||||
LogCounter.Record(level);
|
||||
var now = _clock.UtcNow;
|
||||
using var buffer = new MemoryStream();
|
||||
using (var json = new Utf8JsonWriter(buffer))
|
||||
|
||||
@@ -24,6 +24,12 @@ if (args.Length >= 1 && args[0] == "soak")
|
||||
return await SoakCommand.RunAsync(args[1..]).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
// "anubis diagnostics": the data collected for the analysis of a long run, as one report to paste (issue #95).
|
||||
if (args.Length >= 1 && args[0] == "diagnostics")
|
||||
{
|
||||
return await DiagnosticsCommand.RunAsync(args[1..]).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
var app = ServerApp.Build(args);
|
||||
await app.RunAsync().ConfigureAwait(false);
|
||||
return 0;
|
||||
@@ -1,3 +1,5 @@
|
||||
using System.Reflection;
|
||||
|
||||
namespace Anubis;
|
||||
|
||||
/// <summary>Names fixed by ADR 0001, shared by every part of the bot.</summary>
|
||||
@@ -15,4 +17,10 @@ public static class AnubisInfo
|
||||
/// <summary>Version of the running build, for example "0.0.1".</summary>
|
||||
public static string Version { get; } =
|
||||
typeof(AnubisInfo).Assembly.GetName().Version?.ToString(3) ?? "0.0.0";
|
||||
|
||||
/// <summary>The commit the build came from (the SDK appends it to the informational version), when known.</summary>
|
||||
public static string? Commit { get; } =
|
||||
typeof(AnubisInfo).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion is { } full && full.IndexOf('+', StringComparison.Ordinal) is var plus and >= 0
|
||||
? full[(plus + 1)..][..Math.Min(12, full.Length - plus - 1)]
|
||||
: null;
|
||||
}
|
||||
@@ -91,6 +91,9 @@ public static class DbValues
|
||||
("bool", DbEngine.Sqlite) => "INTEGER",
|
||||
("bytes", DbEngine.Postgres) => "BYTEA",
|
||||
("bytes", DbEngine.Sqlite) => "BLOB",
|
||||
// A whole number beyond 2^31 (bytes of memory, counters of a long run): SQLite's INTEGER is already 64 bits.
|
||||
("long", DbEngine.Postgres) => "BIGINT",
|
||||
("long", DbEngine.Sqlite) => "INTEGER",
|
||||
("float", DbEngine.Postgres) => "DOUBLE PRECISION",
|
||||
("float", DbEngine.Sqlite) => "REAL",
|
||||
("strict", DbEngine.Postgres) => "",
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
-- Data collected for the analysis of a long run (issue #95, ADR 0013). Both tables are kept for 30 days.
|
||||
|
||||
-- One sample of the process every 5 minutes, and one at every start. The counters (collections, pauses, processor
|
||||
-- time, lock contentions, exceptions) are totals since the process started: the report takes the differences
|
||||
-- between two samples of the same process. warnings and errors are the log lines since the previous sample.
|
||||
-- calls holds the outbound HTTP calls since the previous sample, by destination, with their duration buckets.
|
||||
CREATE TABLE diagnostic_samples (
|
||||
id {uuid} PRIMARY KEY,
|
||||
taken_at {timestamp} NOT NULL,
|
||||
process_started_at {timestamp} NOT NULL,
|
||||
kind TEXT NOT NULL,
|
||||
version TEXT NOT NULL,
|
||||
working_set {long} NOT NULL,
|
||||
private_bytes {long} NOT NULL,
|
||||
managed_heap {long} NOT NULL,
|
||||
gc_committed {long} NOT NULL,
|
||||
gc_gen0 {long} NOT NULL,
|
||||
gc_gen1 {long} NOT NULL,
|
||||
gc_gen2 {long} NOT NULL,
|
||||
gc_pause_ms {float} NOT NULL,
|
||||
threads INTEGER NOT NULL,
|
||||
handles INTEGER NOT NULL,
|
||||
cpu_ms {float} NOT NULL,
|
||||
pool_threads INTEGER NOT NULL,
|
||||
pool_pending {long} NOT NULL,
|
||||
lock_contentions {long} NOT NULL,
|
||||
exceptions {long} NOT NULL,
|
||||
db_bytes {long},
|
||||
warnings INTEGER NOT NULL,
|
||||
errors INTEGER NOT NULL,
|
||||
calls {json},
|
||||
created_at {timestamp} NOT NULL
|
||||
){strict};
|
||||
|
||||
CREATE INDEX diagnostic_samples_taken ON diagnostic_samples (taken_at);
|
||||
|
||||
-- Every run of a scheduled job, with its lateness and duration. jobs keeps only the last one.
|
||||
CREATE TABLE job_runs (
|
||||
id {uuid} PRIMARY KEY,
|
||||
job TEXT NOT NULL,
|
||||
due_at {timestamp} NOT NULL,
|
||||
started_at {timestamp} NOT NULL,
|
||||
finished_at {timestamp} NOT NULL,
|
||||
outcome TEXT NOT NULL,
|
||||
missed {bool} NOT NULL,
|
||||
error TEXT,
|
||||
created_at {timestamp} NOT NULL
|
||||
){strict};
|
||||
|
||||
CREATE INDEX job_runs_started ON job_runs (started_at);
|
||||
@@ -32,7 +32,7 @@ public static partial class Migrations
|
||||
{
|
||||
public const string VersionTable = "schema_versions";
|
||||
|
||||
[GeneratedRegex(@"\{(money|uuid|timestamp|json|bool|bytes|float|strict)\}")]
|
||||
[GeneratedRegex(@"\{(money|uuid|timestamp|json|bool|bytes|float|long|strict)\}")]
|
||||
internal static partial Regex Tokens();
|
||||
|
||||
[GeneratedRegex(@"^(\d{4})_([a-z0-9_]+)\.sql$")]
|
||||
|
||||
@@ -83,9 +83,10 @@ public static partial class Schema
|
||||
"{BOOL}" => ColumnKind.Bool,
|
||||
"{BYTES}" => ColumnKind.Bytes,
|
||||
"{FLOAT}" => ColumnKind.Measure,
|
||||
"{LONG}" => ColumnKind.Number,
|
||||
"TEXT" => ColumnKind.Text,
|
||||
"INTEGER" or "BIGINT" => ColumnKind.Number,
|
||||
var other => throw new InvalidOperationException($"Column type {other} is not portable: use TEXT, INTEGER, BIGINT or a token."),
|
||||
"INTEGER" => ColumnKind.Number,
|
||||
var other => throw new InvalidOperationException($"Column type {other} is not portable: use TEXT, INTEGER or a token."),
|
||||
};
|
||||
var upper = definition.ToUpperInvariant();
|
||||
var nullable = !upper.Contains("NOT NULL", StringComparison.Ordinal) && !upper.Contains("PRIMARY KEY", StringComparison.Ordinal);
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace Anubis.Diagnostics;
|
||||
|
||||
/// <summary>
|
||||
/// The warning and error lines written by the logs since the last look (issue #95). The log writer counts each line;
|
||||
/// the sampler takes the counts every 5 minutes, so the report shows when the troubles came, not only how many.
|
||||
/// </summary>
|
||||
public static class LogCounter
|
||||
{
|
||||
private static long _warnings;
|
||||
private static long _errors;
|
||||
|
||||
public static void Record(LogLevel level)
|
||||
{
|
||||
if (level == LogLevel.Warning)
|
||||
{
|
||||
Interlocked.Increment(ref _warnings);
|
||||
}
|
||||
else if (level >= LogLevel.Error && level != LogLevel.None)
|
||||
{
|
||||
Interlocked.Increment(ref _errors);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The lines since the previous call, and the counts start again from zero.</summary>
|
||||
public static (int Warnings, int Errors) Take() =>
|
||||
((int)Math.Min(int.MaxValue, Interlocked.Exchange(ref _warnings, 0)), (int)Math.Min(int.MaxValue, Interlocked.Exchange(ref _errors, 0)));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Every exception thrown in the process, caught or not, since the counting started. Many are normal (a cancelled
|
||||
/// wait, a lost connection retried), but a count that keeps climbing points to a loop that fails over and over.
|
||||
/// </summary>
|
||||
public static class ExceptionCounter
|
||||
{
|
||||
private static long _count;
|
||||
private static int _started;
|
||||
|
||||
public static long Count => Interlocked.Read(ref _count);
|
||||
|
||||
public static void Start()
|
||||
{
|
||||
if (Interlocked.Exchange(ref _started, 1) == 0)
|
||||
{
|
||||
AppDomain.CurrentDomain.FirstChanceException += (_, _) => Interlocked.Increment(ref _count);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
using System.Diagnostics;
|
||||
using System.Text.Json;
|
||||
using Anubis.Core;
|
||||
using Anubis.Db;
|
||||
using Anubis.Platform;
|
||||
|
||||
namespace Anubis.Diagnostics;
|
||||
|
||||
public static class SampleKinds
|
||||
{
|
||||
/// <summary>The first sample of a process, written as soon as the bot is ready.</summary>
|
||||
public const string Start = "start";
|
||||
|
||||
public const string Periodic = "periodic";
|
||||
}
|
||||
|
||||
/// <summary>One look at the process (issue #95). Counters are totals since the process started.</summary>
|
||||
public sealed record ProcessSample
|
||||
{
|
||||
public required DateTimeOffset TakenAt { get; init; }
|
||||
|
||||
public required DateTimeOffset ProcessStartedAt { get; init; }
|
||||
|
||||
public required string Kind { get; init; }
|
||||
|
||||
public string Version { get; init; } = AnubisInfo.Version;
|
||||
|
||||
public long WorkingSet { get; init; }
|
||||
|
||||
public long PrivateBytes { get; init; }
|
||||
|
||||
public long ManagedHeap { get; init; }
|
||||
|
||||
public long GcCommitted { get; init; }
|
||||
|
||||
public long Gen0 { get; init; }
|
||||
|
||||
public long Gen1 { get; init; }
|
||||
|
||||
public long Gen2 { get; init; }
|
||||
|
||||
public double GcPauseMs { get; init; }
|
||||
|
||||
public int Threads { get; init; }
|
||||
|
||||
public int Handles { get; init; }
|
||||
|
||||
public double CpuMs { get; init; }
|
||||
|
||||
public int PoolThreads { get; init; }
|
||||
|
||||
public long PoolPending { get; init; }
|
||||
|
||||
public long LockContentions { get; init; }
|
||||
|
||||
public long Exceptions { get; init; }
|
||||
|
||||
public long? DbBytes { get; init; }
|
||||
|
||||
public int Warnings { get; init; }
|
||||
|
||||
public int Errors { get; init; }
|
||||
|
||||
public IReadOnlyList<HttpCallStats> Calls { get; init; } = [];
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Every 5 minutes, and once at each start, a sample of the process goes to <c>diagnostic_samples</c>, with the log
|
||||
/// warnings and errors and the outbound calls since the previous one (issue #95, ADR 0013). Samples and job runs older
|
||||
/// than 30 days are deleted once a day. It only measures: nothing here changes what the bot does.
|
||||
/// </summary>
|
||||
public sealed class DiagnosticSampler(Database db, IClock clock, HttpCallMeter meter)
|
||||
{
|
||||
public const string JobName = "diagnostica";
|
||||
|
||||
public static readonly TimeSpan Interval = TimeSpan.FromMinutes(5);
|
||||
|
||||
public static readonly TimeSpan Keep = TimeSpan.FromDays(30);
|
||||
|
||||
internal static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);
|
||||
|
||||
private DateTimeOffset? _lastPrune;
|
||||
|
||||
public ScheduledJob Job() => new(JobName, "Raccolta dei dati per l'analisi", Schedule.Every(Interval), ct => TakeAsync(SampleKinds.Periodic, ct))
|
||||
{
|
||||
MaxLateness = Interval,
|
||||
};
|
||||
|
||||
public async Task<ProcessSample> TakeAsync(string kind, CancellationToken cancellationToken)
|
||||
{
|
||||
var (warnings, errors) = LogCounter.Take();
|
||||
var sample = Probe(clock.UtcNow, kind) with
|
||||
{
|
||||
DbBytes = await DatabaseBytesAsync(db, cancellationToken).ConfigureAwait(false),
|
||||
Warnings = warnings,
|
||||
Errors = errors,
|
||||
Calls = meter.Take(),
|
||||
};
|
||||
var prune = _lastPrune is not { } last || sample.TakenAt - last >= TimeSpan.FromDays(1);
|
||||
await db.WriteAsync(async s =>
|
||||
{
|
||||
await WriteAsync(s, clock, sample, cancellationToken).ConfigureAwait(false);
|
||||
if (prune)
|
||||
{
|
||||
var before = sample.TakenAt - Keep;
|
||||
await s.ExecuteAsync("DELETE FROM diagnostic_samples WHERE taken_at < @t", cancellationToken, ("t", before)).ConfigureAwait(false);
|
||||
await s.ExecuteAsync("DELETE FROM job_runs WHERE started_at < @t", cancellationToken, ("t", before)).ConfigureAwait(false);
|
||||
}
|
||||
}, cancellationToken).ConfigureAwait(false);
|
||||
if (prune)
|
||||
{
|
||||
_lastPrune = sample.TakenAt;
|
||||
}
|
||||
|
||||
return sample;
|
||||
}
|
||||
|
||||
/// <summary>The process as it is now. Process times come from the system clock: they measure the machine, not the market.</summary>
|
||||
public static ProcessSample Probe(DateTimeOffset now, string kind)
|
||||
{
|
||||
using var process = Process.GetCurrentProcess();
|
||||
var gc = GC.GetGCMemoryInfo();
|
||||
return new ProcessSample
|
||||
{
|
||||
TakenAt = now,
|
||||
ProcessStartedAt = new DateTimeOffset(process.StartTime.ToUniversalTime(), TimeSpan.Zero),
|
||||
Kind = kind,
|
||||
WorkingSet = process.WorkingSet64,
|
||||
PrivateBytes = process.PrivateMemorySize64,
|
||||
ManagedHeap = GC.GetTotalMemory(forceFullCollection: false),
|
||||
GcCommitted = gc.TotalCommittedBytes,
|
||||
Gen0 = GC.CollectionCount(0),
|
||||
Gen1 = GC.CollectionCount(1),
|
||||
Gen2 = GC.CollectionCount(2),
|
||||
GcPauseMs = Math.Round(GC.GetTotalPauseDuration().TotalMilliseconds, 1),
|
||||
Threads = process.Threads.Count,
|
||||
Handles = process.HandleCount,
|
||||
CpuMs = Math.Round(process.TotalProcessorTime.TotalMilliseconds, 1),
|
||||
PoolThreads = ThreadPool.ThreadCount,
|
||||
PoolPending = ThreadPool.PendingWorkItemCount,
|
||||
LockContentions = Monitor.LockContentionCount,
|
||||
Exceptions = ExceptionCounter.Count,
|
||||
};
|
||||
}
|
||||
|
||||
public static async Task WriteAsync(DbSession s, IClock clock, ProcessSample sample, CancellationToken cancellationToken)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(s);
|
||||
ArgumentNullException.ThrowIfNull(sample);
|
||||
await s.ExecuteAsync(
|
||||
"INSERT INTO diagnostic_samples (id, taken_at, process_started_at, kind, version, working_set, private_bytes, managed_heap, gc_committed, gc_gen0, gc_gen1, gc_gen2, " +
|
||||
"gc_pause_ms, threads, handles, cpu_ms, pool_threads, pool_pending, lock_contentions, exceptions, db_bytes, warnings, errors, calls, created_at) VALUES " +
|
||||
"(@id, @t, @ps, @k, @v, @ws, @pb, @mh, @gcc, @g0, @g1, @g2, @gp, @th, @h, @cpu, @pt, @pp, @lc, @ex, @db, @w, @e, @calls, @now)",
|
||||
cancellationToken,
|
||||
("id", Ids.NewId(clock)), ("t", sample.TakenAt), ("ps", sample.ProcessStartedAt), ("k", sample.Kind), ("v", sample.Version), ("ws", sample.WorkingSet),
|
||||
("pb", sample.PrivateBytes), ("mh", sample.ManagedHeap), ("gcc", sample.GcCommitted), ("g0", sample.Gen0), ("g1", sample.Gen1), ("g2", sample.Gen2),
|
||||
("gp", sample.GcPauseMs), ("th", sample.Threads), ("h", sample.Handles), ("cpu", sample.CpuMs), ("pt", sample.PoolThreads), ("pp", sample.PoolPending),
|
||||
("lc", sample.LockContentions), ("ex", sample.Exceptions), ("db", sample.DbBytes), ("w", sample.Warnings), ("e", sample.Errors),
|
||||
("calls", sample.Calls.Count == 0 ? null : new DbJson(JsonSerializer.Serialize(sample.Calls, Json))), ("now", clock.UtcNow)).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>The size of the database: its files on SQLite (with the journal), what PostgreSQL reports for it.</summary>
|
||||
public static async Task<long?> DatabaseBytesAsync(Database db, CancellationToken cancellationToken)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(db);
|
||||
try
|
||||
{
|
||||
if (db.Engine == DbEngine.Sqlite)
|
||||
{
|
||||
return db.SqlitePath is not { } path ? null
|
||||
: new[] { path, path + "-wal", path + "-shm" }.Where(File.Exists).Sum(f => new FileInfo(f).Length);
|
||||
}
|
||||
|
||||
return await db.ReadAsync(s => s.CountAsync("SELECT pg_database_size(current_database())"), cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or System.Data.Common.DbException)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,595 @@
|
||||
using System.Globalization;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
using System.Text.RegularExpressions;
|
||||
using Anubis.Core;
|
||||
using Anubis.Db;
|
||||
using Anubis.Platform;
|
||||
using Anubis.Supervision;
|
||||
|
||||
namespace Anubis.Diagnostics;
|
||||
|
||||
/// <summary>What the report covers and the facts about the installation that only the caller knows.</summary>
|
||||
public sealed record DiagnosticsRequest(DateTimeOffset From, DateTimeOffset To, TimeZoneInfo Zone)
|
||||
{
|
||||
/// <summary>The folder of the technical logs (<c>anubis-yyyyMMdd.log</c>); without it the report skips them.</summary>
|
||||
public string? LogsFolder { get; init; }
|
||||
|
||||
/// <summary>Startup settings with nothing secret in them, shown as they are.</summary>
|
||||
public IReadOnlyList<KeyValuePair<string, string>> Setup { get; init; } = [];
|
||||
|
||||
public DateTimeOffset GeneratedAt { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The report the user pastes back after a long run of a release (issue #95, ADR 0013): in Markdown, at most 60 KB,
|
||||
/// with everything passed through <see cref="Redactor"/> and the user's folders masked. It only reads.
|
||||
/// </summary>
|
||||
public static partial class DiagnosticsReporter
|
||||
{
|
||||
public const int MaxBytes = 60 * 1024;
|
||||
|
||||
private const int MaxLogGroups = 40;
|
||||
private const long MaxLogBytes = 256L * 1024 * 1024;
|
||||
|
||||
/// <summary>Two missed samples in a row: the process lived but did not sample (sleep, a stuck scheduler).</summary>
|
||||
private static readonly TimeSpan Silence = DiagnosticSampler.Interval * 2 + TimeSpan.FromMinutes(1);
|
||||
|
||||
private static readonly TimeSpan[] Steps =
|
||||
[TimeSpan.FromMinutes(15), TimeSpan.FromMinutes(30), TimeSpan.FromHours(1), TimeSpan.FromHours(2), TimeSpan.FromHours(3),
|
||||
TimeSpan.FromHours(6), TimeSpan.FromHours(12), TimeSpan.FromDays(1)];
|
||||
|
||||
public static async Task<string> BuildAsync(Database db, DiagnosticsRequest request, CancellationToken cancellationToken = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(db);
|
||||
ArgumentNullException.ThrowIfNull(request);
|
||||
if (request.To <= request.From)
|
||||
{
|
||||
throw new ArgumentException("La fine del periodo deve venire dopo l'inizio.", nameof(request));
|
||||
}
|
||||
|
||||
var zone = request.Zone;
|
||||
var findings = new List<string>();
|
||||
var soak = await SoakReporter.BuildAsync(db, request.From, request.To, request.To - request.From, zone, cancellationToken).ConfigureAwait(false);
|
||||
var data = await db.ReadAsync(async s =>
|
||||
{
|
||||
(string Name, object? Value)[] window = [("from", request.From), ("to", request.To)];
|
||||
var engine = await s.FirstOrDefaultAsync(s.Engine == DbEngine.Sqlite ? "SELECT 'SQLite ' || sqlite_version() AS v" : "SELECT version() AS v", r => r.Text("v")).ConfigureAwait(false);
|
||||
var samples = await s.QueryAsync("SELECT * FROM diagnostic_samples WHERE taken_at >= @from AND taken_at <= @to ORDER BY taken_at", ReadSample, window).ConfigureAwait(false);
|
||||
var runs = await s.QueryAsync("SELECT job, due_at, started_at, finished_at, outcome, missed, error FROM job_runs WHERE started_at >= @from AND started_at <= @to",
|
||||
r => new Run(r.Text("job"), r.Moment("due_at"), r.Moment("started_at"), r.Moment("finished_at"), r.Text("outcome"), r.Bool("missed"), r.TextOrNull("error")), window)
|
||||
.ConfigureAwait(false);
|
||||
var absences = await s.QueryAsync("SELECT started_at, ended_at FROM absences WHERE ended_at >= @from AND started_at <= @to ORDER BY started_at",
|
||||
r => (Start: r.Moment("started_at"), End: r.Moment("ended_at")), window).ConfigureAwait(false);
|
||||
return (Engine: engine, Samples: samples, Runs: runs, Absences: absences);
|
||||
}, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
var logs = request.LogsFolder is { } folder ? ReadLogs(folder, request.From, request.To) : null;
|
||||
|
||||
var sections = new List<string>
|
||||
{
|
||||
Setup(request, data.Engine, data.Samples),
|
||||
Soak(soak, findings),
|
||||
Starts(data.Samples, data.Absences, zone, findings),
|
||||
Jobs(data.Runs, findings),
|
||||
Calls(data.Samples, findings),
|
||||
Logs(logs, zone, findings),
|
||||
Resources(data.Samples, request, findings),
|
||||
};
|
||||
|
||||
var text = new StringBuilder()
|
||||
.AppendLine("# Anubis · dati per l'analisi")
|
||||
.AppendLine()
|
||||
.AppendLine(CultureInfo.InvariantCulture, $"Versione {AnubisInfo.Version} (commit {AnubisInfo.Commit ?? "non noto"}). Dal {SoakReport.Moment(request.From, zone)} al " +
|
||||
$"{SoakReport.Moment(request.To, zone)} ({SoakReport.Hours(request.To - request.From)}), ora di {zone.Id}. Fatto il {SoakReport.Moment(request.GeneratedAt, zone)}.")
|
||||
.AppendLine()
|
||||
.AppendLine("## In breve")
|
||||
.AppendLine();
|
||||
foreach (var finding in findings.Count == 0 ? ["Nessun segnale di problema nei dati raccolti."] : findings)
|
||||
{
|
||||
text.AppendLine("- " + finding);
|
||||
}
|
||||
|
||||
foreach (var section in sections)
|
||||
{
|
||||
text.AppendLine().Append(section);
|
||||
}
|
||||
|
||||
return Fit(Mask(text.ToString().ReplaceLineEndings("\n")));
|
||||
}
|
||||
|
||||
/// <summary>The user's folders and name out, the secrets out, and no more than <see cref="MaxBytes"/>.</summary>
|
||||
internal static string Mask(string text)
|
||||
{
|
||||
var profile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
|
||||
if (profile.Length > 3)
|
||||
{
|
||||
text = text.Replace(profile, "%USERPROFILE%", StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
var user = Environment.UserName;
|
||||
if (user.Length >= 3)
|
||||
{
|
||||
text = text.Replace("\\" + user + "\\", "\\‹utente›\\", StringComparison.OrdinalIgnoreCase)
|
||||
.Replace("/" + user + "/", "/‹utente›/", StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
return Redactor.Redact(text);
|
||||
}
|
||||
|
||||
internal static string Fit(string text)
|
||||
{
|
||||
if (Encoding.UTF8.GetByteCount(text) <= MaxBytes)
|
||||
{
|
||||
return text;
|
||||
}
|
||||
|
||||
const string note = "\n\n_Rapporto tagliato a 60 KB: le righe più vecchie delle risorse mancano._\n";
|
||||
var limit = MaxBytes - Encoding.UTF8.GetByteCount(note);
|
||||
var cut = text.Length;
|
||||
while (cut > 0 && Encoding.UTF8.GetByteCount(text.AsSpan(0, cut)) > limit)
|
||||
{
|
||||
cut = text.LastIndexOf('\n', cut - 1);
|
||||
}
|
||||
|
||||
return text[..Math.Max(0, cut)] + note;
|
||||
}
|
||||
|
||||
private static string Setup(DiagnosticsRequest request, string? engine, List<ProcessSample> samples)
|
||||
{
|
||||
var text = new StringBuilder("## Installazione\n\n");
|
||||
text.AppendLine(CultureInfo.InvariantCulture, $"- Sistema: {RuntimeInformation.OSDescription} ({RuntimeInformation.OSArchitecture}), {Environment.ProcessorCount} processori")
|
||||
.AppendLine(CultureInfo.InvariantCulture, $"- Runtime: {RuntimeInformation.FrameworkDescription}")
|
||||
.AppendLine(CultureInfo.InvariantCulture, $"- Motore del database: {engine ?? "non noto"}");
|
||||
if (samples.LastOrDefault(s => s.DbBytes is not null) is { DbBytes: { } bytes })
|
||||
{
|
||||
text.AppendLine(CultureInfo.InvariantCulture, $"- Dimensione del database: {Mb(bytes)} MB");
|
||||
}
|
||||
|
||||
foreach (var (name, value) in request.Setup)
|
||||
{
|
||||
text.AppendLine(CultureInfo.InvariantCulture, $"- {name}: {value}");
|
||||
}
|
||||
|
||||
return text.ToString();
|
||||
}
|
||||
|
||||
private static string Soak(SoakReport soak, List<string> findings)
|
||||
{
|
||||
var failed = soak.Checks.Where(c => !c.Ok).ToList();
|
||||
if (failed.Count > 0)
|
||||
{
|
||||
findings.Add($"Controlli del lavoro da guardare: {failed.Count} (sezione «Controlli del lavoro»).");
|
||||
}
|
||||
|
||||
var text = new StringBuilder("## Controlli del lavoro\n\n");
|
||||
foreach (var check in soak.Checks)
|
||||
{
|
||||
text.AppendLine(CultureInfo.InvariantCulture, $"- {(check.Ok ? "✓" : "✗")} {check.Text}");
|
||||
}
|
||||
|
||||
foreach (var fact in soak.Facts)
|
||||
{
|
||||
text.AppendLine("- " + fact);
|
||||
}
|
||||
|
||||
return text.ToString();
|
||||
}
|
||||
|
||||
private static string Starts(List<ProcessSample> samples, List<(DateTimeOffset Start, DateTimeOffset End)> absences, TimeZoneInfo zone, List<string> findings)
|
||||
{
|
||||
var text = new StringBuilder("## Avvii, spegnimenti e silenzi\n\n");
|
||||
var processes = Processes(samples);
|
||||
if (processes.Count == 0)
|
||||
{
|
||||
findings.Add("Nessun campione nel periodo: la raccolta dei dati non ha girato (versione senza raccolta, o bot spento).");
|
||||
return text.AppendLine("Nessun campione nel periodo.").ToString();
|
||||
}
|
||||
|
||||
text.AppendLine("| Avviato | Versione | Primo campione | Ultimo campione | Campioni |").AppendLine("|---|---|---|---|---|");
|
||||
foreach (var p in processes)
|
||||
{
|
||||
text.AppendLine(CultureInfo.InvariantCulture,
|
||||
$"| {SoakReport.Moment(p[0].ProcessStartedAt, zone)} | {p[0].Version} | {SoakReport.Moment(p[0].TakenAt, zone)} | {SoakReport.Moment(p[^1].TakenAt, zone)} | {p.Count} |");
|
||||
}
|
||||
|
||||
if (processes.Count > 1)
|
||||
{
|
||||
findings.Add($"Il bot è ripartito {processes.Count - 1} volte nel periodo.");
|
||||
}
|
||||
|
||||
text.AppendLine();
|
||||
if (absences.Count > 0)
|
||||
{
|
||||
var total = absences.Aggregate(TimeSpan.Zero, (sum, a) => sum + (a.End - a.Start));
|
||||
findings.Add($"Spento {absences.Count} volte, in tutto {Duration(total)}.");
|
||||
text.AppendLine("Spento: " + string.Join(", ", absences.Select(a => $"dal {SoakReport.Moment(a.Start, zone)} per {Duration(a.End - a.Start)}")) + ".");
|
||||
}
|
||||
else
|
||||
{
|
||||
text.AppendLine("Nessuno spegnimento registrato.");
|
||||
}
|
||||
|
||||
var silences = processes.SelectMany(p => p.Zip(p.Skip(1)).Where(x => x.Second.TakenAt - x.First.TakenAt > Silence)).ToList();
|
||||
if (silences.Count > 0)
|
||||
{
|
||||
var total = silences.Aggregate(TimeSpan.Zero, (sum, x) => sum + (x.Second.TakenAt - x.First.TakenAt));
|
||||
findings.Add($"Silenzi a processo acceso: {silences.Count}, in tutto {Duration(total)} (computer in sospensione, o lavori bloccati).");
|
||||
text.AppendLine().AppendLine("Silenzi a processo acceso (nessun campione per più di 11 minuti): " +
|
||||
string.Join(", ", silences.Take(30).Select(x => $"dal {SoakReport.Moment(x.First.TakenAt, zone)} per {Duration(x.Second.TakenAt - x.First.TakenAt)}")) +
|
||||
(silences.Count > 30 ? $" e altri {silences.Count - 30}" : "") + ".");
|
||||
}
|
||||
|
||||
return text.ToString();
|
||||
}
|
||||
|
||||
private static string Jobs(List<Run> runs, List<string> findings)
|
||||
{
|
||||
var text = new StringBuilder("## Lavori pianificati\n\n");
|
||||
if (runs.Count == 0)
|
||||
{
|
||||
return text.AppendLine("Nessuna esecuzione registrata nel periodo.").ToString();
|
||||
}
|
||||
|
||||
text.AppendLine("| Lavoro | Esecuzioni | Fallite | Saltate | Recuperate | Ritardo medio · massimo | Durata mediana · 95% · massima | Ultimo errore |")
|
||||
.AppendLine("|---|---|---|---|---|---|---|---|");
|
||||
foreach (var job in runs.GroupBy(r => r.Job, StringComparer.Ordinal).OrderBy(g => g.Key, StringComparer.Ordinal))
|
||||
{
|
||||
var list = job.OrderBy(r => r.Started).ToList();
|
||||
var failed = list.Count(r => r.Outcome == "failed");
|
||||
var skipped = list.Count(r => r.Outcome == "skipped");
|
||||
var late = list.Where(r => r.Outcome != "skipped" && !r.Missed).Select(r => (r.Started - r.Due).TotalSeconds).DefaultIfEmpty(0).ToList();
|
||||
var took = list.Where(r => r.Outcome != "skipped").Select(r => (r.Finished - r.Started).TotalSeconds).Order().ToList();
|
||||
var error = list.LastOrDefault(r => r.Error is not null)?.Error;
|
||||
text.AppendLine(CultureInfo.InvariantCulture,
|
||||
$"| {job.Key} | {list.Count} | {failed} | {skipped} | {list.Count(r => r.Missed)} | {Seconds(late.Average())} · {Seconds(late.Max())} | " +
|
||||
$"{Seconds(Rank(took, 0.5))} · {Seconds(Rank(took, 0.95))} · {Seconds(took.LastOrDefault())} | {Cell(error, 160)} |");
|
||||
if (failed > 0)
|
||||
{
|
||||
findings.Add($"Il lavoro «{job.Key}» è fallito {failed} volte su {list.Count}.");
|
||||
}
|
||||
|
||||
if (skipped > 0)
|
||||
{
|
||||
findings.Add($"Il lavoro «{job.Key}» è stato saltato {skipped} volte (troppo in ritardo).");
|
||||
}
|
||||
}
|
||||
|
||||
return text.ToString();
|
||||
}
|
||||
|
||||
private static string Calls(List<ProcessSample> samples, List<string> findings)
|
||||
{
|
||||
var text = new StringBuilder("## Chiamate esterne\n\n");
|
||||
var calls = HttpCallStats.Merge(samples.SelectMany(s => s.Calls));
|
||||
if (calls.Count == 0)
|
||||
{
|
||||
return text.AppendLine("Nessuna chiamata registrata nel periodo.").ToString();
|
||||
}
|
||||
|
||||
text.AppendLine("| Destinazione | Chiamate | Fallite | Esiti | Media ms | 50% ms | 95% ms | Massimo ms |").AppendLine("|---|---|---|---|---|---|---|---|");
|
||||
foreach (var c in calls)
|
||||
{
|
||||
text.AppendLine(CultureInfo.InvariantCulture,
|
||||
$"| {Cell(c.Host, 80)} | {c.Calls} | {c.Failures} | {Cell(string.Join(", ", c.Outcomes.Select(o => o.Key + "×" + o.Value)), 160)} | {Ms(c.AverageMs)} | " +
|
||||
$"{Ms(c.Percentile(0.5))} | {Ms(c.Percentile(0.95))} | {Ms(c.MaxMs)} |");
|
||||
if (c.Calls >= 20 && c.Failures * 20 > c.Calls)
|
||||
{
|
||||
findings.Add($"Le chiamate a {c.Host} falliscono spesso: {c.Failures} su {c.Calls}.");
|
||||
}
|
||||
|
||||
if (c.Calls >= 20 && c.Percentile(0.95) >= 5000)
|
||||
{
|
||||
findings.Add($"Le chiamate a {c.Host} sono lente: il 95% sta sotto {Ms(c.Percentile(0.95))} ms.");
|
||||
}
|
||||
}
|
||||
|
||||
return text.ToString();
|
||||
}
|
||||
|
||||
private static string Logs(LogSummary? logs, TimeZoneInfo zone, List<string> findings)
|
||||
{
|
||||
var text = new StringBuilder("## Registri tecnici: avvisi ed errori\n\n");
|
||||
if (logs is null)
|
||||
{
|
||||
return text.AppendLine("Cartella dei registri non disponibile.").ToString();
|
||||
}
|
||||
|
||||
text.AppendLine(CultureInfo.InvariantCulture,
|
||||
$"Letti {logs.Files} file, {logs.Lines} righe nel periodo: {logs.Warnings} avvisi e {logs.Errors} errori{(logs.Truncated ? " (lettura fermata a 256 MB)" : "")}.").AppendLine();
|
||||
if (logs.Errors > 0)
|
||||
{
|
||||
findings.Add($"Errori nei registri tecnici: {logs.Errors}, di {logs.Groups.Count(g => g.Level != "warning")} tipi.");
|
||||
}
|
||||
|
||||
if (logs.Groups.Count == 0)
|
||||
{
|
||||
return text.ToString();
|
||||
}
|
||||
|
||||
text.AppendLine("| Livello | Volte | Prima | Ultima | Origine | Messaggio |").AppendLine("|---|---|---|---|---|---|");
|
||||
foreach (var g in logs.Groups.OrderBy(g => g.Level == "warning" ? 1 : 0).ThenByDescending(g => g.Count).Take(MaxLogGroups))
|
||||
{
|
||||
var message = g.Error is null ? g.Sample : g.Sample + " — " + g.Error;
|
||||
text.AppendLine(CultureInfo.InvariantCulture,
|
||||
$"| {g.Level} | {g.Count} | {SoakReport.Moment(g.First, zone)} | {SoakReport.Moment(g.Last, zone)} | {Cell(g.Category, 60)} | {Cell(message, 300)} |");
|
||||
}
|
||||
|
||||
if (logs.Groups.Count > MaxLogGroups)
|
||||
{
|
||||
text.AppendLine().AppendLine(CultureInfo.InvariantCulture, $"Altri {logs.Groups.Count - MaxLogGroups} tipi di messaggio non mostrati.");
|
||||
}
|
||||
|
||||
return text.ToString();
|
||||
}
|
||||
|
||||
private static string Resources(List<ProcessSample> samples, DiagnosticsRequest request, List<string> findings)
|
||||
{
|
||||
var text = new StringBuilder("## Risorse nel tempo\n\n");
|
||||
var processes = Processes(samples);
|
||||
if (processes.Count == 0)
|
||||
{
|
||||
return text.AppendLine("Nessun campione.").ToString();
|
||||
}
|
||||
|
||||
foreach (var p in processes)
|
||||
{
|
||||
var settled = p.Where(s => s.TakenAt - s.ProcessStartedAt >= TimeSpan.FromMinutes(30)).ToList();
|
||||
var line = $"Processo avviato il {SoakReport.Moment(p[0].ProcessStartedAt, request.Zone)}: memoria da {Mb(p[0].WorkingSet)} a {Mb(p[^1].WorkingSet)} MB, " +
|
||||
$"memoria gestita da {Mb(p[0].ManagedHeap)} a {Mb(p[^1].ManagedHeap)} MB, handle da {p[0].Handles} a {p[^1].Handles}, thread da {p[0].Threads} a {p[^1].Threads}";
|
||||
if (settled.Count >= 12 && settled[^1].TakenAt - settled[0].TakenAt >= TimeSpan.FromHours(3))
|
||||
{
|
||||
var ws = Slope(settled, s => s.WorkingSet / 1048576.0);
|
||||
var heap = Slope(settled, s => s.GcCommitted / 1048576.0);
|
||||
var handles = Slope(settled, s => s.Handles);
|
||||
var threads = Slope(settled, s => s.Threads);
|
||||
line += $"; pendenza dopo la prima mezz'ora: memoria {Signed(ws)} MB/ora, memoria del GC {Signed(heap)} MB/ora, handle {Signed(handles)}/ora, thread {Signed(threads)}/ora";
|
||||
var hours = (settled[^1].TakenAt - settled[0].TakenAt).TotalHours;
|
||||
if (ws > 2 && ws * hours > settled[0].WorkingSet / 1048576.0 * 0.2)
|
||||
{
|
||||
findings.Add($"La memoria cresce di {Signed(ws)} MB l'ora da {Duration(TimeSpan.FromHours(hours))}: possibile perdita.");
|
||||
}
|
||||
|
||||
if (handles > 10 && handles * hours > settled[0].Handles * 0.2)
|
||||
{
|
||||
findings.Add($"Gli handle crescono di {Signed(handles)} l'ora: possibile perdita di connessioni o file.");
|
||||
}
|
||||
|
||||
if (threads > 1 && threads * hours > settled[0].Threads * 0.3)
|
||||
{
|
||||
findings.Add($"I thread crescono di {Signed(threads)} l'ora.");
|
||||
}
|
||||
}
|
||||
|
||||
var hoursAlive = (p[^1].TakenAt - p[0].ProcessStartedAt).TotalHours;
|
||||
if (hoursAlive >= 1 && (p[^1].Exceptions / hoursAlive) > 2000)
|
||||
{
|
||||
findings.Add($"Molte eccezioni: {Format.Number((decimal)(p[^1].Exceptions / hoursAlive))} l'ora nel processo avviato il {SoakReport.Moment(p[0].ProcessStartedAt, request.Zone)}.");
|
||||
}
|
||||
|
||||
text.AppendLine(line + ".");
|
||||
}
|
||||
|
||||
var dbFirst = samples.FirstOrDefault(s => s.DbBytes is not null);
|
||||
var dbLast = samples.LastOrDefault(s => s.DbBytes is not null);
|
||||
if (dbFirst is { DbBytes: { } a } && dbLast is { DbBytes: { } b } && dbLast.TakenAt - dbFirst.TakenAt >= TimeSpan.FromHours(6))
|
||||
{
|
||||
var perDay = (b - a) / (dbLast.TakenAt - dbFirst.TakenAt).TotalDays;
|
||||
text.AppendLine(CultureInfo.InvariantCulture, $"Il database è passato da {Mb(a)} a {Mb(b)} MB ({Signed(perDay / 1048576.0)} MB al giorno).");
|
||||
}
|
||||
|
||||
var span = request.To - request.From;
|
||||
var step = Steps.FirstOrDefault(s => span / s <= 48, Steps[^1]);
|
||||
text.AppendLine()
|
||||
.AppendLine(CultureInfo.InvariantCulture, $"Un campione ogni {Duration(step)}; i conteggi sono dal campione della riga prima. Memorie in MB, CPU in % di un processore.")
|
||||
.AppendLine()
|
||||
.AppendLine("| Ora | Memoria | Gestita | GC | Thread | Handle | Coda | CPU % | GC2 | Pause ms | Eccezioni | Avvisi | Errori | DB | |")
|
||||
.AppendLine("|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|");
|
||||
ProcessSample? previous = null;
|
||||
foreach (var bucket in samples.GroupBy(s => s.TakenAt.UtcTicks / step.Ticks).OrderBy(g => g.Key))
|
||||
{
|
||||
var last = bucket.Last();
|
||||
var same = previous is not null && previous.ProcessStartedAt == last.ProcessStartedAt;
|
||||
var basis = same ? previous! : null;
|
||||
var wall = (last.TakenAt - (basis?.TakenAt ?? last.ProcessStartedAt)).TotalMilliseconds;
|
||||
var cpu = wall <= 0 ? 0 : (last.CpuMs - (basis?.CpuMs ?? 0)) / wall * 100;
|
||||
text.AppendLine(CultureInfo.InvariantCulture,
|
||||
$"| {SoakReport.Moment(last.TakenAt, request.Zone)} | {Mb(last.WorkingSet)} | {Mb(last.ManagedHeap)} | {Mb(last.GcCommitted)} | {last.Threads} | {last.Handles} | " +
|
||||
$"{last.PoolPending} | {Format.Number((decimal)cpu, 1)} | {last.Gen2 - (basis?.Gen2 ?? 0)} | {Format.Number((decimal)(last.GcPauseMs - (basis?.GcPauseMs ?? 0)))} | " +
|
||||
$"{last.Exceptions - (basis?.Exceptions ?? 0)} | {bucket.Sum(s => s.Warnings)} | {bucket.Sum(s => s.Errors)} | {(last.DbBytes is { } db ? Mb(db) : "")} | " +
|
||||
$"{(previous is not null && !same ? "riavvio" : "")} |");
|
||||
previous = last;
|
||||
}
|
||||
|
||||
return text.ToString();
|
||||
}
|
||||
|
||||
private static List<List<ProcessSample>> Processes(List<ProcessSample> samples) =>
|
||||
samples.GroupBy(s => s.ProcessStartedAt).Select(g => g.OrderBy(s => s.TakenAt).ToList()).OrderBy(p => p[0].TakenAt).ToList();
|
||||
|
||||
private static ProcessSample ReadSample(DbRow r) => new()
|
||||
{
|
||||
TakenAt = r.Moment("taken_at"),
|
||||
ProcessStartedAt = r.Moment("process_started_at"),
|
||||
Kind = r.Text("kind"),
|
||||
Version = r.Text("version"),
|
||||
WorkingSet = r.Number("working_set"),
|
||||
PrivateBytes = r.Number("private_bytes"),
|
||||
ManagedHeap = r.Number("managed_heap"),
|
||||
GcCommitted = r.Number("gc_committed"),
|
||||
Gen0 = r.Number("gc_gen0"),
|
||||
Gen1 = r.Number("gc_gen1"),
|
||||
Gen2 = r.Number("gc_gen2"),
|
||||
GcPauseMs = r.Measure("gc_pause_ms"),
|
||||
Threads = (int)r.Number("threads"),
|
||||
Handles = (int)r.Number("handles"),
|
||||
CpuMs = r.Measure("cpu_ms"),
|
||||
PoolThreads = (int)r.Number("pool_threads"),
|
||||
PoolPending = r.Number("pool_pending"),
|
||||
LockContentions = r.Number("lock_contentions"),
|
||||
Exceptions = r.Number("exceptions"),
|
||||
DbBytes = r.IsNull("db_bytes") ? null : r.Number("db_bytes"),
|
||||
Warnings = (int)r.Number("warnings"),
|
||||
Errors = (int)r.Number("errors"),
|
||||
Calls = r.TextOrNull("calls") is { } json ? JsonSerializer.Deserialize<List<HttpCallStats>>(json, DiagnosticSampler.Json) ?? [] : [],
|
||||
};
|
||||
|
||||
/// <summary>The warning and error lines of the technical logs in the window, grouped by what they say.</summary>
|
||||
internal static LogSummary ReadLogs(string folder, DateTimeOffset from, DateTimeOffset to)
|
||||
{
|
||||
var groups = new Dictionary<string, LogGroup>(StringComparer.Ordinal);
|
||||
int files = 0, warnings = 0, errors = 0;
|
||||
long lines = 0, read = 0;
|
||||
var truncated = false;
|
||||
if (!Directory.Exists(folder))
|
||||
{
|
||||
return new LogSummary(0, 0, 0, 0, false, []);
|
||||
}
|
||||
|
||||
var first = DateOnly.FromDateTime(from.UtcDateTime).AddDays(-1);
|
||||
var last = DateOnly.FromDateTime(to.UtcDateTime).AddDays(1);
|
||||
foreach (var file in Directory.EnumerateFiles(folder, "anubis-*.log").Order(StringComparer.Ordinal))
|
||||
{
|
||||
var name = Path.GetFileNameWithoutExtension(file);
|
||||
if (!DateOnly.TryParseExact(name["anubis-".Length..], "yyyyMMdd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var day) || day < first || day > last)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (read >= MaxLogBytes)
|
||||
{
|
||||
truncated = true;
|
||||
break;
|
||||
}
|
||||
|
||||
files++;
|
||||
try
|
||||
{
|
||||
using var stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete);
|
||||
using var reader = new StreamReader(stream, Encoding.UTF8);
|
||||
while (reader.ReadLine() is { } line)
|
||||
{
|
||||
read += line.Length + 1;
|
||||
if (read > MaxLogBytes)
|
||||
{
|
||||
truncated = true;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!TryParse(line, out var entry) || entry.At < from || entry.At > to)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
lines++;
|
||||
if (entry.Level is not ("warning" or "error" or "critical"))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
if (entry.Level == "warning")
|
||||
{
|
||||
warnings++;
|
||||
}
|
||||
else
|
||||
{
|
||||
errors++;
|
||||
}
|
||||
|
||||
var category = entry.Category[(entry.Category.LastIndexOf('.') + 1)..];
|
||||
var key = entry.Level + "|" + category + "|" + Normalize(entry.Message);
|
||||
if (groups.TryGetValue(key, out var group))
|
||||
{
|
||||
groups[key] = group with { Count = group.Count + 1, Last = entry.At > group.Last ? entry.At : group.Last, Error = group.Error ?? entry.Error };
|
||||
}
|
||||
else
|
||||
{
|
||||
groups[key] = new LogGroup(entry.Level, category, entry.Message, entry.Error, 1, entry.At, entry.At);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (IOException)
|
||||
{
|
||||
}
|
||||
catch (UnauthorizedAccessException)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
return new LogSummary(files, lines, warnings, errors, truncated, [.. groups.Values]);
|
||||
}
|
||||
|
||||
private static bool TryParse(string line, out (DateTimeOffset At, string Level, string Category, string Message, string? Error) entry)
|
||||
{
|
||||
entry = default;
|
||||
try
|
||||
{
|
||||
using var json = JsonDocument.Parse(line);
|
||||
var root = json.RootElement;
|
||||
if (!root.TryGetProperty("at", out var at) || !DateTimeOffset.TryParse(at.GetString(), CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var moment))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
entry = (moment, root.TryGetProperty("level", out var l) ? l.GetString() ?? "" : "", root.TryGetProperty("category", out var c) ? c.GetString() ?? "" : "",
|
||||
root.TryGetProperty("message", out var m) ? m.GetString() ?? "" : "", root.TryGetProperty("error", out var e) ? e.GetString() : null);
|
||||
return true;
|
||||
}
|
||||
catch (JsonException)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The message with ids and numbers taken out, so the same trouble with other values counts once.</summary>
|
||||
internal static string Normalize(string message) => Numbers().Replace(Guids().Replace(message, "‹id›"), "#");
|
||||
|
||||
private static double Slope(List<ProcessSample> samples, Func<ProcessSample, double> value)
|
||||
{
|
||||
var t0 = samples[0].TakenAt;
|
||||
var xs = samples.Select(s => (s.TakenAt - t0).TotalHours).ToList();
|
||||
var ys = samples.Select(value).ToList();
|
||||
var mx = xs.Average();
|
||||
var my = ys.Average();
|
||||
var den = xs.Sum(x => (x - mx) * (x - mx));
|
||||
return den == 0 ? 0 : xs.Zip(ys).Sum(p => (p.First - mx) * (p.Second - my)) / den;
|
||||
}
|
||||
|
||||
private static double Rank(List<double> sorted, double q) => sorted.Count == 0 ? 0 : sorted[Math.Clamp((int)Math.Ceiling(q * sorted.Count) - 1, 0, sorted.Count - 1)];
|
||||
|
||||
private static string Mb(long bytes) => Format.Number((decimal)Math.Round(bytes / 1048576.0, 1), 1);
|
||||
|
||||
private static string Ms(double ms) => Format.Number((decimal)Math.Round(ms));
|
||||
|
||||
private static string Seconds(double seconds) => seconds < 10 ? Format.Number((decimal)Math.Round(seconds, 2), 2) + " s" : Format.Number((decimal)Math.Round(seconds)) + " s";
|
||||
|
||||
private static string Signed(double value) => Format.Number((decimal)Math.Round(value, 2), 2, withSign: true);
|
||||
|
||||
private static string Duration(TimeSpan span) => span.TotalMinutes < 90
|
||||
? Format.Number((decimal)Math.Round(span.TotalMinutes)) + " minuti"
|
||||
: span.TotalHours < 48 ? SoakReport.Hours(TimeSpan.FromHours(Math.Round(span.TotalHours, 1))) : Format.Number((decimal)Math.Round(span.TotalDays, 1), 1) + " giorni";
|
||||
|
||||
private static string Cell(string? text, int max)
|
||||
{
|
||||
if (string.IsNullOrEmpty(text))
|
||||
{
|
||||
return "";
|
||||
}
|
||||
|
||||
var flat = text.ReplaceLineEndings(" ").Replace("|", "\\|", StringComparison.Ordinal);
|
||||
return flat.Length <= max ? flat : flat[..max] + "…";
|
||||
}
|
||||
|
||||
[GeneratedRegex(@"\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b")]
|
||||
private static partial Regex Guids();
|
||||
|
||||
[GeneratedRegex(@"\d+(?:[.,:]\d+)*")]
|
||||
private static partial Regex Numbers();
|
||||
|
||||
private sealed record Run(string Job, DateTimeOffset Due, DateTimeOffset Started, DateTimeOffset Finished, string Outcome, bool Missed, string? Error);
|
||||
|
||||
internal sealed record LogGroup(string Level, string Category, string Sample, string? Error, int Count, DateTimeOffset First, DateTimeOffset Last);
|
||||
|
||||
internal sealed record LogSummary(int Files, long Lines, int Warnings, int Errors, bool Truncated, IReadOnlyList<LogGroup> Groups);
|
||||
}
|
||||
@@ -0,0 +1,196 @@
|
||||
using System.Diagnostics.Metrics;
|
||||
using System.Globalization;
|
||||
|
||||
namespace Anubis.Diagnostics;
|
||||
|
||||
/// <summary>
|
||||
/// The outbound HTTP calls of one destination over a stretch of time (issue #95): how many, how many failed and how,
|
||||
/// and how long they took, in fixed buckets so that stretches can be added together without keeping every call.
|
||||
/// </summary>
|
||||
public sealed record HttpCallStats(string Host, long Calls, long Failures, IReadOnlyDictionary<string, long> Outcomes, long[] Buckets, double MaxMs, double TotalMs)
|
||||
{
|
||||
/// <summary>Upper bounds in milliseconds of the duration buckets; one more bucket holds everything slower.</summary>
|
||||
public static IReadOnlyList<double> Bounds { get; } = [5, 10, 20, 30, 50, 75, 100, 150, 200, 250, 300, 400, 500, 750, 1000, 1500, 2000, 3000, 5000, 10000, 20000, 30000, 60000];
|
||||
|
||||
public double AverageMs => Calls == 0 ? 0 : TotalMs / Calls;
|
||||
|
||||
/// <summary>
|
||||
/// The duration under which a share <paramref name="q"/> of the calls finished, read from the buckets: the upper
|
||||
/// bound of the bucket where that share is reached, never more than the slowest call.
|
||||
/// </summary>
|
||||
public double Percentile(double q)
|
||||
{
|
||||
var total = Buckets.Sum();
|
||||
if (total == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
var rank = Math.Max(1, (long)Math.Ceiling(q * total));
|
||||
long seen = 0;
|
||||
for (var i = 0; i < Buckets.Length; i++)
|
||||
{
|
||||
seen += Buckets[i];
|
||||
if (seen >= rank)
|
||||
{
|
||||
return i < Bounds.Count ? Math.Min(Bounds[i], MaxMs) : MaxMs;
|
||||
}
|
||||
}
|
||||
|
||||
return MaxMs;
|
||||
}
|
||||
|
||||
public static IReadOnlyList<HttpCallStats> Merge(IEnumerable<HttpCallStats> stats)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(stats);
|
||||
return stats.GroupBy(s => s.Host, StringComparer.Ordinal).Select(g =>
|
||||
{
|
||||
var buckets = new long[Bounds.Count + 1];
|
||||
var outcomes = new SortedDictionary<string, long>(StringComparer.Ordinal);
|
||||
foreach (var s in g)
|
||||
{
|
||||
for (var i = 0; i < Math.Min(buckets.Length, s.Buckets.Length); i++)
|
||||
{
|
||||
buckets[i] += s.Buckets[i];
|
||||
}
|
||||
|
||||
foreach (var (outcome, count) in s.Outcomes)
|
||||
{
|
||||
outcomes[outcome] = outcomes.GetValueOrDefault(outcome) + count;
|
||||
}
|
||||
}
|
||||
|
||||
return new HttpCallStats(g.Key, g.Sum(s => s.Calls), g.Sum(s => s.Failures), outcomes, buckets, g.Max(s => s.MaxMs), g.Sum(s => s.TotalMs));
|
||||
}).OrderByDescending(s => s.Calls).ThenBy(s => s.Host, StringComparer.Ordinal).ToList();
|
||||
}
|
||||
|
||||
internal static int Bucket(double milliseconds)
|
||||
{
|
||||
for (var i = 0; i < Bounds.Count; i++)
|
||||
{
|
||||
if (milliseconds <= Bounds[i])
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return Bounds.Count;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Listens to the duration that .NET records for every outbound HTTP request (meter <c>System.Net.Http</c>,
|
||||
/// instrument <c>http.client.request.duration</c>) and adds it up by destination until <see cref="Take"/>. No
|
||||
/// package and no change to the brokers' clients: every <see cref="HttpClient"/> of the process is measured.
|
||||
/// </summary>
|
||||
public sealed class HttpCallMeter : IDisposable
|
||||
{
|
||||
public const string MeterName = "System.Net.Http";
|
||||
public const string InstrumentName = "http.client.request.duration";
|
||||
|
||||
private static readonly Lazy<HttpCallMeter> _shared = new(() => new HttpCallMeter());
|
||||
|
||||
private readonly MeterListener _listener = new();
|
||||
private readonly Lock _gate = new();
|
||||
private Dictionary<string, Tally> _tallies = new(StringComparer.Ordinal);
|
||||
|
||||
public HttpCallMeter()
|
||||
{
|
||||
_listener.InstrumentPublished = (instrument, listener) =>
|
||||
{
|
||||
if (instrument.Meter.Name == MeterName && instrument.Name == InstrumentName)
|
||||
{
|
||||
listener.EnableMeasurementEvents(instrument);
|
||||
}
|
||||
};
|
||||
_listener.SetMeasurementEventCallback<double>(OnMeasurement);
|
||||
_listener.Start();
|
||||
}
|
||||
|
||||
/// <summary>The one meter of the running bot, started at the first use.</summary>
|
||||
public static HttpCallMeter Shared => _shared.Value;
|
||||
|
||||
/// <summary>The calls since the previous call to this method, by destination; the counts start again from zero.</summary>
|
||||
public IReadOnlyList<HttpCallStats> Take()
|
||||
{
|
||||
Dictionary<string, Tally> taken;
|
||||
lock (_gate)
|
||||
{
|
||||
taken = _tallies;
|
||||
_tallies = new Dictionary<string, Tally>(StringComparer.Ordinal);
|
||||
}
|
||||
|
||||
return taken.Select(t => t.Value.Stats(t.Key)).OrderBy(s => s.Host, StringComparer.Ordinal).ToList();
|
||||
}
|
||||
|
||||
public void Dispose() => _listener.Dispose();
|
||||
|
||||
private void OnMeasurement(Instrument instrument, double seconds, ReadOnlySpan<KeyValuePair<string, object?>> tags, object? state)
|
||||
{
|
||||
string? host = null;
|
||||
int? port = null;
|
||||
int? status = null;
|
||||
string? error = null;
|
||||
foreach (var tag in tags)
|
||||
{
|
||||
switch (tag.Key)
|
||||
{
|
||||
case "server.address":
|
||||
host = tag.Value?.ToString();
|
||||
break;
|
||||
case "server.port":
|
||||
port = tag.Value is null ? null : Convert.ToInt32(tag.Value, CultureInfo.InvariantCulture);
|
||||
break;
|
||||
case "http.response.status_code":
|
||||
status = tag.Value is null ? null : Convert.ToInt32(tag.Value, CultureInfo.InvariantCulture);
|
||||
break;
|
||||
case "error.type":
|
||||
error = tag.Value?.ToString();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
var key = (host ?? "?") + (port is { } p and not (80 or 443) ? ":" + p.ToString(CultureInfo.InvariantCulture) : "");
|
||||
var outcome = status?.ToString(CultureInfo.InvariantCulture) ?? error ?? "?";
|
||||
// 101 is the answer that opens a WebSocket: a success like 2xx and 3xx.
|
||||
var failed = status is not (>= 100 and < 400);
|
||||
var milliseconds = Math.Max(0, seconds * 1000);
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_tallies.TryGetValue(key, out var tally))
|
||||
{
|
||||
tally = new Tally();
|
||||
_tallies[key] = tally;
|
||||
}
|
||||
|
||||
tally.Add(outcome, failed, milliseconds);
|
||||
}
|
||||
}
|
||||
|
||||
private sealed class Tally
|
||||
{
|
||||
private readonly long[] _buckets = new long[HttpCallStats.Bounds.Count + 1];
|
||||
private readonly SortedDictionary<string, long> _outcomes = new(StringComparer.Ordinal);
|
||||
private long _calls;
|
||||
private long _failures;
|
||||
private double _max;
|
||||
private double _total;
|
||||
|
||||
public void Add(string outcome, bool failed, double milliseconds)
|
||||
{
|
||||
_calls++;
|
||||
if (failed)
|
||||
{
|
||||
_failures++;
|
||||
}
|
||||
|
||||
_outcomes[outcome] = _outcomes.GetValueOrDefault(outcome) + 1;
|
||||
_buckets[HttpCallStats.Bucket(milliseconds)]++;
|
||||
_max = Math.Max(_max, milliseconds);
|
||||
_total += milliseconds;
|
||||
}
|
||||
|
||||
public HttpCallStats Stats(string host) => new(host, _calls, _failures, new SortedDictionary<string, long>(_outcomes, StringComparer.Ordinal),
|
||||
(long[])_buckets.Clone(), Math.Round(_max, 1), Math.Round(_total, 1));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
using System.Diagnostics.Metrics;
|
||||
using System.Globalization;
|
||||
using System.Net;
|
||||
using System.Text;
|
||||
using Anubis.Core;
|
||||
using Anubis.Data;
|
||||
using Anubis.Db;
|
||||
using Anubis.Diagnostics;
|
||||
|
||||
namespace Anubis.Tests;
|
||||
|
||||
/// <summary>The data collected for the analysis of a long run and the report made from it (issue #95, ADR 0013).</summary>
|
||||
[TestClass]
|
||||
public sealed class DiagnosticsTests
|
||||
{
|
||||
private const string Hidden = "segretissima42";
|
||||
|
||||
private static readonly DateTimeOffset Start = new(2026, 11, 14, 8, 0, 0, TimeSpan.Zero);
|
||||
|
||||
[TestMethod]
|
||||
public void OutboundCallsAreCountedByDestinationWithTheirDurations()
|
||||
{
|
||||
using var meter = new HttpCallMeter();
|
||||
using var source = new Meter(HttpCallMeter.MeterName);
|
||||
var duration = source.CreateHistogram<double>(HttpCallMeter.InstrumentName, "s");
|
||||
const string host = "misura.invalid";
|
||||
foreach (var (seconds, status) in new[] { (0.04, 200), (0.08, 101), (0.4, 200), (2.5, 503) })
|
||||
{
|
||||
duration.Record(seconds, new("server.address", host), new("server.port", 443), new("http.response.status_code", status));
|
||||
}
|
||||
|
||||
duration.Record(30.0, new("server.address", host), new("server.port", 8443), new("error.type", "timeout"));
|
||||
|
||||
var calls = meter.Take().Where(c => c.Host.StartsWith(host, StringComparison.Ordinal)).ToDictionary(c => c.Host);
|
||||
var main = calls[host];
|
||||
Assert.AreEqual(4, main.Calls);
|
||||
Assert.AreEqual(1, main.Failures);
|
||||
Assert.AreEqual(2, main.Outcomes["200"]);
|
||||
Assert.AreEqual(1, main.Outcomes["101"], "A WebSocket that opens is not a failure.");
|
||||
Assert.AreEqual(1, main.Outcomes["503"]);
|
||||
Assert.AreEqual(2500, main.MaxMs);
|
||||
Assert.AreEqual(100, main.Percentile(0.5), "The second fastest call is under the 100 ms bound.");
|
||||
Assert.AreEqual(400, main.Percentile(0.75));
|
||||
Assert.AreEqual(2500, main.Percentile(0.95), "Never more than the slowest call.");
|
||||
Assert.AreEqual(1, calls[host + ":8443"].Failures);
|
||||
Assert.AreEqual(1, calls[host + ":8443"].Outcomes["timeout"]);
|
||||
Assert.IsFalse(meter.Take().Any(c => c.Host.StartsWith(host, StringComparison.Ordinal)), "The counts start again after a take.");
|
||||
|
||||
var merged = HttpCallStats.Merge([main, main with { Calls = 1, Failures = 0, MaxMs = 9000, Buckets = Bucketed(9000) }]).Single();
|
||||
Assert.AreEqual(5, merged.Calls);
|
||||
Assert.AreEqual(9000, merged.MaxMs);
|
||||
Assert.AreEqual(9000, merged.Percentile(1));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
public void LogMessagesWithOtherValuesCountAsOneAndTheReportStaysSmall()
|
||||
{
|
||||
Assert.AreEqual(
|
||||
DiagnosticsReporter.Normalize("Ordine 7f0c1e2a-0000-7000-8000-0123456789ab rifiutato dopo 3 tentativi, 1.250,50 EUR"),
|
||||
DiagnosticsReporter.Normalize("Ordine 0193aaaa-bbbb-7ccc-8ddd-eeeeffff0000 rifiutato dopo 12 tentativi, 7,1 EUR"));
|
||||
|
||||
var long_ = string.Join('\n', Enumerable.Range(0, 5000).Select(i => $"| riga {i} | {new string('x', 40)} |"));
|
||||
var fitted = DiagnosticsReporter.Fit(long_);
|
||||
Assert.IsLessThanOrEqualTo(DiagnosticsReporter.MaxBytes, Encoding.UTF8.GetByteCount(fitted));
|
||||
Assert.Contains("Rapporto tagliato a 60 KB", fitted);
|
||||
Assert.AreEqual("breve", DiagnosticsReporter.Fit("breve"));
|
||||
|
||||
LogCounter.Record(Microsoft.Extensions.Logging.LogLevel.Error);
|
||||
Assert.IsGreaterThanOrEqualTo(1, LogCounter.Take().Errors);
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
[TestCategory(Category.Integration)]
|
||||
public async Task SamplesAndJobRunsBecomeAReportWithoutSecrets()
|
||||
{
|
||||
await using var test = await DatabaseTests.MigratedAsync().ConfigureAwait(false);
|
||||
var clock = new ManualClock(Start);
|
||||
var sampler = new DiagnosticSampler(test.Db, clock, new HttpCallMeter());
|
||||
|
||||
// A first sample of the process: the database size is measured on both engines.
|
||||
var first = await sampler.TakeAsync(SampleKinds.Start, CancellationToken.None).ConfigureAwait(false);
|
||||
Assert.IsGreaterThan(0, first.WorkingSet);
|
||||
Assert.IsGreaterThan(0L, first.DbBytes ?? 0);
|
||||
Assert.AreEqual(DiagnosticSampler.JobName, sampler.Job().Name);
|
||||
|
||||
// Ten hours of one process whose memory grows by 30 MB an hour, with a silence of 40 minutes, then a restart.
|
||||
var process = Start.AddMinutes(-1);
|
||||
await test.Db.WriteAsync(async s =>
|
||||
{
|
||||
for (var i = 1; i <= 120; i++)
|
||||
{
|
||||
var at = Start.AddMinutes(5 * i + (i > 60 ? 40 : 0));
|
||||
await DiagnosticSampler.WriteAsync(s, clock, Sample(at, process, 200 + 30 * (at - Start).TotalHours, i) with
|
||||
{
|
||||
Errors = i == 50 ? 2 : 0,
|
||||
Calls = i % 10 == 0 ? [new HttpCallStats("paper-api.alpaca.markets", 10, 1, new Dictionary<string, long> { ["200"] = 9, ["429"] = 1 }, Bucketed(120, 10), 900, 1500)] : [],
|
||||
}, CancellationToken.None).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
var restart = Start.AddHours(11);
|
||||
await DiagnosticSampler.WriteAsync(s, clock, Sample(restart.AddMinutes(1), restart, 150, 1) with { Kind = SampleKinds.Start }, CancellationToken.None).ConfigureAwait(false);
|
||||
await s.ExecuteAsync("INSERT INTO absences (id, started_at, ended_at, acknowledged_at, created_at) VALUES (@id, @s, @e, NULL, @e)", CancellationToken.None,
|
||||
("id", Guid.NewGuid()), ("s", Start.AddHours(10.6)), ("e", restart)).ConfigureAwait(false);
|
||||
for (var i = 1; i <= 30; i++)
|
||||
{
|
||||
var due = Start.AddMinutes(5 * i);
|
||||
await s.ExecuteAsync("INSERT INTO job_runs (id, job, due_at, started_at, finished_at, outcome, missed, error, created_at) VALUES (@id, @j, @d, @s, @f, @o, @m, @e, @f)",
|
||||
CancellationToken.None, ("id", Guid.NewGuid()), ("j", "riconciliazione"), ("d", due), ("s", due.AddSeconds(2)), ("f", due.AddSeconds(5)),
|
||||
("o", i == 7 ? "failed" : "completed"), ("m", false), ("e", i == 7 ? "Alpaca ha risposto 500" : null)).ConfigureAwait(false);
|
||||
}
|
||||
}).ConfigureAwait(false);
|
||||
|
||||
// The technical logs, with a secret that must never reach the report.
|
||||
var logs = TempFolder.Create("diagnostica");
|
||||
try
|
||||
{
|
||||
var leaked = "pass" + "word=" + Hidden;
|
||||
var lines = new StringBuilder();
|
||||
for (var i = 0; i < 5; i++)
|
||||
{
|
||||
lines.AppendLine(CultureInfo.InvariantCulture, $"{{\"at\":\"{Start.AddHours(1).AddMinutes(i):yyyy-MM-ddTHH:mm:ss.fffZ}\",\"level\":\"warning\",\"category\":\"Anubis.Data.MarketDataService\",\"message\":\"Fonte lenta: {i * 100} ms\"}}");
|
||||
}
|
||||
|
||||
lines.AppendLine(CultureInfo.InvariantCulture, $"{{\"at\":\"{Start.AddHours(2):yyyy-MM-ddTHH:mm:ss.fffZ}\",\"level\":\"error\",\"category\":\"Anubis.Trading.Reconciler\",\"message\":\"Riconciliazione non riuscita {leaked}\",\"error\":\"HttpRequestException: 500\"}}");
|
||||
lines.AppendLine(CultureInfo.InvariantCulture, $"{{\"at\":\"{Start.AddHours(2):yyyy-MM-ddTHH:mm:ss.fffZ}\",\"level\":\"information\",\"category\":\"Anubis.Server\",\"message\":\"normale\"}}");
|
||||
lines.AppendLine("non è json");
|
||||
await File.WriteAllTextAsync(Path.Combine(logs, $"anubis-{Start:yyyyMMdd}.log"), lines.ToString()).ConfigureAwait(false);
|
||||
|
||||
var text = await DiagnosticsReporter.BuildAsync(test.Db, new DiagnosticsRequest(Start.AddMinutes(1), Start.AddHours(12), Zones.Rome)
|
||||
{
|
||||
LogsFolder = logs,
|
||||
Setup = [new("Piattaforma", "desktop")],
|
||||
GeneratedAt = Start.AddHours(12),
|
||||
}).ConfigureAwait(false);
|
||||
|
||||
Assert.IsLessThanOrEqualTo(DiagnosticsReporter.MaxBytes, Encoding.UTF8.GetByteCount(text));
|
||||
Assert.DoesNotContain(Hidden, text);
|
||||
Assert.Contains("# Anubis · dati per l'analisi", text);
|
||||
Assert.Contains("- Piattaforma: desktop", text);
|
||||
Assert.Contains("Il bot è ripartito 1 volte nel periodo.", text);
|
||||
Assert.Contains("Spento 1 volte", text);
|
||||
Assert.Contains("Silenzi a processo acceso: 1", text);
|
||||
Assert.Contains("La memoria cresce di +30,00 MB l'ora", text);
|
||||
Assert.Contains("Il lavoro «riconciliazione» è fallito 1 volte su 30.", text);
|
||||
Assert.Contains("| riconciliazione | 30 | 1 | 0 | 0 | 2,00 s · 2,00 s | 3,00 s · 3,00 s · 3,00 s | Alpaca ha risposto 500 |", text);
|
||||
Assert.Contains("| paper-api.alpaca.markets | 120 | 12 | 200×108, 429×12 |", text);
|
||||
Assert.Contains("Letti 1 file, 7 righe nel periodo: 5 avvisi e 1 errori.", text);
|
||||
Assert.Contains("Errori nei registri tecnici: 1", text);
|
||||
Assert.Contains("| warning | 5 |", text);
|
||||
Assert.Contains("HttpRequestException: 500", text);
|
||||
Assert.Contains("riavvio", text);
|
||||
Assert.Contains("## Controlli del lavoro", text);
|
||||
}
|
||||
finally
|
||||
{
|
||||
TempFolder.Delete(logs);
|
||||
}
|
||||
|
||||
// Thirty days later the old rows go, once a day.
|
||||
clock.Set(Start.AddDays(31));
|
||||
await sampler.TakeAsync(SampleKinds.Periodic, CancellationToken.None).ConfigureAwait(false);
|
||||
Assert.AreEqual(1L, await test.Db.ReadAsync(s => s.CountAsync("SELECT COUNT(*) FROM diagnostic_samples")).ConfigureAwait(false));
|
||||
Assert.AreEqual(0L, await test.Db.ReadAsync(s => s.CountAsync("SELECT COUNT(*) FROM job_runs")).ConfigureAwait(false));
|
||||
}
|
||||
|
||||
[TestMethod]
|
||||
[TestCategory(Category.Integration)]
|
||||
public async Task TheReportDownloadNeedsASessionAndCoversTheStart()
|
||||
{
|
||||
await using var server = await ServerHarness.StartAsync("docker", ServerHarness.DockerSqlite());
|
||||
using (var anonymous = await server.GetAsync("/api/diagnostica.md"))
|
||||
{
|
||||
Assert.AreEqual(HttpStatusCode.Unauthorized, anonymous.StatusCode);
|
||||
}
|
||||
|
||||
await server.SignInFirstTimeAsync();
|
||||
using var report = await server.GetAsync("/api/diagnostica.md?ore=2");
|
||||
Assert.AreEqual(HttpStatusCode.OK, report.StatusCode);
|
||||
Assert.AreEqual("text/markdown", report.Content.Headers.ContentType?.MediaType);
|
||||
var text = await report.Content.ReadAsStringAsync();
|
||||
Assert.Contains("# Anubis · dati per l'analisi", text);
|
||||
Assert.Contains("- Piattaforma: docker", text);
|
||||
Assert.Contains("| " + AnubisInfo.Version + " |", text, "The start sample of the running process is in the report.");
|
||||
Assert.Contains("Scarica i dati per l'analisi", await server.TextAsync("/diario"));
|
||||
}
|
||||
|
||||
private static ProcessSample Sample(DateTimeOffset at, DateTimeOffset process, double megabytes, int i) => new()
|
||||
{
|
||||
TakenAt = at,
|
||||
ProcessStartedAt = process,
|
||||
Kind = SampleKinds.Periodic,
|
||||
WorkingSet = (long)(megabytes * 1048576),
|
||||
PrivateBytes = (long)(megabytes * 1048576),
|
||||
ManagedHeap = 80L * 1048576,
|
||||
GcCommitted = 100L * 1048576,
|
||||
Gen0 = i * 4,
|
||||
Gen1 = i,
|
||||
Gen2 = i / 10,
|
||||
GcPauseMs = i * 1.5,
|
||||
Threads = 30,
|
||||
Handles = 600,
|
||||
CpuMs = i * 3000,
|
||||
PoolThreads = 8,
|
||||
Exceptions = i * 2,
|
||||
DbBytes = 10L * 1048576 + i * 4096,
|
||||
};
|
||||
|
||||
private static long[] Bucketed(double milliseconds, long count = 1)
|
||||
{
|
||||
var buckets = new long[HttpCallStats.Bounds.Count + 1];
|
||||
buckets[HttpCallStats.Bounds.TakeWhile(b => b < milliseconds).Count()] = count;
|
||||
return buckets;
|
||||
}
|
||||
}
|
||||
@@ -18,6 +18,7 @@ return command switch
|
||||
"hooks" => Step("Attivazione dell'hook pre-commit (.githooks)", "git", ["config", "core.hooksPath", ".githooks"]) ?? 0,
|
||||
"seed-demo" => Run("dotnet", ["run", "--project", "src/Anubis.Server", "-c", "Release", "--", "--demo", .. rest]),
|
||||
"screenshots" => Screenshots(rest),
|
||||
"release-win" => ReleaseWindows(),
|
||||
"desktop-win" => NotYet("desktop-win", 10),
|
||||
_ => Help(),
|
||||
};
|
||||
@@ -182,6 +183,41 @@ static int FreePort()
|
||||
return port;
|
||||
}
|
||||
|
||||
// The zip of a trial release for Windows (ADR 0013, point 6): the server, a start script and the instructions, before
|
||||
// the Phase 10 installer exists. It needs the ASP.NET Core 10 runtime on the computer.
|
||||
int ReleaseWindows()
|
||||
{
|
||||
var props = File.ReadAllText(Path.Combine(root, "Directory.Build.props"));
|
||||
var start = props.IndexOf("<Version>", StringComparison.Ordinal) + "<Version>".Length;
|
||||
var version = props[start..props.IndexOf("</Version>", start, StringComparison.Ordinal)];
|
||||
var name = $"anubis-{version}-win-x64";
|
||||
var output = Path.Combine(root, "artifacts", "release");
|
||||
var folder = Path.Combine(output, name);
|
||||
if (Directory.Exists(folder))
|
||||
{
|
||||
Directory.Delete(folder, recursive: true);
|
||||
}
|
||||
|
||||
var failed = Step($"Pubblicazione del server {version} per Windows", "dotnet",
|
||||
["publish", "src/Anubis.Server", "-c", "Release", "-r", "win-x64", "--self-contained", "false", "-o", folder]);
|
||||
if (failed is { } code)
|
||||
{
|
||||
return code;
|
||||
}
|
||||
|
||||
foreach (var file in Directory.EnumerateFiles(Path.Combine(root, "deploy", "windows")))
|
||||
{
|
||||
File.Copy(file, Path.Combine(folder, Path.GetFileName(file)), overwrite: true);
|
||||
}
|
||||
|
||||
var zip = Path.Combine(output, name + ".zip");
|
||||
File.Delete(zip);
|
||||
System.IO.Compression.ZipFile.CreateFromDirectory(folder, zip, System.IO.Compression.CompressionLevel.Optimal, includeBaseDirectory: true);
|
||||
Console.WriteLine();
|
||||
Console.WriteLine($"== Pronto: {zip} ({(new FileInfo(zip).Length / 1048576.0).ToString("0.0", CultureInfo.InvariantCulture)} MB)");
|
||||
return 0;
|
||||
}
|
||||
|
||||
int NotYet(string name, int phase)
|
||||
{
|
||||
Console.Error.WriteLine($"'tasks {name}' arriva nella Fase {phase.ToString(CultureInfo.InvariantCulture)}.");
|
||||
@@ -200,6 +236,7 @@ int Help()
|
||||
tasks hooks attiva l'hook che esegue check prima di ogni commit
|
||||
tasks seed-demo avvia la modalità dimostrativa (dati dell'appendice F, database a parte)
|
||||
tasks screenshots fotografa le schermate dimostrative a 1440 e 390 pixel
|
||||
tasks release-win zip di prova per Windows in artifacts/release (ADR 0013)
|
||||
tasks desktop-win installatore Windows (Fase 10)
|
||||
""");
|
||||
return command == "help" ? 0 : 1;
|
||||
|
||||
Reference in new issue
Block a user