replace println with logd in player modules

Author: youngtaekiim

src/Cargo.lock

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+use crate::logd;
 use crate::rocksdbservice::{
     rocks_db_service_client::RocksDbServiceClient, BatchPutRequest, DeleteRequest,
     GetByPrefixRequest, GetRequest, HealthRequest, KeyValue, PutRequest,
@@ -17,9 +18,9 @@ lazy_static::lazy_static! {
 
 /// Put a key-value pair into the gRPC RocksDB service
 pub async fn put(key: &str, value: &str) -> Result<(), String> {
-    crate::logd!(
+    logd!(
         2,
-        "[ETCD->RocksDB-gRPC] Putting key '{}' to service: {}",
+        "[RocksDB] Putting key '{}' to service: {}",
         key,
         *ROCKSDB_SERVICE_URL
     );
@@ -35,34 +36,35 @@ pub async fn put(key: &str, value: &str) -> Result<(), String> {
                 Ok(response) => {
                     let put_response = response.into_inner();
                     if put_response.success {
-                        println!("[ETCD->RocksDB-gRPC] Successfully stored key: {}", key);
                         Ok(())
                     } else {
                         let error_msg = put_response.error;
-                        println!("[ETCD->RocksDB-gRPC] Put failed: {}", error_msg);
+                        logd!(5, "[RocksDB] Put failed: {}", error_msg);
                         Err(error_msg)
                     }
                 }
                 Err(e) => {
                     let error_msg = format!("gRPC request failed: {}", e);
-                    println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+                    logd!(5, "[RocksDB] {}", error_msg);
                     Err(error_msg)
                 }
             }
         }
         Err(e) => {
             let error_msg = format!("Failed to create client: {}", e);
-            println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+            logd!(5, "[RocksDB] {}", error_msg);
             Err(error_msg)
         }
     }
 }
 
 /// Get a value by key from the gRPC RocksDB service
 pub async fn get(key: &str) -> Result<String, String> {
-    println!(
-        "[ETCD->RocksDB-gRPC] Getting key '{}' from service: {}",
-        key, *ROCKSDB_SERVICE_URL
+    logd!(
+        2,
+        "[RocksDB] Getting key '{}' from service: {}",
+        key,
+        *ROCKSDB_SERVICE_URL
     );
 
     match RocksDbServiceClient::connect(ROCKSDB_SERVICE_URL.clone()).await {
@@ -75,33 +77,40 @@ pub async fn get(key: &str) -> Result<String, String> {
                 Ok(response) => {
                     let get_response = response.into_inner();
                     if get_response.success {
-                        println!("[ETCD->RocksDB-gRPC] Successfully retrieved key: {} (value length: {})", key, get_response.value.len());
+                        logd!(
+                            2,
+                            "[RocksDB] Successfully retrieved key: {} (value length: {})",
+                            key,
+                            get_response.value.len()
+                        );
                         Ok(get_response.value)
                     } else {
-                        println!("[ETCD->RocksDB-gRPC] Key not found: {}", key);
+                        logd!(5, "[RocksDB] Key not found: {}", key);
                         Err("Key not found".to_string())
                     }
                 }
                 Err(e) => {
                     let error_msg = format!("gRPC request failed: {}", e);
-                    println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+                    logd!(5, "[RocksDB] {}", error_msg);
                     Err(error_msg)
                 }
             }
         }
         Err(e) => {
             let error_msg = format!("Failed to create client: {}", e);
-            println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+            logd!(5, "[RocksDB] {}", error_msg);
             Err(error_msg)
         }
     }
 }
 
 /// 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> {
-    println!(
-        "[ETCD->RocksDB-gRPC] Getting all keys with prefix '{}' from service: {}",
-        prefix, *ROCKSDB_SERVICE_URL
+    logd!(
+        2,
+        "[RocksDB] Getting all keys with prefix '{}' from service: {}",
+        prefix,
+        *ROCKSDB_SERVICE_URL
     );
 
     match RocksDbServiceClient::connect(ROCKSDB_SERVICE_URL.clone()).await {
@@ -120,40 +129,40 @@ pub async fn get_all_with_prefix(prefix: &str) -> Result<Vec<(String, String)>,
                             .into_iter()
                             .map(|kv| (kv.key, kv.value))
                             .collect();
-                        println!(
-                            "[ETCD->RocksDB-gRPC] Successfully retrieved {} keys with prefix '{}'",
+                        logd!(
+                            2,
+                            "[RocksDB] Successfully retrieved {} keys with prefix '{}'",
                             result.len(),
                             prefix
                         );
                         Ok(result)
                     } else {
-                        println!(
-                            "[ETCD->RocksDB-gRPC] Error from service: {}",
-                            get_response.error
-                        );
+                        logd!(5, "[RocksDB] Error from service: {}", get_response.error);
                         Err(get_response.error)
                     }
                 }
                 Err(e) => {
                     let error_msg = format!("gRPC request failed: {}", e);
-                    println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+                    logd!(5, "[RocksDB] {}", error_msg);
                     Err(error_msg)
                 }
             }
         }
         Err(e) => {
             let error_msg = format!("Failed to create client: {}", e);
-            println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+            logd!(5, "[RocksDB] {}", error_msg);
             Err(error_msg)
         }
     }
 }
 
 /// Delete a key from the gRPC RocksDB service
 pub async fn delete(key: &str) -> Result<(), String> {
-    println!(
-        "[ETCD->RocksDB-gRPC] Deleting key '{}' from service: {}",
-        key, *ROCKSDB_SERVICE_URL
+    logd!(
+        2,
+        "[RocksDB] Deleting key '{}' from service: {}",
+        key,
+        *ROCKSDB_SERVICE_URL
     );
 
     match RocksDbServiceClient::connect(ROCKSDB_SERVICE_URL.clone()).await {
@@ -166,33 +175,34 @@ pub async fn delete(key: &str) -> Result<(), String> {
                 Ok(response) => {
                     let delete_response = response.into_inner();
                     if delete_response.success {
-                        println!("[ETCD->RocksDB-gRPC] Successfully deleted key: {}", key);
+                        logd!(2, "[RocksDB] Successfully deleted key: {}", key);
                         Ok(())
                     } else {
                         let error_msg = delete_response.error;
-                        println!("[ETCD->RocksDB-gRPC] Delete failed: {}", error_msg);
+                        logd!(5, "[RocksDB] Delete failed: {}", error_msg);
                         Err(error_msg)
                     }
                 }
                 Err(e) => {
                     let error_msg = format!("gRPC request failed: {}", e);
-                    println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+                    logd!(5, "[RocksDB] {}", error_msg);
                     Err(error_msg)
                 }
             }
         }
         Err(e) => {
             let error_msg = format!("Failed to create client: {}", e);
-            println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+            logd!(5, "[RocksDB] {}", error_msg);
             Err(error_msg)
         }
     }
 }
 
 /// Batch put operation to store multiple key-value pairs using gRPC RocksDB service
 pub async fn batch_put(items: Vec<(String, String)>) -> Result<(), String> {
-    println!(
-        "[ETCD->RocksDB-gRPC] Batch putting {} items to service: {}",
+    logd!(
+        3,
+        "[RocksDB] Batch putting {} items to service: {}",
         items.len(),
         *ROCKSDB_SERVICE_URL
     );
@@ -210,36 +220,38 @@ pub async fn batch_put(items: Vec<(String, String)>) -> Result<(), String> {
                 Ok(response) => {
                     let batch_response = response.into_inner();
                     if batch_response.success {
-                        println!(
-                            "[ETCD->RocksDB-gRPC] Successfully stored {} items in batch",
+                        logd!(
+                            2,
+                            "[RocksDB] Successfully stored {} items in batch",
                             batch_response.processed_count
                         );
                         Ok(())
                     } else {
                         let error_msg = batch_response.error;
-                        println!("[ETCD->RocksDB-gRPC] Batch put failed: {}", error_msg);
+                        logd!(5, "[RocksDB] Batch put failed: {}", error_msg);
                         Err(error_msg)
                     }
                 }
                 Err(e) => {
                     let error_msg = format!("gRPC request failed: {}", e);
-                    println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+                    logd!(5, "[RocksDB] {}", error_msg);
                     Err(error_msg)
                 }
             }
         }
         Err(e) => {
             let error_msg = format!("Failed to create client: {}", e);
-            println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+            logd!(5, "[RocksDB] {}", error_msg);
             Err(error_msg)
         }
     }
 }
 
 /// Health check for the gRPC RocksDB service
 pub async fn health_check() -> Result<bool, String> {
-    println!(
-        "[ETCD->RocksDB-gRPC] Health check for service: {}",
+    logd!(
+        1,
+        "[RocksDB] Health check for service: {}",
         *ROCKSDB_SERVICE_URL
     );
 
@@ -251,22 +263,23 @@ pub async fn health_check() -> Result<bool, String> {
                 Ok(response) => {
                     let health_response = response.into_inner();
                     let is_healthy = health_response.status == "healthy";
-                    println!(
-                        "[ETCD->RocksDB-gRPC] Health check result: {}",
+                    logd!(
+                        2,
+                        "[RocksDB] Health check result: {}",
                         health_response.status
                     );
                     Ok(is_healthy)
                 }
                 Err(e) => {
                     let error_msg = format!("Health check failed: {}", e);
-                    println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+                    logd!(5, "[RocksDB] {}", error_msg);
                     Err(error_msg)
                 }
             }
         }
         Err(e) => {
             let error_msg = format!("Failed to create client: {}", e);
-            println!("[ETCD->RocksDB-gRPC] {}", error_msg);
+            logd!(5, "[RocksDB] {}", error_msg);
             Err(error_msg)
         }
     }

src/common/src/etcd.rs

@@ -5,8 +5,8 @@
 pub mod receiver;
 pub mod sender;
 
+use common::logd;
 use std::sync::Arc;
-
 use tonic::transport::Server;
 
 /// Initialize the gRPC communication system for ActionController
@@ -29,19 +29,19 @@ pub async fn init(manager: crate::manager::ActionControllerManager) -> common::R
     let grpc_server = receiver::ActionControllerReceiver::new(arc_manager.clone());
 
     let addr = common::actioncontroller::open_server().parse()?;
-    println!("Starting gRPC server on {}", addr);
+    logd!(1, "Starting gRPC server on {}", addr);
 
     tokio::spawn(async move {
         if let Err(e) = Server::builder()
             .add_service(grpc_server.into_service())
             .serve(addr)
             .await
         {
-            eprintln!("gRPC server error: {}", e);
+            logd!(5, "gRPC server error: {}", e);
         }
     });
 
-    println!("gRPC server started and listening");
+    logd!(1, "gRPC server started and listening");
 
     Ok(())
 }
@@ -56,7 +56,6 @@ mod tests {
     #[tokio::test]
     async fn test_open_server_returns_valid_address() {
         let addr = common::actioncontroller::open_server();
-        println!("open_server() returned: {}", addr);
 
         // Just check it contains ":" (host:port format)
         assert!(addr.contains(':'), "Address should be in host:port format");
@@ -65,7 +64,6 @@ mod tests {
     #[tokio::test]
     async fn test_connect_server_returns_valid_url() {
         let url = common::actioncontroller::connect_server();
-        println!("connect_server() returned: {}", url);
 
         // Should start with http:// and contain ":"
         assert!(url.starts_with("http://"));