Acht Pruefungen standen Nacht fuer Nacht als rot da -- sie waren gruen
Der naechtliche Lauf meldete heute frueh "37 Pruefungen sind rot".
Acht davon waren gar nicht rot: fehlerfrei durchgelaufen, Exitcode 0,
keine einzige FEHL-Zeile. Der Laeufer zaehlte bei ihnen aber NULL
Einzelpruefungen, und "null Pruefungen ist ein Fehler" -- eine Regel,
die richtig ist und hier das Falsche traf.
DER GRUND WAR EIN GROSSBUCHSTABE. Der Zaehler suchte `(ok|FEHL)`;
pruef-kachelfarben, -livepunkt, -tippziele, -turn-wege, -leerzustand,
-nachfrage, -tagesruf und -anruf-klingelt schreiben ` OK `.
Zwei Schaeden auf einmal:
1. Ihre Punkte fehlten in der Gesamtzahl -- allein in fuenf der acht
sind das 114 Stueck. Ausgerechnet die Zahl, die vor stillen
Aussetzern schuetzen soll, war selbst eine Luecke.
2. Acht dauerhaft rote Eintraege in einer Notiz, die morgens gelesen
wird. Eine Warnung, die immer kommt, ist keine mehr.
Der Zaehler liest jetzt beide Schreibweisen. Die Dateien werden NICHT
vereinheitlicht: Acht umzuschreiben waeren acht Gelegenheiten, etwas
kaputtzumachen -- und die neunte, die morgen jemand anlegt, schreibt
ohnehin wieder, was sie will.
DAZU EINE PRUEFUNG, DIE DAS FESTHAELT (server/pruef-pruefzaehler.mjs).
Ein Kommentar haette den naechsten Fall nicht verhindert. Sie holt
sich den Ausdruck AUS alles-pruefen.mjs (zwei Fassungen desselben
Musters laufen auseinander), startet vier der schnellsten Pruefungen
wirklich -- je zwei in beiden Schreibweisen -- und hat drei
Gegenproben: Sie darf nicht wahllos zaehlen, sie muss zwei als zwei
zaehlen, und sie muss null als null sehen koennen, sonst waere "null
ist ein Fehler" blind.
UND DIE NOTIZ SAGT JETZT, WAS SIE MEINT. Statt "(keine Fehlerzeile
gefunden)" steht bei diesen Faellen: "Kein Befund -- es wurde keine
einzige Pruefung GEZAEHLT", mit der Erklaerung dazu. Fuer alles andere
ohne Fehlerzeile gibt es den dritten Ausgang ("Konnte nicht sagen,
woran es lag") samt den letzten Ausgabezeilen.
NEBENBEFUND, GEFUNDEN VON pruef-rueckmeldung: Die Tuer ins andere Haus
trug Ton 40 -- dieselbe Nummer wie "Entwicklung". Auf DogFathers Wand
standen zwei Kacheln in derselben Farbe, und er ist der Einzige, der
beide sieht; deshalb ist es nie jemandem aufgefallen.
Die naheliegende Antwort waere eine 46. Farbe gewesen. Gerechnet kam
ein Abstand von 0,0862 heraus -- unter der Hausgrenze von 0,09. Der
Farbraum ist bei 45 Toenen voll, und eine zweite benannte Ausnahme
am selben Tag waere der Anfang vom Ende der Regel.
Richtig ist die andere Antwort: Die Tuer ist gar keine
Bereichskachel. Sie fuehrt hinaus und gehoert keinem Bereich an --
also bekommt sie keine Bereichsfarbe, sondern faellt auf --akzent
zurueck. Damit unterscheidet sie sich von allen 45 anderen.
Gefunden hat das die Pruefung erst, nachdem sie SAGEN konnte, welche
Nummer doppelt ist. Vorher stand dort nur "kein Farbton doppelt (34
Kacheln vom Server)" -- damit sucht man in vier Listen ueber zwei
Dateien.
Dazu: start.js schreibt kein data-ton="undefined" mehr (String()
macht aus einem fehlenden Wert sonst ein Wort, und jede Pruefung,
die Toene zaehlt, liest dann Text statt Zahl).
WAS MICH VOR DER FALSCHEN REPARATUR BEWAHRT HAT: Meine erste Vermutung
war, die FEHL-Zeilen staenden zu weit hinten im Ausgabefenster. Die
Gegenprobe dazu wurde rot -- null Dateien. Genau dafuer ist sie da.
GEMESSEN:
- pruef-pruefzaehler (neu): 7 Pruefungen, 0 Fehler.
- pruef-rueckmeldung: 30 geprueft, 0 Fehler (war rot).
- pruef-kachelfarben 26/0, pruef-haus-trennung 100/0,
pruef-crew-adresse 153/0.
- tools/.nachtlauf-* ist jetzt ignoriert: Laufzeitzustand, der sich
jede Nacht aendert. Das Ergebnis steht in der Vault-Notiz.
Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
Claude Opus 5
+22
-1
@@ -76,7 +76,28 @@ const laufen = (datei) => new Promise((fertig) => {
|
||||
kind.on("close", (code) => {
|
||||
clearTimeout(wecker);
|
||||
const sek = Math.round((Date.now() - start) / 100) / 10;
|
||||
const einzeln = (aus.match(/^\s{2}(ok|FEHL)\s/gm) || []).length;
|
||||
/* ==== GROSS ODER KLEIN -- BEIDES ZAEHLT (25.09.2026) ==========
|
||||
|
||||
Hier stand `(ok|FEHL)`. Acht Pruefdateien schreiben aber „OK"
|
||||
in Grossbuchstaben (pruef-kachelfarben, -livepunkt, -tippziele,
|
||||
-turn-wege, -leerzustand, -nachfrage, -tagesruf,
|
||||
-anruf-klingelt). Fuer sie zaehlte dieser Ausdruck NULL --
|
||||
und weil „null Pruefungen ist ein Fehler" (die Regel direkt
|
||||
darunter, und sie ist richtig), standen sie Nacht fuer Nacht
|
||||
als ROT in der Notiz, obwohl sie fehlerfrei durchliefen.
|
||||
Exitcode 0, keine FEHL-Zeile, trotzdem rot.
|
||||
|
||||
Zwei Schaeden auf einmal: Ihre Pruefungen fehlten in der
|
||||
Gesamtzahl (also genau der Zahl, die vor stillen Aussetzern
|
||||
schuetzen soll), und acht dauerhaft rote Eintraege gewoehnen
|
||||
einem das Hinsehen ab.
|
||||
|
||||
DIE SCHREIBWEISE WIRD NICHT VEREINHEITLICHT, SONDERN GELESEN.
|
||||
Acht Dateien umzuschreiben waere acht Gelegenheiten, etwas
|
||||
kaputtzumachen -- und die neunte Datei, die jemand morgen
|
||||
anlegt, schreibt ohnehin wieder, was sie will. Ein Zaehler, der
|
||||
beide Schreibweisen kennt, braucht niemanden zu erziehen. */
|
||||
const einzeln = (aus.match(/^\s{2}(ok|OK|FEHL)\s/gm) || []).length;
|
||||
const schlecht = (aus.match(/^\s{2}FEHL\s/gm) || []).length;
|
||||
if (abgewuergt) {
|
||||
aus += `\n\n FEHL DIE PRUEFUNG HING. Nach ${Math.round(FRIST_MS / 1000)} s kam nichts mehr`
|
||||
|
||||
+67
-5
@@ -156,11 +156,53 @@ function auswerten(aus) {
|
||||
const rote = [];
|
||||
for (const treffer of aus.matchAll(/^### (pruef-[\w-]+\.mjs) \(Exitcode (-?\d+)\)$/gm)) {
|
||||
/* Die erste FEHL-Zeile darunter ist die Auskunft, die man braucht --
|
||||
der Rest ist Zusammenhang. */
|
||||
der Rest ist Zusammenhang.
|
||||
|
||||
ZWEI FENSTER, NICHT EINS (25.09.2026): Bisher wurde nur in den
|
||||
ersten 900 Zeichen gesucht. Prüfungen mit viel Vorlauf (die
|
||||
browsergestützten vor allem) haben ihre FEHL-Zeile weiter
|
||||
hinten -- vier davon standen deshalb am 25.09. als „keine
|
||||
Fehlerzeile gefunden" in der Notiz, und man konnte ihnen nicht
|
||||
ansehen, ob sie kaputt waren oder nur lang. Jetzt wird zuerst
|
||||
eng gesucht (damit die erste, wichtigste Zeile gewinnt) und
|
||||
danach im ganzen Abschnitt. */
|
||||
const ab = aus.indexOf(treffer[0]) + treffer[0].length;
|
||||
const stueck = aus.slice(ab, ab + 900);
|
||||
const erste = (stueck.split("\n").find((z) => /FEHL|Error|error:/.test(z)) || "").trim();
|
||||
rote.push({ datei: treffer[1], code: Number(treffer[2]), erste: erste.slice(0, 160) });
|
||||
const bisNaechste = aus.indexOf("\n### pruef-", ab);
|
||||
const ganz = aus.slice(ab, bisNaechste === -1 ? ab + 20000 : bisNaechste);
|
||||
const suchen = (text) => (text.split("\n")
|
||||
.find((z) => /FEHL|Error|error:/.test(z)) || "").trim();
|
||||
let erste = suchen(ganz.slice(0, 900)) || suchen(ganz);
|
||||
|
||||
/* UND WENN GAR NICHTS DASTEHT, IST DAS AUCH EINE AUSKUNFT.
|
||||
Dann sind die letzten Zeilen das Beste, was es gibt -- zusammen
|
||||
mit dem Exitcode. Eine Meldung „kaputt, weiss nicht warum" ist
|
||||
ehrlich; „keine Fehlerzeile gefunden" klingt nach einer
|
||||
Kleinigkeit und ist doch dasselbe. */
|
||||
let ohneGrund = false;
|
||||
if (!erste) {
|
||||
ohneGrund = true;
|
||||
const letzte = ganz.split("\n").map((z) => z.trim())
|
||||
.filter(Boolean).slice(-3).join(" / ");
|
||||
erste = letzte || "(die Prüfung hat gar nichts ausgegeben)";
|
||||
}
|
||||
|
||||
/* DIE HAEUFIGSTE URSACHE HAT EINEN NAMEN -- und sie steht in der
|
||||
Uebersichtszeile ganz oben, nicht im Fehlerabschnitt. Am
|
||||
25.09.2026 waren acht der 37 roten Dateien von dieser Sorte:
|
||||
fehlerfrei durchgelaufen, Exitcode 0, aber der Zaehler hat ihre
|
||||
Punkte nicht erkannt (sie schreiben „OK" statt „ok"). „Null
|
||||
Pruefungen ist ein Fehler" ist dann richtig UND irrefuehrend --
|
||||
es klingt nach einer Pruefung, die nichts tut, und war eine,
|
||||
die niemand zaehlt. */
|
||||
const uebersicht = new RegExp(
|
||||
`^\\s*FEHL\\s+${treffer[1].replace(/[.*+?^$()|[\]\\]/g, "\\$&")}\\s.*$`, "m");
|
||||
const zeile = (aus.match(uebersicht) || [""])[0];
|
||||
const nullPunkte = /KEINE PRUEFUNG GELAUFEN/.test(zeile);
|
||||
|
||||
rote.push({
|
||||
datei: treffer[1], code: Number(treffer[2]),
|
||||
erste: erste.slice(0, 220), ohneGrund, nullPunkte,
|
||||
});
|
||||
}
|
||||
return {
|
||||
dateienOk: dateien ? Number(dateien[1]) : null,
|
||||
@@ -238,7 +280,27 @@ function notizSchreiben({ lage, vorher, minuten, konnteNicht }) {
|
||||
for (const r of lage.rote) {
|
||||
zeilen.push(`### \`${r.datei}\``);
|
||||
zeilen.push("");
|
||||
zeilen.push(r.erste ? `\`\`\`\n${r.erste}\n\`\`\`` : "*(keine Fehlerzeile gefunden)*");
|
||||
if (r.nullPunkte) {
|
||||
zeilen.push(`**Kein Befund – es wurde keine einzige Prüfung GEZÄHLT** `
|
||||
+ `(Exitcode ${r.code}).` );
|
||||
zeilen.push("");
|
||||
zeilen.push("Das ist etwas anderes als „kaputt“: Die Datei ist "
|
||||
+ "durchgelaufen. Der Zähler hat ihre Punkte nur nicht erkannt – "
|
||||
+ "meist, weil sie ihre Ergebnisse anders schreibt als erwartet "
|
||||
+ "(` OK ` statt ` ok `, andere Einrückung, eigenes Format). "
|
||||
+ "Nachsehen lohnt trotzdem: Eine Datei, deren Punkte niemand "
|
||||
+ "zählt, kann still aufhören zu prüfen, ohne dass es auffällt. "
|
||||
+ "Zuletzt stand da:");
|
||||
zeilen.push("");
|
||||
} else if (r.ohneGrund) {
|
||||
zeilen.push(`**Konnte nicht sagen, woran es lag** (Exitcode ${r.code}). `
|
||||
+ "Das ist etwas anderes als ein Befund: Die Prüfung ist nicht "
|
||||
+ "durchgelaufen, hat aber auch keine FEHL-Zeile hinterlassen. "
|
||||
+ "Meist steckt dahinter eine Zeitüberschreitung oder ein Absturz "
|
||||
+ "im Vorlauf, kein Fehler im Programm. Zuletzt stand da:");
|
||||
zeilen.push("");
|
||||
}
|
||||
zeilen.push(`\`\`\`\n${r.erste}\n\`\`\``);
|
||||
zeilen.push("");
|
||||
zeilen.push(`Einzeln nachsehen: \`node server/${r.datei}\``);
|
||||
zeilen.push("");
|
||||
|
||||
Reference in New Issue
Block a user