add more logging for syncing and migrating

server/src/db/mod.rs

···
         let _guard = scc::ebr::Guard::new();
         for (_, handle) in self.hits.iter(&_guard) {
             let mut nsid_data = Vec::with_capacity(2);
+            let mut total_count = 0;
             let is_too_old = handle.since_last_activity() > self.max_last_activity;
             // if we disconnect for a long time, we want to sync all of what we
             // have to avoid having many small blocks (even if we run compaction
···
             if count > 0 && (all || data_count > 0 || is_too_old) {
                 for i in 0..data_count {
                     nsid_data.push((i, handle.clone(), block_size));
+                    total_count += block_size;
                 }
                 // only sync remainder if we haven't met block size
                 let remainder = count % block_size;
                 if (all || data_count == 0) && remainder > 0 {
                     nsid_data.push((data_count, handle.clone(), remainder));
+                    total_count += remainder;
                 }
             }
+            tracing::info!(
+                "{}: will sync {} blocks ({} count)",
+                handle.nsid(),
+                nsid_data.len(),
+                total_count,
+            );
             data.push(nsid_data);
         }
         drop(_guard);
···
                     .map(|(i, handle, max_block_size)| {
                         handle
                             .encode_block(max_block_size)
+                            .inspect(|block| {
+                                tracing::info!(
+                                    "{}: encoded block with {} items",
+                                    handle.nsid(),
+                                    block.written,
+                                )
+                            })
                             .map(|block| (i, block, handle))
                     })
                     .collect::<Result<Vec<_>, _>>()
···
                 self.sync_pool
                     .execute(move || match handle.insert(block.key, block.data) {
                         Ok(_) => {
-                            tracing::info!(
-                                "[{i}] synced {} of {} to db",
-                                block.written,
-                                handle.nsid()
-                            )
+                            tracing::info!("{}: [{i}] synced {}", block.written, handle.nsid())
                         }
                         Err(err) => tracing::error!("failed to sync block: {}", err),
                     });

server/src/main.rs

···
     }
     let read_time = start.elapsed();
     let read_per_second = total_count as f64 / read_time.as_secs_f64();
+    drop(from);
+    tracing::info!("starting sync!!!");
     to.sync(true).expect("cant sync");
     let total_time = start.elapsed();
     let write_per_second = total_count as f64 / (total_time - read_time).as_secs_f64();