Add provider to fetch_token() spans

Author: djc

src/config_default_credentials.rs

@@ -49,31 +49,28 @@ impl ConfigDefaultCredentials {
         })
     }
 
-    #[instrument(level = Level::DEBUG, skip(cred, client))]
+    #[instrument(level = Level::DEBUG, skip(cred, client), fields(provider = "ConfigDefaultCredentials"))]
     async fn fetch_token(
         cred: &AuthorizedUserRefreshToken,
         client: &HttpClient,
     ) -> Result<Arc<Token>, Error> {
         client
-            .token(
-                &|| {
-                    Request::builder()
-                        .method(Method::POST)
-                        .uri(DEFAULT_TOKEN_GCP_URI)
-                        .header(CONTENT_TYPE, "application/json")
-                        .body(Full::from(Bytes::from(
-                            serde_json::to_vec(&RefreshRequest {
-                                client_id: &cred.client_id,
-                                client_secret: &cred.client_secret,
-                                grant_type: "refresh_token",
-                                refresh_token: &cred.refresh_token,
-                            })
-                            .unwrap(),
-                        )))
-                        .unwrap()
-                },
-                "ConfigDefaultCredentials",
-            )
+            .token(&|| {
+                Request::builder()
+                    .method(Method::POST)
+                    .uri(DEFAULT_TOKEN_GCP_URI)
+                    .header(CONTENT_TYPE, "application/json")
+                    .body(Full::from(Bytes::from(
+                        serde_json::to_vec(&RefreshRequest {
+                            client_id: &cred.client_id,
+                            client_secret: &cred.client_secret,
+                            grant_type: "refresh_token",
+                            refresh_token: &cred.refresh_token,
+                        })
+                        .unwrap(),
+                    )))
+                    .unwrap()
+            })
             .await
     }
 }

src/custom_service_account.rs

@@ -70,7 +70,7 @@ impl CustomServiceAccount {
         })
     }
 
-    #[instrument(level = Level::DEBUG, skip(self))]
+    #[instrument(level = Level::DEBUG, skip(self), fields(provider = "CustomServiceAccount"))]
     async fn fetch_token(&self, scopes: &[&str]) -> Result<Arc<Token>, Error> {
         let jwt =
             Claims::new(&self.credentials, scopes, self.subject.as_deref()).to_jwt(&self.signer)?;
@@ -83,15 +83,12 @@ impl CustomServiceAccount {
 
         let token = self
             .client
-            .token(
-                &|| {
-                    Request::post(&self.credentials.token_uri)
-                        .header(CONTENT_TYPE, "application/x-www-form-urlencoded")
-                        .body(Full::from(body.clone()))
-                        .unwrap()
-                },
-                "CustomServiceAccount",
-            )
+            .token(&|| {
+                Request::post(&self.credentials.token_uri)
+                    .header(CONTENT_TYPE, "application/x-www-form-urlencoded")
+                    .body(Full::from(body.clone()))
+                    .unwrap()
+            })
             .await?;
 
         Ok(token)

src/gcloud_authorized_user.rs

@@ -28,7 +28,7 @@ impl GCloudAuthorizedUser {
         })
     }
 
-    #[instrument(level = tracing::Level::DEBUG)]
+    #[instrument(level = tracing::Level::DEBUG, fields(provider = "GCloudAuthorizedUser"))]
     fn fetch_token() -> Result<Arc<Token>, Error> {
         Ok(Arc::new(Token::from_string(
             run(&["auth", "print-access-token", "--quiet"])?,

src/metadata_service_account.rs

@@ -34,7 +34,7 @@ impl MetadataServiceAccount {
 
         debug!("getting project ID from GCP instance metadata server");
         let req = metadata_request(DEFAULT_PROJECT_ID_GCP_URI);
-        let body = client.request(req, "MetadataServiceAccount").await?;
+        let body = client.request(req).await?;
         let project_id = match str::from_utf8(&body) {
             Ok(s) if !s.is_empty() => Arc::from(s),
             Ok(_) => {
@@ -56,13 +56,10 @@ impl MetadataServiceAccount {
         })
     }
 
-    #[instrument(level = Level::DEBUG, skip(client))]
+    #[instrument(level = Level::DEBUG, skip(client), fields(provider = "MetadataServiceAccount"))]
     async fn fetch_token(client: &HttpClient) -> Result<Arc<Token>, Error> {
         client
-            .token(
-                &|| metadata_request(DEFAULT_TOKEN_GCP_URI),
-                "MetadataServiceAccount",
-            )
+            .token(&|| metadata_request(DEFAULT_TOKEN_GCP_URI))
             .await
     }
 }

src/types.rs

@@ -48,20 +48,16 @@ impl HttpClient {
     pub(crate) async fn token(
         &self,
         request: &impl Fn() -> Request<Full<Bytes>>,
-        provider: &'static str,
     ) -> Result<Arc<Token>, Error> {
         let mut retries = 0;
         let body = loop {
-            let err = match self.request(request(), provider).await {
+            let err = match self.request(request()).await {
                 // Early return when the request succeeds
                 Ok(body) => break body,
                 Err(err) => err,
             };
 
-            warn!(
-                ?err,
-                provider, retries, "failed to refresh token, trying again..."
-            );
+            warn!(?err, retries, "failed to refresh token, trying again...");
 
             retries += 1;
             if retries >= RETRY_COUNT {
@@ -73,12 +69,8 @@ impl HttpClient {
             .map_err(|err| Error::Json("failed to deserialize token from response", err))
     }
 
-    pub(crate) async fn request(
-        &self,
-        req: Request<Full<Bytes>>,
-        provider: &'static str,
-    ) -> Result<Bytes, Error> {
-        debug!(url = ?req.uri(), provider, "requesting token");
+    pub(crate) async fn request(&self, req: Request<Full<Bytes>>) -> Result<Bytes, Error> {
+        debug!(url = ?req.uri(), "requesting token");
         let (parts, body) = self
             .inner
             .request(req)