Switch logging target when the response to capabilities is a bundle

src/hg_connect_http.rs

@@ -603,6 +603,32 @@ fn http_send_info(data: &mut HttpThreadData) {
                     None
                 }
             };
+            if data.logger.as_ref().map(|logger| logger.log_target())
+                == Some("raw-wire::capabilities")
+            {
+                match content_type.as_deref() {
+                    Some("application/mercurial-0.1") | Some("application/mercurial-0.2") => {}
+                    _ => {
+                        // If the response to the capabilities request is a bundle, log in
+                        // a different category.
+                        // Ideally we'd log the headers too with the switched logger, but
+                        // it's too late for that.
+                        trace!(
+                            target: "raw-wire::capabilities",
+                            "Not a capabilities response; switching to clonebundle.",
+                        );
+                        if log_enabled!(target: "raw-wire::clonebundle", log::Level::Trace) {
+                            let mut writer = LoggingWriter::new_hex(
+                                "raw-wire::clonebundle".to_string(),
+                                log::Level::Trace,
+                                std::io::sink(),
+                            );
+                            writer.set_direction(logging::Direction::Receive);
+                            data.logger = Some(writer);
+                        }
+                    }
+                }
+            }
             data.sender
                 .send(Either::Left(HttpResponseInfo {
                     http_status: http_status as usize,

src/logging.rs

@@ -477,6 +477,10 @@ impl<'a, W: Write> LoggingWriter<'a, W> {
     pub fn set_direction(&mut self, direction: Direction) {
         self.log.direction = direction;
     }
+
+    pub fn log_target(&self) -> &str {
+        &self.log.target
+    }
 }
 
 impl<'a, W: Write> Write for LoggingWriter<'a, W> {