Discord-bot statistiekenpaneel: serveraantal en metrics

Een Discord-bot statistieken-paneel laat je in één oogopslag zien in hoeveel servers je bot zit, hoeveel gebruikers hij bedient en welke commando's het vaakst draaien. Deze metrics zijn van onschatbare waarde, zowel om de groei van je bot te volgen als om te begrijpen welke functies mensen echt gebruiken. In dit artikel laat ik stap voor stap zien hoe je gebruiksmetrics verzamelt, opslaat en toont met discord.js, te beginnen met de meest fundamentele: het serveraantal.

Welke metrics moet je volgen?

In plaats van elk mogelijk getal te verzamelen, richt je je op die welke beslissingen sturen. Voor de meeste bots zijn deze kernmetrics genoeg:

• Server- (guild-)aantal — het totale aantal servers waarin je bot zit. Het meest directe teken van groei.
• Totaal aantal gebruikers — het geschatte publiek dat je bereikt (de som van de ledenaantallen).
• Commandogebruik — hoe vaak elk slash-commando is uitgevoerd.
• Actieve servers — servers die in de afgelopen 24 uur minstens één commando hebben gedraaid.
• Shard-status — zodra de bot groeit, de latentie en uptime van elke shard.

Let op privacy: sla nooit gevoelige gegevens op zoals berichtinhoud. Getallen zijn genoeg voor statistieken; de inhoud is niet nodig.

Het serveraantal real-time uitlezen

De meest basale metric, het serveraantal, komt rechtstreeks uit client.guilds.cache in discord.js. Je kunt het uitlezen wanneer de bot klaar is en het bijwerken telkens als de bot een server betreedt of verlaat:

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} in ${serverCount} servers, ~${userCount} gebruikers`);
});

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

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

client.login(process.env.DISCORD_TOKEN);

Het veld memberCount geeft het totale ledenaantal van een server zonder een extra intent of het ophalen van de volledige ledenlijst, wat het ideaal en snel maakt om je gebruikersbereik te schatten.

Commandogebruik registreren

Om te weten welke commando's waardevol zijn, moet je elke uitvoering ergens persistent wegschrijven. Je kunt een eenvoudige teller bijhouden in je slash-commandohandler. In het voorbeeld hieronder duwen we elke commando-aanroep naar een database:

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

  // Voer het commando uit...
  const command = commands.get(interaction.commandName);
  if (command) await command.execute(interaction);

  // Registreer de metric (zonder te blokkeren)
  recordUsage(interaction.commandName, interaction.guildId)
    .catch(console.error);
});

Het wegschrijven van de metric mag het antwoord van het commando niet vertragen. Daarom dragen we het over aan een aparte functie zonder await en vangen we de fout op. Voor opslag is SQLite prima voor kleine bots, terwijl PostgreSQL of Redis (voor snelle tellers) logisch worden naarmate je groeit.

De data opslaan: een eenvoudig schema

Een sobere opzet met twee tabellen is meestal genoeg voor statistieken. Eén tabel voor momentopnames (snapshots) in de tijd, één voor commandotellers:

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'))
);

Elke uur of eens per dag een rij aan de snapshot-tabel toevoegen laat je het serveraantal door de tijd heen uitzetten. Dat kan met een eenvoudig interval:

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);

Het paneel uitleveren: een kleine API en UI

Zodra je de data verzamelt, is een minieme HTTP-server genoeg om ze in een paneel te tonen. Met Express kun je een endpoint blootstellen dat JSON teruggeeft en het aan de voorkant als eenvoudige kaarten renderen:

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);

Aan de voorkant kun je dit endpoint elke paar seconden fetchen en de getallen bijwerken om een live gevoel te geven. Voor een historische grafiek voer je simpelweg de data uit stat_snapshots in een lijngrafiekbibliotheek zoals Chart.js. Is het paneel openbaar, bescherm dan alle schrijf-endpoints en toon alleen alleen-lezen statistieken aan het publiek.

Totalen tellen op een geshardde bot

Wanneer je bot groeit en overgaat op sharding, ziet elke shard alleen zijn eigen servers. Voor een nauwkeurig totaal moet je over alle shards aggregeren. De klasse ShardingManager van discord.js maakt dit makkelijk:

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

Deze aanroep vraagt elke shard en geeft een array terug die je optelt. Voor berekende waarden zoals het gebruikersaantal gebruik je broadcastEval. Je hoeft sharding niet vroeg op te zetten, maar je paneel vanaf het begin rond aggregatie ontwerpen maakt de latere migratie veel soepeler.

Veelgestelde vragen

Kan ik het serveraantal in de status van de bot tonen?

Ja. Met client.user.setActivity kun je tekst tonen zoals "in X servers". Werk het bij op join/leave-events of om de paar minuten; te vaak bijwerken kan tegen rate limits aanlopen.

Is het gebruikersaantal exact?

memberCount geeft het totale aantal leden dat een server rapporteert, maar dezelfde persoon kan in meerdere van je servers zitten; het is dus een "bereik"-schatting en geen telling van unieke gebruikers. Unieke gebruikers tellen is veel duurder en meestal onnodig.

Welke database moet ik kiezen?

Tot een paar honderd servers is SQLite ruim voldoende en vergt nul installatie. Naarmate je groeit, stap je over op PostgreSQL, en gebruik je Redis voor zeer hoogfrequente tellers.

Wil je een professioneel statistiekenpaneel voor je bot? Van serveraantal tot commando-analyse: ik bouw de metrics-pijplijn en ontwerp het live paneel. Neem contact op en begin je bot met data te sturen.