diff --git a/services/backup/blob_client/src/get_client.rs b/services/backup/blob_client/src/get_client.rs
index bb681346c..2fd00ed09 100644
--- a/services/backup/blob_client/src/get_client.rs
+++ b/services/backup/blob_client/src/get_client.rs
@@ -1,145 +1,145 @@
 mod proto {
   tonic::include_proto!("blob");
 }
 
 use proto::blob_service_client::BlobServiceClient;
 use proto::GetRequest;
 
 use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY};
 use crate::tools::{
-  c_char_pointer_to_string_new, string_to_c_char_pointer_new,
+  c_char_pointer_to_string, string_to_c_char_pointer,
 };
 use anyhow::bail;
 use crate::RUNTIME;
 use lazy_static::lazy_static;
 use libc;
 use libc::c_char;
 use std::collections::HashMap;
 use std::sync::Mutex;
 use tokio::sync::mpsc;
 use tokio::task::JoinHandle;
 
 struct ReadClient {
   rx: mpsc::Receiver<Vec<u8>>,
   rx_handle: JoinHandle<anyhow::Result<(), anyhow::Error>>,
 }
 
 lazy_static! {
   // todo: we should consider limiting the clients size,
   // if every client is able to allocate up to 4MB data at a time
   static ref CLIENTS: Mutex<HashMap<String, ReadClient>> =
     Mutex::new(HashMap::new());
   static ref ERROR_MESSAGES: Mutex<Vec<String>> =
     Mutex::new(Vec::new());
 }
 
 fn is_initialized(holder: &str) -> anyhow::Result<bool, anyhow::Error> {
   if let Ok(clients) = CLIENTS.lock() {
     return Ok(clients.contains_key(holder));
   }
   bail!("couldn't access client");
 }
 
 pub fn get_client_initialize_cxx(
   holder_char: *const c_char,
 ) -> anyhow::Result<(), anyhow::Error> {
-  let holder = c_char_pointer_to_string_new(holder_char)?;
+  let holder = c_char_pointer_to_string(holder_char)?;
   if is_initialized(&holder)? {
-    get_client_terminate_cxx(string_to_c_char_pointer_new(&holder)?)?;
+    get_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?;
   }
 
   // grpc
   if let Ok(mut grpc_client) =
     RUNTIME.block_on(async { BlobServiceClient::connect(BLOB_ADDRESS).await })
   {
     // spawn receiver thread
     let (response_thread_tx, response_thread_rx) =
       mpsc::channel::<Vec<u8>>(MPSC_CHANNEL_BUFFER_CAPACITY);
     let cloned_holder = holder.clone();
     let rx_handle = RUNTIME.spawn(async move {
       let response = grpc_client
         .get(GetRequest {
           holder: cloned_holder,
         })
         .await?;
       let mut inner_response = response.into_inner();
       loop {
         let maybe_data = inner_response.message().await?;
         let mut result = false;
         if let Some(data) = maybe_data {
           let data: Vec<u8> = data.data_chunk;
           result = match response_thread_tx.send(data).await {
             Ok(_) => true,
             Err(err) => {
               bail!(err);
             }
           }
         }
         if !result {
           break;
         }
       }
       Ok(())
     });
 
     if let Ok(mut clients) = CLIENTS.lock() {
       let client = ReadClient {
         rx_handle,
         rx: response_thread_rx,
       };
       (*clients).insert(holder, client);
       return Ok(());
     }
     bail!("could not access client");
   }
   bail!("could not successfully connect to the blob server")
 }
 
 pub fn get_client_blocking_read_cxx(
   holder_char: *const c_char,
 ) -> anyhow::Result<Vec<u8>, anyhow::Error> {
-  let holder = c_char_pointer_to_string_new(holder_char)?;
+  let holder = c_char_pointer_to_string(holder_char)?;
   Ok(RUNTIME.block_on(async {
     if let Ok(mut clients) = CLIENTS.lock() {
       if let Some(client) = clients.get_mut(&holder) {
         let maybe_data = client.rx.recv().await;
         return Ok(maybe_data.unwrap_or_else(|| vec![]));
       } else {
         bail!(format!("no client present for {}", holder));
       }
     } else {
       bail!("couldn't access client");
     }
   })?)
 }
 
 pub fn get_client_terminate_cxx(
   holder_char: *const c_char,
 ) -> anyhow::Result<(), anyhow::Error> {
-  let holder = c_char_pointer_to_string_new(holder_char)?;
+  let holder = c_char_pointer_to_string(holder_char)?;
   if !is_initialized(&holder)? {
     return Ok(());
   }
   if let Ok(mut clients) = CLIENTS.lock() {
     match clients.remove(&holder) {
       Some(client) => {
         RUNTIME.block_on(async {
           if client.rx_handle.await.is_err() {
             bail!(format!("awaiting for the client {} failed", holder));
           }
           Ok(())
         })?;
       }
       None => {
         bail!(format!("no client foudn for {}", holder));
       }
     }
   } else {
     bail!("couldn't access client");
   }
 
   if is_initialized(&holder)? {
     bail!("client transmitter handler released properly");
   }
   Ok(())
 }
diff --git a/services/backup/blob_client/src/put_client.rs b/services/backup/blob_client/src/put_client.rs
index b4d819bbe..162dc75d3 100644
--- a/services/backup/blob_client/src/put_client.rs
+++ b/services/backup/blob_client/src/put_client.rs
@@ -1,282 +1,262 @@
 mod proto {
   tonic::include_proto!("blob");
 }
 
 use proto::blob_service_client::BlobServiceClient;
 use proto::put_request;
 use proto::put_request::Data::*;
 use proto::PutRequest;
 
 use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY};
 use crate::tools::{
-  c_char_pointer_to_string, c_char_pointer_to_string_new, report_error, string_to_c_char_pointer_new,
+  c_char_pointer_to_string, string_to_c_char_pointer,
 };
 use anyhow::bail;
 use crate::RUNTIME;
 use lazy_static::lazy_static;
 use libc;
 use libc::c_char;
 use std::collections::HashMap;
 use std::ffi::CStr;
 use std::sync::Mutex;
 use tokio::sync::mpsc;
 use tokio::task::JoinHandle;
 
 #[derive(Debug)]
 struct PutRequestData {
   field_index: usize,
   data: Vec<u8>,
 }
 
 struct BidiClient {
   tx: mpsc::Sender<PutRequestData>,
 
   rx: mpsc::Receiver<String>,
-  rx_handle: JoinHandle<()>,
+  rx_handle: JoinHandle<anyhow::Result<(), anyhow::Error>>,
 }
 
 lazy_static! {
   // todo: we should consider limiting the clients size,
   // if every client is able to allocate up to 4MB data at a time
   static ref CLIENTS: Mutex<HashMap<String, BidiClient>> =
     Mutex::new(HashMap::new());
   static ref ERROR_MESSAGES: Mutex<Vec<String>> =
     Mutex::new(Vec::new());
 }
 
-fn is_initialized(holder: &str) -> bool {
+fn is_initialized(holder: &str) -> anyhow::Result<bool, anyhow::Error> {
   match CLIENTS.lock() {
-    Ok(clients) => clients.contains_key(holder),
-    _ => {
-      report_error(&ERROR_MESSAGES, "couldn't access client", Some("put"));
-      false
-    }
+    Ok(clients) => Ok(clients.contains_key(holder)),
+    _ => bail!("couldn't access client")
   }
 }
 
-fn is_initialized_new(holder: &str) -> anyhow::Result<bool, anyhow::Error> {
-  return Ok(match CLIENTS.lock() {
-    Ok(clients) => clients.contains_key(holder),
-    _ => {
-      bail!("couldn't access client");
-    }
-  });
-}
-
 pub fn put_client_initialize_cxx(
   holder_char: *const c_char,
-) -> Result<(), String> {
+) -> anyhow::Result<(), anyhow::Error> {
   let holder = c_char_pointer_to_string(holder_char)?;
-  assert!(
-    !is_initialized(&holder),
-    "client cannot be initialized twice"
-  );
+  if is_initialized(&holder)? {
+    put_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?;
+  }
+  if is_initialized(&holder)? {
+    bail!("client cannot be initialized twice");
+  }
   // grpc
   if let Ok(mut grpc_client) =
     RUNTIME.block_on(async { BlobServiceClient::connect(BLOB_ADDRESS).await })
   {
     let (request_thread_tx, mut request_thread_rx) =
       mpsc::channel::<PutRequestData>(MPSC_CHANNEL_BUFFER_CAPACITY);
 
     let outbound = async_stream::stream! {
+      let mut maybe_error: Option<String> = None;
       while let Some(data) = request_thread_rx.recv().await {
         let request_data: Option<put_request::Data> = match data.field_index {
           1 => {
             match String::from_utf8(data.data) {
               Ok(utf8_data) => Some(Holder(utf8_data)),
               _ => {
-                report_error(&ERROR_MESSAGES, "invalid utf-8", Some("put"));
-                None
+                maybe_error = Some("invalid utf-8".to_string());
+                break;
               },
             }
           }
           2 => {
             match String::from_utf8(data.data).ok() {
               Some(utf8_data) => Some(BlobHash(utf8_data)),
               None => {
-                report_error(&ERROR_MESSAGES, "invalid utf-8", Some("put"));
-                None
+                maybe_error = Some("invalid utf-8".to_string());
+                break;
               },
             }
           }
           3 => {
             Some(DataChunk(data.data))
           }
           _ => {
-            report_error(
-              &ERROR_MESSAGES,
-              &format!("invalid field index value {}", data.field_index),
-              Some("put")
-            );
-            None
+            maybe_error = Some(format!("invalid field index value {}", data.field_index));
+            break;
           }
         };
         if let Some (unpacked_data) = request_data {
           let request = PutRequest {
             data: Some(unpacked_data),
           };
           yield request;
         } else {
-          report_error(
-            &ERROR_MESSAGES,
-            "an error occured, aborting connection",
-            Some("put")
-          );
+          maybe_error = Some("an error occured, aborting connection".to_string());
           break;
         }
       }
+      if let Some(error) = maybe_error {
+        // todo consider handling this differently
+        println!("an error occured in the stream: {}", error);
+      }
     };
 
     // spawn receiver thread
     let (response_thread_tx, response_thread_rx) =
       mpsc::channel::<String>(MPSC_CHANNEL_BUFFER_CAPACITY);
     let rx_handle = RUNTIME.spawn(async move {
       match grpc_client.put(tonic::Request::new(outbound)).await {
         Ok(response) => {
           let mut inner_response = response.into_inner();
           loop {
             match inner_response.message().await {
               Ok(maybe_response_message) => {
                 let mut result = false;
                 if let Some(response_message) = maybe_response_message {
                   // warning: this will produce an error if there's more unread
                   // responses than MPSC_CHANNEL_BUFFER_CAPACITY
                   // you should then use put_client_blocking_read_cxx in order
                   // to dequeue the responses in c++ and make room for more
                   if let Ok(_) = response_thread_tx
                     .try_send((response_message.data_exists as i32).to_string())
                   {
                     result = true;
                   } else {
-                    report_error(
-                      &ERROR_MESSAGES,
-                      "response queue full",
-                      Some("put"),
-                    );
+                    bail!("response queue full");
                   }
                 }
                 if !result {
                   break;
                 }
               }
               Err(err) => {
-                report_error(&ERROR_MESSAGES, &err.to_string(), Some("put"));
-                break;
+                bail!(err.to_string());
               }
             };
           }
         }
         Err(err) => {
-          report_error(&ERROR_MESSAGES, &err.to_string(), Some("put"));
+          bail!(err.to_string());
         }
       };
+      Ok(())
     });
 
-    if is_initialized(&holder) {
-      return Err(format!(
+    if is_initialized(&holder)? {
+      bail!(format!(
         "client initialization overlapped for holder {}",
         holder
       ));
     }
     if let Ok(mut clients) = CLIENTS.lock() {
       let client = BidiClient {
         tx: request_thread_tx,
         rx: response_thread_rx,
         rx_handle,
       };
       (*clients).insert(holder, client);
       return Ok(());
     }
-    return Err(format!("could not access client for holder {}", holder));
+    bail!(format!("could not access client for holder {}", holder));
   }
-  Err("could not successfully connect to the blob server".to_string())
+  bail!("could not successfully connect to the blob server");
 }
 
 pub fn put_client_blocking_read_cxx(
   holder_char: *const c_char,
 ) -> anyhow::Result<String, anyhow::Error> {
-  let holder = c_char_pointer_to_string_new(holder_char)?;
+  let holder = c_char_pointer_to_string(holder_char)?;
   Ok(RUNTIME.block_on(async {
     if let Ok(mut clients) = CLIENTS.lock() {
       let maybe_client = clients.get_mut(&holder);
       if let Some(client) = maybe_client {
         if let Some(data) = client.rx.recv().await {
           return Ok(data);
         } else {
           bail!("couldn't receive data via client's receiver");
         }
       } else {
         bail!(format!("no client detected for {} in blocking read", holder));
       }
     } else {
       bail!("couldn't access clients");
     }
   })?)
 }
 
 /**
  * field index:
  * 1 - holder (utf8 string)
  * 2 - blob hash (utf8 string)
  * 3 - data chunk (bytes)
  */
 pub fn put_client_write_cxx(
   holder_char: *const c_char,
   field_index: usize,
   data: *const c_char,
 ) -> anyhow::Result<(), anyhow::Error> {
-  let holder = c_char_pointer_to_string_new(holder_char)?;
+  let holder = c_char_pointer_to_string(holder_char)?;
   let data_c_str: &CStr = unsafe { CStr::from_ptr(data) };
   let data_bytes: Vec<u8> = data_c_str.to_bytes().to_vec();
 
   RUNTIME.block_on(async {
     if let Ok(clients) = CLIENTS.lock() {
       let maybe_client = clients.get(&holder);
       if let Some(client) = maybe_client {
         client
           .tx
           .send(PutRequestData {
             field_index,
             data: data_bytes,
           })
           .await?;
         return Ok(());
       }
       bail!(format!("no client detected for {} in write", holder));
     } else {
       bail!("couldn't access clients");
     }
   })?;
   Ok(())
 }
 
 pub fn put_client_terminate_cxx(
   holder_char: *const c_char,
 ) -> anyhow::Result<(), anyhow::Error> {
-  let holder = c_char_pointer_to_string_new(holder_char)?;
-  if !is_initialized_new(&holder)? {
+  let holder = c_char_pointer_to_string(holder_char)?;
+  if !is_initialized(&holder)? {
     return Ok(());
   }
 
   if let Ok(mut clients) = CLIENTS.lock() {
     let maybe_client = clients.remove(&holder);
     if let Some(client) = maybe_client {
       drop(client.tx);
       RUNTIME.block_on(async {
-        if client.rx_handle.await.is_err() {
-          bail!(format!("awaiting for the client {} failed", holder));
-        }
-        Ok(())
+        client.rx_handle.await?
       })?;
     } else {
       bail!("no client detected in terminate");
     }
   } else {
     bail!("couldn't access client");
   }
 
-  if is_initialized_new(&holder)? {
+  if is_initialized(&holder)? {
     bail!("client transmitter handler released properly");
   }
   Ok(())
 }
diff --git a/services/backup/blob_client/src/tools.rs b/services/backup/blob_client/src/tools.rs
index 3c2a3bfc9..efd1d4305 100644
--- a/services/backup/blob_client/src/tools.rs
+++ b/services/backup/blob_client/src/tools.rs
@@ -1,43 +1,15 @@
 use libc::c_char;
 use std::ffi::{CStr, CString};
-use std::sync::Mutex;
-use tracing::error;
-
-pub fn report_error(
-  error_messages: &Mutex<Vec<String>>,
-  message: &str,
-  label_provided: Option<&str>,
-) {
-  let label = match label_provided {
-    Some(value) => format!("[{}]", value),
-    None => "".to_string(),
-  };
-  println!("[RUST] {} Error: {}", label, message);
-  if let Ok(mut error_messages_unpacked) = error_messages.lock() {
-    error_messages_unpacked.push(message.to_string());
-  }
-  error!("could not access error messages");
-}
 
 pub fn c_char_pointer_to_string(
   c_char_pointer: *const c_char,
-) -> Result<String, String> {
-  let holder_cstr: &CStr = unsafe { CStr::from_ptr(c_char_pointer) };
-  match holder_cstr.to_str() {
-    Ok(result) => Ok(result.to_owned()),
-    Err(err) => Err(err.to_string()),
-  }
-}
-
-pub fn c_char_pointer_to_string_new(
-  c_char_pointer: *const c_char,
 ) -> anyhow::Result<String, anyhow::Error> {
   let holder_cstr: &CStr = unsafe { CStr::from_ptr(c_char_pointer) };
   Ok(holder_cstr.to_str()?.to_owned())
 }
 
-pub fn string_to_c_char_pointer_new(
+pub fn string_to_c_char_pointer(
   signs: &String,
 ) -> anyhow::Result<*const c_char, anyhow::Error> {
   Ok(CString::new((&signs).as_bytes())?.as_ptr())
 }