fix(codebase): Changed git URL in updator to reflect new git name

Added a Token Credential Manager - Closes #4
Added TUI Menu - Closes #2

.gitignore

@@ -1 +1,2 @@
 /target
+cliff.toml

Cargo.toml

@@ -1,9 +1,21 @@
 [package]
-name = "discord_music"
+name = "RhythmWorks"
-version = "0.1.0"
+version = "0.7.0"
 edition = "2024"
 
 [dependencies]
+color-eyre = "0.6.5"
+crossterm = "0.29.0"
+dialoguer = "0.12.0"
+keyring = { version = "3.6.3", features = ["linux-native", "windows-native"] }
+opentelemetry = { version = "0.27.0", features = ["logs", "metrics", "trace"] }
+opentelemetry-appender-log = "0.27.0"
+opentelemetry-appender-tracing = "0.27.0"
+opentelemetry-otlp = { version = "0.27.0", features = ["trace", "metrics", "grpc-tonic", "http-proto", "tls", "reqwest-client", "reqwest-rustls", "logs"] }
+opentelemetry-proto = "0.27.0"
+opentelemetry-semantic-conventions = "0.27.0"
+opentelemetry_sdk = { version = "0.27.0", features = ["logs", "rt-tokio", "trace"] }
+ratatui = { version = "0.30.0", features = ["all-widgets"] }
 reqwest = { version = "0.12.28", features = ["blocking", "json"] }
 semver = "1.0.27"
 serde = "1.0.228"
@@ -12,4 +24,20 @@ serenity = { version = "0.12.5", features = ["client", "gateway", "voice"] }
 songbird = { version = "0.5.0", features = ["builtin-queue", "driver", "serenity"] }
 symphonia = { version = "0.5.5", features = ["aac", "alac", "isomp4", "mp3"] }
 tokio = "1.48.0"
+tokio-util = "0.7.18"
+tonic = { version = "0.12.3", features = ["tls-roots"] }
+tracing = "0.1.41"
+tracing-opentelemetry = "0.32.0"
+tracing-subscriber = "0.3.20"
 yt-dlp = "1.4.7"
+
+
+[profile.release]
+opt-level = "z"
+lto = "fat"
+debug = false
+codegen-units = 1
+panic = 'abort'
+strip = true
+debug-assertions = false
+overflow-checks = true

README.md

@@ -0,0 +1,30 @@
+## Welcome to RhythmWorks
+RhythmWorks is a lightweight Discord music bot designed for simple, direct audio playback from YouTube links. It focuses on manual control, minimal complexity, and local execution, making it ideal for personal servers or small communities.
+
+Unlike many modern Discord bots, RhythmWorks does not rely on hosted services or third-party dashboards. You run it yourself, connect it to your Discord server, and control playback using straightforward text commands.
+
+### Features
+- Play Audio directly from YouTube 
+- Basic Playback Controls
+- Runs locally on your machine
+- No external accounts or external bot hosting required
+
+### How It Works
+RhythmWorks connects to Discord using a custom bot that you generate through the Discord Developer Portal
+
+### Roadmap
+[Project Roadmap](https://git.racooncity.org/brotoskyj/RhythmWorks/projects/4)
+
+### Getting Started
+Please follow the [Getting Started](https://git.racooncity.org/brotoskyj/RhythmWorks/wiki/Getting-Started) Documentation for details on how to get RhythmWorks up and running
+
+### Discord Commands
+Please review the [Commands](https://git.racooncity.org/brotoskyj/RhythmWorks/wiki/Commands) for usage
+
+### Wiki
+[RhythmWorks Wiki](https://git.racooncity.org/brotoskyj/RhythmWorks/wiki/?action=_pages) - Please review this all for all documentation
+
+## License
+
+[AGPLv3](https://choosealicense.com/licenses/agpl-3.0/)
+

build.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+cargo clean
+cargo fmt
+cargo clippy --fix --all-targets --allow-dirty
+cargo build --release
+cargo build --release --target x86_64-pc-windows-gnu

changelog.md

@@ -0,0 +1 @@
+## [0.5.2] - 2026-01-21

src/main.rs

@@ -1,25 +1,77 @@
+use dialoguer::Select;
+use dialoguer::theme::ColorfulTheme;
 use modules::*;
+use opentelemetry::KeyValue;
+use opentelemetry::global;
+use opentelemetry::trace::Status;
+use opentelemetry::trace::TraceContextExt;
+use opentelemetry::trace::Tracer;
 use serenity::all::ChannelId;
 use serenity::async_trait;
 use serenity::model::channel::Message;
 use serenity::model::gateway::Ready;
 use serenity::prelude::*;
+use songbird::Event;
+use songbird::EventContext;
 use songbird::SerenityInit;
+use songbird::events::EventHandler as VoiceEventHandler;
 use songbird::get;
 use songbird::input::HlsRequest;
 use songbird::input::Input;
-use songbird::tracks::TrackHandle;
+use tracing::instrument;
-use std::collections::HashMap;
 use std::env;
 use std::process::Command;
 use std::process::Stdio;
-use std::sync::Arc;
+use tokio::task::JoinHandle;
-pub mod modules;
+use tokio_util::sync::CancellationToken;
+use tracing::level_filters::LevelFilter;
+use tracing_subscriber::Layer;
+use tracing_subscriber::filter::Targets;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
 
-type TrackMap = Arc<Mutex<HashMap<u64, TrackHandle>>>;
+pub mod modules;
-struct Handler {
+enum BotState {
-    track_map: TrackMap,
+    Stopped,
+    Running,
 }
+struct TrackTraceHandler {
+    otel_ctx: opentelemetry::Context,
+    guild_id: String,
+    track_url: String,
+    hls_url: String,
+    event_name: &'static str,
+}
+
+#[async_trait]
+impl VoiceEventHandler for TrackTraceHandler {
+    async fn act(&self, ctx: &EventContext<'_>) -> Option<Event> {
+        let tracer = global::tracer("RhythmWorks");
+        let track_status = if let EventContext::Track(track_list) = ctx {
+            track_list.first().map(|state| format!("{:?}", state.0))
+        } else {
+            None
+        };
+        tracer.in_span(self.event_name, |cx| {
+            cx.span()
+                .set_attribute(KeyValue::new("Guild_ID", self.guild_id.clone()));
+            cx.span()
+                .set_attribute(KeyValue::new("Youtube_URL", self.track_url.clone()));
+            cx.span()
+                .set_attribute(KeyValue::new("Stream_URL", self.hls_url.clone()));
+            cx.span().add_event(
+                self.event_name,
+                vec![KeyValue::new(
+                    "track_status",
+                    track_status.unwrap().to_string(),
+                )],
+            );
+        });
+
+        None
+    }
+}
+struct Handler;
 fn get_user_voice_channel(ctx: &Context, msg: &Message) -> Option<ChannelId> {
     let guild_id = msg.guild_id?;
     let guild = ctx.cache.guild(guild_id)?;
@@ -38,13 +90,51 @@ impl EventHandler for Handler {
             println!("Error sending message: {why:?}");
         }
         if msg.content == "!join" {
+            let tracer = global::tracer("RhythmWorks");
+            let span = tracer.start("Join Message Received");
+            let cx = opentelemetry::Context::current_with_span(span);
             let guild_id = match msg.guild_id {
-                Some(g) => g,
+                Some(g) => {
-                None => return,
+                    tracing::info!("Received Guild ID");
-            };
+                    cx.span().add_event(
-            let channel_id = match get_user_voice_channel(&ctx, &msg) {
+                        "Received Guild ID",
-                Some(c) => c,
+                        vec![KeyValue::new("Server ID", g.to_string())],
+                    );
+                    cx.span().set_status(opentelemetry::trace::Status::Ok);
+                    cx.span()
+                        .set_attribute(KeyValue::new("Guild_ID", g.to_string()));
+                    g
+                }
                 None => {
+                    cx.span().add_event(
+                        "Failed to Retreive Guild ID",
+                        vec![KeyValue::new("Server ID", "None")],
+                    );
+                    cx.span()
+                        .set_status(opentelemetry::trace::Status::error("Failed"));
+                    return;
+                }
+            };
+
+            let channel_id = match get_user_voice_channel(&ctx, &msg) {
+                Some(c) => {
+                    cx.span().add_event(
+                        "Received Channel ID",
+                        vec![KeyValue::new("Channel ID", c.to_string())],
+                    );
+                    cx.span().set_status(Status::Ok);
+                    c
+                }
+                None => {
+                    cx.span().add_event(
+                        "Failed to Retreive Channel ID",
+                        vec![KeyValue::new("Channel ID", "None")],
+                    );
+                    cx.span()
+                        .set_status(opentelemetry::trace::Status::error(format!(
+                            "{} not in Voice Channel",
+                            msg.author
+                        )));
                     let _ = msg
                         .channel_id
                         .say(&ctx.http, "You must be in a voice channel")
@@ -52,7 +142,6 @@ impl EventHandler for Handler {
                     return;
                 }
             };
-
             let manager = get(&ctx).await.expect("Songbird not initialized").clone();
 
             let _ = manager.join(guild_id, channel_id).await;
@@ -61,6 +150,11 @@ impl EventHandler for Handler {
                 .channel_id
                 .say(&ctx.http, "Joined your voice channel!")
                 .await;
+            cx.span().add_event(
+                "Joined Voice Channel",
+                vec![KeyValue::new("Voice Channel", msg.channel_id.to_string())],
+            );
+            cx.span().set_status(Status::Ok);
         }
         if msg.content == "!leave" {
             let guild_id = match msg.guild_id {
@@ -77,58 +171,168 @@ impl EventHandler for Handler {
             }
         }
         if msg.content.starts_with("!play") {
-            let url = msg
+            let tracer = global::tracer("RhythmWorks");
+            let span = tracer.start("Play Message Received");
+            let mut yt_url = msg
                 .content
                 .strip_prefix("!play ")
                 .unwrap_or("")
                 .trim()
                 .to_string();
-
+            if let Some(offset) = yt_url.find('&') {
-            if url.is_empty() {
+                yt_url.truncate(offset);
+            }
+            if yt_url.is_empty() {
                 let _ = msg.reply(&ctx, "Please provide a YouTube URL.").await;
                 return;
             }
-            let guild_id = msg.guild_id.unwrap();
+            let cx = opentelemetry::Context::current_with_span(span);
-            let manager = songbird::get(&ctx)
+            cx.span()
-                .await
+                .set_attribute(KeyValue::new("Youtube_URL", yt_url.to_string()));
-                .expect("Songbird Voice client placed in at initialisation.")
+            let guild_id = match msg.guild_id {
-                .clone();
+                Some(g) => {
-            let handler_lock = if let Some(handler) = manager.get(guild_id) {
+                    cx.span().add_event(
-                handler
+                        "Received Guild ID",
-            } else {
+                        vec![KeyValue::new("Server ID", g.to_string())],
-                let channel_id = get_user_voice_channel(&ctx, &msg);
+                    );
-                match channel_id {
+                    cx.span().set_status(opentelemetry::trace::Status::Ok);
-                    Some(c) => manager.join(guild_id, c).await.unwrap(),
+                    cx.span()
+                        .set_attribute(KeyValue::new("Guild_ID", g.to_string()));
+                    g
+                }
                 None => {
-                        let _ = msg.reply(&ctx, "Join a voice channel first!").await;
+                    cx.span().add_event(
+                        "Failed to Retreive Guild ID",
+                        vec![KeyValue::new("Server ID", "None")],
+                    );
+                    cx.span()
+                        .set_status(opentelemetry::trace::Status::error("Failed"));
                     return;
                 }
+            };
+            let manager = songbird::get(&ctx).await.unwrap().clone();
+            let handler_lock = if let Some(call) = manager.get(guild_id) {
+                call
+            } else {
+                let channel_id = match get_user_voice_channel(&ctx, &msg) {
+                    Some(c) => c,
+                    None => {
+                        cx.span().add_event(
+                            "Failed to Retreive Channel ID",
+                            vec![KeyValue::new("Channel ID", "None")],
+                        );
+                        cx.span()
+                            .set_status(opentelemetry::trace::Status::error(format!(
+                                "{} not in Voice Channel",
+                                msg.author
+                            )));
+                        let _ = msg
+                            .channel_id
+                            .say(&ctx.http, "You must be in a voice channel")
+                            .await;
+                        return;
                     }
                 };
-            let output = Command::new("yt-dlp")
+                manager.join(guild_id, channel_id).await.unwrap()
-                .args(["-f", "bestaudio", "-g", &url])
+            };
+            let output = match Command::new("./yt-dlp")
+                .args(["-f", "bestaudio", "-g", "--no-playlist", &yt_url])
                 .stdout(Stdio::piped())
                 .output()
-                .expect("Failed");
+            {
-            let url_bytes = output.stdout;
+                Ok(output) => {
-            let url = String::from_utf8(url_bytes).expect("Failed");
+                    cx.span().add_event(
-            let mut handler = handler_lock.lock().await;
+                        "Retreiving Youtube Information",
-            let input = Input::from(HlsRequest::new(reqwest::Client::new(), url.to_string()));
+                        vec![KeyValue::new("Success", yt_url.to_string())],
-            let track_handle = handler.play_input(input);
+                    );
-            let _ = track_handle.play();
+                    output
-            self.track_map
+                }
-                .lock()
+                Err(e) => {
-                .await
+                    cx.span().add_event(
-                .insert(guild_id.into(), track_handle);
+                        "Retreiving Youtube Information",
-            let _ = msg.channel_id.say(&ctx.http, "🎶 Playing...").await;
+                        vec![KeyValue::new("Failed", e.to_string())],
+                    );
+                    cx.span().set_status(Status::error("Failed"));
+                    eprintln!("{}", e);
+                    return;
+                }
+            };
+            let stream_url = String::from_utf8(output.stdout)
+                .expect("Invalid UTF-8")
+                .trim()
+                .to_string();
+            let telemetry_stream_url = stream_url.clone();
+            let mut call = handler_lock.lock().await;
+            let input = Input::from(HlsRequest::new(reqwest::Client::new(), stream_url));
+            let track_handle = call.enqueue_input(input).await;
+            let otel_ctx = opentelemetry::Context::current();
+            let position = call.queue().len();
+            let response = if position == 1 {
+                cx.span().add_event(
+                    "Starting Playback",
+                    vec![KeyValue::new("Status", "Playing".to_string())],
+                );
+                "🎶 Now playing!".to_string()
+            } else {
+                cx.span().add_event(
+                    "Starting Playback",
+                    vec![KeyValue::new("Status", "Added to Queue".to_string())],
+                );
+                format!("🎶 Added Song to Queue: #{}", position)
+            };
+            let _ = msg.channel_id.say(&ctx.http, response).await;
+            let _ = track_handle.add_event(
+                Event::Track(songbird::events::TrackEvent::Play),
+                TrackTraceHandler {
+                    otel_ctx: otel_ctx.clone(),
+                    guild_id: guild_id.to_string().clone(),
+                    track_url: yt_url.clone(),
+                    hls_url: telemetry_stream_url.clone(),
+                    event_name: "Track Started Playing",
+                },
+            );
+            let _ = track_handle.add_event(
+                Event::Track(songbird::events::TrackEvent::End),
+                TrackTraceHandler {
+                    otel_ctx: otel_ctx.clone(),
+                    guild_id: guild_id.to_string().clone(),
+                    track_url: yt_url.clone(),
+                    hls_url: telemetry_stream_url.clone(),
+                    event_name: "Track Finished",
+                },
+            );
+            let _ = track_handle.add_event(
+                Event::Track(songbird::events::TrackEvent::Error),
+                TrackTraceHandler {
+                    otel_ctx: otel_ctx.clone(),
+                    guild_id: guild_id.to_string().clone(),
+                    track_url: yt_url.clone(),
+                    hls_url: telemetry_stream_url.clone(),
+                    event_name: "Playback had an error",
+                },
+            );
+        }
+        if msg.content == "!skip" {
+            let guild_id = match msg.guild_id {
+                Some(g) => g,
+                None => return,
+            };
+            let manager = songbird::get(&ctx).await.unwrap();
+            if let Some(call) = manager.get(guild_id) {
+                let call = call.lock().await;
+                let _ = call.queue().skip();
+                let _ = msg.channel_id.say(&ctx.http, "Skipped").await;
+            }
         }
         if msg.content == "!pause" {
             let guild_id = match msg.guild_id {
                 Some(g) => g,
                 None => return,
             };
-            if let Some(handle) = self.track_map.lock().await.get(&guild_id.into()) {
+            let manager = songbird::get(&ctx).await.unwrap();
-                let _ = handle.pause();
+            if let Some(call) = manager.get(guild_id) {
+                let call = call.lock().await;
+                let _ = call.queue().pause();
             }
         }
         if msg.content == "!resume" {
@@ -136,8 +340,10 @@ impl EventHandler for Handler {
                 Some(g) => g,
                 None => return,
             };
-            if let Some(handle) = self.track_map.lock().await.get(&guild_id.into()) {
+            let manager = songbird::get(&ctx).await.unwrap();
-                let _ = handle.play();
+            if let Some(call) = manager.get(guild_id) {
+                let call = call.lock().await;
+                let _ = call.queue().resume();
             }
         }
         if msg.content == "!stop" {
@@ -145,8 +351,10 @@ impl EventHandler for Handler {
                 Some(g) => g,
                 None => return,
             };
-            if let Some(handle) = self.track_map.lock().await.get(&guild_id.into()) {
+            let manager = songbird::get(&ctx).await.unwrap();
-                let _ = handle.stop();
+            if let Some(call) = manager.get(guild_id) {
+                let call = call.lock().await;
+                let _ = call.queue().stop();
             }
         }
     }
@@ -154,25 +362,112 @@ impl EventHandler for Handler {
         println!("{} is connected!", ready.user.name);
     }
 }
-#[tokio::main]
+async fn run_bot(token: String, shutdown: CancellationToken) {
-async fn main() {
-    println!("RhythmWorks  Copyright (C) 2025  James Brotosky\n
-This program comes with ABSOLUTELY NO WARRANTY\n
-This is free software, and you are welcome to redistribute it under certain conditions.");
-    updator::update().await;
-    let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");
     let intents = GatewayIntents::GUILD_MESSAGES
         | GatewayIntents::GUILDS
         | GatewayIntents::DIRECT_MESSAGES
         | GatewayIntents::MESSAGE_CONTENT
         | GatewayIntents::GUILD_VOICE_STATES;
-    let track_map: TrackMap = Arc::new(Mutex::new(HashMap::new()));
+
     let mut client = Client::builder(&token, intents)
-        .event_handler(Handler { track_map })
+        .event_handler(Handler)
         .register_songbird()
         .await
         .expect("Err creating client");
-    if let Err(why) = client.start().await {
+
+    tokio::select! {
+        result = client.start() => {
+            if let Err(why) = result {
                 println!("Client error: {why:?}");
             }
+        }
+        _ = shutdown.cancelled() => {
+            println!("Shutting down bot...");
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    println!(
+        "RhythmWorks  Copyright (C) 2025  James Brotosky\n
+This program comes with ABSOLUTELY NO WARRANTY\n
+This is free software, and you are welcome to redistribute it under certain conditions."
+    );
+    let (tracer_provider, logger_provider) = telemetry::init_telemetry();
+    global::set_tracer_provider(tracer_provider.clone());
+    let filter = Targets::new()
+        .with_target("RhythmWorks", LevelFilter::INFO)
+        .with_default(LevelFilter::OFF);
+    let otel_log_layer =
+        opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge::new(&logger_provider)
+            .with_filter(filter);
+    tracing_subscriber::registry().with(otel_log_layer).init();
+    let tracer: global::BoxedTracer = global::tracer("tracer");
+    tracer
+        .in_span("Checking for Updates", |_cx| updator::update())
+        .await;
+    let service_name = "RhythmWorks";
+    let username = env::var("USER").or_else(|_| env::var("USERNAME")).unwrap();
+    let mut bot_task: Option<JoinHandle<()>> = None;
+    let mut shutdown_token: Option<CancellationToken> = None;
+    let mut bot_state = BotState::Stopped;
+    loop {
+        let token = credentialmanager::get_token(service_name, &username);
+        let options: Vec<&'static str> = vec![
+            "- Start Bot",
+            "- Stop Bot",
+            "- Change Token",
+            "- Delete Token",
+            "- Exit",
+        ];
+        let selection = Select::with_theme(&ColorfulTheme::default())
+            .with_prompt("Choose an Option")
+            .default(0)
+            .items(&options)
+            .interact()
+            .unwrap();
+        match selection {
+            0 => {
+                if matches!(bot_state, BotState::Running) {
+                    println!("[x] Bot is already running.");
+                    continue;
+                }
+
+                let token = credentialmanager::get_token(service_name, &username);
+                let shutdown = CancellationToken::new();
+                let shutdown_clone = shutdown.clone();
+
+                let task = tokio::spawn(run_bot(token, shutdown_clone));
+
+                bot_task = Some(task);
+                shutdown_token = Some(shutdown);
+                bot_state = BotState::Running;
+
+                println!("✅ Bot started.");
+            }
+            1 => {
+                if let Some(token) = shutdown_token.take() {
+                    token.cancel();
+                }
+                if let Some(task) = bot_task.take() {
+                    let _ = task.await;
+                }
+                println!("Bot stopped.");
+            }
+            2 => {
+                credentialmanager::change_token(service_name, &username);
+            }
+            3 => {
+                credentialmanager::remove_token(service_name, &username);
+            }
+            4 => {
+                if let Some(token) = shutdown_token {
+                    token.cancel();
+                }
+                break;
+            }
+            _ => println!("Invalid Option"),
+        }
+    }
 }

src/modules/credentialmanager.rs

@@ -0,0 +1,37 @@
+use dialoguer::{Input, theme::ColorfulTheme};
+use keyring::Entry;
+
+pub fn get_token<'a>(service: &str, username: &str) -> String {
+    let entry = Entry::new(service, username).expect("Failed to get keyring entry");
+    match entry.get_password() {
+        Ok(token) => token,
+        Err(_) => {
+            let token: String = Input::with_theme(&ColorfulTheme::default())
+                .with_prompt("Enter your bot token")
+                .interact_text()
+                .unwrap();
+            match entry.set_password(&token) {
+                Ok(_) => {}
+                Err(e) => {
+                    println!("Failed to set token: {}", e);
+                    std::process::abort()
+                }
+            };
+            token
+        }
+    }
+}
+
+pub fn change_token(service: &str, username: &str) {
+    let entry = Entry::new(service, username).expect("Failed to get keyring entry");
+    let new_token: String = Input::with_theme(&ColorfulTheme::default())
+        .with_prompt("New Token")
+        .interact_text()
+        .unwrap();
+    let _ = entry.set_password(&new_token);
+}
+
+pub fn remove_token(service: &str, username: &str) {
+    let entry = Entry::new(service, username).expect("Failed to get keyring entry");
+    let _ = entry.delete_credential();
+}

src/modules/mod.rs

@@ -1,2 +1,3 @@
+pub mod credentialmanager;
+pub mod telemetry;
 pub mod updator;
-pub mod downloadyt;

src/modules/telemetry.rs

@@ -0,0 +1,44 @@
+use opentelemetry::KeyValue;
+use opentelemetry::global;
+use opentelemetry_otlp::{WithExportConfig, WithTonicConfig};
+use opentelemetry_sdk::{Resource, logs, runtime};
+use tonic::transport::{Channel, ClientTlsConfig};
+
+pub fn init_telemetry() -> (
+    opentelemetry_sdk::trace::TracerProvider,
+    opentelemetry_sdk::logs::LoggerProvider,
+) {
+    let endpoint = "https://signoz.racooncity.org".to_string();
+    let channel = Channel::from_shared(endpoint.clone())
+        .unwrap()
+        .tls_config(ClientTlsConfig::new().with_native_roots())
+        .unwrap()
+        .connect_lazy();
+    let exporter = opentelemetry_otlp::SpanExporter::builder()
+        .with_tonic()
+        .with_endpoint(endpoint.clone())
+        .with_channel(channel.clone())
+        .build()
+        .expect("Failed to Build Exporter");
+    let log_exporter = opentelemetry_otlp::LogExporter::builder()
+        .with_tonic()
+        .with_endpoint(endpoint.clone())
+        .with_channel(channel.clone())
+        .build()
+        .expect("Failed to build log exporter");
+    let logger_provider = logs::LoggerProvider::builder()
+        .with_resource(Resource::new(vec![KeyValue::new(
+            "service.name",
+            "RhythmWorks",
+        )]))
+        .with_batch_exporter(log_exporter, runtime::Tokio)
+        .build();
+    let tracer_provider = opentelemetry_sdk::trace::TracerProvider::builder()
+        .with_batch_exporter(exporter, runtime::Tokio)
+        .with_resource(Resource::new(vec![KeyValue::new(
+            "service.name",
+            "RhythmWorks",
+        )]))
+        .build();
+    (tracer_provider, logger_provider)
+}

src/modules/updator.rs

@@ -1,20 +1,29 @@
-use serde::Deserialize;
+use std::thread;
-use semver::Version;
+
 use reqwest;
+use semver::Version;
+use serde::Deserialize;
 #[derive(Deserialize, Debug)]
 struct Release {
     tag_name: String,
 }
 
 pub async fn update() {
-    let body  = reqwest::get("https://git.racooncity.org/api/v1/repos/brotoskyj/RhythmWorks/releases/latest").await.unwrap().text().await.unwrap();
+    let body = reqwest::get(
+        "https://git.racooncity.org/api/v1/repos/mysticmomba/RhythmWorks/releases/latest",
+    )
+    .await
+    .unwrap()
+    .text()
+    .await
+    .unwrap();
     let release_info: Release = serde_json::from_str(&body).unwrap();
     let latest_version = Version::parse(&release_info.tag_name).unwrap();
     let current_version = Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
     if latest_version > current_version {
-        println!("Update Available")
+        println!("Update Available! Please download the latest version");
-    }
+        println!("URL: https://git.racooncity.org/mysticmomba/RhythmWorks/releases");
-    else {
+        thread::sleep(std::time::Duration::from_secs(10));
-        println!("Already on current version");
+        std::process::exit(1);
     }
 }