refactor sidecar/interface.rs into smaller files

sidecar-ffi/src/lib.rs

@@ -9,8 +9,22 @@ use datadog_sidecar::agent_remote_config::{
 };
 use datadog_sidecar::config;
 use datadog_sidecar::config::LogMethod;
+use datadog_sidecar::one_way_shared_memory::{OneWayShmReader, ReaderOpener};
+use datadog_sidecar::service::{
+    blocking::{self, SidecarTransport},
+    InstanceId, QueueId, RuntimeMetadata, SerializedTracerHeaderTags, SessionConfig, SidecarAction,
+};
+use ddcommon::Endpoint;
 use ddcommon_ffi as ffi;
+use ddcommon_ffi::MaybeError;
+use ddtelemetry::{
+    data::{self, Dependency, Integration},
+    worker::{LifecycleAction, TelemetryActions},
+};
+use ddtelemetry_ffi::try_c;
+use ffi::slice::AsBytes;
 use libc::c_char;
+use std::convert::TryInto;
 use std::ffi::c_void;
 use std::fs::File;
 #[cfg(unix)]
@@ -20,21 +34,6 @@ use std::os::windows::io::{FromRawHandle, RawHandle};
 use std::slice;
 use std::time::Duration;
 
-use datadog_sidecar::interface::{
-    blocking::{self, SidecarTransport},
-    InstanceId, QueueId, RuntimeMeta, SerializedTracerHeaderTags, SessionConfig, SidecarAction,
-};
-use datadog_sidecar::one_way_shared_memory::{OneWayShmReader, ReaderOpener};
-use ddcommon::Endpoint;
-use ddtelemetry::{
-    data::{self, Dependency, Integration},
-    worker::{LifecycleAction, TelemetryActions},
-};
-use ffi::slice::AsBytes;
-
-use ddcommon_ffi::MaybeError;
-use ddtelemetry_ffi::try_c;
-
 #[repr(C)]
 pub struct NativeFile {
     pub handle: Box<PlatformHandle<File>>,
@@ -241,8 +240,8 @@ pub unsafe extern "C" fn ddog_sidecar_runtimeMeta_build(
     language_name: ffi::CharSlice,
     language_version: ffi::CharSlice,
     tracer_version: ffi::CharSlice,
-) -> Box<RuntimeMeta> {
-    let inner = RuntimeMeta::new(
+) -> Box<RuntimeMetadata> {
+    let inner = RuntimeMetadata::new(
         language_name.to_utf8_lossy(),
         language_version.to_utf8_lossy(),
         tracer_version.to_utf8_lossy(),
@@ -253,7 +252,7 @@ pub unsafe extern "C" fn ddog_sidecar_runtimeMeta_build(
 
 #[no_mangle]
 #[allow(clippy::missing_safety_doc)]
-pub unsafe extern "C" fn ddog_sidecar_runtimeMeta_drop(meta: Box<RuntimeMeta>) {
+pub unsafe extern "C" fn ddog_sidecar_runtimeMeta_drop(meta: Box<RuntimeMetadata>) {
     drop(meta)
 }
 
@@ -345,7 +344,7 @@ pub unsafe extern "C" fn ddog_sidecar_telemetry_flushServiceData(
     transport: &mut Box<SidecarTransport>,
     instance_id: &InstanceId,
     queue_id: &QueueId,
-    runtime_meta: &RuntimeMeta,
+    runtime_meta: &RuntimeMetadata,
     service_name: ffi::CharSlice,
     env_name: ffi::CharSlice,
 ) -> MaybeError {
@@ -429,19 +428,27 @@ pub struct TracerHeaderTags<'a> {
     pub client_computed_stats: bool,
 }
 
-impl<'a> From<&'a TracerHeaderTags<'a>> for SerializedTracerHeaderTags {
-    fn from(tags: &'a TracerHeaderTags<'a>) -> Self {
-        datadog_trace_utils::trace_utils::TracerHeaderTags {
-            lang: &tags.lang.to_utf8_lossy(),
-            lang_version: &tags.lang_version.to_utf8_lossy(),
-            lang_interpreter: &tags.lang_interpreter.to_utf8_lossy(),
-            lang_vendor: &tags.lang_vendor.to_utf8_lossy(),
-            tracer_version: &tags.tracer_version.to_utf8_lossy(),
-            container_id: &tags.container_id.to_utf8_lossy(),
-            client_computed_top_level: tags.client_computed_top_level,
-            client_computed_stats: tags.client_computed_stats,
-        }
-        .into()
+impl<'a> TryInto<SerializedTracerHeaderTags> for &'a TracerHeaderTags<'a> {
+    type Error = std::io::Error;
+
+    fn try_into(self) -> Result<SerializedTracerHeaderTags, Self::Error> {
+        let tags = datadog_trace_utils::trace_utils::TracerHeaderTags {
+            lang: &self.lang.to_utf8_lossy(),
+            lang_version: &self.lang_version.to_utf8_lossy(),
+            lang_interpreter: &self.lang_interpreter.to_utf8_lossy(),
+            lang_vendor: &self.lang_vendor.to_utf8_lossy(),
+            tracer_version: &self.tracer_version.to_utf8_lossy(),
+            container_id: &self.container_id.to_utf8_lossy(),
+            client_computed_top_level: self.client_computed_top_level,
+            client_computed_stats: self.client_computed_stats,
+        };
+
+        tags.try_into().map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to convert TracerHeaderTags to SerializedTracerHeaderTags",
+            )
+        })
     }
 }
 
@@ -453,11 +460,13 @@ pub unsafe extern "C" fn ddog_sidecar_send_trace_v04_shm(
     shm_handle: Box<ShmHandle>,
     tracer_header_tags: &TracerHeaderTags,
 ) -> MaybeError {
+    let tracer_header_tags = try_c!(tracer_header_tags.try_into());
+
     try_c!(blocking::send_trace_v04_shm(
         transport,
         instance_id,
         *shm_handle,
-        tracer_header_tags.into(),
+        tracer_header_tags,
     ));
 
     MaybeError::None
@@ -471,11 +480,13 @@ pub unsafe extern "C" fn ddog_sidecar_send_trace_v04_bytes(
     data: ffi::CharSlice,
     tracer_header_tags: &TracerHeaderTags,
 ) -> MaybeError {
+    let tracer_header_tags = try_c!(tracer_header_tags.try_into());
+
     try_c!(blocking::send_trace_v04_bytes(
         transport,
         instance_id,
         data.as_bytes().to_vec(),
-        tracer_header_tags.into(),
+        tracer_header_tags,
     ));
 
     MaybeError::None

sidecar/src/entry.rs

@@ -15,8 +15,8 @@ use std::{
 };
 use tokio::sync::mpsc;
 
-use crate::interface::blocking::SidecarTransport;
-use crate::interface::SidecarServer;
+use crate::service::blocking::SidecarTransport;
+use crate::service::SidecarServer;
 use datadog_ipc::platform::AsyncChannel;
 
 use crate::setup::{self, IpcClient, IpcServer, Liaison};