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

# What does this PR do?

This PR allows to send process_tags through Remote Configuration payload. This PR comes with DataDog/dd-trace-php#3658 testing the feature in PHP Tracer.

# Motivation

Process tags must be sent by dd-trace-php for every product including RC. PHP tracer is using libdatadog for sending RC payload. 

# How to test the change?

The changes is mainly validated in dd-trace-php. I also added a test here and modified the one impacted by the add of process_tags in the `.proto`.


Co-authored-by: louis.tricot <louis.tricot@datadoghq.com>

Author: dubloom

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,
                 ),
             );
         }