Convert local root span id to u64, fix clippy lints

ddcommon-ffi/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "ddcommon-ffi"
-version = "1.0.1"
+version = "2.0.0"
 edition = "2021"
 license = "Apache-2.0"
 

ddcommon-ffi/src/vec.rs

@@ -59,7 +59,7 @@ impl<T> From<alloc::vec::Vec<T>> for Vec<T> {
 impl From<anyhow::Error> for Vec<u8> {
     fn from(err: anyhow::Error) -> Self {
         let mut vec = vec![];
-        write!(vec, "{}", err).expect("write to vec to always succeed");
+        write!(vec, "{err}").expect("write to vec to always succeed");
         Self::from(vec)
     }
 }

ddcommon/Cargo.toml

@@ -5,7 +5,7 @@
 edition = "2021"
 license = "Apache-2.0"
 name = "ddcommon"
-version = "1.0.1"
+version = "2.0.0"
 
 [lib]
 crate-type = ["lib"]

ddcommon/src/tag.rs

@@ -55,10 +55,10 @@ impl Tag {
 
         let mut chars = chunk.chars();
         if chars.next() == Some(':') {
-            return Err(format!("tag '{}' begins with a colon", chunk).into());
+            return Err(format!("tag '{chunk}' begins with a colon").into());
         }
         if chars.last() == Some(':') {
-            return Err(format!("tag '{}' ends with a colon", chunk).into());
+            return Err(format!("tag '{chunk}' ends with a colon").into());
         }
 
         Ok(Tag {
@@ -74,7 +74,7 @@ impl Tag {
         let key = key.as_ref();
         let value = value.as_ref();
 
-        Tag::from_value(format!("{}:{}", key, value))
+        Tag::from_value(format!("{key}:{value}"))
     }
 }
 

ddtelemetry-ffi/Cargo.toml

@@ -3,14 +3,14 @@
 
 [package]
 name = "ddtelemetry-ffi"
-version = "1.0.1"
+version = "2.0.0"
 edition = "2021"
 
 [lib]
 crate-type = ["lib", "staticlib", "cdylib"]
 
 [dependencies]
-ddtelemetry = { path = "../ddtelemetry", version = "1.0.1" }
-ddcommon-ffi = { path = "../ddcommon-ffi", version = "1.0.1" }
+ddtelemetry = { path = "../ddtelemetry" }
+ddcommon-ffi = { path = "../ddcommon-ffi" }
 paste = "1"
 libc = "0.2"

ddtelemetry/Cargo.toml

@@ -2,7 +2,7 @@
 edition = "2021"
 license = "Apache 2.0"
 name = "ddtelemetry"
-version = "1.0.1"
+version = "2.0.0"
 
 [dependencies]
 anyhow = {version = "1.0"}

ddtelemetry/benches/ipc.rs

@@ -47,7 +47,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         _ => panic!("shouldn't happen"),
     };
 
-    println!("Total requests handled: {}", requests_received);
+    println!("Total requests handled: {requests_received}");
 
     drop(transport);
     worker.join().unwrap();

ddtelemetry/src/config.rs

@@ -50,7 +50,7 @@ impl FromEnv {
         let agent_host =
             env::var(DD_AGENT_HOST).unwrap_or_else(|_| String::from(DEFAULT_AGENT_HOST));
 
-        format!("http://{}:{}", agent_host, agent_port)
+        format!("http://{agent_host}:{agent_port}")
     }
 
     fn get_intake_base_url() -> String {
@@ -63,9 +63,9 @@ impl FromEnv {
 
         if let Ok(dd_site) = env::var(DD_SITE) {
             if dd_site.is_empty() {
-                format!("{}.{}", PROD_INTAKE_FORMAT_PREFIX, DEFAULT_DD_SITE)
+                format!("{PROD_INTAKE_FORMAT_PREFIX}.{DEFAULT_DD_SITE}")
             } else {
-                format!("{}.{}", PROD_INTAKE_FORMAT_PREFIX, dd_site)
+                format!("{PROD_INTAKE_FORMAT_PREFIX}.{dd_site}")
             }
         } else {
             String::from(STAGING_INTAKE)
@@ -77,9 +77,9 @@ impl FromEnv {
 
         let telemetry_url = if api_key.is_some() {
             let telemetry_intake_base_url = Self::get_intake_base_url();
-            format!("{}{}", telemetry_intake_base_url, DIRECT_TELEMETRY_URL_PATH)
+            format!("{telemetry_intake_base_url}{DIRECT_TELEMETRY_URL_PATH}")
         } else {
-            format!("{}{}", &agent_url, AGENT_TELEMETRY_URL_PATH)
+            format!("{}{AGENT_TELEMETRY_URL_PATH}", &agent_url)
         };
 
         let telemetry_uri = Uri::from_str(&telemetry_url).ok()?;

ddtelemetry/src/fork.rs

@@ -142,7 +142,7 @@ pub mod tests {
         sock_a.read_to_string(&mut out).unwrap();
 
         assert_child_exit!(pid);
-        assert_eq!(format!("child-{}", pid), out);
+        assert_eq!(format!("child-{pid}"), out);
     }
 
     #[test]

ddtelemetry/src/ipc/platform/unix/mod.rs

@@ -23,7 +23,6 @@ mod tests {
         fs::File,
         io::{self, Read, Seek, Write},
         os::unix::prelude::{AsRawFd, RawFd},
-        path::Path,
     };
 
     use crate::ipc::platform::{metadata::ChannelMetadata, unix::message::MAX_FDS};
@@ -53,7 +52,7 @@ mod tests {
             .map(|p| format!("{}", p))
             .unwrap_or_else(|| "self".into());
 
-        let fds_path = Path::new("/proc").join(proc).join("fd");
+        let fds_path = std::path::Path::new("/proc").join(proc).join("fd");
         let fds = std::fs::read_dir(fds_path)?
             .filter_map(|r| r.ok())
             .filter_map(|r| {

ddtelemetry/src/metrics.rs

@@ -212,14 +212,14 @@ mod test {
             for (i, &a) in assertions.iter().enumerate() {
                 if a(e) {
                     if used[i] {
-                        panic!("Assertion {} has been used multiple times", i);
+                        panic!("Assertion {i} has been used multiple times");
                     }
                     found = true;
                     break;
                 }
             }
             if !found {
-                panic!("No assertion found for elem {:?}", e)
+                panic!("No assertion found for elem {e:?}")
             }
         }
     }

profiling-ffi/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "datadog-profiling-ffi"
-version = "1.0.1"
+version = "2.0.0"
 edition = "2021"
 license = "Apache-2.0"
 

profiling-ffi/src/profiles.rs

@@ -353,22 +353,20 @@ pub extern "C" fn ddog_prof_Profile_add(
 ///
 /// # Arguments
 /// * `profile` - a reference to the profile that will contain the samples.
-/// * `local_root_span_id` - the value of the local root span id label to look for.
+/// * `local_root_span_id`
 /// * `endpoint` - the value of the endpoint label to add for matching samples.
 ///
 /// # Safety
 /// The `profile` ptr must point to a valid Profile object created by this
 /// module.
 /// This call is _NOT_ thread-safe.
 #[no_mangle]
-pub unsafe extern "C" fn ddog_prof_Profile_set_endpoint<'a>(
+pub unsafe extern "C" fn ddog_prof_Profile_set_endpoint(
     profile: &mut datadog_profiling::profile::Profile,
-    local_root_span_id: CharSlice<'a>,
-    endpoint: CharSlice<'a>,
+    local_root_span_id: u64,
+    endpoint: CharSlice,
 ) {
-    let local_root_span_id = local_root_span_id.to_utf8_lossy();
     let endpoint = endpoint.to_utf8_lossy();
-
     profile.add_endpoint(local_root_span_id, endpoint);
 }
 

profiling/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "datadog-profiling"
-version = "1.0.1"
+version = "2.0.0"
 edition = "2021"
 license = "Apache-2.0"
 

profiling/src/exporter/config.rs

@@ -23,7 +23,7 @@ pub fn agent(base_url: Uri) -> anyhow::Result<Endpoint> {
         Some(pq) => {
             let path = pq.path();
             let path = path.strip_suffix('/').unwrap_or(path);
-            Some(format!("{}/profiling/v1/input", path).parse()?)
+            Some(format!("{path}/profiling/v1/input").parse()?)
         }
     };
     parts.path_and_query = p_q;

profiling/src/profile/mod.rs

@@ -91,7 +91,7 @@ pub struct Profile {
 }
 
 pub struct Endpoints {
-    mappings: FxIndexMap<i64, i64>,
+    mappings: FxIndexMap<u64, i64>,
     local_root_span_id_label: i64,
     endpoint_label: i64,
     stats: ProfiledEndpointsStats,
@@ -426,18 +426,19 @@ impl Profile {
         Some(profile)
     }
 
-    pub fn add_endpoint(&mut self, local_root_span_id: Cow<str>, endpoint: Cow<str>) {
+    /// Add the endpoint data to the endpoint mappings. The `endpoint` will be
+    /// interned, as will the strings "local root span id" and "trace endpoint".
+    pub fn add_endpoint(&mut self, local_root_span_id: u64, endpoint: Cow<str>) {
         if self.endpoints.mappings.is_empty() {
             self.endpoints.local_root_span_id_label = self.intern("local root span id");
             self.endpoints.endpoint_label = self.intern("trace endpoint");
         }
 
-        let interned_span_id = self.intern(local_root_span_id.as_ref());
         let interned_endpoint = self.intern(endpoint.as_ref());
 
         self.endpoints
             .mappings
-            .insert(interned_span_id, interned_endpoint);
+            .insert(local_root_span_id, interned_endpoint);
     }
 
     pub fn add_endpoint_count(&mut self, endpoint: Cow<str>, value: i64) {
@@ -488,6 +489,35 @@ impl Profile {
     pub fn get_string(&self, id: i64) -> Option<&String> {
         self.strings.get_index(id as usize)
     }
+
+    fn get_endpoint_for_label(&self, label: &Label) -> anyhow::Result<&i64> {
+        let local_root_span_id: u64 = if label.str == 0 {
+            /* Safety: the value is a u64, but pprof only has signed values,
+             * so we transmute it; the backend does the same.
+             */
+            unsafe { std::intrinsics::transmute(label.num) }
+        } else {
+            /* Sad path: have to fetch the string from the table and convert
+             * it back into a u64. Clients should change to use numbers!
+             */
+            let string = match self.strings.get_index(label.str as usize) {
+                None => anyhow::bail!(
+                    "failed to retrieve index {} from the string table when looking for endpoint data",
+                    label.str
+                ),
+                Some(string) => string,
+            };
+            string.as_str().parse()?
+        };
+
+        match self.endpoints.mappings.get(&local_root_span_id) {
+            None => Err(anyhow::anyhow!(
+                "failed to retrieve endpoint information for local root span id {}",
+                local_root_span_id
+            )),
+            Some(endpoint_string_id) => Ok(endpoint_string_id),
+        }
+    }
 }
 
 impl From<&Profile> for pprof::Profile {
@@ -509,14 +539,14 @@ impl From<&Profile> for pprof::Profile {
 
         if !profile.endpoints.mappings.is_empty() {
             for sample in samples.iter_mut() {
-                let mut endpoint: Option<&i64> = None;
-
-                for label in &sample.labels {
+                let endpoint = sample.labels.iter().find_map(|label| {
+                    // todo: log errors in get_endpoint_for_label (should not happen)
                     if label.key == profile.endpoints.local_root_span_id_label {
-                        endpoint = profile.endpoints.mappings.get(&label.str);
-                        break;
+                        profile.get_endpoint_for_label(label).ok()
+                    } else {
+                        None
                     }
-                }
+                });
 
                 if let Some(endpoint_value) = endpoint {
                     sample.labels.push(pprof::Label {
@@ -907,7 +937,7 @@ mod api_test {
 
         profile.add(sample2).expect("add to success");
 
-        profile.add_endpoint(Cow::from("10"), Cow::from("my endpoint"));
+        profile.add_endpoint(10, Cow::from("my endpoint"));
 
         let serialized_profile: pprof::Profile = (&profile).into();