feat: publish HoloLake model-native living system source

product-source/hololake-platform/src-tauri/src/telemetry.rs

@@ -0,0 +1,225 @@
+use crate::settings;
+use chrono::NaiveDate;
+use regex::Regex;
+use std::borrow::Cow;
+use std::sync::Mutex;
+
+/// Global Sentry guard — must live for the duration of the app.
+static SENTRY_GUARD: Mutex<Option<sentry::ClientInitGuard>> = Mutex::new(None);
+
+/// Scrub absolute file paths from a string to prevent vault content leakage.
+fn scrub_paths(input: &str) -> String {
+    let re = Regex::new(r"(?:/[\w.-]+){2,}|[A-Z]:\\[\w\\.-]+").unwrap();
+    re.replace_all(input, "<redacted-path>").to_string()
+}
+
+fn normalize_embedded_env(raw: Option<&str>) -> Option<String> {
+    let value = raw?.trim();
+    if value.is_empty() {
+        return None;
+    }
+
+    let unwrapped = match (value.chars().next(), value.chars().last()) {
+        (Some('"'), Some('"')) | (Some('\''), Some('\'')) if value.len() >= 2 => {
+            value[1..value.len() - 1].trim()
+        }
+        _ => value,
+    };
+
+    if unwrapped.is_empty() {
+        None
+    } else {
+        Some(unwrapped.to_string())
+    }
+}
+
+fn normalize_http_like_value(value: &str) -> String {
+    if value.contains("://") {
+        value.to_string()
+    } else {
+        format!("https://{value}")
+    }
+}
+
+fn parse_embedded_sentry_dsn(raw: Option<&str>) -> Option<sentry::types::Dsn> {
+    let normalized = normalize_embedded_env(raw)?;
+    normalize_http_like_value(&normalized).parse().ok()
+}
+
+fn is_stable_calendar_release(version: &str) -> bool {
+    let mut parts = version.split('.');
+    let (Some(year), Some(month), Some(day)) = (parts.next(), parts.next(), parts.next()) else {
+        return false;
+    };
+
+    if parts.next().is_some() {
+        return false;
+    }
+
+    let (Ok(year), Ok(month), Ok(day)) = (
+        year.parse::<i32>(),
+        month.parse::<u32>(),
+        day.parse::<u32>(),
+    ) else {
+        return false;
+    };
+
+    NaiveDate::from_ymd_opt(year, month, day).is_some()
+}
+
+fn sentry_release_for_version(version: &'static str) -> Option<Cow<'static, str>> {
+    is_stable_calendar_release(version).then(|| version.into())
+}
+
+fn sentry_release_kind(version: &str) -> &'static str {
+    if is_stable_calendar_release(version) {
+        "stable"
+    } else if version.contains('-') {
+        "prerelease"
+    } else {
+        "internal"
+    }
+}
+
+/// Initialize Sentry if the user has opted in to crash reporting.
+/// Returns `true` if Sentry was initialized, `false` if skipped.
+pub fn init_sentry_from_settings() -> bool {
+    let settings = match settings::get_settings() {
+        Ok(s) => s,
+        Err(_) => return false,
+    };
+
+    if settings.crash_reporting_enabled != Some(true) {
+        return false;
+    }
+
+    let Some(dsn) = parse_embedded_sentry_dsn(option_env!("SENTRY_DSN")) else {
+        return false;
+    };
+
+    let anonymous_id = settings.anonymous_id.unwrap_or_default();
+    let build_version = env!("CARGO_PKG_VERSION");
+    let guard = sentry::init(sentry::ClientOptions {
+        dsn: Some(dsn),
+        release: sentry_release_for_version(build_version),
+        send_default_pii: false,
+        before_send: Some(std::sync::Arc::new(|mut event| {
+            if let Some(ref mut msg) = event.message {
+                *msg = scrub_paths(msg);
+            }
+            Some(event)
+        })),
+        ..Default::default()
+    });
+
+    sentry::configure_scope(|scope| {
+        scope.set_user(Some(sentry::User {
+            id: Some(anonymous_id),
+            ..Default::default()
+        }));
+        scope.set_tag("tolaria.build_version", build_version);
+        scope.set_tag("tolaria.release_kind", sentry_release_kind(build_version));
+    });
+
+    *SENTRY_GUARD.lock().unwrap() = Some(guard);
+    true
+}
+
+/// Tear down and reinitialize Sentry (called when user changes settings).
+pub fn reinit_sentry() {
+    // Drop old guard first
+    *SENTRY_GUARD.lock().unwrap() = None;
+    // Re-read settings and optionally re-init
+    init_sentry_from_settings();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_scrub_paths_unix() {
+        assert_eq!(
+            scrub_paths("Error at /Users/luca/Laputa/note.md"),
+            "Error at <redacted-path>"
+        );
+    }
+
+    #[test]
+    fn test_scrub_paths_windows() {
+        assert_eq!(
+            scrub_paths("Error at C:\\Users\\test\\doc.md"),
+            "Error at <redacted-path>"
+        );
+    }
+
+    #[test]
+    fn test_scrub_paths_no_paths() {
+        assert_eq!(scrub_paths("Normal error message"), "Normal error message");
+    }
+
+    #[test]
+    fn test_normalize_embedded_env_trims_wrapping_quotes() {
+        assert_eq!(
+            normalize_embedded_env(Some("  \"value\"  ")).as_deref(),
+            Some("value")
+        );
+        assert_eq!(
+            normalize_embedded_env(Some("  'value'  ")).as_deref(),
+            Some("value")
+        );
+    }
+
+    #[test]
+    fn test_normalize_embedded_env_drops_blank_values() {
+        assert_eq!(normalize_embedded_env(Some("   ")), None);
+        assert_eq!(normalize_embedded_env(None), None);
+    }
+
+    #[test]
+    fn test_parse_embedded_sentry_dsn_accepts_valid_trimmed_value() {
+        let parsed =
+            parse_embedded_sentry_dsn(Some("  \"https://public@example.ingest.sentry.io/1\"  "));
+        assert!(parsed.is_some());
+    }
+
+    #[test]
+    fn test_parse_embedded_sentry_dsn_accepts_scheme_less_value() {
+        let parsed = parse_embedded_sentry_dsn(Some("public@example.ingest.sentry.io/1"));
+        assert!(parsed.is_some());
+    }
+
+    #[test]
+    fn test_parse_embedded_sentry_dsn_rejects_invalid_value() {
+        let parsed = parse_embedded_sentry_dsn(Some("not a dsn"));
+        assert!(parsed.is_none());
+    }
+
+    #[test]
+    fn test_init_sentry_returns_false_without_dsn() {
+        // Without SENTRY_DSN env var set at compile time, init should return false
+        assert!(!init_sentry_from_settings());
+    }
+
+    #[test]
+    fn test_sentry_release_for_stable_calendar_version() {
+        assert!(sentry_release_for_version("2026.4.28").is_some());
+    }
+
+    #[test]
+    fn test_sentry_release_for_alpha_version_is_none() {
+        assert!(sentry_release_for_version("2026.4.28-alpha.7").is_none());
+    }
+
+    #[test]
+    fn test_sentry_release_for_local_dev_version_is_none() {
+        assert!(sentry_release_for_version("0.1.0").is_none());
+    }
+
+    #[test]
+    fn test_sentry_release_kind_classifies_versions() {
+        assert_eq!(sentry_release_kind("2026.4.28"), "stable");
+        assert_eq!(sentry_release_kind("2026.4.28-alpha.7"), "prerelease");
+        assert_eq!(sentry_release_kind("0.1.0"), "internal");
+    }
+}