Move all println's after logger setup to the log facade

Author: tankyleo

rust/impls/Cargo.toml

@@ -12,6 +12,7 @@ bytes = "1.4.0"
 tokio = { version = "1.38.0", default-features = false, features = ["rt", "macros"] }
 native-tls = { version = "0.2.14", default-features = false }
 postgres-native-tls = { version = "0.5.2", default-features = false, features = ["runtime"] }
+log = "0.4.29"
 
 [dev-dependencies]
 tokio = { version = "1.38.0", default-features = false, features = ["rt-multi-thread", "macros"] }

rust/impls/src/postgres_store.rs

@@ -17,6 +17,8 @@ use tokio::sync::Mutex;
 use tokio_postgres::tls::{MakeTlsConnect, TlsConnect};
 use tokio_postgres::{error, Client, NoTls, Socket, Transaction};
 
+use log::{info, error, warn, debug};
+
 pub use native_tls::Certificate;
 
 pub(crate) struct VssDbRecord {
@@ -104,6 +106,7 @@ where
 
 	async fn ensure_connected(&self, client: &mut Client) -> Result<(), Error> {
 		if client.is_closed() || client.check_connection().await.is_err() {
+			debug!("Rotating connection to the postgres database");
 			let new_client =
 				make_db_connection(&self.endpoint, &self.db_name, self.tls.clone()).await?;
 			*client = new_client;
@@ -145,7 +148,7 @@ where
 	// Connection must be driven on a separate task, and will resolve when the client is dropped
 	tokio::spawn(async move {
 		if let Err(e) = connection.await {
-			eprintln!("Connection error: {}", e);
+			warn!("Connection error: {}", e);
 		}
 	});
 	Ok(client)
@@ -173,7 +176,7 @@ where
 		client.execute(&stmt, &[]).await.map_err(|e| {
 			Error::new(ErrorKind::Other, format!("Failed to create database {}: {}", db_name, e))
 		})?;
-		println!("Created database {}", db_name);
+		info!("Created database {}", db_name);
 	}
 
 	Ok(())
@@ -291,7 +294,7 @@ where
 			panic!("We do not allow downgrades");
 		}
 
-		println!("Applying migration(s) {} through {}", migration_start, migrations.len() - 1);
+		info!("Applying migration(s) {} through {}", migration_start, migrations.len() - 1);
 
 		for (idx, &stmt) in (&migrations[migration_start..]).iter().enumerate() {
 			let _num_rows = tx.execute(stmt, &[]).await.map_err(|e| {

rust/server/src/main.rs

@@ -17,7 +17,7 @@ use tokio::signal::unix::SignalKind;
 use hyper::server::conn::http1;
 use hyper_util::rt::TokioIo;
 
-use log::error;
+use log::{error, info, warn};
 
 use api::auth::{Authorizer, NoopAuthorizer};
 use api::kv_store::KvStore;
@@ -52,7 +52,7 @@ fn main() {
 	let runtime = match tokio::runtime::Builder::new_multi_thread().enable_all().build() {
 		Ok(runtime) => Arc::new(runtime),
 		Err(e) => {
-			eprintln!("Failed to setup tokio runtime: {}", e);
+			error!("Failed to setup tokio runtime: {}", e);
 			std::process::exit(-1);
 		},
 	};
@@ -62,15 +62,15 @@ fn main() {
 		let mut sighup_stream = match tokio::signal::unix::signal(SignalKind::hangup()) {
 			Ok(stream) => stream,
 			Err(e) => {
-				eprintln!("Failed to register SIGHUP handler: {e}");
+				error!("Failed to register SIGHUP handler: {e}");
 				std::process::exit(-1);
 			}
 		};
 
 		let mut sigterm_stream = match tokio::signal::unix::signal(SignalKind::terminate()) {
 			Ok(stream) => stream,
 			Err(e) => {
-				println!("Failed to register for SIGTERM stream: {}", e);
+				error!("Failed to register for SIGTERM stream: {}", e);
 				std::process::exit(-1);
 			},
 		};
@@ -81,11 +81,11 @@ fn main() {
 			if let Some(rsa_pem) = config.rsa_pem {
 				authorizer = match JWTAuthorizer::new(&rsa_pem).await {
 					Ok(auth) => {
-						println!("Configured JWT authorizer with RSA public key");
+						info!("Configured JWT authorizer with RSA public key");
 						Some(Arc::new(auth))
 					},
 					Err(e) => {
-						println!("Failed to configure JWT authorizer: {}", e);
+						error!("Failed to configure JWT authorizer: {}", e);
 						std::process::exit(-1);
 					},
 				};
@@ -94,14 +94,14 @@ fn main() {
 		#[cfg(feature = "sigs")]
 		{
 			if authorizer.is_none() {
-				println!("Configured signature-validating authorizer");
+				info!("Configured signature-validating authorizer");
 				authorizer = Some(Arc::new(SignatureValidatingAuthorizer));
 			}
 		}
 		let authorizer = if let Some(auth) = authorizer {
 			auth
 		} else {
-			println!("No authentication method configured, all storage with the same store id will be commingled.");
+			warn!("No authentication method configured, all storage with the same store id will be commingled.");
 			Arc::new(NoopAuthorizer {})
 		};
 
@@ -114,10 +114,10 @@ fn main() {
 			)
 			.await
 			.unwrap_or_else(|e| {
-				println!("Failed to start postgres TLS backend: {}", e);
+				error!("Failed to start postgres TLS backend: {}", e);
 				std::process::exit(-1);
 			});
-			println!(
+			info!(
 				"Connected to PostgreSQL TLS backend with DSN: {}/{}",
 				config.postgresql_prefix, config.vss_db
 			);
@@ -130,21 +130,21 @@ fn main() {
 			)
 			.await
 			.unwrap_or_else(|e| {
-				println!("Failed to start postgres plaintext backend: {}", e);
+				error!("Failed to start postgres plaintext backend: {}", e);
 				std::process::exit(-1);
 			});
-			println!(
+			info!(
 				"Connected to PostgreSQL plaintext backend with DSN: {}/{}",
 				config.postgresql_prefix, config.vss_db
 			);
 			Arc::new(postgres_plaintext_backend)
 		};
 
 		let rest_svc_listener = TcpListener::bind(&config.bind_address).await.unwrap_or_else(|e| {
-			println!("Failed to bind listening port: {}", e);
+			error!("Failed to bind listening port: {}", e);
 			std::process::exit(-1);
 		});
-		println!("Listening for incoming connections on {}{}", config.bind_address, crate::vss_service::BASE_PATH_PREFIX);
+		info!("Listening for incoming connections on {}{}", config.bind_address, crate::vss_service::BASE_PATH_PREFIX);
 
 		loop {
 			tokio::select! {
@@ -155,15 +155,15 @@ fn main() {
 							let vss_service = VssService::new(Arc::clone(&store), Arc::clone(&authorizer));
 							runtime.spawn(async move {
 								if let Err(err) = http1::Builder::new().serve_connection(io_stream, vss_service).await {
-									eprintln!("Failed to serve connection: {}", err);
+									warn!("Failed to serve connection: {}", err);
 								}
 							});
 						},
-						Err(e) => eprintln!("Failed to accept connection: {}", e),
+						Err(e) => warn!("Failed to accept connection: {}", e),
 					}
 				}
 				_ = tokio::signal::ctrl_c() => {
-					println!("Received CTRL-C, shutting down..");
+					info!("Received CTRL-C, shutting down..");
 					break;
 				}
 				_ = sighup_stream.recv() => {
@@ -172,7 +172,7 @@ fn main() {
 					}
 				}
 				_ = sigterm_stream.recv() => {
-					println!("Received SIGTERM, shutting down..");
+					info!("Received SIGTERM, shutting down..");
 					break;
 				}
 			}

rust/server/src/vss_service.rs

@@ -18,6 +18,8 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 
+use log::{debug, trace};
+
 #[derive(Clone)]
 pub struct VssService {
 	store: Arc<dyn KvStore>,
@@ -73,22 +75,42 @@ impl Service<Request<Incoming>> for VssService {
 async fn handle_get_object_request(
 	store: Arc<dyn KvStore>, user_token: String, request: GetObjectRequest,
 ) -> Result<GetObjectResponse, VssError> {
-	store.get(user_token, request).await
+	trace!("handling GetObject request with store_id {}", request.store_id);
+	let result = store.get(user_token, request).await;
+	if let Err(ref e) = result {
+		debug!("GetObject request with store_id {} failed", e);
+	}
+	result
 }
 async fn handle_put_object_request(
 	store: Arc<dyn KvStore>, user_token: String, request: PutObjectRequest,
 ) -> Result<PutObjectResponse, VssError> {
-	store.put(user_token, request).await
+	trace!("handling PutObject request with store_id {}", request.store_id);
+	let result = store.put(user_token, request).await;
+	if let Err(ref e) = result {
+		debug!("PutObject request with store_id {} failed", e);
+	}
+	result
 }
 async fn handle_delete_object_request(
 	store: Arc<dyn KvStore>, user_token: String, request: DeleteObjectRequest,
 ) -> Result<DeleteObjectResponse, VssError> {
-	store.delete(user_token, request).await
+	trace!("handling DeleteObject request with store_id {}", request.store_id);
+	let result = store.delete(user_token, request).await;
+	if let Err(ref e) = result {
+		debug!("DeleteObject request with store_id {} failed", e);
+	}
+	result
 }
 async fn handle_list_object_request(
 	store: Arc<dyn KvStore>, user_token: String, request: ListKeyVersionsRequest,
 ) -> Result<ListKeyVersionsResponse, VssError> {
-	store.list_key_versions(user_token, request).await
+	trace!("handling ListKeyVersions request with store_id {}", request.store_id);
+	let result = store.list_key_versions(user_token, request).await;
+	if let Err(ref e) = result {
+		debug!("ListKeyVersions request with store_id {} failed", e);
+	}
+	result
 }
 async fn handle_request<
 	T: Message + Default,