feat(dips): enhance logging with agreement ID in DIPs processing

Signed-off-by: Lorenzo Delgado <[email protected]>

Author: LNSD

crates/dips/src/lib.rs

@@ -325,6 +325,9 @@ pub async fn validate_and_create_agreement(
 
     decoded_voucher.validate(signer_validator, domain, expected_payee, allowed_payers)?;
 
+    // Extract and parse the agreement ID from the voucher
+    let agreement_id = Uuid::from_bytes(decoded_voucher.voucher.agreement_id.into());
+
     let manifest = ipfs_fetcher.fetch(&metadata.subgraphDeploymentId).await?;
 
     let network = match registry.get_network_by_id(&metadata.chainId) {
@@ -337,7 +340,9 @@ pub async fn validate_and_create_agreement(
 
     match manifest.network() {
         Some(manifest_network_name) => {
-            tracing::debug!("Subgraph manifest network: {}", manifest_network_name);
+            tracing::debug!(
+                agreement_id = %agreement_id,
+                "Subgraph manifest network: {}", manifest_network_name);
             if manifest_network_name != network {
                 return Err(DipsError::InvalidSubgraphManifest(
                     metadata.subgraphDeploymentId,
@@ -354,28 +359,64 @@ pub async fn validate_and_create_agreement(
     let offered_epoch_price = metadata.basePricePerEpoch;
     match price_calculator.get_minimum_price(&metadata.chainId) {
         Some(price) if offered_epoch_price.lt(&Uint::from(price)) => {
+            tracing::debug!(
+                agreement_id = %agreement_id,
+                chain_id = %metadata.chainId,
+                deployment_id = %metadata.subgraphDeploymentId,
+                "offered epoch price '{}' is lower than minimum price '{}'",
+                offered_epoch_price,
+                price
+            );
             return Err(DipsError::PricePerEpochTooLow(
                 network,
                 price,
                 offered_epoch_price.to_string(),
-            ))
+            ));
         }
         Some(_) => {}
-        None => return Err(DipsError::UnsupportedChainId(metadata.chainId)),
+        None => {
+            tracing::debug!(
+                agreement_id = %agreement_id,
+                chain_id = %metadata.chainId,
+                deployment_id = %metadata.subgraphDeploymentId,
+                "chain id '{}' is not supported",
+                metadata.chainId
+            );
+            return Err(DipsError::UnsupportedChainId(metadata.chainId));
+        }
     }
 
     let offered_entity_price = metadata.pricePerEntity;
     if offered_entity_price < price_calculator.entity_price() {
+        tracing::debug!(
+            agreement_id = %agreement_id,
+            chain_id = %metadata.chainId,
+            deployment_id = %metadata.subgraphDeploymentId,
+            "offered entity price '{}' is lower than minimum price '{}'",
+            offered_entity_price,
+            price_calculator.entity_price()
+        );
         return Err(DipsError::PricePerEntityTooLow(
             network,
             price_calculator.entity_price(),
             offered_entity_price.to_string(),
         ));
     }
 
+    tracing::debug!(
+        agreement_id = %agreement_id,
+        chain_id = %metadata.chainId,
+        deployment_id = %metadata.subgraphDeploymentId,
+        "creating agreement"
+    );
+
     store
         .create_agreement(decoded_voucher.clone(), metadata)
-        .await?;
+        .await
+        .map_err(|error| {
+            tracing::error!(%agreement_id, %error, "failed to create agreement");
+            error
+        })?;
 
     Ok(Uuid::from_bytes(
         decoded_voucher.voucher.agreement_id.into(),

crates/monitor/src/escrow_accounts.rs

@@ -144,6 +144,8 @@ async fn get_escrow_accounts_v1(
 
     let response = response?;
 
+    tracing::trace!("Escrow accounts response: {:?}", response);
+
     let senders_balances: HashMap<Address, U256> = response
         .escrow_accounts
         .iter()