diff --git a/src/gui/js/license.js b/src/gui/js/license.js
index a9874967..02651263 100644
--- a/src/gui/js/license.js
+++ b/src/gui/js/license.js
@@ -24,6 +24,10 @@ export const licenseText = `
Elevation data derived from the
AWS Terrain Tiles dataset.
+
Privacy Policy:
+If you consent to telemetry data collection, please review our Privacy Policy at:
+
https://arnismc.com/privacypolicy.html.
+
License:
Apache License
diff --git a/src/gui/js/main.js b/src/gui/js/main.js
index ccc2720f..971ad538 100644
--- a/src/gui/js/main.js
+++ b/src/gui/js/main.js
@@ -20,6 +20,7 @@ window.addEventListener("DOMContentLoaded", async () => {
setupProgressListener();
initSettings();
initWorldPicker();
+ initTelemetryConsent();
handleBboxInput();
const localization = await getLocalization();
await applyLocalization(localization);
@@ -305,6 +306,20 @@ function initSettings() {
}
});
+ // Telemetry consent toggle
+ const telemetryToggle = document.getElementById("telemetry-toggle");
+ const telemetryKey = 'telemetry-consent';
+
+ // Load saved telemetry consent
+ const savedConsent = localStorage.getItem(telemetryKey);
+ telemetryToggle.checked = savedConsent === 'true';
+
+ // Handle telemetry consent change
+ telemetryToggle.addEventListener("change", () => {
+ const isEnabled = telemetryToggle.checked;
+ localStorage.setItem(telemetryKey, isEnabled ? 'true' : 'false');
+ });
+
/// License and Credits
function openLicense() {
@@ -329,6 +344,49 @@ function initSettings() {
window.closeLicense = closeLicense;
}
+// Telemetry consent (first run only)
+function initTelemetryConsent() {
+ const key = 'telemetry-consent'; // values: 'true' | 'false'
+ const existing = localStorage.getItem(key);
+
+ const modal = document.getElementById('telemetry-modal');
+ if (!modal) return;
+
+ if (existing === null) {
+ // First run: ask for consent
+ modal.style.display = 'flex';
+ modal.style.justifyContent = 'center';
+ modal.style.alignItems = 'center';
+ }
+
+ // Expose handlers
+ window.acceptTelemetry = () => {
+ localStorage.setItem(key, 'true');
+ modal.style.display = 'none';
+ // Update settings toggle to reflect the consent
+ const telemetryToggle = document.getElementById('telemetry-toggle');
+ if (telemetryToggle) {
+ telemetryToggle.checked = true;
+ }
+ };
+
+ window.rejectTelemetry = () => {
+ localStorage.setItem(key, 'false');
+ modal.style.display = 'none';
+ // Update settings toggle to reflect the consent
+ const telemetryToggle = document.getElementById('telemetry-toggle');
+ if (telemetryToggle) {
+ telemetryToggle.checked = false;
+ }
+ };
+
+ // Utility for other scripts to read consent
+ window.getTelemetryConsent = () => {
+ const v = localStorage.getItem(key);
+ return v === null ? null : v === 'true';
+ };
+}
+
function initWorldPicker() {
// World Picker
const worldPickerModal = document.getElementById("world-modal");
@@ -617,6 +675,9 @@ async function startGeneration() {
floodfill_timeout = isNaN(floodfill_timeout) || floodfill_timeout < 0 ? 20 : floodfill_timeout;
ground_level = isNaN(ground_level) || ground_level < -62 ? 20 : ground_level;
+ // Get telemetry consent (defaults to false if not set)
+ const telemetryConsent = window.getTelemetryConsent ? window.getTelemetryConsent() : false;
+
// Pass the selected options to the Rust backend
await invoke("gui_start_generation", {
bboxText: selectedBBox,
@@ -630,7 +691,8 @@ async function startGeneration() {
roofEnabled: roof,
fillgroundEnabled: fill_ground,
isNewWorld: isNewWorld,
- spawnPoint: spawnPoint
+ spawnPoint: spawnPoint,
+ telemetryConsent: telemetryConsent || false
});
console.log("Generation process started.");
diff --git a/src/main.rs b/src/main.rs
index 8e96c329..29bc0c52 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -14,6 +14,8 @@ mod osm_parser;
#[cfg(feature = "gui")]
mod progress;
mod retrieve_data;
+#[cfg(feature = "gui")]
+mod telemetry;
#[cfg(test)]
mod test_utilities;
mod version_check;
diff --git a/src/progress.rs b/src/progress.rs
index a777b970..65fbede4 100644
--- a/src/progress.rs
+++ b/src/progress.rs
@@ -1,3 +1,4 @@
+use crate::telemetry::{send_log, LogLevel};
use once_cell::sync::OnceCell;
use serde_json::json;
use tauri::{Emitter, WebviewWindow};
@@ -38,7 +39,9 @@ pub fn emit_gui_progress_update(progress: f64, message: &str) {
});
if let Err(e) = window.emit("progress-update", payload) {
- eprintln!("Failed to emit progress event: {e}");
+ let error_msg = format!("Failed to emit progress event: {}", e);
+ eprintln!("{}", error_msg);
+ send_log(LogLevel::Warning, &error_msg);
}
}
}
diff --git a/src/telemetry.rs b/src/telemetry.rs
new file mode 100644
index 00000000..3163f9cc
--- /dev/null
+++ b/src/telemetry.rs
@@ -0,0 +1,249 @@
+use log::error;
+use reqwest::blocking::Client;
+use serde::Serialize;
+use std::panic::{self, AssertUnwindSafe};
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// Telemetry endpoint URL
+const TELEMETRY_URL: &str = "https://arnismc.com/telemetry/report_telemetry.php";
+
+/// Global flag to store user's telemetry consent
+static TELEMETRY_CONSENT: AtomicBool = AtomicBool::new(false);
+
+/// Sets the user's telemetry consent preference
+pub fn set_telemetry_consent(consent: bool) {
+ TELEMETRY_CONSENT.store(consent, Ordering::Relaxed);
+}
+
+/// Gets the user's telemetry consent preference
+fn get_telemetry_consent() -> bool {
+ TELEMETRY_CONSENT.load(Ordering::Relaxed)
+}
+
+/// Determines the current platform as a string
+fn get_platform() -> &'static str {
+ match std::env::consts::OS {
+ "windows" => "windows",
+ "linux" => "linux",
+ "macos" => "macos",
+ _ => "unknown",
+ }
+}
+
+/// Gets the application version from Cargo.toml
+fn get_app_version() -> &'static str {
+ env!("CARGO_PKG_VERSION")
+}
+
+/// Crash report payload structure
+#[derive(Serialize)]
+struct CrashReport<'a> {
+ r#type: &'a str,
+ error_message: &'a str,
+ platform: &'a str,
+ app_version: &'a str,
+}
+
+/// Generation click payload structure
+#[derive(Serialize)]
+struct GenerationClick<'a> {
+ r#type: &'a str,
+}
+
+/// Log entry payload structure
+#[derive(Serialize)]
+struct LogEntry<'a> {
+ r#type: &'a str,
+ log_level: &'a str,
+ log_message: &'a str,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ platform: Option<&'a str>,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ app_version: Option<&'a str>,
+}
+
+/// Sends a crash report to the telemetry server
+fn send_crash_report(error_message: String, platform: &str, app_version: &str) {
+ // Wrap in catch_unwind to prevent any panics during crash reporting
+ let _ = std::panic::catch_unwind(AssertUnwindSafe(|| {
+ let _ = (|| -> Result<(), Box> {
+ let client = Client::new();
+
+ let payload = CrashReport {
+ r#type: "crash",
+ error_message: &error_message,
+ platform,
+ app_version,
+ };
+
+ let _res = client
+ .post(TELEMETRY_URL)
+ .header("Content-Type", "application/json")
+ .json(&payload)
+ .send()?;
+
+ Ok(())
+ })();
+ }));
+}
+
+/// Sends a generation click event to the telemetry server
+pub fn send_generation_click() {
+ // Check user consent
+ if !get_telemetry_consent() {
+ return;
+ }
+
+ // Only send in release builds
+ if cfg!(debug_assertions) {
+ return;
+ }
+
+ // Send in background thread to avoid blocking UI
+ // Wrap in catch_unwind to prevent any panics from escaping
+ let _ = std::thread::spawn(|| {
+ let _ = std::panic::catch_unwind(AssertUnwindSafe(|| {
+ let _ = (|| -> Result<(), Box> {
+ let client = Client::new();
+
+ let payload = GenerationClick {
+ r#type: "generation_click",
+ };
+
+ let _res = client
+ .post(TELEMETRY_URL)
+ .header("Content-Type", "application/json")
+ .json(&payload)
+ .send()?;
+
+ Ok(())
+ })();
+ }));
+ });
+}
+
+/// Log levels for telemetry
+#[allow(dead_code)]
+pub enum LogLevel {
+ Debug,
+ Info,
+ Warning,
+ Error,
+}
+
+impl LogLevel {
+ fn as_str(&self) -> &'static str {
+ match self {
+ LogLevel::Debug => "debug",
+ LogLevel::Info => "info",
+ LogLevel::Warning => "warning",
+ LogLevel::Error => "error",
+ }
+ }
+}
+
+/// Sends a log entry to the telemetry server
+pub fn send_log(level: LogLevel, message: &str) {
+ // Check user consent
+ if !get_telemetry_consent() {
+ return;
+ }
+
+ // Only send in release builds
+ if cfg!(debug_assertions) {
+ return;
+ }
+
+ // Truncate message to 1000 characters
+ let truncated_message = if message.chars().count() > 1000 {
+ message.chars().take(1000).collect::()
+ } else {
+ message.to_string()
+ };
+
+ let platform = get_platform();
+ let app_version = get_app_version();
+
+ // Send in background thread to avoid blocking
+ // Wrap in catch_unwind to prevent any panics from escaping
+ let _ = std::thread::spawn(move || {
+ let _ = std::panic::catch_unwind(AssertUnwindSafe(|| {
+ let _ = (|| -> Result<(), Box> {
+ let client = Client::new();
+
+ let payload = LogEntry {
+ r#type: "log",
+ log_level: level.as_str(),
+ log_message: &truncated_message,
+ platform: Some(platform),
+ app_version: Some(app_version),
+ };
+
+ let _res = client
+ .post(TELEMETRY_URL)
+ .header("Content-Type", "application/json")
+ .json(&payload)
+ .send()?;
+
+ Ok(())
+ })();
+ }));
+ });
+}
+
+/// Installs a panic hook that logs panics and sends crash reports
+pub fn install_panic_hook() {
+ panic::set_hook(Box::new(|panic_info| {
+ // Log the panic to both stderr and log file
+ error!("Application panicked: {:?}", panic_info);
+
+ // Filter out secondary "panic in a function that cannot unwind" panics
+ if let Some(location) = panic_info.location() {
+ if location.file().contains("panicking.rs") {
+ return;
+ }
+ }
+
+ // Check user consent
+ if !get_telemetry_consent() {
+ return;
+ }
+
+ // Only send crash reports in release builds
+ if cfg!(debug_assertions) {
+ return;
+ }
+
+ // Everything else wrapped in catch_unwind to prevent secondary panics
+ let _ = std::panic::catch_unwind(AssertUnwindSafe(|| {
+ // Extract panic payload
+ let payload = if let Some(s) = panic_info.payload().downcast_ref::<&str>() {
+ s.to_string()
+ } else if let Some(s) = panic_info.payload().downcast_ref::() {
+ s.clone()
+ } else {
+ "Unknown panic".to_string()
+ };
+
+ // Extract location
+ let location = panic_info
+ .location()
+ .map(|l| format!("{}:{}:{}", l.file(), l.line(), l.column()))
+ .unwrap_or_else(|| "unknown location".to_string());
+
+ // Combine payload and location
+ let mut error_message = format!("{} @ {}", payload, location);
+
+ // Truncate to 500 Unicode characters
+ if error_message.chars().count() > 500 {
+ error_message = error_message.chars().take(500).collect();
+ }
+
+ let platform = get_platform();
+ let app_version = get_app_version();
+
+ // Send crash report (best-effort, ignore all errors)
+ send_crash_report(error_message, platform, app_version);
+ }));
+ }));
+}
diff --git a/src/world_editor.rs b/src/world_editor.rs
index 6aa174c3..fe5ef2b2 100644
--- a/src/world_editor.rs
+++ b/src/world_editor.rs
@@ -3,6 +3,7 @@ use crate::coordinate_system::cartesian::{XZBBox, XZPoint};
use crate::coordinate_system::geographic::LLBBox;
use crate::ground::Ground;
use crate::progress::emit_gui_progress_update;
+use crate::telemetry::{send_log, LogLevel};
use colored::Colorize;
use fastanvil::Region;
use fastnbt::{LongArray, Value};
@@ -755,7 +756,8 @@ impl<'a> WorldEditor<'a> {
// Save metadata with error handling
if let Err(e) = self.save_metadata() {
- eprintln!("Warning: Failed to save world metadata: {}", e);
+ eprintln!("Failed to save world metadata: {}", e);
+ send_log(LogLevel::Warning, "Failed to save world metadata.");
// Continue with world saving even if metadata fails
}