Merge pull request #19 from temper-mc/fix/dashboard

Use redesigned dashboard

Author: ReCore-sys

src/app/runtime/src/game_loop.rs

@@ -24,7 +24,6 @@ use temper_game_systems::{
 use temper_messages::register_messages;
 use temper_net_runtime::connection::{NewConnection, handle_connection};
 use temper_net_runtime::server::create_server_listener;
-use temper_performance::ServerPerformance;
 use temper_performance::tick::TickData;
 use temper_protocol::{PacketSender, create_packet_senders};
 use temper_resources::register_resources;
@@ -209,7 +208,10 @@ pub fn start_game_loop(global_state: GlobalState, no_tui: bool) -> Result<(), Bi
                 ran_count,
             };
 
-            let mut performance = ecs_world.resource_mut::<ServerPerformance>();
+            let mut performance = global_state
+                .performance
+                .lock()
+                .expect("Failed to lock performance resource");
             performance.tps.record_tick(tick_data);
         }
     }

src/dashboard/Cargo.toml

@@ -14,11 +14,13 @@ serde_json = { workspace = true }
 include_dir = { workspace = true }
 mime_guess = { workspace = true }
 dir-size = { workspace = true }
+uuid = { workspace = true, features = ["serde"] }
 
 # temper local crates
 temper-state = { workspace = true }
 temper-general-purpose = { workspace = true }
 temper-config = { workspace = true }
+temper-performance = { workspace = true }
 
 [build-dependencies]
 reqwest = { workspace = true }

src/dashboard/build.rs

@@ -8,7 +8,7 @@ use zip::ZipArchive;
 // CONFIGURATION
 // Since we set up the GitHub Action to release to 'latest', we can use this URL.
 const DASHBOARD_URL: &str =
-    "https://github.com/ferrumc-rs/dashboard/releases/download/latest/ferrumc-dashboard.zip";
+    "https://github.com/temper-mc/dashboard/releases/download/latest/temper-dashboard.zip";
 
 fn main() -> Result<()> {
     // Tell Cargo about our custom cfg flags to suppress warnings

src/dashboard/src/handshake.rs

@@ -11,6 +11,8 @@ pub struct SystemData {
     pub cpu_cores: usize,
     /// Number of logical threads (including hyperthreading)
     pub cpu_threads: usize,
+    /// OS name and version (e.g., "Windows 10 Pro 10.0.19044")
+    pub os: String,
 }
 
 /// Server configuration data
@@ -42,10 +44,18 @@ impl Handshake {
         let cpu_cores = System::physical_core_count().unwrap_or(1);
         let cpu_threads = sys.cpus().len();
 
+        let os = format!(
+            "{} {} {}",
+            System::name().unwrap_or_default(),
+            System::os_version().unwrap_or_default(),
+            System::kernel_version().unwrap_or_default()
+        );
+
         let system = SystemData {
             cpu_model,
             cpu_cores,
             cpu_threads,
+            os,
         };
 
         let config = ConfigData {

src/dashboard/src/telemetry.rs

@@ -4,10 +4,12 @@ use std::path::PathBuf;
 use std::time::Duration;
 use sysinfo::{Pid, ProcessesToUpdate, System};
 use temper_config::server_config::get_global_config;
+use temper_performance::memory::MemoryUnit;
 use temper_state::GlobalState;
 use tokio::sync::broadcast::Sender;
 use tokio::time::interval;
 use tracing::{debug, error};
+use uuid::Uuid;
 
 #[derive(Clone, Debug, Serialize)]
 pub struct ServerMetric {
@@ -23,6 +25,14 @@ pub struct ServerMetric {
     pub storage_used: u64,
     /// Number of connected players
     pub player_count: usize,
+    pub tps: f32,
+    pub players: Vec<PlayerInfo>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct PlayerInfo {
+    name: String,
+    uuid: Uuid,
 }
 
 /// Events sent from the server to the dashboard (websocket)
@@ -69,15 +79,31 @@ pub async fn start_telemetry_loop(tx: Sender<DashboardEvent>, state: GlobalState
             0
         };
 
+        let cpu_count = sys.cpus().len() as f32;
+
         let player_count = state.players.player_list.len();
+        let mut perf_lock = state
+            .performance
+            .lock()
+            .expect("Failed to lock performance resource");
 
         let metric = ServerMetric {
-            cpu_usage: process.cpu_usage(),
-            ram_usage: process.memory(),
+            cpu_usage: process.cpu_usage() / cpu_count,
+            ram_usage: perf_lock.memory.get_memory(MemoryUnit::Bytes).0,
             total_ram: sys.total_memory(),
             uptime: process.run_time(),
             storage_used,
             player_count,
+            tps: perf_lock.tps.tps(Duration::from_secs(1)),
+            players: state
+                .players
+                .player_list
+                .iter()
+                .map(|kv| PlayerInfo {
+                    name: kv.value().1.clone(),
+                    uuid: Uuid::from_u128(kv.value().0),
+                })
+                .collect(),
         };
 
         // Broadcast to all connected web clients

src/default_commands/src/tps.rs

@@ -1,17 +1,28 @@
+use bevy_ecs::prelude::ResMut;
 use std::time::Duration;
-
-use bevy_ecs::system::ResMut;
 use temper_commands::Sender;
 use temper_macros::command;
-use temper_performance::{memory::MemoryUnit, ServerPerformance};
+use temper_performance::memory::MemoryUnit;
+use temper_state::GlobalStateResource;
 use temper_text::{NamedColor, TextComponent, TextComponentBuilder};
 
 #[command("tps")]
-fn tps_command(#[sender] sender: Sender, performance_res: ResMut<ServerPerformance>) {
-    let performance = performance_res.into_inner();
+fn tps_command(#[sender] sender: Sender, state: ResMut<GlobalStateResource>) {
+    let (current, peak) = {
+        let mut perf_lock = state
+            .0
+            .performance
+            .lock()
+            .expect("Failed to lock performance resource");
+        perf_lock.memory.get_memory(MemoryUnit::Kilobytes)
+    };
 
-    let tps = &performance.tps;
-    let (current, peak) = performance.memory.get_memory(MemoryUnit::Kilobytes);
+    let perf_lock = state
+        .0
+        .performance
+        .lock()
+        .expect("Failed to lock performance resource");
+    let tps = &perf_lock.tps;
 
     sender.send_message(
         TextComponentBuilder::new("Server Performance\n")

src/performance/Cargo.toml

@@ -8,6 +8,7 @@ version.workspace = true
 bevy_ecs = { workspace = true }
 sysinfo = { workspace = true }
 tracing = { workspace = true }
+serde = { workspace = true }
 
 [lints]
 workspace = true

src/performance/src/lib.rs

@@ -1,4 +1,3 @@
-use bevy_ecs::resource::Resource;
 use tracing::warn;
 
 use crate::{memory::MemoryUsage, tps::TPSMonitor};
@@ -9,7 +8,7 @@ pub mod tps;
 
 pub const WINDOW_SECONDS: usize = 60;
 
-/// Core ECS resource for all server performance metrics.
+/// Core tracker for all server performance metrics.
 ///
 /// This resource is updated once per tick by the main scheduler
 /// loop and can be queried by commands, debug tools, or plugins.
@@ -36,7 +35,6 @@ pub const WINDOW_SECONDS: usize = 60;
 /// - Tick durations
 /// - Rolling TPS (1s / 5s / 15s windows)
 /// - Memory Usage (Current / Peak)
-#[derive(Resource)]
 pub struct ServerPerformance {
     pub tps: TPSMonitor,
     pub memory: MemoryUsage,
@@ -45,7 +43,7 @@ pub struct ServerPerformance {
 impl ServerPerformance {
     pub fn new(tps: u32) -> Self {
         if !sysinfo::IS_SUPPORTED_SYSTEM {
-            warn!("System does not support 'sysinfo', disabling server performance statisics.");
+            warn!("System does not support 'sysinfo', metrics are likely to be inaccurate or unavailable");
         }
 
         Self {

src/performance/src/tick.rs

@@ -9,7 +9,7 @@ pub struct TickData {
 }
 #[derive(Debug)]
 pub(crate) struct TickHistory {
-    buffer: VecDeque<TickData>,
+    pub(crate) buffer: VecDeque<TickData>,
     capacity: usize,
 }
 

src/resources/src/lib.rs

@@ -4,10 +4,8 @@ use crate::time::WorldTime;
 use crate::world_sync_tracker::WorldSyncTracker;
 use bevy_ecs::prelude::World;
 use crossbeam_channel::Receiver;
-use temper_config::server_config::get_global_config;
 use temper_entities::PhysicalRegistry;
 use temper_net_runtime::connection::NewConnection;
-use temper_performance::ServerPerformance;
 use temper_state::GlobalStateResource;
 
 pub mod new_conn;
@@ -27,7 +25,6 @@ pub fn register_resources(
         last_synced: std::time::Instant::now(),
     });
     world.insert_resource(WorldTime::default());
-    world.insert_resource(ServerPerformance::new(get_global_config().tps));
     world.insert_resource(ServerCommandReceiver(server_command_recv));
     world.insert_resource(PhysicalRegistry::new());
 }