Panneau de statistiques de bot Discord : nombre de serveurs

Un panneau de statistiques de bot Discord vous permet de voir d'un coup d'œil dans combien de serveurs se trouve votre bot, combien d'utilisateurs il sert et quelles commandes sont le plus exécutées. Ces métriques sont précieuses à la fois pour suivre la croissance de votre bot et pour comprendre quelles fonctionnalités sont réellement utilisées. Dans cet article, je vous montre comment collecter, stocker et afficher des métriques d'utilisation avec discord.js, en commençant par la plus fondamentale : le nombre de serveurs.

Quelles métriques suivre ?

Plutôt que de collecter chaque chiffre possible, concentrez-vous sur ceux qui éclairent vos décisions. Pour la plupart des bots, ces métriques de base suffisent :

• Nombre de serveurs (guilds) — le total de serveurs où se trouve votre bot. Le signe le plus direct de croissance.
• Nombre total d'utilisateurs — l'audience approximative que vous touchez (la somme des membres des serveurs).
• Utilisation des commandes — combien de fois chaque commande slash a été exécutée.
• Serveurs actifs — les serveurs ayant lancé au moins une commande au cours des dernières 24 heures.
• État des shards — une fois le bot agrandi, la latence et l'uptime de chaque shard.

Attention à la confidentialité : ne stockez jamais de données sensibles comme le contenu des messages. Les chiffres suffisent pour les statistiques ; le contenu n'est pas nécessaire.

Lire le nombre de serveurs en temps réel

La métrique la plus basique, le nombre de serveurs, provient directement de client.guilds.cache dans discord.js. Vous pouvez la lire lorsque le bot est prêt et la mettre à jour à chaque fois qu'il rejoint ou quitte un serveur :

const { Client, GatewayIntentBits, Events } = require('discord.js');

const client = new Client({ intents: [GatewayIntentBits.Guilds] });

client.once(Events.ClientReady, (c) => {
  const serverCount = c.guilds.cache.size;
  const userCount = c.guilds.cache.reduce(
    (acc, g) => acc + g.memberCount, 0
  );
  console.log(`${c.user.tag} dans ${serverCount} serveurs, ~${userCount} utilisateurs`);
});

client.on(Events.GuildCreate, (guild) => {
  console.log(`Rejoint : ${guild.name} (${guild.memberCount})`);
});

client.on(Events.GuildDelete, (guild) => {
  console.log(`Quitté : ${guild.name}`);
});

client.login(process.env.DISCORD_TOKEN);

Le champ memberCount donne le total des membres d'un serveur sans nécessiter d'intent supplémentaire ni de récupérer la liste complète des membres, ce qui le rend idéal et rapide pour estimer votre portée utilisateur.

Enregistrer l'utilisation des commandes

Pour savoir quelles commandes sont précieuses, vous devez écrire chaque exécution dans un endroit persistant. Vous pouvez tenir un simple compteur dans votre gestionnaire de commandes slash. Dans l'exemple ci-dessous, nous poussons chaque appel de commande vers une base de données :

client.on(Events.InteractionCreate, async (interaction) => {
  if (!interaction.isChatInputCommand()) return;

  // Exécuter la commande...
  const command = commands.get(interaction.commandName);
  if (command) await command.execute(interaction);

  // Enregistrer la métrique (sans bloquer)
  recordUsage(interaction.commandName, interaction.guildId)
    .catch(console.error);
});

L'écriture de la métrique ne doit pas ralentir la réponse de la commande. C'est pourquoi nous la déléguons à une fonction distincte sans await, en capturant l'erreur. Pour le stockage, SQLite convient parfaitement aux petits bots, tandis que PostgreSQL ou Redis (pour des compteurs rapides) ont du sens à mesure que vous grandissez.

Stocker les données : un schéma simple

Une structure sobre à deux tables suffit généralement pour les statistiques. Une table pour les instantanés (snapshots) dans le temps, une pour les compteurs de commandes :

CREATE TABLE stat_snapshots (
  id          INTEGER PRIMARY KEY,
  server_count INTEGER NOT NULL,
  user_count   INTEGER NOT NULL,
  recorded_at  TEXT NOT NULL DEFAULT (datetime('now'))
);

CREATE TABLE command_usage (
  command   TEXT NOT NULL,
  guild_id  TEXT,
  used_at   TEXT NOT NULL DEFAULT (datetime('now'))
);

Ajouter une ligne à la table des snapshots chaque heure ou une fois par jour vous permet de tracer le nombre de serveurs dans le temps. Vous pouvez le faire avec un simple intervalle :

const ONE_HOUR = 60 * 60 * 1000;

setInterval(() => {
  const servers = client.guilds.cache.size;
  const users = client.guilds.cache.reduce(
    (a, g) => a + g.memberCount, 0
  );
  db.run(
    'INSERT INTO stat_snapshots (server_count, user_count) VALUES (?, ?)',
    [servers, users]
  );
}, ONE_HOUR);

Publier le panneau : une petite API et une interface

Une fois les données collectées, un minuscule serveur HTTP suffit pour les afficher dans un panneau. Avec Express, vous pouvez exposer un point de terminaison qui renvoie du JSON et le rendre sous forme de simples cartes côté front :

const express = require('express');
const app = express();

app.get('/api/stats', (req, res) => {
  res.json({
    servers: client.guilds.cache.size,
    users: client.guilds.cache.reduce((a, g) => a + g.memberCount, 0),
    uptime: Math.floor(client.uptime / 1000),
    ping: client.ws.ping,
  });
});

app.listen(3000);

Côté front, vous pouvez fetch ce point de terminaison toutes les quelques secondes et mettre à jour les chiffres pour donner une sensation en direct. Pour un graphique historique, alimentez simplement les données de stat_snapshots dans une bibliothèque de graphiques en courbes comme Chart.js. Si le panneau est public, protégez tout point d'écriture et n'exposez que des statistiques en lecture seule.

Compter les totaux sur un bot shardé

Lorsque votre bot grandit et passe au sharding, chaque shard ne voit que ses propres serveurs. Pour un total exact, vous devez agréger sur l'ensemble des shards. La classe ShardingManager de discord.js facilite cela :

const total = await client.shard.fetchClientValues('guilds.cache.size');
const serverCount = total.reduce((acc, n) => acc + n, 0);

Cet appel interroge chaque shard et renvoie un tableau que vous additionnez. Pour les valeurs calculées comme le nombre d'utilisateurs, vous utilisez broadcastEval. Inutile de mettre en place le sharding tôt, mais concevoir votre panneau autour de l'agrégation dès le départ rend la migration future bien plus fluide.

Questions fréquentes

Puis-je afficher le nombre de serveurs dans le statut du bot ?

Oui. Avec client.user.setActivity, vous pouvez afficher un texte comme « dans X serveurs ». Mettez-le à jour lors des événements d'arrivée/départ ou toutes les quelques minutes ; une mise à jour trop fréquente peut atteindre les limites de débit.

Le nombre d'utilisateurs est-il exact ?

memberCount donne le total des membres rapporté par un serveur, mais la même personne peut se trouver dans plusieurs de vos serveurs ; c'est donc une estimation de « portée » et non un décompte d'utilisateurs uniques. Compter les utilisateurs uniques est bien plus coûteux et généralement inutile.

Quelle base de données choisir ?

Jusqu'à quelques centaines de serveurs, SQLite est largement suffisant et ne demande aucune configuration. En grandissant, passez à PostgreSQL, et utilisez Redis pour des compteurs à très haute fréquence.

Vous voulez un panneau de statistiques professionnel pour votre bot ? Du nombre de serveurs à l'analyse des commandes, je construis le pipeline de métriques et conçois le panneau en direct. Contactez-moi et commencez à piloter votre bot avec des données.