Use context logs in process_pending_htlc_forwards

Utilise `WithChannelContext` instead of using `self.logger` in
`ChannelManager::process_pending_htlc_forwards`.

Author: jbesraa

lightning/src/ln/channelmanager.rs

@@ -5415,6 +5415,23 @@ where
 										panic!("short_channel_id == 0 should imply any pending_forward entries are of type Receive");
 									}
 								};
+
+								let chan_info_opt = self.short_to_chan_info.read().unwrap().get(&short_chan_id).cloned();
+								let mut logger = LogContext::Module(&self.logger);
+								match chan_info_opt {
+									Some((counterparty_node_id, forward_chan_id)) => {
+										let per_peer_state = self.per_peer_state.read().unwrap();
+											if let Some(peer_state_mutex) = per_peer_state.get(&counterparty_node_id) {
+												if let Ok(mut peer_state_lock) = peer_state_mutex.lock() {
+													let peer_state = &mut *peer_state_lock;
+														if let Some(chan) =  peer_state.channel_by_id.get_mut(&forward_chan_id) {
+															logger = LogContext::ChannelContext(WithChannelContext::from(&self.logger, chan.context(), Some(payment_hash)));
+														}
+												}
+											}
+									}
+									_ => {}
+								}; 
 								let claimable_htlc = ClaimableHTLC {
 									prev_hop: HTLCPreviousHopData {
 										short_channel_id: prev_short_channel_id,
@@ -5490,11 +5507,11 @@ where
 											});
 										if $purpose != claimable_payment.purpose {
 											let log_keysend = |keysend| if keysend { "keysend" } else { "non-keysend" };
-											log_trace!(self.logger, "Failing new {} HTLC with payment_hash {} as we already had an existing {} HTLC with the same payment hash", log_keysend(is_keysend), &payment_hash, log_keysend(!is_keysend));
+											log_trace!(logger, "Failing new {} HTLC with payment_hash {} as we already had an existing {} HTLC with the same payment hash", log_keysend(is_keysend), &payment_hash, log_keysend(!is_keysend));
 											fail_htlc!(claimable_htlc, payment_hash);
 										}
 										if !self.default_configuration.accept_mpp_keysend && is_keysend && !claimable_payment.htlcs.is_empty() {
-											log_trace!(self.logger, "Failing new keysend HTLC with payment_hash {} as we already had an existing keysend HTLC with the same payment hash and our config states we don't accept MPP keysend", &payment_hash);
+											log_trace!(logger, "Failing new keysend HTLC with payment_hash {} as we already had an existing keysend HTLC with the same payment hash and our config states we don't accept MPP keysend", &payment_hash);
 											fail_htlc!(claimable_htlc, payment_hash);
 										}
 										if let Some(earlier_fields) = &mut claimable_payment.onion_fields {
@@ -5511,7 +5528,7 @@ where
 											total_value += htlc.sender_intended_value;
 											earliest_expiry = cmp::min(earliest_expiry, htlc.cltv_expiry);
 											if htlc.total_msat != claimable_htlc.total_msat {
-												log_trace!(self.logger, "Failing HTLCs with payment_hash {} as the HTLCs had inconsistent total values (eg {} and {})",
+												log_trace!(logger, "Failing HTLCs with payment_hash {} as the HTLCs had inconsistent total values (eg {} and {})",
 													&payment_hash, claimable_htlc.total_msat, htlc.total_msat);
 												total_value = msgs::MAX_VALUE_MSAT;
 											}
@@ -5522,7 +5539,7 @@ where
 										if total_value >= msgs::MAX_VALUE_MSAT {
 											fail_htlc!(claimable_htlc, payment_hash);
 										} else if total_value - claimable_htlc.sender_intended_value >= claimable_htlc.total_msat {
-											log_trace!(self.logger, "Failing HTLC with payment_hash {} as payment is already claimable",
+											log_trace!(logger, "Failing HTLC with payment_hash {} as payment is already claimable",
 												&payment_hash);
 											fail_htlc!(claimable_htlc, payment_hash);
 										} else if total_value >= claimable_htlc.total_msat {
@@ -5573,17 +5590,17 @@ where
 										match claimable_htlc.onion_payload {
 											OnionPayload::Invoice { .. } => {
 												let payment_data = payment_data.unwrap();
-												let (payment_preimage, min_final_cltv_expiry_delta) = match inbound_payment::verify(payment_hash, &payment_data, self.highest_seen_timestamp.load(Ordering::Acquire) as u64, &self.inbound_payment_key, &self.logger) {
+												let (payment_preimage, min_final_cltv_expiry_delta) = match inbound_payment::verify(payment_hash, &payment_data, self.highest_seen_timestamp.load(Ordering::Acquire) as u64, &self.inbound_payment_key, logger.deref()) {
 													Ok(result) => result,
 													Err(()) => {
-														log_trace!(self.logger, "Failing new HTLC with payment_hash {} as payment verification failed", &payment_hash);
+														log_trace!(logger, "Failing new HTLC with payment_hash {} as payment verification failed", &payment_hash);
 														fail_htlc!(claimable_htlc, payment_hash);
 													}
 												};
 												if let Some(min_final_cltv_expiry_delta) = min_final_cltv_expiry_delta {
 													let expected_min_expiry_height = (self.current_best_block().height + min_final_cltv_expiry_delta as u32) as u64;
 													if (cltv_expiry as u64) < expected_min_expiry_height {
-														log_trace!(self.logger, "Failing new HTLC with payment_hash {} as its CLTV expiry was too soon (had {}, earliest expected {})",
+														log_trace!(logger, "Failing new HTLC with payment_hash {} as its CLTV expiry was too soon (had {}, earliest expected {})",
 															&payment_hash, cltv_expiry, expected_min_expiry_height);
 														fail_htlc!(claimable_htlc, payment_hash);
 													}
@@ -5603,15 +5620,15 @@ where
 									},
 									hash_map::Entry::Occupied(inbound_payment) => {
 										if let OnionPayload::Spontaneous(_) = claimable_htlc.onion_payload {
-											log_trace!(self.logger, "Failing new keysend HTLC with payment_hash {} because we already have an inbound payment with the same payment hash", &payment_hash);
+											log_trace!(logger, "Failing new keysend HTLC with payment_hash {} because we already have an inbound payment with the same payment hash", &payment_hash);
 											fail_htlc!(claimable_htlc, payment_hash);
 										}
 										let payment_data = payment_data.unwrap();
 										if inbound_payment.get().payment_secret != payment_data.payment_secret {
-											log_trace!(self.logger, "Failing new HTLC with payment_hash {} as it didn't match our expected payment secret.", &payment_hash);
+											log_trace!(logger, "Failing new HTLC with payment_hash {} as it didn't match our expected payment secret.", &payment_hash);
 											fail_htlc!(claimable_htlc, payment_hash);
 										} else if inbound_payment.get().min_value_msat.is_some() && payment_data.total_msat < inbound_payment.get().min_value_msat.unwrap() {
-											log_trace!(self.logger, "Failing new HTLC with payment_hash {} as it didn't match our minimum value (had {}, needed {}).",
+											log_trace!(logger, "Failing new HTLC with payment_hash {} as it didn't match our minimum value (had {}, needed {}).",
 												&payment_hash, payment_data.total_msat, inbound_payment.get().min_value_msat.unwrap());
 											fail_htlc!(claimable_htlc, payment_hash);
 										} else {