tracing span issue caused weirdness

crates/jacquard-common/src/types/aturi.rs

···
+use crate::cowstr::ToCowStr;
 use crate::types::ident::AtIdentifier;
 use crate::types::nsid::Nsid;
 use crate::types::recordkey::{RecordKey, Rkey};
···
     pub collection: Nsid<'u>,
     /// Optional record key identifying a specific record
     pub rkey: Option<RecordKey<Rkey<'u>>>,
+}
+
+impl fmt::Display for RepoPath<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "/{}", self.collection)?;
+        if let Some(rkey) = &self.rkey {
+            write!(f, "/{}", rkey.as_ref())?;
+        }
+        Ok(())
+    }
 }
 
 impl IntoStatic for RepoPath<'_> {
···
 }
 
 impl AtUri<'static> {
+    /// Fallible owned constructor from typical parts
+    pub fn from_parts_owned(
+        authority: impl AsRef<str>,
+        collection: impl AsRef<str>,
+        rkey: impl AsRef<str>,
+    ) -> Result<Self, AtStrError> {
+        let (authority, collection, rkey) =
+            (authority.as_ref(), collection.as_ref(), rkey.as_ref());
+        if authority.is_empty() || (collection.is_empty() && !rkey.is_empty()) {
+            Err(AtStrError::missing(
+                "at-uri-scheme",
+                &format!("at://{}/{}/{}", authority, collection, rkey),
+                "correct uri path",
+            ))
+        } else if !authority.is_empty() && collection.is_empty() && rkey.is_empty() {
+            let uri = format!("at://{}", authority);
+            Self::new_owned(uri)
+        } else if !collection.is_empty() && rkey.is_empty() {
+            let uri = format!("at://{}/{}", authority, collection);
+            Self::new_owned(uri)
+        } else {
+            let uri = format!("at://{}/{}/{}", authority, collection, rkey);
+            Self::new_owned(uri)
+        }
+    }
     /// Owned constructor
     ///
     /// Uses ouroboros self-referential tricks internally to make sure everything

crates/jacquard/src/client.rs

···
         R: Collection + serde::Serialize,
     {
         async move {
-            #[cfg(feature = "tracing")]
-            let _span = tracing::debug_span!("create_record", collection = %R::nsid()).entered();
-
             use jacquard_api::com_atproto::repo::create_record::CreateRecord;
             use jacquard_common::types::ident::AtIdentifier;
             use jacquard_common::types::value::to_data;
···
                 .await
                 .ok_or_else(AgentError::no_session)?;
 
+            #[cfg(feature = "tracing")]
+            let _span = tracing::debug_span!("create_record", collection = %R::nsid()).entered();
+
             let data =
                 to_data(&record).map_err(|e| AgentError::sub_operation("serialize record", e))?;
 
···
                 .record(data)
                 .maybe_rkey(rkey)
                 .build();
+
+            #[cfg(feature = "tracing")]
+            _span.exit();
 
             let response = self.send(request).await?;
             response.into_output().map_err(|e| match e {
···
                 ClientError::invalid_request("AtUri missing rkey")
                     .with_help("ensure the URI includes a record key after the collection")
             })?;
+
+            #[cfg(feature = "tracing")]
+            _span.exit();
 
             // Resolve authority (DID or handle) to get DID and PDS
             use jacquard_common::types::ident::AtIdentifier;
···
                 .rkey(rkey.clone())
                 .build();
 
+            #[cfg(feature = "tracing")]
+            _span.exit();
+
             let response: Response<GetRecordResponse> = {
                 use url::Url;
 
···
         for<'a> CollectionError<'a, R>: Send + Sync + std::error::Error + IntoStatic,
     {
         async move {
+            // Fetch the record - Response<R::Record> where R::Record::Output<'de> = R<'de>
+            let response = self.get_record::<R>(uri).await?;
+
             #[cfg(feature = "tracing")]
             let _span = tracing::debug_span!("update_record", collection = %R::nsid(), uri = %uri)
                 .entered();
-
-            // Fetch the record - Response<R::Record> where R::Record::Output<'de> = R<'de>
-            let response = self.get_record::<R>(uri).await?;
 
             // Parse to get R<'_> borrowing from response buffer
             let record = response.parse().map_err(|e| match e {
···
                 })?
                 .clone()
                 .into_static();
+
+            #[cfg(feature = "tracing")]
+            _span.exit();
             self.put_record::<R>(rkey, owned).await
         }
     }
···
         R: Collection,
     {
         async {
+            let (did, _) = self
+                .session_info()
+                .await
+                .ok_or_else(AgentError::no_session)?;
             #[cfg(feature = "tracing")]
             let _span = tracing::debug_span!("delete_record", collection = %R::nsid()).entered();
 
             use jacquard_api::com_atproto::repo::delete_record::DeleteRecord;
             use jacquard_common::types::ident::AtIdentifier;
 
-            let (did, _) = self
-                .session_info()
-                .await
-                .ok_or_else(AgentError::no_session)?;
-
             let request = DeleteRecord::new()
                 .repo(AtIdentifier::Did(did))
                 .collection(R::nsid())
                 .rkey(rkey)
                 .build();
 
+            #[cfg(feature = "tracing")]
+            _span.exit();
+
             let response = self.send(request).await?;
             response.into_output().map_err(|e| match e {
                 XrpcError::Auth(auth) => AgentError::from(auth),
···
                 .rkey(rkey)
                 .record(data)
                 .build();
+
+            #[cfg(feature = "tracing")]
+            _span.exit();
 
             let response = self.send(request).await?;
             response.into_output().map_err(|e| match e {
···
                 http::HeaderValue::from_str(mime_type.as_str())
                     .map_err(|e| AgentError::sub_operation("set Content-Type header", e))?,
             ));
+
+            #[cfg(feature = "tracing")]
+            _span.exit();
+
             let response = self.send_with_opts(request, opts).await?;
-            let debug: serde_json::Value = serde_json::from_slice(response.buffer()).unwrap();
-            println!("json: {}", serde_json::to_string_pretty(&debug).unwrap());
             let output = response.into_output().map_err(|e| match e {
                 XrpcError::Auth(auth) => AgentError::from(auth),
                 e @ (XrpcError::Generic(_) | XrpcError::Decode(_)) => AgentError::xrpc(e),