fix(coprocessor): add missing tracing log for tfhe_event_propagate (#320)

Author: dartdart26

coprocessor/fhevm-engine/fhevm-listener/src/database/tfhe_event_propagate.rs

@@ -8,7 +8,10 @@ use sqlx::postgres::PgPoolOptions;
 use sqlx::types::Uuid;
 use sqlx::Error as SqlxError;
 use sqlx::{PgPool, Postgres};
+use tracing::warn;
 use std::time::Duration;
+use tracing::error;
+use tracing::info;
 
 use fhevm_engine_common::types::SupportedFheOperations;
 
@@ -76,8 +79,9 @@ impl Database {
         };
         let mut pool = connect().await;
         while let Err(err) = pool {
-            eprintln!(
-                "Database connection failed. {err}. Will retry indefinitively."
+            error!(
+                error = %err,
+                "Database connection failed. Will retry indefinitely."
             );
             tokio::time::sleep(Duration::from_secs(5)).await;
             pool = connect().await;
@@ -107,7 +111,7 @@ impl Database {
             match query().await {
                 Ok(tenant_id) => return tenant_id,
                 Err(err) if retry_on_sqlx_error(&err) => {
-                    eprintln!("Error requesting tenant id, retrying: {err}");
+                    error!(error = %err, "Error requesting tenant id, retrying");
                     tokio::time::sleep(Duration::from_secs(1)).await;
                 }
                 Err(SqlxError::RowNotFound) => {
@@ -200,9 +204,9 @@ impl Database {
             match query().execute(&self.pool).await {
                 Ok(_) => return Ok(()),
                 Err(err) if retry_on_sqlx_error(&err) => {
-                    eprintln!(
-                        "\tDatabase I/O error: {}, will retry indefinitely",
-                        err
+                    error!(
+                        error = %err,
+                        "Database I/O error, will retry indefinitely"
                     );
                     self.reconnect().await;
                 }
@@ -365,9 +369,9 @@ impl Database {
                     .collect::<Vec<_>>();
 
                 for handle in handles.clone() {
-                    println!(
-                        "Allowed for public decryption: {}",
-                        compact_hex(&handle),
+                    info!(
+                        handle = compact_hex(&handle),
+                        "Allowed for public decryption"
                     );
 
                     self.insert_allowed_handle(
@@ -381,47 +385,56 @@ impl Database {
                 self.insert_pbs_computations(&handles).await?;
             }
             AclContractEvents::Initialized(initialized) => {
-                println!("unhandled Acl::Initialized event {:?}", initialized);
+                warn!(event = ?initialized, "unhandled Acl::Initialized event");
             }
             AclContractEvents::NewDelegation(new_delegation) => {
-                println!(
-                    "unhandled Acl::NewDelegation event {:?}",
-                    new_delegation
+                warn!(
+                    event = ?new_delegation,
+                    "unhandled Acl::NewDelegation event"
                 );
             }
             AclContractEvents::OwnershipTransferStarted(
                 ownership_transfer_started,
             ) => {
-                println!(
-                    "unhandled Acl::OwnershipTransferStarted event {:?}",
-                    ownership_transfer_started
+                warn!(
+                    event = ?ownership_transfer_started,
+                    "unhandled Acl::OwnershipTransferStarted event"
                 );
             }
             AclContractEvents::OwnershipTransferred(ownership_transferred) => {
-                println!(
-                    "unhandled Acl::OwnershipTransferred event {:?}",
-                    ownership_transferred
+                warn!(
+                    event = ?ownership_transferred,
+                    "unhandled Acl::OwnershipTransferred event"
                 );
             }
             AclContractEvents::RevokedDelegation(revoked_delegation) => {
-                println!(
-                    "unhandled Acl::RevokedDelegation event {:?}",
-                    revoked_delegation
+                warn!(
+                    event = ?revoked_delegation,
+                    "unhandled Acl::RevokedDelegation event"
                 );
             }
             AclContractEvents::Upgraded(upgraded) => {
-                println!("unhandled Acl::Upgraded event {:?}", upgraded);
+                warn!(
+                    event = ?upgraded,
+                    "unhandled Acl::Upgraded event"
+                );
             }
             AclContractEvents::Paused(paused) => {
-                println!("unhandled Acl::Paused event {:?}", paused);
+                warn!(
+                    event = ?paused,
+                    "unhandled Acl::Paused event"
+                );
             }
             AclContractEvents::Unpaused(unpaused) => {
-                println!("unhandled Acl::Unpaused event {:?}", unpaused);
+                warn!(
+                    event = ?unpaused,
+                    "unhandled Acl::Unpaused event"
+                );
             }
             AclContractEvents::UpdatePauser(update_pauser) => {
-                println!(
-                    "unhandled Acl::UpdatePauser event {:?}",
-                    update_pauser
+                warn!(
+                    event = ?update_pauser,
+                    "unhandled Acl::UpdatePauser event"
                 );
             }
         }
@@ -450,10 +463,7 @@ impl Database {
                 match query().execute(&self.pool).await {
                     Ok(_) => break,
                     Err(err) if retry_on_sqlx_error(&err) => {
-                        eprintln!(
-                            "\tDatabase I/O error: {}, will retry indefinitely",
-                            err
-                        );
+                        error!(error = %err, "Database I/O error, will retry indefinitely");
                         self.reconnect().await;
                     }
                     Err(sqlx_err) => {
@@ -490,10 +500,7 @@ impl Database {
             match query().execute(&self.pool).await {
                 Ok(_) => break,
                 Err(err) if retry_on_sqlx_error(&err) => {
-                    eprintln!(
-                        "\tDatabase I/O error: {}, will retry indefinitely",
-                        err
-                    );
+                    error!(error = %err, "Database I/O error, will retry indefinitely");
                     self.reconnect().await;
                 }
                 Err(sqlx_err) => {
@@ -533,9 +540,7 @@ fn event_to_op_int(op: &TfheContractEvents) -> FheOperation {
         E::FheNeg(_) => O::FheNeg as i32,
         E::FheNot(_) => O::FheNot as i32,
         E::Cast(_) => O::FheCast as i32,
-        E::TrivialEncrypt(_) => {
-            O::FheTrivialEncrypt as i32
-        }
+        E::TrivialEncrypt(_) => O::FheTrivialEncrypt as i32,
         E::FheIfThenElse(_) => O::FheIfThenElse as i32,
         E::FheRand(_) => O::FheRand as i32,
         E::FheRandBounded(_) => O::FheRandBounded as i32,