v0.1.4-pre.016

crates/ksp-app-config-desk/src/app_state.rs

@@ -1,11 +1,12 @@
 // file: crates/ksp-app-config-desk/src/app_state.rs
-// version: 5
+// version: 6
 
 //! Shared backend state owned by the Tauri application.
 
 struct LoggingRuntimeState {
     guard: ksp_logging_lib::LoggingGuard,
     active_profile_id: std::option::Option<String>,
+    selection_source: String,
     generation: u32,
     fallback_active: bool,
     startup_diagnostic: std::option::Option<crate::CommandErrorDto>,
@@ -27,7 +28,12 @@ impl AppState {
             std::result::Result::Ok(value) => value,
             std::result::Result::Err(error) => return std::result::Result::Err(error),
         };
-        let logging_startup = crate::initialize_logging(&config_management);
+        let runtime_identity = crate::logging_runtime::launch_identity();
+        let runtime_identity = match runtime_identity {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let logging_startup = crate::initialize_logging(&config_management, &runtime_identity);
         let logging_startup = match logging_startup {
             std::result::Result::Ok(value) => value,
             std::result::Result::Err(error) => return std::result::Result::Err(error),
@@ -61,6 +67,7 @@ impl AppState {
             logging_runtime: std::sync::Mutex::new(LoggingRuntimeState {
                 guard: logging_startup.guard,
                 active_profile_id: logging_startup.active_profile_id,
+                selection_source: logging_startup.selection_source,
                 generation: 1,
                 fallback_active: logging_startup.fallback_active,
                 startup_diagnostic: logging_startup.startup_diagnostic,
@@ -111,7 +118,12 @@ impl AppState {
     }
 
     /// Replaces the active Logging runtime with freshly resolved settings and advances the runtime generation only after success.
-    pub(crate) fn reinitialize_logging_runtime(&self, profile_id: &str, settings: &ksp_logging_lib::LoggingSettings) -> ksp_core_lib::Result<u32> {
+    pub(crate) fn reinitialize_logging_runtime(
+        &self,
+        profile_id: &str,
+        selection_source: &str,
+        settings: &ksp_logging_lib::LoggingSettings,
+    ) -> ksp_core_lib::Result<u32> {
         let runtime = self.logging_runtime.lock();
         let mut runtime = match runtime {
             std::result::Result::Ok(value) => value,
@@ -127,12 +139,59 @@ impl AppState {
             return std::result::Result::Err(error);
         }
         runtime.active_profile_id = std::option::Option::Some(profile_id.to_owned());
+        runtime.selection_source = selection_source.to_owned();
         runtime.generation = runtime.generation.saturating_add(1);
         runtime.fallback_active = false;
         runtime.startup_diagnostic = std::option::Option::None;
         return std::result::Result::Ok(runtime.generation);
     }
 
+    /// Returns a safe observable snapshot of the currently active Logging runtime.
+    pub(crate) fn logging_runtime_status(&self) -> ksp_core_lib::Result<crate::LoggingRuntimeStatusDto> {
+        let runtime = self.logging_runtime.lock();
+        let runtime = match runtime {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => {
+                return std::result::Result::Err(ksp_core_lib::Error::new(
+                    crate::ERROR_CODE_APP_STATE_LOCK_FAILED,
+                    "Config Desk Logging runtime state lock is poisoned",
+                ));
+            },
+        };
+        let identity = runtime.guard.runtime_identity();
+        let identity = match identity {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => {
+                return std::result::Result::Err(ksp_core_lib::Error::new(
+                    crate::ERROR_CODE_APP_STATE_INVALID,
+                    "Config Desk Logging runtime is missing its application launch identity",
+                ));
+            },
+        };
+        let console_enabled = match runtime.guard.settings().console() {
+            std::option::Option::Some(console) => console.enabled(),
+            std::option::Option::None => false,
+        };
+        let dropped = runtime.guard.dropped_lines();
+        let mut files = std::vec::Vec::<crate::LoggingRuntimeFileDto>::new();
+        for metadata in runtime.guard.active_file_outputs() {
+            files.push(crate::logging_runtime::project_file(&metadata));
+        }
+        return std::result::Result::Ok(crate::LoggingRuntimeStatusDto {
+            active_profile: runtime.active_profile_id.clone(),
+            selection_source: runtime.selection_source.clone(),
+            generation: runtime.generation,
+            fallback_active: runtime.fallback_active,
+            application_id: identity.application_id().to_owned(),
+            launch_timestamp: identity.launch_timestamp().to_owned(),
+            console_enabled,
+            dropped_console_lines: crate::logging_runtime::count_to_u64(dropped.console()),
+            dropped_file_lines: crate::logging_runtime::count_to_u64(dropped.file()),
+            dropped_total_lines: crate::logging_runtime::count_to_u64(dropped.total()),
+            files,
+        });
+    }
+
     /// Returns the resolved splash timings captured during application bootstrap.
     #[must_use]
     pub(crate) const fn splash_settings(&self) -> crate::SplashSettings {