Spawn threads with names

index-scheduler/src/index_mapper.rs

@@ -126,24 +126,27 @@ impl IndexMapper {
         let index_map = self.index_map.clone();
         let index_path = self.base_path.join(uuid.to_string());
         let index_name = name.to_string();
-        thread::spawn(move || {
-            // We first wait to be sure that the previously opened index is effectively closed.
-            // This can take a lot of time, this is why we do that in a seperate thread.
-            if let Some(closing_event) = closing_event {
-                closing_event.wait();
-            }
+        thread::Builder::new()
+            .name(String::from("index_deleter"))
+            .spawn(move || {
+                // We first wait to be sure that the previously opened index is effectively closed.
+                // This can take a lot of time, this is why we do that in a seperate thread.
+                if let Some(closing_event) = closing_event {
+                    closing_event.wait();
+                }
 
-            // Then we remove the content from disk.
-            if let Err(e) = fs::remove_dir_all(&index_path) {
-                error!(
-                    "An error happened when deleting the index {} ({}): {}",
-                    index_name, uuid, e
-                );
-            }
+                // Then we remove the content from disk.
+                if let Err(e) = fs::remove_dir_all(&index_path) {
+                    error!(
+                        "An error happened when deleting the index {} ({}): {}",
+                        index_name, uuid, e
+                    );
+                }
 
-            // Finally we remove the entry from the index map.
-            assert!(matches!(index_map.write().unwrap().remove(&uuid), Some(BeingDeleted)));
-        });
+                // Finally we remove the entry from the index map.
+                assert!(matches!(index_map.write().unwrap().remove(&uuid), Some(BeingDeleted)));
+            })
+            .unwrap();
 
         Ok(())
     }

index-scheduler/src/lib.rs

@@ -412,28 +412,31 @@ impl IndexScheduler {
     /// only once per index scheduler.
     fn run(&self) {
         let run = self.private_clone();
-        std::thread::spawn(move || loop {
-            run.wake_up.wait();
+        std::thread::Builder::new()
+            .name(String::from("scheduler"))
+            .spawn(move || loop {
+                run.wake_up.wait();
 
-            match run.tick() {
-                Ok(0) => (),
-                Ok(_) => run.wake_up.signal(),
-                Err(e) => {
-                    log::error!("{}", e);
-                    // Wait one second when an irrecoverable error occurs.
-                    if matches!(
-                        e,
-                        Error::CorruptedTaskQueue
-                            | Error::TaskDatabaseUpdate(_)
-                            | Error::HeedTransaction(_)
-                            | Error::CreateBatch(_)
-                    ) {
-                        std::thread::sleep(Duration::from_secs(1));
+                match run.tick() {
+                    Ok(0) => (),
+                    Ok(_) => run.wake_up.signal(),
+                    Err(e) => {
+                        log::error!("{}", e);
+                        // Wait one second when an irrecoverable error occurs.
+                        if matches!(
+                            e,
+                            Error::CorruptedTaskQueue
+                                | Error::TaskDatabaseUpdate(_)
+                                | Error::HeedTransaction(_)
+                                | Error::CreateBatch(_)
+                        ) {
+                            std::thread::sleep(Duration::from_secs(1));
+                        }
+                        run.wake_up.signal();
                     }
-                    run.wake_up.signal();
                 }
-            }
-        });
+            })
+            .unwrap();
     }
 
     pub fn indexer_config(&self) -> &IndexerConfig {
@@ -925,7 +928,10 @@ impl IndexScheduler {
         // 2. Process the tasks
         let res = {
             let cloned_index_scheduler = self.private_clone();
-            let handle = std::thread::spawn(move || cloned_index_scheduler.process_batch(batch));
+            let handle = std::thread::Builder::new()
+                .name(String::from("batch-operation"))
+                .spawn(move || cloned_index_scheduler.process_batch(batch))
+                .unwrap();
             handle.join().unwrap_or(Err(Error::ProcessBatchPanicked))
         };
 

meilisearch-http/src/lib.rs

@@ -204,12 +204,15 @@ pub fn setup_meilisearch(opt: &Opt) -> anyhow::Result<(Arc<IndexScheduler>, Auth
     if opt.schedule_snapshot {
         let snapshot_delay = Duration::from_secs(opt.snapshot_interval_sec);
         let index_scheduler = index_scheduler.clone();
-        thread::spawn(move || loop {
-            thread::sleep(snapshot_delay);
-            if let Err(e) = index_scheduler.register(KindWithContent::SnapshotCreation) {
-                error!("Error while registering snapshot: {}", e);
-            }
-        });
+        thread::Builder::new()
+            .name(String::from("register-snapshot-tasks"))
+            .spawn(move || loop {
+                thread::sleep(snapshot_delay);
+                if let Err(e) = index_scheduler.register(KindWithContent::SnapshotCreation) {
+                    error!("Error while registering snapshot: {}", e);
+                }
+            })
+            .unwrap();
     }
 
     Ok((index_scheduler, auth_controller))