fix: log

Author: aoikurokawa

cranker/src/lib.rs

@@ -79,14 +79,12 @@ impl InterceptorCranker {
     }
 
     pub async fn start(&self) {
-        info!("Starting InterceptorCranker service");
         let mut interval_timer = time::interval(self.interval);
         let mut tick: u64 = 0;
-        info!("Set interval timer to {} seconds", self.interval.as_secs());
 
         loop {
             interval_timer.tick().await;
-            info!("Tick: Starting new processing cycle");
+            info!("Cranker tick tick={tick}");
             match emit_heartbeat(self.rpc_client.clone(), tick, &self.cluster_name).await {
                 Ok(_) => tick += 1,
                 Err(e) => emit_error(format!("Failed to emit heartbeat: {e}"), &self.cluster_name),
@@ -108,19 +106,18 @@ impl InterceptorCranker {
             }
 
             match self.process_expired_receipts().await {
-                Ok(_) => info!("Successfully processed expired receipts"),
+                Ok(_) => info!("Processed expired receipts tick={tick}"),
                 Err(e) => emit_error(
-                    format!("Error processing receipts: {e}"),
+                    format!("Failed to process expired receipts: {e}"),
                     &self.cluster_name,
                 ),
             }
         }
     }
 
     async fn process_expired_receipts(&self) -> Result<(), CrankerError> {
-        info!("Starting to process expired receipts");
         let receipts = self.get_deposit_receipts().await?;
-        info!("Found {} deposit receipts", receipts.len());
+        info!("Fetched deposit receipts count={}", receipts.len());
 
         let now = SystemTime::now()
             .duration_since(UNIX_EPOCH)
@@ -133,52 +130,41 @@ impl InterceptorCranker {
         let mut claimed_receipts: u64 = 0;
 
         for receipt in receipts {
-            // Get raw bytes using bytemuck and interpret as little-endian
             let deposit_time = u64::from(receipt.deposit_time);
             let cool_down = u64::from(receipt.cool_down_seconds);
 
             info!(
-                "Receipt {} raw bytes:\n\
-                  Interpreted values:\n\
-                  deposit_time: {}\n\
-                  cool_down: {}\n\
-                  current_time: {}",
+                "Processing deposit receipt base={} deposit_time={} cool_down={} now={}",
                 receipt.base, deposit_time, cool_down, now
             );
             emit_deposit_receipt(&receipt, &self.cluster_name);
 
             if deposit_time > now {
                 info!(
-                     "Receipt {} not yet expired (future deposit time). Current time: {}, Deposit time: {}",
-                     receipt.base,
-                     now,
-                     deposit_time
-                 );
+                    "Skipping receipt status=future_deposit base={} deposit_time={} now={}",
+                    receipt.base, deposit_time, now
+                );
                 future_deposits += 1;
                 continue;
             }
 
-            // Safe addition check
             match deposit_time.checked_add(cool_down) {
                 Some(expiry_time) => {
                     if now > expiry_time {
                         info!(
-                            "Receipt {} is expired. Current time: {}, Expiry time: {}",
-                            receipt.base, now, expiry_time
+                            "Receipt expired base={} expiry_time={} now={}",
+                            receipt.base, expiry_time, now
                         );
                         match self.claim_pool_tokens(&receipt).await {
                             Ok(_) => {
-                                info!("Successfully claimed tokens for receipt {}", receipt.base);
+                                info!("Claimed pool tokens base={}", receipt.base);
                                 let mut metrics = self.metrics.lock().unwrap();
                                 metrics.successful_claims += 1;
                                 claimed_receipts += 1;
                             }
                             Err(e) => {
                                 emit_error(
-                                    format!(
-                                        "Failed to claim tokens for receipt {}: {}",
-                                        receipt.base, e
-                                    ),
+                                    format!("Failed to claim pool tokens base={}: {}", receipt.base, e),
                                     &self.cluster_name,
                                 );
                                 let mut metrics = self.metrics.lock().unwrap();
@@ -187,19 +173,20 @@ impl InterceptorCranker {
                         }
                     } else {
                         info!(
-                            "Receipt {} not yet expired. Current time: {}, Expiry time: {}",
-                            receipt.base, now, expiry_time
+                            "Skipping receipt status=not_yet_expired base={} expiry_time={} now={}",
+                            receipt.base, expiry_time, now
                         );
                         not_yet_expired_receipts += 1;
                     }
                 }
                 None => {
-                    emit_error(format!(
-                         "Receipt {} has invalid timing values - would overflow. Deposit time: {}, Cool down: {}",
-                         receipt.base,
-                         deposit_time,
-                         cool_down
-                     ), &self.cluster_name);
+                    emit_error(
+                        format!(
+                            "Skipping receipt status=overflow base={} deposit_time={} cool_down={}",
+                            receipt.base, deposit_time, cool_down
+                        ),
+                        &self.cluster_name,
+                    );
                 }
             }
         }
@@ -217,7 +204,6 @@ impl InterceptorCranker {
 
     async fn get_deposit_receipts(&self) -> Result<Vec<DepositReceipt>, CrankerError> {
         let discriminator = StakeDepositInterceptorDiscriminators::DepositReceipt as u8;
-        info!("Searching for deposit receipts");
 
         let accounts = self
             .rpc_client
@@ -239,7 +225,7 @@ impl InterceptorCranker {
             .await
             .map_err(CrankerError::RpcError)?;
 
-        info!("Found {} raw accounts", accounts.len());
+        info!("Fetched program accounts count={}", accounts.len());
 
         Ok(accounts
             .into_iter()
@@ -248,11 +234,7 @@ impl InterceptorCranker {
                 match DepositReceipt::try_from_slice_unchecked(account_data.as_slice()) {
                     Ok(receipt) => {
                         info!(
-                            "Found receipt:\n\
-                                 Account pubkey: {}\n\
-                                 Receipt base: {}\n\
-                                 Receipt stake pool: {}\n\
-                                 Derived PDA: {}",
+                            "Decoded deposit receipt account={} base={} stake_pool={} derived_pda={}",
                             pubkey,
                             receipt.base,
                             receipt.stake_pool,
@@ -263,12 +245,11 @@ impl InterceptorCranker {
                             )
                             .0
                         );
-
                         Some(*receipt)
                     }
                     Err(e) => {
                         emit_error(
-                            format!("Failed to deserialize receipt for {pubkey}: {e}"),
+                            format!("Failed to deserialize receipt account={pubkey}: {e}"),
                             &self.cluster_name,
                         );
                         None
@@ -279,7 +260,7 @@ impl InterceptorCranker {
     }
 
     async fn claim_pool_tokens(&self, receipt: &DepositReceipt) -> Result<(), CrankerError> {
-        info!("Starting detailed claim debug for receipt {}", receipt.base);
+        info!("Claiming pool tokens base={}", receipt.base);
 
         let stake_pool_deposit_authority = self
             .get_stake_pool_deposit_authority(&receipt.stake_pool_deposit_stake_authority)
@@ -288,13 +269,12 @@ impl InterceptorCranker {
         let owner_ata =
             get_associated_token_address(&receipt.owner, &stake_pool_deposit_authority.pool_mint);
 
-        // Check if account exists
         match self.rpc_client.get_account(&owner_ata).await {
             Ok(_) => {
-                info!("Owner token account exists: {owner_ata}");
+                info!("Owner token account exists ata={owner_ata}");
             }
             Err(_) => {
-                info!("Creating owner token account: {owner_ata}");
+                info!("Creating owner token account ata={owner_ata}");
                 let create_ata_ix = create_associated_token_account(
                     &self.payer.pubkey(),
                     &receipt.owner,
@@ -313,7 +293,7 @@ impl InterceptorCranker {
                 self.rpc_client
                     .send_and_confirm_transaction(&create_ata_tx)
                     .await?;
-                info!("Created owner ata token account");
+                info!("Created owner token account ata={owner_ata}");
             }
         }
 
@@ -322,19 +302,12 @@ impl InterceptorCranker {
             &stake_pool_deposit_authority.pool_mint,
         );
 
-        // Check if account exists
         match self.rpc_client.get_account(&fee_wallet_token_account).await {
             Ok(_) => {
-                info!(
-                    "Fee wallet token account exists: {}",
-                    fee_wallet_token_account
-                );
+                info!("Fee wallet token account exists ata={fee_wallet_token_account}");
             }
             Err(_) => {
-                info!(
-                    "Creating fee wallet token account: {}",
-                    fee_wallet_token_account
-                );
+                info!("Creating fee wallet token account ata={fee_wallet_token_account}");
                 let create_ata_ix = create_associated_token_account(
                     &self.payer.pubkey(),
                     &stake_pool_deposit_authority.fee_wallet,
@@ -353,7 +326,7 @@ impl InterceptorCranker {
                 self.rpc_client
                     .send_and_confirm_transaction(&create_ata_tx)
                     .await?;
-                info!("Created fee wallet token account");
+                info!("Created fee wallet token account ata={fee_wallet_token_account}");
             }
         }
 
@@ -388,18 +361,12 @@ impl InterceptorCranker {
             .await
         {
             Ok(sig) => {
-                info!(
-                    "Successfully claimed pool tokens for receipt {}. Transaction signature: {}",
-                    receipt.base, sig
-                );
+                info!("Claimed pool tokens base={} signature={}", receipt.base, sig);
                 Ok(())
             }
             Err(e) => {
                 emit_error(
-                    format!(
-                        "Failed to claim pool tokens for receipt {}. Error: {}",
-                        receipt.base, e
-                    ),
+                    format!("Failed to claim pool tokens base={}: {}", receipt.base, e),
                     &self.cluster_name,
                 );
                 Err(CrankerError::RpcError(e))

cranker/src/main.rs

@@ -7,7 +7,7 @@ use ::{
     solana_metrics::set_host_id,
     solana_sdk::{
         pubkey::Pubkey,
-        signature::{read_keypair_file, Signer}, // Added Signer trait
+        signature::{read_keypair_file, Signer},
     },
     stake_deposit_interceptor_cranker::{CrankerConfig, InterceptorCranker},
     tracing::{info, Level},
@@ -72,40 +72,52 @@ impl TryFrom<Cli> for CrankerConfig {
     }
 }
 
+/// Strips path, query, and userinfo from an RPC URL so embedded API keys
+/// never reach the logs.
+fn redact_url(url: &str) -> String {
+    match url.split_once("://") {
+        Some((scheme, rest)) => {
+            let host = rest
+                .split(['/', '?', '#'])
+                .next()
+                .unwrap_or("")
+                .rsplit('@')
+                .next()
+                .unwrap_or("");
+            format!("{scheme}://{host}/<redacted>")
+        }
+        None => "<redacted>".to_string(),
+    }
+}
+
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Initialize logging with a simpler configuration
-    tracing_subscriber::fmt() // Use fully qualified path
+    dotenv().ok();
+
+    tracing_subscriber::fmt()
         .with_max_level(Level::INFO)
         .with_file(true)
         .with_line_number(true)
         .with_thread_ids(true)
-        .pretty()
+        .compact()
         .init();
 
-    info!("Logger initialized");
-
-    // Load .env file before parsing so clap can read from it
-    dotenv().ok();
-    info!("Environment loaded");
+    info!("Starting interceptor cranker service");
 
-    // Parse configuration from CLI args / environment
     let config = CrankerConfig::try_from(Cli::parse())?;
 
-    info!("Configuration loaded successfully:");
-    info!("RPC URL: {}", config.rpc_url);
-    info!("Program ID: {}", config.program_id);
-    info!("Payer: {}", config.payer.as_ref().pubkey()); // Signer trait now in scope
-    info!("Interval: {}s", config.interval.as_secs());
-    info!("Cluster: {}", config.cluster);
-    info!("Region: {}", config.region);
+    info!("rpc_url={}", redact_url(&config.rpc_url));
+    info!("program_id={}", config.program_id);
+    info!("payer={}", config.payer.as_ref().pubkey());
+    info!("interval_seconds={}", config.interval.as_secs());
+    info!("cluster={}", config.cluster);
+    info!("region={}", config.region);
     info!(
-        "Stake Pool Deposit Stake Authority: {}",
+        "stake_pool_deposit_stake_authority={}",
         config.stake_pool_deposit_stake_authority
     );
-    info!("Whitelist: {}", config.whitelist);
+    info!("whitelist={}", config.whitelist);
 
-    // Set host ID
     let hostname_cmd = Command::new("hostname")
         .output()
         .expect("Failed to execute hostname command");
@@ -119,13 +131,51 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         config.region, config.cluster, hostname
     ));
 
-    // Initialize cranker
     let cranker = InterceptorCranker::new(config);
-    info!("Cranker initialized");
-
-    // Start processing
-    info!("Starting cranker service...");
+    info!("Starting cranker service");
     cranker.start().await;
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::redact_url;
+
+    #[test]
+    fn test_redact_url_strips_path_and_query() {
+        assert_eq!(
+            redact_url("https://mainnet.helius-rpc.com/?api-key=SECRET"),
+            "https://mainnet.helius-rpc.com/<redacted>"
+        );
+        assert_eq!(
+            redact_url("https://example.com/rpc/SECRET"),
+            "https://example.com/<redacted>"
+        );
+    }
+
+    #[test]
+    fn test_redact_url_strips_userinfo() {
+        assert_eq!(
+            redact_url("https://SECRET@example.com/rpc"),
+            "https://example.com/<redacted>"
+        );
+        assert_eq!(
+            redact_url("https://user:pass@example.com:8899"),
+            "https://example.com:8899/<redacted>"
+        );
+    }
+
+    #[test]
+    fn test_redact_url_keeps_host_and_port() {
+        assert_eq!(
+            redact_url("http://127.0.0.1:8899"),
+            "http://127.0.0.1:8899/<redacted>"
+        );
+    }
+
+    #[test]
+    fn test_redact_url_without_scheme() {
+        assert_eq!(redact_url("not a url"), "<redacted>");
+    }
+}