feat: add an option to pass the request id in the API client

Now you can send a header `x-request-id` to the API.

```rust
let request_id = Uuid::new_v4();

let response = Client::new(env.get_connection_info())
    .get_request_with_query(
        "stats",
        Query::params([QueryParam::new("token", "")].to_vec()),
        Some(headers_with_request_id(request_id)),
    )
    .await;
```

That ID is recorded in logs. So you can use it to track the request.

Author: josecelano

tests/servers/api/v1/client.rs

@@ -1,5 +1,7 @@
+use hyper::HeaderMap;
 use reqwest::Response;
 use serde::Serialize;
+use uuid::Uuid;
 
 use crate::common::http::{Query, QueryParam, ReqwestQuery};
 use crate::servers::api::connection_info::ConnectionInfo;
@@ -65,7 +67,7 @@ impl Client {
             query.add_param(QueryParam::new("token", token));
         };
 
-        self.get_request_with_query(path, query).await
+        self.get_request_with_query(path, query, None).await
     }
 
     pub async fn post_empty(&self, path: &str) -> Response {
@@ -96,12 +98,12 @@ impl Client {
             .unwrap()
     }
 
-    pub async fn get_request_with_query(&self, path: &str, params: Query) -> Response {
-        get(&self.base_url(path), Some(params)).await
+    pub async fn get_request_with_query(&self, path: &str, params: Query, headers: Option<HeaderMap>) -> Response {
+        get(&self.base_url(path), Some(params), headers).await
     }
 
     pub async fn get_request(&self, path: &str) -> Response {
-        get(&self.base_url(path), None).await
+        get(&self.base_url(path), None, None).await
     }
 
     fn query_with_token(&self) -> Query {
@@ -116,18 +118,27 @@ impl Client {
     }
 }
 
-pub async fn get(path: &str, query: Option<Query>) -> Response {
-    match query {
-        Some(params) => reqwest::Client::builder()
-            .build()
-            .unwrap()
-            .get(path)
-            .query(&ReqwestQuery::from(params))
-            .send()
-            .await
-            .unwrap(),
-        None => reqwest::Client::builder().build().unwrap().get(path).send().await.unwrap(),
-    }
+pub async fn get(path: &str, query: Option<Query>, headers: Option<HeaderMap>) -> Response {
+    let builder = reqwest::Client::builder().build().unwrap();
+
+    let builder = match query {
+        Some(params) => builder.get(path).query(&ReqwestQuery::from(params)),
+        None => builder.get(path),
+    };
+
+    let builder = match headers {
+        Some(headers) => builder.headers(headers),
+        None => builder,
+    };
+
+    builder.send().await.unwrap()
+}
+
+/// Returns a `HeaderMap` with a request id header
+pub fn headers_with_request_id(request_id: Uuid) -> HeaderMap {
+    let mut headers = HeaderMap::new();
+    headers.insert("x-request-id", request_id.to_string().parse().unwrap());
+    headers
 }
 
 #[derive(Serialize, Debug)]

tests/servers/api/v1/contract/authentication.rs

@@ -1,9 +1,10 @@
 use torrust_tracker_test_helpers::configuration;
+use uuid::Uuid;
 
 use crate::common::http::{Query, QueryParam};
-use crate::common::logging::{self};
+use crate::common::logging::{self, logs_contains_a_line_with};
 use crate::servers::api::v1::asserts::{assert_token_not_valid, assert_unauthorized};
-use crate::servers::api::v1::client::Client;
+use crate::servers::api::v1::client::{headers_with_request_id, Client};
 use crate::servers::api::Started;
 
 #[tokio::test]
@@ -15,7 +16,7 @@ async fn should_authenticate_requests_by_using_a_token_query_param() {
     let token = env.get_connection_info().api_token.unwrap();
 
     let response = Client::new(env.get_connection_info())
-        .get_request_with_query("stats", Query::params([QueryParam::new("token", &token)].to_vec()))
+        .get_request_with_query("stats", Query::params([QueryParam::new("token", &token)].to_vec()), None)
         .await;
 
     assert_eq!(response.status(), 200);
@@ -30,7 +31,7 @@ async fn should_not_authenticate_requests_when_the_token_is_missing() {
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let response = Client::new(env.get_connection_info())
-        .get_request_with_query("stats", Query::default())
+        .get_request_with_query("stats", Query::default(), None)
         .await;
 
     assert_unauthorized(response).await;
@@ -44,13 +45,24 @@ async fn should_not_authenticate_requests_when_the_token_is_empty() {
 
     let env = Started::new(&configuration::ephemeral().into()).await;
 
+    let request_id = Uuid::new_v4();
+
     let response = Client::new(env.get_connection_info())
-        .get_request_with_query("stats", Query::params([QueryParam::new("token", "")].to_vec()))
+        .get_request_with_query(
+            "stats",
+            Query::params([QueryParam::new("token", "")].to_vec()),
+            Some(headers_with_request_id(request_id)),
+        )
         .await;
 
     assert_token_not_valid(response).await;
 
     env.stop().await;
+
+    assert!(
+        logs_contains_a_line_with(&["ERROR", "API", &format!("{request_id}")]),
+        "Expected logs to contain: ERROR ... API ... request_id={request_id}"
+    );
 }
 
 #[tokio::test]
@@ -60,7 +72,11 @@ async fn should_not_authenticate_requests_when_the_token_is_invalid() {
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let response = Client::new(env.get_connection_info())
-        .get_request_with_query("stats", Query::params([QueryParam::new("token", "INVALID TOKEN")].to_vec()))
+        .get_request_with_query(
+            "stats",
+            Query::params([QueryParam::new("token", "INVALID TOKEN")].to_vec()),
+            None,
+        )
         .await;
 
     assert_token_not_valid(response).await;

tests/servers/api/v1/contract/context/health_check.rs

@@ -13,7 +13,7 @@ async fn health_check_endpoint_should_return_status_ok_if_api_is_running() {
 
     let url = format!("http://{}/api/health_check", env.get_connection_info().bind_address);
 
-    let response = get(&url, None).await;
+    let response = get(&url, None, None).await;
 
     assert_eq!(response.status(), 200);
     assert_eq!(response.headers().get("content-type").unwrap(), "application/json");