Use a proper struct for Telemetry SHM data

Signed-off-by: Bob Weinand <bob.weinand@datadoghq.com>

Author: bwoebi

components-rs/telemetry.rs

@@ -1,11 +1,10 @@
 use crate::log::Log;
-use datadog_sidecar::service::telemetry::path_for_telemetry;
+use datadog_sidecar::service::telemetry::{path_for_telemetry, TelemetryCachedClientShmData};
 
 use hashbrown::{Equivalent, HashMap};
-use std::collections::HashSet;
 use std::ffi::CString;
 use std::path::PathBuf;
-use std::time::{Duration, SystemTime};
+use std::time::Duration;
 
 use datadog_ipc::platform::NamedShmHandle;
 use datadog_sidecar::one_way_shared_memory::{open_named_shm, OneWayShmReader};
@@ -255,10 +254,7 @@ pub unsafe extern "C" fn ddog_sidecar_telemetry_add_integration_log_buffer(
 }
 
 pub struct ShmCache {
-    pub config_sent: bool,
-    pub integrations: HashSet<Integration>,
-    pub composer_paths: HashSet<PathBuf>,
-    pub last_endpoints_push: SystemTime,
+    pub shared: TelemetryCachedClientShmData,
     pub reader: OneWayShmReader<NamedShmHandle, CString>,
 }
 
@@ -287,7 +283,7 @@ pub unsafe extern "C" fn ddog_sidecar_telemetry_config_sent(
     service: CharSlice,
     env: CharSlice,
 ) -> bool {
-    ddog_sidecar_telemetry_cache_get_or_update(cache, service, env).config_sent
+    ddog_sidecar_telemetry_cache_get_or_update(cache, service, env).shared.config_sent
 }
 
 unsafe fn ddog_sidecar_telemetry_cache_get_or_update<'a>(
@@ -305,21 +301,13 @@ unsafe fn ddog_sidecar_telemetry_cache_get_or_update<'a>(
                 if changed {
                     buf = newbuf;
                 } else {
-                    cache.config_sent = false;
-                    cache.integrations.clear();
-                    cache.composer_paths.clear();
-                    cache.last_endpoints_push = SystemTime::UNIX_EPOCH;
+                    cache.shared = TelemetryCachedClientShmData::default();
                     return;
                 }
             }
 
-            if let Ok((config_sent, integrations, composer_paths, last_endpoints_push)) =
-                bincode::deserialize::<(bool, HashSet<Integration>, HashSet<PathBuf>, SystemTime)>(buf)
-            {
-                cache.config_sent = config_sent;
-                cache.integrations = integrations;
-                cache.composer_paths = composer_paths;
-                cache.last_endpoints_push = last_endpoints_push;
+            if let Ok(shared) = bincode::deserialize::<TelemetryCachedClientShmData>(buf) {
+                cache.shared = shared;
             }
         }
     }
@@ -337,10 +325,7 @@ unsafe fn ddog_sidecar_telemetry_cache_get_or_update<'a>(
     let reader = OneWayShmReader::<NamedShmHandle, _>::new(open_named_shm(&shm_path).ok(), shm_path);
     let cached_entry = cache.entry(ShmCacheKey(service_str.into(), env_str.into())).insert(ShmCache {
         reader,
-        config_sent: false,
-        integrations: HashSet::new(),
-        composer_paths: HashSet::new(),
-        last_endpoints_push: SystemTime::UNIX_EPOCH,
+        shared: TelemetryCachedClientShmData::default(),
     }).into_mut();
 
     refresh_cache(cached_entry);
@@ -365,10 +350,10 @@ pub unsafe extern "C" fn ddog_sidecar_telemetry_filter_flush(
         .into_iter()
         .filter(|action| match action {
             SidecarAction::Telemetry(TelemetryActions::AddIntegration(integration)) => {
-                !cache_entry.integrations.contains(integration)
+                !cache_entry.shared.integrations.contains(integration)
             }
             SidecarAction::PhpComposerTelemetryFile(path) => {
-                !cache_entry.composer_paths.contains(path)
+                !cache_entry.shared.composer_paths.contains(path)
             }
             _ => true,
         })
@@ -392,5 +377,5 @@ pub unsafe extern "C" fn ddog_sidecar_telemetry_are_endpoints_collected(
     env: CharSlice,
 ) -> bool {
     let cache_entry = ddog_sidecar_telemetry_cache_get_or_update(cache, service, env);
-    cache_entry.last_endpoints_push.elapsed().map_or(false, |d| d < Duration::from_secs(1800)) // 30 minutes
+    cache_entry.shared.last_endpoints_push.elapsed().map_or(false, |d| d < Duration::from_secs(1800)) // 30 minutes
 }