Rapports automatisés avec Grafana

graph TD
    A[Données Zabbix] --> B[Grafana Server]
    B --> C[Moteur de rapports]
    C --> D[Génération PDF/Images]
    D --> E[Système d'envoi]
    E --> F[Email automatique]
    F --> G[Destinataires configurés]

// Structure d'un rapport Grafana
interface GrafanaCreateReportParams {
  nameAndSubject: string;           // "Rapport Mensuel - [Parc]"
  additionalRecipientEmail: string; // Email de l'utilisateur
  groupName: string;                // Nom du groupe Zabbix
  hostNames: string[];              // Liste des serveurs surveillés
  dashboardUid?: string;            // Dashboard Grafana utilisé
}

// Configuration du rapport PDF
const reportOptions = {
  orientation: "landscape",          // Format paysage
  layout: "grid",                   // Disposition en grille
  pdfShowTemplateVariables: false,  // Masquer les variables
  pdfCombineOneFile: true,          // Un seul fichier PDF
  scaleFactor: 2,                   // Haute résolution
  formats: ["pdf", "image"]         // PDF + images
};

// Configuration de la planification
const schedule = {
  startDate: now.toISOString(),     // Date de début
  endDate: null,                    // Pas de fin
  frequency: "monthly",             // Fréquence mensuelle
  workdaysOnly: false,              // Tous les jours
  dayOfMonth: "last",               // Dernier jour du mois
  timeZone: "Indian/Mauritius"      // Fuseau horaire
};

// Algorithme de calcul de la prochaine date
function calculateNextReportDate(frequency: string, dayOfMonth: string) {
  const now = new Date();
  const currentMonth = now.getMonth();
  const currentYear = now.getFullYear();
  
  if (frequency === "monthly" && dayOfMonth === "last") {
    // Dernier jour du mois
    const lastDay = new Date(currentYear, currentMonth + 1, 0);
    return now > lastDay 
      ? new Date(currentYear, currentMonth + 2, 0)  // Mois suivant
      : lastDay;                                     // Mois actuel
  }
}

// Format des destinataires
const recipients = `${baseRecipients};${additionalRecipientEmail}`;
 
// Exemple de configuration
const reportConfig = {
  recipients: "admin@logiserv.com;client@entreprise.com;technique@entreprise.com",
  replyTo: "contact@logiserv.app",
  subject: "Rapport Mensuel - MonParc",
  message: `Bonjour,
 
Vous trouverez en pièce jointe le rapport mensuel de surveillance de vos serveurs.
 
Bonne journée.
 
Logiserv`
};

// Algorithme de recherche de rapport par nom de parc
export async function grafanaFindReportByParcName(parcName: string) {
  const allReports = await grafanaGetAllReports();
  
  // Recherche par contenance du nom de parc
  let foundReport = allReports.find(report => 
    report.name.toLowerCase().includes(parcName.toLowerCase())
  );
  
  // Si non trouvé, tester les conventions communes
  if (!foundReport) {
    const commonFormats = [
      `Rapport Mensuel - ${parcName}`,
      `Rapport ${parcName}`,
      `Monthly Report - ${parcName}`
    ];
    
    foundReport = allReports.find(report =>
      commonFormats.some(format => 
        report.name.toLowerCase() === format.toLowerCase()
      )
    );
  }
  
  return foundReport;
}

// Mise à jour automatique lors de changements
export async function updateReportsWithDeletion(params: {
  parc: string;
  oldParcName: string | null;
  userEmail: string;
  zabbixHostNamesForParc: string[];
  grafanaReportId?: string;
}) {
  // Suppression de l'ancien rapport si le nom change
  if (oldParcName && oldParcName !== parc) {
    await deleteOldReport(oldParcName);
  }
  
  // Création/mise à jour du nouveau rapport
  await grafanaUpdateReport({
    reportId: grafanaReportId,
    groupName: parc,
    hostNames: zabbixHostNamesForParc
  });
}

// Gestion robuste des erreurs
async function getReportScheduleInfo(parcName: string) {
  try {
    const reportInfo = await grafanaFindReportByParcName(parcName);
    
    if (!reportInfo) {
      return {
        error: "Aucun rapport trouvé pour votre parc",
        recipients: [],
        nextScheduledDate: null
      };
    }
    
    return {
      reportId: reportInfo.reportId,
      recipients: reportInfo.recipients.split(';'),
      nextScheduledDate: calculateNextDate(reportInfo.schedule)
    };
  } catch (error) {
    return {
      error: "Erreur lors de la récupération des informations",
      recipients: [],
      nextScheduledDate: null
    };
  }
}

// Variables Grafana dynamiques
const reportVariables = {
  "Group": [groupName],     // Filtre par groupe Zabbix
  "Host": hostNames,        // Liste des serveurs
  "TimeRange": "now/M",     // Période mensuelle
  "Organization": parcName   // Nom de votre organisation
};

// Configuration du dashboard
const dashboardConfig = {
  dashboard: {
    uid: "uidparcserveurs",  // Dashboard dédié aux parcs
  },
  timeRange: {
    from: "now/M",           // Début du mois
    to: "now/M"              // Fin du mois
  },
  reportVariables: {
    "Group": [groupName],
    "Host": hostNames
  }
};

// Envoi automatique mensuel
export async function grafanaSendReportById(
  reportId: string, 
  useEmailsFromReport: boolean = true,
  emails?: string
) {
  const payload = {
    id: reportId,
    useEmailsFromReport,
    emails: emails || undefined
  };
  
  // Priorité Grafana Cloud, fallback standard
  if (GRAFANA_CLOUD_API_URL && GRAFANA_CLOUD_API_TOKEN) {
    return await callGrafanaCloudApi("POST", "/api/reports/email", payload);
  } else {
    return await callGrafanaApi("POST", "/api/reports/email", payload);
  }
}

// Alertes en cas de problème
if (reportSendFailed) {
  await sendAlert({
    type: "report_failure",
    parc: parcName,
    error: errorMessage,
    recipients: ["admin@logiserv.com"]
  });
}

-- Exemples de métriques calculées
SELECT 
  AVG(cpu_usage) as avg_cpu,
  MAX(memory_usage) as peak_memory,
  COUNT(alerts) as alert_count,
  SUM(downtime) as total_downtime
FROM monitoring_data 
WHERE timestamp BETWEEN start_of_month AND end_of_month
  AND host IN (hostNames)
GROUP BY host;