Initial commit.

src/main/java/org/mobarena/stats/MobArenaStats.java

@@ -0,0 +1,24 @@
+package org.mobarena.stats;
+
+import org.mobarena.stats.store.StatsStore;
+import org.mobarena.stats.store.StatsStoreRegistry;
+
+import java.io.File;
+import java.util.concurrent.Executor;
+import java.util.logging.Logger;
+
+public interface MobArenaStats {
+
+    Logger getLogger();
+
+    Executor getSyncExecutor();
+
+    Executor getAsyncExecutor();
+
+    StatsStore getStatsStore();
+
+    StatsStoreRegistry getStatsStoreRegistry();
+
+    File getDataFolder();
+
+}

src/main/java/org/mobarena/stats/MobArenaStatsPlugin.java

@@ -0,0 +1,193 @@
+package org.mobarena.stats;
+
+import com.garbagemule.MobArena.MobArena;
+import com.garbagemule.MobArena.commands.CommandHandler;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.event.HandlerList;
+import org.bukkit.plugin.PluginManager;
+import org.mobarena.stats.command.ArenaStatsCommand;
+import org.mobarena.stats.command.DeleteSessionStatsCommand;
+import org.mobarena.stats.command.ExportCommand;
+import org.mobarena.stats.command.GlobalStatsCommand;
+import org.mobarena.stats.command.ImportCommand;
+import org.mobarena.stats.command.PlayerStatsCommand;
+import org.mobarena.stats.platform.AsyncBukkitExecutor;
+import org.mobarena.stats.platform.SyncBukkitExecutor;
+import org.mobarena.stats.session.SessionListener;
+import org.mobarena.stats.session.SessionStore;
+import org.mobarena.stats.store.StatsStore;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitScheduler;
+import org.mobarena.stats.store.StatsStoreRegistry;
+import org.mobarena.stats.store.csv.CsvStatsStore;
+import org.mobarena.stats.store.jdbc.JdbcStatsStore;
+import org.mobarena.stats.store.mariadb.MariadbStatsStore;
+import org.mobarena.stats.store.mysql.MysqlStatsStore;
+import org.mobarena.stats.store.sqlite.SqliteStatsStore;
+
+import java.io.File;
+import java.util.concurrent.Executor;
+import java.util.logging.Level;
+
+public class MobArenaStatsPlugin extends JavaPlugin implements MobArenaStats {
+
+    // The sad state of affairs is that MobArena's command framework has no
+    // support for registering commands by instance, but only by class, which
+    // means that we can't properly inject dependencies and have to resort to
+    // the Singleton Pattern.
+    private static MobArenaStats instance;
+
+    private StatsStoreRegistry statsStoreRegistry;
+
+    private Executor syncExecutor;
+    private Executor asyncExecutor;
+
+    private SessionStore sessionStore;
+    private StatsStore statsStore;
+    private SessionListener sessionListener;
+
+    @Override
+    public void onLoad() {
+        createStatsStoreRegistry();
+        registerStatsStoreFactories();
+    }
+
+    private void createStatsStoreRegistry() {
+        statsStoreRegistry = StatsStoreRegistry.create(this);
+    }
+
+    private void registerStatsStoreFactories() {
+        statsStoreRegistry.register("csv", CsvStatsStore::create);
+        statsStoreRegistry.register("jdbc", JdbcStatsStore::create);
+        statsStoreRegistry.register("sqlite", SqliteStatsStore::create);
+        statsStoreRegistry.register("mysql", MysqlStatsStore::create);
+        statsStoreRegistry.register("mariadb", MariadbStatsStore::create);
+    }
+
+    @Override
+    public void onEnable() {
+        setup();
+        reload();
+    }
+
+    private void setup() {
+        try {
+            instance = this;
+
+            createDataFolder();
+            createConfigFile();
+            setupExecutors();
+            setupCommands();
+        } catch (Exception up) {
+            // If setup fails, we can't recover, so throw up
+            throw new RuntimeException(up);
+        }
+    }
+
+    private void createDataFolder() {
+        File dir = getDataFolder();
+        if (!dir.exists()) {
+            if (!dir.mkdir()) {
+                throw new IllegalStateException("Failed to create plugin data folder!");
+            }
+            getLogger().info("Data folder created.");
+        }
+    }
+
+    private void createConfigFile() {
+        File file = new File(getDataFolder(), "config.yml");
+        if (!file.exists()) {
+            saveResource("config.yml", false);
+            getLogger().info("config.yml created.");
+        }
+    }
+
+    private void setupExecutors() {
+        BukkitScheduler scheduler = getServer().getScheduler();
+        if (syncExecutor == null) {
+            syncExecutor = new SyncBukkitExecutor(this, scheduler);
+        }
+        if (asyncExecutor == null) {
+            asyncExecutor = new AsyncBukkitExecutor(this, scheduler);
+        }
+    }
+
+    private void setupCommands() {
+        PluginManager manager = getServer().getPluginManager();
+        MobArena mobarena = (MobArena) manager.getPlugin("MobArena");
+
+        PluginCommand command = mobarena.getCommand("ma");
+        CommandHandler handler = (CommandHandler) command.getExecutor();
+
+        // User commands
+        handler.register(ArenaStatsCommand.class);
+        handler.register(GlobalStatsCommand.class);
+        handler.register(PlayerStatsCommand.class);
+
+        // Admin commands
+        handler.register(DeleteSessionStatsCommand.class);
+        handler.register(ExportCommand.class);
+        handler.register(ImportCommand.class);
+    }
+
+    private void reload() {
+        try {
+            createSessionStore();
+            loadStatsStore();
+            registerSessionListener();
+        } catch (Exception e) {
+            getLogger().log(Level.SEVERE, "Load failure", e);
+        }
+    }
+
+    private void createSessionStore() {
+        if (sessionStore != null) {
+            sessionStore.clear();
+        }
+
+        sessionStore = SessionStore.createNew();
+        getLogger().info("Session store created.");
+    }
+
+    private void loadStatsStore() throws Exception {
+        ConfigurationSection config = getConfig();
+        ConfigurationSection section = config.getConfigurationSection("store");
+        if (section == null) {
+            throw new IllegalArgumentException("No store section in config-file.");
+        }
+
+        statsStore = statsStoreRegistry.create(section);
+    }
+
+    private void registerSessionListener() {
+        if (sessionListener != null) {
+            HandlerList.unregisterAll(sessionListener);
+        }
+
+        sessionListener = new SessionListener(sessionStore, statsStore, asyncExecutor, getLogger());
+        getServer().getPluginManager().registerEvents(sessionListener, this);
+        getLogger().info("Session listener registered.");
+    }
+
+    public StatsStoreRegistry getStatsStoreRegistry() {
+        return statsStoreRegistry;
+    }
+
+    public Executor getSyncExecutor() {
+        return syncExecutor;
+    }
+
+    public Executor getAsyncExecutor() {
+        return asyncExecutor;
+    }
+
+    public StatsStore getStatsStore() {
+        return statsStore;
+    }
+
+    public static MobArenaStats getInstance() {
+        return instance;
+    }
+
+}

src/main/java/org/mobarena/stats/command/ArenaStatsCommand.java

@@ -0,0 +1,57 @@
+package org.mobarena.stats.command;
+
+import com.garbagemule.MobArena.commands.Command;
+import com.garbagemule.MobArena.commands.CommandInfo;
+import com.garbagemule.MobArena.framework.ArenaMaster;
+import com.garbagemule.MobArena.util.Slugs;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.MobArenaStatsPlugin;
+import org.mobarena.stats.store.ArenaStats;
+import org.mobarena.stats.store.StatsStore;
+
+import java.util.List;
+
+@CommandInfo(
+    name = "arena-stats",
+    pattern = "arena-stats",
+    usage = "/ma arena-stats <arena>",
+    desc = "show overall stats for the given arena",
+    permission = "mobarenastats.command.arena-stats"
+)
+public class ArenaStatsCommand implements Command {
+
+    @Override
+    public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
+        // :(
+        MobArenaStats plugin = MobArenaStatsPlugin.getInstance();
+
+        if (args.length < 1) {
+            return false;
+        }
+        String slug = Slugs.create(args[0]);
+
+        plugin.getAsyncExecutor().execute(() -> {
+            StatsStore store = plugin.getStatsStore();
+            ArenaStats stats = store.getArenaStats(slug);
+            sender.sendMessage("Stats for arena " + slug + ":");
+            sender.sendMessage("- Highest wave: " + stats.highestWave);
+            sender.sendMessage("- Longest duration: " + stats.highestSeconds + " secs");
+            sender.sendMessage("- Most kills: " + stats.highestKills);
+            sender.sendMessage("- Total sessions: " + stats.totalSessions);
+            sender.sendMessage("- Total duration: " + stats.totalSeconds + " secs");
+            sender.sendMessage("- Total kills: " + stats.totalKills);
+            sender.sendMessage("- Total waves: " + stats.totalWaves);
+        });
+
+        return true;
+    }
+
+    @Override
+    public List<String> tab(ArenaMaster am, Player player, String... args) {
+        // TODO: tab complete arena slugs?
+        return Command.super.tab(am, player, args);
+    }
+
+}

src/main/java/org/mobarena/stats/command/DeleteSessionStatsCommand.java

@@ -0,0 +1,56 @@
+package org.mobarena.stats.command;
+
+import com.garbagemule.MobArena.Messenger;
+import com.garbagemule.MobArena.commands.Command;
+import com.garbagemule.MobArena.commands.CommandInfo;
+import com.garbagemule.MobArena.framework.ArenaMaster;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.MobArenaStatsPlugin;
+import org.mobarena.stats.store.StatsStore;
+
+import java.util.List;
+import java.util.UUID;
+
+@CommandInfo(
+    name = "delete-session-stats",
+    pattern = "delete-session-stats",
+    usage = "/ma delete-session-stats <session-id>",
+    desc = "delete all stats collected for the given session",
+    permission = "mobarenastats.command.delete-session-stats"
+)
+public class DeleteSessionStatsCommand implements Command {
+
+    @Override
+    public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
+        // :(
+        MobArenaStats plugin = MobArenaStatsPlugin.getInstance();
+
+        // TODO: check args, handle non-UUID input error
+        UUID sessionId = UUID.fromString(args[0]);
+
+        StatsStore store = plugin.getStatsStore();
+        Messenger messenger = am.getGlobalMessenger();
+
+        plugin.getAsyncExecutor().execute(() -> {
+            store.delete(sessionId);
+            messenger.tell(sender, String.format(
+                "Stats for session %s%s%s deleted.",
+                ChatColor.YELLOW,
+                sessionId,
+                ChatColor.RESET
+            ));
+        });
+
+        return true;
+    }
+
+    @Override
+    public List<String> tab(ArenaMaster am, Player player, String... args) {
+        // TODO: tab complete session IDs?
+        return Command.super.tab(am, player, args);
+    }
+
+}

src/main/java/org/mobarena/stats/command/ExportCommand.java

@@ -0,0 +1,57 @@
+package org.mobarena.stats.command;
+
+import com.garbagemule.MobArena.Messenger;
+import com.garbagemule.MobArena.commands.Command;
+import com.garbagemule.MobArena.commands.CommandInfo;
+import com.garbagemule.MobArena.framework.ArenaMaster;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.MobArenaStatsPlugin;
+import org.mobarena.stats.store.StatsExport;
+import org.mobarena.stats.store.StatsStore;
+import org.mobarena.stats.store.StatsStoreRegistry;
+
+@CommandInfo(
+    name = "export-stats",
+    pattern = "export-stats",
+    usage = "/ma export-stats",
+    desc = "export the current stats store to a file in the given format",
+    permission = "mobarenastats.command.export-stats"
+)
+public class ExportCommand implements Command {
+
+    @Override
+    public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
+        // :(
+        MobArenaStats plugin = MobArenaStatsPlugin.getInstance();
+
+        StatsStore store = plugin.getStatsStore();
+        StatsStoreRegistry registry = plugin.getStatsStoreRegistry();
+
+        Messenger messenger = am.getGlobalMessenger();
+        messenger.tell(sender, "Exporting stats. This may take a while...");
+        plugin.getAsyncExecutor().execute(() -> {
+            try {
+                String filename = StatsExport.run(store, registry);
+
+                messenger.tell(sender, String.format(
+                    "Export to %s%s%s complete.",
+                    ChatColor.YELLOW,
+                    filename,
+                    ChatColor.RESET
+                ));
+            } catch (Exception e) {
+                messenger.tell(sender, String.format(
+                    "Export %sfailed%s because:\n%s",
+                    ChatColor.RED,
+                    ChatColor.RESET,
+                    e.getMessage()
+                ));
+            }
+        });
+
+        return true;
+    }
+
+}

src/main/java/org/mobarena/stats/command/GlobalStatsCommand.java

@@ -0,0 +1,39 @@
+package org.mobarena.stats.command;
+
+import com.garbagemule.MobArena.commands.Command;
+import com.garbagemule.MobArena.commands.CommandInfo;
+import com.garbagemule.MobArena.framework.ArenaMaster;
+import org.bukkit.command.CommandSender;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.MobArenaStatsPlugin;
+import org.mobarena.stats.store.GlobalStats;
+import org.mobarena.stats.store.StatsStore;
+
+@CommandInfo(
+    name = "global-stats",
+    pattern = "global-stats",
+    usage = "/ma global-stats",
+    desc = "show stats across all sessions",
+    permission = "mobarenastats.command.global-stats"
+)
+public class GlobalStatsCommand implements Command {
+
+    @Override
+    public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
+        // :(
+        MobArenaStats plugin = MobArenaStatsPlugin.getInstance();
+
+        plugin.getAsyncExecutor().execute(() -> {
+            StatsStore store = plugin.getStatsStore();
+            GlobalStats stats = store.getGlobalStats();
+            sender.sendMessage("Global stats:");
+            sender.sendMessage("- Total sessions: " + stats.totalSessions);
+            sender.sendMessage("- Total duration: " + stats.totalSeconds + " secs");
+            sender.sendMessage("- Total kills: " + stats.totalKills);
+            sender.sendMessage("- Total waves: " + stats.totalWaves);
+        });
+
+        return true;
+    }
+
+}

src/main/java/org/mobarena/stats/command/ImportCommand.java

@@ -0,0 +1,130 @@
+package org.mobarena.stats.command;
+
+import com.garbagemule.MobArena.Messenger;
+import com.garbagemule.MobArena.commands.Command;
+import com.garbagemule.MobArena.commands.CommandInfo;
+import com.garbagemule.MobArena.framework.ArenaMaster;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.MobArenaStatsPlugin;
+import org.mobarena.stats.store.StatsExport;
+import org.mobarena.stats.store.StatsImport;
+import org.mobarena.stats.store.StatsStore;
+import org.mobarena.stats.store.StatsStoreRegistry;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@CommandInfo(
+    name = "import-stats",
+    pattern = "import-stats",
+    usage = "/ma import-stats <filename>",
+    desc = "import stats from an database export file into the current stats store",
+    permission = "mobarenastats.command.import-stats"
+)
+public class ImportCommand implements Command {
+
+    @Override
+    public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
+        if (args.length < 1) {
+            return false;
+        }
+
+        // :(
+        MobArenaStats plugin = MobArenaStatsPlugin.getInstance();
+
+        Path data = plugin.getDataFolder().toPath();
+        Path file = data.resolve(args[0]);
+        if (!Files.exists(file)) {
+            sender.sendMessage(String.format(
+                "File %s%s%s not found.",
+                ChatColor.YELLOW,
+                args[0],
+                ChatColor.RESET
+            ));
+            return false;
+        }
+
+        String filename = file.getFileName().toString();
+        if (!filename.startsWith(StatsExport.FILENAME_PREFIX)) {
+            sender.sendMessage(String.format(
+                "Not a valid database export; filename must start with %s%s%s.",
+                ChatColor.YELLOW,
+                StatsExport.FILENAME_PREFIX,
+                ChatColor.RESET
+            ));
+            return true;
+        }
+        if (!filename.endsWith(StatsExport.FILENAME_SUFFIX)) {
+            sender.sendMessage(String.format(
+                "Not a valid database export; filename must end with %s%s%s.",
+                ChatColor.YELLOW,
+                StatsExport.FILENAME_SUFFIX,
+                ChatColor.RESET
+            ));
+            return true;
+        }
+
+        StatsStore store = plugin.getStatsStore();
+        StatsStoreRegistry registry = plugin.getStatsStoreRegistry();
+
+        Messenger messenger = am.getGlobalMessenger();
+        messenger.tell(sender, String.format(
+            "Importing stats from %s%s%s. This may take a while...",
+            ChatColor.YELLOW,
+            filename,
+            ChatColor.RESET
+        ));
+        plugin.getAsyncExecutor().execute(() -> {
+            try {
+                StatsImport.run(registry, filename, store);
+
+                messenger.tell(sender, String.format(
+                    "Import from %s%s%s complete.",
+                    ChatColor.YELLOW,
+                    filename,
+                    ChatColor.RESET
+                ));
+            } catch (Exception e) {
+                messenger.tell(sender, String.format(
+                    "Import %sfailed%s because:\n%s",
+                    ChatColor.RED,
+                    ChatColor.RESET,
+                    e.getMessage()
+                ));
+            }
+        });
+
+        return true;
+    }
+
+    @Override
+    public List<String> tab(ArenaMaster am, Player player, String... args) {
+        if (args.length > 1) {
+            return Collections.emptyList();
+        }
+
+        // :(
+        MobArenaStats plugin = MobArenaStatsPlugin.getInstance();
+
+        String[] files = plugin.getDataFolder().list();
+        if (files == null || files.length == 0) {
+            return Collections.emptyList();
+        }
+
+        String prefix = (args.length == 1) ? args[0] : "";
+
+        return Arrays.stream(files)
+            .filter(filename -> filename.startsWith(prefix))
+            .filter(filename -> filename.startsWith(StatsExport.FILENAME_PREFIX))
+            .filter(filename -> filename.endsWith(StatsExport.FILENAME_SUFFIX))
+            .collect(Collectors.toList());
+    }
+
+}

src/main/java/org/mobarena/stats/command/PlayerStatsCommand.java

@@ -0,0 +1,58 @@
+package org.mobarena.stats.command;
+
+import com.garbagemule.MobArena.commands.Command;
+import com.garbagemule.MobArena.commands.CommandInfo;
+import com.garbagemule.MobArena.framework.ArenaMaster;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.MobArenaStatsPlugin;
+import org.mobarena.stats.store.PlayerStats;
+import org.mobarena.stats.store.StatsStore;
+
+import java.util.List;
+
+@CommandInfo(
+    name = "player-stats",
+    pattern = "player-stats",
+    usage = "/ma player-stats <player>",
+    desc = "show overall stats for the given player",
+    permission = "mobarenastats.command.player-stats"
+)
+public class PlayerStatsCommand implements Command {
+
+    @Override
+    public boolean execute(ArenaMaster am, CommandSender sender, String... args) {
+        // :(
+        MobArenaStats plugin = MobArenaStatsPlugin.getInstance();
+
+        String name;
+        if (args.length == 0) {
+            if (!(sender instanceof Player)) {
+                return false;
+            }
+            name = sender.getName();
+        } else {
+            name = args[0];
+        }
+
+        plugin.getAsyncExecutor().execute(() -> {
+            StatsStore store = plugin.getStatsStore();
+            PlayerStats stats = store.getPlayerStats(name);
+            sender.sendMessage("Stats for player " + name + ":");
+            sender.sendMessage("- Total sessions: " + stats.totalSessions);
+            sender.sendMessage("- Total duration: " + stats.totalSeconds + " secs");
+            sender.sendMessage("- Total kills: " + stats.totalKills);
+            sender.sendMessage("- Total waves: " + stats.totalWaves);
+        });
+
+        return true;
+    }
+
+    @Override
+    public List<String> tab(ArenaMaster am, Player player, String... args) {
+        // TODO: tab complete player names?
+        return Command.super.tab(am, player, args);
+    }
+
+}

src/main/java/org/mobarena/stats/platform/AsyncBukkitExecutor.java

@@ -0,0 +1,23 @@
+package org.mobarena.stats.platform;
+
+import org.bukkit.plugin.Plugin;
+import org.bukkit.scheduler.BukkitScheduler;
+
+import java.util.concurrent.Executor;
+
+public class AsyncBukkitExecutor implements Executor {
+
+    private final Plugin plugin;
+    private final BukkitScheduler scheduler;
+
+    public AsyncBukkitExecutor(Plugin plugin, BukkitScheduler scheduler) {
+        this.plugin = plugin;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public void execute(Runnable command) {
+        scheduler.runTaskAsynchronously(plugin, command);
+    }
+
+}

src/main/java/org/mobarena/stats/platform/SyncBukkitExecutor.java

@@ -0,0 +1,23 @@
+package org.mobarena.stats.platform;
+
+import org.bukkit.plugin.Plugin;
+import org.bukkit.scheduler.BukkitScheduler;
+
+import java.util.concurrent.Executor;
+
+public class SyncBukkitExecutor implements Executor {
+
+    private final Plugin plugin;
+    private final BukkitScheduler scheduler;
+
+    public SyncBukkitExecutor(Plugin plugin, BukkitScheduler scheduler) {
+        this.plugin = plugin;
+        this.scheduler = scheduler;
+    }
+
+    @Override
+    public void execute(Runnable command) {
+        scheduler.runTask(plugin, command);
+    }
+
+}

src/main/java/org/mobarena/stats/session/PlayerConclusion.java

@@ -0,0 +1,23 @@
+package org.mobarena.stats.session;
+
+public enum PlayerConclusion {
+
+    /**
+     * When an arena has a final wave and the given player reaches and
+     * completes that wave, the player session concludes in a victory.
+     */
+    VICTORY,
+
+    /**
+     * When the given player dies in an arena, the player's session will
+     * concludes in a defeat, even if other players are still alive.
+     */
+    DEFEAT,
+
+    /**
+     * When the given player leaves an ongoing arena, the player's session
+     * will conclude in a retreat, even if other players are still alive.
+     */
+    RETREAT,
+
+}

src/main/java/org/mobarena/stats/session/PlayerSessionStats.java

@@ -0,0 +1,38 @@
+package org.mobarena.stats.session;
+
+import java.time.Instant;
+import java.util.UUID;
+
+public class PlayerSessionStats {
+
+    public final UUID sessionId;
+    public final UUID playerId;
+    public final String playerName;
+
+    public String className;
+
+    public Instant joinTime;
+    public Instant readyTime;
+    public Instant leaveTime;
+    public Instant deathTime;
+
+    public int kills;
+    public int dmgDone;
+    public int dmgTaken;
+    public int swings;
+    public int hits;
+    public int lastWave;
+
+    public PlayerConclusion conclusion;
+
+    public PlayerSessionStats(
+        UUID sessionId,
+        UUID playerId,
+        String playerName
+    ) {
+        this.sessionId = sessionId;
+        this.playerId = playerId;
+        this.playerName = playerName;
+    }
+
+}

src/main/java/org/mobarena/stats/session/Session.java

@@ -0,0 +1,130 @@
+package org.mobarena.stats.session;
+
+import com.garbagemule.MobArena.framework.Arena;
+import org.bukkit.entity.Player;
+
+import java.time.Instant;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class Session {
+
+    final UUID sessionId;
+    final String arenaSlug;
+
+    final SessionStats sessionStats;
+    final Map<UUID, PlayerSessionStats> playerStats;
+
+    public Session(UUID sessionId, String arenaSlug) {
+        this.sessionId = sessionId;
+        this.arenaSlug = arenaSlug;
+
+        this.sessionStats = new SessionStats(sessionId, arenaSlug);
+        this.playerStats = new HashMap<>();
+    }
+
+    public void playerJoin(Player player) {
+        UUID playerId = player.getUniqueId();
+        String playerName = player.getName();
+        PlayerSessionStats stats = new PlayerSessionStats(sessionId, playerId, playerName);
+        playerStats.put(playerId, stats);
+
+        stats.joinTime = Instant.now();
+    }
+
+    public void playerReady(Player player, String className) {
+        UUID playerId = player.getUniqueId();
+        PlayerSessionStats stats = playerStats.get(playerId);
+        if (stats == null) {
+            return;
+        }
+
+        stats.readyTime = Instant.now();
+        stats.className = className;
+    }
+
+    public void playerLeave(Arena arena, Player player) {
+        UUID playerId = player.getUniqueId();
+        PlayerSessionStats stats = playerStats.get(playerId);
+        if (stats == null) {
+            return;
+        }
+
+        stats.leaveTime = Instant.now();
+
+        if (stats.conclusion == null) {
+            stats.conclusion = PlayerConclusion.RETREAT;
+        }
+
+        StatsUtil.copy(arena, player, stats);
+    }
+
+    public void playerDeath(Arena arena, Player player) {
+        UUID playerId = player.getUniqueId();
+        PlayerSessionStats stats = playerStats.get(playerId);
+        if (stats == null) {
+            return;
+        }
+
+        stats.deathTime = Instant.now();
+
+        if (stats.conclusion == null) {
+            stats.conclusion = PlayerConclusion.DEFEAT;
+        }
+
+        StatsUtil.copy(arena, player, stats);
+    }
+
+    public void start() {
+        sessionStats.startTime = Instant.now();
+    }
+
+    public void wave(int wave) {
+        sessionStats.lastWave = wave;
+    }
+
+    public void complete() {
+        sessionStats.conclusion = SessionConclusion.VICTORY;
+
+        for (PlayerSessionStats playerStats : playerStats.values()) {
+            if (playerStats.conclusion == null) {
+                playerStats.conclusion = PlayerConclusion.VICTORY;
+            }
+        }
+    }
+
+    public void end() {
+        sessionStats.endTime = Instant.now();
+
+        if (sessionStats.conclusion == null) {
+            sessionStats.conclusion = SessionConclusion.DEFEAT;
+        }
+    }
+
+    public UUID getSessionId() {
+        return sessionId;
+    }
+
+    public String getArenaSlug() {
+        return arenaSlug;
+    }
+
+    public SessionStats getSessionStats() {
+        return sessionStats;
+    }
+
+    public Collection<PlayerSessionStats> getPlayerStats() {
+        return playerStats.values();
+    }
+
+    public PlayerSessionStats getPlayerStats(UUID playerId) {
+        return playerStats.get(playerId);
+    }
+
+    public void setPlayerStats(UUID playerId, PlayerSessionStats stats) {
+        playerStats.put(playerId, stats);
+    }
+
+}

src/main/java/org/mobarena/stats/session/SessionConclusion.java

@@ -0,0 +1,17 @@
+package org.mobarena.stats.session;
+
+public enum SessionConclusion {
+
+    /**
+     * When an arena has a final wave and one or more players reach and
+     * complete that wave, the session concludes in a victory.
+     */
+    VICTORY,
+
+    /**
+     * When the last player alive in an arena dies, the session concludes
+     * in a defeat, meaning the players "lost" the session.
+     */
+    DEFEAT,
+
+}

src/main/java/org/mobarena/stats/session/SessionListener.java

@@ -0,0 +1,190 @@
+package org.mobarena.stats.session;
+
+import com.garbagemule.MobArena.ArenaClass;
+import com.garbagemule.MobArena.ArenaPlayer;
+import com.garbagemule.MobArena.events.ArenaCompleteEvent;
+import com.garbagemule.MobArena.events.ArenaEndEvent;
+import com.garbagemule.MobArena.events.ArenaPlayerDeathEvent;
+import com.garbagemule.MobArena.events.ArenaPlayerJoinEvent;
+import com.garbagemule.MobArena.events.ArenaPlayerLeaveEvent;
+import com.garbagemule.MobArena.events.ArenaPlayerReadyEvent;
+import com.garbagemule.MobArena.events.ArenaStartEvent;
+import com.garbagemule.MobArena.events.NewWaveEvent;
+import com.garbagemule.MobArena.framework.Arena;
+import org.mobarena.stats.store.StatsStore;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class SessionListener implements Listener {
+
+    private final SessionStore sessionStore;
+    private final StatsStore statsStore;
+    private final Executor asyncExecutor;
+    private final Logger log;
+
+    public SessionListener(
+        SessionStore sessionStore,
+        StatsStore statsStore,
+        Executor asyncExecutor,
+        Logger log
+    ) {
+        this.sessionStore = sessionStore;
+        this.statsStore = statsStore;
+        this.asyncExecutor = asyncExecutor;
+        this.log = log;
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void on(ArenaPlayerJoinEvent event) {
+        Arena arena = event.getArena();
+        Player player = event.getPlayer();
+
+        Session session = sessionStore.getByArena(arena);
+        if (session == null) {
+            session = sessionStore.create(arena);
+        }
+
+        session.playerJoin(player);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void on(ArenaPlayerReadyEvent event) {
+        Arena arena = event.getArena();
+        Player player = event.getPlayer();
+        String className = getClassName(arena, player);
+
+        Session session = sessionStore.getByArena(arena);
+        if (session == null) {
+            log.warning("Unexpected ready event for non-existent session of arena " + arena.getSlug());
+            return;
+        }
+
+        session.playerReady(player, className);
+    }
+
+    private String getClassName(Arena arena, Player player) {
+        ArenaPlayer ap = arena.getArenaPlayer(player);
+        if (ap == null) {
+            return null;
+        }
+
+        ArenaClass ac = ap.getArenaClass();
+        if (ac == null) {
+            return null;
+        }
+
+        return ac.getSlug();
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void on(ArenaPlayerLeaveEvent event) {
+        Arena arena = event.getArena();
+        Player player = event.getPlayer();
+
+        Session session = sessionStore.getByArena(arena);
+        if (session == null) {
+            log.warning("Unexpected leave event for non-existent session of arena " + arena.getSlug());
+            return;
+        }
+
+        session.playerLeave(arena, player);
+
+        if (!arena.isRunning()) {
+            if (arena.getPlayersInLobby().size() <= 1) {
+                sessionStore.delete(session);
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void on(ArenaPlayerDeathEvent event) {
+        Arena arena = event.getArena();
+        Player player = event.getPlayer();
+
+        Session session = sessionStore.getByArena(arena);
+        if (session == null) {
+            log.warning("Unexpected death event for non-existent session of arena " + arena.getSlug());
+            return;
+        }
+
+        session.playerDeath(arena, player);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void on(ArenaStartEvent event) {
+        Arena arena = event.getArena();
+
+        Session session = sessionStore.getByArena(arena);
+        if (session == null) {
+            log.warning("Unexpected start event for non-existent session of arena " + arena.getSlug());
+            return;
+        }
+
+        session.start();
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void on(NewWaveEvent event) {
+        Arena arena = event.getArena();
+        int wave = event.getWaveNumber();
+
+        Session session = sessionStore.getByArena(arena);
+        if (session == null) {
+            log.warning("Unexpected wave event for non-existent session of arena " + arena.getSlug());
+            return;
+        }
+
+        session.wave(wave);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void on(ArenaCompleteEvent event) {
+        Arena arena = event.getArena();
+
+        Session session = sessionStore.getByArena(arena);
+        if (session == null) {
+            log.warning("Unexpected complete event for non-existent session of arena " + arena.getSlug());
+            return;
+        }
+
+        session.complete();
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void on(ArenaEndEvent event) {
+        Arena arena = event.getArena();
+
+        Session session = sessionStore.getByArena(arena);
+        if (session == null) {
+            log.warning("Unexpected end event for non-existent session of arena " + arena.getSlug());
+            return;
+        }
+
+        session.end();
+
+        if (!arena.isRunning()) {
+            // Session never started, so just clean up and bail
+            sessionStore.delete(session);
+            return;
+        }
+
+        CompletableFuture.runAsync(() -> {
+            try {
+                statsStore.save(session);
+                sessionStore.delete(session);
+                log.info("Session (" + session.sessionId + ") for arena " + session.arenaSlug + " saved.");
+            } catch (Exception e) {
+                log.log(Level.SEVERE, "Failed to save session (" + session.sessionId + ") for arena " + session.arenaSlug, e);
+                sessionStore.delete(session);
+            }
+        }, asyncExecutor);
+    }
+
+}

src/main/java/org/mobarena/stats/session/SessionStats.java

@@ -0,0 +1,23 @@
+package org.mobarena.stats.session;
+
+import java.time.Instant;
+import java.util.UUID;
+
+public class SessionStats {
+
+    public final UUID sessionId;
+    public final String arenaSlug;
+
+    public Instant startTime;
+    public Instant endTime;
+
+    public int lastWave;
+
+    public SessionConclusion conclusion;
+
+    public SessionStats(UUID sessionId, String arenaSlug) {
+        this.sessionId = sessionId;
+        this.arenaSlug = arenaSlug;
+    }
+
+}

src/main/java/org/mobarena/stats/session/SessionStore.java

@@ -0,0 +1,86 @@
+package org.mobarena.stats.session;
+
+import com.garbagemule.MobArena.framework.Arena;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * In-memory store for on-going session data.
+ * <p>
+ * The session store is the top-level bookkeeping entity for current sessions
+ * in that all {@link Session} objects are created and kept track of by this
+ * store. Unlike {@link org.mobarena.stats.store.StatsStore}, which persists
+ * its data, the session store is just an in-memory collection.
+ */
+public class SessionStore {
+
+    private final Map<String, Session> slugToSession;
+
+    private SessionStore() {
+        this.slugToSession = new HashMap<>();
+    }
+
+    /**
+     * Create a new {@link Session} instance for the given {@link Arena}.
+     * <p>
+     * Note that only one session can be active per arena. The method throws
+     * if it is called with an arena instance that already has an associated
+     * on-going session.
+     *
+     * @param arena the arena to create a new session for
+     * @return a new session for the given arena
+     * @throws IllegalStateException if a session exists for the given arena
+     */
+    public Session create(Arena arena) {
+        String arenaSlug = arena.getSlug();
+
+        if (slugToSession.containsKey(arenaSlug)) {
+            throw new IllegalStateException("A session for arena " + arenaSlug + " already exists");
+        }
+
+        UUID sessionId = UUID.randomUUID();
+        Session session = new Session(sessionId, arenaSlug);
+        slugToSession.put(arenaSlug, session);
+
+        return session;
+    }
+
+    /**
+     * Delete the given {@link Session} from the store.
+     * <p>
+     * When a session is deleted, it opens up the possibility of starting a
+     * new one for the associated arena.
+     *
+     * @param session a session to delete
+     */
+    public void delete(Session session) {
+        slugToSession.remove(session.getArenaSlug());
+    }
+
+    /**
+     * Look up a {@link Session} by its associated {@link Arena}.
+     *
+     * @param arena the arena whose session to look up
+     * @return the associated session instance, or null
+     */
+    public Session getByArena(Arena arena) {
+        return slugToSession.get(arena.getSlug());
+    }
+
+    /**
+     * Clear the internal session map.
+     * <p>
+     * This method is called by MobArenaStats on reloads to try to clear any
+     * residue from old sessions.
+     */
+    public void clear() {
+        slugToSession.clear();
+    }
+
+    public static SessionStore createNew() {
+        return new SessionStore();
+    }
+
+}

src/main/java/org/mobarena/stats/session/StatsUtil.java

@@ -0,0 +1,33 @@
+package org.mobarena.stats.session;
+
+import com.garbagemule.MobArena.ArenaPlayer;
+import com.garbagemule.MobArena.ArenaPlayerStatistics;
+import com.garbagemule.MobArena.framework.Arena;
+import org.bukkit.entity.Player;
+
+final class StatsUtil {
+
+    private StatsUtil() {
+        // OK BOSS
+    }
+
+    static void copy(Arena arena, Player player, PlayerSessionStats target) {
+        ArenaPlayer ap = arena.getArenaPlayer(player);
+        if (ap == null) {
+            return;
+        }
+
+        ArenaPlayerStatistics aps = ap.getStats();
+        if (aps == null) {
+            return;
+        }
+
+        target.kills = aps.getInt("kills");
+        target.dmgDone = aps.getInt("dmgDone");
+        target.dmgTaken = aps.getInt("dmgTaken");
+        target.swings = aps.getInt("swings");
+        target.hits = aps.getInt("hits");
+        target.lastWave = aps.getInt("lastWave");
+    }
+
+}

src/main/java/org/mobarena/stats/store/ArenaStats.java

@@ -0,0 +1,31 @@
+package org.mobarena.stats.store;
+
+public class ArenaStats {
+
+    public final int highestWave;
+    public final int highestSeconds;
+    public final int highestKills;
+    public final int totalSessions;
+    public final long totalSeconds;
+    public final long totalKills;
+    public final long totalWaves;
+
+    public ArenaStats(
+        int highestWave,
+        int highestSeconds,
+        int highestKills,
+        int totalSessions,
+        long totalSeconds,
+        long totalKills,
+        long totalWaves
+    ) {
+        this.highestWave = highestWave;
+        this.highestSeconds = highestSeconds;
+        this.highestKills = highestKills;
+        this.totalSessions = totalSessions;
+        this.totalSeconds = totalSeconds;
+        this.totalKills = totalKills;
+        this.totalWaves = totalWaves;
+    }
+
+}

src/main/java/org/mobarena/stats/store/CachingStatsStore.java

@@ -0,0 +1,67 @@
+package org.mobarena.stats.store;
+
+import org.mobarena.stats.session.Session;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class CachingStatsStore implements StatsStore {
+
+    private final StatsStore delegate;
+
+    private GlobalStats globalStats;
+    private final Map<String, ArenaStats> arenaStats;
+    private final Map<String, PlayerStats> playerStats;
+
+    public CachingStatsStore(StatsStore delegate) {
+        this.delegate = delegate;
+
+        this.globalStats = null;
+        this.arenaStats = new HashMap<>();
+        this.playerStats = new HashMap<>();
+    }
+
+    @Override
+    public void save(Session session) throws IOException {
+        delegate.save(session);
+
+        globalStats = null;
+        arenaStats.remove(session.getArenaSlug());
+        session.getPlayerStats().forEach(stats -> playerStats.remove(stats.playerName));
+    }
+
+    @Override
+    public void delete(UUID sessionId) {
+        delegate.delete(sessionId);
+
+        globalStats = null;
+        arenaStats.clear();
+        playerStats.clear();
+    }
+
+    @Override
+    public GlobalStats getGlobalStats() {
+        if (globalStats == null) {
+            globalStats = delegate.getGlobalStats();
+        }
+        return globalStats;
+    }
+
+    @Override
+    public ArenaStats getArenaStats(String slug) {
+        return arenaStats.computeIfAbsent(slug, delegate::getArenaStats);
+    }
+
+    @Override
+    public PlayerStats getPlayerStats(String name) {
+        return playerStats.computeIfAbsent(name, delegate::getPlayerStats);
+    }
+
+    @Override
+    public void export(StatsStore target) throws IOException {
+        delegate.export(target);
+    }
+
+}

src/main/java/org/mobarena/stats/store/GlobalStats.java

@@ -0,0 +1,22 @@
+package org.mobarena.stats.store;
+
+public class GlobalStats {
+
+    public final int totalSessions;
+    public final long totalSeconds;
+    public final long totalKills;
+    public final long totalWaves;
+
+    public GlobalStats(
+        int totalSessions,
+        long totalSeconds,
+        long totalKills,
+        long totalWaves
+    ) {
+        this.totalSessions = totalSessions;
+        this.totalSeconds = totalSeconds;
+        this.totalKills = totalKills;
+        this.totalWaves = totalWaves;
+    }
+
+}

src/main/java/org/mobarena/stats/store/PlayerStats.java

@@ -0,0 +1,22 @@
+package org.mobarena.stats.store;
+
+public class PlayerStats {
+
+    public final int totalSessions;
+    public final long totalSeconds;
+    public final long totalKills;
+    public final long totalWaves;
+
+    public PlayerStats(
+        int totalSessions,
+        long totalSeconds,
+        long totalKills,
+        long totalWaves
+    ) {
+        this.totalSessions = totalSessions;
+        this.totalSeconds = totalSeconds;
+        this.totalKills = totalKills;
+        this.totalWaves = totalWaves;
+    }
+
+}

src/main/java/org/mobarena/stats/store/StatsExport.java

@@ -0,0 +1,27 @@
+package org.mobarena.stats.store;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+public class StatsExport {
+
+    public static final String FILENAME_PREFIX = "stats.export-";
+    public static final String FILENAME_SUFFIX = ".db";
+
+    public static String run(
+        StatsStore store,
+        StatsStoreRegistry registry
+    ) throws Exception {
+        String filename = FILENAME_PREFIX + System.currentTimeMillis() + FILENAME_SUFFIX;
+
+        ConfigurationSection config = new YamlConfiguration();
+        config.set("type", "sqlite");
+        config.set("filename", filename);
+        StatsStore output = registry.create(config);
+
+        store.export(output);
+
+        return filename;
+    }
+
+}

src/main/java/org/mobarena/stats/store/StatsImport.java

@@ -0,0 +1,21 @@
+package org.mobarena.stats.store;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+public class StatsImport {
+
+    public static void run(
+        StatsStoreRegistry registry,
+        String filename,
+        StatsStore store
+    ) throws Exception {
+        ConfigurationSection config = new YamlConfiguration();
+        config.set("type", "sqlite");
+        config.set("filename", filename);
+        StatsStore source = registry.create(config);
+
+        source.export(store);
+    }
+
+}

src/main/java/org/mobarena/stats/store/StatsStore.java

@@ -0,0 +1,49 @@
+package org.mobarena.stats.store;
+
+import org.mobarena.stats.session.Session;
+
+import java.io.IOException;
+import java.util.UUID;
+
+/**
+ * Persistent data store for session and player stats.
+ * <p>
+ * All store operations are <i>blocking</i>, meaning any calls to the store
+ * should be handled off the main thread to prevent performance impacts.
+ */
+public interface StatsStore {
+
+    /**
+     * Store the given {@link Session}'s data in the store.
+     * <p>
+     * This method should only be called with a "finished" session, i.e. a
+     * session that has concluded and won't be altered after saving.
+     *
+     * @param session a session to store
+     * @throws IOException if the operation fails due to I/O
+     */
+    void save(Session session) throws IOException;
+
+    /**
+     * Delete all data about the session with the given ID.
+     * <p>
+     * Removes all session and player data associated with the session of
+     * the given ID, meaning these stats will be lost forever.
+     *
+     * @param sessionId the ID of the session whose data to delete
+     */
+    void delete(UUID sessionId);
+
+    // TODO: docs
+    GlobalStats getGlobalStats();
+
+    // TODO: docs
+    ArenaStats getArenaStats(String slug);
+
+    // TODO: docs
+    PlayerStats getPlayerStats(String name);
+
+    // TODO: docs
+    void export(StatsStore target) throws IOException;
+
+}

src/main/java/org/mobarena/stats/store/StatsStoreFactory.java

@@ -0,0 +1,22 @@
+package org.mobarena.stats.store;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.mobarena.stats.MobArenaStats;
+
+@FunctionalInterface
+public interface StatsStoreFactory {
+
+    /**
+     * Create a new stats store from the given configuration.
+     *
+     * @param config a configuration to set up the stats store
+     * @param plugin a plugin instance for dependencies
+     * @return a new stats store instance
+     * @throws Exception if store creation fails
+     */
+    StatsStore create(
+        ConfigurationSection config,
+        MobArenaStats plugin
+    ) throws Exception;
+
+}

src/main/java/org/mobarena/stats/store/StatsStoreRegistry.java

@@ -0,0 +1,41 @@
+package org.mobarena.stats.store;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.mobarena.stats.MobArenaStatsPlugin;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class StatsStoreRegistry {
+
+    private final Map<String, StatsStoreFactory> typeToFactory;
+    private final MobArenaStatsPlugin plugin;
+
+    StatsStoreRegistry(MobArenaStatsPlugin plugin) {
+        this.typeToFactory = new HashMap<>();
+        this.plugin = plugin;
+    }
+
+    public void register(String type, StatsStoreFactory factory) {
+        typeToFactory.put(type.toLowerCase(), factory);
+    }
+
+    public StatsStore create(ConfigurationSection config) throws Exception {
+        String type = config.getString("type");
+        if (type == null || type.isEmpty()) {
+            throw new IllegalArgumentException("Missing 'type' in store configuration");
+        }
+
+        StatsStoreFactory factory = typeToFactory.get(type.toLowerCase());
+        if (factory == null) {
+            throw new IllegalArgumentException("Unknown store type: " + type);
+        }
+
+        return factory.create(config, plugin);
+    }
+
+    public static StatsStoreRegistry create(MobArenaStatsPlugin plugin) {
+        return new StatsStoreRegistry(plugin);
+    }
+
+}

src/main/java/org/mobarena/stats/store/csv/CsvStatsStore.java

@@ -0,0 +1,253 @@
+package org.mobarena.stats.store.csv;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.session.PlayerConclusion;
+import org.mobarena.stats.session.PlayerSessionStats;
+import org.mobarena.stats.session.Session;
+import org.mobarena.stats.session.SessionConclusion;
+import org.mobarena.stats.session.SessionStats;
+import org.mobarena.stats.store.ArenaStats;
+import org.mobarena.stats.store.GlobalStats;
+import org.mobarena.stats.store.PlayerStats;
+import org.mobarena.stats.store.StatsStore;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.nio.file.Files;
+import java.time.Instant;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.UUID;
+import java.util.function.Function;
+import java.util.logging.Logger;
+
+public class CsvStatsStore implements StatsStore {
+
+    private static final String[] SESSION_FIELDS = {
+        "session_id",
+        "arena_slug",
+        "start_time",
+        "end_time",
+        "last_wave",
+        "conclusion"
+    };
+
+    private static final String[] PLAYER_SESSION_FIELDS = {
+        "session_id",
+        "player_id",
+        "player_name",
+        "class",
+        "join_time",
+        "ready_time",
+        "leave_time",
+        "death_time",
+        "kills",
+        "dmg_done",
+        "dmg_taken",
+        "swings",
+        "hits",
+        "last_wave",
+        "conclusion"
+    };
+
+    private final File folder;
+    private final File sessionsFile;
+    private final File playersFile;
+    private final String separator;
+    private final DateTimeFormatter formatter;
+    private final Logger log;
+
+    private CsvStatsStore(
+        File folder,
+        String separator,
+        Logger log
+    ) {
+        this.folder = folder;
+        this.sessionsFile = new File(folder, "sessions.csv");
+        this.playersFile = new File(folder, "players.csv");
+        this.separator = separator;
+        this.formatter = DateTimeFormatter.ISO_INSTANT;
+        this.log = log;
+    }
+
+    @Override
+    public void save(Session session) throws IOException {
+        try {
+            createDataFolder();
+            saveArenaSession(session);
+            savePlayerSessions(session);
+        } catch (Exception e) {
+            throw new IOException(e);
+        }
+    }
+
+    @Override
+    public void delete(UUID sessionId) {
+        throw new UnsupportedOperationException("Session deletion is not supported by the CSV data store");
+    }
+
+    private void createDataFolder() {
+        if (!folder.exists()) {
+            if (!folder.mkdirs()) {
+                throw new IllegalStateException("Failed to create stats data folder");
+            }
+        }
+    }
+
+    private void saveArenaSession(Session session) throws Exception {
+        boolean writeHeader = !sessionsFile.exists();
+
+        try (PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(sessionsFile, true)))) {
+            if (writeHeader) {
+                String line = String.join(separator, SESSION_FIELDS);
+                writer.println(line);
+            }
+
+            SessionStats stats = session.getSessionStats();
+            String line = String.join(
+                separator,
+                stats.sessionId.toString(),
+                stats.arenaSlug,
+                formatter.format(stats.startTime),
+                formatter.format(stats.endTime),
+                String.valueOf(stats.lastWave),
+                String.valueOf(stats.conclusion)
+            );
+            writer.println(line);
+            log.info("Session stats written to disk (" + stats.sessionId + ").");
+        }
+    }
+
+    private void savePlayerSessions(Session session) throws Exception {
+        boolean writeHeader = !playersFile.exists();
+
+        try (PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(playersFile, true)))) {
+            if (writeHeader) {
+                String line = String.join(separator, PLAYER_SESSION_FIELDS);
+                writer.println(line);
+            }
+
+            for (PlayerSessionStats stats : session.getPlayerStats()) {
+                String line = String.join(
+                    separator,
+                    stats.sessionId.toString(),
+                    stats.playerId.toString(),
+                    stats.playerName,
+                    stats.className,
+                    formatter.format(stats.joinTime),
+                    formatter.format(stats.readyTime),
+                    stats.leaveTime != null ? formatter.format(stats.leaveTime) : "",
+                    stats.deathTime != null ? formatter.format(stats.deathTime) : "",
+                    String.valueOf(stats.kills),
+                    String.valueOf(stats.dmgDone),
+                    String.valueOf(stats.dmgTaken),
+                    String.valueOf(stats.swings),
+                    String.valueOf(stats.hits),
+                    String.valueOf(stats.lastWave),
+                    String.valueOf(stats.conclusion)
+                );
+                writer.println(line);
+            }
+            log.info("Player stats written to disk (" + session.getSessionStats().sessionId + ").");
+        }
+    }
+
+    @Override
+    public GlobalStats getGlobalStats() {
+        throw new UnsupportedOperationException("Queries are not supported by the CSV data store");
+    }
+
+    @Override
+    public ArenaStats getArenaStats(String slug) {
+        throw new UnsupportedOperationException("Queries are not supported by the CSV data store");
+    }
+
+    @Override
+    public PlayerStats getPlayerStats(String name) {
+        throw new UnsupportedOperationException("Queries are not supported by the CSV data store");
+    }
+
+    @Override
+    public void export(StatsStore target) throws IOException {
+        List<String> sessionLines = Files.readAllLines(sessionsFile.toPath());
+        List<String> playerLines = Files.readAllLines(playersFile.toPath());
+
+        for (int i = 1; i < sessionLines.size(); i++) {
+            String sessionLine = sessionLines.get(i);
+            String[] sessionParts = sessionLine.split(separator);
+
+            UUID sessionId = UUID.fromString(sessionParts[0]);
+            String arenaSlug = sessionParts[1];
+            Session session = new Session(sessionId, arenaSlug);
+            {
+                SessionStats stats = session.getSessionStats();
+                stats.startTime = Instant.parse(sessionParts[2]);
+                stats.endTime = Instant.parse(sessionParts[3]);
+                stats.lastWave = Integer.parseInt(sessionParts[4]);
+                stats.conclusion = SessionConclusion.valueOf(sessionParts[5]);
+            }
+
+            String prefix = sessionId + separator;
+            for (int j = 1; j < playerLines.size(); j++) {
+                String playerLine = playerLines.get(j);
+                if (!playerLine.startsWith(prefix)) {
+                    continue;
+                }
+
+                String[] playerParts = playerLine.split(separator);
+                {
+                    UUID playerId = UUID.fromString(playerParts[1]);
+                    String playerName = playerParts[2];
+
+                    PlayerSessionStats stats = new PlayerSessionStats(sessionId, playerId, playerName);
+                    stats.className = playerParts[3];
+                    stats.joinTime = safe(playerParts[4], Instant::parse);
+                    stats.readyTime = safe(playerParts[5], Instant::parse);
+                    stats.leaveTime = safe(playerParts[6], Instant::parse);
+                    stats.deathTime = safe(playerParts[7], Instant::parse);
+                    stats.kills = Integer.parseInt(playerParts[8]);
+                    stats.dmgDone = Integer.parseInt(playerParts[9]);
+                    stats.dmgTaken = Integer.parseInt(playerParts[10]);
+                    stats.swings = Integer.parseInt(playerParts[11]);
+                    stats.hits = Integer.parseInt(playerParts[12]);
+                    stats.lastWave = Integer.parseInt(playerParts[13]);
+                    stats.conclusion = safe(playerParts[14], PlayerConclusion::valueOf, PlayerConclusion.DEFEAT);
+
+                    session.setPlayerStats(playerId, stats);
+                }
+            }
+
+            target.save(session);
+        }
+    }
+
+    private static <T, R> R safe(T value, Function<T, R> parser) {
+        return safe(value, parser, null);
+    }
+
+    private static <T, R> R safe(T value, Function<T, R> parser, R def) {
+        try {
+            return parser.apply(value);
+        } catch (Exception e) {
+            return def;
+        }
+    }
+
+    public static CsvStatsStore create(
+        ConfigurationSection config,
+        MobArenaStats plugin
+    ) {
+        String folder = config.getString("folder", "data");
+        String separator = config.getString("separator", ";");
+
+        File root = new File(plugin.getDataFolder(), folder);
+        Logger log = plugin.getLogger();
+
+        return new CsvStatsStore(root, separator, log);
+    }
+
+}

src/main/java/org/mobarena/stats/store/jdbc/JdbcStatsStore.java

@@ -0,0 +1,245 @@
+package org.mobarena.stats.store.jdbc;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.jdbi.v3.core.Jdbi;
+import org.jdbi.v3.core.mapper.RowMapper;
+import org.jdbi.v3.core.statement.PreparedBatch;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.session.PlayerConclusion;
+import org.mobarena.stats.session.PlayerSessionStats;
+import org.mobarena.stats.session.Session;
+import org.mobarena.stats.session.SessionConclusion;
+import org.mobarena.stats.session.SessionStats;
+import org.mobarena.stats.store.ArenaStats;
+import org.mobarena.stats.store.GlobalStats;
+import org.mobarena.stats.store.PlayerStats;
+import org.mobarena.stats.store.StatsStore;
+import org.mobarena.stats.util.ResourceLoader;
+
+import java.io.IOException;
+import java.sql.Timestamp;
+import java.util.List;
+import java.util.UUID;
+import java.util.function.Function;
+import java.util.logging.Logger;
+
+import static org.mobarena.stats.store.jdbc.Statement.DELETE_SESSION_DATA;
+import static org.mobarena.stats.store.jdbc.Statement.FIND_ARENA_STATS;
+import static org.mobarena.stats.store.jdbc.Statement.FIND_GLOBAL_STATS;
+import static org.mobarena.stats.store.jdbc.Statement.FIND_PLAYER_SESSIONS_BY_ID;
+import static org.mobarena.stats.store.jdbc.Statement.FIND_PLAYER_STATS;
+import static org.mobarena.stats.store.jdbc.Statement.FIND_SESSIONS;
+import static org.mobarena.stats.store.jdbc.Statement.INSERT_PLAYER_DATA;
+import static org.mobarena.stats.store.jdbc.Statement.INSERT_SESSION_DATA;
+
+public class JdbcStatsStore implements StatsStore {
+
+    private final Jdbi jdbi;
+    private final Statements statements;
+
+    private JdbcStatsStore(Jdbi jdbi, Statements statements) {
+        this.jdbi = jdbi;
+        this.statements = statements;
+    }
+
+    @Override
+    public synchronized void save(Session session) {
+        jdbi.useTransaction(handle -> {
+            // First the session data
+            handle.createUpdate(statements.get(INSERT_SESSION_DATA))
+                .bind("session_id", session.getSessionId().toString())
+                .bind("arena_slug", session.getArenaSlug())
+                .bind("start_time", session.getSessionStats().startTime)
+                .bind("end_time", session.getSessionStats().endTime)
+                .bind("last_wave", session.getSessionStats().lastWave)
+                .bind("conclusion", session.getSessionStats().conclusion)
+                .execute();
+
+            // Then all of the player data
+            PreparedBatch batch = handle.prepareBatch(statements.get(INSERT_PLAYER_DATA));
+            for (PlayerSessionStats player : session.getPlayerStats()) {
+                batch.bind("session_id", session.getSessionId().toString());
+                batch.bind("player_id", player.playerId.toString());
+                batch.bind("player_name", player.playerName);
+                batch.bind("class", player.className);
+                batch.bind("join_time", player.joinTime);
+                batch.bind("ready_time", player.readyTime);
+                batch.bind("leave_time", player.leaveTime);
+                batch.bind("death_time", player.deathTime);
+                batch.bind("kills", player.kills);
+                batch.bind("dmg_done", player.dmgDone);
+                batch.bind("dmg_taken", player.dmgTaken);
+                batch.bind("swings", player.swings);
+                batch.bind("hits", player.hits);
+                batch.bind("last_wave", player.lastWave);
+                batch.bind("conclusion", player.conclusion);
+                batch.add();
+            }
+            batch.execute();
+        });
+    }
+
+    @Override
+    public void delete(UUID sessionId) {
+        jdbi.useTransaction(handle -> handle
+            .createUpdate(statements.get(DELETE_SESSION_DATA))
+            .bind("session_id", sessionId.toString())
+            .execute()
+        );
+    }
+
+    @Override
+    public GlobalStats getGlobalStats() {
+        return jdbi.withHandle(handle -> handle
+            .createQuery(statements.get(FIND_GLOBAL_STATS))
+                .map((rs, ctx) -> new GlobalStats(
+                    rs.getInt("total_sessions"),
+                    rs.getLong("total_seconds"),
+                    rs.getLong("total_kills"),
+                    rs.getLong("total_waves")
+                ))
+                .first()
+        );
+    }
+
+    @Override
+    public ArenaStats getArenaStats(String slug) {
+        return jdbi.withHandle(handle -> handle
+            .createQuery(statements.get(FIND_ARENA_STATS))
+            .bind("arena_slug", slug)
+            .map((rs, ctx) -> new ArenaStats(
+                rs.getInt("highest_wave"),
+                rs.getInt("highest_seconds"),
+                rs.getInt("highest_kills"),
+                rs.getInt("total_sessions"),
+                rs.getLong("total_seconds"),
+                rs.getLong("total_kills"),
+                rs.getLong("total_waves")
+            ))
+            .first()
+        );
+    }
+
+    @Override
+    public PlayerStats getPlayerStats(String name) {
+        return jdbi.withHandle(handle -> handle
+            .createQuery(statements.get(FIND_PLAYER_STATS))
+            .bind("player_name", name)
+            .map((rs, ctx) -> new PlayerStats(
+                rs.getInt("total_sessions"),
+                rs.getLong("total_seconds"),
+                rs.getLong("total_kills"),
+                rs.getLong("total_waves")
+            ))
+            .first()
+        );
+    }
+
+    @Override
+    public synchronized void export(StatsStore target) throws IOException {
+        jdbi.useHandle(handle -> {
+            int limit = 100;
+            int offset = 0;
+
+            while (true) {
+                List<Session> sessions = handle.createQuery(statements.get(FIND_SESSIONS))
+                    .bind("limit", limit)
+                    .bind("offset", offset)
+                    .map(toSession())
+                    .list();
+
+                for (Session session : sessions) {
+                    UUID sessionId = session.getSessionId();
+
+                    handle.createQuery(statements.get(FIND_PLAYER_SESSIONS_BY_ID))
+                        .bind("session_id", session.getSessionId().toString())
+                        .map(toPlayerStats(sessionId))
+                        .forEach(stats -> session.setPlayerStats(stats.playerId, stats));
+
+                    target.save(session);
+                }
+
+                if (sessions.size() < limit) {
+                    break;
+                }
+
+                offset += limit;
+            }
+        });
+    }
+
+    private static RowMapper<Session> toSession() {
+        return (r, ctx) -> {
+            UUID sessionId = UUID.fromString(r.getString("session_id"));
+            String arenaSlug = r.getString("arena_slug");
+            Session session = new Session(sessionId, arenaSlug);
+
+            SessionStats stats = session.getSessionStats();
+            stats.startTime = r.getTimestamp("start_time").toInstant();
+            stats.endTime = r.getTimestamp("end_time").toInstant();
+            stats.lastWave = r.getInt("last_wave");
+            stats.conclusion = SessionConclusion.valueOf(r.getString("conclusion"));
+
+            return session;
+        };
+    }
+
+    private static RowMapper<PlayerSessionStats> toPlayerStats(UUID sessionId) {
+        return (r, ctx) -> {
+            UUID playerId = UUID.fromString(r.getString("player_id"));
+            String playerName = r.getString("player_name");
+
+            PlayerSessionStats stats = new PlayerSessionStats(sessionId, playerId, playerName);
+            stats.className = r.getString("class");
+            stats.joinTime = safe(r.getTimestamp("join_time"), Timestamp::toInstant);
+            stats.readyTime = safe(r.getTimestamp("ready_time"), Timestamp::toInstant);
+            stats.leaveTime = safe(r.getTimestamp("leave_time"), Timestamp::toInstant);
+            stats.deathTime = safe(r.getTimestamp("death_time"), Timestamp::toInstant);
+            stats.kills = r.getInt("kills");
+            stats.dmgDone = r.getInt("dmg_done");
+            stats.dmgTaken = r.getInt("dmg_taken");
+            stats.swings = r.getInt("swings");
+            stats.hits = r.getInt("hits");
+            stats.lastWave = r.getInt("last_wave");
+            stats.conclusion = safe(r.getString("conclusion"), PlayerConclusion::valueOf, PlayerConclusion.DEFEAT);
+
+            return stats;
+        };
+    }
+
+    private static <T, R> R safe(T value, Function<T, R> parser) {
+        return safe(value, parser, null);
+    }
+
+    private static <T, R> R safe(T value, Function<T, R> parser, R def) {
+        try {
+            return parser.apply(value);
+        } catch (Exception e) {
+            return def;
+        }
+    }
+
+    public static JdbcStatsStore create(
+        ConfigurationSection config,
+        MobArenaStats plugin
+    ) throws Exception {
+        String type = config.getString("type");
+        String url = config.getString("url");
+        String username = config.getString("username");
+        String password = config.getString("password");
+        Jdbi jdbi = Jdbi.create(url, username, password);
+
+        // Load up migrations and statements for the given type
+        ResourceLoader loader = ResourceLoader.create(plugin.getClass().getClassLoader());
+        Migrations migrations = Migrations.create(loader, type);
+        Statements statements = Statements.create(loader, type);
+        Logger log = plugin.getLogger();
+
+        // Bring database schema up to speed
+        SchemaMigrator migrator = new SchemaMigrator(jdbi, migrations, statements, log);
+        migrator.migrate();
+
+        return new JdbcStatsStore(jdbi, statements);
+    }
+
+}

src/main/java/org/mobarena/stats/store/jdbc/Migrations.java

@@ -0,0 +1,31 @@
+package org.mobarena.stats.store.jdbc;
+
+import org.mobarena.stats.util.ResourceLoader;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.util.List;
+
+class Migrations {
+
+    private final ResourceLoader loader;
+    private final String type;
+
+    private Migrations(ResourceLoader loader, String type) {
+        this.loader = loader;
+        this.type = type;
+    }
+
+    List<String> list() throws URISyntaxException, IOException {
+        return loader.list(type + "/migration");
+    }
+
+    String get(String filename) throws IOException {
+        return loader.loadString(type + "/migration/" + filename);
+    }
+
+    static Migrations create(ResourceLoader loader, String type) {
+        return new Migrations(loader, type);
+    }
+
+}

src/main/java/org/mobarena/stats/store/jdbc/SchemaMigrator.java

@@ -0,0 +1,139 @@
+package org.mobarena.stats.store.jdbc;
+
+import org.jdbi.v3.core.Jdbi;
+import org.jdbi.v3.core.statement.Batch;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+import static org.mobarena.stats.store.jdbc.Statement.FIND_ALL_MIGRATIONS;
+import static org.mobarena.stats.store.jdbc.Statement.INSERT_MIGRATION;
+
+class SchemaMigrator {
+
+    private final Jdbi jdbi;
+    private final Migrations migrations;
+    private final Statements statements;
+    private final Logger log;
+
+    SchemaMigrator(
+        Jdbi jdbi,
+        Migrations migrations,
+        Statements statements,
+        Logger log
+    ) {
+        this.jdbi = jdbi;
+        this.migrations = migrations;
+        this.statements = statements;
+        this.log = log;
+    }
+
+    void migrate() throws IOException, SQLException, URISyntaxException {
+        List<String> filenames = migrations.list();
+        List<String> completed = getCompletedMigrations();
+
+        filenames.removeAll(completed);
+
+        if (filenames.isEmpty()) {
+            log.info("Schema is up to date.");
+            return;
+        }
+
+        if (completed.isEmpty()) {
+            log.info("Schema is has not yet been initialized, migrating...");
+        } else {
+            log.info("Schema is " + filenames.size() + " version(s) behind, migrating...");
+        }
+
+        for (String filename : filenames) {
+            execute(filename);
+        }
+
+        log.info("Schema migration complete.");
+    }
+
+    private List<String> getCompletedMigrations() throws SQLException {
+        return jdbi.withHandle(handle -> {
+            // We don't really have a good way to check if the database has
+            // migration info without making some actual queries, which will
+            // fail if it doesn't. Instead, we can use the database metadata
+            // (available via the underlying JDBC connection object) to find
+            // out if the schema migrations table exists.
+            Connection connection = handle.getConnection();
+            DatabaseMetaData meta = connection.getMetaData();
+            try (ResultSet tables = meta.getTables(null, null, "schema_migrations", null)) {
+                while (tables.next()) {
+                    String name = tables.getString("TABLE_NAME");
+                    if (name.equals("schema_migrations")) {
+                        // Jackpot! We found the table, now query it.
+                        String sql = statements.get(FIND_ALL_MIGRATIONS);
+                        return handle.createQuery(sql)
+                            .map((r, ctx) -> r.getString("filename"))
+                            .list();
+                    }
+                }
+            }
+
+            // No migrations table means fresh database.
+            return Collections.emptyList();
+        });
+    }
+
+    private void execute(String filename) throws IOException {
+        String content = migrations.get(filename);
+
+        // Migration files may contain several different statements,
+        // but not all databases support multiple statements in a
+        // single update, so we split the file contents by semicolon
+        // and hold our breath while we invoke each part...
+        List<String> parts = Arrays.stream(content.split(";"))
+            .map(String::trim)
+            .filter(s -> !s.isEmpty())
+            .collect(Collectors.toList());
+
+        jdbi.useTransaction(handle -> {
+            Instant executed = Instant.now();
+            try {
+                if (parts.size() == 1) {
+                    handle.execute(parts.get(0));
+                } else {
+                    Batch batch = handle.createBatch();
+                    parts.forEach(batch::add);
+                    batch.execute();
+                }
+
+                String sql = statements.get(INSERT_MIGRATION);
+                handle.createUpdate(sql)
+                    .bind("filename", filename)
+                    .bind("executed", executed)
+                    .bind("success", true)
+                    .bind("error", (String) null)
+                    .execute();
+
+                log.info("\u2713 " + filename);
+            } catch (Exception e) {
+                String sql = statements.get(INSERT_MIGRATION);
+                handle.createUpdate(sql)
+                    .bind("filename", filename)
+                    .bind("executed", executed)
+                    .bind("success", false)
+                    .bind("error", e.getMessage())
+                    .execute();
+
+                log.severe("\u2717 " + filename);
+                throw new IllegalStateException("Migration failed: " + filename, e);
+            }
+        });
+    }
+
+}

src/main/java/org/mobarena/stats/store/jdbc/Statement.java

@@ -0,0 +1,19 @@
+package org.mobarena.stats.store.jdbc;
+
+public enum Statement {
+
+    FIND_ALL_MIGRATIONS,
+    INSERT_MIGRATION,
+
+    INSERT_SESSION_DATA,
+    INSERT_PLAYER_DATA,
+    DELETE_SESSION_DATA,
+
+    FIND_ARENA_STATS,
+    FIND_GLOBAL_STATS,
+    FIND_PLAYER_STATS,
+
+    FIND_SESSIONS,
+    FIND_PLAYER_SESSIONS_BY_ID,
+
+}

src/main/java/org/mobarena/stats/store/jdbc/Statements.java

@@ -0,0 +1,32 @@
+package org.mobarena.stats.store.jdbc;
+
+import org.mobarena.stats.util.ResourceLoader;
+
+import java.io.IOException;
+import java.util.EnumMap;
+import java.util.Map;
+
+class Statements {
+
+    private final Map<Statement, String> sql;
+
+    private Statements(Map<Statement, String> sql) {
+        this.sql = sql;
+    }
+
+    String get(Statement statement) {
+        return sql.get(statement);
+    }
+
+    static Statements create(ResourceLoader loader, String type) throws IOException {
+        EnumMap<Statement, String> result = new EnumMap<>(Statement.class);
+        for (Statement statement : Statement.values()) {
+            // SCREAMING_SNAKE_CASE -> kebab-case, .sql file extension
+            String filename = statement.toString().toLowerCase().replace('_', '-') + ".sql";
+            String sql = loader.loadString(type + "/" + filename);
+            result.put(statement, sql);
+        }
+        return new Statements(result);
+    }
+
+}

src/main/java/org/mobarena/stats/store/mariadb/MariadbStatsStore.java

@@ -0,0 +1,39 @@
+package org.mobarena.stats.store.mariadb;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.MemoryConfiguration;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.store.jdbc.JdbcStatsStore;
+
+public class MariadbStatsStore {
+
+    public static JdbcStatsStore create(
+        ConfigurationSection config,
+        MobArenaStats plugin
+    ) throws Exception {
+        ConfigurationSection copy = new MemoryConfiguration();
+        for (String key : config.getKeys(false)) {
+            copy.set(key, config.get(key));
+        }
+
+        // Note the type override of "mysql" here. This ensures that we
+        // reuse the MySQL SQL files from the resources folder.
+        String url = getUrl(copy);
+        copy.set("type", "mysql");
+        copy.set("url", url);
+
+        return JdbcStatsStore.create(copy, plugin);
+    }
+
+    static String getUrl(ConfigurationSection config) {
+        String host = config.getString("host", "localhost");
+        int port = config.getInt("port", 3306);
+        String database = config.getString("database", "mobarena_stats");
+        boolean ssl = config.getBoolean("ssl", false);
+
+        String params = "useSSL=" + ssl;
+
+        return "jdbc:mariadb://" + host + ":" + port + "/" + database + "?" + params;
+    }
+
+}

src/main/java/org/mobarena/stats/store/mysql/MysqlStatsStore.java

@@ -0,0 +1,37 @@
+package org.mobarena.stats.store.mysql;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.MemoryConfiguration;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.store.jdbc.JdbcStatsStore;
+
+public class MysqlStatsStore {
+
+    public static JdbcStatsStore create(
+        ConfigurationSection config,
+        MobArenaStats plugin
+    ) throws Exception {
+        ConfigurationSection copy = new MemoryConfiguration();
+        for (String key : config.getKeys(false)) {
+            copy.set(key, config.get(key));
+        }
+
+        String url = getUrl(copy);
+        copy.set("type", "mysql");
+        copy.set("url", url);
+
+        return JdbcStatsStore.create(copy, plugin);
+    }
+
+    static String getUrl(ConfigurationSection config) {
+        String host = config.getString("host", "localhost");
+        int port = config.getInt("port", 3306);
+        String database = config.getString("database", "mobarena_stats");
+        boolean ssl = config.getBoolean("ssl", false);
+
+        String params = "useSSL=" + ssl;
+
+        return "jdbc:mysql://" + host + ":" + port + "/" + database + "?" + params;
+    }
+
+}

src/main/java/org/mobarena/stats/store/sqlite/SqliteStatsStore.java

@@ -0,0 +1,38 @@
+package org.mobarena.stats.store.sqlite;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.MemoryConfiguration;
+import org.mobarena.stats.MobArenaStats;
+import org.mobarena.stats.store.jdbc.JdbcStatsStore;
+
+import java.io.File;
+
+public class SqliteStatsStore {
+
+    public static JdbcStatsStore create(
+        ConfigurationSection config,
+        MobArenaStats plugin
+    ) throws Exception {
+        ConfigurationSection copy = new MemoryConfiguration();
+        for (String key : config.getKeys(false)) {
+            copy.set(key, config.get(key));
+        }
+
+        File data = plugin.getDataFolder();
+        String url = getUrl(copy, data);
+        copy.set("type", "sqlite");
+        copy.set("url", url);
+        copy.addDefault("username", "sa");
+        copy.addDefault("password", "");
+
+        return JdbcStatsStore.create(copy, plugin);
+    }
+
+    static String getUrl(ConfigurationSection config, File data) {
+        String folder = data.getPath();
+        String filename = config.getString("filename", "stats.db");
+
+        return "jdbc:sqlite:" + folder + "/" + filename;
+    }
+
+}

src/main/java/org/mobarena/stats/util/ResourceLoader.java

@@ -0,0 +1,118 @@
+package org.mobarena.stats.util;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.stream.Collectors;
+
+/**
+ * Lists and loads resources via a given {@link ClassLoader}.
+ * <p>
+ * The primary goal of this class is to provide a developer-friendly
+ * abstraction over Java's complex concept of "resources", allowing
+ * client components to focus their efforts on their own context.
+ * <p>
+ * In general, we know what resources we're looking for, and we just
+ * want to load them into memory and apply them where needed, but we
+ * also want to "scan" resource "folders". The latter is fairly easy
+ * in a file system context, but in a jar-file, while still somewhat
+ * doable, becomes a nightmare to have to do again and again. That's
+ * where this class comes in, as a mild wrapper around something that
+ * can best be described as infuriating.
+ */
+public class ResourceLoader {
+
+    private final ClassLoader loader;
+
+    ResourceLoader(ClassLoader loader) {
+        this.loader = loader;
+    }
+
+    /**
+     * Find all resources that match the given path.
+     *
+     * @param prefix a resource "prefix" to filter resources by
+     * @return a list of all resources that match the given prefix
+     * @throws URISyntaxException if the given path isn't a valid URI
+     * in the context of the class loader
+     * @throws IOException if an I/O error occurs during traversal
+     */
+    public List<String> list(String prefix) throws URISyntaxException, IOException {
+        URL url = loader.getResource(prefix);
+        if (url == null) {
+            throw new NoSuchElementException("No resources found at " + prefix);
+        }
+
+        URI uri = url.toURI();
+        if (uri.getScheme().equals("jar")) {
+            try (FileSystem fs = FileSystems.newFileSystem(uri, Collections.emptyMap())) {
+                Path path = fs.getPath(prefix);
+                return walk(path);
+            }
+        } else {
+            Path path = Paths.get(uri);
+            return walk(path);
+        }
+    }
+
+    private List<String> walk(Path path) throws IOException {
+        // When we traverse the path, we want to skip the folder
+        // denoted by the path itself, and this is always first
+        // in the stream.
+        return Files.walk(path, 1)
+            .skip(1)
+            .map(Path::getFileName)
+            .map(Path::toString)
+            .sorted()
+            .collect(Collectors.toList());
+    }
+
+    /**
+     * Load the resource at the given path, interpreting its contents
+     * as UTF-8 encoded text.
+     *
+     * @param path the path to the resource to load
+     * @return the contents of the resource at the given path
+     * @throws IOException if an I/O error occurs during loading
+     */
+    public String loadString(String path) throws IOException {
+        InputStream is = loader.getResourceAsStream(path);
+        if (is == null) {
+            throw new FileNotFoundException("Resource not found: " + path);
+        }
+
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        byte[] buffer = new byte[1024];
+        int length;
+        while ((length = is.read(buffer)) != -1) {
+            output.write(buffer, 0, length);
+        }
+
+        return output.toString(StandardCharsets.UTF_8.name());
+    }
+
+    /**
+     * Create a new resource loader with the given {@link ClassLoader}
+     * as its source.
+     *
+     * @param loader a class loader to use as a source of resources
+     * @return a new resource loader
+     */
+    public static ResourceLoader create(ClassLoader loader) {
+        return new ResourceLoader(loader);
+    }
+
+}