retain useful information in error messages for debuggability (#62)

Author: 64bit

async-openai/src/client.rs

@@ -7,7 +7,7 @@ use serde::{de::DeserializeOwned, Serialize};
 
 use crate::{
     edit::Edits,
-    error::{OpenAIError, WrappedError},
+    error::{map_deserialization_error, OpenAIError, WrappedError},
     file::Files,
     image::Images,
     moderation::Moderations,
@@ -226,8 +226,8 @@ impl Client {
         let bytes = response.bytes().await?;
 
         if !status.is_success() {
-            let wrapped_error: WrappedError =
-                serde_json::from_slice(bytes.as_ref()).map_err(OpenAIError::JSONDeserialize)?;
+            let wrapped_error: WrappedError = serde_json::from_slice(bytes.as_ref())
+                .map_err(|e| map_deserialization_error(e, bytes.as_ref()))?;
 
             return Err(OpenAIError::ApiError(wrapped_error.error));
         }
@@ -264,7 +264,7 @@ impl Client {
                     // Deserialize response body from either error object or actual response object
                     if !status.is_success() {
                         let wrapped_error: WrappedError = serde_json::from_slice(bytes.as_ref())
-                            .map_err(OpenAIError::JSONDeserialize)
+                            .map_err(|e| map_deserialization_error(e, bytes.as_ref()))
                             .map_err(backoff::Error::Permanent)?;
 
                         if status.as_u16() == 429
@@ -286,7 +286,7 @@ impl Client {
                     }
 
                     let response: O = serde_json::from_slice(bytes.as_ref())
-                        .map_err(OpenAIError::JSONDeserialize)
+                        .map_err(|e| map_deserialization_error(e, bytes.as_ref()))
                         .map_err(backoff::Error::Permanent)?;
                     Ok(response)
                 })

async-openai/src/download.rs

@@ -33,23 +33,28 @@ pub(crate) async fn download_url<P: AsRef<Path>>(
 
     if !response.status().is_success() {
         return Err(OpenAIError::FileSaveError(format!(
-            "couldn't download file (status: {})",
+            "couldn't download file, status: {}, url: {url}",
             response.status()
         )));
     }
 
     let (dir, file_path) = create_paths(&parsed_url, dir);
 
-    tokio::fs::create_dir_all(dir)
+    tokio::fs::create_dir_all(dir.as_path())
         .await
-        .map_err(|e| OpenAIError::FileSaveError(e.to_string()))?;
+        .map_err(|e| {
+            OpenAIError::FileSaveError(format!("{}, dir: {}", e.to_string(), dir.display()))
+        })?;
 
     tokio::fs::write(
         file_path.as_path(),
-        response
-            .bytes()
-            .await
-            .map_err(|e| OpenAIError::FileSaveError(e.to_string()))?,
+        response.bytes().await.map_err(|e| {
+            OpenAIError::FileSaveError(format!(
+                "{}, file path: {}",
+                e.to_string(),
+                file_path.display()
+            ))
+        })?,
     )
     .await
     .map_err(|e| OpenAIError::FileSaveError(e.to_string()))?;
@@ -75,7 +80,9 @@ pub(crate) async fn save_b64<P: AsRef<Path>>(b64: &str, dir: P) -> Result<PathBu
             .map_err(|e| OpenAIError::FileSaveError(e.to_string()))?,
     )
     .await
-    .map_err(|e| OpenAIError::FileSaveError(e.to_string()))?;
+    .map_err(|e| {
+        OpenAIError::FileSaveError(format!("{}, path: {}", e.to_string(), path.display()))
+    })?;
 
     Ok(path)
 }

async-openai/src/error.rs

@@ -18,7 +18,7 @@ pub enum OpenAIError {
     /// Error on the client side when reading file from file system
     #[error("failed to read file: {0}")]
     FileReadError(String),
-    /// Error when trying to stream completions SSE
+    /// Error on SSE streaming
     #[error("stream failed: {0}")]
     StreamError(String),
     /// Error from client side validation
@@ -41,3 +41,11 @@ pub struct ApiError {
 pub(crate) struct WrappedError {
     pub(crate) error: ApiError,
 }
+
+pub(crate) fn map_deserialization_error(e: serde_json::Error, bytes: &[u8]) -> OpenAIError {
+    tracing::error!(
+        "failed deserialization of: {}",
+        String::from_utf8_lossy(bytes.as_ref())
+    );
+    OpenAIError::JSONDeserialize(e)
+}