feat(rc)!: add process_tags to remote config Target

datadog-remote-config/examples/remote_config_fetch.rs

@@ -33,6 +33,7 @@ async fn main() {
             env: ENV.to_string(),
             app_version: VERSION.to_string(),
             tags: vec![Tag::new("test", "value").unwrap()],
+            process_tags: vec![],
         },
         RUNTIME_ID.to_string(),
         ConfigOptions {

datadog-remote-config/src/fetch/fetcher.rs

@@ -277,6 +277,7 @@ impl<S: FileStorage> ConfigFetcher<S> {
             env,
             app_version,
             tags,
+            process_tags,
         } = (*target).clone();
 
         let mut cached_target_files = vec![];
@@ -325,6 +326,8 @@ impl<S: FileStorage> ConfigFetcher<S> {
                     env,
                     app_version,
                     tags: tags.iter().map(|t| t.to_string()).collect(),
+                    process_tags: process_tags.iter().map(|t| t.to_string()).collect(),
+                    container_tags: vec![],
                 }),
                 is_agent: false,
                 client_agent: None,
@@ -601,6 +604,19 @@ pub mod tests {
             env: "env".to_string(),
             app_version: "1.3.5".to_string(),
             tags: vec![],
+            process_tags: vec![],
+        })
+    });
+    pub(crate) static DUMMY_TARGET_WITH_PROCESS_TAGS: LazyLock<Arc<Target>> = LazyLock::new(|| {
+        Arc::new(Target {
+            service: "service".to_string(),
+            env: "env".to_string(),
+            app_version: "1.3.5".to_string(),
+            tags: vec![],
+            process_tags: vec![
+                libdd_common::tag!("entrypoint.workdir", "datadog-remote-config"),
+                libdd_common::tag!("entrypoint.type", "script"),
+            ],
         })
     });
 
@@ -898,6 +914,52 @@ pub mod tests {
         }
     }
 
+    #[tokio::test]
+    #[cfg_attr(miri, ignore)]
+    async fn test_process_tags_forwarded_in_client_tracer() {
+        let server: Arc<RemoteConfigServer> = RemoteConfigServer::spawn();
+        server.files.lock().unwrap().insert(
+            PATH_FIRST.clone(),
+            (
+                vec![DUMMY_TARGET_WITH_PROCESS_TAGS.clone()],
+                1,
+                "v1".to_string(),
+            ),
+        );
+
+        let storage = Arc::new(Storage::default());
+        let mut fetcher = ConfigFetcher::new(
+            storage,
+            Arc::new(ConfigFetcherState::new(server.dummy_options().invariants)),
+        );
+        let mut opaque_state = ConfigClientState::default();
+
+        let fetched = fetcher
+            .fetch_once(
+                DUMMY_RUNTIME_ID,
+                DUMMY_TARGET_WITH_PROCESS_TAGS.clone(),
+                &server.dummy_product_capabilities(),
+                "foo",
+                &mut opaque_state,
+            )
+            .await
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(fetched.len(), 1);
+
+        let req = server.last_request.lock().unwrap();
+        let req = req.as_ref().unwrap();
+        let tracer = req.client.as_ref().unwrap().client_tracer.as_ref().unwrap();
+        assert_eq!(
+            tracer.process_tags,
+            &[
+                "entrypoint.workdir:datadog-remote-config",
+                "entrypoint.type:script"
+            ]
+        );
+    }
+
     #[test]
     #[cfg_attr(miri, ignore)]
     fn test_capability_encoding() {

datadog-remote-config/src/fetch/shared.rs

@@ -385,6 +385,7 @@ pub mod tests {
             env: "env".to_string(),
             app_version: "7.8.9".to_string(),
             tags: vec![],
+            process_tags: vec![],
         })
     });
 

datadog-remote-config/src/lib.rs

@@ -32,6 +32,7 @@ pub struct Target {
     pub env: String,
     pub app_version: String,
     pub tags: Vec<Tag>,
+    pub process_tags: Vec<Tag>,
 }
 
 #[repr(C)]

datadog-sidecar-ffi/src/lib.rs

@@ -255,6 +255,7 @@ pub unsafe extern "C" fn ddog_remote_config_reader_for_endpoint<'a>(
             env: env_name.to_utf8_lossy().into(),
             app_version: app_version.to_utf8_lossy().into(),
             tags: tags.as_slice().to_vec(),
+            process_tags: vec![],
         }),
     ))
 }
@@ -588,7 +589,7 @@ pub unsafe extern "C" fn ddog_sidecar_session_set_config(
     remote_config_capabilities_count: usize,
     remote_config_enabled: bool,
     is_fork: bool,
-    process_tags: ffi::CharSlice,
+    process_tags: &libdd_common_ffi::Vec<Tag>,
 ) -> MaybeError {
     #[cfg(unix)]
     let remote_config_notify_target = libc::getpid();
@@ -632,7 +633,7 @@ pub unsafe extern "C" fn ddog_sidecar_session_set_config(
             .as_slice()
             .to_vec(),
             remote_config_enabled,
-            process_tags: process_tags.to_utf8_lossy().into(),
+            process_tags: process_tags.to_vec(),
         },
         is_fork
     ));
@@ -646,12 +647,12 @@ pub unsafe extern "C" fn ddog_sidecar_session_set_config(
 pub unsafe extern "C" fn ddog_sidecar_session_set_process_tags(
     transport: &mut Box<SidecarTransport>,
     session_id: ffi::CharSlice,
-    process_tags: ffi::CharSlice,
+    process_tags: &libdd_common_ffi::Vec<Tag>,
 ) -> MaybeError {
     try_c!(blocking::set_session_process_tags(
         transport,
         session_id.to_utf8_lossy().into(),
-        process_tags.to_utf8_lossy().into(),
+        process_tags.to_vec(),
     ));
 
     MaybeError::None

datadog-sidecar-ffi/tests/sidecar.rs

@@ -87,6 +87,7 @@ fn test_ddog_sidecar_register_app() {
         .unwrap();
 
     unsafe {
+        let process_tags = libdd_common_ffi::Vec::default();
         ddog_sidecar_session_set_config(
             &mut transport,
             "session_id".into(),
@@ -112,7 +113,7 @@ fn test_ddog_sidecar_register_app() {
             0,
             false,
             false,
-            "".into(),
+            &process_tags,
         )
         .unwrap_none();
 
@@ -163,7 +164,7 @@ fn test_ddog_sidecar_register_app() {
             0,
             false,
             false,
-            "".into(),
+            &process_tags,
         )
         .unwrap_none();
 

datadog-sidecar/src/service/blocking.rs

@@ -249,15 +249,15 @@ pub fn set_session_config(
 ///
 /// * `transport` - The transport used for communication.
 /// * `session_id` - The ID of the session.
-/// * `process_tags` - The process tags string to set.
+/// * `process_tags` - The process tags to set.
 ///
 /// # Returns
 ///
 /// An `io::Result<()>` indicating the result of the operation.
 pub fn set_session_process_tags(
     transport: &mut SidecarTransport,
     session_id: String,
-    process_tags: String,
+    process_tags: Vec<Tag>,
 ) -> io::Result<()> {
     transport.send(SidecarInterfaceRequest::SetSessionProcessTags {
         session_id,

datadog-sidecar/src/service/mod.rs

@@ -64,7 +64,7 @@ pub struct SessionConfig {
     pub remote_config_products: Vec<RemoteConfigProduct>,
     pub remote_config_capabilities: Vec<RemoteConfigCapabilities>,
     pub remote_config_enabled: bool,
-    pub process_tags: String,
+    pub process_tags: Vec<Tag>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]

datadog-sidecar/src/service/remote_configs.rs

@@ -110,6 +110,7 @@ impl RemoteConfigs {
         app_version: String,
         tags: Vec<Tag>,
         dynamic_instrumentation_state: DynamicInstrumentationConfigState,
+        process_tags: Vec<Tag>,
     ) -> RemoteConfigsGuard {
         match self.0.lock_or_panic().entry(options.invariants) {
             Entry::Occupied(e) => e.into_mut(),
@@ -148,6 +149,7 @@ impl RemoteConfigs {
                 capabilities: options.capabilities,
             },
             dynamic_instrumentation_state,
+            process_tags,
         )
     }
 

datadog-sidecar/src/service/runtime_info.rs

@@ -142,6 +142,9 @@ impl ActiveApplication {
             .as_ref()
             .expect("Expecting remote config invariants to be set early")
             .clone();
+
+        let process_tags = session.process_tags.lock_or_panic().clone();
+
         if *session.remote_config_enabled.lock_or_panic() {
             self.remote_config_guard = Some(
                 remote_configs.add_runtime(
@@ -158,6 +161,7 @@ impl ActiveApplication {
                         .expect("set_metadata was called before"),
                     self.global_tags.clone(),
                     dynamic_instrumentation_state,
+                    process_tags,
                 ),
             );
         }

datadog-sidecar/src/service/session_info.rs

@@ -14,7 +14,7 @@ use crate::log::{MultiEnvFilterGuard, MultiWriterGuard};
 use crate::{spawn_map_err, tracer};
 use datadog_live_debugger::sender::{DebuggerType, PayloadSender};
 use datadog_remote_config::fetch::ConfigOptions;
-use libdd_common::MutexExt;
+use libdd_common::{tag::Tag, MutexExt};
 use tracing::log::warn;
 use tracing::{debug, error, info, trace};
 
@@ -43,7 +43,7 @@ pub(crate) struct SessionInfo {
     pub(crate) session_id: String,
     pub(crate) pid: Arc<AtomicI32>,
     pub(crate) remote_config_enabled: Arc<Mutex<bool>>,
-    pub(crate) process_tags: Arc<Mutex<Option<String>>>,
+    pub(crate) process_tags: Arc<Mutex<Vec<Tag>>>,
 }
 
 impl Clone for SessionInfo {

datadog-sidecar/src/service/sidecar_interface.rs

@@ -73,9 +73,9 @@ pub trait SidecarInterface {
     /// # Arguments
     ///
     /// * `session_id` - The ID of the session.
-    /// * `process_tags` - The process tags string.
+    /// * `process_tags` - The process tags.
     #[force_backpressure]
-    async fn set_session_process_tags(session_id: String, process_tags: String);
+    async fn set_session_process_tags(session_id: String, process_tags: Vec<Tag>);
 
     /// Shuts down a runtime.
     ///

datadog-sidecar/src/service/sidecar_server.rs

@@ -567,8 +567,7 @@ impl SidecarInterface for SidecarServer {
             *session.remote_config_notify_function.lock().unwrap() = remote_config_notify_function;
         }
         *session.remote_config_enabled.lock_or_panic() = config.remote_config_enabled;
-        *session.process_tags.lock_or_panic() =
-            (!config.process_tags.is_empty()).then_some(config.process_tags.clone());
+        *session.process_tags.lock_or_panic() = config.process_tags.clone();
         session.modify_telemetry_config(|cfg| {
             cfg.telemetry_heartbeat_interval = config.telemetry_heartbeat_interval;
             let endpoint = get_product_endpoint(
@@ -664,10 +663,10 @@ impl SidecarInterface for SidecarServer {
         self,
         _: Context,
         session_id: String,
-        process_tags: String,
+        process_tags: Vec<Tag>,
     ) -> Self::SetSessionProcessTagsFut {
         let session = self.get_session(&session_id);
-        *session.process_tags.lock_or_panic() = (!process_tags.is_empty()).then_some(process_tags);
+        *session.process_tags.lock_or_panic() = process_tags;
         no_response()
     }
 

datadog-sidecar/src/service/telemetry.rs

@@ -77,7 +77,7 @@ impl TelemetryCachedClient {
         instance_id: &InstanceId,
         runtime_meta: &RuntimeMetadata,
         get_config: impl FnOnce() -> libdd_telemetry::config::Config,
-        process_tags: Option<String>,
+        process_tags: Vec<Tag>,
     ) -> Self {
         let mut builder = TelemetryWorkerBuilder::new_fetch_host(
             service.to_string(),
@@ -88,7 +88,13 @@ impl TelemetryCachedClient {
 
         builder.runtime_id = Some(instance_id.runtime_id.clone());
         builder.application.env = Some(env.to_string());
-        builder.application.process_tags = process_tags;
+        builder.application.process_tags = (!process_tags.is_empty()).then(|| {
+            process_tags
+                .iter()
+                .map(|tag| tag.to_string())
+                .collect::<Vec<_>>()
+                .join(",")
+        });
         let config = get_config();
         builder.config = config.clone();
 
@@ -300,7 +306,7 @@ impl TelemetryCachedClientSet {
         instance_id: &InstanceId,
         runtime_meta: &RuntimeMetadata,
         get_config: F,
-        process_tags: Option<String>,
+        process_tags: Vec<Tag>,
     ) -> Arc<Mutex<TelemetryCachedClient>>
     where
         F: FnOnce() -> libdd_telemetry::config::Config,

datadog-sidecar/src/shm_remote_config.rs

@@ -461,12 +461,14 @@ impl<N: NotifyTarget + 'static> ShmRemoteConfigs<N> {
         tags: Vec<Tag>,
         product_capabilities: ProductCapabilities,
         dynamic_instrumentation_state: DynamicInstrumentationConfigState,
+        process_tags: Vec<Tag>,
     ) -> ShmRemoteConfigsGuard<N> {
         let target = Arc::new(Target {
             service,
             env,
             app_version,
             tags,
+            process_tags,
         });
         self.0.add_runtime(
             runtime_id.clone(),
@@ -776,6 +778,7 @@ mod tests {
             env: "env".to_string(),
             app_version: "1.3.5".to_string(),
             tags: vec![],
+            process_tags: vec![],
         })
     });
 
@@ -852,6 +855,7 @@ mod tests {
                 capabilities: server.dummy_options().capabilities,
             },
             DynamicInstrumentationConfigState::Disabled,
+            DUMMY_TARGET.process_tags.clone(),
         );
 
         receiver.recv().await;

datadog-tracer-flare/src/lib.rs

@@ -192,6 +192,7 @@ impl TracerFlareManager {
                 env,
                 app_version,
                 tags: vec![],
+                process_tags: vec![],
             },
             runtime_id,
             config_to_fetch,

libdd-trace-protobuf/src/pb/remoteconfig.proto

@@ -35,6 +35,8 @@ message ClientTracer {
   string env = 5;
   string app_version = 6;
   repeated string tags = 7;
+  repeated string process_tags = 9;
+  repeated string container_tags = 10;
 }
 
 message ClientAgent {

libdd-trace-protobuf/src/remoteconfig.rs

@@ -54,6 +54,10 @@ pub struct ClientTracer {
     pub app_version: ::prost::alloc::string::String,
     #[prost(string, repeated, tag = "7")]
     pub tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(string, repeated, tag = "9")]
+    pub process_tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(string, repeated, tag = "10")]
+    pub container_tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
 }
 #[derive(Deserialize, Serialize)]
 #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]