[HandsOffConfig] Remove eprintln and return debug messages inside Result (#1201)

* Change return type to get log messages with succes result

Signed-off-by: Anna <[email protected]>

* Change return type to LoggedResult

Signed-off-by: Anna <[email protected]>

* Adapt ffi, dnot use generic for 2 values as cbindgen generates numbered fields

Signed-off-by: Anna <[email protected]>

* Adapt c example

Signed-off-by: Anna <[email protected]>

* Defensive  free model

Signed-off-by: Anna <[email protected]>

* clarify library_config.c

Signed-off-by: Anna <[email protected]>

* Wrap main treatment in catch panic

Indenting

Signed-off-by: Anna <[email protected]>

---------

Signed-off-by: Anna <[email protected]>

Author: anna-git

datadog-library-config-ffi/Cargo.toml

@@ -18,8 +18,9 @@ anyhow = "1.0"
 constcat = "0.4.1"
 
 [features]
-default = ["cbindgen"]
+default = ["cbindgen", "catch_panic"]
 cbindgen = ["build_common/cbindgen", "ddcommon-ffi/cbindgen"]
+catch_panic = []
 
 [build-dependencies]
 build_common = { path = "../build-common" }

datadog-library-config-ffi/src/lib.rs

@@ -4,7 +4,52 @@
 pub mod tracer_metadata;
 
 use datadog_library_config::{self as lib_config, LibraryConfigSource};
-use ddcommon_ffi::{self as ffi, slice::AsBytes, CharSlice};
+use ddcommon_ffi::{self as ffi, slice::AsBytes, CString, CharSlice, Error};
+
+#[cfg(all(feature = "catch_panic", panic = "unwind"))]
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+#[cfg(all(feature = "catch_panic", panic = "unwind"))]
+macro_rules! catch_panic {
+    ($f:expr) => {
+        match catch_unwind(AssertUnwindSafe(|| $f)) {
+            Ok(ret) => ret,
+            Err(info) => {
+                let panic_msg = if let Some(s) = info.downcast_ref::<&'static str>() {
+                    s.to_string()
+                } else if let Some(s) = info.downcast_ref::<String>() {
+                    s.clone()
+                } else {
+                    "Unable to retrieve panic context".to_string()
+                };
+                LibraryConfigLoggedResult::Err(Error::from(format!(
+                    "FFI function panicked: {}",
+                    panic_msg
+                )))
+            }
+        }
+    };
+}
+
+#[cfg(any(not(feature = "catch_panic"), panic = "abort"))]
+macro_rules! catch_panic {
+    ($f:expr) => {
+        $f
+    };
+}
+
+/// A result type that includes debug/log messages along with the data
+#[repr(C)]
+pub struct OkResult {
+    pub value: ffi::Vec<LibraryConfig>,
+    pub logs: CString,
+}
+
+#[repr(C)]
+pub enum LibraryConfigLoggedResult {
+    Ok(OkResult),
+    Err(Error),
+}
 
 // TODO: Centos 6 build
 // Trust me it works bro 😉😉😉
@@ -53,6 +98,29 @@ impl LibraryConfig {
             .collect::<Result<Vec<_>, std::ffi::NulError>>()?;
         Ok(ffi::Vec::from_std(cfg))
     }
+
+    fn logged_result_to_ffi_with_messages(
+        result: datadog_library_config::LoggedResult<Vec<lib_config::LibraryConfig>, anyhow::Error>,
+    ) -> LibraryConfigLoggedResult {
+        match result {
+            datadog_library_config::LoggedResult::Ok(configs, logs) => {
+                match Self::rs_vec_to_ffi(configs) {
+                    Ok(ffi_configs) => {
+                        let messages = logs.join("\n");
+                        let cstring_logs = CString::new_or_empty(messages);
+                        LibraryConfigLoggedResult::Ok(OkResult {
+                            value: ffi_configs,
+                            logs: cstring_logs,
+                        })
+                    }
+                    Err(err) => LibraryConfigLoggedResult::Err(err.into()),
+                }
+            }
+            datadog_library_config::LoggedResult::Err(err) => {
+                LibraryConfigLoggedResult::Err(err.into())
+            }
+        }
+    }
 }
 
 pub struct Configurator<'a> {
@@ -116,19 +184,17 @@ pub extern "C" fn ddog_library_configurator_drop(_: Box<Configurator>) {}
 #[no_mangle]
 pub extern "C" fn ddog_library_configurator_get(
     configurator: &Configurator,
-) -> ffi::Result<ffi::Vec<LibraryConfig>> {
-    (|| {
+) -> LibraryConfigLoggedResult {
+    catch_panic!({
         let local_path = configurator
             .local_path
             .as_ref()
-            .map(|p| p.into_std().to_str())
-            .transpose()?
+            .and_then(|p| p.into_std().to_str().ok())
             .unwrap_or(lib_config::Configurator::LOCAL_STABLE_CONFIGURATION_PATH);
         let fleet_path = configurator
             .fleet_path
             .as_ref()
-            .map(|p| p.into_std().to_str())
-            .transpose()?
+            .and_then(|p| p.into_std().to_str().ok())
             .unwrap_or(lib_config::Configurator::FLEET_STABLE_CONFIGURATION_PATH);
         let detected_process_info;
         let process_info = match configurator.process_info {
@@ -141,14 +207,14 @@ pub extern "C" fn ddog_library_configurator_get(
             }
         };
 
-        configurator.inner.get_config_from_file(
+        let result = configurator.inner.get_config_from_file(
             local_path.as_ref(),
             fleet_path.as_ref(),
             process_info,
-        )
-    })()
-    .and_then(LibraryConfig::rs_vec_to_ffi)
-    .into()
+        );
+
+        LibraryConfig::logged_result_to_ffi_with_messages(result)
+    })
 }
 
 #[no_mangle]
@@ -190,4 +256,12 @@ pub extern "C" fn ddog_library_config_local_stable_config_path() -> ffi::CStr<'s
 }
 
 #[no_mangle]
-pub extern "C" fn ddog_library_config_drop(_: ffi::Vec<LibraryConfig>) {}
+pub extern "C" fn ddog_library_config_drop(mut config_result: LibraryConfigLoggedResult) {
+    match &mut config_result {
+        LibraryConfigLoggedResult::Ok(_) => {}
+        LibraryConfigLoggedResult::Err(err) => {
+            // Use the internal error clearing function for defensive cleanup
+            ddcommon_ffi::clear_error(err);
+        }
+    }
+}