PostHog track API backend

apps/desktop/src-tauri/src/lib.rs

@@ -1880,7 +1880,10 @@ async fn check_notification_permissions(app: AppHandle) {
 #[specta::specta]
 #[instrument(skip(app))]
 async fn set_server_url(app: MutableState<'_, App>, server_url: String) -> Result<(), ()> {
-    app.write().await.server_url = server_url;
+    let mut app = app.write().await;
+    posthog::set_server_url(&server_url);
+    app.server_url = server_url;
+
     Ok(())
 }
 
@@ -2223,6 +2226,36 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
             });
 
             {
+                let (server_url, should_update) = if cfg!(debug_assertions)
+                    && let Ok(url) = std::env::var("VITE_SERVER_URL")
+                {
+                    (url, true)
+                } else if let Some(url) = GeneralSettingsStore::get(&app)
+                    .ok()
+                    .flatten()
+                    .map(|v| v.server_url.clone())
+                {
+                    (url, false)
+                } else {
+                    (
+                        option_env!("VITE_SERVER_URL")
+                            .unwrap_or("https://cap.so")
+                            .to_string(),
+                        true,
+                    )
+                };
+
+                // This ensures settings reflects the correct value if it's set at startup
+                if should_update {
+                    GeneralSettingsStore::update(&app, |mut s| {
+                        s.server_url = server_url.clone();
+                    })
+                    .map_err(|err| warn!("Error updating server URL into settings store: {err}"))
+                    .ok();
+                }
+
+                posthog::set_server_url(&server_url);
+
                 app.manage(Arc::new(RwLock::new(App {
                     camera_ws_port,
                     handle: app.clone(),
@@ -2231,15 +2264,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                     recording_logging_handle,
                     mic_feed,
                     camera_feed,
-                    server_url: std::option_env!("VITE_SERVER_URL")
-                        .map(|s| s.to_string())
-                        .or_else(|| {
-                            GeneralSettingsStore::get(&app)
-                                .ok()
-                                .flatten()
-                                .map(|v| v.server_url.clone())
-                        })
-                        .unwrap_or_else(|| "https://cap.so".to_string()),
+                    server_url,
                     logs_dir: logs_dir.clone(),
                 })));
 

apps/desktop/src-tauri/src/posthog.rs

@@ -1,4 +1,7 @@
-use std::time::Duration;
+use std::{
+    sync::{OnceLock, PoisonError, RwLock},
+    time::Duration,
+};
 use tracing::error;
 
 #[derive(Debug)]
@@ -21,7 +24,7 @@ pub enum PostHogEvent {
 
 impl From<PostHogEvent> for posthog_rs::Event {
     fn from(event: PostHogEvent) -> Self {
-        let mut e = match event {
+        match event {
             PostHogEvent::MultipartUploadComplete {
                 duration,
                 length,
@@ -49,19 +52,7 @@ impl From<PostHogEvent> for posthog_rs::Event {
                     .ok();
                 e
             }
-        };
-
-        e.insert_prop("cap_version", env!("CARGO_PKG_VERSION"))
-            .map_err(|err| error!("Error adding PostHog property: {err:?}"))
-            .ok();
-        e.insert_prop("os", std::env::consts::OS)
-            .map_err(|err| error!("Error adding PostHog property: {err:?}"))
-            .ok();
-        e.insert_prop("arch", std::env::consts::ARCH)
-            .map_err(|err| error!("Error adding PostHog property: {err:?}"))
-            .ok();
-
-        e
+        }
     }
 }
 
@@ -76,10 +67,45 @@ pub fn init() {
     }
 }
 
+pub fn set_server_url(url: &str) {
+    *API_SERVER_IS_CAP_CLOUD
+        .get_or_init(Default::default)
+        .write()
+        .unwrap_or_else(PoisonError::into_inner) = Some(url == "https://cap.so");
+}
+
+static API_SERVER_IS_CAP_CLOUD: OnceLock<RwLock<Option<bool>>> = OnceLock::new();
+
 pub fn async_capture_event(event: PostHogEvent) {
     if option_env!("VITE_POSTHOG_KEY").is_some() {
         tokio::spawn(async move {
-            posthog_rs::capture(event.into())
+            let mut e: posthog_rs::Event = event.into();
+
+            e.insert_prop("cap_version", env!("CARGO_PKG_VERSION"))
+                .map_err(|err| error!("Error adding PostHog property: {err:?}"))
+                .ok();
+            e.insert_prop(
+                "cap_backend",
+                match *API_SERVER_IS_CAP_CLOUD
+                    .get_or_init(Default::default)
+                    .read()
+                    .unwrap_or_else(PoisonError::into_inner)
+                {
+                    Some(true) => "cloud",
+                    Some(false) => "self_hosted",
+                    None => "unknown",
+                },
+            )
+            .map_err(|err| error!("Error adding PostHog property: {err:?}"))
+            .ok();
+            e.insert_prop("os", std::env::consts::OS)
+                .map_err(|err| error!("Error adding PostHog property: {err:?}"))
+                .ok();
+            e.insert_prop("arch", std::env::consts::ARCH)
+                .map_err(|err| error!("Error adding PostHog property: {err:?}"))
+                .ok();
+
+            posthog_rs::capture(e)
                 .await
                 .map_err(|err| error!("Error sending event to PostHog: {err:?}"))
                 .ok();