Improves code linting and indexing process

Refactors clippy configuration to lint tests separately, allowing `unwrap_used`, `expect_used`, and `panic` in test code.

Adds total block count and latest block number to indexing logs for better monitoring.
Updates tracing subscriber configuration for enhanced readability in development.

Author: ametel01

.github/workflows/ci.yml

@@ -26,8 +26,11 @@ jobs:
 
       - uses: Swatinem/rust-cache@v2
 
-      - name: Run Clippy
-        run: cargo clippy --all-targets --all-features -- -D warnings -A clippy::unwrap_used -A clippy::expect_used -A clippy::panic
+      - name: Run Clippy on production code
+        run: cargo clippy --lib --bins -- -D warnings
+
+      - name: Run Clippy on tests (with panic allowed)
+        run: cargo clippy --tests -- -D warnings -A clippy::unwrap_used -A clippy::expect_used -A clippy::panic
 
   build:
     needs: [fmt, clippy]

Makefile

@@ -29,7 +29,9 @@ test: ## Run all tests
 
 lint: ## Run clippy linter
 	@echo "Running clippy..."
-	cargo clippy --all-targets --all-features -- -D warnings -A clippy::unwrap_used -A clippy::expect_used -A clippy::panic
+	cargo clippy --lib --bins -- -D warnings
+	@echo "Running clippy on tests (with panic allowed)..."
+	cargo clippy --tests -- -D warnings -A clippy::unwrap_used -A clippy::expect_used -A clippy::panic
 
 format: ## Format code using rustfmt
 	@echo "Formatting code..."

lcov.info

@@ -285,6 +285,20 @@ where
         }
     }
 
+    async fn get_total_block_count(&self) -> Result<i64> {
+        let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM blockheaders")
+            .fetch_one(&self.db.pool)
+            .await?;
+        Ok(count)
+    }
+
+    async fn get_latest_block_number(&self) -> Result<i64> {
+        let latest: Option<i64> = sqlx::query_scalar("SELECT MAX(number) FROM blockheaders")
+            .fetch_one(&self.db.pool)
+            .await?;
+        Ok(latest.unwrap_or(0))
+    }
+
     fn is_backfilling_complete(
         current_backfilling_block_number: i64,
         index_start_block_number: i64,
@@ -356,9 +370,11 @@ where
                     return Err(eyre!("Block storage verification failed: {}. This indicates a critical database consistency issue.", e));
                 }
 
+                let total_blocks = self.get_total_block_count().await.unwrap_or(0);
+                let latest_block = self.get_latest_block_number().await.unwrap_or(0);
                 info!(
-                    "[batch_index] Successfully stored and verified blocks {} to {}",
-                    starting_block, ending_block
+                    "Verified blocks {} to {}. Total blocks in DB: {}, Latest block: {}",
+                    starting_block, ending_block, total_blocks, latest_block
                 );
                 return Ok(());
             }
@@ -574,9 +590,11 @@ where
             eyre!("Database transaction commit failed: {}", e)
         })?;
 
+        let total_blocks = self.get_total_block_count().await.unwrap_or(0);
+        let latest_block = self.get_latest_block_number().await.unwrap_or(0);
         info!(
-            "[batch_index] Indexing block range from {} to {} complete.",
-            starting_block, ending_block
+            "Indexed blocks {} to {}. Total blocks in DB: {}, Latest block: {}",
+            starting_block, ending_block, total_blocks, latest_block
         );
         Ok(())
     }

src/indexer/batch_service.rs

@@ -39,8 +39,14 @@ pub async fn main() -> Result<()> {
         .ok()
         .and_then(|s| s.parse::<u64>().ok());
 
-    // Initialize tracing subscriber
-    fmt().init();
+    // Initialize tracing subscriber with human-readable format
+    fmt()
+        .with_target(false)
+        .with_thread_ids(false)
+        .with_file(false)
+        .with_line_number(false)
+        .compact()
+        .init();
 
     let should_terminate = Arc::new(AtomicBool::new(false));
 

src/indexer/main.rs

@@ -9,7 +9,7 @@ use std::{
 use eyre::{eyre, Result};
 use futures::future::try_join_all;
 use tokio::task;
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, warn};
 
 use crate::{
     db::DbConnection,
@@ -274,7 +274,7 @@ where
     }
 
     async fn wait_for_new_blocks(&self, new_latest_block: BlockNumber) -> Result<()> {
-        info!(
+        debug!(
             "No new block finalized. Latest: {}. Sleeping for {}s...",
             new_latest_block, self.config.poll_interval
         );
@@ -311,7 +311,8 @@ where
                     .await,
                 Ok(())
             ) {
-                Self::log_indexing_success(starting_block, ending_block);
+                self.log_indexing_success(starting_block, ending_block)
+                    .await;
                 return Ok(());
             }
 
@@ -340,10 +341,26 @@ where
             .await
     }
 
-    fn log_indexing_success(starting_block: i64, ending_block: i64) {
+    async fn get_total_block_count(&self) -> Result<i64> {
+        let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM blockheaders")
+            .fetch_one(&self.db.pool)
+            .await?;
+        Ok(count)
+    }
+
+    async fn get_latest_block_number(&self) -> Result<i64> {
+        let latest: Option<i64> = sqlx::query_scalar("SELECT MAX(number) FROM blockheaders")
+            .fetch_one(&self.db.pool)
+            .await?;
+        Ok(latest.unwrap_or(0))
+    }
+
+    async fn log_indexing_success(&self, starting_block: i64, ending_block: i64) {
+        let total_blocks = self.get_total_block_count().await.unwrap_or(0);
+        let latest_block = self.get_latest_block_number().await.unwrap_or(0);
         info!(
-            "[quick_index] Indexing block range from {} to {} complete.",
-            starting_block, ending_block
+            "Indexed blocks {} to {}. Total blocks in DB: {}, Latest block: {}",
+            starting_block, ending_block, total_blocks, latest_block
         );
     }
 
@@ -525,14 +542,16 @@ where
         }
 
         // Verify ending block matches
-        let last_block_num = convert_hex_string_to_i64(&sorted_headers.last().unwrap().number)
-            .map_err(|e| {
-                eyre!(
-                    "Invalid block number in last header: '{}' failed to parse with error: {}",
-                    sorted_headers.last().unwrap().number,
-                    e
-                )
-            })?;
+        let last_header = sorted_headers
+            .last()
+            .ok_or_else(|| eyre!("No headers available after sorting (this should not happen)"))?;
+        let last_block_num = convert_hex_string_to_i64(&last_header.number).map_err(|e| {
+            eyre!(
+                "Invalid block number in last header: '{}' failed to parse with error: {}",
+                last_header.number,
+                e
+            )
+        })?;
         if last_block_num != ending_block {
             return Err(eyre!(
                 "Ending block mismatch: expected {}, got {}",

src/indexer/quick_service.rs

@@ -41,8 +41,15 @@ enum Mode {
 async fn main() -> Result<()> {
     dotenvy::dotenv().ok();
 
-    // Initialize tracing subscriber
-    fmt().with_env_filter(EnvFilter::from_default_env()).init();
+    // Initialize tracing subscriber with human-readable format
+    fmt()
+        .with_env_filter(EnvFilter::from_default_env())
+        .with_target(false)
+        .with_thread_ids(false)
+        .with_file(false)
+        .with_line_number(false)
+        .compact()
+        .init();
 
     info!("Starting Indexer");
 

src/main.rs

@@ -798,9 +798,7 @@ mod integration_tests {
         // Get one of the tx to test.
         let tx = header.transactions[0].clone();
 
-        let expected_tx = tx.clone();
-
-        let BlockTransaction::Full(expected_tx) = expected_tx else {
+        let BlockTransaction::Full(expected_tx) = tx.clone() else {
             panic!("unexpected error due to tx type, should not happen.")
         };