+ /// Logs the [`Record`].
+ fn log(&self, record: Record);
+}
+
+/// Adds relevant context to a [`Record`] before passing it to the wrapped [`Logger`].
+pub struct WithContext<'a, L: Deref> where L::Target: Logger {
+ /// The logger to delegate to after adding context to the record.
+ logger: &'a L,
+ /// The node id of the peer pertaining to the logged record.
+ peer_id: Option<PublicKey>,
+ /// The channel id of the channel pertaining to the logged record.
+ channel_id: Option<ChannelId>,
+}
+
+impl<'a, L: Deref> Logger for WithContext<'a, L> where L::Target: Logger {
+ fn log(&self, mut record: Record) {
+ if self.peer_id.is_some() {
+ record.peer_id = self.peer_id
+ };
+ if self.channel_id.is_some() {
+ record.channel_id = self.channel_id;
+ }
+ self.logger.log(record)
+ }
+}
+
+impl<'a, L: Deref> WithContext<'a, L> where L::Target: Logger {
+ /// Wraps the given logger, providing additional context to any logged records.
+ pub fn from(logger: &'a L, peer_id: Option<PublicKey>, channel_id: Option<ChannelId>) -> Self {
+ WithContext {
+ logger,
+ peer_id,
+ channel_id,
+ }
+ }
+}
+
+/// Wrapper for logging a [`PublicKey`] in hex format.
+///
+/// This is not exported to bindings users as fmt can't be used in C
+#[doc(hidden)]
+pub struct DebugPubKey<'a>(pub &'a PublicKey);
+impl<'a> core::fmt::Display for DebugPubKey<'a> {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+ for i in self.0.serialize().iter() {
+ write!(f, "{:02x}", i)?;
+ }
+ Ok(())
+ }
+}
+
+/// Wrapper for logging byte slices in hex format.
+///
+/// This is not exported to bindings users as fmt can't be used in C
+#[doc(hidden)]
+pub struct DebugBytes<'a>(pub &'a [u8]);
+impl<'a> core::fmt::Display for DebugBytes<'a> {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+ for i in self.0 {
+ write!(f, "{:02x}", i)?;
+ }
+ Ok(())
+ }
+}
+
+/// Wrapper for logging `Iterator`s.
+///
+/// This is not exported to bindings users as fmt can't be used in C
+#[doc(hidden)]
+pub struct DebugIter<T: fmt::Display, I: core::iter::Iterator<Item = T> + Clone>(pub I);
+impl<T: fmt::Display, I: core::iter::Iterator<Item = T> + Clone> fmt::Display for DebugIter<T, I> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ write!(f, "[")?;
+ let mut iter = self.0.clone();
+ if let Some(item) = iter.next() {
+ write!(f, "{}", item)?;
+ }
+ while let Some(item) = iter.next() {
+ write!(f, ", {}", item)?;
+ }
+ write!(f, "]")?;
+ Ok(())
+ }