feat: Add missing PUT key to the Rust client, replace anyhow with… (#191)

… `thiserror`

We did a 360 when figuring out whether we should assign objects keys
from the server or the client. In that process, I guess I forgot to add
back the `key` to the Rust client. So here it is.

Also, this replaces our usage of `anyhow` within the `types` and
`client` crate with `thiserror`. This is a bit verbose, and I can
predict for a fact that noone will ever match on these errors or care
about which one it is.

But relay folks insist. They seem to have a "no `anyhow`" policy, as
they claim capturing backtraces on every `anyhow` that happens is
expensive. While that is true, they have also pinned a >2 year old
`anyhow` version which supposedly does not capture backtraces by
default. And relay team also does not seem aware that you can actually
disable backtraces for errors by setting `RUST_LIB_BACKTRACE=0`. But
hey, I don’t really want to argue. If they want to cargo-cult around
these decisions without challenging them every now and then, who am I to
tell them otherwise?

Author: Swatinem

Cargo.lock

@@ -43,6 +43,7 @@ sentry = { version = "0.45.0" }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
 tempfile = "3.20.0"
+thiserror = "2.0.17"
 tokio = "1.47.0"
 tokio-stream = "0.1.17"
 tokio-util = "0.7.15"

Cargo.toml

@@ -11,16 +11,16 @@ rust-version = "1.89"
 publish = true
 
 [dependencies]
-anyhow = { workspace = true }
 async-compression = { version = "0.4.27", features = ["tokio", "zstd"] }
 bytes = { workspace = true }
 futures-util = { workspace = true }
 objectstore-types = { workspace = true }
 reqwest = { workspace = true, features = ["json", "stream"] }
+sentry = { workspace = true }
 serde = { workspace = true }
+thiserror = { workspace = true }
 tokio = { workspace = true }
 tokio-util = { workspace = true, features = ["io"] }
-sentry = { workspace = true }
 
 [dev-dependencies]
 objectstore-server = { workspace = true }

clients/rust/Cargo.toml

@@ -5,7 +5,6 @@ use std::time::Duration;
 use bytes::Bytes;
 use futures_util::stream::BoxStream;
 use objectstore_types::ExpirationPolicy;
-use reqwest::header::HeaderName;
 
 pub use objectstore_types::{Compression, PARAM_SCOPE, PARAM_USECASE};
 
@@ -36,7 +35,7 @@ impl ClientBuilder {
     ///
     /// In order to get or put objects, one has to create a [`Client`] using the
     /// [`for_organization`](Self::for_organization) function.
-    pub fn new(service_url: &str, usecase: &str) -> anyhow::Result<Self> {
+    pub fn new(service_url: &str, usecase: &str) -> crate::Result<Self> {
         let client = reqwest::Client::builder()
             .user_agent(USER_AGENT)
             // hickory-dns: Controlled by the `reqwest/hickory-dns` feature flag
@@ -142,7 +141,7 @@ impl Client {
         &self,
         method: reqwest::Method,
         uri: U,
-    ) -> anyhow::Result<reqwest::RequestBuilder> {
+    ) -> crate::Result<reqwest::RequestBuilder> {
         let mut builder = self.http.request(method, uri).query(&[
             (PARAM_SCOPE, self.scope.as_ref()),
             (PARAM_USECASE, self.usecase.as_ref()),
@@ -152,15 +151,15 @@ impl Client {
             let trace_headers =
                 sentry::configure_scope(|scope| Some(scope.iter_trace_propagation_headers()));
             for (header_name, value) in trace_headers.into_iter().flatten() {
-                builder = builder.header(HeaderName::try_from(header_name)?, value);
+                builder = builder.header(header_name, value);
             }
         }
 
         Ok(builder)
     }
 
     /// Deletes the object with the given `id`.
-    pub async fn delete(&self, id: &str) -> anyhow::Result<()> {
+    pub async fn delete(&self, id: &str) -> crate::Result<()> {
         let delete_url = format!("{}/v1/{id}", self.service_url);
 
         let _response = self

clients/rust/src/client.rs

@@ -0,0 +1,19 @@
+/// Errors that can happen within the objectstore-client
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    /// Any error emitted from the underlying [`reqwest`] client.
+    #[error(transparent)]
+    Reqwest(#[from] reqwest::Error),
+    /// IO errors related to payload streaming.
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    /// Errors related to UTF-8 dcoding
+    #[error(transparent)]
+    Utf8(#[from] std::string::FromUtf8Error),
+    /// Errors handling metadata, such as serializing it to/from HTTP headers.
+    #[error(transparent)]
+    Metadata(#[from] objectstore_types::Error),
+}
+
+/// A convenience alias that defaults our [`Error`] type.
+pub type Result<T, E = Error> = std::result::Result<T, E>;

clients/rust/src/error.rs

@@ -23,13 +23,13 @@ pub struct GetResult {
 
 impl GetResult {
     /// Loads the object payload fully into memory.
-    pub async fn payload(self) -> anyhow::Result<bytes::Bytes> {
+    pub async fn payload(self) -> crate::Result<bytes::Bytes> {
         let bytes: BytesMut = self.stream.try_collect().await?;
         Ok(bytes.freeze())
     }
 
     /// Loads the object payload fully into memory and interprets it as UTF-8 text.
-    pub async fn text(self) -> anyhow::Result<String> {
+    pub async fn text(self) -> crate::Result<String> {
         let bytes = self.payload().await?;
         Ok(String::from_utf8(bytes.to_vec())?)
     }
@@ -73,7 +73,7 @@ impl GetBuilder<'_> {
     }
 
     /// Sends the `GET` request.
-    pub async fn send(self) -> anyhow::Result<Option<GetResult>> {
+    pub async fn send(self) -> crate::Result<Option<GetResult>> {
         let get_url = format!("{}/v1/{}", self.client.service_url, self.id);
 
         let response = self

clients/rust/src/get.rs

@@ -10,7 +10,7 @@
 //! use objectstore_client::ClientBuilder;
 //!
 //! #[tokio::main]
-//! # async fn main() -> anyhow::Result<()> {
+//! # async fn main() -> objectstore_client::Result<()> {
 //! let client = ClientBuilder::new("http://localhost:8888/", "my-usecase")?
 //!     .for_organization(42);
 //!
@@ -24,12 +24,14 @@
 #![warn(missing_debug_implementations)]
 
 mod client;
+mod error;
 mod get;
 mod put;
 
 pub use objectstore_types::{Compression, ExpirationPolicy};
 
 pub use client::*;
+pub use error::*;
 pub use get::*;
 pub use put::*;
 

clients/rust/src/lib.rs

@@ -26,6 +26,7 @@ impl Client {
         PutBuilder {
             client: self,
             metadata,
+            key: None,
             body,
         }
     }
@@ -55,6 +56,7 @@ impl Client {
 pub struct PutBuilder<'a> {
     pub(crate) client: &'a Client,
     pub(crate) metadata: Metadata,
+    pub(crate) key: Option<String>,
     pub(crate) body: PutBody,
 }
 
@@ -69,6 +71,15 @@ impl fmt::Debug for PutBody {
 }
 
 impl PutBuilder<'_> {
+    /// Sets an explicit object key.
+    ///
+    /// If a key is specified, the object will be stored under that key. Otherwise, the objectstore
+    /// server will automatically assign a random key, which is then returned from this request.
+    pub fn key(mut self, key: impl Into<String>) -> Self {
+        self.key = Some(key.into());
+        self
+    }
+
     /// Sets an explicit compression algorithm to be used for this payload.
     ///
     /// [`None`] should be used if no compression should be performed by the client,
@@ -112,8 +123,12 @@ pub struct PutResponse {
 // and "impl trait in associated type position" is not yet stable :-(
 impl PutBuilder<'_> {
     /// Sends the built PUT request to the upstream service.
-    pub async fn send(self) -> anyhow::Result<PutResponse> {
-        let put_url = format!("{}/v1/", self.client.service_url);
+    pub async fn send(self) -> crate::Result<PutResponse> {
+        let put_url = format!(
+            "{}/v1/{}",
+            self.client.service_url,
+            self.key.as_deref().unwrap_or_default()
+        );
         let mut builder = self.client.request(reqwest::Method::PUT, put_url)?;
 
         let body = match (self.metadata.compression, self.body) {

clients/rust/src/put.rs

@@ -2,6 +2,7 @@
 
 use std::io;
 
+use anyhow::Context;
 use axum::body::Body;
 use axum::extract::{Path, Query, State};
 use axum::http::{HeaderMap, StatusCode};
@@ -54,7 +55,8 @@ async fn put_object_nokey(
         key: uuid::Uuid::new_v4().to_string(),
     };
     populate_sentry_scope(&path);
-    let metadata = Metadata::from_headers(&headers, "")?;
+    let metadata =
+        Metadata::from_headers(&headers, "").context("extracting metadata from headers")?;
 
     let stream = body.into_data_stream().map_err(io::Error::other).boxed();
     let key = state.service.put_object(path, &metadata, stream).await?;
@@ -77,7 +79,8 @@ async fn put_object(
         key,
     };
     populate_sentry_scope(&path);
-    let metadata = Metadata::from_headers(&headers, "")?;
+    let metadata =
+        Metadata::from_headers(&headers, "").context("extracting metadata from headers")?;
 
     let stream = body.into_data_stream().map_err(io::Error::other).boxed();
     let key = state.service.put_object(path, &metadata, stream).await?;
@@ -103,7 +106,9 @@ async fn get_object(
         return Ok(StatusCode::NOT_FOUND.into_response());
     };
 
-    let headers = metadata.to_headers("", false)?;
+    let headers = metadata
+        .to_headers("", false)
+        .context("extracting metadata from headers")?;
     Ok((headers, Body::from_stream(stream)).into_response())
 }
 

objectstore-server/src/endpoints.rs

@@ -10,7 +10,7 @@ edition = "2024"
 publish = true
 
 [dependencies]
-anyhow = { workspace = true }
-humantime = { workspace = true }
 http = { workspace = true }
+humantime = { workspace = true }
 serde = { workspace = true }
+thiserror = { workspace = true }