Add files using upload-large-folder tool

diffs/pr_10025/15190c5/diff.json

@@ -0,0 +1,110 @@
+{
+  "commit_sha": "15190c59749a33d2aca29849e348a50fccd7b8c3",
+  "pr_number": 10025,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/payjustnow.rs",
+    "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::impl::PayjustnowRefundRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl<F> TryFrom<&RefundsRouterData<F>> for PayjustnowRefundRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.request.refund_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),\n            refund_amount_cents: item.request.minor_refund_amount,\n            refund_description: item\n                .request\n                .reason\n                .clone()\n                .unwrap_or(\"No reason provided\".to_string()),\n        })\n    }\n}",
+      "after_code": "impl<F> TryFrom<&RefundsRouterData<F>> for PayjustnowRefundRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.request.refund_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),\n            refund_amount_cents: item.request.minor_refund_amount,\n            refund_description: item\n                .request\n                .reason\n                .clone()\n                .unwrap_or(NO_REFUND_REASON.to_string()),\n        })\n    }\n}",
+      "diff_span": {
+        "before": "                .reason\n                .clone()\n                .unwrap_or(\"No reason provided\".to_string()),\n        })\n    }",
+        "after": "                .reason\n                .clone()\n                .unwrap_or(NO_REFUND_REASON.to_string()),\n        })\n    }"
+      },
+      "commit_sha": "15190c59749a33d2aca29849e348a50fccd7b8c3"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::PayjustnowRefundRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.request.refund_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),\n            refund_amount_cents: item.request.minor_refund_amount,\n            refund_description: item\n                .request\n                .reason\n                .clone()\n                .unwrap_or(\"No reason provided\".to_string()),\n        })\n    }",
+      "after_code": "fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.request.refund_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),\n            refund_amount_cents: item.request.minor_refund_amount,\n            refund_description: item\n                .request\n                .reason\n                .clone()\n                .unwrap_or(NO_REFUND_REASON.to_string()),\n        })\n    }",
+      "diff_span": {
+        "before": "                .reason\n                .clone()\n                .unwrap_or(\"No reason provided\".to_string()),\n        })\n    }",
+        "after": "                .reason\n                .clone()\n                .unwrap_or(NO_REFUND_REASON.to_string()),\n        })\n    }"
+      },
+      "commit_sha": "15190c59749a33d2aca29849e348a50fccd7b8c3"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow.rs::Payjustnow::function::validate_psync_reference_id",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn validate_psync_reference_id(\n        &self,\n        _data: &PaymentsSyncData,\n        _is_three_ds: bool,\n        _status: enums::AttemptStatus,\n        _connector_meta_data: Option<common_utils::pii::SecretSerdeValue>,\n    ) -> CustomResult<(), errors::ConnectorError> {\n        Ok(())\n    }",
+      "after_code": "fn validate_psync_reference_id(\n        &self,\n        data: &PaymentsSyncData,\n        _is_three_ds: bool,\n        _status: enums::AttemptStatus,\n        _connector_meta_data: Option<common_utils::pii::SecretSerdeValue>,\n    ) -> CustomResult<(), errors::ConnectorError> {\n        if data.encoded_data.is_some()\n            || data\n                .connector_transaction_id\n                .get_connector_transaction_id()\n                .is_ok()\n        {\n            return Ok(());\n        }\n\n        Err(errors::ConnectorError::MissingConnectorTransactionID.into())\n    }",
+      "diff_span": {
+        "before": "fn validate_psync_reference_id(\n        &self,\n        _data: &PaymentsSyncData,\n        _is_three_ds: bool,\n        _status: enums::AttemptStatus,\n        _connector_meta_data: Option<common_utils::pii::SecretSerdeValue>,\n    ) -> CustomResult<(), errors::ConnectorError> {\n        Ok(())\n    }",
+        "after": "fn validate_psync_reference_id(\n        &self,\n        data: &PaymentsSyncData,\n        _is_three_ds: bool,\n        _status: enums::AttemptStatus,\n        _connector_meta_data: Option<common_utils::pii::SecretSerdeValue>,\n    ) -> CustomResult<(), errors::ConnectorError> {\n        if data.encoded_data.is_some()\n            || data\n                .connector_transaction_id\n                .get_connector_transaction_id()\n                .is_ok()\n        {\n            return Ok(());\n        }\n\n        Err(errors::ConnectorError::MissingConnectorTransactionID.into())\n    }"
+      },
+      "commit_sha": "15190c59749a33d2aca29849e348a50fccd7b8c3"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::impl::PayjustnowPaymentsRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<&PayjustnowRouterData<&PaymentsAuthorizeRouterData>> for PayjustnowPaymentsRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: &PayjustnowRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let router_data = item.router_data;\n        let order_items = router_data\n            .request\n            .order_details\n            .as_ref()\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|order| {\n                        Ok(OrderItem {\n                            name: order.product_name.clone(),\n                            sku: order.product_id.clone().unwrap_or_default(),\n                            quantity: u32::from(order.quantity),\n                            price_cents: order.amount,\n                            // image_url: order.product_img_link.clone().unwrap_or_default(),\n                            // category: order.category.clone().unwrap_or_default(),\n                        })\n                    })\n                    .collect::<Result<Vec<OrderItem>, errors::ConnectorError>>()\n            })\n            .transpose()?;\n\n        let customer = router_data\n            .get_optional_billing_email()\n            .or_else(|| item.router_data.request.email.clone())\n            .map(|email| Customer {\n                first_name: router_data.get_optional_billing_first_name(),\n                last_name: router_data.get_optional_billing_last_name(),\n                email,\n                phone_number: router_data.get_optional_billing_phone_number(),\n            });\n\n        let billing_address = Some(Address {\n            address_line1: router_data.get_optional_billing_line1(),\n            address_line2: router_data.get_optional_billing_line2(),\n            city: router_data.get_optional_billing_city(),\n            province: router_data.get_optional_billing_state(),\n            postal_code: item.router_data.get_optional_billing_zip(),\n        });\n\n        let shipping_address = Some(Address {\n            address_line1: item.router_data.get_optional_shipping_line1(),\n            address_line2: item.router_data.get_optional_shipping_line2(),\n            city: item.router_data.get_optional_shipping_city(),\n            province: item.router_data.get_optional_shipping_state(),\n            postal_code: item.router_data.get_optional_shipping_zip(),\n        });\n\n        let confirm_redirect_url = \"https://www.google.com/\".to_string();\n        let cancel_redirect_url = \"https://www.google.com/\".to_string();\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url,\n            cancel_redirect_url,\n        };\n\n        Ok(Self {\n            payjustnow: payjustnow_request,\n            checkout_total_cents: item.amount,\n        })\n    }\n}",
+      "after_code": "impl TryFrom<&PayjustnowRouterData<&PaymentsAuthorizeRouterData>> for PayjustnowPaymentsRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: &PayjustnowRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let router_data = item.router_data;\n        let order_items = router_data\n            .request\n            .order_details\n            .as_ref()\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|order| {\n                        Ok(OrderItem {\n                            name: order.product_name.clone(),\n                            sku: order.product_id.clone().unwrap_or_default(),\n                            quantity: u32::from(order.quantity),\n                            price_cents: order.amount,\n                        })\n                    })\n                    .collect::<Result<Vec<OrderItem>, errors::ConnectorError>>()\n            })\n            .transpose()?;\n\n        let customer = router_data\n            .get_optional_billing_email()\n            .or_else(|| item.router_data.request.email.clone())\n            .map(|email| Customer {\n                first_name: router_data.get_optional_billing_first_name(),\n                last_name: router_data.get_optional_billing_last_name(),\n                email,\n                phone_number: router_data.get_optional_billing_phone_number(),\n            });\n\n        let billing_address = Some(Address {\n            address_line1: router_data.get_optional_billing_line1(),\n            address_line2: router_data.get_optional_billing_line2(),\n            city: router_data.get_optional_billing_city(),\n            province: router_data.get_optional_billing_state(),\n            postal_code: item.router_data.get_optional_billing_zip(),\n        });\n\n        let shipping_address = Some(Address {\n            address_line1: item.router_data.get_optional_shipping_line1(),\n            address_line2: item.router_data.get_optional_shipping_line2(),\n            city: item.router_data.get_optional_shipping_city(),\n            province: item.router_data.get_optional_shipping_state(),\n            postal_code: item.router_data.get_optional_shipping_zip(),\n        });\n\n        let router_return_url = item.router_data.request.get_router_return_url()?;\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url: router_return_url.clone(),\n            cancel_redirect_url: router_return_url,\n        };\n\n        Ok(Self {\n            payjustnow: payjustnow_request,\n            checkout_total_cents: item.amount,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "                            quantity: u32::from(order.quantity),\n                            price_cents: order.amount,\n                            // image_url: order.product_img_link.clone().unwrap_or_default(),\n                            // category: order.category.clone().unwrap_or_default(),\n                        })\n                    })\n                    .collect::<Result<Vec<OrderItem>, errors::ConnectorError>>()\n            })\n            .transpose()?;\n\n        let customer = router_data\n            .get_optional_billing_email()\n            .or_else(|| item.router_data.request.email.clone())\n            .map(|email| Customer {\n                first_name: router_data.get_optional_billing_first_name(),\n                last_name: router_data.get_optional_billing_last_name(),\n                email,\n                phone_number: router_data.get_optional_billing_phone_number(),\n            });\n\n        let billing_address = Some(Address {\n            address_line1: router_data.get_optional_billing_line1(),\n            address_line2: router_data.get_optional_billing_line2(),\n            city: router_data.get_optional_billing_city(),\n            province: router_data.get_optional_billing_state(),\n            postal_code: item.router_data.get_optional_billing_zip(),\n        });\n\n        let shipping_address = Some(Address {\n            address_line1: item.router_data.get_optional_shipping_line1(),\n            address_line2: item.router_data.get_optional_shipping_line2(),\n            city: item.router_data.get_optional_shipping_city(),\n            province: item.router_data.get_optional_shipping_state(),\n            postal_code: item.router_data.get_optional_shipping_zip(),\n        });\n\n        let confirm_redirect_url = \"https://www.google.com/\".to_string();\n        let cancel_redirect_url = \"https://www.google.com/\".to_string();\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url,\n            cancel_redirect_url,\n        };\n",
+        "after": "        });\n\n        let router_return_url = item.router_data.request.get_router_return_url()?;\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url: router_return_url.clone(),\n            cancel_redirect_url: router_return_url,\n        };\n"
+      },
+      "commit_sha": "15190c59749a33d2aca29849e348a50fccd7b8c3"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::PayjustnowPaymentsRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: &PayjustnowRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let router_data = item.router_data;\n        let order_items = router_data\n            .request\n            .order_details\n            .as_ref()\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|order| {\n                        Ok(OrderItem {\n                            name: order.product_name.clone(),\n                            sku: order.product_id.clone().unwrap_or_default(),\n                            quantity: u32::from(order.quantity),\n                            price_cents: order.amount,\n                            // image_url: order.product_img_link.clone().unwrap_or_default(),\n                            // category: order.category.clone().unwrap_or_default(),\n                        })\n                    })\n                    .collect::<Result<Vec<OrderItem>, errors::ConnectorError>>()\n            })\n            .transpose()?;\n\n        let customer = router_data\n            .get_optional_billing_email()\n            .or_else(|| item.router_data.request.email.clone())\n            .map(|email| Customer {\n                first_name: router_data.get_optional_billing_first_name(),\n                last_name: router_data.get_optional_billing_last_name(),\n                email,\n                phone_number: router_data.get_optional_billing_phone_number(),\n            });\n\n        let billing_address = Some(Address {\n            address_line1: router_data.get_optional_billing_line1(),\n            address_line2: router_data.get_optional_billing_line2(),\n            city: router_data.get_optional_billing_city(),\n            province: router_data.get_optional_billing_state(),\n            postal_code: item.router_data.get_optional_billing_zip(),\n        });\n\n        let shipping_address = Some(Address {\n            address_line1: item.router_data.get_optional_shipping_line1(),\n            address_line2: item.router_data.get_optional_shipping_line2(),\n            city: item.router_data.get_optional_shipping_city(),\n            province: item.router_data.get_optional_shipping_state(),\n            postal_code: item.router_data.get_optional_shipping_zip(),\n        });\n\n        let confirm_redirect_url = \"https://www.google.com/\".to_string();\n        let cancel_redirect_url = \"https://www.google.com/\".to_string();\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url,\n            cancel_redirect_url,\n        };\n\n        Ok(Self {\n            payjustnow: payjustnow_request,\n            checkout_total_cents: item.amount,\n        })\n    }",
+      "after_code": "fn try_from(\n        item: &PayjustnowRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let router_data = item.router_data;\n        let order_items = router_data\n            .request\n            .order_details\n            .as_ref()\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|order| {\n                        Ok(OrderItem {\n                            name: order.product_name.clone(),\n                            sku: order.product_id.clone().unwrap_or_default(),\n                            quantity: u32::from(order.quantity),\n                            price_cents: order.amount,\n                        })\n                    })\n                    .collect::<Result<Vec<OrderItem>, errors::ConnectorError>>()\n            })\n            .transpose()?;\n\n        let customer = router_data\n            .get_optional_billing_email()\n            .or_else(|| item.router_data.request.email.clone())\n            .map(|email| Customer {\n                first_name: router_data.get_optional_billing_first_name(),\n                last_name: router_data.get_optional_billing_last_name(),\n                email,\n                phone_number: router_data.get_optional_billing_phone_number(),\n            });\n\n        let billing_address = Some(Address {\n            address_line1: router_data.get_optional_billing_line1(),\n            address_line2: router_data.get_optional_billing_line2(),\n            city: router_data.get_optional_billing_city(),\n            province: router_data.get_optional_billing_state(),\n            postal_code: item.router_data.get_optional_billing_zip(),\n        });\n\n        let shipping_address = Some(Address {\n            address_line1: item.router_data.get_optional_shipping_line1(),\n            address_line2: item.router_data.get_optional_shipping_line2(),\n            city: item.router_data.get_optional_shipping_city(),\n            province: item.router_data.get_optional_shipping_state(),\n            postal_code: item.router_data.get_optional_shipping_zip(),\n        });\n\n        let router_return_url = item.router_data.request.get_router_return_url()?;\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url: router_return_url.clone(),\n            cancel_redirect_url: router_return_url,\n        };\n\n        Ok(Self {\n            payjustnow: payjustnow_request,\n            checkout_total_cents: item.amount,\n        })\n    }",
+      "diff_span": {
+        "before": "                            quantity: u32::from(order.quantity),\n                            price_cents: order.amount,\n                            // image_url: order.product_img_link.clone().unwrap_or_default(),\n                            // category: order.category.clone().unwrap_or_default(),\n                        })\n                    })\n                    .collect::<Result<Vec<OrderItem>, errors::ConnectorError>>()\n            })\n            .transpose()?;\n\n        let customer = router_data\n            .get_optional_billing_email()\n            .or_else(|| item.router_data.request.email.clone())\n            .map(|email| Customer {\n                first_name: router_data.get_optional_billing_first_name(),\n                last_name: router_data.get_optional_billing_last_name(),\n                email,\n                phone_number: router_data.get_optional_billing_phone_number(),\n            });\n\n        let billing_address = Some(Address {\n            address_line1: router_data.get_optional_billing_line1(),\n            address_line2: router_data.get_optional_billing_line2(),\n            city: router_data.get_optional_billing_city(),\n            province: router_data.get_optional_billing_state(),\n            postal_code: item.router_data.get_optional_billing_zip(),\n        });\n\n        let shipping_address = Some(Address {\n            address_line1: item.router_data.get_optional_shipping_line1(),\n            address_line2: item.router_data.get_optional_shipping_line2(),\n            city: item.router_data.get_optional_shipping_city(),\n            province: item.router_data.get_optional_shipping_state(),\n            postal_code: item.router_data.get_optional_shipping_zip(),\n        });\n\n        let confirm_redirect_url = \"https://www.google.com/\".to_string();\n        let cancel_redirect_url = \"https://www.google.com/\".to_string();\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url,\n            cancel_redirect_url,\n        };\n",
+        "after": "        });\n\n        let router_return_url = item.router_data.request.get_router_return_url()?;\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url: router_return_url.clone(),\n            cancel_redirect_url: router_return_url,\n        };\n"
+      },
+      "commit_sha": "15190c59749a33d2aca29849e348a50fccd7b8c3"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::struct::OrderItem",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct OrderItem {\n    name: String,\n    sku: String,\n    quantity: u32,\n    price_cents: MinorUnit,\n    // image_url: String,\n    // category: String,\n}",
+      "after_code": "pub struct OrderItem {\n    name: String,\n    sku: String,\n    quantity: u32,\n    price_cents: MinorUnit,\n}",
+      "diff_span": {
+        "before": "    quantity: u32,\n    price_cents: MinorUnit,\n    // image_url: String,\n    // category: String,\n}",
+        "after": ""
+      },
+      "commit_sha": "15190c59749a33d2aca29849e348a50fccd7b8c3"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::const::NO_REFUND_REASON",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "const_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "const NO_REFUND_REASON: &str = \"No reason provided\";",
+      "diff_span": null,
+      "commit_sha": "15190c59749a33d2aca29849e348a50fccd7b8c3"
+    }
+  ]
+}

diffs/pr_10025/9bedc92/diff.json

@@ -0,0 +1,54 @@
+{
+  "commit_sha": "9bedc92c4f353b2b7d2707930e3b369b09cd496b",
+  "pr_number": 10025,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/payjustnow.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow.rs::Payjustnow::function::get_webhook_source_verification_message",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_webhook_source_verification_message(\n        &self,\n        request: &webhooks::IncomingWebhookRequestDetails<'_>,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        let body_with_no_whitespace = request\n            .body\n            .iter()\n            .filter(|&b| !b.is_ascii_whitespace())\n            .copied()\n            .collect::<Vec<u8>>();\n\n        Ok(body_with_no_whitespace)\n    }",
+      "after_code": "fn get_webhook_source_verification_message(\n        &self,\n        request: &webhooks::IncomingWebhookRequestDetails<'_>,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        let message = request\n            .body\n            .iter()\n            .filter(|&b| !b.is_ascii_whitespace())\n            .copied()\n            .collect::<Vec<u8>>();\n\n        Ok(message)\n    }",
+      "diff_span": {
+        "before": "        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        let body_with_no_whitespace = request\n            .body\n            .iter()\n            .filter(|&b| !b.is_ascii_whitespace())\n            .copied()\n            .collect::<Vec<u8>>();\n\n        Ok(body_with_no_whitespace)\n    }",
+        "after": "        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        let message = request\n            .body\n            .iter()\n            .filter(|&b| !b.is_ascii_whitespace())\n            .copied()\n            .collect::<Vec<u8>>();\n\n        Ok(message)\n    }"
+      },
+      "commit_sha": "9bedc92c4f353b2b7d2707930e3b369b09cd496b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow.rs::Payjustnow::function::build_headers",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn build_headers(\n        &self,\n        req: &RouterData<Flow, Request, Response>,\n        _connectors: &Connectors,\n    ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {\n        let mut header = vec![\n            (\n                headers::CONTENT_TYPE.to_string(),\n                self.get_content_type().to_string().into(),\n            ),\n            (\n                headers::USER_AGENT.to_string(),\n                hyperswitch_interfaces::consts::USER_AGENT\n                    .to_string()\n                    .into(),\n            ),\n        ];\n        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;\n        header.append(&mut api_key);\n        Ok(header)\n    }",
+      "after_code": "fn build_headers(\n        &self,\n        req: &RouterData<Flow, Request, Response>,\n        connectors: &Connectors,\n    ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {\n        let request_body = Self::get_request_body(self, req, connectors)?;\n\n        let request_body_string =\n            String::from_utf8(request_body.get_inner_value().peek().as_bytes().to_vec())\n                .map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;\n        let request_body_string_without_whitespace =\n            request_body_string.replace(char::is_whitespace, \"\");\n\n        let auth = payjustnow::PayjustnowAuthType::try_from(&req.connector_auth_type)\n            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;\n\n        let signature = crypto::HmacSha256::sign_message(\n            &crypto::HmacSha256,\n            auth.signing_key.expose().as_bytes(),\n            request_body_string_without_whitespace.as_bytes(),\n        )\n        .change_context(errors::ConnectorError::RequestEncodingFailed)?;\n\n        let signature_base64 = base64::engine::general_purpose::STANDARD.encode(signature);\n\n        let mut headers = vec![\n            (\n                headers::CONTENT_TYPE.to_string(),\n                self.get_content_type().to_string().into(),\n            ),\n            (\n                headers::USER_AGENT.to_string(),\n                hyperswitch_interfaces::consts::USER_AGENT\n                    .to_string()\n                    .into(),\n            ),\n        ];\n        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;\n        headers.append(&mut api_key);\n        headers.push((\"X-Signature\".to_string(), signature_base64.into_masked()));\n\n        Ok(headers)\n    }",
+      "diff_span": {
+        "before": "        &self,\n        req: &RouterData<Flow, Request, Response>,\n        _connectors: &Connectors,\n    ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {\n        let mut header = vec![\n            (\n                headers::CONTENT_TYPE.to_string(),\n                self.get_content_type().to_string().into(),\n            ),\n            (\n                headers::USER_AGENT.to_string(),\n                hyperswitch_interfaces::consts::USER_AGENT\n                    .to_string()\n                    .into(),\n            ),\n        ];\n        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;\n        header.append(&mut api_key);\n        Ok(header)\n    }",
+        "after": "        &self,\n        req: &RouterData<Flow, Request, Response>,\n        connectors: &Connectors,\n    ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {\n        let request_body = Self::get_request_body(self, req, connectors)?;\n\n        let request_body_string =\n            String::from_utf8(request_body.get_inner_value().peek().as_bytes().to_vec())\n                .map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;\n        let request_body_string_without_whitespace =\n            request_body_string.replace(char::is_whitespace, \"\");\n\n        let auth = payjustnow::PayjustnowAuthType::try_from(&req.connector_auth_type)\n            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;\n\n        let signature = crypto::HmacSha256::sign_message(\n            &crypto::HmacSha256,\n            auth.signing_key.expose().as_bytes(),\n            request_body_string_without_whitespace.as_bytes(),\n        )\n        .change_context(errors::ConnectorError::RequestEncodingFailed)?;\n\n        let signature_base64 = base64::engine::general_purpose::STANDARD.encode(signature);\n\n        let mut headers = vec![\n            (\n                headers::CONTENT_TYPE.to_string(),\n                self.get_content_type().to_string().into(),\n            ),\n            (\n                headers::USER_AGENT.to_string(),\n                hyperswitch_interfaces::consts::USER_AGENT\n                    .to_string()\n                    .into(),\n            ),\n        ];\n        let mut api_key = self.get_auth_header(&req.connector_auth_type)?;\n        headers.append(&mut api_key);\n        headers.push((\"X-Signature\".to_string(), signature_base64.into_masked()));\n\n        Ok(headers)\n    }"
+      },
+      "commit_sha": "9bedc92c4f353b2b7d2707930e3b369b09cd496b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow.rs::Payjustnow::function::build_request",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn build_request(\n        &self,\n        req: &RefundSyncRouterData,\n        connectors: &Connectors,\n    ) -> CustomResult<Option<Request>, errors::ConnectorError> {\n        let request_body = types::RefundSyncType::get_request_body(self, req, connectors)?;\n        let request_body_string =\n            String::from_utf8(request_body.get_inner_value().peek().as_bytes().to_vec())\n                .map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;\n        let request_body_string_without_whitespace =\n            request_body_string.replace(char::is_whitespace, \"\");\n\n        let auth = payjustnow::PayjustnowAuthType::try_from(&req.connector_auth_type)\n            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;\n\n        let signature = crypto::HmacSha256::sign_message(\n            &crypto::HmacSha256,\n            auth.signing_key.expose().as_bytes(),\n            request_body_string_without_whitespace.as_bytes(),\n        )\n        .change_context(errors::ConnectorError::RequestEncodingFailed)?;\n\n        let signature_base64 = base64::engine::general_purpose::STANDARD.encode(signature);\n\n        let mut headers = self.get_headers(req, connectors)?;\n        headers.push((\"X-Signature\".to_string(), signature_base64.into_masked()));\n\n        Ok(Some(\n            RequestBuilder::new()\n                .method(Method::Post)\n                .url(&types::RefundSyncType::get_url(self, req, connectors)?)\n                .attach_default_headers()\n                .headers(headers)\n                .set_body(request_body)\n                .build(),\n        ))\n    }",
+      "after_code": "fn build_request(\n        &self,\n        req: &RefundSyncRouterData,\n        connectors: &Connectors,\n    ) -> CustomResult<Option<Request>, errors::ConnectorError> {\n        Ok(Some(\n            RequestBuilder::new()\n                .method(Method::Post)\n                .url(&types::RefundSyncType::get_url(self, req, connectors)?)\n                .attach_default_headers()\n                .headers(self.get_headers(req, connectors)?)\n                .set_body(self.get_request_body(req, connectors)?)\n                .build(),\n        ))\n    }",
+      "diff_span": {
+        "before": "        connectors: &Connectors,\n    ) -> CustomResult<Option<Request>, errors::ConnectorError> {\n        let request_body = types::RefundSyncType::get_request_body(self, req, connectors)?;\n        let request_body_string =\n            String::from_utf8(request_body.get_inner_value().peek().as_bytes().to_vec())\n                .map_err(|_| errors::ConnectorError::RequestEncodingFailed)?;\n        let request_body_string_without_whitespace =\n            request_body_string.replace(char::is_whitespace, \"\");\n\n        let auth = payjustnow::PayjustnowAuthType::try_from(&req.connector_auth_type)\n            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;\n\n        let signature = crypto::HmacSha256::sign_message(\n            &crypto::HmacSha256,\n            auth.signing_key.expose().as_bytes(),\n            request_body_string_without_whitespace.as_bytes(),\n        )\n        .change_context(errors::ConnectorError::RequestEncodingFailed)?;\n\n        let signature_base64 = base64::engine::general_purpose::STANDARD.encode(signature);\n\n        let mut headers = self.get_headers(req, connectors)?;\n        headers.push((\"X-Signature\".to_string(), signature_base64.into_masked()));\n\n        Ok(Some(\n            RequestBuilder::new()\n                .method(Method::Post)\n                .url(&types::RefundSyncType::get_url(self, req, connectors)?)\n                .attach_default_headers()\n                .headers(headers)\n                .set_body(request_body)\n                .build(),\n        ))",
+        "after": "                .url(&types::RefundSyncType::get_url(self, req, connectors)?)\n                .attach_default_headers()\n                .headers(self.get_headers(req, connectors)?)\n                .set_body(self.get_request_body(req, connectors)?)\n                .build(),\n        ))"
+      },
+      "commit_sha": "9bedc92c4f353b2b7d2707930e3b369b09cd496b"
+    }
+  ]
+}

diffs/pr_10071/17d77c7/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "17d77c78962cb525ee92c036278177c32ceadff1",
+  "pr_number": 10071,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10071/ba9963e/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "ba9963e844d239b1d02f949bdba346606f03852d",
+  "pr_number": 10071,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10080/0c197b6/diff.json

@@ -0,0 +1,184 @@
+{
+  "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/santander.rs",
+    "crates/hyperswitch_interfaces/src/api.rs",
+    "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+    "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+    "crates/router/src/core/payments/access_token.rs",
+    "crates/router/src/core/payouts/access_token.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::trait::ConnectorAccessTokenSuffix",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError>;\n}",
+      "after_code": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError>;\n}",
+      "diff_span": {
+        "before": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,",
+        "after": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,"
+      },
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs::impl::BoxedConnectorV2",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "after_code": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "diff_span": {
+        "before": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,",
+        "after": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,"
+      },
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::impl::Santander",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorAccessTokenSuffix for Santander {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }\n    }\n}",
+      "after_code": "impl ConnectorAccessTokenSuffix for Santander {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }\n    }\n}",
+      "diff_span": {
+        "before": "impl ConnectorAccessTokenSuffix for Santander {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,",
+        "after": "impl ConnectorAccessTokenSuffix for Santander {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,"
+      },
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/router/src/core/payments/access_token.rs::function::add_access_token",
+      "file": "crates/router/src/core/payments/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token<\n    F: Clone + 'static,\n    Req: Debug + Clone + 'static,\n    Res: Debug + Clone + 'static,\n>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    router_data: &types::RouterData<F, Req, Res>,\n    creds_identifier: Option<&str>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token(router_data.payment_method)\n    {\n        let merchant_id = &router_data.merchant_id;\n        let store = &*state.store;\n\n        // `merchant_connector_id` may not be present in the below cases\n        // - when straight through routing is used without passing the `merchant_connector_id`\n        // - when creds identifier is passed\n        //\n        // In these cases fallback to `connector_name`.\n        // We cannot use multiple merchant connector account in these cases\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n        let key = connector\n            .connector\n            .get_access_token_key_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                key.clone(),\n                                modified_access_token_with_expiry.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\")\n                        {\n                            // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n                            // Payments should not fail, once the access token is successfully created\n                            // The next request will create new access token, if required\n                            logger::error!(access_token_set_error=?access_token_set_error);\n                        }\n                        Some(modified_access_token_with_expiry)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token<\n    F: Clone + 'static,\n    Req: Debug + Clone + 'static,\n    Res: Debug + Clone + 'static,\n>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    router_data: &types::RouterData<F, Req, Res>,\n    creds_identifier: Option<&str>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token(router_data.payment_method)\n    {\n        let merchant_id = &router_data.merchant_id;\n        let store = &*state.store;\n\n        // `merchant_connector_id` may not be present in the below cases\n        // - when straight through routing is used without passing the `merchant_connector_id`\n        // - when creds identifier is passed\n        //\n        // In these cases fallback to `connector_name`.\n        // We cannot use multiple merchant connector account in these cases\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n            let key = connector\n            .connector\n            .get_access_token_key(\n                router_data,\n                merchant_connector_id_or_connector_name.clone(),\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(format!(\n                \"Failed to get access token key for connector: {:?}\",\n                connector.connector_name\n            ))?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                key.clone(),\n                                modified_access_token_with_expiry.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\")\n                        {\n                            // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n                            // Payments should not fail, once the access token is successfully created\n                            // The next request will create new access token, if required\n                            logger::error!(access_token_set_error=?access_token_set_error);\n                        }\n                        Some(modified_access_token_with_expiry)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "            .unwrap_or(connector.connector_name.to_string());\n\n        let key = connector\n            .connector\n            .get_access_token_key_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store",
+        "after": "            .unwrap_or(connector.connector_name.to_string());\n\n            let key = connector\n            .connector\n            .get_access_token_key(\n                router_data,\n                merchant_connector_id_or_connector_name.clone(),\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(format!(\n                \"Failed to get access token key for connector: {:?}\",\n                connector.connector_name\n            ))?;\n\n        let old_access_token = store"
+      },
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/router/src/core/payouts/access_token.rs::function::add_access_token_for_payout",
+      "file": "crates/router/src/core/payouts/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token_for_payout<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    merchant_context: &domain::MerchantContext,\n    router_data: &types::PayoutsRouterData<F>,\n    payout_type: Option<enums::PayoutType>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token_for_payout(payout_type)\n    {\n        let store = &*state.store;\n\n        let key = connector\n            .connector\n            .get_access_token_key_from_connector(router_data, connector.connector.id().to_string())\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(\n                    state,\n                    connector,\n                    merchant_context,\n                    &refresh_token_router_data,\n                )\n                .await?\n                .async_map(|access_token| async {\n                    //Store the access token in db\n                    let store = &*state.store;\n                    // This error should not be propagated, we don't want payments to fail once we have\n                    // the access token, the next request will create new access token\n                    let _ = store\n                        .set_access_token(key, access_token.clone())\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"DB error when setting the access token\");\n                    Some(access_token)\n                })\n                .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token_for_payout<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    merchant_context: &domain::MerchantContext,\n    router_data: &types::PayoutsRouterData<F>,\n    payout_type: Option<enums::PayoutType>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token_for_payout(payout_type)\n    {\n        let store = &*state.store;\n\n        let key = connector\n            .connector\n            .get_access_token_key(router_data, connector.connector.id().to_string())\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(\n                    state,\n                    connector,\n                    merchant_context,\n                    &refresh_token_router_data,\n                )\n                .await?\n                .async_map(|access_token| async {\n                    //Store the access token in db\n                    let store = &*state.store;\n                    // This error should not be propagated, we don't want payments to fail once we have\n                    // the access token, the next request will create new access token\n                    let _ = store\n                        .set_access_token(key, access_token.clone())\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"DB error when setting the access token\");\n                    Some(access_token)\n                })\n                .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "        let key = connector\n            .connector\n            .get_access_token_key_from_connector(router_data, connector.connector.id().to_string())\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n",
+        "after": "        let key = connector\n            .connector\n            .get_access_token_key(router_data, connector.connector.id().to_string())\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n"
+      },
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::impl::BoxedConnector",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorAccessTokenSuffix for BoxedConnector {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "after_code": "impl ConnectorAccessTokenSuffix for BoxedConnector {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "diff_span": {
+        "before": "impl ConnectorAccessTokenSuffix for BoxedConnector {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,",
+        "after": "impl ConnectorAccessTokenSuffix for BoxedConnector {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,"
+      },
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::BoxedConnector::function::get_access_token_key",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "diff_span": null,
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs::BoxedConnectorV2::function::get_access_token_key",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "diff_span": null,
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::Santander::function::get_access_token_key",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }\n    }",
+      "diff_span": null,
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs::ConnectorEnum::function::get_access_token_key",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => connector.get_access_token_key(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n            Self::New(connector) => connector.get_access_token_key(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n        }\n    }",
+      "diff_span": null,
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs::BoxedConnectorV2::function::get_access_token_key_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::Santander::function::get_access_token_key_from_connector",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs::ConnectorEnum::function::get_access_token_key_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => connector.get_access_token_key_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n            Self::New(connector) => connector.get_access_token_key_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n        }\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::BoxedConnector::function::get_access_token_key_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "0c197b601ad247baa07f06c9dda55b4690e2a072"
+    }
+  ]
+}

diffs/pr_10080/0cdddb5/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "0cdddb59f13bf54ae63b89dc6b869881380c95d2",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/common_utils/src/id_type/merchant.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/common_utils/src/id_type/merchant.rs::impl::MerchantId",
+      "file": "crates/common_utils/src/id_type/merchant.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl MerchantId {\n    /// get step up enabled key\n    pub fn get_step_up_enabled_key(&self) -> String {\n        format!(\"step_up_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_retries_enabled key\n    pub fn get_max_auto_retries_enabled(&self) -> String {\n        format!(\"max_auto_retries_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_requires_cvv_key\n    pub fn get_requires_cvv_key(&self) -> String {\n        format!(\"{}_requires_cvv\", self.get_string_repr())\n    }\n\n    /// get_pm_filters_cgraph_key\n    pub fn get_pm_filters_cgraph_key(&self) -> String {\n        format!(\"pm_filters_cgraph_{}\", self.get_string_repr())\n    }\n\n    /// get_blocklist_enabled_key\n    pub fn get_blocklist_guard_key(&self) -> String {\n        format!(\"guard_blocklist_for_{}\", self.get_string_repr())\n    }\n\n    /// get_merchant_fingerprint_secret_key\n    pub fn get_merchant_fingerprint_secret_key(&self) -> String {\n        format!(\"fingerprint_secret_{}\", self.get_string_repr())\n    }\n\n    /// get_surcharge_dsk_key\n    pub fn get_surcharge_dsk_key(&self) -> String {\n        format!(\"surcharge_dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_dsk_key\n    pub fn get_dsl_config(&self) -> String {\n        format!(\"dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_creds_identifier_key\n    pub fn get_creds_identifier_key(&self, creds_identifier: &str) -> String {\n        format!(\"mcd_{}_{creds_identifier}\", self.get_string_repr())\n    }\n\n    /// get_poll_id\n    pub fn get_poll_id(&self, unique_id: &str) -> String {\n        format!(\"poll_{}_{unique_id}\", self.get_string_repr())\n    }\n\n    /// get_access_token_key\n    pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}_{:?}\",\n            self.get_string_repr(),\n            payment_method_type,\n        )\n    }\n\n    /// get_skip_saving_wallet_at_connector_key\n    pub fn get_skip_saving_wallet_at_connector_key(&self) -> String {\n        format!(\"skip_saving_wallet_at_connector_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_config_routing_id\n    pub fn get_payment_config_routing_id(&self) -> String {\n        format!(\"payment_config_id_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_method_surcharge_routing_id\n    pub fn get_payment_method_surcharge_routing_id(&self) -> String {\n        format!(\"payment_method_surcharge_id_{}\", self.get_string_repr())\n    }\n\n    /// get_webhook_config_disabled_events_key\n    pub fn get_webhook_config_disabled_events_key(&self, connector_id: &str) -> String {\n        format!(\n            \"whconf_disabled_events_{}_{connector_id}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// get_should_call_gsm_payout_key\n    pub fn get_should_call_gsm_payout_key(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"should_call_gsm_single_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"should_call_gsm_multiple_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n\n    /// Get should call gsm key for payment\n    pub fn get_should_call_gsm_key(&self) -> String {\n        format!(\"should_call_gsm_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_single_connector_payout_retries_enabled_\n    pub fn get_max_auto_single_connector_payout_retries_enabled(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"max_auto_single_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"max_auto_multiple_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n    /// allow payment update via client auth default should be false\n    pub fn get_payment_update_enabled_for_client_auth_key(&self) -> String {\n        format!(\n            \"payment_update_enabled_for_client_auth_{}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// Get should perform eligibility check key for payment\n    pub fn get_should_perform_eligibility_check_key(&self) -> String {\n        format!(\"should_perform_eligibility_{}\", self.get_string_repr())\n    }\n}",
+      "after_code": "impl MerchantId {\n    /// get step up enabled key\n    pub fn get_step_up_enabled_key(&self) -> String {\n        format!(\"step_up_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_retries_enabled key\n    pub fn get_max_auto_retries_enabled(&self) -> String {\n        format!(\"max_auto_retries_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_requires_cvv_key\n    pub fn get_requires_cvv_key(&self) -> String {\n        format!(\"{}_requires_cvv\", self.get_string_repr())\n    }\n\n    /// get_pm_filters_cgraph_key\n    pub fn get_pm_filters_cgraph_key(&self) -> String {\n        format!(\"pm_filters_cgraph_{}\", self.get_string_repr())\n    }\n\n    /// get_blocklist_enabled_key\n    pub fn get_blocklist_guard_key(&self) -> String {\n        format!(\"guard_blocklist_for_{}\", self.get_string_repr())\n    }\n\n    /// get_merchant_fingerprint_secret_key\n    pub fn get_merchant_fingerprint_secret_key(&self) -> String {\n        format!(\"fingerprint_secret_{}\", self.get_string_repr())\n    }\n\n    /// get_surcharge_dsk_key\n    pub fn get_surcharge_dsk_key(&self) -> String {\n        format!(\"surcharge_dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_dsk_key\n    pub fn get_dsl_config(&self) -> String {\n        format!(\"dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_creds_identifier_key\n    pub fn get_creds_identifier_key(&self, creds_identifier: &str) -> String {\n        format!(\"mcd_{}_{creds_identifier}\", self.get_string_repr())\n    }\n\n    /// get_poll_id\n    pub fn get_poll_id(&self, unique_id: &str) -> String {\n        format!(\"poll_{}_{unique_id}\", self.get_string_repr())\n    }\n\n    /// get_access_token_key\n    pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        match payment_method_type {\n            Some(pmt) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    pmt\n                )\n            }\n            None => {\n                format!(\n                    \"access_token_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name\n                )\n            }\n        }\n    }\n\n    /// get_skip_saving_wallet_at_connector_key\n    pub fn get_skip_saving_wallet_at_connector_key(&self) -> String {\n        format!(\"skip_saving_wallet_at_connector_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_config_routing_id\n    pub fn get_payment_config_routing_id(&self) -> String {\n        format!(\"payment_config_id_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_method_surcharge_routing_id\n    pub fn get_payment_method_surcharge_routing_id(&self) -> String {\n        format!(\"payment_method_surcharge_id_{}\", self.get_string_repr())\n    }\n\n    /// get_webhook_config_disabled_events_key\n    pub fn get_webhook_config_disabled_events_key(&self, connector_id: &str) -> String {\n        format!(\n            \"whconf_disabled_events_{}_{connector_id}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// get_should_call_gsm_payout_key\n    pub fn get_should_call_gsm_payout_key(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"should_call_gsm_single_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"should_call_gsm_multiple_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n\n    /// Get should call gsm key for payment\n    pub fn get_should_call_gsm_key(&self) -> String {\n        format!(\"should_call_gsm_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_single_connector_payout_retries_enabled_\n    pub fn get_max_auto_single_connector_payout_retries_enabled(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"max_auto_single_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"max_auto_multiple_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n    /// allow payment update via client auth default should be false\n    pub fn get_payment_update_enabled_for_client_auth_key(&self) -> String {\n        format!(\n            \"payment_update_enabled_for_client_auth_{}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// Get should perform eligibility check key for payment\n    pub fn get_should_perform_eligibility_check_key(&self) -> String {\n        format!(\"should_perform_eligibility_{}\", self.get_string_repr())\n    }\n}",
+      "diff_span": {
+        "before": "        payment_method_type: Option<String>,\n    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}_{:?}\",\n            self.get_string_repr(),\n            payment_method_type,\n        )\n    }\n",
+        "after": "        payment_method_type: Option<String>,\n    ) -> String {\n        match payment_method_type {\n            Some(pmt) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    pmt\n                )\n            }\n            None => {\n                format!(\n                    \"access_token_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name\n                )\n            }\n        }\n    }\n"
+      },
+      "commit_sha": "0cdddb59f13bf54ae63b89dc6b869881380c95d2"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/merchant.rs::MerchantId::function::get_access_token_key",
+      "file": "crates/common_utils/src/id_type/merchant.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}_{:?}\",\n            self.get_string_repr(),\n            payment_method_type,\n        )\n    }",
+      "after_code": "pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        match payment_method_type {\n            Some(pmt) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    pmt\n                )\n            }\n            None => {\n                format!(\n                    \"access_token_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name\n                )\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "        payment_method_type: Option<String>,\n    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}_{:?}\",\n            self.get_string_repr(),\n            payment_method_type,\n        )\n    }",
+        "after": "        payment_method_type: Option<String>,\n    ) -> String {\n        match payment_method_type {\n            Some(pmt) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    pmt\n                )\n            }\n            None => {\n                format!(\n                    \"access_token_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name\n                )\n            }\n        }\n    }"
+      },
+      "commit_sha": "0cdddb59f13bf54ae63b89dc6b869881380c95d2"
+    }
+  ]
+}

diffs/pr_10080/1e024a1/diff.json

@@ -0,0 +1,192 @@
+{
+  "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/common_utils/src/access_token.rs",
+    "crates/common_utils/src/id_type/merchant.rs",
+    "crates/router/src/db/kafka_store.rs",
+    "crates/router/src/db/merchant_connector_account.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::Store::function::get_access_token",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }",
+      "after_code": "async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            access_token_key_suffix_from_connector,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }",
+      "diff_span": {
+        "before": "        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n",
+        "after": "        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            access_token_key_suffix_from_connector,\n        );\n"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/merchant.rs::MerchantId::function::get_access_token_key",
+      "file": "crates/common_utils/src/id_type/merchant.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        match payment_method_type {\n            Some(pmt) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    pmt\n                )\n            }\n            None => {\n                format!(\n                    \"access_token_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name\n                )\n            }\n        }\n    }",
+      "after_code": "pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> String {\n        match access_token_key_suffix_from_connector {\n            Some(key_suffix) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    key_suffix\n                )\n            }\n            None => {\n                format!(\n                    \"access_token_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name\n                )\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        match payment_method_type {\n            Some(pmt) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    pmt\n                )\n            }",
+        "after": "        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> String {\n        match access_token_key_suffix_from_connector {\n            Some(key_suffix) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    key_suffix\n                )\n            }"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::trait::ConnectorAccessToken",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub trait ConnectorAccessToken {\n    async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError>;\n\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError>;\n}",
+      "after_code": "pub trait ConnectorAccessToken {\n    async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError>;\n\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError>;\n}",
+      "diff_span": {
+        "before": "        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError>;\n\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError>;\n}",
+        "after": "        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError>;\n\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError>;\n}"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::impl::Store",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorAccessToken for Store {\n    #[instrument(skip_all)]\n    async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }\n\n    #[instrument(skip_all)]\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n        let serialized_access_token = access_token\n            .encode_to_string_of_json()\n            .change_context(errors::StorageError::SerializationFailed)?;\n        self.get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .set_key_with_expiry(&key.into(), serialized_access_token, access_token.expires)\n            .await\n            .change_context(errors::StorageError::KVError)\n    }\n}",
+      "after_code": "impl ConnectorAccessToken for Store {\n    #[instrument(skip_all)]\n    async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            access_token_key_suffix_from_connector,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }\n\n    #[instrument(skip_all)]\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            access_token_key_suffix_from_connector,\n        );\n        let serialized_access_token = access_token\n            .encode_to_string_of_json()\n            .change_context(errors::StorageError::SerializationFailed)?;\n        self.get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .set_key_with_expiry(&key.into(), serialized_access_token, access_token.expires)\n            .await\n            .change_context(errors::StorageError::KVError)\n    }\n}",
+      "diff_span": {
+        "before": "        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }\n\n    #[instrument(skip_all)]\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n        let serialized_access_token = access_token",
+        "after": "        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            access_token_key_suffix_from_connector,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }\n\n    #[instrument(skip_all)]\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            access_token_key_suffix_from_connector,\n        );\n        let serialized_access_token = access_token"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::impl::MockDb",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorAccessToken for MockDb {\n    async fn get_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }\n\n    async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())\n    }\n}",
+      "after_code": "impl ConnectorAccessToken for MockDb {\n    async fn get_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }\n\n    async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())\n    }\n}",
+      "diff_span": {
+        "before": "        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }\n\n    async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())",
+        "after": "        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }\n\n    async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::MockDb::function::get_access_token",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn get_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }",
+      "after_code": "async fn get_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }",
+      "diff_span": {
+        "before": "        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)",
+        "after": "        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/common_utils/src/access_token.rs::function::create_access_token_key",
+      "file": "crates/common_utils/src/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn create_access_token_key(\n    merchant_id: &id_type::MerchantId,\n    merchant_connector_id_or_connector_name: impl Display,\n    payment_method_type: Option<String>,\n) -> String {\n    merchant_id.get_access_token_key(merchant_connector_id_or_connector_name, payment_method_type)\n}",
+      "after_code": "pub fn create_access_token_key(\n    merchant_id: &id_type::MerchantId,\n    merchant_connector_id_or_connector_name: impl Display,\n    access_token_key_suffix_from_connector: Option<String>,\n) -> String {\n    merchant_id.get_access_token_key(\n        merchant_connector_id_or_connector_name,\n        access_token_key_suffix_from_connector,\n    )\n}",
+      "diff_span": {
+        "before": "    merchant_id: &id_type::MerchantId,\n    merchant_connector_id_or_connector_name: impl Display,\n    payment_method_type: Option<String>,\n) -> String {\n    merchant_id.get_access_token_key(merchant_connector_id_or_connector_name, payment_method_type)\n}",
+        "after": "    merchant_id: &id_type::MerchantId,\n    merchant_connector_id_or_connector_name: impl Display,\n    access_token_key_suffix_from_connector: Option<String>,\n) -> String {\n    merchant_id.get_access_token_key(\n        merchant_connector_id_or_connector_name,\n        access_token_key_suffix_from_connector,\n    )\n}"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/router/src/db/kafka_store.rs::KafkaStore::function::get_access_token",
+      "file": "crates/router/src/db/kafka_store.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn get_access_token(\n        &self,\n        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<AccessToken>, errors::StorageError> {\n        self.diesel_store\n            .get_access_token(merchant_id, merchant_connector_id, payment_method_type)\n            .await\n    }",
+      "after_code": "async fn get_access_token(\n        &self,\n        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<AccessToken>, errors::StorageError> {\n        self.diesel_store\n            .get_access_token(\n                merchant_id,\n                merchant_connector_id,\n                access_token_key_suffix_from_connector,\n            )\n            .await\n    }",
+      "diff_span": {
+        "before": "        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<AccessToken>, errors::StorageError> {\n        self.diesel_store\n            .get_access_token(merchant_id, merchant_connector_id, payment_method_type)\n            .await\n    }",
+        "after": "        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<Option<AccessToken>, errors::StorageError> {\n        self.diesel_store\n            .get_access_token(\n                merchant_id,\n                merchant_connector_id,\n                access_token_key_suffix_from_connector,\n            )\n            .await\n    }"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/merchant.rs::impl::MerchantId",
+      "file": "crates/common_utils/src/id_type/merchant.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl MerchantId {\n    /// get step up enabled key\n    pub fn get_step_up_enabled_key(&self) -> String {\n        format!(\"step_up_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_retries_enabled key\n    pub fn get_max_auto_retries_enabled(&self) -> String {\n        format!(\"max_auto_retries_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_requires_cvv_key\n    pub fn get_requires_cvv_key(&self) -> String {\n        format!(\"{}_requires_cvv\", self.get_string_repr())\n    }\n\n    /// get_pm_filters_cgraph_key\n    pub fn get_pm_filters_cgraph_key(&self) -> String {\n        format!(\"pm_filters_cgraph_{}\", self.get_string_repr())\n    }\n\n    /// get_blocklist_enabled_key\n    pub fn get_blocklist_guard_key(&self) -> String {\n        format!(\"guard_blocklist_for_{}\", self.get_string_repr())\n    }\n\n    /// get_merchant_fingerprint_secret_key\n    pub fn get_merchant_fingerprint_secret_key(&self) -> String {\n        format!(\"fingerprint_secret_{}\", self.get_string_repr())\n    }\n\n    /// get_surcharge_dsk_key\n    pub fn get_surcharge_dsk_key(&self) -> String {\n        format!(\"surcharge_dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_dsk_key\n    pub fn get_dsl_config(&self) -> String {\n        format!(\"dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_creds_identifier_key\n    pub fn get_creds_identifier_key(&self, creds_identifier: &str) -> String {\n        format!(\"mcd_{}_{creds_identifier}\", self.get_string_repr())\n    }\n\n    /// get_poll_id\n    pub fn get_poll_id(&self, unique_id: &str) -> String {\n        format!(\"poll_{}_{unique_id}\", self.get_string_repr())\n    }\n\n    /// get_access_token_key\n    pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        match payment_method_type {\n            Some(pmt) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    pmt\n                )\n            }\n            None => {\n                format!(\n                    \"access_token_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name\n                )\n            }\n        }\n    }\n\n    /// get_skip_saving_wallet_at_connector_key\n    pub fn get_skip_saving_wallet_at_connector_key(&self) -> String {\n        format!(\"skip_saving_wallet_at_connector_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_config_routing_id\n    pub fn get_payment_config_routing_id(&self) -> String {\n        format!(\"payment_config_id_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_method_surcharge_routing_id\n    pub fn get_payment_method_surcharge_routing_id(&self) -> String {\n        format!(\"payment_method_surcharge_id_{}\", self.get_string_repr())\n    }\n\n    /// get_webhook_config_disabled_events_key\n    pub fn get_webhook_config_disabled_events_key(&self, connector_id: &str) -> String {\n        format!(\n            \"whconf_disabled_events_{}_{connector_id}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// get_should_call_gsm_payout_key\n    pub fn get_should_call_gsm_payout_key(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"should_call_gsm_single_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"should_call_gsm_multiple_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n\n    /// Get should call gsm key for payment\n    pub fn get_should_call_gsm_key(&self) -> String {\n        format!(\"should_call_gsm_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_single_connector_payout_retries_enabled_\n    pub fn get_max_auto_single_connector_payout_retries_enabled(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"max_auto_single_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"max_auto_multiple_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n    /// allow payment update via client auth default should be false\n    pub fn get_payment_update_enabled_for_client_auth_key(&self) -> String {\n        format!(\n            \"payment_update_enabled_for_client_auth_{}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// Get should perform eligibility check key for payment\n    pub fn get_should_perform_eligibility_check_key(&self) -> String {\n        format!(\"should_perform_eligibility_{}\", self.get_string_repr())\n    }\n}",
+      "after_code": "impl MerchantId {\n    /// get step up enabled key\n    pub fn get_step_up_enabled_key(&self) -> String {\n        format!(\"step_up_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_retries_enabled key\n    pub fn get_max_auto_retries_enabled(&self) -> String {\n        format!(\"max_auto_retries_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_requires_cvv_key\n    pub fn get_requires_cvv_key(&self) -> String {\n        format!(\"{}_requires_cvv\", self.get_string_repr())\n    }\n\n    /// get_pm_filters_cgraph_key\n    pub fn get_pm_filters_cgraph_key(&self) -> String {\n        format!(\"pm_filters_cgraph_{}\", self.get_string_repr())\n    }\n\n    /// get_blocklist_enabled_key\n    pub fn get_blocklist_guard_key(&self) -> String {\n        format!(\"guard_blocklist_for_{}\", self.get_string_repr())\n    }\n\n    /// get_merchant_fingerprint_secret_key\n    pub fn get_merchant_fingerprint_secret_key(&self) -> String {\n        format!(\"fingerprint_secret_{}\", self.get_string_repr())\n    }\n\n    /// get_surcharge_dsk_key\n    pub fn get_surcharge_dsk_key(&self) -> String {\n        format!(\"surcharge_dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_dsk_key\n    pub fn get_dsl_config(&self) -> String {\n        format!(\"dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_creds_identifier_key\n    pub fn get_creds_identifier_key(&self, creds_identifier: &str) -> String {\n        format!(\"mcd_{}_{creds_identifier}\", self.get_string_repr())\n    }\n\n    /// get_poll_id\n    pub fn get_poll_id(&self, unique_id: &str) -> String {\n        format!(\"poll_{}_{unique_id}\", self.get_string_repr())\n    }\n\n    /// get_access_token_key\n    pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> String {\n        match access_token_key_suffix_from_connector {\n            Some(key_suffix) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    key_suffix\n                )\n            }\n            None => {\n                format!(\n                    \"access_token_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name\n                )\n            }\n        }\n    }\n\n    /// get_skip_saving_wallet_at_connector_key\n    pub fn get_skip_saving_wallet_at_connector_key(&self) -> String {\n        format!(\"skip_saving_wallet_at_connector_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_config_routing_id\n    pub fn get_payment_config_routing_id(&self) -> String {\n        format!(\"payment_config_id_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_method_surcharge_routing_id\n    pub fn get_payment_method_surcharge_routing_id(&self) -> String {\n        format!(\"payment_method_surcharge_id_{}\", self.get_string_repr())\n    }\n\n    /// get_webhook_config_disabled_events_key\n    pub fn get_webhook_config_disabled_events_key(&self, connector_id: &str) -> String {\n        format!(\n            \"whconf_disabled_events_{}_{connector_id}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// get_should_call_gsm_payout_key\n    pub fn get_should_call_gsm_payout_key(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"should_call_gsm_single_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"should_call_gsm_multiple_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n\n    /// Get should call gsm key for payment\n    pub fn get_should_call_gsm_key(&self) -> String {\n        format!(\"should_call_gsm_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_single_connector_payout_retries_enabled_\n    pub fn get_max_auto_single_connector_payout_retries_enabled(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"max_auto_single_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"max_auto_multiple_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n    /// allow payment update via client auth default should be false\n    pub fn get_payment_update_enabled_for_client_auth_key(&self) -> String {\n        format!(\n            \"payment_update_enabled_for_client_auth_{}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// Get should perform eligibility check key for payment\n    pub fn get_should_perform_eligibility_check_key(&self) -> String {\n        format!(\"should_perform_eligibility_{}\", self.get_string_repr())\n    }\n}",
+      "diff_span": {
+        "before": "        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        match payment_method_type {\n            Some(pmt) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    pmt\n                )\n            }",
+        "after": "        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> String {\n        match access_token_key_suffix_from_connector {\n            Some(key_suffix) => {\n                format!(\n                    \"access_token_{}_{}_{}\",\n                    self.get_string_repr(),\n                    merchant_connector_id_or_connector_name,\n                    key_suffix\n                )\n            }"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/router/src/db/kafka_store.rs::KafkaStore::function::set_access_token",
+      "file": "crates/router/src/db/kafka_store.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn set_access_token(\n        &self,\n        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n        access_token: AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        self.diesel_store\n            .set_access_token(\n                merchant_id,\n                merchant_connector_id,\n                access_token,\n                payment_method_type,\n            )\n            .await\n    }",
+      "after_code": "async fn set_access_token(\n        &self,\n        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n        access_token: AccessToken,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        self.diesel_store\n            .set_access_token(\n                merchant_id,\n                merchant_connector_id,\n                access_token,\n                access_token_key_suffix_from_connector,\n            )\n            .await\n    }",
+      "diff_span": {
+        "before": "        merchant_connector_id: &str,\n        access_token: AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        self.diesel_store\n            .set_access_token(\n                merchant_id,\n                merchant_connector_id,\n                access_token,\n                payment_method_type,\n            )\n            .await",
+        "after": "        merchant_connector_id: &str,\n        access_token: AccessToken,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        self.diesel_store\n            .set_access_token(\n                merchant_id,\n                merchant_connector_id,\n                access_token,\n                access_token_key_suffix_from_connector,\n            )\n            .await"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::MockDb::function::set_access_token",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())\n    }",
+      "after_code": "async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())\n    }",
+      "diff_span": {
+        "before": "        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())",
+        "after": "        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::Store::function::set_access_token",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n        let serialized_access_token = access_token\n            .encode_to_string_of_json()\n            .change_context(errors::StorageError::SerializationFailed)?;\n        self.get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .set_key_with_expiry(&key.into(), serialized_access_token, access_token.expires)\n            .await\n            .change_context(errors::StorageError::KVError)\n    }",
+      "after_code": "async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            access_token_key_suffix_from_connector,\n        );\n        let serialized_access_token = access_token\n            .encode_to_string_of_json()\n            .change_context(errors::StorageError::SerializationFailed)?;\n        self.get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .set_key_with_expiry(&key.into(), serialized_access_token, access_token.expires)\n            .await\n            .change_context(errors::StorageError::KVError)\n    }",
+      "diff_span": {
+        "before": "        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n        let serialized_access_token = access_token",
+        "after": "        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        access_token_key_suffix_from_connector: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            access_token_key_suffix_from_connector,\n        );\n        let serialized_access_token = access_token"
+      },
+      "commit_sha": "1e024a149d15b5a6bb69758e41cf0d3703fe8e69"
+    }
+  ]
+}

diffs/pr_10080/28781e8/diff.json

@@ -0,0 +1,235 @@
+{
+  "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/common_enums/src/connector_enums.rs",
+    "crates/common_utils/src/access_token.rs",
+    "crates/common_utils/src/id_type/merchant.rs",
+    "crates/router/src/core/payments/access_token.rs",
+    "crates/router/src/core/payouts/access_token.rs",
+    "crates/router/src/db/kafka_store.rs",
+    "crates/router/src/db/merchant_connector_account.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::Store::function::get_access_token",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }",
+      "after_code": "async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/merchant.rs::MerchantId::function::get_access_token_key",
+      "file": "crates/common_utils/src/id_type/merchant.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}\",\n            self.get_string_repr()\n        )\n    }",
+      "after_code": "pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}_{:?}\",\n            self.get_string_repr(),\n            payment_method_type,\n        )\n    }",
+      "diff_span": {
+        "before": "    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}\",\n            self.get_string_repr()\n        )\n    }",
+        "after": "        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}_{:?}\",\n            self.get_string_repr(),\n            payment_method_type,\n        )\n    }"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::trait::ConnectorAccessToken",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub trait ConnectorAccessToken {\n    async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError>;\n\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n    ) -> CustomResult<(), errors::StorageError>;\n}",
+      "after_code": "pub trait ConnectorAccessToken {\n    async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError>;\n\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError>;\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError>;\n\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError>;\n}"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::impl::Store",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorAccessToken for Store {\n    #[instrument(skip_all)]\n    async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }\n\n    #[instrument(skip_all)]\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n        );\n        let serialized_access_token = access_token\n            .encode_to_string_of_json()\n            .change_context(errors::StorageError::SerializationFailed)?;\n        self.get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .set_key_with_expiry(&key.into(), serialized_access_token, access_token.expires)\n            .await\n            .change_context(errors::StorageError::KVError)\n    }\n}",
+      "after_code": "impl ConnectorAccessToken for Store {\n    #[instrument(skip_all)]\n    async fn get_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }\n\n    #[instrument(skip_all)]\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n        let serialized_access_token = access_token\n            .encode_to_string_of_json()\n            .change_context(errors::StorageError::SerializationFailed)?;\n        self.get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .set_key_with_expiry(&key.into(), serialized_access_token, access_token.expires)\n            .await\n            .change_context(errors::StorageError::KVError)\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        //TODO: Handle race condition\n        // This function should acquire a global lock on some resource, if access token is already\n        // being refreshed by other request then wait till it finishes and use the same access token\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n\n        let maybe_token = self\n            .get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .get_key::<Option<Vec<u8>>>(&key.into())\n            .await\n            .change_context(errors::StorageError::KVError)\n            .attach_printable(\"DB error when getting access token\")?;\n\n        let access_token = maybe_token\n            .map(|token| token.parse_struct::<types::AccessToken>(\"AccessToken\"))\n            .transpose()\n            .change_context(errors::StorageError::DeserializationFailed)?;\n\n        Ok(access_token)\n    }\n\n    #[instrument(skip_all)]\n    async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n        let serialized_access_token = access_token"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::impl::MockDb",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorAccessToken for MockDb {\n    async fn get_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }\n\n    async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())\n    }\n}",
+      "after_code": "impl ConnectorAccessToken for MockDb {\n    async fn get_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }\n\n    async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }\n\n    async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::MockDb::function::get_access_token",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn get_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }",
+      "after_code": "async fn get_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<Option<types::AccessToken>, errors::StorageError> {\n        Ok(None)"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/common_utils/src/access_token.rs::function::create_access_token_key",
+      "file": "crates/common_utils/src/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn create_access_token_key(\n    merchant_id: &id_type::MerchantId,\n    merchant_connector_id_or_connector_name: impl Display,\n) -> String {\n    merchant_id.get_access_token_key(merchant_connector_id_or_connector_name)\n}",
+      "after_code": "pub fn create_access_token_key(\n    merchant_id: &id_type::MerchantId,\n    merchant_connector_id_or_connector_name: impl Display,\n    payment_method_type: Option<String>,\n) -> String {\n    merchant_id.get_access_token_key(merchant_connector_id_or_connector_name, payment_method_type)\n}",
+      "diff_span": {
+        "before": "    merchant_connector_id_or_connector_name: impl Display,\n) -> String {\n    merchant_id.get_access_token_key(merchant_connector_id_or_connector_name)\n}",
+        "after": "    merchant_id: &id_type::MerchantId,\n    merchant_connector_id_or_connector_name: impl Display,\n    payment_method_type: Option<String>,\n) -> String {\n    merchant_id.get_access_token_key(merchant_connector_id_or_connector_name, payment_method_type)\n}"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/router/src/core/payments/access_token.rs::function::add_access_token",
+      "file": "crates/router/src/core/payments/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token<\n    F: Clone + 'static,\n    Req: Debug + Clone + 'static,\n    Res: Debug + Clone + 'static,\n>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    router_data: &types::RouterData<F, Req, Res>,\n    creds_identifier: Option<&str>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token(router_data.payment_method)\n    {\n        let merchant_id = &router_data.merchant_id;\n        let store = &*state.store;\n\n        // `merchant_connector_id` may not be present in the below cases\n        // - when straight through routing is used without passing the `merchant_connector_id`\n        // - when creds identifier is passed\n        //\n        // In these cases fallback to `connector_name`.\n        // We cannot use multiple merchant connector account in these cases\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n        let old_access_token = store\n            .get_access_token(merchant_id, &merchant_connector_id_or_connector_name)\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                merchant_id,\n                                &merchant_connector_id_or_connector_name,\n                                modified_access_token_with_expiry.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\")\n                        {\n                            // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n                            // Payments should not fail, once the access token is successfully created\n                            // The next request will create new access token, if required\n                            logger::error!(access_token_set_error=?access_token_set_error);\n                        }\n                        Some(modified_access_token_with_expiry)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token<\n    F: Clone + 'static,\n    Req: Debug + Clone + 'static,\n    Res: Debug + Clone + 'static,\n>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    router_data: &types::RouterData<F, Req, Res>,\n    creds_identifier: Option<&str>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token(router_data.payment_method)\n    {\n        let merchant_id = &router_data.merchant_id;\n        let store = &*state.store;\n\n        // `merchant_connector_id` may not be present in the below cases\n        // - when straight through routing is used without passing the `merchant_connector_id`\n        // - when creds identifier is passed\n        //\n        // In these cases fallback to `connector_name`.\n        // We cannot use multiple merchant connector account in these cases\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n        let pmt_suffix = connector\n            .connector_name\n            .is_different_access_token_required_per_payment_method_type()\n            .then(|| {\n                router_data\n                    .payment_method_type\n                    .as_ref()\n                    .map(|pmt| pmt.to_string())\n            })\n            .flatten();\n\n        let old_access_token = store\n            .get_access_token(\n                merchant_id,\n                &merchant_connector_id_or_connector_name,\n                pmt_suffix.clone(),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                merchant_id,\n                                &merchant_connector_id_or_connector_name,\n                                modified_access_token_with_expiry.clone(),\n                                pmt_suffix.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\")\n                        {\n                            // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n                            // Payments should not fail, once the access token is successfully created\n                            // The next request will create new access token, if required\n                            logger::error!(access_token_set_error=?access_token_set_error);\n                        }\n                        Some(modified_access_token_with_expiry)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "\n        let old_access_token = store\n            .get_access_token(merchant_id, &merchant_connector_id_or_connector_name)\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)",
+        "after": "            .unwrap_or(connector.connector_name.to_string());\n\n        let pmt_suffix = connector\n            .connector_name\n            .is_different_access_token_required_per_payment_method_type()\n            .then(|| {\n                router_data\n                    .payment_method_type\n                    .as_ref()\n                    .map(|pmt| pmt.to_string())\n            })\n            .flatten();\n\n        let old_access_token = store\n            .get_access_token(\n                merchant_id,\n                &merchant_connector_id_or_connector_name,\n                pmt_suffix.clone(),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                merchant_id,\n                                &merchant_connector_id_or_connector_name,\n                                modified_access_token_with_expiry.clone(),\n                                pmt_suffix.clone(),\n                            )\n                            .await"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/router/src/db/kafka_store.rs::KafkaStore::function::get_access_token",
+      "file": "crates/router/src/db/kafka_store.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn get_access_token(\n        &self,\n        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n    ) -> CustomResult<Option<AccessToken>, errors::StorageError> {\n        self.diesel_store\n            .get_access_token(merchant_id, merchant_connector_id)\n            .await\n    }",
+      "after_code": "async fn get_access_token(\n        &self,\n        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<AccessToken>, errors::StorageError> {\n        self.diesel_store\n            .get_access_token(merchant_id, merchant_connector_id, payment_method_type)\n            .await\n    }",
+      "diff_span": {
+        "before": "    ) -> CustomResult<Option<AccessToken>, errors::StorageError> {\n        self.diesel_store\n            .get_access_token(merchant_id, merchant_connector_id)\n            .await\n    }",
+        "after": "        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<Option<AccessToken>, errors::StorageError> {\n        self.diesel_store\n            .get_access_token(merchant_id, merchant_connector_id, payment_method_type)\n            .await\n    }"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/merchant.rs::impl::MerchantId",
+      "file": "crates/common_utils/src/id_type/merchant.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl MerchantId {\n    /// get step up enabled key\n    pub fn get_step_up_enabled_key(&self) -> String {\n        format!(\"step_up_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_retries_enabled key\n    pub fn get_max_auto_retries_enabled(&self) -> String {\n        format!(\"max_auto_retries_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_requires_cvv_key\n    pub fn get_requires_cvv_key(&self) -> String {\n        format!(\"{}_requires_cvv\", self.get_string_repr())\n    }\n\n    /// get_pm_filters_cgraph_key\n    pub fn get_pm_filters_cgraph_key(&self) -> String {\n        format!(\"pm_filters_cgraph_{}\", self.get_string_repr())\n    }\n\n    /// get_blocklist_enabled_key\n    pub fn get_blocklist_guard_key(&self) -> String {\n        format!(\"guard_blocklist_for_{}\", self.get_string_repr())\n    }\n\n    /// get_merchant_fingerprint_secret_key\n    pub fn get_merchant_fingerprint_secret_key(&self) -> String {\n        format!(\"fingerprint_secret_{}\", self.get_string_repr())\n    }\n\n    /// get_surcharge_dsk_key\n    pub fn get_surcharge_dsk_key(&self) -> String {\n        format!(\"surcharge_dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_dsk_key\n    pub fn get_dsl_config(&self) -> String {\n        format!(\"dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_creds_identifier_key\n    pub fn get_creds_identifier_key(&self, creds_identifier: &str) -> String {\n        format!(\"mcd_{}_{creds_identifier}\", self.get_string_repr())\n    }\n\n    /// get_poll_id\n    pub fn get_poll_id(&self, unique_id: &str) -> String {\n        format!(\"poll_{}_{unique_id}\", self.get_string_repr())\n    }\n\n    /// get_access_token_key\n    pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// get_skip_saving_wallet_at_connector_key\n    pub fn get_skip_saving_wallet_at_connector_key(&self) -> String {\n        format!(\"skip_saving_wallet_at_connector_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_config_routing_id\n    pub fn get_payment_config_routing_id(&self) -> String {\n        format!(\"payment_config_id_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_method_surcharge_routing_id\n    pub fn get_payment_method_surcharge_routing_id(&self) -> String {\n        format!(\"payment_method_surcharge_id_{}\", self.get_string_repr())\n    }\n\n    /// get_webhook_config_disabled_events_key\n    pub fn get_webhook_config_disabled_events_key(&self, connector_id: &str) -> String {\n        format!(\n            \"whconf_disabled_events_{}_{connector_id}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// get_should_call_gsm_payout_key\n    pub fn get_should_call_gsm_payout_key(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"should_call_gsm_single_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"should_call_gsm_multiple_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n\n    /// Get should call gsm key for payment\n    pub fn get_should_call_gsm_key(&self) -> String {\n        format!(\"should_call_gsm_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_single_connector_payout_retries_enabled_\n    pub fn get_max_auto_single_connector_payout_retries_enabled(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"max_auto_single_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"max_auto_multiple_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n    /// allow payment update via client auth default should be false\n    pub fn get_payment_update_enabled_for_client_auth_key(&self) -> String {\n        format!(\n            \"payment_update_enabled_for_client_auth_{}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// Get should perform eligibility check key for payment\n    pub fn get_should_perform_eligibility_check_key(&self) -> String {\n        format!(\"should_perform_eligibility_{}\", self.get_string_repr())\n    }\n}",
+      "after_code": "impl MerchantId {\n    /// get step up enabled key\n    pub fn get_step_up_enabled_key(&self) -> String {\n        format!(\"step_up_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_retries_enabled key\n    pub fn get_max_auto_retries_enabled(&self) -> String {\n        format!(\"max_auto_retries_enabled_{}\", self.get_string_repr())\n    }\n\n    /// get_requires_cvv_key\n    pub fn get_requires_cvv_key(&self) -> String {\n        format!(\"{}_requires_cvv\", self.get_string_repr())\n    }\n\n    /// get_pm_filters_cgraph_key\n    pub fn get_pm_filters_cgraph_key(&self) -> String {\n        format!(\"pm_filters_cgraph_{}\", self.get_string_repr())\n    }\n\n    /// get_blocklist_enabled_key\n    pub fn get_blocklist_guard_key(&self) -> String {\n        format!(\"guard_blocklist_for_{}\", self.get_string_repr())\n    }\n\n    /// get_merchant_fingerprint_secret_key\n    pub fn get_merchant_fingerprint_secret_key(&self) -> String {\n        format!(\"fingerprint_secret_{}\", self.get_string_repr())\n    }\n\n    /// get_surcharge_dsk_key\n    pub fn get_surcharge_dsk_key(&self) -> String {\n        format!(\"surcharge_dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_dsk_key\n    pub fn get_dsl_config(&self) -> String {\n        format!(\"dsl_{}\", self.get_string_repr())\n    }\n\n    /// get_creds_identifier_key\n    pub fn get_creds_identifier_key(&self, creds_identifier: &str) -> String {\n        format!(\"mcd_{}_{creds_identifier}\", self.get_string_repr())\n    }\n\n    /// get_poll_id\n    pub fn get_poll_id(&self, unique_id: &str) -> String {\n        format!(\"poll_{}_{unique_id}\", self.get_string_repr())\n    }\n\n    /// get_access_token_key\n    pub fn get_access_token_key(\n        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}_{:?}\",\n            self.get_string_repr(),\n            payment_method_type,\n        )\n    }\n\n    /// get_skip_saving_wallet_at_connector_key\n    pub fn get_skip_saving_wallet_at_connector_key(&self) -> String {\n        format!(\"skip_saving_wallet_at_connector_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_config_routing_id\n    pub fn get_payment_config_routing_id(&self) -> String {\n        format!(\"payment_config_id_{}\", self.get_string_repr())\n    }\n\n    /// get_payment_method_surcharge_routing_id\n    pub fn get_payment_method_surcharge_routing_id(&self) -> String {\n        format!(\"payment_method_surcharge_id_{}\", self.get_string_repr())\n    }\n\n    /// get_webhook_config_disabled_events_key\n    pub fn get_webhook_config_disabled_events_key(&self, connector_id: &str) -> String {\n        format!(\n            \"whconf_disabled_events_{}_{connector_id}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// get_should_call_gsm_payout_key\n    pub fn get_should_call_gsm_payout_key(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"should_call_gsm_single_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"should_call_gsm_multiple_connector_payout_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n\n    /// Get should call gsm key for payment\n    pub fn get_should_call_gsm_key(&self) -> String {\n        format!(\"should_call_gsm_{}\", self.get_string_repr())\n    }\n\n    /// get_max_auto_single_connector_payout_retries_enabled_\n    pub fn get_max_auto_single_connector_payout_retries_enabled(\n        &self,\n        payout_retry_type: common_enums::PayoutRetryType,\n    ) -> String {\n        match payout_retry_type {\n            common_enums::PayoutRetryType::SingleConnector => format!(\n                \"max_auto_single_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n            common_enums::PayoutRetryType::MultiConnector => format!(\n                \"max_auto_multiple_connector_payout_retries_enabled_{}\",\n                self.get_string_repr()\n            ),\n        }\n    }\n    /// allow payment update via client auth default should be false\n    pub fn get_payment_update_enabled_for_client_auth_key(&self) -> String {\n        format!(\n            \"payment_update_enabled_for_client_auth_{}\",\n            self.get_string_repr()\n        )\n    }\n\n    /// Get should perform eligibility check key for payment\n    pub fn get_should_perform_eligibility_check_key(&self) -> String {\n        format!(\"should_perform_eligibility_{}\", self.get_string_repr())\n    }\n}",
+      "diff_span": {
+        "before": "    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}\",\n            self.get_string_repr()\n        )\n    }",
+        "after": "        &self,\n        merchant_connector_id_or_connector_name: impl Display,\n        payment_method_type: Option<String>,\n    ) -> String {\n        format!(\n            \"access_token_{}_{merchant_connector_id_or_connector_name}_{:?}\",\n            self.get_string_repr(),\n            payment_method_type,\n        )\n    }"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/router/src/db/kafka_store.rs::KafkaStore::function::set_access_token",
+      "file": "crates/router/src/db/kafka_store.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn set_access_token(\n        &self,\n        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n        access_token: AccessToken,\n    ) -> CustomResult<(), errors::StorageError> {\n        self.diesel_store\n            .set_access_token(merchant_id, merchant_connector_id, access_token)\n            .await\n    }",
+      "after_code": "async fn set_access_token(\n        &self,\n        merchant_id: &id_type::MerchantId,\n        merchant_connector_id: &str,\n        access_token: AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        self.diesel_store\n            .set_access_token(\n                merchant_id,\n                merchant_connector_id,\n                access_token,\n                payment_method_type,\n            )\n            .await\n    }",
+      "diff_span": {
+        "before": "    ) -> CustomResult<(), errors::StorageError> {\n        self.diesel_store\n            .set_access_token(merchant_id, merchant_connector_id, access_token)\n            .await\n    }",
+        "after": "        merchant_connector_id: &str,\n        access_token: AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        self.diesel_store\n            .set_access_token(\n                merchant_id,\n                merchant_connector_id,\n                access_token,\n                payment_method_type,\n            )\n            .await\n    }"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::MockDb::function::set_access_token",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())\n    }",
+      "after_code": "async fn set_access_token(\n        &self,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "        _merchant_connector_id_or_connector_name: &str,\n        _access_token: types::AccessToken,\n        _payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        Ok(())"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/router/src/core/payouts/access_token.rs::function::add_access_token_for_payout",
+      "file": "crates/router/src/core/payouts/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token_for_payout<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    merchant_context: &domain::MerchantContext,\n    router_data: &types::PayoutsRouterData<F>,\n    payout_type: Option<enums::PayoutType>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    use crate::types::api::ConnectorCommon;\n\n    if connector\n        .connector_name\n        .supports_access_token_for_payout(payout_type)\n    {\n        let merchant_id = merchant_context.get_merchant_account().get_id();\n        let store = &*state.store;\n        let old_access_token = store\n            .get_access_token(merchant_id, connector.connector.id())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(\n                    state,\n                    connector,\n                    merchant_context,\n                    &refresh_token_router_data,\n                )\n                .await?\n                .async_map(|access_token| async {\n                    //Store the access token in db\n                    let store = &*state.store;\n                    // This error should not be propagated, we don't want payments to fail once we have\n                    // the access token, the next request will create new access token\n                    let _ = store\n                        .set_access_token(\n                            merchant_id,\n                            connector.connector.id(),\n                            access_token.clone(),\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"DB error when setting the access token\");\n                    Some(access_token)\n                })\n                .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token_for_payout<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    merchant_context: &domain::MerchantContext,\n    router_data: &types::PayoutsRouterData<F>,\n    payout_type: Option<enums::PayoutType>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    use crate::types::api::ConnectorCommon;\n\n    if connector\n        .connector_name\n        .supports_access_token_for_payout(payout_type)\n    {\n        let merchant_id = merchant_context.get_merchant_account().get_id();\n        let store = &*state.store;\n        let old_access_token = store\n            .get_access_token(merchant_id, connector.connector.id(), None)\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(\n                    state,\n                    connector,\n                    merchant_context,\n                    &refresh_token_router_data,\n                )\n                .await?\n                .async_map(|access_token| async {\n                    //Store the access token in db\n                    let store = &*state.store;\n                    // This error should not be propagated, we don't want payments to fail once we have\n                    // the access token, the next request will create new access token\n                    let _ = store\n                        .set_access_token(\n                            merchant_id,\n                            connector.connector.id(),\n                            access_token.clone(),\n                            None,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"DB error when setting the access token\");\n                    Some(access_token)\n                })\n                .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "        let store = &*state.store;\n        let old_access_token = store\n            .get_access_token(merchant_id, connector.connector.id())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)",
+        "after": "        let store = &*state.store;\n        let old_access_token = store\n            .get_access_token(merchant_id, connector.connector.id(), None)\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(\n                    state,\n                    connector,\n                    merchant_context,\n                    &refresh_token_router_data,\n                )\n                .await?\n                .async_map(|access_token| async {\n                    //Store the access token in db\n                    let store = &*state.store;\n                    // This error should not be propagated, we don't want payments to fail once we have\n                    // the access token, the next request will create new access token\n                    let _ = store\n                        .set_access_token(\n                            merchant_id,\n                            connector.connector.id(),\n                            access_token.clone(),\n                            None,\n                        )\n                        .await"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/router/src/db/merchant_connector_account.rs::Store::function::set_access_token",
+      "file": "crates/router/src/db/merchant_connector_account.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n        );\n        let serialized_access_token = access_token\n            .encode_to_string_of_json()\n            .change_context(errors::StorageError::SerializationFailed)?;\n        self.get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .set_key_with_expiry(&key.into(), serialized_access_token, access_token.expires)\n            .await\n            .change_context(errors::StorageError::KVError)\n    }",
+      "after_code": "async fn set_access_token(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n        let serialized_access_token = access_token\n            .encode_to_string_of_json()\n            .change_context(errors::StorageError::SerializationFailed)?;\n        self.get_redis_conn()\n            .map_err(Into::<errors::StorageError>::into)?\n            .set_key_with_expiry(&key.into(), serialized_access_token, access_token.expires)\n            .await\n            .change_context(errors::StorageError::KVError)\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "        merchant_connector_id_or_connector_name: &str,\n        access_token: types::AccessToken,\n        payment_method_type: Option<String>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let key = common_utils::access_token::create_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n            payment_method_type,\n        );\n        let serialized_access_token = access_token"
+      },
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    },
+    {
+      "id": "crates/common_enums/src/connector_enums.rs::Connector::function::is_different_access_token_required_per_payment_method_type",
+      "file": "crates/common_enums/src/connector_enums.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn is_different_access_token_required_per_payment_method_type(self) -> bool {\n        matches!(self, Self::Santander)\n    }",
+      "diff_span": null,
+      "commit_sha": "28781e8f64e4a1eb47d0308de4e561fba41d52f2"
+    }
+  ]
+}

diffs/pr_10080/40ff6f2/diff.json

@@ -0,0 +1,40 @@
+{
+  "commit_sha": "40ff6f2b5764a9b8bd2a159047248fdac3c00455",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+    "crates/router/src/core/payments/access_token.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments/access_token.rs::function::add_access_token",
+      "file": "crates/router/src/core/payments/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token<\n    F: Clone + 'static,\n    Req: Debug + Clone + 'static,\n    Res: Debug + Clone + 'static,\n>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    router_data: &types::RouterData<F, Req, Res>,\n    creds_identifier: Option<&str>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token(router_data.payment_method)\n    {\n        let merchant_id = &router_data.merchant_id;\n        let store = &*state.store;\n\n        // `merchant_connector_id` may not be present in the below cases\n        // - when straight through routing is used without passing the `merchant_connector_id`\n        // - when creds identifier is passed\n        //\n        // In these cases fallback to `connector_name`.\n        // We cannot use multiple merchant connector account in these cases\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n            let key = connector\n            .connector\n            .get_access_token_key(\n                router_data,\n                merchant_connector_id_or_connector_name.clone(),\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(format!(\n                \"Failed to get access token key for connector: {:?}\",\n                connector.connector_name\n            ))?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                key.clone(),\n                                modified_access_token_with_expiry.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\")\n                        {\n                            // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n                            // Payments should not fail, once the access token is successfully created\n                            // The next request will create new access token, if required\n                            logger::error!(access_token_set_error=?access_token_set_error);\n                        }\n                        Some(modified_access_token_with_expiry)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token<\n    F: Clone + 'static,\n    Req: Debug + Clone + 'static,\n    Res: Debug + Clone + 'static,\n>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    router_data: &types::RouterData<F, Req, Res>,\n    creds_identifier: Option<&str>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token(router_data.payment_method)\n    {\n        let merchant_id = &router_data.merchant_id;\n        let store = &*state.store;\n\n        // `merchant_connector_id` may not be present in the below cases\n        // - when straight through routing is used without passing the `merchant_connector_id`\n        // - when creds identifier is passed\n        //\n        // In these cases fallback to `connector_name`.\n        // We cannot use multiple merchant connector account in these cases\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n        let key = connector\n            .connector\n            .get_access_token_key(router_data, merchant_connector_id_or_connector_name.clone())\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(format!(\n                \"Failed to get access token key for connector: {:?}\",\n                connector.connector_name\n            ))?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                key.clone(),\n                                modified_access_token_with_expiry.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\")\n                        {\n                            // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n                            // Payments should not fail, once the access token is successfully created\n                            // The next request will create new access token, if required\n                            logger::error!(access_token_set_error=?access_token_set_error);\n                        }\n                        Some(modified_access_token_with_expiry)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "            .unwrap_or(connector.connector_name.to_string());\n\n            let key = connector\n            .connector\n            .get_access_token_key(\n                router_data,\n                merchant_connector_id_or_connector_name.clone(),\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(format!(",
+        "after": "            .unwrap_or(connector.connector_name.to_string());\n\n        let key = connector\n            .connector\n            .get_access_token_key(router_data, merchant_connector_id_or_connector_name.clone())\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(format!("
+      },
+      "commit_sha": "40ff6f2b5764a9b8bd2a159047248fdac3c00455"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs::ConnectorEnum::function::get_access_token_key",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => connector.get_access_token_key(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n            Self::New(connector) => connector.get_access_token_key(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n        }\n    }",
+      "after_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => {\n                connector.get_access_token_key(router_data, merchant_connector_id_or_connector_name)\n            }\n            Self::New(connector) => {\n                connector.get_access_token_key(router_data, merchant_connector_id_or_connector_name)\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "    ) -> CustomResult<String, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => connector.get_access_token_key(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n            Self::New(connector) => connector.get_access_token_key(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n        }\n    }",
+        "after": "    ) -> CustomResult<String, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => {\n                connector.get_access_token_key(router_data, merchant_connector_id_or_connector_name)\n            }\n            Self::New(connector) => {\n                connector.get_access_token_key(router_data, merchant_connector_id_or_connector_name)\n            }\n        }\n    }"
+      },
+      "commit_sha": "40ff6f2b5764a9b8bd2a159047248fdac3c00455"
+    }
+  ]
+}

diffs/pr_10080/57fa606/diff.json

@@ -0,0 +1,171 @@
+{
+  "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/common_utils/src/access_token.rs",
+    "crates/common_utils/src/lib.rs",
+    "crates/hyperswitch_connectors/src/connectors/santander.rs",
+    "crates/hyperswitch_interfaces/src/api.rs",
+    "crates/router/src/core/payment_methods/access_token.rs",
+    "crates/router/src/core/payments/access_token.rs",
+    "crates/router/src/core/payouts/access_token.rs",
+    "crates/router/src/core/unified_connector_service.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::trait::ConnectorAccessTokenSuffix",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "after_code": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(common_utils::access_token::get_default_access_token_key(\n            &router_data.merchant_id,\n            merchant_connector_id_or_connector_name,\n        ))\n    }\n}",
+      "diff_span": {
+        "before": "        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+        "after": "        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(common_utils::access_token::get_default_access_token_key(\n            &router_data.merchant_id,\n            merchant_connector_id_or_connector_name,\n        ))\n    }"
+      },
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    },
+    {
+      "id": "crates/router/src/core/payment_methods/access_token.rs::function::add_access_token_for_external_vault",
+      "file": "crates/router/src/core/payment_methods/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token_for_external_vault<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    merchant_account: &domain::MerchantAccount,\n    router_data: &VaultRouterData<F>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token_for_external_vault()\n    {\n        let merchant_id = merchant_account.get_id();\n        let store = &*state.store;\n        let old_access_token = store\n            .get_access_token(merchant_id, connector.connector.id())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async {\n                        //Store the access token in db\n                        let store = &*state.store;\n                        // This error should not be propagated, we don't want payments to fail once we have\n                        // the access token, the next request will create new access token\n                        let _ = store\n                            .set_access_token(\n                                merchant_id,\n                                connector.connector.id(),\n                                access_token.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\");\n                        Some(access_token)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token_for_external_vault<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    merchant_account: &domain::MerchantAccount,\n    router_data: &VaultRouterData<F>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token_for_external_vault()\n    {\n        let merchant_id = merchant_account.get_id();\n        let store = &*state.store;\n        let key = common_utils::access_token::get_default_access_token_key(\n            merchant_id,\n            connector.connector.id(),\n        );\n        let old_access_token = store\n            .get_access_token(key)\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async {\n                        //Store the access token in db\n                        let store = &*state.store;\n                        // This error should not be propagated, we don't want payments to fail once we have\n                        // the access token, the next request will create new access token\n                        let key = common_utils::access_token::get_default_access_token_key(\n                            merchant_id,\n                            connector.connector.id(),\n                        );\n                        let _ = store\n                            .set_access_token(key, access_token.clone())\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\");\n                        Some(access_token)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "        let store = &*state.store;\n        let old_access_token = store\n            .get_access_token(merchant_id, connector.connector.id())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async {\n                        //Store the access token in db\n                        let store = &*state.store;\n                        // This error should not be propagated, we don't want payments to fail once we have\n                        // the access token, the next request will create new access token\n                        let _ = store\n                            .set_access_token(\n                                merchant_id,\n                                connector.connector.id(),\n                                access_token.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)",
+        "after": "        let merchant_id = merchant_account.get_id();\n        let store = &*state.store;\n        let key = common_utils::access_token::get_default_access_token_key(\n            merchant_id,\n            connector.connector.id(),\n        );\n        let old_access_token = store\n            .get_access_token(key)\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async {\n                        //Store the access token in db\n                        let store = &*state.store;\n                        // This error should not be propagated, we don't want payments to fail once we have\n                        // the access token, the next request will create new access token\n                        let key = common_utils::access_token::get_default_access_token_key(\n                            merchant_id,\n                            connector.connector.id(),\n                        );\n                        let _ = store\n                            .set_access_token(key, access_token.clone())\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)"
+      },
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::impl::Santander",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorAccessTokenSuffix for Santander {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }\n    }\n}",
+      "after_code": "impl ConnectorAccessTokenSuffix for Santander {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(common_utils::access_token::get_default_access_token_key(\n                &router_data.merchant_id,\n                merchant_connector_id_or_connector_name,\n            )),\n        }\n    }\n}",
+      "diff_span": {
+        "before": "                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }",
+        "after": "                key\n            )),\n            None => Ok(common_utils::access_token::get_default_access_token_key(\n                &router_data.merchant_id,\n                merchant_connector_id_or_connector_name,\n            )),\n        }"
+      },
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    },
+    {
+      "id": "crates/router/src/core/payouts/access_token.rs::function::add_access_token_for_payout",
+      "file": "crates/router/src/core/payouts/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token_for_payout<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    platform: &domain::Platform,\n    router_data: &types::PayoutsRouterData<F>,\n    payout_type: Option<enums::PayoutType>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token_for_payout(payout_type)\n    {\n        let merchant_id = platform.get_processor().get_account().get_id();\n        let store = &*state.store;\n\n        let key = connector\n            .connector\n            .get_access_token_key(router_data, connector.connector.id().to_string())\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, platform, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async {\n                        //Store the access token in db\n                        let store = &*state.store;\n                        // This error should not be propagated, we don't want payments to fail once we have\n                        // the access token, the next request will create new access token\n                        let _ = store\n                            .set_access_token(key, access_token.clone())\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\");\n                        Some(access_token)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token_for_payout<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    platform: &domain::Platform,\n    router_data: &types::PayoutsRouterData<F>,\n    payout_type: Option<enums::PayoutType>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token_for_payout(payout_type)\n    {\n        let store = &*state.store;\n\n        let key = connector\n            .connector\n            .get_access_token_key(router_data, connector.connector.id().to_string())\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, platform, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async {\n                        //Store the access token in db\n                        let store = &*state.store;\n                        // This error should not be propagated, we don't want payments to fail once we have\n                        // the access token, the next request will create new access token\n                        let _ = store\n                            .set_access_token(key, access_token.clone())\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\");\n                        Some(access_token)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "        .supports_access_token_for_payout(payout_type)\n    {\n        let merchant_id = platform.get_processor().get_account().get_id();\n        let store = &*state.store;\n",
+        "after": ""
+      },
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::ConnectorAccessTokenSuffix::function::get_access_token_key",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "after_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(common_utils::access_token::get_default_access_token_key(\n            &router_data.merchant_id,\n            merchant_connector_id_or_connector_name,\n        ))\n    }",
+      "diff_span": {
+        "before": "        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+        "after": "        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(common_utils::access_token::get_default_access_token_key(\n            &router_data.merchant_id,\n            merchant_connector_id_or_connector_name,\n        ))\n    }"
+      },
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    },
+    {
+      "id": "crates/router/src/core/unified_connector_service.rs::function::set_access_token_for_ucs",
+      "file": "crates/router/src/core/unified_connector_service.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn set_access_token_for_ucs(\n    state: &SessionState,\n    platform: &Platform,\n    connector_name: &str,\n    access_token: AccessToken,\n    merchant_connector_id: Option<&id_type::MerchantConnectorAccountId>,\n    creds_identifier: Option<String>,\n) -> Result<(), errors::StorageError> {\n    let merchant_id = platform.get_processor().get_account().get_id();\n\n    let merchant_connector_id_or_connector_name = merchant_connector_id\n        .map(|mca_id| mca_id.get_string_repr().to_string())\n        .or(creds_identifier.map(|id| id.to_string()))\n        .unwrap_or(connector_name.to_string());\n\n    let key = format!(\n        \"access_token_{}_{}\",\n        merchant_id.get_string_repr(),\n        merchant_connector_id_or_connector_name\n    );\n\n    let modified_access_token = AccessToken {\n        expires: access_token\n            .expires\n            .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n        ..access_token\n    };\n\n    logger::debug!(\n        access_token_expiry_after_modification = modified_access_token.expires,\n        merchant_id = ?merchant_id,\n        connector_name = connector_name,\n        merchant_connector_id_or_connector_name = merchant_connector_id_or_connector_name\n    );\n\n    if let Err(access_token_set_error) = state\n        .store\n        .set_access_token(key, modified_access_token)\n        .await\n    {\n        // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n        // Payments should not fail, once the access token is successfully created\n        // The next request will create new access token, if required\n        logger::error!(access_token_set_error=?access_token_set_error, \"Failed to store UCS access token\");\n    }\n\n    Ok(())\n}",
+      "after_code": "pub async fn set_access_token_for_ucs(\n    state: &SessionState,\n    platform: &Platform,\n    connector_name: &str,\n    access_token: AccessToken,\n    merchant_connector_id: Option<&id_type::MerchantConnectorAccountId>,\n    creds_identifier: Option<String>,\n) -> Result<(), errors::StorageError> {\n    let merchant_id = platform.get_processor().get_account().get_id();\n\n    let merchant_connector_id_or_connector_name = merchant_connector_id\n        .map(|mca_id| mca_id.get_string_repr().to_string())\n        .or(creds_identifier.map(|id| id.to_string()))\n        .unwrap_or(connector_name.to_string());\n\n    let key = common_utils::access_token::get_default_access_token_key(\n        merchant_id,\n        &merchant_connector_id_or_connector_name,\n    );\n\n    let modified_access_token = AccessToken {\n        expires: access_token\n            .expires\n            .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n        ..access_token\n    };\n\n    logger::debug!(\n        access_token_expiry_after_modification = modified_access_token.expires,\n        merchant_id = ?merchant_id,\n        connector_name = connector_name,\n        merchant_connector_id_or_connector_name = merchant_connector_id_or_connector_name\n    );\n\n    if let Err(access_token_set_error) = state\n        .store\n        .set_access_token(key, modified_access_token)\n        .await\n    {\n        // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n        // Payments should not fail, once the access token is successfully created\n        // The next request will create new access token, if required\n        logger::error!(access_token_set_error=?access_token_set_error, \"Failed to store UCS access token\");\n    }\n\n    Ok(())\n}",
+      "diff_span": {
+        "before": "        .unwrap_or(connector_name.to_string());\n\n    let key = format!(\n        \"access_token_{}_{}\",\n        merchant_id.get_string_repr(),\n        merchant_connector_id_or_connector_name\n    );\n",
+        "after": "        .unwrap_or(connector_name.to_string());\n\n    let key = common_utils::access_token::get_default_access_token_key(\n        merchant_id,\n        &merchant_connector_id_or_connector_name,\n    );\n"
+      },
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::Santander::function::get_access_token_key",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }\n    }",
+      "after_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(common_utils::access_token::get_default_access_token_key(\n                &router_data.merchant_id,\n                merchant_connector_id_or_connector_name,\n            )),\n        }\n    }",
+      "diff_span": {
+        "before": "                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }",
+        "after": "                key\n            )),\n            None => Ok(common_utils::access_token::get_default_access_token_key(\n                &router_data.merchant_id,\n                merchant_connector_id_or_connector_name,\n            )),\n        }"
+      },
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    },
+    {
+      "id": "crates/router/src/core/payments/access_token.rs::function::get_cached_access_token_for_ucs",
+      "file": "crates/router/src/core/payments/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn get_cached_access_token_for_ucs(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    platform: &domain::Platform,\n    payment_method: common_enums::PaymentMethod,\n    creds_identifier: Option<&str>,\n) -> RouterResult<Option<types::AccessToken>> {\n    if connector\n        .connector_name\n        .supports_access_token(payment_method)\n    {\n        let merchant_id = platform.get_processor().get_account().get_id();\n        let store = &*state.store;\n\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n        let key = format!(\n            \"access_token_{}_{}\",\n            merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        );\n\n        let cached_access_token = store\n            .get_access_token(key)\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        if let Some(access_token) = cached_access_token {\n            router_env::logger::info!(\n                \"Cached access token found for UCS flow - merchant_id: {:?}, connector: {} with expiry of: {} seconds\",\n                platform.get_processor().get_account().get_id(),\n                connector.connector_name,\n                access_token.expires\n            );\n            metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                1,\n                router_env::metric_attributes!((\"connector\", connector.connector_name.to_string())),\n            );\n            Ok(Some(access_token))\n        } else {\n            router_env::logger::info!(\n                \"No cached access token found for UCS flow - UCS will generate internally - merchant_id: {:?}, connector: {}\",\n                platform.get_processor().get_account().get_id(),\n                connector.connector_name\n            );\n            metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                1,\n                router_env::metric_attributes!((\"connector\", connector.connector_name.to_string())),\n            );\n            Ok(None)\n        }\n    } else {\n        Ok(None)\n    }\n}",
+      "after_code": "pub async fn get_cached_access_token_for_ucs(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    platform: &domain::Platform,\n    payment_method: common_enums::PaymentMethod,\n    creds_identifier: Option<&str>,\n) -> RouterResult<Option<types::AccessToken>> {\n    if connector\n        .connector_name\n        .supports_access_token(payment_method)\n    {\n        let merchant_id = platform.get_processor().get_account().get_id();\n        let store = &*state.store;\n\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n        let key = common_utils::access_token::get_default_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n        );\n\n        let cached_access_token = store\n            .get_access_token(key)\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        if let Some(access_token) = cached_access_token {\n            router_env::logger::info!(\n                \"Cached access token found for UCS flow - merchant_id: {:?}, connector: {} with expiry of: {} seconds\",\n                platform.get_processor().get_account().get_id(),\n                connector.connector_name,\n                access_token.expires\n            );\n            metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                1,\n                router_env::metric_attributes!((\"connector\", connector.connector_name.to_string())),\n            );\n            Ok(Some(access_token))\n        } else {\n            router_env::logger::info!(\n                \"No cached access token found for UCS flow - UCS will generate internally - merchant_id: {:?}, connector: {}\",\n                platform.get_processor().get_account().get_id(),\n                connector.connector_name\n            );\n            metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                1,\n                router_env::metric_attributes!((\"connector\", connector.connector_name.to_string())),\n            );\n            Ok(None)\n        }\n    } else {\n        Ok(None)\n    }\n}",
+      "diff_span": {
+        "before": "            .unwrap_or(connector.connector_name.to_string());\n\n        let key = format!(\n            \"access_token_{}_{}\",\n            merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        );\n",
+        "after": "            .unwrap_or(connector.connector_name.to_string());\n\n        let key = common_utils::access_token::get_default_access_token_key(\n            merchant_id,\n            merchant_connector_id_or_connector_name,\n        );\n"
+      },
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    },
+    {
+      "id": "crates/router/src/core/unified_connector_service.rs::function::get_access_token_from_ucs_response",
+      "file": "crates/router/src/core/unified_connector_service.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn get_access_token_from_ucs_response(\n    session_state: &SessionState,\n    platform: &Platform,\n    connector_name: &str,\n    merchant_connector_id: Option<&id_type::MerchantConnectorAccountId>,\n    creds_identifier: Option<String>,\n    ucs_state: Option<&unified_connector_service_client::payments::ConnectorState>,\n) -> Option<AccessToken> {\n    let ucs_access_token = ucs_state\n        .and_then(|state| state.access_token.as_ref())\n        .map(AccessToken::foreign_from)?;\n\n    let merchant_id = platform.get_processor().get_account().get_id();\n\n    let merchant_connector_id_or_connector_name = merchant_connector_id\n        .map(|mca_id| mca_id.get_string_repr().to_string())\n        .or(creds_identifier.map(|id| id.to_string()))\n        .unwrap_or(connector_name.to_string());\n\n    let key = format!(\n        \"access_token_{}_{}\",\n        merchant_id.get_string_repr(),\n        merchant_connector_id_or_connector_name\n    );\n\n    if let Ok(Some(cached_token)) = session_state.store.get_access_token(key).await {\n        if cached_token.token.peek() == ucs_access_token.token.peek() {\n            return None;\n        }\n    }\n\n    Some(ucs_access_token)\n}",
+      "after_code": "pub async fn get_access_token_from_ucs_response(\n    session_state: &SessionState,\n    platform: &Platform,\n    connector_name: &str,\n    merchant_connector_id: Option<&id_type::MerchantConnectorAccountId>,\n    creds_identifier: Option<String>,\n    ucs_state: Option<&unified_connector_service_client::payments::ConnectorState>,\n) -> Option<AccessToken> {\n    let ucs_access_token = ucs_state\n        .and_then(|state| state.access_token.as_ref())\n        .map(AccessToken::foreign_from)?;\n\n    let merchant_id = platform.get_processor().get_account().get_id();\n\n    let merchant_connector_id_or_connector_name = merchant_connector_id\n        .map(|mca_id| mca_id.get_string_repr().to_string())\n        .or(creds_identifier.map(|id| id.to_string()))\n        .unwrap_or(connector_name.to_string());\n\n    let key = common_utils::access_token::get_default_access_token_key(\n        merchant_id,\n        merchant_connector_id_or_connector_name,\n    );\n\n    if let Ok(Some(cached_token)) = session_state.store.get_access_token(key).await {\n        if cached_token.token.peek() == ucs_access_token.token.peek() {\n            return None;\n        }\n    }\n\n    Some(ucs_access_token)\n}",
+      "diff_span": {
+        "before": "        .unwrap_or(connector_name.to_string());\n\n    let key = format!(\n        \"access_token_{}_{}\",\n        merchant_id.get_string_repr(),\n        merchant_connector_id_or_connector_name\n    );\n",
+        "after": "        .unwrap_or(connector_name.to_string());\n\n    let key = common_utils::access_token::get_default_access_token_key(\n        merchant_id,\n        merchant_connector_id_or_connector_name,\n    );\n"
+      },
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    },
+    {
+      "id": "crates/common_utils/src/lib.rs::mod::access_token",
+      "file": "crates/common_utils/src/lib.rs",
+      "kind": "mod_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub mod access_token;",
+      "diff_span": null,
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    },
+    {
+      "id": "crates/common_utils/src/access_token.rs::function::get_default_access_token_key",
+      "file": "crates/common_utils/src/access_token.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn get_default_access_token_key(\n    merchant_id: &id_type::MerchantId,\n    merchant_connector_id_or_connector_name: impl Display,\n) -> String {\n    format!(\n        \"access_token_{}_{}\",\n        merchant_id.get_string_repr(),\n        merchant_connector_id_or_connector_name\n    )\n}",
+      "diff_span": null,
+      "commit_sha": "57fa606ea2d0766acbe4d917d5d1dd350d7928d5"
+    }
+  ]
+}

diffs/pr_10080/7959c36/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "7959c36da9de19170c9a621676bc44039b13af3a",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/router/src/core/unified_connector_service.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/unified_connector_service.rs::function::set_access_token_for_ucs",
+      "file": "crates/router/src/core/unified_connector_service.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn set_access_token_for_ucs(\n    state: &SessionState,\n    merchant_context: &MerchantContext,\n    connector_name: &str,\n    access_token: AccessToken,\n    merchant_connector_id: Option<&id_type::MerchantConnectorAccountId>,\n    creds_identifier: Option<String>,\n) -> Result<(), errors::StorageError> {\n    let merchant_id = merchant_context.get_merchant_account().get_id();\n\n    let merchant_connector_id_or_connector_name = merchant_connector_id\n        .map(|mca_id| mca_id.get_string_repr().to_string())\n        .or(creds_identifier.map(|id| id.to_string()))\n        .unwrap_or(connector_name.to_string());\n\n    let key = format!(\n        \"access_token_{}_{}\",\n        merchant_id.get_string_repr(),\n        merchant_connector_id_or_connector_name\n    );\n\n    let modified_access_token = AccessToken {\n        expires: access_token\n            .expires\n            .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n        ..access_token\n    };\n\n    logger::debug!(\n        access_token_expiry_after_modification = modified_access_token.expires,\n        merchant_id = ?merchant_id,\n        connector_name = connector_name,\n        merchant_connector_id_or_connector_name = merchant_connector_id_or_connector_name\n    );\n\n    if let Err(access_token_set_error) = state\n        .store\n        .set_access_token(\n            key,\n            // merchant_id,\n            // &merchant_connector_id_or_connector_name,\n            modified_access_token,\n            // None,\n        )\n        .await\n    {\n        // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n        // Payments should not fail, once the access token is successfully created\n        // The next request will create new access token, if required\n        logger::error!(access_token_set_error=?access_token_set_error, \"Failed to store UCS access token\");\n    }\n\n    Ok(())\n}",
+      "after_code": "pub async fn set_access_token_for_ucs(\n    state: &SessionState,\n    merchant_context: &MerchantContext,\n    connector_name: &str,\n    access_token: AccessToken,\n    merchant_connector_id: Option<&id_type::MerchantConnectorAccountId>,\n    creds_identifier: Option<String>,\n) -> Result<(), errors::StorageError> {\n    let merchant_id = merchant_context.get_merchant_account().get_id();\n\n    let merchant_connector_id_or_connector_name = merchant_connector_id\n        .map(|mca_id| mca_id.get_string_repr().to_string())\n        .or(creds_identifier.map(|id| id.to_string()))\n        .unwrap_or(connector_name.to_string());\n\n    let key = format!(\n        \"access_token_{}_{}\",\n        merchant_id.get_string_repr(),\n        merchant_connector_id_or_connector_name\n    );\n\n    let modified_access_token = AccessToken {\n        expires: access_token\n            .expires\n            .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n        ..access_token\n    };\n\n    logger::debug!(\n        access_token_expiry_after_modification = modified_access_token.expires,\n        merchant_id = ?merchant_id,\n        connector_name = connector_name,\n        merchant_connector_id_or_connector_name = merchant_connector_id_or_connector_name\n    );\n\n    if let Err(access_token_set_error) = state\n        .store\n        .set_access_token(key, modified_access_token)\n        .await\n    {\n        // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n        // Payments should not fail, once the access token is successfully created\n        // The next request will create new access token, if required\n        logger::error!(access_token_set_error=?access_token_set_error, \"Failed to store UCS access token\");\n    }\n\n    Ok(())\n}",
+      "diff_span": {
+        "before": "    if let Err(access_token_set_error) = state\n        .store\n        .set_access_token(\n            key,\n            // merchant_id,\n            // &merchant_connector_id_or_connector_name,\n            modified_access_token,\n            // None,\n        )\n        .await\n    {",
+        "after": "    if let Err(access_token_set_error) = state\n        .store\n        .set_access_token(key, modified_access_token)\n        .await\n    {"
+      },
+      "commit_sha": "7959c36da9de19170c9a621676bc44039b13af3a"
+    }
+  ]
+}

diffs/pr_10080/979147e/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "979147ef8ee64325c4aea5fe6fce9f28f3239173",
+  "pr_number": 10080,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10080/9e04455/diff.json

@@ -0,0 +1,56 @@
+{
+  "commit_sha": "9e044556800ed5582b33230b316688c077c34557",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/santander.rs",
+    "crates/hyperswitch_interfaces/src/api.rs",
+    "crates/hyperswitch_interfaces/src/connector_integration_interface.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::trait::ConnectorSpecifications",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub trait ConnectorSpecifications {\n    /// Preprocessing flow name if any, that must be made before the current flow.\n    fn get_preprocessing_flow_if_needed(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n    ) -> Option<PreProcessingFlowName> {\n        None\n    }\n    /// Based on the current flow and preprocessing_flow_response, decide if the main flow must be called or not\n    ///\n    /// By default, always continue with the main flow after the preprocessing flow.\n    fn decide_should_continue_after_preprocessing(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n        _pre_processing_flow_name: PreProcessingFlowName,\n        _preprocessing_flow_response: PreProcessingFlowResponse<'_>,\n    ) -> bool {\n        true\n    }\n    /// If Some is returned, the returned api flow must be made instead of the current flow.\n    fn get_alternate_flow_if_needed(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n    ) -> Option<AlternateFlow> {\n        None\n    }\n    /// Details related to payment method supported by the connector\n    fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {\n        None\n    }\n\n    /// Supported webhooks flows\n    fn get_supported_webhook_flows(&self) -> Option<&'static [EventClass]> {\n        None\n    }\n\n    /// About the connector\n    fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {\n        None\n    }\n\n    /// Check if connector should make another request to create an access token\n    /// Connectors should override this method if they require an authentication token to create a new access token\n    fn authentication_token_for_token_creation(&self) -> bool {\n        false\n    }\n\n    /// Check if connector should make another request to create an customer\n    /// Connectors should override this method if they require to create a connector customer\n    fn should_call_connector_customer(\n        &self,\n        _payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n    ) -> bool {\n        false\n    }\n\n    /// Whether SDK session token generation is enabled for this connector\n    fn is_sdk_client_token_generation_enabled(&self) -> bool {\n        false\n    }\n\n    /// Payment method types that support SDK session token generation\n    fn supported_payment_method_types_for_sdk_client_token_generation(\n        &self,\n    ) -> Vec<PaymentMethodType> {\n        vec![]\n    }\n\n    /// Validate if SDK session token generation is allowed for given payment method type\n    fn validate_sdk_session_token_for_payment_method(\n        &self,\n        current_core_payment_method_type: &PaymentMethodType,\n    ) -> bool {\n        self.is_sdk_client_token_generation_enabled()\n            && self\n                .supported_payment_method_types_for_sdk_client_token_generation()\n                .contains(current_core_payment_method_type)\n    }\n\n    #[cfg(not(feature = \"v2\"))]\n    /// Generate connector request reference ID\n    fn generate_connector_request_reference_id(\n        &self,\n        _payment_intent: &hyperswitch_domain_models::payments::PaymentIntent,\n        payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n        is_config_enabled_to_send_payment_id_as_connector_request_id: bool,\n    ) -> String {\n        // Send payment_id if config is enabled for a merchant, else send attempt_id\n        if is_config_enabled_to_send_payment_id_as_connector_request_id {\n            payment_attempt.payment_id.get_string_repr().to_owned()\n        } else {\n            payment_attempt.attempt_id.to_owned()\n        }\n    }\n\n    #[cfg(feature = \"v2\")]\n    /// Generate connector request reference ID\n    fn generate_connector_request_reference_id(\n        &self,\n        payment_intent: &hyperswitch_domain_models::payments::PaymentIntent,\n        payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n    ) -> String {\n        payment_intent\n            .merchant_reference_id\n            .as_ref()\n            .map(|id| id.get_string_repr().to_owned())\n            .unwrap_or_else(|| payment_attempt.id.get_string_repr().to_owned())\n    }\n\n    /// Check if connector needs tokenization call before setup mandate flow\n    fn should_call_tokenization_before_setup_mandate(&self) -> bool {\n        true\n    }\n\n    /// Check if connector requires different access token per payment method type\n    fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        false\n    }\n}",
+      "after_code": "pub trait ConnectorSpecifications {\n    /// Preprocessing flow name if any, that must be made before the current flow.\n    fn get_preprocessing_flow_if_needed(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n    ) -> Option<PreProcessingFlowName> {\n        None\n    }\n    /// Based on the current flow and preprocessing_flow_response, decide if the main flow must be called or not\n    ///\n    /// By default, always continue with the main flow after the preprocessing flow.\n    fn decide_should_continue_after_preprocessing(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n        _pre_processing_flow_name: PreProcessingFlowName,\n        _preprocessing_flow_response: PreProcessingFlowResponse<'_>,\n    ) -> bool {\n        true\n    }\n    /// If Some is returned, the returned api flow must be made instead of the current flow.\n    fn get_alternate_flow_if_needed(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n    ) -> Option<AlternateFlow> {\n        None\n    }\n    /// Details related to payment method supported by the connector\n    fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {\n        None\n    }\n\n    /// Supported webhooks flows\n    fn get_supported_webhook_flows(&self) -> Option<&'static [EventClass]> {\n        None\n    }\n\n    /// About the connector\n    fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {\n        None\n    }\n\n    /// Check if connector should make another request to create an access token\n    /// Connectors should override this method if they require an authentication token to create a new access token\n    fn authentication_token_for_token_creation(&self) -> bool {\n        false\n    }\n\n    /// Check if connector should make another request to create an customer\n    /// Connectors should override this method if they require to create a connector customer\n    fn should_call_connector_customer(\n        &self,\n        _payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n    ) -> bool {\n        false\n    }\n\n    /// Whether SDK session token generation is enabled for this connector\n    fn is_sdk_client_token_generation_enabled(&self) -> bool {\n        false\n    }\n\n    /// Payment method types that support SDK session token generation\n    fn supported_payment_method_types_for_sdk_client_token_generation(\n        &self,\n    ) -> Vec<PaymentMethodType> {\n        vec![]\n    }\n\n    /// Validate if SDK session token generation is allowed for given payment method type\n    fn validate_sdk_session_token_for_payment_method(\n        &self,\n        current_core_payment_method_type: &PaymentMethodType,\n    ) -> bool {\n        self.is_sdk_client_token_generation_enabled()\n            && self\n                .supported_payment_method_types_for_sdk_client_token_generation()\n                .contains(current_core_payment_method_type)\n    }\n\n    #[cfg(not(feature = \"v2\"))]\n    /// Generate connector request reference ID\n    fn generate_connector_request_reference_id(\n        &self,\n        _payment_intent: &hyperswitch_domain_models::payments::PaymentIntent,\n        payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n        is_config_enabled_to_send_payment_id_as_connector_request_id: bool,\n    ) -> String {\n        // Send payment_id if config is enabled for a merchant, else send attempt_id\n        if is_config_enabled_to_send_payment_id_as_connector_request_id {\n            payment_attempt.payment_id.get_string_repr().to_owned()\n        } else {\n            payment_attempt.attempt_id.to_owned()\n        }\n    }\n\n    #[cfg(feature = \"v2\")]\n    /// Generate connector request reference ID\n    fn generate_connector_request_reference_id(\n        &self,\n        payment_intent: &hyperswitch_domain_models::payments::PaymentIntent,\n        payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n    ) -> String {\n        payment_intent\n            .merchant_reference_id\n            .as_ref()\n            .map(|id| id.get_string_repr().to_owned())\n            .unwrap_or_else(|| payment_attempt.id.get_string_repr().to_owned())\n    }\n\n    /// Check if connector needs tokenization call before setup mandate flow\n    fn should_call_tokenization_before_setup_mandate(&self) -> bool {\n        true\n    }\n}",
+      "diff_span": {
+        "before": "        true\n    }\n\n    /// Check if connector requires different access token per payment method type\n    fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        false\n    }\n}",
+        "after": ""
+      },
+      "commit_sha": "9e044556800ed5582b33230b316688c077c34557"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::Santander::function::requires_different_access_token_per_payment_method_type",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        true\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "9e044556800ed5582b33230b316688c077c34557"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::ConnectorSpecifications::function::requires_different_access_token_per_payment_method_type",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        false\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "9e044556800ed5582b33230b316688c077c34557"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs::ConnectorEnum::function::requires_different_access_token_per_payment_method_type",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        match self {\n            Self::Old(connector) => {\n                connector.requires_different_access_token_per_payment_method_type()\n            }\n            Self::New(connector) => {\n                connector.requires_different_access_token_per_payment_method_type()\n            }\n        }\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "9e044556800ed5582b33230b316688c077c34557"
+    }
+  ]
+}

diffs/pr_10080/aea832f/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "aea832fef0a7853d82f89e7d787239baee4b770c",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/router/src/core/payouts/access_token.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payouts/access_token.rs::function::add_access_token_for_payout",
+      "file": "crates/router/src/core/payouts/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token_for_payout<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    merchant_context: &domain::MerchantContext,\n    router_data: &types::PayoutsRouterData<F>,\n    payout_type: Option<enums::PayoutType>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token_for_payout(payout_type)\n    {\n        let store = &*state.store;\n\n        let key = connector\n            .connector\n            .get_access_token_key_from_connector(\n                router_data,\n                connector.connector.id().to_string(),\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(\n                    state,\n                    connector,\n                    merchant_context,\n                    &refresh_token_router_data,\n                )\n                .await?\n                .async_map(|access_token| async {\n                    //Store the access token in db\n                    let store = &*state.store;\n                    // This error should not be propagated, we don't want payments to fail once we have\n                    // the access token, the next request will create new access token\n                    let _ = store\n                        .set_access_token(key, access_token.clone())\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"DB error when setting the access token\");\n                    Some(access_token)\n                })\n                .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token_for_payout<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    merchant_context: &domain::MerchantContext,\n    router_data: &types::PayoutsRouterData<F>,\n    payout_type: Option<enums::PayoutType>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token_for_payout(payout_type)\n    {\n        let store = &*state.store;\n\n        let key = connector\n            .connector\n            .get_access_token_key_from_connector(router_data, connector.connector.id().to_string())\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(\n                    state,\n                    connector,\n                    merchant_context,\n                    &refresh_token_router_data,\n                )\n                .await?\n                .async_map(|access_token| async {\n                    //Store the access token in db\n                    let store = &*state.store;\n                    // This error should not be propagated, we don't want payments to fail once we have\n                    // the access token, the next request will create new access token\n                    let _ = store\n                        .set_access_token(key, access_token.clone())\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"DB error when setting the access token\");\n                    Some(access_token)\n                })\n                .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "        let key = connector\n            .connector\n            .get_access_token_key_from_connector(\n                router_data,\n                connector.connector.id().to_string(),\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n",
+        "after": "        let key = connector\n            .connector\n            .get_access_token_key_from_connector(router_data, connector.connector.id().to_string())\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n"
+      },
+      "commit_sha": "aea832fef0a7853d82f89e7d787239baee4b770c"
+    }
+  ]
+}

diffs/pr_10080/b608274/diff.json

@@ -0,0 +1,98 @@
+{
+  "commit_sha": "b608274faa1e5916c3355ecd4f120cbe8504c575",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/common_enums/src/connector_enums.rs",
+    "crates/hyperswitch_connectors/src/connectors/santander.rs",
+    "crates/hyperswitch_interfaces/src/api.rs",
+    "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+    "crates/router/src/core/payments/access_token.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::impl::Santander",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorSpecifications for Santander {\n    fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {\n        Some(&SANTANDER_CONNECTOR_INFO)\n    }\n\n    fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {\n        Some(&*SANTANDER_SUPPORTED_PAYMENT_METHODS)\n    }\n\n    fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {\n        Some(&SANTANDER_SUPPORTED_WEBHOOK_FLOWS)\n    }\n}",
+      "after_code": "impl ConnectorSpecifications for Santander {\n    fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {\n        Some(&SANTANDER_CONNECTOR_INFO)\n    }\n\n    fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {\n        Some(&*SANTANDER_SUPPORTED_PAYMENT_METHODS)\n    }\n\n    fn get_supported_webhook_flows(&self) -> Option<&'static [enums::EventClass]> {\n        Some(&SANTANDER_SUPPORTED_WEBHOOK_FLOWS)\n    }\n\n    fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        true\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        Some(&SANTANDER_SUPPORTED_WEBHOOK_FLOWS)\n    }\n\n    fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        true\n    }\n}"
+      },
+      "commit_sha": "b608274faa1e5916c3355ecd4f120cbe8504c575"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::trait::ConnectorSpecifications",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub trait ConnectorSpecifications {\n    /// Preprocessing flow name if any, that must be made before the current flow.\n    fn get_preprocessing_flow_if_needed(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n    ) -> Option<PreProcessingFlowName> {\n        None\n    }\n    /// Based on the current flow and preprocessing_flow_response, decide if the main flow must be called or not\n    ///\n    /// By default, always continue with the main flow after the preprocessing flow.\n    fn decide_should_continue_after_preprocessing(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n        _pre_processing_flow_name: PreProcessingFlowName,\n        _preprocessing_flow_response: PreProcessingFlowResponse<'_>,\n    ) -> bool {\n        true\n    }\n    /// If Some is returned, the returned api flow must be made instead of the current flow.\n    fn get_alternate_flow_if_needed(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n    ) -> Option<AlternateFlow> {\n        None\n    }\n    /// Details related to payment method supported by the connector\n    fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {\n        None\n    }\n\n    /// Supported webhooks flows\n    fn get_supported_webhook_flows(&self) -> Option<&'static [EventClass]> {\n        None\n    }\n\n    /// About the connector\n    fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {\n        None\n    }\n\n    /// Check if connector should make another request to create an access token\n    /// Connectors should override this method if they require an authentication token to create a new access token\n    fn authentication_token_for_token_creation(&self) -> bool {\n        false\n    }\n\n    /// Check if connector should make another request to create an customer\n    /// Connectors should override this method if they require to create a connector customer\n    fn should_call_connector_customer(\n        &self,\n        _payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n    ) -> bool {\n        false\n    }\n\n    /// Whether SDK session token generation is enabled for this connector\n    fn is_sdk_client_token_generation_enabled(&self) -> bool {\n        false\n    }\n\n    /// Payment method types that support SDK session token generation\n    fn supported_payment_method_types_for_sdk_client_token_generation(\n        &self,\n    ) -> Vec<PaymentMethodType> {\n        vec![]\n    }\n\n    /// Validate if SDK session token generation is allowed for given payment method type\n    fn validate_sdk_session_token_for_payment_method(\n        &self,\n        current_core_payment_method_type: &PaymentMethodType,\n    ) -> bool {\n        self.is_sdk_client_token_generation_enabled()\n            && self\n                .supported_payment_method_types_for_sdk_client_token_generation()\n                .contains(current_core_payment_method_type)\n    }\n\n    #[cfg(not(feature = \"v2\"))]\n    /// Generate connector request reference ID\n    fn generate_connector_request_reference_id(\n        &self,\n        _payment_intent: &hyperswitch_domain_models::payments::PaymentIntent,\n        payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n        is_config_enabled_to_send_payment_id_as_connector_request_id: bool,\n    ) -> String {\n        // Send payment_id if config is enabled for a merchant, else send attempt_id\n        if is_config_enabled_to_send_payment_id_as_connector_request_id {\n            payment_attempt.payment_id.get_string_repr().to_owned()\n        } else {\n            payment_attempt.attempt_id.to_owned()\n        }\n    }\n\n    #[cfg(feature = \"v2\")]\n    /// Generate connector request reference ID\n    fn generate_connector_request_reference_id(\n        &self,\n        payment_intent: &hyperswitch_domain_models::payments::PaymentIntent,\n        payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n    ) -> String {\n        payment_intent\n            .merchant_reference_id\n            .as_ref()\n            .map(|id| id.get_string_repr().to_owned())\n            .unwrap_or_else(|| payment_attempt.id.get_string_repr().to_owned())\n    }\n\n    /// Check if connector needs tokenization call before setup mandate flow\n    fn should_call_tokenization_before_setup_mandate(&self) -> bool {\n        true\n    }\n}",
+      "after_code": "pub trait ConnectorSpecifications {\n    /// Preprocessing flow name if any, that must be made before the current flow.\n    fn get_preprocessing_flow_if_needed(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n    ) -> Option<PreProcessingFlowName> {\n        None\n    }\n    /// Based on the current flow and preprocessing_flow_response, decide if the main flow must be called or not\n    ///\n    /// By default, always continue with the main flow after the preprocessing flow.\n    fn decide_should_continue_after_preprocessing(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n        _pre_processing_flow_name: PreProcessingFlowName,\n        _preprocessing_flow_response: PreProcessingFlowResponse<'_>,\n    ) -> bool {\n        true\n    }\n    /// If Some is returned, the returned api flow must be made instead of the current flow.\n    fn get_alternate_flow_if_needed(\n        &self,\n        _current_flow: CurrentFlowInfo<'_>,\n    ) -> Option<AlternateFlow> {\n        None\n    }\n    /// Details related to payment method supported by the connector\n    fn get_supported_payment_methods(&self) -> Option<&'static SupportedPaymentMethods> {\n        None\n    }\n\n    /// Supported webhooks flows\n    fn get_supported_webhook_flows(&self) -> Option<&'static [EventClass]> {\n        None\n    }\n\n    /// About the connector\n    fn get_connector_about(&self) -> Option<&'static ConnectorInfo> {\n        None\n    }\n\n    /// Check if connector should make another request to create an access token\n    /// Connectors should override this method if they require an authentication token to create a new access token\n    fn authentication_token_for_token_creation(&self) -> bool {\n        false\n    }\n\n    /// Check if connector should make another request to create an customer\n    /// Connectors should override this method if they require to create a connector customer\n    fn should_call_connector_customer(\n        &self,\n        _payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n    ) -> bool {\n        false\n    }\n\n    /// Whether SDK session token generation is enabled for this connector\n    fn is_sdk_client_token_generation_enabled(&self) -> bool {\n        false\n    }\n\n    /// Payment method types that support SDK session token generation\n    fn supported_payment_method_types_for_sdk_client_token_generation(\n        &self,\n    ) -> Vec<PaymentMethodType> {\n        vec![]\n    }\n\n    /// Validate if SDK session token generation is allowed for given payment method type\n    fn validate_sdk_session_token_for_payment_method(\n        &self,\n        current_core_payment_method_type: &PaymentMethodType,\n    ) -> bool {\n        self.is_sdk_client_token_generation_enabled()\n            && self\n                .supported_payment_method_types_for_sdk_client_token_generation()\n                .contains(current_core_payment_method_type)\n    }\n\n    #[cfg(not(feature = \"v2\"))]\n    /// Generate connector request reference ID\n    fn generate_connector_request_reference_id(\n        &self,\n        _payment_intent: &hyperswitch_domain_models::payments::PaymentIntent,\n        payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n        is_config_enabled_to_send_payment_id_as_connector_request_id: bool,\n    ) -> String {\n        // Send payment_id if config is enabled for a merchant, else send attempt_id\n        if is_config_enabled_to_send_payment_id_as_connector_request_id {\n            payment_attempt.payment_id.get_string_repr().to_owned()\n        } else {\n            payment_attempt.attempt_id.to_owned()\n        }\n    }\n\n    #[cfg(feature = \"v2\")]\n    /// Generate connector request reference ID\n    fn generate_connector_request_reference_id(\n        &self,\n        payment_intent: &hyperswitch_domain_models::payments::PaymentIntent,\n        payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,\n    ) -> String {\n        payment_intent\n            .merchant_reference_id\n            .as_ref()\n            .map(|id| id.get_string_repr().to_owned())\n            .unwrap_or_else(|| payment_attempt.id.get_string_repr().to_owned())\n    }\n\n    /// Check if connector needs tokenization call before setup mandate flow\n    fn should_call_tokenization_before_setup_mandate(&self) -> bool {\n        true\n    }\n\n    /// Check if connector requires different access token per payment method type\n    fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        false\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        true\n    }\n\n    /// Check if connector requires different access token per payment method type\n    fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        false\n    }\n}"
+      },
+      "commit_sha": "b608274faa1e5916c3355ecd4f120cbe8504c575"
+    },
+    {
+      "id": "crates/router/src/core/payments/access_token.rs::function::add_access_token",
+      "file": "crates/router/src/core/payments/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token<\n    F: Clone + 'static,\n    Req: Debug + Clone + 'static,\n    Res: Debug + Clone + 'static,\n>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    router_data: &types::RouterData<F, Req, Res>,\n    creds_identifier: Option<&str>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token(router_data.payment_method)\n    {\n        let merchant_id = &router_data.merchant_id;\n        let store = &*state.store;\n\n        // `merchant_connector_id` may not be present in the below cases\n        // - when straight through routing is used without passing the `merchant_connector_id`\n        // - when creds identifier is passed\n        //\n        // In these cases fallback to `connector_name`.\n        // We cannot use multiple merchant connector account in these cases\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n        let pmt_suffix = connector\n            .connector_name\n            .is_different_access_token_required_per_payment_method_type()\n            .then(|| {\n                router_data\n                    .payment_method_type\n                    .as_ref()\n                    .map(|pmt| pmt.to_string())\n            })\n            .flatten();\n\n        let old_access_token = store\n            .get_access_token(\n                merchant_id,\n                &merchant_connector_id_or_connector_name,\n                pmt_suffix.clone(),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                merchant_id,\n                                &merchant_connector_id_or_connector_name,\n                                modified_access_token_with_expiry.clone(),\n                                pmt_suffix.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\")\n                        {\n                            // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n                            // Payments should not fail, once the access token is successfully created\n                            // The next request will create new access token, if required\n                            logger::error!(access_token_set_error=?access_token_set_error);\n                        }\n                        Some(modified_access_token_with_expiry)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token<\n    F: Clone + 'static,\n    Req: Debug + Clone + 'static,\n    Res: Debug + Clone + 'static,\n>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    router_data: &types::RouterData<F, Req, Res>,\n    creds_identifier: Option<&str>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token(router_data.payment_method)\n    {\n        let merchant_id = &router_data.merchant_id;\n        let store = &*state.store;\n\n        // `merchant_connector_id` may not be present in the below cases\n        // - when straight through routing is used without passing the `merchant_connector_id`\n        // - when creds identifier is passed\n        //\n        // In these cases fallback to `connector_name`.\n        // We cannot use multiple merchant connector account in these cases\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n        let pmt_suffix = connector\n            .connector\n            .requires_different_access_token_per_payment_method_type()\n            .then(|| {\n                router_data\n                    .payment_method_type\n                    .as_ref()\n                    .map(|pmt| pmt.to_string())\n            })\n            .flatten();\n\n        let old_access_token = store\n            .get_access_token(\n                merchant_id,\n                &merchant_connector_id_or_connector_name,\n                pmt_suffix.clone(),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                merchant_id,\n                                &merchant_connector_id_or_connector_name,\n                                modified_access_token_with_expiry.clone(),\n                                pmt_suffix.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\")\n                        {\n                            // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n                            // Payments should not fail, once the access token is successfully created\n                            // The next request will create new access token, if required\n                            logger::error!(access_token_set_error=?access_token_set_error);\n                        }\n                        Some(modified_access_token_with_expiry)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "\n        let pmt_suffix = connector\n            .connector_name\n            .is_different_access_token_required_per_payment_method_type()\n            .then(|| {\n                router_data",
+        "after": "\n        let pmt_suffix = connector\n            .connector\n            .requires_different_access_token_per_payment_method_type()\n            .then(|| {\n                router_data"
+      },
+      "commit_sha": "b608274faa1e5916c3355ecd4f120cbe8504c575"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::Santander::function::requires_different_access_token_per_payment_method_type",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        true\n    }",
+      "diff_span": null,
+      "commit_sha": "b608274faa1e5916c3355ecd4f120cbe8504c575"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::ConnectorSpecifications::function::requires_different_access_token_per_payment_method_type",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        false\n    }",
+      "diff_span": null,
+      "commit_sha": "b608274faa1e5916c3355ecd4f120cbe8504c575"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs::ConnectorEnum::function::requires_different_access_token_per_payment_method_type",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn requires_different_access_token_per_payment_method_type(&self) -> bool {\n        match self {\n            Self::Old(connector) => {\n                connector.requires_different_access_token_per_payment_method_type()\n            }\n            Self::New(connector) => {\n                connector.requires_different_access_token_per_payment_method_type()\n            }\n        }\n    }",
+      "diff_span": null,
+      "commit_sha": "b608274faa1e5916c3355ecd4f120cbe8504c575"
+    },
+    {
+      "id": "crates/common_enums/src/connector_enums.rs::Connector::function::is_different_access_token_required_per_payment_method_type",
+      "file": "crates/common_enums/src/connector_enums.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "pub fn is_different_access_token_required_per_payment_method_type(self) -> bool {\n        matches!(self, Self::Santander)\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "b608274faa1e5916c3355ecd4f120cbe8504c575"
+    }
+  ]
+}

diffs/pr_10080/cb10d10/diff.json

@@ -0,0 +1,44 @@
+{
+  "commit_sha": "cb10d10cd4353cc9ae5fc889a392c3a2c1ba8d8f",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/santander.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::impl::Santander",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorAccessTokenSuffix for Santander {\n    fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }\n    }\n}",
+      "after_code": "impl ConnectorAccessTokenSuffix for Santander {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }\n    }\n}",
+      "diff_span": {
+        "before": "impl ConnectorAccessTokenSuffix for Santander {\n    fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,",
+        "after": "impl ConnectorAccessTokenSuffix for Santander {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,"
+      },
+      "commit_sha": "cb10d10cd4353cc9ae5fc889a392c3a2c1ba8d8f"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::Santander::function::get_access_token_key_from_connector",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }\n    }",
+      "diff_span": null,
+      "commit_sha": "cb10d10cd4353cc9ae5fc889a392c3a2c1ba8d8f"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/santander.rs::Santander::function::get_access_token_suffix_from_connector",
+      "file": "crates/hyperswitch_connectors/src/connectors/santander.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        let key_suffix = router_data\n            .payment_method_type\n            .as_ref()\n            .map(|pmt| pmt.to_string());\n\n        match key_suffix {\n            Some(key) => Ok(format!(\n                \"access_token_{}_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name,\n                key\n            )),\n            None => Ok(format!(\n                \"access_token_{}_{}\",\n                router_data.merchant_id.get_string_repr(),\n                merchant_connector_id_or_connector_name\n            )),\n        }\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "cb10d10cd4353cc9ae5fc889a392c3a2c1ba8d8f"
+    }
+  ]
+}

diffs/pr_10080/d1cd4a3/diff.json

@@ -0,0 +1,45 @@
+{
+  "commit_sha": "d1cd4a3591ce8482892fa1901161c97e28f200ad",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+    "crates/hyperswitch_interfaces/src/connector_integration_v2.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs::ConnectorEnum::function::get_access_token_suffix_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n    ) -> CustomResult<Option<String>, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => connector.get_access_token_suffix_from_connector(router_data),\n            Self::New(_connector) => Ok(None),\n        }\n    }",
+      "after_code": "fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n    ) -> CustomResult<Option<String>, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => connector.get_access_token_suffix_from_connector(router_data),\n            Self::New(connector) => connector.get_access_token_suffix_from_connector(router_data),\n        }\n    }",
+      "diff_span": {
+        "before": "        match self {\n            Self::Old(connector) => connector.get_access_token_suffix_from_connector(router_data),\n            Self::New(_connector) => Ok(None),\n        }\n    }",
+        "after": "        match self {\n            Self::Old(connector) => connector.get_access_token_suffix_from_connector(router_data),\n            Self::New(connector) => connector.get_access_token_suffix_from_connector(router_data),\n        }\n    }"
+      },
+      "commit_sha": "d1cd4a3591ce8482892fa1901161c97e28f200ad"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs::BoxedConnectorV2::function::get_access_token_suffix_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        _router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n    ) -> CustomResult<Option<String>, errors::ConnectorError> {\n        Ok(None)\n    }",
+      "diff_span": null,
+      "commit_sha": "d1cd4a3591ce8482892fa1901161c97e28f200ad"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs::impl::BoxedConnectorV2",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        _router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n    ) -> CustomResult<Option<String>, errors::ConnectorError> {\n        Ok(None)\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "d1cd4a3591ce8482892fa1901161c97e28f200ad"
+    }
+  ]
+}

diffs/pr_10080/d93a078/diff.json

@@ -0,0 +1,148 @@
+{
+  "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/hyperswitch_interfaces/src/api.rs",
+    "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+    "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+    "crates/router/src/core/payments/access_token.rs",
+    "crates/router/src/core/payouts/access_token.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::trait::ConnectorAccessTokenSuffix",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError>;\n}",
+      "after_code": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError>;\n}",
+      "diff_span": {
+        "before": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,",
+        "after": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,"
+      },
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs::impl::BoxedConnectorV2",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "after_code": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "diff_span": {
+        "before": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,",
+        "after": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,"
+      },
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    },
+    {
+      "id": "crates/router/src/core/payments/access_token.rs::function::add_access_token",
+      "file": "crates/router/src/core/payments/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token<\n    F: Clone + 'static,\n    Req: Debug + Clone + 'static,\n    Res: Debug + Clone + 'static,\n>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    router_data: &types::RouterData<F, Req, Res>,\n    creds_identifier: Option<&str>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token(router_data.payment_method)\n    {\n        let merchant_id = &router_data.merchant_id;\n        let store = &*state.store;\n\n        // `merchant_connector_id` may not be present in the below cases\n        // - when straight through routing is used without passing the `merchant_connector_id`\n        // - when creds identifier is passed\n        //\n        // In these cases fallback to `connector_name`.\n        // We cannot use multiple merchant connector account in these cases\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n        let key = connector\n            .connector\n            .get_access_token_suffix_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                key.clone(),\n                                modified_access_token_with_expiry.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\")\n                        {\n                            // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n                            // Payments should not fail, once the access token is successfully created\n                            // The next request will create new access token, if required\n                            logger::error!(access_token_set_error=?access_token_set_error);\n                        }\n                        Some(modified_access_token_with_expiry)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token<\n    F: Clone + 'static,\n    Req: Debug + Clone + 'static,\n    Res: Debug + Clone + 'static,\n>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    router_data: &types::RouterData<F, Req, Res>,\n    creds_identifier: Option<&str>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token(router_data.payment_method)\n    {\n        let merchant_id = &router_data.merchant_id;\n        let store = &*state.store;\n\n        // `merchant_connector_id` may not be present in the below cases\n        // - when straight through routing is used without passing the `merchant_connector_id`\n        // - when creds identifier is passed\n        //\n        // In these cases fallback to `connector_name`.\n        // We cannot use multiple merchant connector account in these cases\n        let merchant_connector_id_or_connector_name = connector\n            .merchant_connector_id\n            .clone()\n            .map(|mca_id| mca_id.get_string_repr().to_string())\n            .or(creds_identifier.map(|id| id.to_string()))\n            .unwrap_or(connector.connector_name.to_string());\n\n        let key = connector\n            .connector\n            .get_access_token_key_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => {\n                router_env::logger::debug!(\n                    \"Access token found in redis for merchant_id: {:?}, payment_id: {:?}, connector: {} which has expiry of: {} seconds\",\n                    merchant_id,\n                    router_data.payment_id,\n                    connector.connector_name,\n                    access_token.expires\n                );\n                metrics::ACCESS_TOKEN_CACHE_HIT.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n                Ok(Some(access_token))\n            }\n            None => {\n                metrics::ACCESS_TOKEN_CACHE_MISS.add(\n                    1,\n                    router_env::metric_attributes!((\n                        \"connector\",\n                        connector.connector_name.to_string()\n                    )),\n                );\n\n                let authentication_token =\n                    execute_authentication_token(state, connector, router_data).await?;\n\n                let cloned_router_data = router_data.clone();\n\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from((\n                    router_data.connector_auth_type.clone(),\n                    authentication_token,\n                ))\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(state, connector, &refresh_token_router_data)\n                    .await?\n                    .async_map(|access_token| async move {\n                        let store = &*state.store;\n\n                        // The expiry should be adjusted for network delays from the connector\n                        // The access token might not have been expired when request is sent\n                        // But once it reaches the connector, it might expire because of the network delay\n                        // Subtract few seconds from the expiry in order to account for these network delays\n                        // This will reduce the expiry time by `REDUCE_ACCESS_TOKEN_EXPIRY_TIME` seconds\n                        let modified_access_token_with_expiry = types::AccessToken {\n                            expires: access_token\n                                .expires\n                                .saturating_sub(consts::REDUCE_ACCESS_TOKEN_EXPIRY_TIME.into()),\n                            ..access_token\n                        };\n\n                        logger::debug!(\n                            access_token_expiry_after_modification =\n                                modified_access_token_with_expiry.expires\n                        );\n\n                        if let Err(access_token_set_error) = store\n                            .set_access_token(\n                                key.clone(),\n                                modified_access_token_with_expiry.clone(),\n                            )\n                            .await\n                            .change_context(errors::ApiErrorResponse::InternalServerError)\n                            .attach_printable(\"DB error when setting the access token\")\n                        {\n                            // If we are not able to set the access token in redis, the error should just be logged and proceed with the payment\n                            // Payments should not fail, once the access token is successfully created\n                            // The next request will create new access token, if required\n                            logger::error!(access_token_set_error=?access_token_set_error);\n                        }\n                        Some(modified_access_token_with_expiry)\n                    })\n                    .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "        let key = connector\n            .connector\n            .get_access_token_suffix_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,",
+        "after": "        let key = connector\n            .connector\n            .get_access_token_key_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,"
+      },
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    },
+    {
+      "id": "crates/router/src/core/payouts/access_token.rs::function::add_access_token_for_payout",
+      "file": "crates/router/src/core/payouts/access_token.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn add_access_token_for_payout<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    merchant_context: &domain::MerchantContext,\n    router_data: &types::PayoutsRouterData<F>,\n    payout_type: Option<enums::PayoutType>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token_for_payout(payout_type)\n    {\n        let store = &*state.store;\n\n        let key = connector\n            .connector\n            .get_access_token_suffix_from_connector(\n                router_data,\n                connector.connector.id().to_string(),\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(\n                    state,\n                    connector,\n                    merchant_context,\n                    &refresh_token_router_data,\n                )\n                .await?\n                .async_map(|access_token| async {\n                    //Store the access token in db\n                    let store = &*state.store;\n                    // This error should not be propagated, we don't want payments to fail once we have\n                    // the access token, the next request will create new access token\n                    let _ = store\n                        .set_access_token(key, access_token.clone())\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"DB error when setting the access token\");\n                    Some(access_token)\n                })\n                .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "after_code": "pub async fn add_access_token_for_payout<F: Clone + 'static>(\n    state: &SessionState,\n    connector: &api_types::ConnectorData,\n    merchant_context: &domain::MerchantContext,\n    router_data: &types::PayoutsRouterData<F>,\n    payout_type: Option<enums::PayoutType>,\n) -> RouterResult<types::AddAccessTokenResult> {\n    if connector\n        .connector_name\n        .supports_access_token_for_payout(payout_type)\n    {\n        let store = &*state.store;\n\n        let key = connector\n            .connector\n            .get_access_token_key_from_connector(\n                router_data,\n                connector.connector.id().to_string(),\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n        let old_access_token = store\n            .get_access_token(key.clone())\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"DB error when accessing the access token\")?;\n\n        let res = match old_access_token {\n            Some(access_token) => Ok(Some(access_token)),\n            None => {\n                let cloned_router_data = router_data.clone();\n                let refresh_token_request_data = types::AccessTokenRequestData::try_from(\n                    router_data.connector_auth_type.clone(),\n                )\n                .attach_printable(\n                    \"Could not create access token request, invalid connector account credentials\",\n                )?;\n\n                let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =\n                    Err(types::ErrorResponse::default());\n                let refresh_token_router_data = payments::helpers::router_data_type_conversion::<\n                    _,\n                    api_types::AccessTokenAuth,\n                    _,\n                    _,\n                    _,\n                    _,\n                >(\n                    cloned_router_data,\n                    refresh_token_request_data,\n                    refresh_token_response_data,\n                );\n                refresh_connector_auth(\n                    state,\n                    connector,\n                    merchant_context,\n                    &refresh_token_router_data,\n                )\n                .await?\n                .async_map(|access_token| async {\n                    //Store the access token in db\n                    let store = &*state.store;\n                    // This error should not be propagated, we don't want payments to fail once we have\n                    // the access token, the next request will create new access token\n                    let _ = store\n                        .set_access_token(key, access_token.clone())\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"DB error when setting the access token\");\n                    Some(access_token)\n                })\n                .await\n            }\n        };\n\n        Ok(types::AddAccessTokenResult {\n            access_token_result: res,\n            connector_supports_access_token: true,\n        })\n    } else {\n        Ok(types::AddAccessTokenResult {\n            access_token_result: Err(types::ErrorResponse::default()),\n            connector_supports_access_token: false,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "        let key = connector\n            .connector\n            .get_access_token_suffix_from_connector(\n                router_data,\n                connector.connector.id().to_string(),",
+        "after": "        let key = connector\n            .connector\n            .get_access_token_key_from_connector(\n                router_data,\n                connector.connector.id().to_string(),"
+      },
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::impl::BoxedConnector",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorAccessTokenSuffix for BoxedConnector {\n    fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "after_code": "impl ConnectorAccessTokenSuffix for BoxedConnector {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "diff_span": {
+        "before": "impl ConnectorAccessTokenSuffix for BoxedConnector {\n    fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,",
+        "after": "impl ConnectorAccessTokenSuffix for BoxedConnector {\n    fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,"
+      },
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs::BoxedConnectorV2::function::get_access_token_key_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "diff_span": null,
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs::ConnectorEnum::function::get_access_token_key_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => connector.get_access_token_key_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n            Self::New(connector) => connector.get_access_token_key_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n        }\n    }",
+      "diff_span": null,
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::BoxedConnector::function::get_access_token_key_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_access_token_key_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "diff_span": null,
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs::ConnectorEnum::function::get_access_token_suffix_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => connector.get_access_token_suffix_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n            Self::New(connector) => connector.get_access_token_suffix_from_connector(\n                router_data,\n                merchant_connector_id_or_connector_name,\n            ),\n        }\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs::BoxedConnectorV2::function::get_access_token_suffix_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::BoxedConnector::function::get_access_token_suffix_from_connector",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_access_token_suffix_from_connector<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "d93a0780f850bdc07b80ea230fba4c136520b1e7"
+    }
+  ]
+}

diffs/pr_10080/f69bde8/diff.json

@@ -0,0 +1,85 @@
+{
+  "commit_sha": "f69bde896cf380160b893224bf2e6451c4360690",
+  "pr_number": 10080,
+  "rust_files": [
+    "crates/hyperswitch_interfaces/src/api.rs",
+    "crates/hyperswitch_interfaces/src/connector_integration_v2.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::trait::ConnectorAccessTokenSuffix",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError>;\n}",
+      "after_code": "pub trait ConnectorAccessTokenSuffix {\n    /// Function to get dynamic access token key suffix from Connector\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "diff_span": {
+        "before": "        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError>;\n}",
+        "after": "        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}"
+      },
+      "commit_sha": "f69bde896cf380160b893224bf2e6451c4360690"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs::impl::BoxedConnectorV2",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "after_code": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {}",
+      "diff_span": {
+        "before": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+        "after": "impl api::ConnectorAccessTokenSuffix for BoxedConnectorV2 {}"
+      },
+      "commit_sha": "f69bde896cf380160b893224bf2e6451c4360690"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::impl::BoxedConnector",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ConnectorAccessTokenSuffix for BoxedConnector {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+      "after_code": "impl ConnectorAccessTokenSuffix for BoxedConnector {}",
+      "diff_span": {
+        "before": "impl ConnectorAccessTokenSuffix for BoxedConnector {\n    fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }\n}",
+        "after": "impl ConnectorAccessTokenSuffix for BoxedConnector {}"
+      },
+      "commit_sha": "f69bde896cf380160b893224bf2e6451c4360690"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::ConnectorAccessTokenSuffix::function::get_access_token_key",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "diff_span": null,
+      "commit_sha": "f69bde896cf380160b893224bf2e6451c4360690"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/api.rs::BoxedConnector::function::get_access_token_key",
+      "file": "crates/hyperswitch_interfaces/src/api.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "f69bde896cf380160b893224bf2e6451c4360690"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs::BoxedConnectorV2::function::get_access_token_key",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_v2.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_access_token_key<F, Req, Res>(\n        &self,\n        router_data: &hyperswitch_domain_models::router_data::RouterData<F, Req, Res>,\n        merchant_connector_id_or_connector_name: String,\n    ) -> CustomResult<String, errors::ConnectorError> {\n        Ok(format!(\n            \"access_token_{}_{}\",\n            router_data.merchant_id.get_string_repr(),\n            merchant_connector_id_or_connector_name\n        ))\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "f69bde896cf380160b893224bf2e6451c4360690"
+    }
+  ]
+}

diffs/pr_10158/0227ec9/diff.json

@@ -0,0 +1,161 @@
+{
+  "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs",
+    "crates/external_services/src/http_client/metrics.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_client_builder",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub fn get_client_builder(\n    proxy_config: &Proxy,\n) -> CustomResult<reqwest::ClientBuilder, HttpClientError> {\n    let mut client_builder = reqwest::Client::builder()\n        .redirect(reqwest::redirect::Policy::none())\n        .pool_idle_timeout(Duration::from_secs(\n            proxy_config\n                .idle_pool_connection_timeout\n                .unwrap_or_default(),\n        ));\n\n    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\", proxy_config.http_url.clone(), proxy_config.https_url.clone());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy\n    if let Some(url) = proxy_config.https_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::https(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTPS proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config.clone()),\n        );\n    }\n\n    // Proxy all HTTP traffic through the configured HTTP proxy\n    if let Some(url) = proxy_config.http_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::http(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTP proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config),\n        );\n    }\n\n    Ok(client_builder)\n}",
+      "after_code": "pub fn get_client_builder(\n    proxy_config: &Proxy,\n) -> CustomResult<reqwest::ClientBuilder, HttpClientError> {\n    let mut client_builder = reqwest::Client::builder()\n        .redirect(reqwest::redirect::Policy::none())\n        .pool_idle_timeout(Duration::from_secs(\n            proxy_config\n                .idle_pool_connection_timeout\n                .unwrap_or_default(),\n        ));\n\n    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\", proxy_config.http_url.clone(), proxy_config.https_url.clone());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy\n    if let Some(url) = proxy_config.https_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::https(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTPS proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config.clone()),\n        );\n    }\n\n    // Proxy all HTTP traffic through the configured HTTP proxy\n    if let Some(url) = proxy_config.http_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::http(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTP proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config),\n        );\n    }\n\n    Ok(client_builder)\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189",
+      "before_imports": [
+        "use router_env::logger;",
+        "pub use common_utils::errors::CustomResult;",
+        "use std::time::Duration;"
+      ],
+      "after_imports": [
+        "pub use common_utils::errors::CustomResult;",
+        "use router_env::{logger, metric_attributes};"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::create_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub fn create_client(\n    proxy_config: &Proxy,\n    client_certificate: Option<masking::Secret<String>>,\n    client_certificate_key: Option<masking::Secret<String>>,\n    ca_certificate: Option<masking::Secret<String>>,\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Case 1: Mutual TLS with client certificate and key\n    if let (Some(encoded_certificate), Some(encoded_certificate_key)) =\n        (client_certificate.clone(), client_certificate_key.clone())\n    {\n        if ca_certificate.is_some() {\n            logger::warn!(\"All of client certificate, client key, and CA certificate are provided. CA certificate will be ignored in mutual TLS setup.\");\n        }\n\n        logger::debug!(\"Creating HTTP client with mutual TLS (client cert + key)\");\n        let client_builder =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config);\n\n        let identity = create_identity_from_certificate_and_key(\n            encoded_certificate.clone(),\n            encoded_certificate_key,\n        )?;\n        let certificate_list = create_certificate(encoded_certificate)?;\n        let client_builder = certificate_list\n            .into_iter()\n            .fold(client_builder, |client_builder, certificate| {\n                client_builder.add_root_certificate(certificate)\n            });\n        return client_builder\n            .identity(identity)\n            .use_rustls_tls()\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct client with certificate and certificate key\");\n    }\n\n    // Case 2: Use provided CA certificate for server authentication only (one-way TLS)\n    if let Some(ca_pem) = ca_certificate {\n        logger::debug!(\"Creating HTTP client with one-way TLS (CA certificate)\");\n        let pem = ca_pem.expose().replace(\"\\\\r\\\\n\", \"\\n\"); // Fix escaped newlines\n        let cert = reqwest::Certificate::from_pem(pem.as_bytes())\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to parse CA certificate PEM block\")?;\n        let client_builder =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .add_root_certificate(cert);\n        return client_builder\n            .use_rustls_tls()\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct client with CA certificate\");\n    }\n\n    // Case 3: Default client (no certs)\n    logger::debug!(\"Creating default HTTP client (no client or CA certificates)\");\n    get_base_client(proxy_config)\n}",
+      "after_code": "pub fn create_client(\n    proxy_config: &Proxy,\n    client_certificate: Option<masking::Secret<String>>,\n    client_certificate_key: Option<masking::Secret<String>>,\n    ca_certificate: Option<masking::Secret<String>>,\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Case 1: Mutual TLS with client certificate and key\n    if let (Some(encoded_certificate), Some(encoded_certificate_key)) =\n        (client_certificate.clone(), client_certificate_key.clone())\n    {\n        if ca_certificate.is_some() {\n            logger::warn!(\"All of client certificate, client key, and CA certificate are provided. CA certificate will be ignored in mutual TLS setup.\");\n        }\n\n        logger::debug!(\"Creating HTTP client with mutual TLS (client cert + key)\");\n        let client_builder =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config);\n\n        let identity = create_identity_from_certificate_and_key(\n            encoded_certificate.clone(),\n            encoded_certificate_key,\n        )?;\n        let certificate_list = create_certificate(encoded_certificate)?;\n        let client_builder = certificate_list\n            .into_iter()\n            .fold(client_builder, |client_builder, certificate| {\n                client_builder.add_root_certificate(certificate)\n            });\n        return client_builder\n            .identity(identity)\n            .use_rustls_tls()\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct client with certificate and certificate key\");\n    }\n\n    // Case 2: Use provided CA certificate for server authentication only (one-way TLS)\n    if let Some(ca_pem) = ca_certificate {\n        logger::debug!(\"Creating HTTP client with one-way TLS (CA certificate)\");\n        let pem = ca_pem.expose().replace(\"\\\\r\\\\n\", \"\\n\"); // Fix escaped newlines\n        let cert = reqwest::Certificate::from_pem(pem.as_bytes())\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to parse CA certificate PEM block\")?;\n        let client_builder =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .add_root_certificate(cert);\n        return client_builder\n            .use_rustls_tls()\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct client with CA certificate\");\n    }\n\n    // Case 3: Default client (no certs)\n    logger::debug!(\"Creating default HTTP client (no client or CA certificates)\");\n    get_base_client(proxy_config)\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189",
+      "before_imports": [
+        "use router_env::logger;",
+        "pub use common_utils::errors::CustomResult;"
+      ],
+      "after_imports": [
+        "pub use common_utils::errors::CustomResult;",
+        "use router_env::{logger, metric_attributes};"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::apply_mitm_certificate",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "fn apply_mitm_certificate(\n    mut client_builder: reqwest::ClientBuilder,\n    proxy_config: &Proxy,\n) -> reqwest::ClientBuilder {\n    if let Some(mitm_ca_cert) = &proxy_config.mitm_ca_certificate {\n        let pem = mitm_ca_cert.clone().expose().replace(\"\\\\r\\\\n\", \"\\n\");\n        match reqwest::Certificate::from_pem(pem.as_bytes()) {\n            Ok(cert) => {\n                logger::debug!(\"Successfully added MITM CA certificate\");\n                client_builder = client_builder.add_root_certificate(cert);\n            }\n            Err(err) => {\n                logger::error!(\n                    \"Failed to parse MITM CA certificate: {}, continuing without MITM support\",\n                    err\n                );\n            }\n        }\n    }\n    client_builder\n}",
+      "after_code": "fn apply_mitm_certificate(\n    mut client_builder: reqwest::ClientBuilder,\n    proxy_config: &Proxy,\n) -> reqwest::ClientBuilder {\n    if let Some(mitm_ca_cert) = &proxy_config.mitm_ca_certificate {\n        let pem = mitm_ca_cert.clone().expose().replace(\"\\\\r\\\\n\", \"\\n\");\n        match reqwest::Certificate::from_pem(pem.as_bytes()) {\n            Ok(cert) => {\n                logger::debug!(\"Successfully added MITM CA certificate\");\n                client_builder = client_builder.add_root_certificate(cert);\n            }\n            Err(err) => {\n                logger::error!(\n                    \"Failed to parse MITM CA certificate: {}, continuing without MITM support\",\n                    err\n                );\n            }\n        }\n    }\n    client_builder\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189",
+      "before_imports": [
+        "use router_env::logger;"
+      ],
+      "after_imports": [
+        "use router_env::{logger, metric_attributes};"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    Ok(DEFAULT_CLIENT\n        .get_or_try_init(|| {\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct base client\")\n        })?\n        .clone())\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        // Create simple metrics attributes for proxy client tracking\n        let http_proxy_host = extract_proxy_host(&proxy_config.http_url);\n        let https_proxy_host = extract_proxy_host(&proxy_config.https_url);\n            \n        let proxy_metrics_tag = metric_attributes!(\n            (\"client_type\", \"proxy\"),\n            (\"http_proxy_host\", http_proxy_host),\n            (\"https_proxy_host\", https_proxy_host)\n        );\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, proxy_metrics_tag.clone());\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, default_metrics_tag.clone());\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, default_metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    Ok(DEFAULT_CLIENT\n        .get_or_try_init(|| {\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct base client\")\n        })?\n        .clone())\n}",
+        "after": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        // Create simple metrics attributes for proxy client tracking\n        let http_proxy_host = extract_proxy_host(&proxy_config.http_url);\n        let https_proxy_host = extract_proxy_host(&proxy_config.https_url);\n            \n        let proxy_metrics_tag = metric_attributes!(\n            (\"client_type\", \"proxy\"),\n            (\"http_proxy_host\", http_proxy_host),\n            (\"https_proxy_host\", https_proxy_host)\n        );\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, proxy_metrics_tag.clone());\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, default_metrics_tag.clone());\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, default_metrics_tag);\n        Ok(client)\n    }\n}"
+      },
+      "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189",
+      "before_imports": [
+        "pub use common_utils::errors::CustomResult;"
+      ],
+      "after_imports": [
+        "pub use common_utils::errors::CustomResult;",
+        "use super::metrics;",
+        "use router_env::{logger, metric_attributes};"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::has_proxy_config",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }",
+      "diff_span": null,
+      "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::cache_key",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        Some(format!(\n            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"), \n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }",
+      "diff_span": null,
+      "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::extract_proxy_host",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn extract_proxy_host(url_opt: &Option<String>) -> String {\n    url_opt.as_ref()\n        .and_then(|url| url::Url::parse(url).ok())\n        .and_then(|parsed_url| parsed_url.host_str().map(|s| s.to_string()))\n        .unwrap_or_else(|| \"none\".to_string())\n}",
+      "diff_span": null,
+      "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::impl::Proxy",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        Some(format!(\n            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"), \n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }\n    \n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::static::PROXY_CLIENT_CACHE",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "static_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "static PROXY_CLIENT_CACHE: OnceCell<Mutex<HashMap<String, reqwest::Client>>> = OnceCell::new();",
+      "diff_span": null,
+      "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::trait::ProxyClientCacheKey",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "trait_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "trait ProxyClientCacheKey {\n    fn cache_key(&self) -> Option<String>;\n    fn has_proxy_config(&self) -> bool;\n}",
+      "diff_span": null,
+      "commit_sha": "0227ec9fd783b51703a8540cdba5d93e5116b189"
+    }
+  ]
+}

diffs/pr_10158/0c2988e/diff.json

@@ -0,0 +1,44 @@
+{
+  "commit_sha": "0c2988e33c70ab79c7366a454044e85eb67aebeb",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Ok(read_lock) = cache.read() {\n            if let Some(cached_client) = read_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                drop(read_lock);\n                create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n            }\n        } else {\n            create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = get_or_create_proxy_client(cache, cache_key, proxy_config, metrics_tag)?;\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Ok(read_lock) = cache.read() {\n            if let Some(cached_client) = read_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                drop(read_lock);\n                create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n            }\n        } else {\n            create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n        };\n\n        Ok(client)",
+        "after": "        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = get_or_create_proxy_client(cache, cache_key, proxy_config, metrics_tag)?;\n\n        Ok(client)"
+      },
+      "commit_sha": "0c2988e33c70ab79c7366a454044e85eb67aebeb"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_or_create_proxy_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_or_create_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    // First try read lock - fastest path for cache hits\n    if let Ok(read_lock) = cache.read() {\n        if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(cached_client.clone());\n        }\n    }\n\n    // Cache miss - need to create new client with write lock\n    let mut write_lock = cache.try_write().map_err(|_| {\n        error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to acquire proxy client cache write lock\")\n    })?;\n\n    // Double-check pattern: another thread might have created it\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        return Ok(cached_client.clone());\n    }\n\n    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n    let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n        .build()\n        .change_context(HttpClientError::ClientConstructionFailed)\n        .attach_printable(\"Failed to construct proxy client\")?;\n\n    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n    write_lock.insert(cache_key.clone(), new_client.clone());\n    logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n    \n    Ok(new_client)\n}",
+      "diff_span": null,
+      "commit_sha": "0c2988e33c70ab79c7366a454044e85eb67aebeb"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::create_new_proxy_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn create_new_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    let mut write_lock = cache.try_write().map_err(|_| {\n        error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to acquire proxy client cache write lock\")\n    })?;\n\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(cached_client.clone())\n    } else {\n        logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n        let new_client =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n\n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n        write_lock.insert(cache_key.clone(), new_client.clone());\n        logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n        Ok(new_client)\n    }\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "0c2988e33c70ab79c7366a454044e85eb67aebeb"
+    }
+  ]
+}

diffs/pr_10158/152e71c/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "152e71caee0a59c3c7df5592be0384891c4b00d3",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {:?}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {:?}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n            let new_client =\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct proxy client\")?;\n\n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n            new_client\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {",
+        "after": "                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n            let new_client =\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct proxy client\")?;\n\n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n            new_client\n        };\n\n        Ok(client)\n    } else {"
+      },
+      "commit_sha": "152e71caee0a59c3c7df5592be0384891c4b00d3"
+    }
+  ]
+}

diffs/pr_10158/1aaa136/diff.json

@@ -0,0 +1,165 @@
+{
+  "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/api_models/src/webhooks.rs",
+    "crates/common_enums/src/enums.rs",
+    "crates/hyperswitch_connectors/src/connectors/adyenplatform.rs",
+    "crates/hyperswitch_connectors/src/connectors/adyenplatform/transformers/payouts.rs",
+    "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+    "crates/hyperswitch_interfaces/src/webhooks.rs",
+    "crates/router/src/core/webhooks/incoming.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::process_webhook_business_logic",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn process_webhook_business_logic(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_context: &domain::MerchantContext,\n    connector: &ConnectorEnum,\n    connector_name: &str,\n    event_type: webhooks::IncomingWebhookEvent,\n    source_verified_via_ucs: bool,\n    webhook_transform_data: &Option<Box<unified_connector_service::WebhookTransformData>>,\n    shadow_ucs_data: &mut Option<ShadowUcsData<'_>>,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    is_relay_webhook: bool,\n) -> errors::RouterResult<WebhookResponseTracker> {\n    let object_ref_id = connector\n        .get_webhook_object_reference_id(request_details)\n        .switch()\n        .attach_printable(\"Could not find object reference id in incoming webhook body\")?;\n    let connector_enum = Connector::from_str(connector_name)\n        .change_context(errors::ApiErrorResponse::InvalidDataValue {\n            field_name: \"connector\",\n        })\n        .attach_printable_lazy(|| format!(\"unable to parse connector name {connector_name:?}\"))?;\n    let connectors_with_source_verification_call = &state.conf.webhook_source_verification_call;\n\n    let merchant_connector_account = match Box::pin(helper_utils::get_mca_from_object_reference_id(\n        state,\n        object_ref_id.clone(),\n        merchant_context,\n        connector_name,\n    ))\n    .await\n    {\n        Ok(mca) => mca,\n        Err(error) => {\n            let result = handle_incoming_webhook_error(\n                error,\n                connector,\n                connector_name,\n                request_details,\n                merchant_context.get_merchant_account().get_id(),\n            );\n            match result {\n                Ok((_, webhook_tracker, _)) => return Ok(webhook_tracker),\n                Err(e) => return Err(e),\n            }\n        }\n    };\n\n    let source_verified = if source_verified_via_ucs {\n        // If UCS handled verification, use that result\n        source_verified_via_ucs\n    } else {\n        // Fall back to traditional source verification\n        if connectors_with_source_verification_call\n            .connectors_with_webhook_source_verification_call\n            .contains(&connector_enum)\n        {\n            verify_webhook_source_verification_call(\n                connector.clone(),\n                state,\n                merchant_context,\n                merchant_connector_account.clone(),\n                connector_name,\n                request_details,\n            )\n            .await\n            .or_else(|error| match error.current_context() {\n                errors::ConnectorError::WebhookSourceVerificationFailed => {\n                    logger::error!(?error, \"Source Verification Failed\");\n                    Ok(false)\n                }\n                _ => Err(error),\n            })\n            .switch()\n            .attach_printable(\"There was an issue in incoming webhook source verification\")?\n        } else {\n            connector\n                .clone()\n                .verify_webhook_source(\n                    request_details,\n                    merchant_context.get_merchant_account().get_id(),\n                    merchant_connector_account.connector_webhook_details.clone(),\n                    merchant_connector_account.connector_account_details.clone(),\n                    connector_name,\n                )\n                .await\n                .or_else(|error| match error.current_context() {\n                    errors::ConnectorError::WebhookSourceVerificationFailed => {\n                        logger::error!(?error, \"Source Verification Failed\");\n                        Ok(false)\n                    }\n                    _ => Err(error),\n                })\n                .switch()\n                .attach_printable(\"There was an issue in incoming webhook source verification\")?\n        }\n    };\n\n    if source_verified {\n        metrics::WEBHOOK_SOURCE_VERIFIED_COUNT.add(\n            1,\n            router_env::metric_attributes!((\n                MERCHANT_ID,\n                merchant_context.get_merchant_account().get_id().clone()\n            )),\n        );\n    } else if connector.is_webhook_source_verification_mandatory() {\n        // if webhook consumption is mandatory for connector, fail webhook\n        // so that merchant can retrigger it after updating merchant_secret\n        return Err(errors::ApiErrorResponse::WebhookAuthenticationFailed.into());\n    }\n\n    logger::info!(source_verified=?source_verified);\n\n    let event_object: Box<dyn masking::ErasedMaskSerialize> = match webhook_transform_data {\n        Some(webhook_transform_data) => {\n            // Extract resource_object from UCS webhook content\n            webhook_transform_data\n                .webhook_content\n                .as_ref()\n                .map(|webhook_response_content| {\n                    get_ucs_webhook_resource_object(webhook_response_content)\n                })\n                .unwrap_or_else(|| {\n                    // Fall back to connector extraction\n                    connector\n                        .get_webhook_resource_object(request_details)\n                        .switch()\n                        .attach_printable(\"Could not find resource object in incoming webhook body\")\n                })?\n        }\n        None => {\n            // Use traditional connector extraction\n            connector\n                .get_webhook_resource_object(request_details)\n                .switch()\n                .attach_printable(\"Could not find resource object in incoming webhook body\")?\n        }\n    };\n\n    let webhook_details = api::IncomingWebhookDetails {\n        object_reference_id: object_ref_id.clone(),\n        resource_object: serde_json::to_vec(&event_object)\n            .change_context(errors::ParsingError::EncodeError(\"byte-vec\"))\n            .attach_printable(\"Unable to convert webhook payload to a value\")\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\n                \"There was an issue when encoding the incoming webhook body to bytes\",\n            )?,\n    };\n\n    // Create shadow_event_object and shadow_webhook_details using shadow UCS data\n    let shadow_event_object: Option<Box<dyn masking::ErasedMaskSerialize>> =\n        shadow_ucs_data.as_ref().and_then(|shadow_data| {\n            // Create shadow event object using UCS transform data and shadow request details\n            let shadow_event_result = shadow_data\n                .ucs_transform_data\n                .webhook_content\n                .as_ref()\n                .map(|webhook_response_content| {\n                    get_ucs_webhook_resource_object(webhook_response_content)\n                })\n                .unwrap_or_else(|| {\n                    // Fall back to connector extraction using shadow request details\n                    connector\n                        .get_webhook_resource_object(shadow_data.request_details)\n                        .switch()\n                        .attach_printable(\n                            \"Could not find resource object in shadow incoming webhook body\",\n                        )\n                });\n\n            match shadow_event_result {\n                Ok(shadow_obj) => Some(shadow_obj),\n                Err(error) => {\n                    logger::warn!(\n                        connector = connector_name,\n                        merchant_id = ?merchant_context.get_merchant_account().get_id(),\n                        error = ?error,\n                        \"Failed to create shadow event object from UCS transform data\"\n                    );\n                    None\n                }\n            }\n        });\n\n    let shadow_webhook_details: Option<api::IncomingWebhookDetails> =\n        shadow_event_object.as_ref().and_then(|shadow_obj| {\n            let resource_object_result = serde_json::to_vec(shadow_obj)\n                .change_context(errors::ParsingError::EncodeError(\"byte-vec\"))\n                .attach_printable(\"Unable to convert shadow webhook payload to a value\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\n                    \"There was an issue when encoding the shadow incoming webhook body to bytes\",\n                );\n\n            match resource_object_result {\n                Ok(resource_object) => Some(api::IncomingWebhookDetails {\n                    object_reference_id: object_ref_id.clone(),\n                    resource_object,\n                }),\n                Err(error) => {\n                    logger::warn!(\n                        connector = connector_name,\n                        merchant_id = ?merchant_context.get_merchant_account().get_id(),\n                        error = ?error,\n                        \"Failed to serialize shadow webhook payload to bytes\"\n                    );\n                    None\n                }\n            }\n        });\n\n    // Assign shadow_webhook_details to shadow_ucs_data\n    if let Some(shadow_data) = shadow_ucs_data.as_mut() {\n        shadow_data.webhook_details = shadow_webhook_details;\n    }\n\n    let profile_id = &merchant_connector_account.profile_id;\n    let key_manager_state = &(state).into();\n\n    let business_profile = state\n        .store\n        .find_business_profile_by_profile_id(\n            key_manager_state,\n            merchant_context.get_merchant_key_store(),\n            profile_id,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {\n            id: profile_id.get_string_repr().to_owned(),\n        })?;\n\n    // If the incoming webhook is a relay webhook, then we need to trigger the relay webhook flow\n    let result_response = if is_relay_webhook {\n        let relay_webhook_response = Box::pin(relay_incoming_webhook_flow(\n            state.clone(),\n            merchant_context.clone(),\n            business_profile,\n            webhook_details,\n            event_type,\n            source_verified,\n        ))\n        .await\n        .attach_printable(\"Incoming webhook flow for relay failed\");\n\n        // Using early return ensures unsupported webhooks are acknowledged to the connector\n        if let Some(errors::ApiErrorResponse::NotSupported { .. }) = relay_webhook_response\n            .as_ref()\n            .err()\n            .map(|a| a.current_context())\n        {\n            logger::error!(\n                webhook_payload =? request_details.body,\n                \"Failed while identifying the event type\",\n            );\n\n            let _response = connector\n                    .get_webhook_api_response(request_details, None)\n                    .switch()\n                    .attach_printable(\n                        \"Failed while early return in case of not supported event type in relay webhooks\",\n                    )?;\n\n            return Ok(WebhookResponseTracker::NoEffect);\n        };\n\n        relay_webhook_response\n    } else {\n        let flow_type: api::WebhookFlow = event_type.into();\n        match flow_type {\n            api::WebhookFlow::Payment => Box::pin(payments_incoming_webhook_flow(\n                state.clone(),\n                req_state,\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                source_verified,\n                connector,\n                request_details,\n                event_type,\n                webhook_transform_data,\n                shadow_ucs_data,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for payments failed\"),\n\n            api::WebhookFlow::Refund => Box::pin(refunds_incoming_webhook_flow(\n                state.clone(),\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                connector_name,\n                source_verified,\n                event_type,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for refunds failed\"),\n\n            api::WebhookFlow::Dispute => Box::pin(disputes_incoming_webhook_flow(\n                state.clone(),\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                source_verified,\n                connector,\n                request_details,\n                event_type,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for disputes failed\"),\n\n            api::WebhookFlow::BankTransfer => Box::pin(bank_transfer_webhook_flow(\n                state.clone(),\n                req_state,\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                source_verified,\n            ))\n            .await\n            .attach_printable(\"Incoming bank-transfer webhook flow failed\"),\n\n            api::WebhookFlow::ReturnResponse => Ok(WebhookResponseTracker::NoEffect),\n\n            api::WebhookFlow::Mandate => Box::pin(mandates_incoming_webhook_flow(\n                state.clone(),\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                source_verified,\n                event_type,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for mandates failed\"),\n\n            api::WebhookFlow::ExternalAuthentication => {\n                Box::pin(external_authentication_incoming_webhook_flow(\n                    state.clone(),\n                    req_state,\n                    merchant_context.clone(),\n                    source_verified,\n                    event_type,\n                    request_details,\n                    connector,\n                    object_ref_id,\n                    business_profile,\n                    merchant_connector_account,\n                ))\n                .await\n                .attach_printable(\"Incoming webhook flow for external authentication failed\")\n            }\n            api::WebhookFlow::FraudCheck => Box::pin(frm_incoming_webhook_flow(\n                state.clone(),\n                req_state,\n                merchant_context.clone(),\n                source_verified,\n                event_type,\n                object_ref_id,\n                business_profile,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for fraud check failed\"),\n\n            #[cfg(feature = \"payouts\")]\n            api::WebhookFlow::Payout => Box::pin(payouts_incoming_webhook_flow(\n                state.clone(),\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                event_type,\n                source_verified,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for payouts failed\"),\n\n            api::WebhookFlow::Subscription => {\n                Box::pin(subscriptions::webhooks::incoming_webhook_flow(\n                    state.clone().into(),\n                    merchant_context.clone(),\n                    business_profile,\n                    webhook_details,\n                    source_verified,\n                    connector,\n                    request_details,\n                    event_type,\n                    merchant_connector_account,\n                ))\n                .await\n                .attach_printable(\"Incoming webhook flow for subscription failed\")\n            }\n\n            _ => Err(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Unsupported Flow Type received in incoming webhooks\"),\n        }\n    };\n\n    match result_response {\n        Ok(response) => Ok(response),\n        Err(error) => {\n            let result = handle_incoming_webhook_error(\n                error,\n                connector,\n                connector_name,\n                request_details,\n                merchant_context.get_merchant_account().get_id(),\n            );\n            match result {\n                Ok((_, webhook_tracker, _)) => Ok(webhook_tracker),\n                Err(e) => Err(e),\n            }\n        }\n    }\n}",
+      "after_code": "async fn process_webhook_business_logic(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_context: &domain::MerchantContext,\n    connector: &ConnectorEnum,\n    connector_name: &str,\n    event_type: webhooks::IncomingWebhookEvent,\n    source_verified_via_ucs: bool,\n    webhook_transform_data: &Option<Box<unified_connector_service::WebhookTransformData>>,\n    shadow_ucs_data: &mut Option<ShadowUcsData<'_>>,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    is_relay_webhook: bool,\n) -> errors::RouterResult<WebhookResponseTracker> {\n    let object_ref_id = connector\n        .get_webhook_object_reference_id(request_details)\n        .switch()\n        .attach_printable(\"Could not find object reference id in incoming webhook body\")?;\n    let connector_enum = Connector::from_str(connector_name)\n        .change_context(errors::ApiErrorResponse::InvalidDataValue {\n            field_name: \"connector\",\n        })\n        .attach_printable_lazy(|| format!(\"unable to parse connector name {connector_name:?}\"))?;\n    let connectors_with_source_verification_call = &state.conf.webhook_source_verification_call;\n\n    let merchant_connector_account = match Box::pin(helper_utils::get_mca_from_object_reference_id(\n        state,\n        object_ref_id.clone(),\n        merchant_context,\n        connector_name,\n    ))\n    .await\n    {\n        Ok(mca) => mca,\n        Err(error) => {\n            let result = handle_incoming_webhook_error(\n                error,\n                connector,\n                connector_name,\n                request_details,\n                merchant_context.get_merchant_account().get_id(),\n            );\n            match result {\n                Ok((_, webhook_tracker, _)) => return Ok(webhook_tracker),\n                Err(e) => return Err(e),\n            }\n        }\n    };\n\n    let source_verified = if source_verified_via_ucs {\n        // If UCS handled verification, use that result\n        source_verified_via_ucs\n    } else {\n        // Fall back to traditional source verification\n        if connectors_with_source_verification_call\n            .connectors_with_webhook_source_verification_call\n            .contains(&connector_enum)\n        {\n            verify_webhook_source_verification_call(\n                connector.clone(),\n                state,\n                merchant_context,\n                merchant_connector_account.clone(),\n                connector_name,\n                request_details,\n            )\n            .await\n            .or_else(|error| match error.current_context() {\n                errors::ConnectorError::WebhookSourceVerificationFailed => {\n                    logger::error!(?error, \"Source Verification Failed\");\n                    Ok(false)\n                }\n                _ => Err(error),\n            })\n            .switch()\n            .attach_printable(\"There was an issue in incoming webhook source verification\")?\n        } else {\n            connector\n                .clone()\n                .verify_webhook_source(\n                    request_details,\n                    merchant_context.get_merchant_account().get_id(),\n                    merchant_connector_account.connector_webhook_details.clone(),\n                    merchant_connector_account.connector_account_details.clone(),\n                    connector_name,\n                )\n                .await\n                .or_else(|error| match error.current_context() {\n                    errors::ConnectorError::WebhookSourceVerificationFailed => {\n                        logger::error!(?error, \"Source Verification Failed\");\n                        Ok(false)\n                    }\n                    _ => Err(error),\n                })\n                .switch()\n                .attach_printable(\"There was an issue in incoming webhook source verification\")?\n        }\n    };\n\n    if source_verified {\n        metrics::WEBHOOK_SOURCE_VERIFIED_COUNT.add(\n            1,\n            router_env::metric_attributes!((\n                MERCHANT_ID,\n                merchant_context.get_merchant_account().get_id().clone()\n            )),\n        );\n    } else if connector.is_webhook_source_verification_mandatory() {\n        // if webhook consumption is mandatory for connector, fail webhook\n        // so that merchant can retrigger it after updating merchant_secret\n        return Err(errors::ApiErrorResponse::WebhookAuthenticationFailed.into());\n    }\n\n    logger::info!(source_verified=?source_verified);\n\n    let event_object: Box<dyn masking::ErasedMaskSerialize> = match webhook_transform_data {\n        Some(webhook_transform_data) => {\n            // Extract resource_object from UCS webhook content\n            webhook_transform_data\n                .webhook_content\n                .as_ref()\n                .map(|webhook_response_content| {\n                    get_ucs_webhook_resource_object(webhook_response_content)\n                })\n                .unwrap_or_else(|| {\n                    // Fall back to connector extraction\n                    connector\n                        .get_webhook_resource_object(request_details)\n                        .switch()\n                        .attach_printable(\"Could not find resource object in incoming webhook body\")\n                })?\n        }\n        None => {\n            // Use traditional connector extraction\n            connector\n                .get_webhook_resource_object(request_details)\n                .switch()\n                .attach_printable(\"Could not find resource object in incoming webhook body\")?\n        }\n    };\n\n    let webhook_details = api::IncomingWebhookDetails {\n        object_reference_id: object_ref_id.clone(),\n        resource_object: serde_json::to_vec(&event_object)\n            .change_context(errors::ParsingError::EncodeError(\"byte-vec\"))\n            .attach_printable(\"Unable to convert webhook payload to a value\")\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\n                \"There was an issue when encoding the incoming webhook body to bytes\",\n            )?,\n    };\n\n    // Create shadow_event_object and shadow_webhook_details using shadow UCS data\n    let shadow_event_object: Option<Box<dyn masking::ErasedMaskSerialize>> =\n        shadow_ucs_data.as_ref().and_then(|shadow_data| {\n            // Create shadow event object using UCS transform data and shadow request details\n            let shadow_event_result = shadow_data\n                .ucs_transform_data\n                .webhook_content\n                .as_ref()\n                .map(|webhook_response_content| {\n                    get_ucs_webhook_resource_object(webhook_response_content)\n                })\n                .unwrap_or_else(|| {\n                    // Fall back to connector extraction using shadow request details\n                    connector\n                        .get_webhook_resource_object(shadow_data.request_details)\n                        .switch()\n                        .attach_printable(\n                            \"Could not find resource object in shadow incoming webhook body\",\n                        )\n                });\n\n            match shadow_event_result {\n                Ok(shadow_obj) => Some(shadow_obj),\n                Err(error) => {\n                    logger::warn!(\n                        connector = connector_name,\n                        merchant_id = ?merchant_context.get_merchant_account().get_id(),\n                        error = ?error,\n                        \"Failed to create shadow event object from UCS transform data\"\n                    );\n                    None\n                }\n            }\n        });\n\n    let shadow_webhook_details: Option<api::IncomingWebhookDetails> =\n        shadow_event_object.as_ref().and_then(|shadow_obj| {\n            let resource_object_result = serde_json::to_vec(shadow_obj)\n                .change_context(errors::ParsingError::EncodeError(\"byte-vec\"))\n                .attach_printable(\"Unable to convert shadow webhook payload to a value\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\n                    \"There was an issue when encoding the shadow incoming webhook body to bytes\",\n                );\n\n            match resource_object_result {\n                Ok(resource_object) => Some(api::IncomingWebhookDetails {\n                    object_reference_id: object_ref_id.clone(),\n                    resource_object,\n                }),\n                Err(error) => {\n                    logger::warn!(\n                        connector = connector_name,\n                        merchant_id = ?merchant_context.get_merchant_account().get_id(),\n                        error = ?error,\n                        \"Failed to serialize shadow webhook payload to bytes\"\n                    );\n                    None\n                }\n            }\n        });\n\n    // Assign shadow_webhook_details to shadow_ucs_data\n    if let Some(shadow_data) = shadow_ucs_data.as_mut() {\n        shadow_data.webhook_details = shadow_webhook_details;\n    }\n\n    let profile_id = &merchant_connector_account.profile_id;\n    let key_manager_state = &(state).into();\n\n    let business_profile = state\n        .store\n        .find_business_profile_by_profile_id(\n            key_manager_state,\n            merchant_context.get_merchant_key_store(),\n            profile_id,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {\n            id: profile_id.get_string_repr().to_owned(),\n        })?;\n\n    // If the incoming webhook is a relay webhook, then we need to trigger the relay webhook flow\n    let result_response = if is_relay_webhook {\n        let relay_webhook_response = Box::pin(relay_incoming_webhook_flow(\n            state.clone(),\n            merchant_context.clone(),\n            business_profile,\n            webhook_details,\n            event_type,\n            source_verified,\n        ))\n        .await\n        .attach_printable(\"Incoming webhook flow for relay failed\");\n\n        // Using early return ensures unsupported webhooks are acknowledged to the connector\n        if let Some(errors::ApiErrorResponse::NotSupported { .. }) = relay_webhook_response\n            .as_ref()\n            .err()\n            .map(|a| a.current_context())\n        {\n            logger::error!(\n                webhook_payload =? request_details.body,\n                \"Failed while identifying the event type\",\n            );\n\n            let _response = connector\n                    .get_webhook_api_response(request_details, None)\n                    .switch()\n                    .attach_printable(\n                        \"Failed while early return in case of not supported event type in relay webhooks\",\n                    )?;\n\n            return Ok(WebhookResponseTracker::NoEffect);\n        };\n\n        relay_webhook_response\n    } else {\n        let flow_type: api::WebhookFlow = event_type.into();\n        match flow_type {\n            api::WebhookFlow::Payment => Box::pin(payments_incoming_webhook_flow(\n                state.clone(),\n                req_state,\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                source_verified,\n                connector,\n                request_details,\n                event_type,\n                webhook_transform_data,\n                shadow_ucs_data,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for payments failed\"),\n\n            api::WebhookFlow::Refund => Box::pin(refunds_incoming_webhook_flow(\n                state.clone(),\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                connector_name,\n                source_verified,\n                event_type,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for refunds failed\"),\n\n            api::WebhookFlow::Dispute => Box::pin(disputes_incoming_webhook_flow(\n                state.clone(),\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                source_verified,\n                connector,\n                request_details,\n                event_type,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for disputes failed\"),\n\n            api::WebhookFlow::BankTransfer => Box::pin(bank_transfer_webhook_flow(\n                state.clone(),\n                req_state,\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                source_verified,\n            ))\n            .await\n            .attach_printable(\"Incoming bank-transfer webhook flow failed\"),\n\n            api::WebhookFlow::ReturnResponse => Ok(WebhookResponseTracker::NoEffect),\n\n            api::WebhookFlow::Mandate => Box::pin(mandates_incoming_webhook_flow(\n                state.clone(),\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                source_verified,\n                event_type,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for mandates failed\"),\n\n            api::WebhookFlow::ExternalAuthentication => {\n                Box::pin(external_authentication_incoming_webhook_flow(\n                    state.clone(),\n                    req_state,\n                    merchant_context.clone(),\n                    source_verified,\n                    event_type,\n                    request_details,\n                    connector,\n                    object_ref_id,\n                    business_profile,\n                    merchant_connector_account,\n                ))\n                .await\n                .attach_printable(\"Incoming webhook flow for external authentication failed\")\n            }\n            api::WebhookFlow::FraudCheck => Box::pin(frm_incoming_webhook_flow(\n                state.clone(),\n                req_state,\n                merchant_context.clone(),\n                source_verified,\n                event_type,\n                object_ref_id,\n                business_profile,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for fraud check failed\"),\n\n            #[cfg(feature = \"payouts\")]\n            api::WebhookFlow::Payout => Box::pin(payouts_incoming_webhook_flow(\n                state.clone(),\n                merchant_context.clone(),\n                business_profile,\n                webhook_details,\n                event_type,\n                source_verified,\n                request_details,\n                connector,\n            ))\n            .await\n            .attach_printable(\"Incoming webhook flow for payouts failed\"),\n\n            api::WebhookFlow::Subscription => {\n                Box::pin(subscriptions::webhooks::incoming_webhook_flow(\n                    state.clone().into(),\n                    merchant_context.clone(),\n                    business_profile,\n                    webhook_details,\n                    source_verified,\n                    connector,\n                    request_details,\n                    event_type,\n                    merchant_connector_account,\n                ))\n                .await\n                .attach_printable(\"Incoming webhook flow for subscription failed\")\n            }\n\n            _ => Err(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Unsupported Flow Type received in incoming webhooks\"),\n        }\n    };\n\n    match result_response {\n        Ok(response) => Ok(response),\n        Err(error) => {\n            let result = handle_incoming_webhook_error(\n                error,\n                connector,\n                connector_name,\n                request_details,\n                merchant_context.get_merchant_account().get_id(),\n            );\n            match result {\n                Ok((_, webhook_tracker, _)) => Ok(webhook_tracker),\n                Err(e) => Err(e),\n            }\n        }\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": "                event_type,\n                source_verified,\n                request_details,\n                connector,\n            ))\n            .await"
+      },
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/adyenplatform/transformers/payouts.rs::struct::AdyenplatformTrackingData",
+      "file": "crates/hyperswitch_connectors/src/connectors/adyenplatform/transformers/payouts.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct AdyenplatformTrackingData {\n    status: TrackingStatus,\n    estimated_arrival_time: Option<String>,\n}",
+      "after_code": "pub struct AdyenplatformTrackingData {\n    pub status: TrackingStatus,\n    pub reason: Option<String>,\n    pub estimated_arrival_time: Option<String>,\n}",
+      "diff_span": {
+        "before": "pub struct AdyenplatformTrackingData {\n    status: TrackingStatus,\n    estimated_arrival_time: Option<String>,\n}",
+        "after": "pub struct AdyenplatformTrackingData {\n    pub status: TrackingStatus,\n    pub reason: Option<String>,\n    pub estimated_arrival_time: Option<String>,\n}"
+      },
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/webhooks.rs::trait::IncomingWebhook",
+      "file": "crates/hyperswitch_interfaces/src/webhooks.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub trait IncomingWebhook: ConnectorCommon + Sync {\n    /// fn get_webhook_body_decoding_algorithm\n    fn get_webhook_body_decoding_algorithm(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<Box<dyn crypto::DecodeMessage + Send>, errors::ConnectorError> {\n        Ok(Box::new(crypto::NoAlgorithm))\n    }\n\n    /// fn get_webhook_body_decoding_message\n    fn get_webhook_body_decoding_message(\n        &self,\n        request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        Ok(request.body.to_vec())\n    }\n\n    /// fn decode_webhook_body\n    async fn decode_webhook_body(\n        &self,\n        request: &IncomingWebhookRequestDetails<'_>,\n        merchant_id: &common_utils::id_type::MerchantId,\n        connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,\n        connector_name: &str,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        let algorithm = self.get_webhook_body_decoding_algorithm(request)?;\n\n        let message = self\n            .get_webhook_body_decoding_message(request)\n            .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;\n        let secret = self\n            .get_webhook_source_verification_merchant_secret(\n                merchant_id,\n                connector_name,\n                connector_webhook_details,\n            )\n            .await\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n\n        algorithm\n            .decode_message(&secret.secret, message.into())\n            .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)\n    }\n\n    /// fn get_webhook_source_verification_algorithm\n    fn get_webhook_source_verification_algorithm(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {\n        Ok(Box::new(crypto::NoAlgorithm))\n    }\n\n    /// fn get_webhook_source_verification_merchant_secret\n    async fn get_webhook_source_verification_merchant_secret(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        connector_name: &str,\n        connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,\n    ) -> CustomResult<api_models::webhooks::ConnectorWebhookSecrets, errors::ConnectorError> {\n        let debug_suffix =\n            format!(\"For merchant_id: {merchant_id:?}, and connector_name: {connector_name}\");\n        let default_secret = \"default_secret\".to_string();\n        let merchant_secret = match connector_webhook_details {\n            Some(merchant_connector_webhook_details) => {\n                let connector_webhook_details = merchant_connector_webhook_details\n                    .parse_value::<api_models::admin::MerchantConnectorWebhookDetails>(\n                        \"MerchantConnectorWebhookDetails\",\n                    )\n                    .change_context_lazy(|| errors::ConnectorError::WebhookSourceVerificationFailed)\n                    .attach_printable_lazy(|| {\n                        format!(\n                            \"Deserializing MerchantConnectorWebhookDetails failed {debug_suffix}\",\n                        )\n                    })?;\n                api_models::webhooks::ConnectorWebhookSecrets {\n                    secret: connector_webhook_details\n                        .merchant_secret\n                        .expose()\n                        .into_bytes(),\n                    additional_secret: connector_webhook_details.additional_secret,\n                }\n            }\n\n            None => api_models::webhooks::ConnectorWebhookSecrets {\n                secret: default_secret.into_bytes(),\n                additional_secret: None,\n            },\n        };\n\n        //need to fetch merchant secret from config table with caching in future for enhanced performance\n\n        //If merchant has not set the secret for webhook source verification, \"default_secret\" is returned.\n        //So it will fail during verification step and goes to psync flow.\n        Ok(merchant_secret)\n    }\n\n    /// fn get_webhook_source_verification_signature\n    fn get_webhook_source_verification_signature(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        Ok(Vec::new())\n    }\n\n    /// fn get_webhook_source_verification_message\n    fn get_webhook_source_verification_message(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        Ok(Vec::new())\n    }\n\n    /// fn verify_webhook_source\n    async fn verify_webhook_source(\n        &self,\n        request: &IncomingWebhookRequestDetails<'_>,\n        merchant_id: &common_utils::id_type::MerchantId,\n        connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,\n        _connector_account_details: crypto::Encryptable<Secret<serde_json::Value>>,\n        connector_name: &str,\n    ) -> CustomResult<bool, errors::ConnectorError> {\n        let algorithm = self\n            .get_webhook_source_verification_algorithm(request)\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n\n        let connector_webhook_secrets = self\n            .get_webhook_source_verification_merchant_secret(\n                merchant_id,\n                connector_name,\n                connector_webhook_details,\n            )\n            .await\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n\n        let signature = self\n            .get_webhook_source_verification_signature(request, &connector_webhook_secrets)\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n\n        let message = self\n            .get_webhook_source_verification_message(\n                request,\n                merchant_id,\n                &connector_webhook_secrets,\n            )\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n\n        algorithm\n            .verify_signature(&connector_webhook_secrets.secret, &signature, &message)\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)\n    }\n\n    /// fn get_webhook_object_reference_id\n    fn get_webhook_object_reference_id(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError>;\n\n    /// fn get_webhook_event_type\n    fn get_webhook_event_type(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError>;\n\n    /// fn get_webhook_resource_object\n    fn get_webhook_resource_object(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError>;\n\n    /// fn get_webhook_api_response\n    fn get_webhook_api_response(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n        _error_kind: Option<IncomingWebhookFlowError>,\n    ) -> CustomResult<ApplicationResponse<serde_json::Value>, errors::ConnectorError> {\n        Ok(ApplicationResponse::StatusOk)\n    }\n\n    /// fn get_dispute_details\n    fn get_dispute_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<crate::disputes::DisputePayload, errors::ConnectorError> {\n        Err(errors::ConnectorError::NotImplemented(\"get_dispute_details method\".to_string()).into())\n    }\n\n    /// fn get_external_authentication_details\n    fn get_external_authentication_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<crate::authentication::ExternalAuthenticationPayload, errors::ConnectorError>\n    {\n        Err(errors::ConnectorError::NotImplemented(\n            \"get_external_authentication_details method\".to_string(),\n        )\n        .into())\n    }\n\n    /// fn get_mandate_details\n    fn get_mandate_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<\n        Option<hyperswitch_domain_models::router_flow_types::ConnectorMandateDetails>,\n        errors::ConnectorError,\n    > {\n        Ok(None)\n    }\n\n    /// fn get_network_txn_id\n    fn get_network_txn_id(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<\n        Option<hyperswitch_domain_models::router_flow_types::ConnectorNetworkTxnId>,\n        errors::ConnectorError,\n    > {\n        Ok(None)\n    }\n\n    #[cfg(all(feature = \"revenue_recovery\", feature = \"v2\"))]\n    /// get revenue recovery invoice details\n    fn get_revenue_recovery_attempt_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<\n        hyperswitch_domain_models::revenue_recovery::RevenueRecoveryAttemptData,\n        errors::ConnectorError,\n    > {\n        Err(errors::ConnectorError::NotImplemented(\n            \"get_revenue_recovery_attempt_details method\".to_string(),\n        )\n        .into())\n    }\n    #[cfg(all(feature = \"revenue_recovery\", feature = \"v2\"))]\n    /// get revenue recovery transaction details\n    fn get_revenue_recovery_invoice_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<\n        hyperswitch_domain_models::revenue_recovery::RevenueRecoveryInvoiceData,\n        errors::ConnectorError,\n    > {\n        Err(errors::ConnectorError::NotImplemented(\n            \"get_revenue_recovery_invoice_details method\".to_string(),\n        )\n        .into())\n    }\n\n    /// get subscription MIT payment data from webhook\n    fn get_subscription_mit_payment_data(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<\n        hyperswitch_domain_models::router_flow_types::SubscriptionMitPaymentData,\n        errors::ConnectorError,\n    > {\n        Err(errors::ConnectorError::NotImplemented(\n            \"get_subscription_mit_payment_data method\".to_string(),\n        )\n        .into())\n    }\n}",
+      "after_code": "pub trait IncomingWebhook: ConnectorCommon + Sync {\n    /// fn get_webhook_body_decoding_algorithm\n    fn get_webhook_body_decoding_algorithm(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<Box<dyn crypto::DecodeMessage + Send>, errors::ConnectorError> {\n        Ok(Box::new(crypto::NoAlgorithm))\n    }\n\n    /// fn get_webhook_body_decoding_message\n    fn get_webhook_body_decoding_message(\n        &self,\n        request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        Ok(request.body.to_vec())\n    }\n\n    /// fn decode_webhook_body\n    async fn decode_webhook_body(\n        &self,\n        request: &IncomingWebhookRequestDetails<'_>,\n        merchant_id: &common_utils::id_type::MerchantId,\n        connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,\n        connector_name: &str,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        let algorithm = self.get_webhook_body_decoding_algorithm(request)?;\n\n        let message = self\n            .get_webhook_body_decoding_message(request)\n            .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;\n        let secret = self\n            .get_webhook_source_verification_merchant_secret(\n                merchant_id,\n                connector_name,\n                connector_webhook_details,\n            )\n            .await\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n\n        algorithm\n            .decode_message(&secret.secret, message.into())\n            .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)\n    }\n\n    /// fn get_webhook_source_verification_algorithm\n    fn get_webhook_source_verification_algorithm(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {\n        Ok(Box::new(crypto::NoAlgorithm))\n    }\n\n    /// fn get_webhook_source_verification_merchant_secret\n    async fn get_webhook_source_verification_merchant_secret(\n        &self,\n        merchant_id: &common_utils::id_type::MerchantId,\n        connector_name: &str,\n        connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,\n    ) -> CustomResult<api_models::webhooks::ConnectorWebhookSecrets, errors::ConnectorError> {\n        let debug_suffix =\n            format!(\"For merchant_id: {merchant_id:?}, and connector_name: {connector_name}\");\n        let default_secret = \"default_secret\".to_string();\n        let merchant_secret = match connector_webhook_details {\n            Some(merchant_connector_webhook_details) => {\n                let connector_webhook_details = merchant_connector_webhook_details\n                    .parse_value::<api_models::admin::MerchantConnectorWebhookDetails>(\n                        \"MerchantConnectorWebhookDetails\",\n                    )\n                    .change_context_lazy(|| errors::ConnectorError::WebhookSourceVerificationFailed)\n                    .attach_printable_lazy(|| {\n                        format!(\n                            \"Deserializing MerchantConnectorWebhookDetails failed {debug_suffix}\",\n                        )\n                    })?;\n                api_models::webhooks::ConnectorWebhookSecrets {\n                    secret: connector_webhook_details\n                        .merchant_secret\n                        .expose()\n                        .into_bytes(),\n                    additional_secret: connector_webhook_details.additional_secret,\n                }\n            }\n\n            None => api_models::webhooks::ConnectorWebhookSecrets {\n                secret: default_secret.into_bytes(),\n                additional_secret: None,\n            },\n        };\n\n        //need to fetch merchant secret from config table with caching in future for enhanced performance\n\n        //If merchant has not set the secret for webhook source verification, \"default_secret\" is returned.\n        //So it will fail during verification step and goes to psync flow.\n        Ok(merchant_secret)\n    }\n\n    /// fn get_webhook_source_verification_signature\n    fn get_webhook_source_verification_signature(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        Ok(Vec::new())\n    }\n\n    /// fn get_webhook_source_verification_message\n    fn get_webhook_source_verification_message(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        _connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        Ok(Vec::new())\n    }\n\n    /// fn verify_webhook_source\n    async fn verify_webhook_source(\n        &self,\n        request: &IncomingWebhookRequestDetails<'_>,\n        merchant_id: &common_utils::id_type::MerchantId,\n        connector_webhook_details: Option<common_utils::pii::SecretSerdeValue>,\n        _connector_account_details: crypto::Encryptable<Secret<serde_json::Value>>,\n        connector_name: &str,\n    ) -> CustomResult<bool, errors::ConnectorError> {\n        let algorithm = self\n            .get_webhook_source_verification_algorithm(request)\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n\n        let connector_webhook_secrets = self\n            .get_webhook_source_verification_merchant_secret(\n                merchant_id,\n                connector_name,\n                connector_webhook_details,\n            )\n            .await\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n\n        let signature = self\n            .get_webhook_source_verification_signature(request, &connector_webhook_secrets)\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n\n        let message = self\n            .get_webhook_source_verification_message(\n                request,\n                merchant_id,\n                &connector_webhook_secrets,\n            )\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n\n        algorithm\n            .verify_signature(&connector_webhook_secrets.secret, &signature, &message)\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)\n    }\n\n    /// fn get_webhook_object_reference_id\n    fn get_webhook_object_reference_id(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError>;\n\n    /// fn get_status_update_object\n    #[cfg(feature = \"payouts\")]\n    fn get_payout_webhook_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::PayoutWebhookUpdate, errors::ConnectorError> {\n        Ok(api_models::webhooks::PayoutWebhookUpdate {\n            error_code: None,\n            error_message: None,\n        })\n    }\n\n    /// fn get_webhook_event_type\n    fn get_webhook_event_type(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError>;\n\n    /// fn get_webhook_resource_object\n    fn get_webhook_resource_object(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError>;\n\n    /// fn get_webhook_api_response\n    fn get_webhook_api_response(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n        _error_kind: Option<IncomingWebhookFlowError>,\n    ) -> CustomResult<ApplicationResponse<serde_json::Value>, errors::ConnectorError> {\n        Ok(ApplicationResponse::StatusOk)\n    }\n\n    /// fn get_dispute_details\n    fn get_dispute_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<crate::disputes::DisputePayload, errors::ConnectorError> {\n        Err(errors::ConnectorError::NotImplemented(\"get_dispute_details method\".to_string()).into())\n    }\n\n    /// fn get_external_authentication_details\n    fn get_external_authentication_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<crate::authentication::ExternalAuthenticationPayload, errors::ConnectorError>\n    {\n        Err(errors::ConnectorError::NotImplemented(\n            \"get_external_authentication_details method\".to_string(),\n        )\n        .into())\n    }\n\n    /// fn get_mandate_details\n    fn get_mandate_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<\n        Option<hyperswitch_domain_models::router_flow_types::ConnectorMandateDetails>,\n        errors::ConnectorError,\n    > {\n        Ok(None)\n    }\n\n    /// fn get_network_txn_id\n    fn get_network_txn_id(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<\n        Option<hyperswitch_domain_models::router_flow_types::ConnectorNetworkTxnId>,\n        errors::ConnectorError,\n    > {\n        Ok(None)\n    }\n\n    #[cfg(all(feature = \"revenue_recovery\", feature = \"v2\"))]\n    /// get revenue recovery invoice details\n    fn get_revenue_recovery_attempt_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<\n        hyperswitch_domain_models::revenue_recovery::RevenueRecoveryAttemptData,\n        errors::ConnectorError,\n    > {\n        Err(errors::ConnectorError::NotImplemented(\n            \"get_revenue_recovery_attempt_details method\".to_string(),\n        )\n        .into())\n    }\n    #[cfg(all(feature = \"revenue_recovery\", feature = \"v2\"))]\n    /// get revenue recovery transaction details\n    fn get_revenue_recovery_invoice_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<\n        hyperswitch_domain_models::revenue_recovery::RevenueRecoveryInvoiceData,\n        errors::ConnectorError,\n    > {\n        Err(errors::ConnectorError::NotImplemented(\n            \"get_revenue_recovery_invoice_details method\".to_string(),\n        )\n        .into())\n    }\n\n    /// get subscription MIT payment data from webhook\n    fn get_subscription_mit_payment_data(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<\n        hyperswitch_domain_models::router_flow_types::SubscriptionMitPaymentData,\n        errors::ConnectorError,\n    > {\n        Err(errors::ConnectorError::NotImplemented(\n            \"get_subscription_mit_payment_data method\".to_string(),\n        )\n        .into())\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": "    ) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError>;\n\n    /// fn get_status_update_object\n    #[cfg(feature = \"payouts\")]\n    fn get_payout_webhook_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::PayoutWebhookUpdate, errors::ConnectorError> {\n        Ok(api_models::webhooks::PayoutWebhookUpdate {\n            error_code: None,\n            error_message: None,\n        })\n    }\n\n    /// fn get_webhook_event_type\n    fn get_webhook_event_type("
+      },
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::payouts_incoming_webhook_flow",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "async fn payouts_incoming_webhook_flow(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    business_profile: domain::Profile,\n    webhook_details: api::IncomingWebhookDetails,\n    event_type: webhooks::IncomingWebhookEvent,\n    source_verified: bool,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_METRIC.add(1, &[]);\n    if source_verified {\n        let db = &*state.store;\n        //find payout_attempt by object_reference_id\n        let payout_attempt = match webhook_details.object_reference_id {\n            webhooks::ObjectReferenceId::PayoutId(payout_id_type) => match payout_id_type {\n                webhooks::PayoutIdType::PayoutAttemptId(id) => db\n                    .find_payout_attempt_by_merchant_id_payout_attempt_id(\n                        merchant_context.get_merchant_account().get_id(),\n                        &id,\n                        merchant_context.get_merchant_account().storage_scheme,\n                    )\n                    .await\n                    .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                    .attach_printable(\"Failed to fetch the payout attempt\")?,\n                webhooks::PayoutIdType::ConnectorPayoutId(id) => db\n                    .find_payout_attempt_by_merchant_id_connector_payout_id(\n                        merchant_context.get_merchant_account().get_id(),\n                        &id,\n                        merchant_context.get_merchant_account().storage_scheme,\n                    )\n                    .await\n                    .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                    .attach_printable(\"Failed to fetch the payout attempt\")?,\n            },\n            _ => Err(errors::ApiErrorResponse::WebhookProcessingFailure)\n                .attach_printable(\"received a non-payout id when processing payout webhooks\")?,\n        };\n\n        let payouts = db\n            .find_payout_by_merchant_id_payout_id(\n                merchant_context.get_merchant_account().get_id(),\n                &payout_attempt.payout_id,\n                merchant_context.get_merchant_account().storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n            .attach_printable(\"Failed to fetch the payout\")?;\n\n        let payout_attempt_update = PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status: common_enums::PayoutStatus::foreign_try_from(event_type)\n                .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n                .attach_printable(\"failed payout status mapping from event type\")?,\n            error_message: None,\n            error_code: None,\n            is_eligible: payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        };\n\n        let action_req =\n            payout_models::PayoutRequest::PayoutActionRequest(payout_models::PayoutActionRequest {\n                payout_id: payouts.payout_id.clone(),\n            });\n\n        let mut payout_data = Box::pin(payouts::make_payout_data(\n            &state,\n            &merchant_context,\n            None,\n            &action_req,\n            common_utils::consts::DEFAULT_LOCALE,\n        ))\n        .await?;\n\n        let updated_payout_attempt = db\n            .update_payout_attempt(\n                &payout_attempt,\n                payout_attempt_update,\n                &payout_data.payouts,\n                merchant_context.get_merchant_account().storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n            .attach_printable_lazy(|| {\n                format!(\n                    \"Failed while updating payout attempt: payout_attempt_id: {}\",\n                    payout_attempt.payout_attempt_id\n                )\n            })?;\n        payout_data.payout_attempt = updated_payout_attempt;\n\n        let event_type: Option<enums::EventType> = payout_data.payout_attempt.status.into();\n\n        // If event is NOT an UnsupportedEvent, trigger Outgoing Webhook\n        if let Some(outgoing_event_type) = event_type {\n            let payout_create_response =\n                payouts::response_handler(&state, &merchant_context, &payout_data).await?;\n\n            Box::pin(super::create_event_and_trigger_outgoing_webhook(\n                state,\n                merchant_context,\n                business_profile,\n                outgoing_event_type,\n                enums::EventClass::Payouts,\n                payout_data\n                    .payout_attempt\n                    .payout_id\n                    .get_string_repr()\n                    .to_string(),\n                enums::EventObjectType::PayoutDetails,\n                api::OutgoingWebhookContent::PayoutDetails(Box::new(payout_create_response)),\n                Some(payout_data.payout_attempt.created_at),\n            ))\n            .await?;\n        }\n\n        Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        })\n    } else {\n        metrics::INCOMING_PAYOUT_WEBHOOK_SIGNATURE_FAILURE_METRIC.add(1, &[]);\n        Err(report!(\n            errors::ApiErrorResponse::WebhookAuthenticationFailed\n        ))\n    }\n}",
+      "after_code": "async fn payouts_incoming_webhook_flow(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    business_profile: domain::Profile,\n    webhook_details: api::IncomingWebhookDetails,\n    event_type: webhooks::IncomingWebhookEvent,\n    source_verified: bool,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_METRIC.add(1, &[]);\n    if source_verified {\n        let db = &*state.store;\n        //find payout_attempt by object_reference_id\n        let payout_attempt = match webhook_details.object_reference_id {\n            webhooks::ObjectReferenceId::PayoutId(payout_id_type) => match payout_id_type {\n                webhooks::PayoutIdType::PayoutAttemptId(id) => db\n                    .find_payout_attempt_by_merchant_id_payout_attempt_id(\n                        merchant_context.get_merchant_account().get_id(),\n                        &id,\n                        merchant_context.get_merchant_account().storage_scheme,\n                    )\n                    .await\n                    .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                    .attach_printable(\"Failed to fetch the payout attempt\")?,\n                webhooks::PayoutIdType::ConnectorPayoutId(id) => db\n                    .find_payout_attempt_by_merchant_id_connector_payout_id(\n                        merchant_context.get_merchant_account().get_id(),\n                        &id,\n                        merchant_context.get_merchant_account().storage_scheme,\n                    )\n                    .await\n                    .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                    .attach_printable(\"Failed to fetch the payout attempt\")?,\n            },\n            _ => Err(errors::ApiErrorResponse::WebhookProcessingFailure)\n                .attach_printable(\"received a non-payout id when processing payout webhooks\")?,\n        };\n\n        let payouts = db\n            .find_payout_by_merchant_id_payout_id(\n                merchant_context.get_merchant_account().get_id(),\n                &payout_attempt.payout_id,\n                merchant_context.get_merchant_account().storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n            .attach_printable(\"Failed to fetch the payout\")?;\n\n        let status = common_enums::PayoutStatus::foreign_try_from(event_type)\n            .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n            .attach_printable(\"failed payout status mapping from event type\")?;\n\n        let payout_webhook_details = connector\n            .get_payout_webhook_details(request_details)\n            .switch()\n            .attach_printable(\"Failed to get error object for payouts\")?;\n\n        // if status is failure then update the error_code and error_message as well\n        let payout_attempt_update = if status.is_payout_failure() {\n            PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_attempt.connector_payout_id.clone(),\n                status,\n                error_message: payout_webhook_details.error_message,\n                error_code: payout_webhook_details.error_code,\n                is_eligible: payout_attempt.is_eligible,\n                unified_code: None,\n                unified_message: None,\n                payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n            }\n        } else {\n            PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_attempt.connector_payout_id.clone(),\n                status,\n                error_message: None,\n                error_code: None,\n                is_eligible: payout_attempt.is_eligible,\n                unified_code: None,\n                unified_message: None,\n                payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n            }\n        };\n\n        let action_req =\n            payout_models::PayoutRequest::PayoutActionRequest(payout_models::PayoutActionRequest {\n                payout_id: payouts.payout_id.clone(),\n            });\n\n        let mut payout_data = Box::pin(payouts::make_payout_data(\n            &state,\n            &merchant_context,\n            None,\n            &action_req,\n            common_utils::consts::DEFAULT_LOCALE,\n        ))\n        .await?;\n\n        let updated_payout_attempt = db\n            .update_payout_attempt(\n                &payout_attempt,\n                payout_attempt_update,\n                &payout_data.payouts,\n                merchant_context.get_merchant_account().storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n            .attach_printable_lazy(|| {\n                format!(\n                    \"Failed while updating payout attempt: payout_attempt_id: {}\",\n                    payout_attempt.payout_attempt_id\n                )\n            })?;\n        payout_data.payout_attempt = updated_payout_attempt;\n\n        let event_type: Option<enums::EventType> = payout_data.payout_attempt.status.into();\n\n        // If event is NOT an UnsupportedEvent, trigger Outgoing Webhook\n        if let Some(outgoing_event_type) = event_type {\n            let payout_create_response =\n                payouts::response_handler(&state, &merchant_context, &payout_data).await?;\n\n            Box::pin(super::create_event_and_trigger_outgoing_webhook(\n                state,\n                merchant_context,\n                business_profile,\n                outgoing_event_type,\n                enums::EventClass::Payouts,\n                payout_data\n                    .payout_attempt\n                    .payout_id\n                    .get_string_repr()\n                    .to_string(),\n                enums::EventObjectType::PayoutDetails,\n                api::OutgoingWebhookContent::PayoutDetails(Box::new(payout_create_response)),\n                Some(payout_data.payout_attempt.created_at),\n            ))\n            .await?;\n        }\n\n        Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        })\n    } else {\n        metrics::INCOMING_PAYOUT_WEBHOOK_SIGNATURE_FAILURE_METRIC.add(1, &[]);\n        Err(report!(\n            errors::ApiErrorResponse::WebhookAuthenticationFailed\n        ))\n    }\n}",
+      "diff_span": {
+        "before": "            .attach_printable(\"Failed to fetch the payout\")?;\n\n        let payout_attempt_update = PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status: common_enums::PayoutStatus::foreign_try_from(event_type)\n                .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n                .attach_printable(\"failed payout status mapping from event type\")?,\n            error_message: None,\n            error_code: None,\n            is_eligible: payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        };\n",
+        "after": "    event_type: webhooks::IncomingWebhookEvent,\n    source_verified: bool,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_METRIC.add(1, &[]);\n    if source_verified {\n        let db = &*state.store;\n        //find payout_attempt by object_reference_id\n        let payout_attempt = match webhook_details.object_reference_id {\n            webhooks::ObjectReferenceId::PayoutId(payout_id_type) => match payout_id_type {\n                webhooks::PayoutIdType::PayoutAttemptId(id) => db\n                    .find_payout_attempt_by_merchant_id_payout_attempt_id(\n                        merchant_context.get_merchant_account().get_id(),\n                        &id,\n                        merchant_context.get_merchant_account().storage_scheme,\n                    )\n                    .await\n                    .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                    .attach_printable(\"Failed to fetch the payout attempt\")?,\n                webhooks::PayoutIdType::ConnectorPayoutId(id) => db\n                    .find_payout_attempt_by_merchant_id_connector_payout_id(\n                        merchant_context.get_merchant_account().get_id(),\n                        &id,\n                        merchant_context.get_merchant_account().storage_scheme,\n                    )\n                    .await\n                    .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                    .attach_printable(\"Failed to fetch the payout attempt\")?,\n            },\n            _ => Err(errors::ApiErrorResponse::WebhookProcessingFailure)\n                .attach_printable(\"received a non-payout id when processing payout webhooks\")?,\n        };\n\n        let payouts = db\n            .find_payout_by_merchant_id_payout_id(\n                merchant_context.get_merchant_account().get_id(),\n                &payout_attempt.payout_id,\n                merchant_context.get_merchant_account().storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n            .attach_printable(\"Failed to fetch the payout\")?;\n\n        let status = common_enums::PayoutStatus::foreign_try_from(event_type)\n            .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n            .attach_printable(\"failed payout status mapping from event type\")?;\n\n        let payout_webhook_details = connector\n            .get_payout_webhook_details(request_details)\n            .switch()\n            .attach_printable(\"Failed to get error object for payouts\")?;\n\n        // if status is failure then update the error_code and error_message as well\n        let payout_attempt_update = if status.is_payout_failure() {\n            PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_attempt.connector_payout_id.clone(),\n                status,\n                error_message: payout_webhook_details.error_message,\n                error_code: payout_webhook_details.error_code,\n                is_eligible: payout_attempt.is_eligible,\n                unified_code: None,\n                unified_message: None,\n                payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n            }\n        } else {\n            PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_attempt.connector_payout_id.clone(),\n                status,\n                error_message: None,\n                error_code: None,\n                is_eligible: payout_attempt.is_eligible,\n                unified_code: None,\n                unified_message: None,\n                payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n            }\n        };\n"
+      },
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e",
+      "before_imports": [
+        "use hyperswitch_domain_models::{\n    mandates::CommonMandateReference,\n    payments::{payment_attempt::PaymentAttempt, HeaderPayload},\n    router_request_types::VerifyWebhookSourceRequestData,\n    router_response_types::{VerifyWebhookSourceResponseData, VerifyWebhookStatus},\n};",
+        "use common_utils::{\n    errors::ReportSwitchExt,\n    events::ApiEventsType,\n    ext_traits::{AsyncExt, ByteSliceExt},\n    types::{AmountConvertor, StringMinorUnitForConnector},\n};",
+        "use error_stack::{report, ResultExt};",
+        "use super::{types, utils, MERCHANT_ID};",
+        "use api_models::{\n    enums::Connector,\n    webhooks::{self, WebhookResponseTracker},\n};"
+      ],
+      "after_imports": [
+        "use hyperswitch_domain_models::{\n    mandates::CommonMandateReference,\n    payments::{payment_attempt::PaymentAttempt, HeaderPayload},\n    router_request_types::VerifyWebhookSourceRequestData,\n    router_response_types::{VerifyWebhookSourceResponseData, VerifyWebhookStatus},\n};",
+        "use common_utils::{\n    errors::ReportSwitchExt,\n    events::ApiEventsType,\n    ext_traits::{AsyncExt, ByteSliceExt},\n    types::{AmountConvertor, StringMinorUnitForConnector},\n};",
+        "use error_stack::{report, ResultExt};",
+        "use hyperswitch_interfaces::webhooks::{IncomingWebhookFlowError, IncomingWebhookRequestDetails};",
+        "use super::{types, utils, MERCHANT_ID};",
+        "use api_models::{\n    enums::Connector,\n    webhooks::{self, WebhookResponseTracker},\n};"
+      ]
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/adyenplatform/transformers/payouts.rs::struct::AdyenplatformIncomingWebhookData",
+      "file": "crates/hyperswitch_connectors/src/connectors/adyenplatform/transformers/payouts.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct AdyenplatformIncomingWebhookData {\n    pub status: AdyenplatformWebhookStatus,\n    pub reference: String,\n    pub tracking: Option<AdyenplatformTrackingData>,\n    pub category: Option<AdyenPayoutMethod>,\n}",
+      "after_code": "pub struct AdyenplatformIncomingWebhookData {\n    pub status: AdyenplatformWebhookStatus,\n    pub reference: String,\n    pub tracking: Option<AdyenplatformTrackingData>,\n    pub reason: Option<String>,\n    pub category: Option<AdyenPayoutMethod>,\n}",
+      "diff_span": {
+        "before": "",
+        "after": "    pub reference: String,\n    pub tracking: Option<AdyenplatformTrackingData>,\n    pub reason: Option<String>,\n    pub category: Option<AdyenPayoutMethod>,\n}"
+      },
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e"
+    },
+    {
+      "id": "crates/common_enums/src/enums.rs::PayoutStatus::function::is_payout_failure",
+      "file": "crates/common_enums/src/enums.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn is_payout_failure(&self) -> bool {\n        matches!(\n            self,\n            Self::Failed | Self::Cancelled | Self::Expired | Self::Ineligible\n        )\n    }",
+      "diff_span": null,
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/webhooks.rs::IncomingWebhook::function::get_payout_webhook_details",
+      "file": "crates/hyperswitch_interfaces/src/webhooks.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_payout_webhook_details(\n        &self,\n        _request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::PayoutWebhookUpdate, errors::ConnectorError> {\n        Ok(api_models::webhooks::PayoutWebhookUpdate {\n            error_code: None,\n            error_message: None,\n        })\n    }",
+      "diff_span": null,
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e"
+    },
+    {
+      "id": "crates/common_enums/src/enums.rs::impl::PayoutStatus",
+      "file": "crates/common_enums/src/enums.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl PayoutStatus {\n    pub fn is_payout_failure(&self) -> bool {\n        matches!(\n            self,\n            Self::Failed | Self::Cancelled | Self::Expired | Self::Ineligible\n        )\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/adyenplatform.rs::Adyenplatform::function::get_payout_webhook_details",
+      "file": "crates/hyperswitch_connectors/src/connectors/adyenplatform.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_payout_webhook_details(\n        &self,\n        request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::PayoutWebhookUpdate, ConnectorError> {\n        let webhook_body: adyenplatform::AdyenplatformIncomingWebhook = request\n            .body\n            .parse_struct(\"AdyenplatformIncomingWebhook\")\n            .change_context(ConnectorError::ResponseDeserializationFailed)?;\n\n        let error_reason = webhook_body.data.reason.or(webhook_body\n            .data\n            .tracking\n            .and_then(|tracking_data| tracking_data.reason));\n\n        Ok(api_models::webhooks::PayoutWebhookUpdate {\n            error_message: error_reason.clone(),\n            error_code: error_reason,\n        })\n    }",
+      "diff_span": null,
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e"
+    },
+    {
+      "id": "crates/api_models/src/webhooks.rs::struct::PayoutWebhookUpdate",
+      "file": "crates/api_models/src/webhooks.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PayoutWebhookUpdate {\n    pub error_message: Option<String>,\n    pub error_code: Option<String>,\n}",
+      "diff_span": null,
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs::ConnectorEnum::function::get_payout_webhook_details",
+      "file": "crates/hyperswitch_interfaces/src/connector_integration_interface.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_payout_webhook_details(\n        &self,\n        request: &IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::PayoutWebhookUpdate, errors::ConnectorError> {\n        match self {\n            Self::Old(connector) => connector.get_payout_webhook_details(request),\n            Self::New(connector) => connector.get_payout_webhook_details(request),\n        }\n    }",
+      "diff_span": null,
+      "commit_sha": "1aaa136f80f58082dce861be0015c4113ad43a9e"
+    }
+  ]
+}

diffs/pr_10158/1df534e/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "1df534e8014a9011c5559dfe6b10f3e8c0b59ae6",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        // Create simple metrics attributes for proxy client tracking\n        let http_proxy_host = extract_proxy_host(&proxy_config.http_url);\n        let https_proxy_host = extract_proxy_host(&proxy_config.https_url);\n            \n        let proxy_metrics_tag = metric_attributes!(\n            (\"client_type\", \"proxy\"),\n            (\"http_proxy_host\", http_proxy_host),\n            (\"https_proxy_host\", https_proxy_host)\n        );\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, &proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, &proxy_metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, &proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, &default_metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, &default_metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        // Create simple metrics attributes for proxy client tracking\n        let http_proxy_host = extract_proxy_host(&proxy_config.http_url);\n        let https_proxy_host = extract_proxy_host(&proxy_config.https_url);\n            \n        let proxy_metrics_tag = metric_attributes!(\n            (\"client_type\", \"proxy\"),\n            (\"http_proxy_host\", http_proxy_host),\n            (\"https_proxy_host\", https_proxy_host)\n        );\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, proxy_metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, default_metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, default_metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, &proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, &proxy_metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, &proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, &default_metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, &default_metrics_tag);\n        Ok(client)\n    }",
+        "after": "        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, proxy_metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, default_metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, default_metrics_tag);\n        Ok(client)\n    }"
+      },
+      "commit_sha": "1df534e8014a9011c5559dfe6b10f3e8c0b59ae6"
+    }
+  ]
+}

diffs/pr_10158/1e044ba/diff.json

@@ -0,0 +1,84 @@
+{
+  "commit_sha": "1e044bae30e626a5bbd9d11c284ec489142bebb9",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::has_proxy_config",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }",
+      "after_code": "fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }",
+      "diff_span": {
+        "before": "fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }",
+        "after": "fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }"
+      },
+      "commit_sha": "1e044bae30e626a5bbd9d11c284ec489142bebb9"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::cache_key",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        Some(format!(\n            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"), \n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }",
+      "after_code": "fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        Some(format!(\n            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"),\n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }",
+      "diff_span": {
+        "before": "            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"), \n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),",
+        "after": "            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"),\n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),"
+      },
+      "commit_sha": "1e044bae30e626a5bbd9d11c284ec489142bebb9"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::impl::Proxy",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        Some(format!(\n            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"), \n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }\n    \n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }\n}",
+      "after_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        Some(format!(\n            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"),\n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }\n\n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }\n}",
+      "diff_span": {
+        "before": "            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"), \n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }\n    \n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }\n}",
+        "after": "            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"),\n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }\n\n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }\n}"
+      },
+      "commit_sha": "1e044bae30e626a5bbd9d11c284ec489142bebb9"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_client_builder",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_client_builder(\n    proxy_config: &Proxy,\n) -> CustomResult<reqwest::ClientBuilder, HttpClientError> {\n    let mut client_builder = reqwest::Client::builder()\n        .redirect(reqwest::redirect::Policy::none())\n        .pool_idle_timeout(Duration::from_secs(\n            proxy_config\n                .idle_pool_connection_timeout\n                .unwrap_or_default(),\n        ));\n\n    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\", proxy_config.http_url.clone(), proxy_config.https_url.clone());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy\n    if let Some(url) = proxy_config.https_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::https(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTPS proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config.clone()),\n        );\n    }\n\n    // Proxy all HTTP traffic through the configured HTTP proxy\n    if let Some(url) = proxy_config.http_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::http(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTP proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config),\n        );\n    }\n\n    Ok(client_builder)\n}",
+      "after_code": "pub fn get_client_builder(\n    proxy_config: &Proxy,\n) -> CustomResult<reqwest::ClientBuilder, HttpClientError> {\n    let mut client_builder = reqwest::Client::builder()\n        .redirect(reqwest::redirect::Policy::none())\n        .pool_idle_timeout(Duration::from_secs(\n            proxy_config\n                .idle_pool_connection_timeout\n                .unwrap_or_default(),\n        ));\n\n    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\n        \"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\",\n        proxy_config.http_url.clone(),\n        proxy_config.https_url.clone()\n    );\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy\n    if let Some(url) = proxy_config.https_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::https(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTPS proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config.clone()),\n        );\n    }\n\n    // Proxy all HTTP traffic through the configured HTTP proxy\n    if let Some(url) = proxy_config.http_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::http(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTP proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config),\n        );\n    }\n\n    Ok(client_builder)\n}",
+      "diff_span": {
+        "before": "        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\", proxy_config.http_url.clone(), proxy_config.https_url.clone());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy",
+        "after": "        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\n        \"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\",\n        proxy_config.http_url.clone(),\n        proxy_config.https_url.clone()\n    );\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy"
+      },
+      "commit_sha": "1e044bae30e626a5bbd9d11c284ec489142bebb9"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(client.clone());\n        }\n\n        // Create new proxy client if not in cache\n        logger::info!(\n            \"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\",\n            cache_key,\n            proxy_config.http_url,\n            proxy_config.https_url\n        );\n\n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n\n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)",
+        "after": "    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(client.clone());\n        }\n\n        // Create new proxy client if not in cache\n        logger::info!(\n            \"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\",\n            cache_key,\n            proxy_config.http_url,\n            proxy_config.https_url\n        );\n\n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n\n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)"
+      },
+      "commit_sha": "1e044bae30e626a5bbd9d11c284ec489142bebb9"
+    }
+  ]
+}

diffs/pr_10158/34cfedc/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "34cfedce714b7380fc4a54ec951887e427cfdd82",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::create_new_proxy_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn create_new_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    let mut write_lock = cache.try_write().map_err(|_| {\n        error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to acquire proxy client cache write lock\")\n    })?;\n\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(cached_client.clone())\n    } else {\n        logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n        let new_client =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n\n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n        write_lock.insert(cache_key.clone(), new_client.clone());\n        logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n        Ok(new_client)\n    }\n}",
+      "after_code": "fn create_new_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    let mut write_lock = cache.try_write().map_err(|_| {\n        error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to acquire proxy client cache write lock\")\n    })?;\n\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\n            \"Retrieved cached proxy client after write lock for config: {:?}\",\n            cache_key\n        );\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(cached_client.clone())\n    } else {\n        logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n        let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n\n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n        write_lock.insert(cache_key.clone(), new_client.clone());\n        logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n        Ok(new_client)\n    }\n}",
+      "diff_span": {
+        "before": "\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(cached_client.clone())\n    } else {\n        logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n        let new_client =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n\n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);",
+        "after": "\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\n            \"Retrieved cached proxy client after write lock for config: {:?}\",\n            cache_key\n        );\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(cached_client.clone())\n    } else {\n        logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n        let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n\n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);"
+      },
+      "commit_sha": "34cfedce714b7380fc4a54ec951887e427cfdd82"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Ok(read_lock) = cache.read() {\n            if let Some(cached_client) = read_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                drop(read_lock);\n                create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n            }\n        } else {\n            create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n\n        let client = if let Ok(read_lock) = cache.read() {\n            if let Some(cached_client) = read_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                drop(read_lock);\n                create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n            }\n        } else {\n            create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Ok(read_lock) = cache.read() {\n            if let Some(cached_client) = read_lock.get(&cache_key) {",
+        "after": "\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n\n        let client = if let Ok(read_lock) = cache.read() {\n            if let Some(cached_client) = read_lock.get(&cache_key) {"
+      },
+      "commit_sha": "34cfedce714b7380fc4a54ec951887e427cfdd82"
+    }
+  ]
+}

diffs/pr_10158/381ff3b/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "381ff3b050ae5d82ecb202e6b1da91b2ffb68ec8",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_or_create_proxy_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_or_create_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    let read_result = cache.read().ok().and_then(|read_lock| read_lock.get(&cache_key).cloned());\n    \n    let client = match read_result {\n        Some(cached_client) => {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client\n        }\n        None => {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            match write_lock.get(&cache_key) {\n                Some(cached_client) => {\n                    logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n                    metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                    cached_client.clone()\n                }\n                None => {\n                    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                    let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                    write_lock.insert(cache_key.clone(), new_client.clone());\n                    logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                    new_client\n                }\n            }\n        }\n    };\n\n    Ok(client)\n}",
+      "after_code": "fn get_or_create_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    let read_result = cache\n        .read()\n        .ok()\n        .and_then(|read_lock| read_lock.get(&cache_key).cloned());\n\n    let client = match read_result {\n        Some(cached_client) => {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client\n        }\n        None => {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            match write_lock.get(&cache_key) {\n                Some(cached_client) => {\n                    logger::debug!(\n                        \"Retrieved cached proxy client after write lock for config: {:?}\",\n                        cache_key\n                    );\n                    metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                    cached_client.clone()\n                }\n                None => {\n                    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                    let new_client =\n                        apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                            .build()\n                            .change_context(HttpClientError::ClientConstructionFailed)\n                            .attach_printable(\"Failed to construct proxy client\")?;\n\n                    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                    write_lock.insert(cache_key.clone(), new_client.clone());\n                    logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                    new_client\n                }\n            }\n        }\n    };\n\n    Ok(client)\n}",
+      "diff_span": {
+        "before": "    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    let read_result = cache.read().ok().and_then(|read_lock| read_lock.get(&cache_key).cloned());\n    \n    let client = match read_result {\n        Some(cached_client) => {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client\n        }\n        None => {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            match write_lock.get(&cache_key) {\n                Some(cached_client) => {\n                    logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n                    metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                    cached_client.clone()\n                }\n                None => {\n                    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                    let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);",
+        "after": "    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    let read_result = cache\n        .read()\n        .ok()\n        .and_then(|read_lock| read_lock.get(&cache_key).cloned());\n\n    let client = match read_result {\n        Some(cached_client) => {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client\n        }\n        None => {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            match write_lock.get(&cache_key) {\n                Some(cached_client) => {\n                    logger::debug!(\n                        \"Retrieved cached proxy client after write lock for config: {:?}\",\n                        cache_key\n                    );\n                    metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                    cached_client.clone()\n                }\n                None => {\n                    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                    let new_client =\n                        apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                            .build()\n                            .change_context(HttpClientError::ClientConstructionFailed)\n                            .attach_printable(\"Failed to construct proxy client\")?;\n\n                    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);"
+      },
+      "commit_sha": "381ff3b050ae5d82ecb202e6b1da91b2ffb68ec8"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = get_or_create_proxy_client(cache, cache_key, proxy_config, metrics_tag)?;\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n\n        let client = get_or_create_proxy_client(cache, cache_key, proxy_config, metrics_tag)?;\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = get_or_create_proxy_client(cache, cache_key, proxy_config, metrics_tag)?;\n",
+        "after": "\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n\n        let client = get_or_create_proxy_client(cache, cache_key, proxy_config, metrics_tag)?;\n"
+      },
+      "commit_sha": "381ff3b050ae5d82ecb202e6b1da91b2ffb68ec8"
+    }
+  ]
+}

diffs/pr_10158/3ea3282/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "3ea32823bd5433539dff7506938a2f9bad369dbe",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::static::PROXY_CLIENT_CACHE",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "static_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "static PROXY_CLIENT_CACHE: OnceCell<Mutex<HashMap<Proxy, reqwest::Client>>> = OnceCell::new();",
+      "after_code": "static PROXY_CLIENT_CACHE: OnceCell<RwLock<HashMap<Proxy, reqwest::Client>>> = OnceCell::new();",
+      "diff_span": {
+        "before": "static PROXY_CLIENT_CACHE: OnceCell<Mutex<HashMap<Proxy, reqwest::Client>>> = OnceCell::new();",
+        "after": "static PROXY_CLIENT_CACHE: OnceCell<RwLock<HashMap<Proxy, reqwest::Client>>> = OnceCell::new();"
+      },
+      "commit_sha": "3ea32823bd5433539dff7506938a2f9bad369dbe"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {:?}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n            let new_client =\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct proxy client\")?;\n\n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n            new_client\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {:?}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let read_lock = cache.read().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache read lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            drop(read_lock);\n            \n            let mut write_lock = cache.write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n            \n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                \n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                let new_client =\n                    apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n                write_lock.insert(cache_key.clone(), new_client.clone());\n                logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                new_client\n            }\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n            let new_client =\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct proxy client\")?;\n\n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n            new_client\n        };\n",
+        "after": "        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let read_lock = cache.read().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache read lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            drop(read_lock);\n            \n            let mut write_lock = cache.write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n            \n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                \n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                let new_client =\n                    apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n                write_lock.insert(cache_key.clone(), new_client.clone());\n                logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                new_client\n            }\n        };\n"
+      },
+      "commit_sha": "3ea32823bd5433539dff7506938a2f9bad369dbe"
+    }
+  ]
+}

diffs/pr_10158/4c4b7f4/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "4c4b7f405803091b02a01c5142cd9746402099bc",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let read_lock = cache.read().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache read lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            drop(read_lock);\n            \n            let mut write_lock = cache.write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n            \n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                \n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                let new_client =\n                    apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n                write_lock.insert(cache_key.clone(), new_client.clone());\n                logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                new_client\n            }\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n\n        let read_lock = cache.read().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache read lock\")\n        })?;\n\n        let client = if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            drop(read_lock);\n\n            let mut write_lock = cache.write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\n                    \"Retrieved cached proxy client after write lock for config: {:?}\",\n                    cache_key\n                );\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                let new_client =\n                    apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n                write_lock.insert(cache_key.clone(), new_client.clone());\n                logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                new_client\n            }\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let read_lock = cache.read().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache read lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            drop(read_lock);\n            \n            let mut write_lock = cache.write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n            \n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                \n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n",
+        "after": "\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n\n        let read_lock = cache.read().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache read lock\")\n        })?;\n\n        let client = if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            drop(read_lock);\n\n            let mut write_lock = cache.write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\n                    \"Retrieved cached proxy client after write lock for config: {:?}\",\n                    cache_key\n                );\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n"
+      },
+      "commit_sha": "4c4b7f405803091b02a01c5142cd9746402099bc"
+    }
+  ]
+}

diffs/pr_10158/4f0c898/diff.json

@@ -0,0 +1,33 @@
+{
+  "commit_sha": "4f0c8984b24f5f542dcf8cf7de11afeaea82fa9a",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_client_builder",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub fn get_client_builder(\n    proxy_config: &Proxy,\n) -> CustomResult<reqwest::ClientBuilder, HttpClientError> {\n    let mut client_builder = reqwest::Client::builder()\n        .redirect(reqwest::redirect::Policy::none())\n        .pool_idle_timeout(Duration::from_secs(\n            proxy_config\n                .idle_pool_connection_timeout\n                .unwrap_or_default(),\n        ));\n\n    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy\n    if let Some(url) = proxy_config.https_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::https(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTPS proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config.clone()),\n        );\n    }\n\n    // Proxy all HTTP traffic through the configured HTTP proxy\n    if let Some(url) = proxy_config.http_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::http(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTP proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config),\n        );\n    }\n\n    Ok(client_builder)\n}",
+      "after_code": "pub fn get_client_builder(\n    proxy_config: &Proxy,\n) -> CustomResult<reqwest::ClientBuilder, HttpClientError> {\n    let mut client_builder = reqwest::Client::builder()\n        .redirect(reqwest::redirect::Policy::none())\n        .pool_idle_timeout(Duration::from_secs(\n            proxy_config\n                .idle_pool_connection_timeout\n                .unwrap_or_default(),\n        ));\n\n    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\", proxy_config.http_url.clone(), proxy_config.https_url.clone());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy\n    if let Some(url) = proxy_config.https_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::https(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTPS proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config.clone()),\n        );\n    }\n\n    // Proxy all HTTP traffic through the configured HTTP proxy\n    if let Some(url) = proxy_config.http_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::http(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTP proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config),\n        );\n    }\n\n    Ok(client_builder)\n}",
+      "diff_span": {
+        "before": "",
+        "after": "    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\", proxy_config.http_url.clone(), proxy_config.https_url.clone());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy"
+      },
+      "commit_sha": "4f0c8984b24f5f542dcf8cf7de11afeaea82fa9a",
+      "before_imports": [
+        "pub use common_utils::errors::CustomResult;",
+        "use std::time::Duration;"
+      ],
+      "after_imports": [
+        "use router_env::logger;",
+        "pub use common_utils::errors::CustomResult;",
+        "use std::time::Duration;"
+      ]
+    }
+  ]
+}

diffs/pr_10158/575fed7/diff.json

@@ -0,0 +1,64 @@
+{
+  "commit_sha": "575fed7bdcd9efa29fcf288f3dedc8d40daeebe5",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::cache_key",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n\n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }",
+      "after_code": "fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n\n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Self {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }",
+      "diff_span": {
+        "before": "            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),",
+        "after": "            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Self {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),"
+      },
+      "commit_sha": "575fed7bdcd9efa29fcf288f3dedc8d40daeebe5"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::impl::Proxy",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n\n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }\n}",
+      "after_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n\n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Self {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }\n}",
+      "diff_span": {
+        "before": "            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),",
+        "after": "            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Self {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),"
+      },
+      "commit_sha": "575fed7bdcd9efa29fcf288f3dedc8d40daeebe5"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Some(cached_client) = cache.read().unwrap().get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\n                    \"Retrieved cached proxy client after write lock for config: {:?}\",\n                    cache_key\n                );\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                let new_client =\n                    apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n                write_lock.insert(cache_key.clone(), new_client.clone());\n                logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                new_client\n            }\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Ok(read_lock) = cache.read() {\n            if let Some(cached_client) = read_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                drop(read_lock);\n                create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n            }\n        } else {\n            create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Some(cached_client) = cache.read().unwrap().get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\n                    \"Retrieved cached proxy client after write lock for config: {:?}\",\n                    cache_key\n                );\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                let new_client =\n                    apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n                write_lock.insert(cache_key.clone(), new_client.clone());\n                logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                new_client\n            }\n        };",
+        "after": "        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Ok(read_lock) = cache.read() {\n            if let Some(cached_client) = read_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                drop(read_lock);\n                create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n            }\n        } else {\n            create_new_proxy_client(cache, cache_key, proxy_config, metrics_tag)?\n        };\n"
+      },
+      "commit_sha": "575fed7bdcd9efa29fcf288f3dedc8d40daeebe5"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::create_new_proxy_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn create_new_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    let mut write_lock = cache.try_write().map_err(|_| {\n        error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to acquire proxy client cache write lock\")\n    })?;\n\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(cached_client.clone())\n    } else {\n        logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n        let new_client =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n\n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n        write_lock.insert(cache_key.clone(), new_client.clone());\n        logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n        Ok(new_client)\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "575fed7bdcd9efa29fcf288f3dedc8d40daeebe5"
+    }
+  ]
+}

diffs/pr_10158/5a7fbf3/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "5a7fbf30836f623facaf1a8e1d3fce5ddb06fd45",
+  "pr_number": 10158,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10158/5e6a702/diff.json

@@ -0,0 +1,54 @@
+{
+  "commit_sha": "5e6a70283ac8ca9f65326454abce0d95bfdf921a",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::cache_key",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n            \n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }",
+      "after_code": "fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n\n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }",
+      "diff_span": {
+        "before": "        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n            \n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version",
+        "after": "        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n\n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version"
+      },
+      "commit_sha": "5e6a70283ac8ca9f65326454abce0d95bfdf921a"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::impl::Proxy",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n            \n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }\n}",
+      "after_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n\n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }\n}",
+      "diff_span": {
+        "before": "        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n            \n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version",
+        "after": "        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n\n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version"
+      },
+      "commit_sha": "5e6a70283ac8ca9f65326454abce0d95bfdf921a"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {:?}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n            let new_client =\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct proxy client\")?;\n\n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n            new_client\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n            let new_client =\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct proxy client\")?;\n\n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n            new_client\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {:?}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n",
+        "after": "    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n"
+      },
+      "commit_sha": "5e6a70283ac8ca9f65326454abce0d95bfdf921a"
+    }
+  ]
+}

diffs/pr_10158/6f74057/diff.json

@@ -0,0 +1,34 @@
+{
+  "commit_sha": "6f740570fdac6d8326d71fdf736be0e3c653eb0e",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs",
+    "crates/external_services/src/http_client/metrics.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        Ok(DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone())\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        Ok(DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone())\n    }\n}",
+        "after": "    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}"
+      },
+      "commit_sha": "6f740570fdac6d8326d71fdf736be0e3c653eb0e",
+      "before_imports": [
+        "use router_env::logger;",
+        "pub use common_utils::errors::CustomResult;"
+      ],
+      "after_imports": [
+        "use router_env::logger;",
+        "pub use common_utils::errors::CustomResult;",
+        "use super::metrics;"
+      ]
+    }
+  ]
+}

diffs/pr_10158/784bb96/diff.json

@@ -0,0 +1,54 @@
+{
+  "commit_sha": "784bb96edbe27fd4c558e2a02b8c758594ebe895",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::cache_key",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }",
+      "after_code": "fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n\n        logger::debug!(\n            \"Generating cache key for proxy config: {:?}\",\n            (\n                &self.http_url,\n                &self.https_url,\n                &self.bypass_proxy_hosts,\n                self.mitm_ca_certificate.is_some()\n            )\n        );\n\n        let mut hasher = DefaultHasher::new();\n        (\n            &self.http_url,\n            &self.https_url,\n            &self.bypass_proxy_hosts,\n            self.mitm_ca_certificate.is_some(),\n        )\n            .hash(&mut hasher);\n\n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n\n        Some(cache_key)\n    }",
+      "diff_span": {
+        "before": "            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }",
+        "after": "            return None;\n        }\n\n        logger::debug!(\n            \"Generating cache key for proxy config: {:?}\",\n            (\n                &self.http_url,\n                &self.https_url,\n                &self.bypass_proxy_hosts,\n                self.mitm_ca_certificate.is_some()\n            )\n        );\n\n        let mut hasher = DefaultHasher::new();\n        (\n            &self.http_url,\n            &self.https_url,\n            &self.bypass_proxy_hosts,\n            self.mitm_ca_certificate.is_some(),\n        )\n            .hash(&mut hasher);\n\n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n\n        Some(cache_key)\n    }"
+      },
+      "commit_sha": "784bb96edbe27fd4c558e2a02b8c758594ebe895"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::impl::Proxy",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }\n\n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }\n}",
+      "after_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n\n        logger::debug!(\n            \"Generating cache key for proxy config: {:?}\",\n            (\n                &self.http_url,\n                &self.https_url,\n                &self.bypass_proxy_hosts,\n                self.mitm_ca_certificate.is_some()\n            )\n        );\n\n        let mut hasher = DefaultHasher::new();\n        (\n            &self.http_url,\n            &self.https_url,\n            &self.bypass_proxy_hosts,\n            self.mitm_ca_certificate.is_some(),\n        )\n            .hash(&mut hasher);\n\n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n\n        Some(cache_key)\n    }\n\n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }\n}",
+      "diff_span": {
+        "before": "            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }",
+        "after": "            return None;\n        }\n\n        logger::debug!(\n            \"Generating cache key for proxy config: {:?}\",\n            (\n                &self.http_url,\n                &self.https_url,\n                &self.bypass_proxy_hosts,\n                self.mitm_ca_certificate.is_some()\n            )\n        );\n\n        let mut hasher = DefaultHasher::new();\n        (\n            &self.http_url,\n            &self.https_url,\n            &self.bypass_proxy_hosts,\n            self.mitm_ca_certificate.is_some(),\n        )\n            .hash(&mut hasher);\n\n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n\n        Some(cache_key)\n    }"
+      },
+      "commit_sha": "784bb96edbe27fd4c558e2a02b8c758594ebe895"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n                cache_key, \n                proxy_config.http_url, \n                proxy_config.https_url\n            );\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\n                \"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\",\n                cache_key,\n                proxy_config.http_url,\n                proxy_config.https_url\n            );\n\n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n            let new_client =\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct proxy client\")?;\n\n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n                cache_key, \n                proxy_config.http_url, \n                proxy_config.https_url\n            );\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {",
+        "after": "                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n\n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\n                \"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\",\n                cache_key,\n                proxy_config.http_url,\n                proxy_config.https_url\n            );\n\n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n            let new_client =\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct proxy client\")?;\n\n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n\n        Ok(client)\n    } else {"
+      },
+      "commit_sha": "784bb96edbe27fd4c558e2a02b8c758594ebe895"
+    }
+  ]
+}

diffs/pr_10158/78b293b/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "78b293b5c26913f7c126e502cbf3ca20ec163ec8",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Some(cached_client) = cache.read().unwrap().get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n            \n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                \n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                let new_client =\n                    apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n                write_lock.insert(cache_key.clone(), new_client.clone());\n                logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                new_client\n            }\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Some(cached_client) = cache.read().unwrap().get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\n                    \"Retrieved cached proxy client after write lock for config: {:?}\",\n                    cache_key\n                );\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                let new_client =\n                    apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n                write_lock.insert(cache_key.clone(), new_client.clone());\n                logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                new_client\n            }\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n            \n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                \n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n",
+        "after": "                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\n                    \"Retrieved cached proxy client after write lock for config: {:?}\",\n                    cache_key\n                );\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n"
+      },
+      "commit_sha": "78b293b5c26913f7c126e502cbf3ca20ec163ec8"
+    }
+  ]
+}

diffs/pr_10158/7fa4343/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "7fa4343a8a350f641b41f5846e9da72aa27ec883",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_or_create_proxy_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_or_create_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    // First try read lock - fastest path for cache hits\n    if let Ok(read_lock) = cache.read() {\n        if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(cached_client.clone());\n        }\n    }\n\n    // Cache miss - need to create new client with write lock\n    let mut write_lock = cache.try_write().map_err(|_| {\n        error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to acquire proxy client cache write lock\")\n    })?;\n\n    // Double-check pattern: another thread might have created it\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        return Ok(cached_client.clone());\n    }\n\n    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n    let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n        .build()\n        .change_context(HttpClientError::ClientConstructionFailed)\n        .attach_printable(\"Failed to construct proxy client\")?;\n\n    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n    write_lock.insert(cache_key.clone(), new_client.clone());\n    logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n    \n    Ok(new_client)\n}",
+      "after_code": "fn get_or_create_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    // First try read lock - fastest path for cache hits\n    if let Ok(read_lock) = cache.read() {\n        if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(cached_client.clone());\n        }\n    }\n\n    // Cache miss - need to create new client with write lock\n    let mut write_lock = cache.try_write().map_err(|_| {\n        error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to acquire proxy client cache write lock\")\n    })?;\n\n    // Double-check pattern: another thread might have created it\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\n            \"Retrieved cached proxy client after write lock for config: {:?}\",\n            cache_key\n        );\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        return Ok(cached_client.clone());\n    }\n\n    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n    let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n        .build()\n        .change_context(HttpClientError::ClientConstructionFailed)\n        .attach_printable(\"Failed to construct proxy client\")?;\n\n    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n    write_lock.insert(cache_key.clone(), new_client.clone());\n    logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n    \n    Ok(new_client)\n}",
+      "diff_span": {
+        "before": "    // Double-check pattern: another thread might have created it\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        return Ok(cached_client.clone());",
+        "after": "    // Double-check pattern: another thread might have created it\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\n            \"Retrieved cached proxy client after write lock for config: {:?}\",\n            cache_key\n        );\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        return Ok(cached_client.clone());"
+      },
+      "commit_sha": "7fa4343a8a350f641b41f5846e9da72aa27ec883"
+    }
+  ]
+}

diffs/pr_10158/90673b5/diff.json

@@ -0,0 +1,111 @@
+{
+  "commit_sha": "90673b5ce716ba478601ddda6b445c772c18495d",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs",
+    "crates/external_services/src/http_client/metrics.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_client_builder",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub fn get_client_builder(\n    proxy_config: &Proxy,\n) -> CustomResult<reqwest::ClientBuilder, HttpClientError> {\n    let mut client_builder = reqwest::Client::builder()\n        .redirect(reqwest::redirect::Policy::none())\n        .pool_idle_timeout(Duration::from_secs(\n            proxy_config\n                .idle_pool_connection_timeout\n                .unwrap_or_default(),\n        ));\n\n    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\", proxy_config.http_url.clone(), proxy_config.https_url.clone());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy\n    if let Some(url) = proxy_config.https_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::https(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTPS proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config.clone()),\n        );\n    }\n\n    // Proxy all HTTP traffic through the configured HTTP proxy\n    if let Some(url) = proxy_config.http_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::http(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTP proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config),\n        );\n    }\n\n    Ok(client_builder)\n}",
+      "after_code": "pub fn get_client_builder(\n    proxy_config: &Proxy,\n) -> CustomResult<reqwest::ClientBuilder, HttpClientError> {\n    let mut client_builder = reqwest::Client::builder()\n        .redirect(reqwest::redirect::Policy::none())\n        .pool_idle_timeout(Duration::from_secs(\n            proxy_config\n                .idle_pool_connection_timeout\n                .unwrap_or_default(),\n        ));\n\n    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\", proxy_config.http_url.clone(), proxy_config.https_url.clone());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy\n    if let Some(url) = proxy_config.https_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::https(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTPS proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config.clone()),\n        );\n    }\n\n    // Proxy all HTTP traffic through the configured HTTP proxy\n    if let Some(url) = proxy_config.http_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::http(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTP proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config),\n        );\n    }\n\n    Ok(client_builder)\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "90673b5ce716ba478601ddda6b445c772c18495d",
+      "before_imports": [
+        "pub use common_utils::errors::CustomResult;",
+        "use router_env::{logger, metric_attributes};"
+      ],
+      "after_imports": [
+        "use router_env::logger;",
+        "pub use common_utils::errors::CustomResult;"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::create_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub fn create_client(\n    proxy_config: &Proxy,\n    client_certificate: Option<masking::Secret<String>>,\n    client_certificate_key: Option<masking::Secret<String>>,\n    ca_certificate: Option<masking::Secret<String>>,\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Case 1: Mutual TLS with client certificate and key\n    if let (Some(encoded_certificate), Some(encoded_certificate_key)) =\n        (client_certificate.clone(), client_certificate_key.clone())\n    {\n        if ca_certificate.is_some() {\n            logger::warn!(\"All of client certificate, client key, and CA certificate are provided. CA certificate will be ignored in mutual TLS setup.\");\n        }\n\n        logger::debug!(\"Creating HTTP client with mutual TLS (client cert + key)\");\n        let client_builder =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config);\n\n        let identity = create_identity_from_certificate_and_key(\n            encoded_certificate.clone(),\n            encoded_certificate_key,\n        )?;\n        let certificate_list = create_certificate(encoded_certificate)?;\n        let client_builder = certificate_list\n            .into_iter()\n            .fold(client_builder, |client_builder, certificate| {\n                client_builder.add_root_certificate(certificate)\n            });\n        return client_builder\n            .identity(identity)\n            .use_rustls_tls()\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct client with certificate and certificate key\");\n    }\n\n    // Case 2: Use provided CA certificate for server authentication only (one-way TLS)\n    if let Some(ca_pem) = ca_certificate {\n        logger::debug!(\"Creating HTTP client with one-way TLS (CA certificate)\");\n        let pem = ca_pem.expose().replace(\"\\\\r\\\\n\", \"\\n\"); // Fix escaped newlines\n        let cert = reqwest::Certificate::from_pem(pem.as_bytes())\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to parse CA certificate PEM block\")?;\n        let client_builder =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .add_root_certificate(cert);\n        return client_builder\n            .use_rustls_tls()\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct client with CA certificate\");\n    }\n\n    // Case 3: Default client (no certs)\n    logger::debug!(\"Creating default HTTP client (no client or CA certificates)\");\n    get_base_client(proxy_config)\n}",
+      "after_code": "pub fn create_client(\n    proxy_config: &Proxy,\n    client_certificate: Option<masking::Secret<String>>,\n    client_certificate_key: Option<masking::Secret<String>>,\n    ca_certificate: Option<masking::Secret<String>>,\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Case 1: Mutual TLS with client certificate and key\n    if let (Some(encoded_certificate), Some(encoded_certificate_key)) =\n        (client_certificate.clone(), client_certificate_key.clone())\n    {\n        if ca_certificate.is_some() {\n            logger::warn!(\"All of client certificate, client key, and CA certificate are provided. CA certificate will be ignored in mutual TLS setup.\");\n        }\n\n        logger::debug!(\"Creating HTTP client with mutual TLS (client cert + key)\");\n        let client_builder =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config);\n\n        let identity = create_identity_from_certificate_and_key(\n            encoded_certificate.clone(),\n            encoded_certificate_key,\n        )?;\n        let certificate_list = create_certificate(encoded_certificate)?;\n        let client_builder = certificate_list\n            .into_iter()\n            .fold(client_builder, |client_builder, certificate| {\n                client_builder.add_root_certificate(certificate)\n            });\n        return client_builder\n            .identity(identity)\n            .use_rustls_tls()\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct client with certificate and certificate key\");\n    }\n\n    // Case 2: Use provided CA certificate for server authentication only (one-way TLS)\n    if let Some(ca_pem) = ca_certificate {\n        logger::debug!(\"Creating HTTP client with one-way TLS (CA certificate)\");\n        let pem = ca_pem.expose().replace(\"\\\\r\\\\n\", \"\\n\"); // Fix escaped newlines\n        let cert = reqwest::Certificate::from_pem(pem.as_bytes())\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to parse CA certificate PEM block\")?;\n        let client_builder =\n            apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .add_root_certificate(cert);\n        return client_builder\n            .use_rustls_tls()\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct client with CA certificate\");\n    }\n\n    // Case 3: Default client (no certs)\n    logger::debug!(\"Creating default HTTP client (no client or CA certificates)\");\n    get_base_client(proxy_config)\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "90673b5ce716ba478601ddda6b445c772c18495d",
+      "before_imports": [
+        "pub use common_utils::errors::CustomResult;",
+        "use router_env::{logger, metric_attributes};"
+      ],
+      "after_imports": [
+        "use router_env::logger;",
+        "pub use common_utils::errors::CustomResult;"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::apply_mitm_certificate",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "fn apply_mitm_certificate(\n    mut client_builder: reqwest::ClientBuilder,\n    proxy_config: &Proxy,\n) -> reqwest::ClientBuilder {\n    if let Some(mitm_ca_cert) = &proxy_config.mitm_ca_certificate {\n        let pem = mitm_ca_cert.clone().expose().replace(\"\\\\r\\\\n\", \"\\n\");\n        match reqwest::Certificate::from_pem(pem.as_bytes()) {\n            Ok(cert) => {\n                logger::debug!(\"Successfully added MITM CA certificate\");\n                client_builder = client_builder.add_root_certificate(cert);\n            }\n            Err(err) => {\n                logger::error!(\n                    \"Failed to parse MITM CA certificate: {}, continuing without MITM support\",\n                    err\n                );\n            }\n        }\n    }\n    client_builder\n}",
+      "after_code": "fn apply_mitm_certificate(\n    mut client_builder: reqwest::ClientBuilder,\n    proxy_config: &Proxy,\n) -> reqwest::ClientBuilder {\n    if let Some(mitm_ca_cert) = &proxy_config.mitm_ca_certificate {\n        let pem = mitm_ca_cert.clone().expose().replace(\"\\\\r\\\\n\", \"\\n\");\n        match reqwest::Certificate::from_pem(pem.as_bytes()) {\n            Ok(cert) => {\n                logger::debug!(\"Successfully added MITM CA certificate\");\n                client_builder = client_builder.add_root_certificate(cert);\n            }\n            Err(err) => {\n                logger::error!(\n                    \"Failed to parse MITM CA certificate: {}, continuing without MITM support\",\n                    err\n                );\n            }\n        }\n    }\n    client_builder\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "90673b5ce716ba478601ddda6b445c772c18495d",
+      "before_imports": [
+        "use router_env::{logger, metric_attributes};"
+      ],
+      "after_imports": [
+        "use router_env::logger;"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        // Create simple metrics attributes for proxy client tracking\n        let http_proxy_host = extract_proxy_host(&proxy_config.http_url);\n        let https_proxy_host = extract_proxy_host(&proxy_config.https_url);\n            \n        let proxy_metrics_tag = metric_attributes!(\n            (\"client_type\", \"proxy\"),\n            (\"http_proxy_host\", http_proxy_host),\n            (\"https_proxy_host\", https_proxy_host)\n        );\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, proxy_metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, default_metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, default_metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        Ok(DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone())\n    }\n}",
+      "diff_span": {
+        "before": "    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        // Create simple metrics attributes for proxy client tracking\n        let http_proxy_host = extract_proxy_host(&proxy_config.http_url);\n        let https_proxy_host = extract_proxy_host(&proxy_config.https_url);\n            \n        let proxy_metrics_tag = metric_attributes!(\n            (\"client_type\", \"proxy\"),\n            (\"http_proxy_host\", http_proxy_host),\n            (\"https_proxy_host\", https_proxy_host)\n        );\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, proxy_metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, default_metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, default_metrics_tag);\n        Ok(client)\n    }\n}",
+        "after": "        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        Ok(DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone())\n    }\n}"
+      },
+      "commit_sha": "90673b5ce716ba478601ddda6b445c772c18495d",
+      "before_imports": [
+        "pub use common_utils::errors::CustomResult;",
+        "use super::metrics;",
+        "use router_env::{logger, metric_attributes};"
+      ],
+      "after_imports": [
+        "use router_env::logger;",
+        "pub use common_utils::errors::CustomResult;"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::extract_proxy_host",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn extract_proxy_host(url_opt: &Option<String>) -> String {\n    url_opt.as_ref()\n        .and_then(|url| url::Url::parse(url).ok())\n        .and_then(|parsed_url| parsed_url.host_str().map(|s| s.to_string()))\n        .unwrap_or_else(|| \"none\".to_string())\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "90673b5ce716ba478601ddda6b445c772c18495d"
+    }
+  ]
+}

diffs/pr_10158/9b8080e/diff.json

@@ -0,0 +1,69 @@
+{
+  "commit_sha": "9b8080e6d6ca067563686dd9dc0d02d19d4f668c",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::has_proxy_config",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }",
+      "after_code": "fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }",
+      "diff_span": {
+        "before": "fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }",
+        "after": "fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }"
+      },
+      "commit_sha": "9b8080e6d6ca067563686dd9dc0d02d19d4f668c"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::impl::Proxy",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }\n    \n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }\n}",
+      "after_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }\n\n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }\n}",
+      "diff_span": {
+        "before": "        Some(cache_key)\n    }\n    \n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }\n}",
+        "after": "        Some(cache_key)\n    }\n\n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }\n}"
+      },
+      "commit_sha": "9b8080e6d6ca067563686dd9dc0d02d19d4f668c"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_client_builder",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_client_builder(\n    proxy_config: &Proxy,\n) -> CustomResult<reqwest::ClientBuilder, HttpClientError> {\n    let mut client_builder = reqwest::Client::builder()\n        .redirect(reqwest::redirect::Policy::none())\n        .pool_idle_timeout(Duration::from_secs(\n            proxy_config\n                .idle_pool_connection_timeout\n                .unwrap_or_default(),\n        ));\n\n    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\", proxy_config.http_url.clone(), proxy_config.https_url.clone());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy\n    if let Some(url) = proxy_config.https_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::https(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTPS proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config.clone()),\n        );\n    }\n\n    // Proxy all HTTP traffic through the configured HTTP proxy\n    if let Some(url) = proxy_config.http_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::http(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTP proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config),\n        );\n    }\n\n    Ok(client_builder)\n}",
+      "after_code": "pub fn get_client_builder(\n    proxy_config: &Proxy,\n) -> CustomResult<reqwest::ClientBuilder, HttpClientError> {\n    let mut client_builder = reqwest::Client::builder()\n        .redirect(reqwest::redirect::Policy::none())\n        .pool_idle_timeout(Duration::from_secs(\n            proxy_config\n                .idle_pool_connection_timeout\n                .unwrap_or_default(),\n        ));\n\n    let proxy_exclusion_config =\n        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\n        \"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\",\n        proxy_config.http_url.clone(),\n        proxy_config.https_url.clone()\n    );\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy\n    if let Some(url) = proxy_config.https_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::https(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTPS proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config.clone()),\n        );\n    }\n\n    // Proxy all HTTP traffic through the configured HTTP proxy\n    if let Some(url) = proxy_config.http_url.as_ref() {\n        client_builder = client_builder.proxy(\n            reqwest::Proxy::http(url)\n                .change_context(HttpClientError::InvalidProxyConfiguration)\n                .attach_printable(\"HTTP proxy configuration error\")?\n                .no_proxy(proxy_exclusion_config),\n        );\n    }\n\n    Ok(client_builder)\n}",
+      "diff_span": {
+        "before": "        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\", proxy_config.http_url.clone(), proxy_config.https_url.clone());\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy",
+        "after": "        reqwest::NoProxy::from_string(&proxy_config.bypass_proxy_hosts.clone().unwrap_or_default());\n\n    logger::debug!(\n        \"Proxy HTTP Proxy -> {:?} and HTTPS Proxy -> {:?}\",\n        proxy_config.http_url.clone(),\n        proxy_config.https_url.clone()\n    );\n\n    // Proxy all HTTPS traffic through the configured HTTPS proxy"
+      },
+      "commit_sha": "9b8080e6d6ca067563686dd9dc0d02d19d4f668c"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n                cache_key, \n                proxy_config.http_url, \n                proxy_config.https_url\n            );\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n                cache_key, \n                proxy_config.http_url, \n                proxy_config.https_url\n            );\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n                cache_key, \n                proxy_config.http_url, \n                proxy_config.https_url\n            );\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)",
+        "after": "    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n                cache_key, \n                proxy_config.http_url, \n                proxy_config.https_url\n            );\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)"
+      },
+      "commit_sha": "9b8080e6d6ca067563686dd9dc0d02d19d4f668c"
+    }
+  ]
+}

diffs/pr_10158/a68697e/diff.json

@@ -0,0 +1,62 @@
+{
+  "commit_sha": "a68697e1dec36b9655444366c76d27fc68d3c251",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::cache_key",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        Some(format!(\n            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"), \n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }",
+      "after_code": "fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }",
+      "diff_span": {
+        "before": "            return None;\n        }\n        Some(format!(\n            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"), \n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }",
+        "after": "            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }"
+      },
+      "commit_sha": "a68697e1dec36b9655444366c76d27fc68d3c251",
+      "before_imports": [],
+      "after_imports": [
+        "use router_env::logger;"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::impl::Proxy",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        Some(format!(\n            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"), \n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }\n    \n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }\n}",
+      "after_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }\n    \n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() \n            || self.https_url.is_some() \n            || self.mitm_ca_certificate.is_some()\n    }\n}",
+      "diff_span": {
+        "before": "            return None;\n        }\n        Some(format!(\n            \"http:{}_https:{}_bypass:{}_timeout:{}_mitm:{}\",\n            self.http_url.as_deref().unwrap_or(\"\"),\n            self.https_url.as_deref().unwrap_or(\"\"), \n            self.bypass_proxy_hosts.as_deref().unwrap_or(\"\"),\n            self.idle_pool_connection_timeout.unwrap_or_default(),\n            self.mitm_ca_certificate.is_some()\n        ))\n    }\n    ",
+        "after": "            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }\n    "
+      },
+      "commit_sha": "a68697e1dec36b9655444366c76d27fc68d3c251",
+      "before_imports": [],
+      "after_imports": [
+        "use router_env::logger;"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n                cache_key, \n                proxy_config.http_url, \n                proxy_config.https_url\n            );\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {",
+        "after": "        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n                cache_key, \n                proxy_config.http_url, \n                proxy_config.https_url\n            );\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)"
+      },
+      "commit_sha": "a68697e1dec36b9655444366c76d27fc68d3c251"
+    }
+  ]
+}

diffs/pr_10158/acdb837/diff.json

@@ -0,0 +1,90 @@
+{
+  "commit_sha": "acdb837550fa0673212ffa1ad59d88a58453a289",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs",
+    "crates/masking/src/secret.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/masking/src/secret.rs::hash_tests::function::test_secret_hash_implementation",
+      "file": "crates/masking/src/secret.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "fn test_secret_hash_implementation() {\n        let secret1: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret2: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret3: Secret<String> = Secret::new(\"different_string\".to_string());\n\n        // Test that equal secrets hash to the same value\n        let mut hasher1 = DefaultHasher::new();\n        let mut hasher2 = DefaultHasher::new();\n        secret1.hash(&mut hasher1);\n        secret2.hash(&mut hasher2);\n        assert_eq!(hasher1.finish(), hasher2.finish());\n\n        // Test that different secrets hash to different values (usually)\n        let mut hasher3 = DefaultHasher::new();\n        secret3.hash(&mut hasher3);\n        assert_ne!(hasher1.finish(), hasher3.finish());\n    }",
+      "after_code": "fn test_secret_hash_implementation() {\n        let secret1: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret2: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret3: Secret<String> = Secret::new(\"different_string\".to_string());\n\n        // Test that equal secrets hash to the same value\n        let mut hasher1 = DefaultHasher::new();\n        let mut hasher2 = DefaultHasher::new();\n        secret1.hash(&mut hasher1);\n        secret2.hash(&mut hasher2);\n        assert_eq!(hasher1.finish(), hasher2.finish());\n\n        // Test that different secrets hash to different values (usually)\n        let mut hasher3 = DefaultHasher::new();\n        secret3.hash(&mut hasher3);\n        assert_ne!(hasher1.finish(), hasher3.finish());\n    }",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "acdb837550fa0673212ffa1ad59d88a58453a289",
+      "before_imports": [
+        "use std::hash::{Hash, Hasher, DefaultHasher};"
+      ],
+      "after_imports": [
+        "use std::hash::{DefaultHasher, Hash, Hasher};"
+      ]
+    },
+    {
+      "id": "crates/masking/src/secret.rs::mod::hash_tests",
+      "file": "crates/masking/src/secret.rs",
+      "kind": "mod_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "mod hash_tests {\n    use std::hash::{Hash, Hasher, DefaultHasher};\n    use super::*;\n\n    #[test]\n    fn test_secret_hash_implementation() {\n        let secret1: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret2: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret3: Secret<String> = Secret::new(\"different_string\".to_string());\n\n        // Test that equal secrets hash to the same value\n        let mut hasher1 = DefaultHasher::new();\n        let mut hasher2 = DefaultHasher::new();\n        secret1.hash(&mut hasher1);\n        secret2.hash(&mut hasher2);\n        assert_eq!(hasher1.finish(), hasher2.finish());\n\n        // Test that different secrets hash to different values (usually)\n        let mut hasher3 = DefaultHasher::new();\n        secret3.hash(&mut hasher3);\n        assert_ne!(hasher1.finish(), hasher3.finish());\n    }\n}",
+      "after_code": "mod hash_tests {\n    use std::hash::{DefaultHasher, Hash, Hasher};\n\n    use super::*;\n\n    #[test]\n    fn test_secret_hash_implementation() {\n        let secret1: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret2: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret3: Secret<String> = Secret::new(\"different_string\".to_string());\n\n        // Test that equal secrets hash to the same value\n        let mut hasher1 = DefaultHasher::new();\n        let mut hasher2 = DefaultHasher::new();\n        secret1.hash(&mut hasher1);\n        secret2.hash(&mut hasher2);\n        assert_eq!(hasher1.finish(), hasher2.finish());\n\n        // Test that different secrets hash to different values (usually)\n        let mut hasher3 = DefaultHasher::new();\n        secret3.hash(&mut hasher3);\n        assert_ne!(hasher1.finish(), hasher3.finish());\n    }\n}",
+      "diff_span": {
+        "before": "mod hash_tests {\n    use std::hash::{Hash, Hasher, DefaultHasher};\n    use super::*;\n",
+        "after": "mod hash_tests {\n    use std::hash::{DefaultHasher, Hash, Hasher};\n\n    use super::*;\n"
+      },
+      "commit_sha": "acdb837550fa0673212ffa1ad59d88a58453a289",
+      "before_imports": [
+        "use super::*;",
+        "use std::hash::{Hash, Hasher, DefaultHasher};"
+      ],
+      "after_imports": [
+        "use std::hash::{DefaultHasher, Hash, Hasher};",
+        "use super::*;"
+      ]
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Some(cached_client) = cache.read().unwrap().get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\n                    \"Retrieved cached proxy client after write lock for config: {:?}\",\n                    cache_key\n                );\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                let new_client =\n                    apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n                write_lock.insert(cache_key.clone(), new_client.clone());\n                logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                new_client\n            }\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\n            \"Using proxy-specific client cache with key: {:?}\",\n            cache_key\n        );\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n\n        let client = if let Some(cached_client) = cache.read().unwrap().get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            if let Some(cached_client) = write_lock.get(&cache_key) {\n                logger::debug!(\n                    \"Retrieved cached proxy client after write lock for config: {:?}\",\n                    cache_key\n                );\n                metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                cached_client.clone()\n            } else {\n                logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n\n                metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                let new_client =\n                    apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n\n                write_lock.insert(cache_key.clone(), new_client.clone());\n                logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                new_client\n            }\n        };\n\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n        \n        let client = if let Some(cached_client) = cache.read().unwrap().get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);",
+        "after": "\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| RwLock::new(HashMap::new()));\n\n        let client = if let Some(cached_client) = cache.read().unwrap().get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);"
+      },
+      "commit_sha": "acdb837550fa0673212ffa1ad59d88a58453a289"
+    },
+    {
+      "id": "crates/masking/src/secret.rs::Secret<SecretValue, MaskingStrategy>::function::hash",
+      "file": "crates/masking/src/secret.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "fn hash<H: std::hash::Hasher>(&self, state: &mut H) {\n        self.peek().hash(state);\n    }",
+      "after_code": "fn hash<H: std::hash::Hasher>(&self, state: &mut H) {\n        self.peek().hash(state);\n    }",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "acdb837550fa0673212ffa1ad59d88a58453a289",
+      "before_imports": [
+        "use std::hash::{Hash, Hasher, DefaultHasher};"
+      ],
+      "after_imports": [
+        "use std::hash::{DefaultHasher, Hash, Hasher};"
+      ]
+    }
+  ]
+}

diffs/pr_10158/af4489c/diff.json

@@ -0,0 +1,74 @@
+{
+  "commit_sha": "af4489c7c1a144b7121386e006af5839afffddc3",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/masking/src/secret.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/masking/src/secret.rs::hash_tests::function::test_secret_hash_implementation",
+      "file": "crates/masking/src/secret.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "fn test_secret_hash_implementation() {\n        let secret1: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret2: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret3: Secret<String> = Secret::new(\"different_string\".to_string());\n\n        // Test that equal secrets hash to the same value\n        let mut hasher1 = DefaultHasher::new();\n        let mut hasher2 = DefaultHasher::new();\n        secret1.hash(&mut hasher1);\n        secret2.hash(&mut hasher2);\n        assert_eq!(hasher1.finish(), hasher2.finish());\n\n        // Test that different secrets hash to different values (usually)\n        let mut hasher3 = DefaultHasher::new();\n        secret3.hash(&mut hasher3);\n        assert_ne!(hasher1.finish(), hasher3.finish());\n    }",
+      "after_code": "fn test_secret_hash_implementation() {\n        let secret1: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret2: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret3: Secret<String> = Secret::new(\"different_string\".to_string());\n\n        // Test that equal secrets hash to the same value\n        let mut hasher1 = DefaultHasher::new();\n        let mut hasher2 = DefaultHasher::new();\n        secret1.hash(&mut hasher1);\n        secret2.hash(&mut hasher2);\n        assert_eq!(hasher1.finish(), hasher2.finish());\n\n        // Test that different secrets hash to different values (usually)\n        let mut hasher3 = DefaultHasher::new();\n        secret3.hash(&mut hasher3);\n        assert_ne!(hasher1.finish(), hasher3.finish());\n    }",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "af4489c7c1a144b7121386e006af5839afffddc3",
+      "before_imports": [
+        "use std::hash::{Hash, Hasher, DefaultHasher};"
+      ],
+      "after_imports": [
+        "use std::hash::{DefaultHasher, Hash, Hasher};"
+      ]
+    },
+    {
+      "id": "crates/masking/src/secret.rs::mod::hash_tests",
+      "file": "crates/masking/src/secret.rs",
+      "kind": "mod_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "mod hash_tests {\n    use std::hash::{Hash, Hasher, DefaultHasher};\n    use super::*;\n\n    #[test]\n    fn test_secret_hash_implementation() {\n        let secret1: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret2: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret3: Secret<String> = Secret::new(\"different_string\".to_string());\n\n        // Test that equal secrets hash to the same value\n        let mut hasher1 = DefaultHasher::new();\n        let mut hasher2 = DefaultHasher::new();\n        secret1.hash(&mut hasher1);\n        secret2.hash(&mut hasher2);\n        assert_eq!(hasher1.finish(), hasher2.finish());\n\n        // Test that different secrets hash to different values (usually)\n        let mut hasher3 = DefaultHasher::new();\n        secret3.hash(&mut hasher3);\n        assert_ne!(hasher1.finish(), hasher3.finish());\n    }\n}",
+      "after_code": "mod hash_tests {\n    use std::hash::{DefaultHasher, Hash, Hasher};\n\n    use super::*;\n\n    #[test]\n    fn test_secret_hash_implementation() {\n        let secret1: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret2: Secret<String> = Secret::new(\"test_string\".to_string());\n        let secret3: Secret<String> = Secret::new(\"different_string\".to_string());\n\n        // Test that equal secrets hash to the same value\n        let mut hasher1 = DefaultHasher::new();\n        let mut hasher2 = DefaultHasher::new();\n        secret1.hash(&mut hasher1);\n        secret2.hash(&mut hasher2);\n        assert_eq!(hasher1.finish(), hasher2.finish());\n\n        // Test that different secrets hash to different values (usually)\n        let mut hasher3 = DefaultHasher::new();\n        secret3.hash(&mut hasher3);\n        assert_ne!(hasher1.finish(), hasher3.finish());\n    }\n}",
+      "diff_span": {
+        "before": "mod hash_tests {\n    use std::hash::{Hash, Hasher, DefaultHasher};\n    use super::*;\n",
+        "after": "mod hash_tests {\n    use std::hash::{DefaultHasher, Hash, Hasher};\n\n    use super::*;\n"
+      },
+      "commit_sha": "af4489c7c1a144b7121386e006af5839afffddc3",
+      "before_imports": [
+        "use super::*;",
+        "use std::hash::{Hash, Hasher, DefaultHasher};"
+      ],
+      "after_imports": [
+        "use std::hash::{DefaultHasher, Hash, Hasher};",
+        "use super::*;"
+      ]
+    },
+    {
+      "id": "crates/masking/src/secret.rs::Secret<SecretValue, MaskingStrategy>::function::hash",
+      "file": "crates/masking/src/secret.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "fn hash<H: std::hash::Hasher>(&self, state: &mut H) {\n        self.peek().hash(state);\n    }",
+      "after_code": "fn hash<H: std::hash::Hasher>(&self, state: &mut H) {\n        self.peek().hash(state);\n    }",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "af4489c7c1a144b7121386e006af5839afffddc3",
+      "before_imports": [
+        "use std::hash::{Hash, Hasher, DefaultHasher};"
+      ],
+      "after_imports": [
+        "use std::hash::{DefaultHasher, Hash, Hasher};"
+      ]
+    }
+  ]
+}

diffs/pr_10158/c1d8ffc/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "c1d8ffc66e4944c5a820e0ff749d9e1ceb46882b",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        // Create simple metrics attributes for proxy client tracking\n        let http_proxy_host = extract_proxy_host(&proxy_config.http_url);\n        let https_proxy_host = extract_proxy_host(&proxy_config.https_url);\n            \n        let proxy_metrics_tag = metric_attributes!(\n            (\"client_type\", \"proxy\"),\n            (\"http_proxy_host\", http_proxy_host),\n            (\"https_proxy_host\", https_proxy_host)\n        );\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, proxy_metrics_tag.clone());\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, default_metrics_tag.clone());\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, default_metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n        \n        // Create simple metrics attributes for proxy client tracking\n        let http_proxy_host = extract_proxy_host(&proxy_config.http_url);\n        let https_proxy_host = extract_proxy_host(&proxy_config.https_url);\n            \n        let proxy_metrics_tag = metric_attributes!(\n            (\"client_type\", \"proxy\"),\n            (\"http_proxy_host\", http_proxy_host),\n            (\"https_proxy_host\", https_proxy_host)\n        );\n        \n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, &proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, &proxy_metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, &proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, &default_metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, &default_metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, proxy_metrics_tag.clone());\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, default_metrics_tag.clone());\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, default_metrics_tag);\n        Ok(client)\n    }",
+        "after": "        if let Some(client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, &proxy_metrics_tag);\n            return Ok(client.clone());\n        }\n        \n        // Create new proxy client if not in cache\n        logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n            cache_key, \n            proxy_config.http_url, \n            proxy_config.https_url\n        );\n        \n        metrics::HTTP_CLIENT_CACHE_MISS.add(1, &proxy_metrics_tag);\n        \n        let client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n            .build()\n            .change_context(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to construct proxy client\")?;\n        \n        metrics::HTTP_CLIENT_CREATED.add(1, &proxy_metrics_tag);\n        \n        cache_lock.insert(cache_key.clone(), client.clone());\n        logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n        \n        let default_metrics_tag = metric_attributes!((\"client_type\", \"default\"));\n        \n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, &default_metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n            \n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, &default_metrics_tag);\n        Ok(client)\n    }"
+      },
+      "commit_sha": "c1d8ffc66e4944c5a820e0ff749d9e1ceb46882b"
+    }
+  ]
+}

diffs/pr_10158/de60299/diff.json

@@ -0,0 +1,120 @@
+{
+  "commit_sha": "de60299a2a38cc7d3d237cbc8579b464ad0c008f",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs",
+    "crates/hyperswitch_interfaces/src/types.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::trait::ProxyClientCacheKey",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "trait ProxyClientCacheKey {\n    fn cache_key(&self) -> Option<String>;\n    fn has_proxy_config(&self) -> bool;\n}",
+      "after_code": "trait ProxyClientCacheKey {\n    fn cache_key(&self) -> Option<Proxy>;\n}",
+      "diff_span": {
+        "before": "trait ProxyClientCacheKey {\n    fn cache_key(&self) -> Option<String>;\n    fn has_proxy_config(&self) -> bool;\n}",
+        "after": "trait ProxyClientCacheKey {\n    fn cache_key(&self) -> Option<Proxy>;\n}"
+      },
+      "commit_sha": "de60299a2a38cc7d3d237cbc8579b464ad0c008f"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_base_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n                cache_key, \n                proxy_config.http_url, \n                proxy_config.https_url\n            );\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "after_code": "fn get_base_client(proxy_config: &Proxy) -> CustomResult<reqwest::Client, HttpClientError> {\n    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {:?}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n            new_client\n        };\n        \n        Ok(client)\n    } else {\n        logger::debug!(\"No proxy configuration detected, using DEFAULT_CLIENT\");\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"default\"));\n\n        // Use DEFAULT_CLIENT for non-proxy scenarios\n        let client = DEFAULT_CLIENT\n            .get_or_try_init(|| {\n                logger::info!(\"Initializing DEFAULT_CLIENT (no proxy configuration)\");\n                metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                    .build()\n                    .change_context(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to construct default client\")\n            })?\n            .clone();\n\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        Ok(client)\n    }\n}",
+      "diff_span": {
+        "before": "    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for key: {}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for key: {} (http_proxy: {:?}, https_proxy: {:?})\", \n                cache_key, \n                proxy_config.http_url, \n                proxy_config.https_url\n            );\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client with key: {}\", cache_key);\n            new_client\n        };",
+        "after": "    // Check if proxy configuration is provided using trait method\n    if let Some(cache_key) = proxy_config.cache_key() {\n        logger::debug!(\"Using proxy-specific client cache with key: {:?}\", cache_key);\n\n        let metrics_tag = router_env::metric_attributes!((\"client_type\", \"proxy\"));\n\n        // Use proxy-specific client cache\n        let cache = PROXY_CLIENT_CACHE.get_or_init(|| Mutex::new(HashMap::new()));\n        let mut cache_lock = cache.lock().map_err(|_| {\n            error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to acquire proxy client cache lock\")\n        })?;\n        \n        let client = if let Some(cached_client) = cache_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client.clone()\n        } else {\n            // Create new proxy client if not in cache\n            logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n            \n            metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n            \n            let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                .build()\n                .change_context(HttpClientError::ClientConstructionFailed)\n                .attach_printable(\"Failed to construct proxy client\")?;\n            \n            metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n            \n            cache_lock.insert(cache_key.clone(), new_client.clone());\n            logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n            new_client\n        };"
+      },
+      "commit_sha": "de60299a2a38cc7d3d237cbc8579b464ad0c008f"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::cache_key",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }",
+      "after_code": "fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n            \n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }",
+      "diff_span": {
+        "before": "fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }",
+        "after": "fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n            \n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }"
+      },
+      "commit_sha": "de60299a2a38cc7d3d237cbc8579b464ad0c008f"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::static::PROXY_CLIENT_CACHE",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "static_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "static PROXY_CLIENT_CACHE: OnceCell<Mutex<HashMap<String, reqwest::Client>>> = OnceCell::new();",
+      "after_code": "static PROXY_CLIENT_CACHE: OnceCell<Mutex<HashMap<Proxy, reqwest::Client>>> = OnceCell::new();",
+      "diff_span": {
+        "before": "static PROXY_CLIENT_CACHE: OnceCell<Mutex<HashMap<String, reqwest::Client>>> = OnceCell::new();",
+        "after": "static PROXY_CLIENT_CACHE: OnceCell<Mutex<HashMap<Proxy, reqwest::Client>>> = OnceCell::new();"
+      },
+      "commit_sha": "de60299a2a38cc7d3d237cbc8579b464ad0c008f"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::impl::Proxy",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }\n\n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }\n}",
+      "after_code": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n            \n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }\n}",
+      "diff_span": {
+        "before": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<String> {\n        if !self.has_proxy_config() {\n            return None;\n        }\n        \n        logger::debug!(\"Generating cache key for proxy config: {:?}\",\n            (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some())\n        );\n        \n        let mut hasher = DefaultHasher::new();\n        (&self.http_url, &self.https_url, &self.bypass_proxy_hosts, self.mitm_ca_certificate.is_some()).hash(&mut hasher);\n        \n        let cache_key = format!(\"proxy_{:x}\", hasher.finish());\n        logger::debug!(\"Generated cache key: {}\", cache_key);\n        \n        Some(cache_key)\n    }\n\n    fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }\n}",
+        "after": "impl ProxyClientCacheKey for Proxy {\n    fn cache_key(&self) -> Option<Proxy> {\n        if self.has_proxy_config() {\n            logger::debug!(\"Using proxy config as cache key: {:?}\", self);\n            \n            // Return a clone of the proxy config for caching\n            // Exclude timeout from cache key by creating a normalized version\n            Some(Proxy {\n                http_url: self.http_url.clone(),\n                https_url: self.https_url.clone(),\n                bypass_proxy_hosts: self.bypass_proxy_hosts.clone(),\n                mitm_ca_certificate: self.mitm_ca_certificate.clone(),\n                idle_pool_connection_timeout: None, // Exclude timeout from cache key\n                mitm_enabled: self.mitm_enabled,\n            })\n        } else {\n            None\n        }\n    }"
+      },
+      "commit_sha": "de60299a2a38cc7d3d237cbc8579b464ad0c008f"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/types.rs::impl::Proxy",
+      "file": "crates/hyperswitch_interfaces/src/types.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl Default for Proxy {\n    fn default() -> Self {\n        Self {\n            http_url: Default::default(),\n            https_url: Default::default(),\n            idle_pool_connection_timeout: Some(90),\n            bypass_proxy_hosts: Default::default(),\n            mitm_ca_certificate: None,\n            mitm_enabled: None,\n        }\n    }\n}",
+      "after_code": "impl Proxy {\n    /// Check if any proxy configuration is present\n    pub fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some()\n    }\n}",
+      "diff_span": {
+        "before": "impl Default for Proxy {\n    fn default() -> Self {\n        Self {\n            http_url: Default::default(),\n            https_url: Default::default(),\n            idle_pool_connection_timeout: Some(90),\n            bypass_proxy_hosts: Default::default(),\n            mitm_ca_certificate: None,\n            mitm_enabled: None,\n        }\n    }\n}",
+        "after": "impl Proxy {\n    /// Check if any proxy configuration is present\n    pub fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some()\n    }\n}"
+      },
+      "commit_sha": "de60299a2a38cc7d3d237cbc8579b464ad0c008f"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/types.rs::Proxy::function::has_proxy_config",
+      "file": "crates/hyperswitch_interfaces/src/types.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some()\n    }",
+      "diff_span": null,
+      "commit_sha": "de60299a2a38cc7d3d237cbc8579b464ad0c008f"
+    },
+    {
+      "id": "crates/external_services/src/http_client/client.rs::Proxy::function::has_proxy_config",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn has_proxy_config(&self) -> bool {\n        self.http_url.is_some() || self.https_url.is_some() || self.mitm_ca_certificate.is_some()\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "de60299a2a38cc7d3d237cbc8579b464ad0c008f"
+    }
+  ]
+}

diffs/pr_10158/e5a739c/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "e5a739c9f4ab41e937772c3a646bfc65210819ef",
+  "pr_number": 10158,
+  "rust_files": [
+    "crates/external_services/src/http_client/client.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/src/http_client/client.rs::function::get_or_create_proxy_client",
+      "file": "crates/external_services/src/http_client/client.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_or_create_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    // First try read lock - fastest path for cache hits\n    if let Ok(read_lock) = cache.read() {\n        if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(cached_client.clone());\n        }\n    }\n\n    // Cache miss - need to create new client with write lock\n    let mut write_lock = cache.try_write().map_err(|_| {\n        error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to acquire proxy client cache write lock\")\n    })?;\n\n    // Double-check pattern: another thread might have created it\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\n            \"Retrieved cached proxy client after write lock for config: {:?}\",\n            cache_key\n        );\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        return Ok(cached_client.clone());\n    }\n\n    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n    let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n        .build()\n        .change_context(HttpClientError::ClientConstructionFailed)\n        .attach_printable(\"Failed to construct proxy client\")?;\n\n    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n    write_lock.insert(cache_key.clone(), new_client.clone());\n    logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n    \n    Ok(new_client)\n}",
+      "after_code": "fn get_or_create_proxy_client(\n    cache: &RwLock<HashMap<Proxy, reqwest::Client>>,\n    cache_key: Proxy,\n    proxy_config: &Proxy,\n    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    let read_result = cache.read().ok().and_then(|read_lock| read_lock.get(&cache_key).cloned());\n    \n    let client = match read_result {\n        Some(cached_client) => {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client\n        }\n        None => {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            match write_lock.get(&cache_key) {\n                Some(cached_client) => {\n                    logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n                    metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                    cached_client.clone()\n                }\n                None => {\n                    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                    let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                    write_lock.insert(cache_key.clone(), new_client.clone());\n                    logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                    new_client\n                }\n            }\n        }\n    };\n\n    Ok(client)\n}",
+      "diff_span": {
+        "before": "    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    // First try read lock - fastest path for cache hits\n    if let Ok(read_lock) = cache.read() {\n        if let Some(cached_client) = read_lock.get(&cache_key) {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            return Ok(cached_client.clone());\n        }\n    }\n\n    // Cache miss - need to create new client with write lock\n    let mut write_lock = cache.try_write().map_err(|_| {\n        error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n            .attach_printable(\"Failed to acquire proxy client cache write lock\")\n    })?;\n\n    // Double-check pattern: another thread might have created it\n    if let Some(cached_client) = write_lock.get(&cache_key) {\n        logger::debug!(\n            \"Retrieved cached proxy client after write lock for config: {:?}\",\n            cache_key\n        );\n        metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n        return Ok(cached_client.clone());\n    }\n\n    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n    let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n        .build()\n        .change_context(HttpClientError::ClientConstructionFailed)\n        .attach_printable(\"Failed to construct proxy client\")?;\n\n    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n    write_lock.insert(cache_key.clone(), new_client.clone());\n    logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n    \n    Ok(new_client)\n}",
+        "after": "    metrics_tag: &[router_env::opentelemetry::KeyValue],\n) -> CustomResult<reqwest::Client, HttpClientError> {\n    let read_result = cache.read().ok().and_then(|read_lock| read_lock.get(&cache_key).cloned());\n    \n    let client = match read_result {\n        Some(cached_client) => {\n            logger::debug!(\"Retrieved cached proxy client for config: {:?}\", cache_key);\n            metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n            cached_client\n        }\n        None => {\n            let mut write_lock = cache.try_write().map_err(|_| {\n                error_stack::Report::new(HttpClientError::ClientConstructionFailed)\n                    .attach_printable(\"Failed to acquire proxy client cache write lock\")\n            })?;\n\n            match write_lock.get(&cache_key) {\n                Some(cached_client) => {\n                    logger::debug!(\"Retrieved cached proxy client after write lock for config: {:?}\", cache_key);\n                    metrics::HTTP_CLIENT_CACHE_HIT.add(1, metrics_tag);\n                    cached_client.clone()\n                }\n                None => {\n                    logger::info!(\"Creating new proxy client for config: {:?}\", cache_key);\n                    metrics::HTTP_CLIENT_CACHE_MISS.add(1, metrics_tag);\n\n                    let new_client = apply_mitm_certificate(get_client_builder(proxy_config)?, proxy_config)\n                        .build()\n                        .change_context(HttpClientError::ClientConstructionFailed)\n                        .attach_printable(\"Failed to construct proxy client\")?;\n\n                    metrics::HTTP_CLIENT_CREATED.add(1, metrics_tag);\n                    write_lock.insert(cache_key.clone(), new_client.clone());\n                    logger::debug!(\"Cached new proxy client for config: {:?}\", cache_key);\n                    new_client\n                }\n            }\n        }\n    };\n\n    Ok(client)\n}"
+      },
+      "commit_sha": "e5a739c9f4ab41e937772c3a646bfc65210819ef"
+    }
+  ]
+}