Add player count prometheus exporting

It is global and dimensions based.
There's also version info in the export now.

cubic-server/Player.cpp

@@ -85,11 +85,13 @@ Player::Player(std::weak_ptr<Client> cli, std::shared_ptr<Dimension> dim, u128 u
     nbt_tag_compound_append(root, display);
 
     this->_inventory->playerInventory().at(14) = protocol::Slot(true, 1, 12, root);
+    PEXP(incrementPlayerCountGlobal);
 }
 
 Player::~Player()
 {
     this->_dim->getWorld()->sendPlayerInfoRemovePlayer(this);
+    PEXP(decrementPlayerCountGlobal);
 
     // Send a disconnect message
     onEvent(Server::getInstance()->getPluginManager(), onPlayerLeave, this);

cubic-server/PrometheusExporter.cpp

@@ -1,6 +1,8 @@
 #include <memory>
 
 #include <prometheus/counter.h>
+#include <prometheus/gauge.h>
+#include <prometheus/info.h>
 #include <prometheus/registry.h>
 
 #include "PrometheusExporter.hpp"
@@ -16,19 +18,34 @@ void PrometheusExporter::registerMetrics()
 {
     _registry = std::make_shared<prometheus::Registry>();
 
-    // Just an example of what you can put here
-    // To add anything else to the metrics follow the readme of prometheus-cpp:
-    // https://github.com/jupp0r/prometheus-cpp/blob/master/README.md
     // clang-format off
     auto &packet_counter = prometheus::BuildCounter()
         .Name("observed_packets_total")
         .Help("Number of observed packets")
         .Register(*_registry);
     // clang-format on
-
     _packet_rx_counter = &packet_counter.Add({{"direction", "rx"}});
     _packet_tx_counter = &packet_counter.Add({{"direction", "tx"}});
 
+    // clang-format off
+    auto& version_info = prometheus::BuildInfo()
+        .Name("versions")
+        .Help("Static info about the server")
+        .Register(*_registry);
+    // clang-format on
+    _version_info = &version_info.Add({{PROGRAM_NAME, PROGRAM_VERSION}});
+
+    // clang-format off
+    auto &player_gauge = prometheus::BuildGauge()
+        .Name("player_count")
+        .Help("Number of players connected")
+        .Register(*_registry);
+    // clang-format on
+    _player_global_gauge = &player_gauge.Add({{"dimension", "global"}});
+    _player_overworld_gauge = &player_gauge.Add({{"dimension", "overworld"}});
+    _player_nether_gauge = &player_gauge.Add({{"dimension", "nether"}});
+    _player_end_gauge = &player_gauge.Add({{"dimension", "end"}});
+
     _exposer.RegisterCollectable(_registry);
 
     _ready = true;

cubic-server/PrometheusExporter.hpp

@@ -22,6 +22,66 @@ class PrometheusExporter {
         if (_ready)
             _packet_tx_counter->Increment();
     }
+    void setPlayerCountGlobal(size_t n)
+    {
+        if (_ready)
+            _player_global_gauge->Set(n);
+    }
+    void setPlayerCountOverworld(size_t n)
+    {
+        if (_ready)
+            _player_overworld_gauge->Set(n);
+    }
+    void setPlayerCountNether(size_t n)
+    {
+        if (_ready)
+            _player_nether_gauge->Set(n);
+    }
+    void setPlayerCountEnd(size_t n)
+    {
+        if (_ready)
+            _player_end_gauge->Set(n);
+    }
+    void incrementPlayerCountGlobal()
+    {
+        if (_ready)
+            _player_global_gauge->Increment();
+    }
+    void incrementPlayerCountOverworld()
+    {
+        if (_ready)
+            _player_overworld_gauge->Increment();
+    }
+    void incrementPlayerCountNether()
+    {
+        if (_ready)
+            _player_nether_gauge->Increment();
+    }
+    void incrementPlayerCountEnd()
+    {
+        if (_ready)
+            _player_end_gauge->Increment();
+    }
+    void decrementPlayerCountGlobal()
+    {
+        if (_ready)
+            _player_global_gauge->Decrement();
+    }
+    void decrementPlayerCountOverworld()
+    {
+        if (_ready)
+            _player_overworld_gauge->Decrement();
+    }
+    void decrementPlayerCountNether()
+    {
+        if (_ready)
+            _player_nether_gauge->Decrement();
+    }
+    void decrementPlayerCountEnd()
+    {
+        if (_ready)
+            _player_end_gauge->Decrement();
+    }
 
 private:
     prometheus::Exposer _exposer;
@@ -30,7 +90,14 @@ class PrometheusExporter {
     prometheus::Counter *_packet_tx_counter;
     prometheus::Counter *_packet_rx_counter;
 
-    bool _ready;
+    prometheus::Info *_version_info; // This is not dynamic yet, but it can be in the future
+
+    prometheus::Gauge *_player_global_gauge;
+    prometheus::Gauge *_player_overworld_gauge;
+    prometheus::Gauge *_player_nether_gauge;
+    prometheus::Gauge *_player_end_gauge;
+
+    std::atomic<bool> _ready;
 };
 
 #endif /* D5AEBC4C_6028_4506_86F2_DA6261F54832 */

cubic-server/default/Overworld.cpp

@@ -1,5 +1,6 @@
 #include "Overworld.hpp"
 
+#include "Dimension.hpp"
 #include "Server.hpp"
 #include "World.hpp"
 #include "default/DefaultWorld.hpp"
@@ -80,3 +81,15 @@ void Overworld::generateChunk(int x, int z, world_storage::GenerationState goalS
     else
         _level.addChunkColumn(pos, shared_from_this());
 }
+
+void Overworld::removePlayer(int32_t entity_id)
+{
+    Dimension::removePlayer(entity_id);
+    PEXP(decrementPlayerCountOverworld);
+}
+
+void Overworld::spawnPlayer(Player &player)
+{
+    Dimension::spawnPlayer(player);
+    PEXP(incrementPlayerCountOverworld);
+}

cubic-server/default/Overworld.hpp

@@ -19,6 +19,8 @@ class Overworld : public Dimension {
     void initialize() override;
     void stop() override;
     void generateChunk(int x, int z, world_storage::GenerationState goalState = world_storage::GenerationState::READY) override;
+    void spawnPlayer(Player &player) override;
+    void removePlayer(int32_t entity_id) override;
 
 private:
     std::future<void> _worldGenFuture;

cubic-server/default/TheEnd.cpp

@@ -1,4 +1,5 @@
 #include "TheEnd.hpp"
+#include "Server.hpp"
 
 void TheEnd::tick()
 {
@@ -18,3 +19,15 @@ void TheEnd::initialize()
     Dimension::initialize();
     this->_isInitialized = true;
 }
+
+void TheEnd::removePlayer(int32_t entity_id)
+{
+    Dimension::removePlayer(entity_id);
+    PEXP(decrementPlayerCountEnd);
+}
+
+void TheEnd::spawnPlayer(Player &player)
+{
+    Dimension::spawnPlayer(player);
+    PEXP(incrementPlayerCountEnd);
+}

cubic-server/default/TheEnd.hpp

@@ -14,6 +14,8 @@ class TheEnd : public Dimension {
 
     void tick() override;
     void initialize() override;
+    void spawnPlayer(Player &player) override;
+    void removePlayer(int32_t entity_id) override;
 };
 
 #endif // CUBICSERVER_DEFAULT_THEEND_HPP

cubic-server/default/TheNether.cpp

@@ -1,4 +1,5 @@
 #include "TheNether.hpp"
+#include "Server.hpp"
 
 void TheNether::initialize()
 {
@@ -18,3 +19,15 @@ void TheNether::tick()
 
     // auto endProcessing = std::chrono::system_clock::now();
 }
+
+void TheNether::removePlayer(int32_t entity_id)
+{
+    Dimension::removePlayer(entity_id);
+    PEXP(decrementPlayerCountNether);
+}
+
+void TheNether::spawnPlayer(Player &player)
+{
+    Dimension::spawnPlayer(player);
+    PEXP(incrementPlayerCountNether);
+}

cubic-server/default/TheNether.hpp

@@ -14,6 +14,8 @@ class TheNether : public Dimension {
 
     void tick() override;
     void initialize() override;
+    void spawnPlayer(Player &player) override;
+    void removePlayer(int32_t entity_id) override;
 };
 
 #endif // CUBICSERVER_DEFAULT_THENETHER_HPP