chore: formatting

src/bin/quickdid.rs

···
     metrics::create_metrics_publisher,
     queue::{
         HandleResolutionWork, QueueAdapter, create_mpsc_queue_from_channel, create_noop_queue,
-        create_redis_queue, create_redis_queue_with_dedup, create_sqlite_queue, 
+        create_redis_queue, create_redis_queue_with_dedup, create_sqlite_queue,
         create_sqlite_queue_with_max_size,
     },
     sqlite_schema::create_sqlite_pool,
···
                     "    QUEUE_REDIS_PREFIX  Redis key prefix for queues (default: queue:handleresolver:)"
                 );
                 println!("    QUEUE_REDIS_TIMEOUT Queue blocking timeout in seconds (default: 5)");
-                println!("    QUEUE_REDIS_DEDUP_ENABLED Enable queue deduplication (default: false)");
+                println!(
+                    "    QUEUE_REDIS_DEDUP_ENABLED Enable queue deduplication (default: false)"
+                );
                 println!("    QUEUE_REDIS_DEDUP_TTL TTL for dedup keys in seconds (default: 60)");
                 println!("    QUEUE_WORKER_ID     Worker ID for Redis queue (default: worker1)");
                 println!("    QUEUE_BUFFER_SIZE   Buffer size for MPSC queue (default: 1000)");

src/handle_resolver/proactive_refresh.rs

···
                 resolve_time_us = resolve_time,
                 "Fast resolution detected, considering proactive refresh"
             );
-            
+
             if let Some(metrics) = &self.metrics {
                 metrics.incr("proactive_refresh.cache_hit_detected").await;
             }
···
     threshold: f64,
 ) -> Arc<dyn HandleResolver> {
     Arc::new(DynProactiveRefreshResolver::with_metrics(
-        inner, queue, Some(metrics), cache_ttl, threshold,
+        inner,
+        queue,
+        Some(metrics),
+        cache_ttl,
+        threshold,
     ))
 }
 

src/handle_resolver_task.rs

···
 
     /// Check if an error represents a soft failure (handle not found)
     /// rather than a real error condition.
-    /// 
+    ///
     /// These atproto_identity library errors indicate the handle doesn't support
     /// the specific resolution method, which is normal and expected:
     /// - error-atproto-identity-resolve-4: DNS resolution failed (no records)
···
             error_str.contains("NoRecordsFound")
         } else if error_str.starts_with("error-atproto-identity-resolve-5") {
             // HTTP resolution - check if it's a hostname lookup failure
-            error_str.contains("No address associated with hostname") ||
-            error_str.contains("failed to lookup address information")
+            error_str.contains("No address associated with hostname")
+                || error_str.contains("failed to lookup address information")
         } else {
             false
         }
···
             }
             Ok(Err(e)) => {
                 let error_str = e.to_string();
-                
+
                 if Self::is_soft_failure(&error_str) {
                     // This is a soft failure - handle simply doesn't support this resolution method
                     // Publish not-found metrics
···
         assert!(!HandleResolverTask::is_soft_failure(dns_real_error));
 
         // Test HTTP error that is NOT a soft failure (connection timeout)
-        let http_timeout = "error-atproto-identity-resolve-5 HTTP resolution failed: connection timeout";
+        let http_timeout =
+            "error-atproto-identity-resolve-5 HTTP resolution failed: connection timeout";
         assert!(!HandleResolverTask::is_soft_failure(http_timeout));
 
         // Test HTTP error that is NOT a soft failure (500 error)
···
         assert!(!HandleResolverTask::is_soft_failure(http_500));
 
         // Test QuickDID errors should never be soft failures
-        let quickdid_error = "error-quickdid-resolve-1 Failed to resolve subject: internal server error";
+        let quickdid_error =
+            "error-quickdid-resolve-1 Failed to resolve subject: internal server error";
         assert!(!HandleResolverTask::is_soft_failure(quickdid_error));
 
         // Test other atproto_identity error codes should not be soft failures

src/metrics.rs

···
             .build(buffered_sink);
         let client = StatsdClient::from_sink(prefix, queuing_sink);
 
-        tracing::info!("StatsdMetricsPublisher created successfully with bind address: {}", bind_addr);
+        tracing::info!(
+            "StatsdMetricsPublisher created successfully with bind address: {}",
+            bind_addr
+        );
         Ok(Self {
             client,
             default_tags,

src/queue/redis.rs

···
         }
 
         let dedup_key = self.dedup_key(item_id);
-        
+
         // Use SET NX EX to atomically set if not exists with expiry
         // Returns OK if the key was set, Nil if it already existed
         let result: Option<String> = deadpool_redis::redis::cmd("SET")
···
         if self.dedup_enabled {
             let dedup_id = work.dedup_key();
             let is_new = self.check_and_mark_dedup(&mut conn, &dedup_id).await?;
-            
+
             if !is_new {
                 debug!(
                     dedup_key = %dedup_id,
···
                 .unwrap()
                 .as_nanos()
         );
-        
+
         // Create adapter with deduplication enabled
         let adapter = RedisQueueAdapter::<HandleResolutionWork>::with_dedup(
             pool.clone(),
             "test-worker-dedup".to_string(),
             test_prefix.clone(),
             1,
-            true,  // Enable deduplication
-            2,     // 2 second TTL for quick testing
+            true, // Enable deduplication
+            2,    // 2 second TTL for quick testing
         );
 
         let work = HandleResolutionWork::new("alice.example.com".to_string());
 
         // First push should succeed
-        adapter.push(work.clone()).await.expect("First push should succeed");
-        
+        adapter
+            .push(work.clone())
+            .await
+            .expect("First push should succeed");
+
         // Second push of same item should be deduplicated (but still return Ok)
-        adapter.push(work.clone()).await.expect("Second push should succeed (deduplicated)");
-        
+        adapter
+            .push(work.clone())
+            .await
+            .expect("Second push should succeed (deduplicated)");
+
         // Queue should only have one item
         let depth = adapter.depth().await;
-        assert_eq!(depth, Some(1), "Queue should only have one item after deduplication");
-        
+        assert_eq!(
+            depth,
+            Some(1),
+            "Queue should only have one item after deduplication"
+        );
+
         // Pull the item
         let pulled = adapter.pull().await;
         assert_eq!(pulled, Some(work.clone()));
-        
+
         // Queue should now be empty
         let depth = adapter.depth().await;
         assert_eq!(depth, Some(0), "Queue should be empty after pulling");
-        
+
         // Wait for dedup TTL to expire
         tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
-        
+
         // Should be able to push again after TTL expires
-        adapter.push(work.clone()).await.expect("Push after TTL expiry should succeed");
-        
+        adapter
+            .push(work.clone())
+            .await
+            .expect("Push after TTL expiry should succeed");
+
         let depth = adapter.depth().await;
-        assert_eq!(depth, Some(1), "Queue should have one item after TTL expiry");
+        assert_eq!(
+            depth,
+            Some(1),
+            "Queue should have one item after TTL expiry"
+        );
     }
 
     #[tokio::test]
···
                 .unwrap()
                 .as_nanos()
         );
-        
+
         // Create adapter with deduplication disabled
         let adapter = RedisQueueAdapter::<HandleResolutionWork>::with_dedup(
             pool.clone(),
             "test-worker-nodedup".to_string(),
             test_prefix.clone(),
             1,
-            false,  // Disable deduplication
+            false, // Disable deduplication
             60,
         );
 
         let work = HandleResolutionWork::new("bob.example.com".to_string());
 
         // Push same item twice
-        adapter.push(work.clone()).await.expect("First push should succeed");
-        adapter.push(work.clone()).await.expect("Second push should succeed");
-        
+        adapter
+            .push(work.clone())
+            .await
+            .expect("First push should succeed");
+        adapter
+            .push(work.clone())
+            .await
+            .expect("Second push should succeed");
+
         // Queue should have two items (no deduplication)
         let depth = adapter.depth().await;
-        assert_eq!(depth, Some(2), "Queue should have two items when deduplication is disabled");
-        
+        assert_eq!(
+            depth,
+            Some(2),
+            "Queue should have two items when deduplication is disabled"
+        );
+
         // Pull both items
         let pulled1 = adapter.pull().await;
         assert_eq!(pulled1, Some(work.clone()));
-        
+
         let pulled2 = adapter.pull().await;
         assert_eq!(pulled2, Some(work.clone()));
-        
+
         // Queue should now be empty
         let depth = adapter.depth().await;
-        assert_eq!(depth, Some(0), "Queue should be empty after pulling all items");
+        assert_eq!(
+            depth,
+            Some(0),
+            "Queue should be empty after pulling all items"
+        );
     }
 
     #[tokio::test]

src/queue/work.rs

···
         // Same handle should have same dedup key
         assert_eq!(work1.dedup_key(), work2.dedup_key());
         assert_eq!(work1.dedup_key(), "alice.example.com");
-        
+
         // Different handle should have different dedup key
         assert_ne!(work1.dedup_key(), work3.dedup_key());
         assert_eq!(work3.dedup_key(), "bob.example.com");