[RSDK-8612] capture and cache logs, then upload to app.viam.com

Cargo.toml

@@ -83,6 +83,7 @@ once_cell = "1.18.0"
 openssl = { version = "0.10.50" }
 pin-project = "1.1.5"
 pin-project-lite = "0.2.9"
+printf-compat = "0.1.1"
 proc-macro-crate = "2.0.0"
 proc-macro2 = "1.0.67"
 prost = "0.11.0"

micro-rdk-ffi/src/ffi/runtime.rs

@@ -7,6 +7,7 @@ use std::{
 use micro_rdk::common::{
     config::ConfigType,
     entry::RobotRepresentation,
+    log::initialize_logger,
     provisioning::server::ProvisioningInfo,
     registry::{ComponentRegistry, Dependency},
     sensor::{SensorError, SensorType},
@@ -206,16 +207,12 @@ pub unsafe extern "C" fn viam_server_start(ctx: *mut viam_server_context) -> via
 
     #[cfg(not(target_os = "espidf"))]
     {
-        use log::LevelFilter;
-        env_logger::builder()
-            .format_timestamp(Some(env_logger::TimestampPrecision::Millis))
-            .filter_level(LevelFilter::Info)
-            .init()
+        initialize_logger::<env_logger::Logger>();
     }
     #[cfg(target_os = "espidf")]
     {
         micro_rdk::esp32::esp_idf_svc::sys::link_patches();
-        micro_rdk::esp32::esp_idf_svc::log::EspLogger::initialize_default();
+        initialize_logger::<micro_rdk::esp32::esp_idf_svc::log::EspLogger>();
         micro_rdk::esp32::esp_idf_svc::sys::esp!(unsafe {
             micro_rdk::esp32::esp_idf_svc::sys::esp_vfs_eventfd_register(
                 &micro_rdk::esp32::esp_idf_svc::sys::esp_vfs_eventfd_config_t { max_fds: 5 },

micro-rdk-server/esp32/main.rs

@@ -17,13 +17,15 @@ mod esp32 {
                 RobotConfigurationStorage, RobotCredentials, WifiCredentialStorage, WifiCredentials,
             },
             entry::RobotRepresentation,
+            log::initialize_logger,
             provisioning::server::ProvisioningInfo,
             registry::ComponentRegistry,
         },
         esp32::{
             entry::serve,
             esp_idf_svc::{
                 self,
+                log::EspLogger,
                 sys::{g_wifi_feature_caps, CONFIG_FEATURE_CACHE_TX_BUF_BIT},
             },
             nvs_storage::NVSStorage,
@@ -45,7 +47,7 @@ mod esp32 {
 
     pub(crate) fn main_esp32() {
         esp_idf_svc::sys::link_patches();
-        esp_idf_svc::log::EspLogger::initialize_default();
+        initialize_logger::<EspLogger>();
 
         esp_idf_svc::sys::esp!(unsafe {
             esp_idf_svc::sys::esp_vfs_eventfd_register(

micro-rdk-server/native/main.rs

@@ -7,14 +7,13 @@ mod native {
         conn::network::ExternallyManagedNetwork,
         credentials_storage::{RAMStorage, RobotConfigurationStorage, RobotCredentials},
         entry::{serve_with_network, RobotRepresentation},
+        log::initialize_logger,
         provisioning::server::ProvisioningInfo,
         registry::ComponentRegistry,
     };
 
     pub(crate) fn main_native() {
-        env_logger::builder()
-            .format_timestamp(Some(env_logger::TimestampPrecision::Millis))
-            .init();
+        initialize_logger::<env_logger::Logger>();
 
         let network = match local_ip_address::local_ip().expect("error parsing local IP") {
             std::net::IpAddr::V4(ip) => ExternallyManagedNetwork::new(ip),

micro-rdk/Cargo.toml

@@ -20,17 +20,19 @@ binstart = ["esp-idf-svc/binstart"]
 libstart = ["esp-idf-svc/libstart"]
 builtin-components = []
 camera = []
-esp32 = ["dep:esp-idf-svc", "dep:embedded-svc", "dep:embedded-hal", "esp-idf-svc/std", "esp-idf-svc/alloc"]
+esp32 = ["dep:esp-idf-svc", "dep:embedded-svc", "dep:embedded-hal", "esp-idf-svc/std", "esp-idf-svc/alloc", "dep:printf-compat"]
 native = ["dep:rustls", "dep:webpki-roots", "dep:rustls-pemfile", "dep:mdns-sd", "dep:local-ip-address", "dep:openssl", "dep:rcgen", "dep:async-std-openssl"]
 data-upload-hook-unstable = ["data", "esp32"]
 data = []
+esp-idf-logs = ["esp32"]
 
 [dev-dependencies]
 test-log.workspace = true
 env_logger.workspace = true
 
 [target.'cfg(not(target_os = "espidf"))'.dependencies]
 async-std-openssl = { workspace = true, optional = true }
+env_logger.workspace = true
 futures-rustls.workspace = true
 local-ip-address = { workspace = true, optional = true }
 mdns-sd = { workspace = true, optional = true }
@@ -81,6 +83,7 @@ ringbuf.workspace = true
 pin-project.workspace = true
 async-lock.workspace = true
 dns-message-parser.workspace = true
+printf-compat = { workspace = true, optional = true }
 
 [build-dependencies]
 embuild.workspace = true

micro-rdk/src/common/entry.rs

@@ -21,7 +21,7 @@ use super::{
     exec::Executor,
     grpc::ServerError,
     grpc_client::GrpcClient,
-    log::config_log_entry,
+    log::LogUploadTask,
     provisioning::server::{serve_provisioning_async, ProvisioningInfo},
     registry::ComponentRegistry,
     restart_monitor::RestartMonitor,
@@ -150,15 +150,13 @@ pub async fn serve_inner<S>(
                 cfg_received_datetime,
             ) {
                 Ok(robot) => (robot, None),
-                Err(err) => {
-                    log::error!("could not build robot from config due to {:?}, defaulting to empty robot until a valid config is accessible", err);
-                    (LocalRobot::new(), Some(err))
-                }
+                Err(err) => (LocalRobot::new(), Some(err)),
+            };
+            if let Some(err) = err {
+                log::error!("could not build robot from config due to {:?}, defaulting to empty robot until a valid config is accessible", err);
+            } else {
+                log::info!("successfully created robot from config");
             };
-            if let Some(datetime) = cfg_received_datetime {
-                let logs = vec![config_log_entry(datetime, err)];
-                let _ = app_client.push_logs(logs).await;
-            }
             Arc::new(Mutex::new(r))
         }
     };
@@ -202,13 +200,16 @@ pub async fn serve_inner<S>(
         network,
         rpc_host,
     )
-    .with_webrtc(webrtc)
-    .with_periodic_app_client_task(Box::new(RestartMonitor::new(restart)))
-    .with_periodic_app_client_task(Box::new(ConfigMonitor::new(
-        *(cfg_response.clone()),
-        storage.clone(),
-        restart,
-    )));
+    .with_webrtc(webrtc);
+
+    let server_builder = server_builder
+        .with_periodic_app_client_task(Box::new(RestartMonitor::new(restart)))
+        .with_periodic_app_client_task(Box::new(ConfigMonitor::new(
+            *(cfg_response.clone()),
+            storage.clone(),
+            restart,
+        )))
+        .with_periodic_app_client_task(Box::new(LogUploadTask {}));
 
     #[cfg(feature = "native")]
     let server_builder = {