feat: detect process.runtime.name and process.runtime.version (#251)

Signed-off-by: bestgopher <[email protected]>

Author: bestgopher

opentelemetry-resource-detectors/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## vNext
 
+### Added
+
+- Add "process.runtime.name/process.runtime.version/process.runtime.description" attributes into the `ProcessResourceDetector`.
+
 ## v0.8.0
 
 ### Changed

opentelemetry-resource-detectors/build.rs

@@ -0,0 +1,21 @@
+use std::process::Command;
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let Ok(output) = Command::new("rustc").arg("-V").output() else {
+        return;
+    };
+
+    let Ok(stdout) = String::from_utf8(output.stdout) else {
+        return;
+    };
+
+    println!("cargo:rustc-env=RUSTC_VERSION_DESCRIPTION={}", stdout);
+
+    // rustc -V: rustc 1.76.0 (07dca489a 2024-02-04)
+    // version is 1.76.0
+    if let Some(version) = stdout.split_whitespace().nth(1) {
+        println!("cargo:rustc-env=RUSTC_VERSION={}", version);
+    }
+}

opentelemetry-resource-detectors/src/process.rs

@@ -15,6 +15,9 @@ use std::process::id;
 /// - process command line arguments(`process.command_args`), the full command arguments of this
 ///   application.
 /// - OS assigned process id(`process.pid`).
+/// - process runtime version(`process.runtime.version`).
+/// - process runtime name(`process.runtime.name`).
+/// - process runtime description(`process.runtime.description`).
 pub struct ProcessResourceDetector;
 
 impl ResourceDetector for ProcessResourceDetector {
@@ -25,29 +28,76 @@ impl ResourceDetector for ProcessResourceDetector {
             .map(|arg| arg.to_string_lossy().into_owned().into())
             .collect::<Vec<StringValue>>();
         Resource::builder_empty()
-            .with_attributes(vec![
-                KeyValue::new(
-                    opentelemetry_semantic_conventions::attribute::PROCESS_COMMAND_ARGS,
-                    Value::Array(cmd_arg_val.into()),
-                ),
-                KeyValue::new(
-                    opentelemetry_semantic_conventions::attribute::PROCESS_PID,
-                    id() as i64,
-                ),
-            ])
+            .with_attributes(
+                vec![
+                    Some(KeyValue::new(
+                        opentelemetry_semantic_conventions::attribute::PROCESS_COMMAND_ARGS,
+                        Value::Array(cmd_arg_val.into()),
+                    )),
+                    Some(KeyValue::new(
+                        opentelemetry_semantic_conventions::attribute::PROCESS_PID,
+                        id() as i64,
+                    )),
+                    Some(KeyValue::new(
+                        opentelemetry_semantic_conventions::attribute::PROCESS_RUNTIME_NAME,
+                        "rustc",
+                    )),
+                    // Set from build.rs
+                    option_env!("RUSTC_VERSION").map(|rustc_version| {
+                        KeyValue::new(
+                            opentelemetry_semantic_conventions::attribute::PROCESS_RUNTIME_VERSION,
+                            rustc_version,
+                        )
+                    }),
+                    // Set from build.rs
+                    option_env!("RUSTC_VERSION_DESCRIPTION").map(|rustc_version_desc| {
+                        KeyValue::new(
+                            opentelemetry_semantic_conventions::attribute::PROCESS_RUNTIME_DESCRIPTION,
+                            rustc_version_desc,
+                        )
+                    }),
+                ]
+                .into_iter()
+                .flatten(),
+            )
             .build()
     }
 }
 
-#[cfg(target_os = "linux")]
 #[cfg(test)]
 mod tests {
     use super::ProcessResourceDetector;
     use opentelemetry_sdk::resource::ResourceDetector;
+    use opentelemetry_semantic_conventions::resource::PROCESS_RUNTIME_DESCRIPTION;
 
+    #[cfg(target_os = "linux")]
     #[test]
     fn test_processor_resource_detector() {
         let resource = ProcessResourceDetector.detect();
-        assert_eq!(resource.len(), 2); // we cannot assert on the values because it changes along with runtime.
+        assert_eq!(resource.len(), 5); // we cannot assert on the values because it changes along with runtime.
+    }
+
+    #[test]
+    fn test_processor_resource_detector_runtime() {
+        use opentelemetry_semantic_conventions::attribute::{
+            PROCESS_RUNTIME_NAME, PROCESS_RUNTIME_VERSION,
+        };
+
+        let resource = ProcessResourceDetector.detect();
+
+        assert_eq!(
+            resource.get(&PROCESS_RUNTIME_NAME.into()),
+            Some("rustc".into())
+        );
+
+        assert_eq!(
+            resource.get(&PROCESS_RUNTIME_VERSION.into()),
+            Some(env!("RUSTC_VERSION").into())
+        );
+
+        assert_eq!(
+            resource.get(&PROCESS_RUNTIME_DESCRIPTION.into()),
+            Some(env!("RUSTC_VERSION_DESCRIPTION").into())
+        );
     }
 }