feat(rc): add process_tags to remote config Target

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,7 @@ 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(),
                 }),
                 is_agent: false,
                 client_agent: None,
@@ -601,6 +603,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::Tag::new("entrypoint.workdir", "datadog-remote-config").unwrap(),
+                libdd_common::tag::Tag::new("entrypoint.type", "script").unwrap(),
+            ],
         })
     });
 
@@ -898,6 +913,42 @@ 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![],
         }),
     ))
 }

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,13 @@ impl ActiveApplication {
             .as_ref()
             .expect("Expecting remote config invariants to be set early")
             .clone();
+
+        let process_tags = session
+            .process_tags
+            .lock_or_panic()
+            .clone()
+            .unwrap_or_default();
+
         if *session.remote_config_enabled.lock_or_panic() {
             self.remote_config_guard = Some(
                 remote_configs.add_runtime(
@@ -158,6 +165,14 @@ impl ActiveApplication {
                         .expect("set_metadata was called before"),
                     self.global_tags.clone(),
                     dynamic_instrumentation_state,
+                    process_tags
+                        .split(',')
+                        .filter_map(|s| {
+                            s.split_once(':').and_then(|(key, value)| {
+                                libdd_common::tag::Tag::new(key, value).ok()
+                            })
+                        })
+                        .collect(),
                 ),
             );
         }

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,7 @@ message ClientTracer {
   string env = 5;
   string app_version = 6;
   repeated string tags = 7;
+  repeated string process_tags = 9;
 }
 
 message ClientAgent {