f: differentiate test and prod log output

Author: joostjager

lightning/src/util/logger.rs

@@ -162,25 +162,59 @@ impl<$($args)?> Display for Record<$($args)?> {
 		write!(&mut context_formatter, "{:<5} [{}:{}]", self.level, self.module_path, self.line)?;
 		context_formatter.pad_remaining()?;
 
-		let mut peer_formatter = SubstringFormatter::new(8, f);
-		if let Some(peer_id) = self.peer_id {
-			write!(peer_formatter, "p:{}", peer_id)?;
-		}
-		peer_formatter.pad_remaining()?;
-
-		let mut channel_formatter = SubstringFormatter::new(10, f);
+		let mut channel_formatter = SubstringFormatter::new(9, f);
 		if let Some(channel_id) = self.channel_id {
-			write!(channel_formatter, " ch:{}", channel_id)?;
+			write!(channel_formatter, "ch:{}", channel_id)?;
 		}
 		channel_formatter.pad_remaining()?;
 
-		let mut payment_formatter = SubstringFormatter::new(9, f);
-		if let Some(payment_hash) = self.payment_hash {
-			write!(payment_formatter, " h:{}", payment_hash)?;
+		#[cfg(not(test))]
+		{
+			let mut peer_formatter = SubstringFormatter::new(9, f);
+			if let Some(peer_id) = self.peer_id {
+				write!(peer_formatter, " p:{}", peer_id)?;
+			}
+			peer_formatter.pad_remaining()?;
+
+			let mut payment_formatter = SubstringFormatter::new(9, f);
+			if let Some(payment_hash) = self.payment_hash {
+				write!(payment_formatter, " h:{}", payment_hash)?;
+			}
+			payment_formatter.pad_remaining()?;
+
+			write!(f, " {}", self.args)
 		}
-		payment_formatter.pad_remaining()?;
 
-		write!(f, " {}", self.args)
+		#[cfg(test)]
+		{
+			write!(f, " {}", self.args)?;
+
+			let mut open_bracket_written = false;
+			if let Some(peer_id) = self.peer_id {
+				write!(f, " [")?;
+				open_bracket_written = true;
+				let mut peer_formatter = SubstringFormatter::new(8, f);
+				write!(peer_formatter, "p:{}", peer_id)?;
+			}
+
+			if let Some(payment_hash) = self.payment_hash {
+				if !open_bracket_written {
+					write!(f, " [")?;
+					open_bracket_written = true;
+				} else {
+					write!(f, " ")?;
+				}
+
+				let mut payment_formatter = SubstringFormatter::new(8, f);
+				write!(payment_formatter, "h:{}", payment_hash)?;
+			}
+
+			if open_bracket_written {
+				write!(f, "]")?;
+			}
+
+			Ok(())
+		}
 	}
 }
 } }
@@ -191,19 +225,19 @@ impl_record!(, 'a);
 
 // Writes only up to a certain number of unicode characters to the underlying formatter. This handles multi-byte Unicode
 // characters safely.
-struct SubstringFormatter<'fmt: 'r, 'r> {
+pub(crate) struct SubstringFormatter<'fmt: 'r, 'r> {
 	remaining_chars: usize,
 	fmt: &'r mut fmt::Formatter<'fmt>,
 }
 
 impl<'fmt: 'r, 'r> SubstringFormatter<'fmt, 'r> {
-	fn new(length: usize, formatter: &'r mut fmt::Formatter<'fmt>) -> Self {
+	pub(crate) fn new(length: usize, formatter: &'r mut fmt::Formatter<'fmt>) -> Self {
 		debug_assert!(length <= 100);
 		SubstringFormatter { remaining_chars: length, fmt: formatter }
 	}
 
 	// Pads the underlying formatter with spaces until the remaining character count.
-	fn pad_remaining(&mut self) -> fmt::Result {
+	pub(crate) fn pad_remaining(&mut self) -> fmt::Result {
 		// Use a constant string to avoid allocations.
 		const PAD100: &str = "                                                                                                    "; // 100 spaces