Grafana : les deux bases se consultent, et les requetes sont verifiees

Trois tableaux de bord provisionnes depuis git, sur le modele de la regle R2
(le depot est la source de verite, l'interface ne peut pas les ecraser) :

  La nuit      SOC reel contre SOC exige par le bilan, et la marge entre les
               deux. C'est la question qui avait demande une nuit d'archeologie
               le 03/09.
  Le solaire   l'excedent (§36), la censure, et le mode declare par chacun des
               sept chargeurs (§37) — le signal le plus direct dont on dispose.
  Prevision    l'ecart heure par heure, avec la bande de censure dessous : une
               production sous la prevision peut vouloir dire mauvaise
               prevision OU absence de preneur.

Les evenements de la table `evenement` deviennent des marqueurs verticaux sur
tous les graphiques — une courbe sans ses evenements ne s'interprete pas.

tools/verifier-dashboards.mjs rejoue CHAQUE requete pour de vrai (SQL contre
PostgreSQL, Flux contre InfluxDB, macros Grafana substituees), annotations
comprises puisqu'elles s'executent sur tous les panneaux. Sans lui une requete
cassee ne se voit qu'a l'ecran, panneau par panneau. 19/19 au deploiement.

Port 3001 et non 3000 : sonde avant d'ecrire la ligne, quelque chose ecoute
deja sur 3000 — la lecon du 5432 deja pris par le PostgreSQL de DSM.

Connexion PostgreSQL par le role evcs_lecture : un tableau de bord ne doit pas
pouvoir ecrire dans la memoire. Aucun secret duplique, aucun secret commite :
le provisionnement les reference par $VARIABLE depuis les deux .env.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KKzkkVTG6KXnGXFFC7X9XJ

tools/verifier-dashboards.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+// Verifie que CHAQUE requete des tableaux de bord Grafana s'execute vraiment.
+//
+// Grafana n'annonce une requete cassee qu'a l'ecran, panneau par panneau. Ce
+// controle rejoue les requetes SQL contre PostgreSQL et les requetes Flux
+// contre InfluxDB, avec les macros substituees comme Grafana le fait.
+//
+//   node tools/verifier-dashboards.mjs
+//
+// Sortie non nulle si une seule requete echoue.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import pg from 'pg';
+
+const env = Object.fromEntries(
+  fs.readFileSync('.env', 'utf8').split('\n').filter(l => l.includes('='))
+    .map(l => [l.slice(0, l.indexOf('=')).trim(), l.slice(l.indexOf('=') + 1).trim()]));
+
+const DEPUIS = new Date(Date.now() - 24 * 3600e3).toISOString();
+const JUSQUA = new Date().toISOString();
+
+// Les macros de Grafana, telles qu'il les developpe cote serveur.
+const macros = (q) => q
+  .replace(/\$__timeFilter\(([^)]+)\)/g, `$1 BETWEEN '${DEPUIS}' AND '${JUSQUA}'`)
+  .replace(/\$__timeFrom\(\)/g, `'${DEPUIS}'`)
+  .replace(/\$__timeTo\(\)/g, `'${JUSQUA}'`);
+
+const fluxVars = (q) => q
+  .replace(/v\.timeRangeStart/g, `${DEPUIS}`)
+  .replace(/v\.timeRangeStop/g, `${JUSQUA}`)
+  .replace(/v\.windowPeriod/g, '1m');
+
+const client = new pg.Client({
+  host: '10.10.10.22', port: 5433, database: 'evcs',
+  user: 'evcs_lecture', password: env.PG_LECTURE_PASSWORD });
+await client.connect();
+
+async function flux(q) {
+  const r = await fetch('http://10.10.10.22:8086/api/v2/query?org=airtria', {
+    method: 'POST',
+    headers: { Authorization: `Token ${env.INFLUXDB_TOKEN}`,
+               'Content-Type': 'application/vnd.flux', Accept: 'application/csv' },
+    body: q });
+  const t = await r.text();
+  if (!r.ok) throw new Error(t.slice(0, 300));
+  return t.split('\n').filter(l => l.includes(',_result,')).length;
+}
+
+const dossier = 'deploy/historisation/grafana/dashboards';
+let echecs = 0, total = 0;
+
+for (const f of fs.readdirSync(dossier).filter(f => f.endsWith('.json')).sort()) {
+  const d = JSON.parse(fs.readFileSync(path.join(dossier, f), 'utf8'));
+  console.log(`\n=== ${d.title}  (${f}) ===`);
+
+  // Les annotations sont des requetes comme les autres, et elles s'executent
+  // sur TOUS les panneaux : une annotation cassee casse tout le tableau.
+  const cibles = [];
+  for (const a of d.annotations.list) {
+    if (a.target?.rawSql) cibles.push({ ou: 'annotation ' + a.name, sql: a.target.rawSql });
+  }
+  for (const p of d.panels) {
+    for (const t of p.targets ?? []) {
+      if (t.rawSql) cibles.push({ ou: p.title, sql: t.rawSql });
+      else if (t.query) cibles.push({ ou: p.title, flux: t.query });
+    }
+  }
+
+  for (const c of cibles) {
+    total++;
+    try {
+      const n = c.sql ? (await client.query(macros(c.sql))).rows.length
+                      : await flux(fluxVars(c.flux));
+      const vide = n === 0 ? '  (aucune ligne sur 24 h — normal si la mesure vient de demarrer)' : '';
+      console.log(`  OK    ${String(n).padStart(5)} lignes   ${c.ou}${vide}`);
+    } catch (e) {
+      echecs++;
+      console.log(`  ECHEC              ${c.ou}\n         ${String(e.message).split('\n')[0]}`);
+    }
+  }
+}
+
+await client.end();
+console.log(`\n${total - echecs}/${total} requetes valides`);
+process.exit(echecs ? 1 : 0);