Discord-bot-stats

Discord-bot-stats is a cool Node.js package to have statistics graphs for your Discord Bot.

Example results

Documentation

Here is the updated documentation.

Installation

npm install discord-bot-stats
OR
yarn add discord-bot-stats

Example Usage with a local database enmap in javascript

npm i enmap
OR
yarn add enmap

Note: See more about enmap installation here.

Create a config.json.

{
    "token": "YOUR_BOT_TOKEN",
    "guildId": "YOUR_GUILD_ID",
    "clientId": "YOUR_CLIENT_ID"
}

Create a new file called deploycommands.js and paste the following code in it:

const { SlashCommandBuilder, Routes } = require("discord.js");
const { REST } = require("@discordjs/rest");
const { clientId, guildId, token } = require("./config.json");

const commands = [
    new SlashCommandBuilder().setName("ram").setDescription("Generates a beautiful graph for my bot ram usage.")
].map(command => command.toJSON());

const rest = new REST({ version: "10" }).setToken(token);

rest.put(Routes.applicationGuildCommands(clientId, guildId), { body: commands })
    .then(() => console.log("Successfully registered application commands."))
    .catch(console.error);

Create a new file called EnmapStatsManager.js and paste the following code in it:

const { StatsManager } = require("discord-bot-stats");

const Enmap = require("enmap");

module.exports = class extends StatsManager {
    constructor(options) {
        super(options);
        this.stats = new Enmap({ name: "stats" });
    }

    async deleteStats(timestamps) {
        for (const timestamp of timestamps) {
            this.stats.delete(timestamp.toString());
        }
        this.return;
    }

    async getStats() {
        return this.stats.fetchEverything().array();
    }

    async saveStats(stats) {
        this.stats.set(stats.timestamp.toString(), stats);
        return;
    }
};

Now create your bot main file index.js

// Require the necessary discord.js classes
const { Client, GatewayIntentBits } = require("discord.js");
const { token } = require("./config.json");
const { LineGraph } = require("discord-bot-stats");
const EnmapStatsManager = require("./EnmapStatsManager.js");

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

const statsManager = new EnmapStatsManager({
    enabledStats: {
        servers: true,
        users: true,
        ram: true
    }
});

// When the client is ready, run this code (only once)
client.once("ready", () => {
    console.log("Ready!");
    statsManager.start(async () => {
        return {
            stats: {
                servers: client.guilds.cache.size,
                users: client.users.cache.size,
                ram: process.memoryUsage().heapUsed / 1024 / 1024
            }
        };
    });
});

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

    const { commandName } = interaction;

    if (commandName === "line") {
        const graph = await new LineGraph(statsManager).generate("ram");
        await interaction.reply({
            files: [{ name: "graph.png", attachment: graph }]
        });
    }
});

// Login to Discord with your client's token
client.login(token);

Example Usage With MongoDB in typescript

npm i mongoose
OR
yarn add mongoose

Creates a first file named MongoStatsManager.ts

import { StatsManager } from "discord-bot-stats";
import mongoose from "mongoose";
import { SavedStatsFormat, StatsManagerOptions } from "discord-bot-stats/types/types";

const StatsSchema = new mongoose.Schema({
    timestamp: Number,
    stats: {
        cpu: Number,
        ram: Number,
        servers: Number,
        users: Number,
        commands: Map,
        errors: Number
    }
});

const StatsModel = mongoose.model("BotStats", StatsSchema);

export default class extends StatsManager {
    constructor(options: StatsManagerOptions) {
        super(options);
        this._connect();
    }

    async _connect() {
        await mongoose.connect("mongodb://localhost:27017/botstatsmodule");
    }

    async deleteStats(timestamps: number[]): Promise<void> {
        StatsModel.deleteMany({ timestamp: { $in: timestamps } }).exec();
        return;
    }

    async getStats(): Promise<SavedStatsFormat[]> {
        return StatsModel.find().lean().exec() as unknown as Promise<SavedStatsFormat[]>;
    }

    async saveStats(stats: SavedStatsFormat): Promise<void> {
        StatsModel.create(stats);
        return;
    }
}

Crate a second file named bot.ts

import { Client, GatewayIntentBits } from "discord.js";
import { LineGraph } from "discord-bot-stats";
import MongoStatsManager from "./MongoStatsManager";

// Create a new client instance
const client = new Client({
    intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent]
});

const statsManager = new MongoStatsManager({
    enabledStats: {
        cpu: true,
        ram: true,
        servers: true,
        commands: true
    }
});

// When the client is ready, run this code (only once)
client.once("ready", () => {
    console.log("Ready!");
    statsManager.start(async () => {
        const cmds = new Map()
            .set("ping", Math.floor(Math.random() * 12))
            .set("stats", Math.floor(Math.random() * 12))
            .set("lmao", Math.floor(Math.random() * 12))
            .set("trala", Math.floor(Math.random() * 12))
            .set("xxx", Math.floor(Math.random() * 12))
            .set("pitttng", Math.floor(Math.random() * 12));
        return {
            timestamp: Date.now(),
            stats: {
                cpu: 0.1,
                ram: Math.round((process.memoryUsage().heapUsed / 1024 / 1024) * 100) / 100,
                servers: client.guilds.cache.size,
                users: client.users.cache.size,
                commands: cmds
            }
        };
    });
});

client.on("messageCreate", async message => {
    if (message.author.bot) return;
    console.log(message.content);
    if (message.content.startsWith("+stats")) {
        const graph = await new LineGraph(statsManager).generate("ram");
        await message.channel.send({
            files: [
                {
                    attachment: graph
                }
            ]
        });
    }
});

// Login to Discord with your client's token
client.login(token);