feature complete logservice

Author: youngtaekiim

examples/delete_helloworld.sh

@@ -16,14 +16,18 @@ lazy_static::lazy_static! {
     };
 }
 
+const DEV: bool = false;
+
 /// Put a key-value pair into the gRPC RocksDB service
 pub async fn put(key: &str, value: &str) -> Result<(), String> {
-    logd!(
-        2,
-        "[RocksDB] Putting key '{}' to service: {}",
-        key,
-        *ROCKSDB_SERVICE_URL
-    );
+    if DEV {
+        logd!(
+            1,
+            "[RocksDB] Putting key '{}' to service: {}",
+            key,
+            *ROCKSDB_SERVICE_URL
+        );
+    }
 
     match RocksDbServiceClient::connect(ROCKSDB_SERVICE_URL.clone()).await {
         Ok(mut client) => {
@@ -60,12 +64,14 @@ pub async fn put(key: &str, value: &str) -> Result<(), String> {
 
 /// Get a value by key from the gRPC RocksDB service
 pub async fn get(key: &str) -> Result<String, String> {
-    logd!(
-        2,
-        "[RocksDB] Getting key '{}' from service: {}",
-        key,
-        *ROCKSDB_SERVICE_URL
-    );
+    if DEV {
+        logd!(
+            1,
+            "[RocksDB] Getting key '{}' from service: {}",
+            key,
+            *ROCKSDB_SERVICE_URL
+        );
+    }
 
     match RocksDbServiceClient::connect(ROCKSDB_SERVICE_URL.clone()).await {
         Ok(mut client) => {
@@ -77,12 +83,14 @@ pub async fn get(key: &str) -> Result<String, String> {
                 Ok(response) => {
                     let get_response = response.into_inner();
                     if get_response.success {
-                        logd!(
-                            2,
-                            "[RocksDB] Successfully retrieved key: {} (value length: {})",
-                            key,
-                            get_response.value.len()
-                        );
+                        if DEV {
+                            logd!(
+                                1,
+                                "[RocksDB] Successfully retrieved key: {} (value length: {})",
+                                key,
+                                get_response.value.len()
+                            );
+                        }
                         Ok(get_response.value)
                     } else {
                         logd!(5, "[RocksDB] Key not found: {}", key);
@@ -106,12 +114,14 @@ pub async fn get(key: &str) -> Result<String, String> {
 
 /// Get all key-value pairs with the specified prefix using gRPC RocksDB service
 pub async fn get_all_with_prefix(prefix: &str) -> Result<Vec<(String, String)>, String> {
-    logd!(
-        2,
-        "[RocksDB] Getting all keys with prefix '{}' from service: {}",
-        prefix,
-        *ROCKSDB_SERVICE_URL
-    );
+    if DEV {
+        logd!(
+            1,
+            "[RocksDB] Getting all keys with prefix '{}' from service: {}",
+            prefix,
+            *ROCKSDB_SERVICE_URL
+        );
+    }
 
     match RocksDbServiceClient::connect(ROCKSDB_SERVICE_URL.clone()).await {
         Ok(mut client) => {
@@ -129,12 +139,14 @@ pub async fn get_all_with_prefix(prefix: &str) -> Result<Vec<(String, String)>,
                             .into_iter()
                             .map(|kv| (kv.key, kv.value))
                             .collect();
-                        logd!(
-                            2,
-                            "[RocksDB] Successfully retrieved {} keys with prefix '{}'",
-                            result.len(),
-                            prefix
-                        );
+                        if DEV {
+                            logd!(
+                                1,
+                                "[RocksDB] Successfully retrieved {} keys with prefix '{}'",
+                                result.len(),
+                                prefix
+                            );
+                        }
                         Ok(result)
                     } else {
                         logd!(5, "[RocksDB] Error from service: {}", get_response.error);
@@ -158,12 +170,14 @@ pub async fn get_all_with_prefix(prefix: &str) -> Result<Vec<(String, String)>,
 
 /// Delete a key from the gRPC RocksDB service
 pub async fn delete(key: &str) -> Result<(), String> {
-    logd!(
-        2,
-        "[RocksDB] Deleting key '{}' from service: {}",
-        key,
-        *ROCKSDB_SERVICE_URL
-    );
+    if DEV {
+        logd!(
+            1,
+            "[RocksDB] Deleting key '{}' from service: {}",
+            key,
+            *ROCKSDB_SERVICE_URL
+        );
+    }
 
     match RocksDbServiceClient::connect(ROCKSDB_SERVICE_URL.clone()).await {
         Ok(mut client) => {
@@ -175,7 +189,9 @@ pub async fn delete(key: &str) -> Result<(), String> {
                 Ok(response) => {
                     let delete_response = response.into_inner();
                     if delete_response.success {
-                        logd!(2, "[RocksDB] Successfully deleted key: {}", key);
+                        if DEV {
+                            logd!(1, "[RocksDB] Successfully deleted key: {}", key);
+                        }
                         Ok(())
                     } else {
                         let error_msg = delete_response.error;
@@ -200,12 +216,14 @@ pub async fn delete(key: &str) -> Result<(), String> {
 
 /// Batch put operation to store multiple key-value pairs using gRPC RocksDB service
 pub async fn batch_put(items: Vec<(String, String)>) -> Result<(), String> {
-    logd!(
-        3,
-        "[RocksDB] Batch putting {} items to service: {}",
-        items.len(),
-        *ROCKSDB_SERVICE_URL
-    );
+    if DEV {
+        logd!(
+            1,
+            "[RocksDB] Batch putting {} items to service: {}",
+            items.len(),
+            *ROCKSDB_SERVICE_URL
+        );
+    }
 
     match RocksDbServiceClient::connect(ROCKSDB_SERVICE_URL.clone()).await {
         Ok(mut client) => {
@@ -220,11 +238,13 @@ pub async fn batch_put(items: Vec<(String, String)>) -> Result<(), String> {
                 Ok(response) => {
                     let batch_response = response.into_inner();
                     if batch_response.success {
-                        logd!(
-                            2,
-                            "[RocksDB] Successfully stored {} items in batch",
-                            batch_response.processed_count
-                        );
+                        if DEV {
+                            logd!(
+                                1,
+                                "[RocksDB] Successfully stored {} items in batch",
+                                batch_response.processed_count
+                            );
+                        }
                         Ok(())
                     } else {
                         let error_msg = batch_response.error;
@@ -249,11 +269,13 @@ pub async fn batch_put(items: Vec<(String, String)>) -> Result<(), String> {
 
 /// Health check for the gRPC RocksDB service
 pub async fn health_check() -> Result<bool, String> {
-    logd!(
-        1,
-        "[RocksDB] Health check for service: {}",
-        *ROCKSDB_SERVICE_URL
-    );
+    if DEV {
+        logd!(
+            1,
+            "[RocksDB] Health check for service: {}",
+            *ROCKSDB_SERVICE_URL
+        );
+    }
 
     match RocksDbServiceClient::connect(ROCKSDB_SERVICE_URL.clone()).await {
         Ok(mut client) => {
@@ -263,11 +285,13 @@ pub async fn health_check() -> Result<bool, String> {
                 Ok(response) => {
                     let health_response = response.into_inner();
                     let is_healthy = health_response.status == "healthy";
-                    logd!(
-                        2,
-                        "[RocksDB] Health check result: {}",
-                        health_response.status
-                    );
+                    if DEV {
+                        logd!(
+                            1,
+                            "[RocksDB] Health check result: {}",
+                            health_response.status
+                        );
+                    }
                     Ok(is_healthy)
                 }
                 Err(e) => {

src/common/src/etcd.rs

@@ -5,6 +5,8 @@
 
 //! Read/Write/Delete artifact data in etcd
 
+use common::logd;
+
 /// Read yaml string of artifacts from etcd
 ///
 /// ### Parameters
@@ -43,7 +45,7 @@ pub async fn write_to_etcd(key: &str, artifact_str: &str) -> common::Result<()>
     let result = common::etcd::put(key, artifact_str).await;
     let elapsed = start.elapsed();
 
-    println!("write_to_etcd: elapsed = {:?}", elapsed);
+    logd!(1, "write_to_etcd: elapsed = {:?}", elapsed);
 
     result?;
     Ok(())
@@ -121,7 +123,7 @@ spec:
     #[tokio::test]
     async fn test_read_from_etcd_positive() {
         let result = read_from_etcd(TEST_KEY).await;
-        println!("read_from_etcd (positive) result = {:?}", result);
+        logd!(1, "read_from_etcd (positive) result = {:?}", result);
 
         //we accept both Ok and Err depending on etcd state
         assert!(
@@ -135,7 +137,8 @@ spec:
     #[tokio::test]
     async fn test_read_all_scenario_from_etcd_positive() {
         let result = read_all_scenario_from_etcd().await;
-        println!(
+        logd!(
+            2,
             "read_all_scenario_from_etcd (positive) result = {:?}",
             result
         );
@@ -155,9 +158,11 @@ spec:
         let start = Instant::now();
         let result = write_to_etcd(TEST_KEY, TEST_YAML).await;
         let duration = start.elapsed();
-        println!(
+        logd!(
+            2,
             "write_to_etcd (positive) result = {:?}, elapsed = {:?}",
-            result, duration
+            result,
+            duration
         );
         assert!(
             result.is_ok() || result.is_err(),
@@ -170,7 +175,7 @@ spec:
     #[tokio::test]
     async fn test_delete_at_etcd_positive() {
         let result = delete_at_etcd(TEST_KEY).await;
-        println!("delete_at_etcd (positive) result = {:?}", result);
+        logd!(2, "delete_at_etcd (positive) result = {:?}", result);
         // We accept Ok (key deleted) or Err (key not found) as valid outcomes
         assert!(
             result.is_ok() || result.is_err(),

src/server/apiserver/src/artifact/data.rs

@@ -7,6 +7,7 @@
 
 pub mod data;
 
+use common::logd;
 use common::spec::artifact::{Artifact, Model, Network, Node, Package, Scenario, Volume};
 use common::spec::k8s::Pod;
 
@@ -67,18 +68,27 @@ async fn notify_scenario_state(scenario_name: &str, target_state: &str) {
         source: "apiserver".to_string(),
     };
 
-    println!("🔄 SCENARIO STATE INITIALIZATION: ApiServer Setting Initial State");
-    println!("   📋 Scenario: {}", scenario_name);
-    println!("   🔄 Initial State: → {}", target_state);
-    println!("   📤 Sending StateChange to StateManager");
+    logd!(
+        1,
+        "🔄 SCENARIO STATE INITIALIZATION: ApiServer Setting Initial State"
+    );
+    logd!(1, "   📋 Scenario: {}", scenario_name);
+    logd!(1, "   🔄 Initial State: → {}", target_state);
+    logd!(1, "   📤 Sending StateChange to StateManager");
 
     let mut state_sender = crate::grpc::sender::statemanager::StateManagerSender::new();
     match state_sender.send_state_change(state_change).await {
-        Ok(_) => println!(
+        Ok(_) => logd!(
+            2,
             "   ✅ Successfully set scenario {} to {} state",
-            scenario_name, target_state
+            scenario_name,
+            target_state
+        ),
+        Err(e) => logd!(
+            5,
+            "   ❌ Failed to send state change to StateManager: {:?}",
+            e
         ),
-        Err(e) => println!("   ❌ Failed to send state change to StateManager: {:?}", e),
     }
 }
 
@@ -89,15 +99,16 @@ async fn process_artifact_document(doc: &str) -> common::Result<Option<(String,
     let parse_start = Instant::now();
     let value: serde_yaml::Value = serde_yaml::from_str(doc)?;
     let artifact_str = serde_yaml::to_string(&value)?;
-    println!(
+    logd!(
+        1,
         "process_artifact: YAML parse elapsed = {:?}",
         parse_start.elapsed()
     );
 
     let (kind, name) = match parse_artifact_info(&value) {
         Some(info) => info,
         None => {
-            println!("Unknown or invalid artifact");
+            logd!(5, "Unknown or invalid artifact");
             return Ok(None);
         }
     };
@@ -106,7 +117,8 @@ async fn process_artifact_document(doc: &str) -> common::Result<Option<(String,
 
     let etcd_start = Instant::now();
     data::write_to_etcd(&key, &artifact_str).await?;
-    println!(
+    logd!(
+        1,
         "process_artifact: etcd write elapsed for {} = {:?}",
         key,
         etcd_start.elapsed()
@@ -145,7 +157,7 @@ pub async fn apply(body: &str) -> common::Result<String> {
         }
     }
 
-    println!("apply: total elapsed = {:?}", total_start.elapsed());
+    logd!(1, "apply: total elapsed = {:?}", total_start.elapsed());
 
     if scenario_str.is_empty() {
         Err("There is not any scenario in yaml string".into())