Tidy various logging uses

Author: frankmcsherry

timely/src/dataflow/scopes/child.rs

@@ -135,8 +135,8 @@ where
         let path = self.addr_for_child(index);
 
         let type_name = std::any::type_name::<T2>();
-        let progress_logging = self.log_register().as_ref().and_then(|l| l.get(&format!("timely/progress/{type_name}")));
-        let summary_logging  = self.log_register().as_ref().and_then(|l| l.get(&format!("timely/summary/{type_name}")));
+        let progress_logging = self.logger_for(&format!("timely/progress/{type_name}"));
+        let summary_logging  = self.logger_for(&format!("timely/summary/{type_name}"));
 
         let subscope = RefCell::new(SubgraphBuilder::new_from(path, identifier, self.logging(), summary_logging, name));
         let result = {

timely/src/progress/subgraph.rs

@@ -10,7 +10,7 @@ use std::cell::RefCell;
 use std::collections::BinaryHeap;
 use std::cmp::Reverse;
 
-use crate::logging::{TimelyLogger as Logger, TimelyProgressEventBuilder};
+use crate::logging::TimelyLogger as Logger;
 use crate::logging::TimelySummaryLogger as SummaryLogger;
 
 use crate::scheduling::Schedule;
@@ -182,13 +182,9 @@ where
         // The `None` argument is optional logging infrastructure.
         let type_name = std::any::type_name::<TInner>();
         let reachability_logging =
-        worker.log_register()
-            .as_ref()
-            .and_then(|l| 
-                l.get::<reachability::logging::TrackerEventBuilder<TInner>>(&format!("timely/reachability/{type_name}"))
-                .map(|logger| reachability::logging::TrackerLogger::new(self.identifier, logger))
-        );
-        let progress_logging = worker.log_register().as_ref().and_then(|l| l.get::<TimelyProgressEventBuilder<TInner>>(&format!("timely/progress/{type_name}")));
+        worker.logger_for(&format!("timely/reachability/{type_name}"))
+              .map(|logger| reachability::logging::TrackerLogger::new(self.identifier, logger));
+        let progress_logging = worker.logger_for(&format!("timely/progress/{type_name}"));
         let (tracker, scope_summary) = builder.build(reachability_logging);
 
         let progcaster = Progcaster::new(worker, Rc::clone(&self.path), self.identifier, self.logging.clone(), progress_logging);

timely/src/worker.rs

@@ -202,8 +202,14 @@ pub trait AsWorker : Scheduler {
     fn peek_identifier(&self) -> usize;
     /// Provides access to named logging streams.
     fn log_register(&self) -> Option<::std::cell::RefMut<crate::logging_core::Registry>>;
+    /// Acquires a logger by name, if the log register exists and the name is registered.
+    ///
+    /// For a more precise understanding of why a result is `None` one can use the direct functions.
+    fn logger_for<CB: timely_container::ContainerBuilder>(&self, name: &str) -> Option<timely_logging::Logger<CB>> {
+        self.log_register().and_then(|l| l.get(name))
+    }
     /// Provides access to the timely logging stream.
-    fn logging(&self) -> Option<crate::logging::TimelyLogger> { self.log_register().and_then(|l| l.get("timely").map(Into::into)) }
+    fn logging(&self) -> Option<crate::logging::TimelyLogger> { self.logger_for("timely").map(Into::into) }
 }
 
 /// A `Worker` is the entry point to a timely dataflow computation. It wraps a `Allocate`,
@@ -579,8 +585,7 @@ impl<A: Allocate> Worker<A> {
         T: Refines<()>,
         F: FnOnce(&mut Child<Self, T>)->R,
     {
-        let logging = self.logging.as_ref().map(|l| l.borrow_mut()).and_then(|l| l.get("timely").map(Into::into));
-        self.dataflow_core("Dataflow", logging, Box::new(()), |_, child| func(child))
+        self.dataflow_core("Dataflow", self.logging(), Box::new(()), |_, child| func(child))
     }
 
     /// Construct a new dataflow with a (purely cosmetic) name.
@@ -603,8 +608,7 @@ impl<A: Allocate> Worker<A> {
         T: Refines<()>,
         F: FnOnce(&mut Child<Self, T>)->R,
     {
-        let logging = self.logging.as_ref().map(|l| l.borrow_mut()).and_then(|l| l.get("timely").map(Into::into));
-        self.dataflow_core(name, logging, Box::new(()), |_, child| func(child))
+        self.dataflow_core(name, self.logging(), Box::new(()), |_, child| func(child))
     }
 
     /// Construct a new dataflow with specific configurations.
@@ -643,8 +647,8 @@ impl<A: Allocate> Worker<A> {
         let identifier = self.new_identifier();
 
         let type_name = std::any::type_name::<T>();
-        let progress_logging = self.logging.as_ref().map(|l| l.borrow_mut()).and_then(|l| l.get(&format!("timely/progress/{}", type_name)).map(Into::into));
-        let summary_logging  = self.logging.as_ref().map(|l| l.borrow_mut()).and_then(|l| l.get(&format!("timely/summary/{}", type_name)).map(Into::into));
+        let progress_logging = self.logger_for(&format!("timely/progress/{}", type_name));
+        let summary_logging  = self.logger_for(&format!("timely/summary/{}", type_name));
         let subscope = SubgraphBuilder::new_from(addr, identifier, logging.clone(), summary_logging, name);
         let subscope = RefCell::new(subscope);