Remove non used fields

Author: estringana

datadog-sidecar-ffi/src/lib.rs

@@ -409,58 +409,24 @@ pub unsafe extern "C" fn ddog_sidecar_telemetry_enqueueConfig(
     MaybeError::None
 }
 
-unsafe fn box_from_raw_opt<T: Default>(ptr: *mut T) -> Option<Box<T>> {
-    if ptr.is_null() {
-        Some(Box::new(T::default()))
-    } else {
-        Some(Box::from_raw(ptr))
-    }
-}
-
-fn slice_of_char_slice_to_vec_of_string<'a, T>(ffi_vec: T) -> Vec<String>
-where
-    T: AsRef<[CharSlice<'a>]>,
-{
-    ffi_vec
-        .as_ref()
-        .iter()
-        .map(|s| s.to_utf8_lossy().into_owned())
-        .collect()
-}
-
 /// Reports an endpoint to the telemetry.
 #[no_mangle]
 #[allow(clippy::missing_safety_doc)]
 pub unsafe extern "C" fn ddog_sidecar_telemetry_addEndpoint(
     transport: &mut Box<SidecarTransport>,
     instance_id: &InstanceId,
     queue_id: &QueueId,
-    r#type: CharSlice,
     method: ddtelemetry::data::Method,
     path: CharSlice,
     operation_name: CharSlice,
     resource_name: CharSlice,
-    request_body_type: *mut ffi::Vec<CharSlice>,
-    response_body_type: *mut ffi::Vec<CharSlice>,
-    authentication: *mut ffi::Vec<ddtelemetry::data::Authentication>,
-    metadata: CharSlice,
 ) -> MaybeError {
-    let request_body_type = box_from_raw_opt(request_body_type);
-    let response_body_type = box_from_raw_opt(response_body_type);
-    let authentication = box_from_raw_opt(authentication);
-
     #[allow(clippy::unwrap_used)]
     let endpoint = TelemetryActions::AddEndpoint(ddtelemetry::data::Endpoint {
-        r#type: Some(r#type.to_utf8_lossy().into_owned()),
         method: Some(method),
         path: Some(path.to_utf8_lossy().into_owned()),
         operation_name: operation_name.to_utf8_lossy().into_owned(),
         resource_name: resource_name.to_utf8_lossy().into_owned(),
-        request_body_type: request_body_type.map(|v| slice_of_char_slice_to_vec_of_string(&**v)),
-        response_body_type: response_body_type.map(|v| slice_of_char_slice_to_vec_of_string(&**v)),
-        // into_iter() is not implemented correctly for ffi::Vec, so we need to copy the elements
-        authentication: authentication.map(|v| v.iter().map(|auth| auth.to_owned()).collect()),
-        metadata: metadata.assume_utf8().to_string(),
     });
 
     try_c!(blocking::enqueue_actions(

ddtelemetry/src/data/payloads.rs

@@ -4,7 +4,6 @@
 use crate::data::metrics;
 
 use serde::{Deserialize, Serialize};
-use tracing::warn;
 
 #[derive(Serialize, Deserialize, Debug, Hash, PartialEq, Eq, Clone, Default)]
 pub struct Dependency {
@@ -119,67 +118,22 @@ pub enum Method {
     Other = 9, //This is specified as "*" in the OpenAPI spec
 }
 
-#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
-#[serde(rename_all = "UPPERCASE")]
-#[repr(C)]
-pub enum Authentication {
-    Jwt = 0,
-    Basic = 1,
-    Oauth = 2,
-    Oidc = 3,
-    ApiKey = 4,
-    Session = 5,
-    Mtls = 6,
-    Saml = 7,
-    Ldap = 8,
-    Form = 9,
-    Other = 10,
-}
-
 #[derive(Serialize, Deserialize, Debug, Hash, PartialEq, Eq, Clone, Default)]
 pub struct Endpoint {
-    #[serde(default)]
-    pub r#type: Option<String>,
     #[serde(default)]
     pub method: Option<Method>,
     #[serde(default)]
     pub path: Option<String>,
-    pub operation_name: String,
-    pub resource_name: String,
-    #[serde(default)]
-    pub request_body_type: Option<Vec<String>>,
-    #[serde(default)]
-    pub response_body_type: Option<Vec<String>>,
-    #[serde(default)]
-    pub authentication: Option<Vec<Authentication>>,
-    #[serde(default)]
-    pub metadata: String,
+    pub operation_name: String, 
+    pub resource_name: String   
 }
 
 impl Endpoint {
     pub fn to_json_value(&self) -> serde_json::Result<serde_json::Value> {
         let result = serde_json::to_value(self);
         match result {
-            Ok(mut value) => {
-                // replace the metadata string with parsed JSON
-                if let Some(obj) = value.as_object_mut() {
-                    let metadata_json = if self.metadata.is_empty() {
-                        serde_json::json!({})
-                    } else {
-                        serde_json::from_str(&self.metadata)?
-                    };
-                    obj.insert("metadata".to_string(), metadata_json);
-                }
-
-                Ok(value)
-            }
-            Err(err) => {
-                warn!(
-                    "Failed to convert Endpoint to JSON: {}: {}",
-                    self.metadata, err
-                );
-                Err(err)
-            }
+            Ok(value) => Ok(value),
+            Err(err) => Err(err),
         }
     }
 }