Give a name to all non-main threads

yama/src/pile/local_sqlitebloblogs.rs

@@ -706,7 +706,9 @@ impl RawPile for SqliteBloblogPile {
 
         let this = self.clone();
 
-        thread::spawn(move || {
+        thread::Builder::new()
+            .name("SQLBloblogStPpln".to_string())
+            .spawn(move || {
                 let worker_id = Arc::new(format!("bloblogwriter"));
                 if let Err(err) = this.storage_pipeline_worker(incoming) {
                     controller_send
@@ -716,7 +718,8 @@ impl RawPile for SqliteBloblogPile {
                         })
                         .expect("This is BAD: failed to send failure message to controller.");
                 }
-        });
+            })
+            .unwrap();
 
         Ok(sender)
     }

yama/src/remote/requester.rs

@@ -39,22 +39,34 @@ impl Requester {
             // Spawn a reader
             let in_flight = in_flight.clone();
             let shutdown_signal = shutdown_signal.clone();
-            handles.push(thread::spawn(move || {
+            handles.push(
+                thread::Builder::new()
+                    .name("ReqstrReader".to_string())
+                    .spawn(move || {
                         if let Err(e) = Self::reader(read, in_flight, shutdown_signal) {
                             error!("reader failed: {:?}", e);
                         }
-            }));
+                    })
+                    .unwrap(),
+            );
         }
 
         {
             // Spawn a writer
             let in_flight = in_flight.clone();
             let command_receiver = command_receiver.clone();
-            handles.push(thread::spawn(move || {
+            handles.push(
-                if let Err(e) = Self::writer(write, in_flight, command_receiver, shutdown_signal) {
+                thread::Builder::new()
+                    .name("ReqstrWriter".to_string())
+                    .spawn(move || {
+                        if let Err(e) =
+                            Self::writer(write, in_flight, command_receiver, shutdown_signal)
+                        {
                             error!("writer failed: {:?}", e);
                         }
-            }));
+                    })
+                    .unwrap(),
+            );
         }
 
         (
@@ -77,26 +89,38 @@ impl Requester {
             // Spawn a reader
             let in_flight = in_flight.clone();
             let shutdown_signal = shutdown_signal.clone();
-            handles.push(thread::spawn(move || {
+            handles.push(
+                thread::Builder::new()
+                    .name("ReqstrReaderSI".to_string())
+                    .spawn(move || {
                         let stdin = stdin();
                         let read = stdin.lock();
                         if let Err(e) = Self::reader(read, in_flight, shutdown_signal) {
                             error!("reader failed: {:?}", e);
                         }
-            }));
+                    })
+                    .unwrap(),
+            );
         }
 
         {
             // Spawn a writer
             let in_flight = in_flight.clone();
             let command_receiver = command_receiver.clone();
-            handles.push(thread::spawn(move || {
+            handles.push(
+                thread::Builder::new()
+                    .name("ReqstrWriterSO".to_string())
+                    .spawn(move || {
                         let stdout = stdout();
                         let write = stdout.lock();
-                if let Err(e) = Self::writer(write, in_flight, command_receiver, shutdown_signal) {
+                        if let Err(e) =
+                            Self::writer(write, in_flight, command_receiver, shutdown_signal)
+                        {
                             error!("writer failed: {:?}", e);
                         }
-            }));
+                    })
+                    .unwrap(),
+            );
         }
 
         (
@@ -327,7 +351,9 @@ impl RawPile for Requester {
         let command_sender = self.commands.clone();
         register_histogram!("requester_cmd_response_time_ms", Unit::Milliseconds);
 
-        std::thread::spawn(move || {
+        std::thread::Builder::new()
+            .name("ReqStPpln".to_string())
+            .spawn(move || {
                 let (response_tx, response_rx) = crossbeam_channel::bounded::<ResponseBody>(32);
                 let mut in_flight_writes = 0;
                 const MAX_IN_FLIGHT_WRITES: u32 = 32;
@@ -394,7 +420,8 @@ impl RawPile for Requester {
                         }
                     }
                 }
-        });
+            })
+            .unwrap();
 
         Ok(input)
     }

yama/src/remote/responder.rs

@@ -54,26 +54,33 @@ impl Responder {
             // spawn the reader
             let work_queue_send = work_queue_send.clone();
             let responder = responder.clone();
-            thread::spawn(move || {
+            thread::Builder::new()
+                .name("RespdrReader".to_string())
+                .spawn(move || {
                     let mut read = read;
-                if let Err(e) = responder.reader(&mut read, work_queue_send, &mut progress_bar) {
+                    if let Err(e) = responder.reader(&mut read, work_queue_send, &mut progress_bar)
+                    {
                         error!("reader failed: {:?}", e);
                     }
                     read
                 })
+                .unwrap()
         };
 
         let w_handle = {
             // spawn the writer
             let resp_recv = resp_recv.clone();
             let responder = responder.clone();
-            thread::spawn(move || {
+            thread::Builder::new()
+                .name("RespdrWriter".to_string())
+                .spawn(move || {
                     let mut write = write;
                     if let Err(e) = responder.writer(&mut write, resp_recv) {
                         error!("writer failed: {:?}", e);
                     }
                     write
                 })
+                .unwrap()
         };
 
         for worker_num in 0..num_workers {
@@ -82,11 +89,17 @@ impl Responder {
             let work_queue_recv = work_queue_recv.clone();
             let resp_send = resp_send.clone();
             let pile = pile.clone();
-            handles.push(thread::spawn(move || {
+            handles.push(
-                if let Err(e) = responder.worker(pile.as_ref(), work_queue_recv, resp_send) {
+                thread::Builder::new()
+                    .name("RespdrWorker".to_string())
+                    .spawn(move || {
+                        if let Err(e) = responder.worker(pile.as_ref(), work_queue_recv, resp_send)
+                        {
                             error!("worker {} failed: {:?}", worker_num, e);
                         }
-            }));
+                    })
+                    .unwrap(),
+            );
         }
 
         (r_handle, w_handle, handles)