refactor: tracing cleanup

Signed-off-by: Nick Gerakines <[e-mail]>

CLAUDE.md

···
 
 Use tracing for structured logging.
 
+All calls to `tracing::error`, `tracing::warn`, `tracing::info`, `tracing::debug`, and `tracing::trace` should be fully qualified.
+
+Do not use the `println!` macro in library code.
+
 Async calls should be instrumented using the `.instrument()` that references the `use tracing::Instrument;` trait.
 
 ## Module Structure

crates/atproto-xrpcs-helloworld/src/main.rs

···
                 "publicKeyMultibase": public_service_key
             }],
             "service":[{
-                "id":"#bsky_appview",
-                "type":"BskyAppView",
+                "id":"#helloworld",
+                "type":"HelloWorldService",
                 "serviceEndpoint":format!("https://{external_base}")
             }]
         }

crates/atproto-xrpcs/src/authorization.rs

···
 use base64::engine::general_purpose;
 use std::convert::Infallible;
 use std::sync::Arc;
-use tracing::{debug, error, info};
 
 use crate::errors::AuthorizationError;
 
···
         let token = match auth_header {
             Some(token) => token.to_string(),
             None => {
-                debug!("No Authorization header found or Bearer token missing");
+                tracing::debug!("No Authorization header found or Bearer token missing");
                 return Ok(None);
             }
         };
···
 
         match validate_jwt(&token, did_document_storage.0, None).await {
             Ok((header, claims)) => {
-                debug!("JWT successfully validated");
+                tracing::debug!("JWT successfully validated");
                 Ok(Some(Authorization(header, claims, token, true)))
             }
             Err(e) => {
-                error!(error = ?e, "JWT validation failed");
+                tracing::error!(error = ?e, "JWT validation failed");
                 // Return unvalidated authorization so the handler can decide what to do
                 let header = Header::default();
                 let claims = Claims::default();
···
         let token = match auth_header {
             Some(token) => token.to_string(),
             None => {
-                info!("No Authorization header found or Bearer token missing");
+                tracing::info!("No Authorization header found or Bearer token missing");
                 return Ok(None);
             }
         };
···
         match validate_jwt(&token, did_document_storage.0, Some(&identity_resolver)).await {
             Ok((header, claims)) => Ok(Some(ResolvingAuthorization(header, claims, token, true))),
             Err(e) => {
-                debug!("JWT validation failed with resolving storage: {e:?}");
+                tracing::debug!("JWT validation failed with resolving storage: {e:?}");
                 // Return unvalidated authorization so the handler can decide what to do
                 let header = Header::default();
                 let claims = Claims::default();
···
         .as_ref()
         .ok_or_else(|| AuthorizationError::NoIssuerInClaims)?;
 
-    debug!("JWT issuer: {}", issuer);
+    tracing::debug!("JWT issuer: {}", issuer);
 
     // Try to look up DID document directly first
     let mut did_document = storage.get_document_by_did(issuer).await?;
 
     // If not found, try to resolve the subject
     if did_document.is_none() {
-        debug!(
+        tracing::debug!(
             "DID document not found for issuer: {}, attempting resolution",
             issuer
         );
···
     let did_document = did_document.ok_or_else(|| AuthorizationError::DIDDocumentNotFound {
         issuer: issuer.to_string(),
     })?;
-    debug!("Found DID document for issuer: {}", issuer);
+    tracing::debug!("Found DID document for issuer: {}", issuer);
 
     // Extract keys from DID document
     let did_keys = did_document.did_keys();
···
         return Err(AuthorizationError::NoVerificationKeys.into());
     }
 
-    debug!("Found {} verification keys in DID document", did_keys.len());
+    tracing::debug!("Found {} verification keys in DID document", did_keys.len());
 
     // Try to validate with each key
     for key_multibase in did_keys {