feat: server checking system rewrite & sentry integration

dest4590 · dest4590 · commit 7840edf70275 · 2025-12-12T15:23:43.000+02:00
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -16,6 +16,7 @@
     },
     "dependencies": {
         "@guolao/vue-monaco-editor": "1.6.0",
+        "@sentry/vue": "^10.30.0",
         "@tauri-apps/api": "2.9.1",
         "@tauri-apps/plugin-dialog": "2.4.2",
         "@tauri-apps/plugin-fs": "2.4.4",
diff --git a/src-tauri/src/commands/clients.rs b/src-tauri/src/commands/clients.rs
@@ -82,8 +82,9 @@ pub fn initialize_rpc() -> Result<(), String> {
 }
 
 #[tauri::command]
-pub fn get_server_connectivity_status() -> ServerConnectivityStatus {
+pub async fn get_server_connectivity_status() -> ServerConnectivityStatus {
     let servers = &SERVERS;
+    servers.wait_for_initial_check().await;
     servers.connectivity_status.lock().unwrap().clone()
 }
 
diff --git a/src-tauri/src/core/network/servers.rs b/src-tauri/src/core/network/servers.rs
@@ -2,60 +2,16 @@ use crate::{
     core::utils::globals::{AUTH_SERVERS, CDN_SERVERS},
     log_info, log_warn,
 };
-use backoff::{future::retry, ExponentialBackoff};
 use reqwest::Client;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::{Arc, LazyLock, Mutex, RwLock};
-use std::time::{Duration, Instant};
+use std::sync::{LazyLock, Mutex, RwLock};
+use std::time::Duration;
+use tokio::sync::watch;
 
-const REQUEST_TIMEOUT: Duration = Duration::from_secs(5);
-const CB_MAX_FAILURES: usize = 3;
-const CB_RESET_WINDOW: Duration = Duration::from_secs(60);
-const BACKOFF_MAX_ELAPSED: Duration = Duration::from_secs(10);
-
-#[derive(Debug)]
-pub struct CircuitBreaker {
-    failures: AtomicUsize,
-    last_failure: Mutex<Option<Instant>>,
-}
-
-impl CircuitBreaker {
-    fn new() -> Self {
-        Self {
-            failures: AtomicUsize::new(0),
-            last_failure: Mutex::new(None),
-        }
-    }
-
-    fn record_failure(&self) {
-        self.failures.fetch_add(1, Ordering::SeqCst);
-        let mut last = self.last_failure.lock().unwrap();
-        *last = Some(Instant::now());
-    }
-
-    fn record_success(&self) {
-        self.failures.store(0, Ordering::SeqCst);
-    }
-
-    fn is_open(&self) -> bool {
-        if self.failures.load(Ordering::SeqCst) < CB_MAX_FAILURES {
-            return false;
-        }
-        let last = self.last_failure.lock().unwrap();
-        if let Some(time) = *last {
-            if time.elapsed() < CB_RESET_WINDOW {
-                return true;
-            }
-        }
-        false
-    }
-}
+const REQUEST_TIMEOUT: Duration = Duration::from_secs(10);
 
 #[derive(Debug, Clone, serde::Serialize)]
 pub struct Server {
     pub url: String,
-    #[serde(skip)]
-    pub circuit_breaker: Arc<CircuitBreaker>,
 }
 
 #[derive(Debug, Clone, serde::Serialize)]
@@ -71,13 +27,14 @@ pub struct Servers {
     pub selected_cdn: RwLock<Option<Server>>,
     pub selected_auth: RwLock<Option<Server>>,
     pub connectivity_status: Mutex<ServerConnectivityStatus>,
+    pub check_complete_tx: watch::Sender<bool>,
+    pub check_complete_rx: watch::Receiver<bool>,
 }
 
 impl Server {
     pub fn new(url: &str) -> Self {
         Self {
             url: url.to_string(),
-            circuit_breaker: Arc::new(CircuitBreaker::new()),
         }
     }
 }
@@ -99,6 +56,8 @@ impl Servers {
             None
         };
 
+        let (tx, rx) = watch::channel(false);
+
         Self {
             cdns,
             auths,
@@ -108,6 +67,8 @@ impl Servers {
                 cdn_online: false,
                 auth_online: false,
             }),
+            check_complete_tx: tx,
+            check_complete_rx: rx,
         }
     }
 
@@ -123,6 +84,15 @@ impl Servers {
             .await;
 
         self.set_status();
+        let _ = self.check_complete_tx.send(true);
+    }
+
+    pub async fn wait_for_initial_check(&self) {
+        let mut rx = self.check_complete_rx.clone();
+        if *rx.borrow_and_update() {
+            return;
+        }
+        let _ = rx.changed().await;
     }
 
     async fn check_group(
@@ -133,51 +103,33 @@ impl Servers {
         name: &str,
     ) {
         for server in servers {
-            if server.circuit_breaker.is_open() {
-                log_warn!("Skipping {} Server {}", name, server.url);
-                continue;
-            }
-
-            let op = || async {
-                let resp = client.head(&server.url).send().await.map_err(|e| {
-                    backoff::Error::<Box<dyn std::error::Error + Send + Sync>>::transient(Box::new(
-                        e,
-                    ))
-                })?;
-                if !resp.status().is_success() {
-                    return Err(
-                        backoff::Error::<Box<dyn std::error::Error + Send + Sync>>::transient(
-                            format!("Status not success: {}", resp.status()).into(),
-                        ),
-                    );
-                }
-                Ok(resp)
-            };
-
-            let backoff = ExponentialBackoff {
-                max_elapsed_time: Some(BACKOFF_MAX_ELAPSED),
-                ..Default::default()
-            };
-
-            match retry(backoff, op).await {
-                Ok(response) => {
-                    log_info!(
-                        "{} Server {} responded with: {}",
-                        name,
-                        server.url,
-                        response.status()
-                    );
-                    server.circuit_breaker.record_success();
-                    let mut lock = selected.write().unwrap();
-                    *lock = Some(server.clone());
-                    return;
+            match client.head(&server.url).send().await {
+                Ok(resp) => {
+                    if resp.status().is_success() {
+                        log_info!(
+                            "{} Server {} responded with: {}",
+                            name,
+                            server.url,
+                            resp.status()
+                        );
+                        let mut lock = selected.write().unwrap();
+                        *lock = Some(server.clone());
+                        return;
+                    } else {
+                        log_warn!(
+                            "{} Server {} returned status: {}",
+                            name,
+                            server.url,
+                            resp.status()
+                        );
+                    }
                 }
                 Err(e) => {
                     log_warn!("Failed to connect to {} Server {}: {}", name, server.url, e);
-                    server.circuit_breaker.record_failure();
                 }
             }
         }
+
         let mut lock = selected.write().unwrap();
         *lock = None;
     }
diff --git a/src/components/features/social/InlineIRCChat.vue b/src/components/features/social/InlineIRCChat.vue
@@ -1,5 +1,6 @@
 <template>
-    <div class="irc-chat flex flex-col bg-base-200 border border-base-300 rounded-lg overflow-hidden transition-all duration-300 ease-out relative mb-6"
+    <div v-bind="attrs"
+        class="irc-chat flex flex-col bg-base-200 border border-base-300 rounded-lg overflow-hidden transition-all duration-300 ease-out relative mb-6"
         :class="isExpanded ? 'shadow-lg max-h-[380px]' : 'shadow-sm max-h-[68px] hover:shadow-md'">
         <button type="button" class="flex items-center justify-between w-full px-4 py-3 bg-base-300/40 cursor-pointer"
             @click="toggleExpanded">
@@ -80,12 +81,14 @@
 </template>
 
 <script setup lang="ts">
-import { computed, nextTick, onMounted, ref, watch, onUnmounted } from 'vue';
+import { computed, nextTick, onMounted, ref, watch, onUnmounted, useAttrs } from 'vue';
+defineOptions({ inheritAttrs: false });
 import { CheckCircle2, ChevronDown, Loader2, MessageSquare, RefreshCw, WifiOff, AtSign, Copy } from 'lucide-vue-next';
 import { useToast } from '../../../services/toastService';
 import { useIrcChat } from '../../../composables/useIrcChat';
 import { useI18n } from 'vue-i18n';
 
+const attrs = useAttrs();
 const { messages, connected, status, sendIrcMessage, forceReconnect, ensureIrcConnection } = useIrcChat();
 const { t } = useI18n();
 const inputMessage = ref('');
diff --git a/src/composables/useIrcChat.ts b/src/composables/useIrcChat.ts
@@ -156,7 +156,7 @@ export const ensureIrcConnection = async (isReconnect = false): Promise<void> =>
         status.value = isReconnect ? 'reconnecting' : 'connecting';
         const token = localStorage.getItem('authToken') || '';
         const tokenPresent = token.length > 0;
-        console.debug('IRC: attempting connect, token present=', tokenPresent);
+        console.debug('IRC: attempting connect, token present =', tokenPresent);
 
         clearReconnectTimer();
         await invoke('connect_irc', { token: tokenPresent ? token : null });
diff --git a/src/main.ts b/src/main.ts
@@ -5,16 +5,30 @@ import i18n from './i18n/index';
 import { initializeAuthUrl } from './config';
 import { loader } from '@guolao/vue-monaco-editor';
 
+import * as Sentry from "@sentry/vue";
+
 loader.config({
   paths: {
     vs: 'https://cdn.jsdelivr.net/npm/monaco-editor@0.55/min/vs',
   },
 })
 
+const app = createApp(App)
+  .use(Vue3Lottie)
+  .use(i18n);
+
 initializeAuthUrl()
   .finally(() => {
-    createApp(App)
-      .use(Vue3Lottie)
-      .use(i18n)
-      .mount('#app');
+    app.mount('#app');
   });
+
+Sentry.init({
+  app,
+  dsn: "https://2220bc70de22a1841c3792c4bf314731@o4510521933889536.ingest.de.sentry.io/4510521935528016",
+  sendDefaultPii: true,
+  integrations: [
+    Sentry.replayIntegration()
+  ],
+  replaysSessionSampleRate: 0.1,
+  replaysOnErrorSampleRate: 1.0
+});

Original file line number	Diff line number	Diff line change
`@@ -82,8 +82,9 @@ pub fn initialize_rpc() -> Result<(), String> {`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`#[tauri::command]`
`85`		`-pub fn get_server_connectivity_status() -> ServerConnectivityStatus {`
	`85`	`+pub async fn get_server_connectivity_status() -> ServerConnectivityStatus {`
`86`	`86`	`let servers = &SERVERS;`
	`87`	`+ servers.wait_for_initial_check().await;`
`87`	`88`	`servers.connectivity_status.lock().unwrap().clone()`
`88`	`89`	`}`
`89`	`90`