Fix bug in smaps parsing logic related to pathnames containing whitespace (#1237)

* Adds failing test for smaps pathnames with whitespace

* Adds fix for pathnames containing whitespace

* Adds changelog entry

Author: scottopell

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Introduced the ability for users to configure lading's sample rate,
   configuration option `sample_period_milliseconds` in `lading.yaml`.
 - Users can now configure expvar scraping on https endpoints, skipping certificate validation.
+- `smaps` parsing logic correctly collects memory region pathnames that contain whitespace
 - Fixes issue when parsing `NaN` values from a prometheus endpoint
 
 ## [0.25.4]

lading/src/observer/linux/procfs/memory/smaps.rs

@@ -67,9 +67,11 @@ impl Region {
             let mut offset: Option<u64> = None;
             let mut dev: Option<String> = None;
             let mut inode: Option<u64> = None;
-            let mut pathname: Option<String> = None;
+            let pathname: Option<String> = None;
+            let mut pathname_tokens = vec![];
 
             let mut chars = metadata_line.char_indices().peekable();
+            let mut entered_pathname = false;
 
             loop {
                 let token = next_token(metadata_line, &mut chars);
@@ -93,14 +95,15 @@ impl Region {
                     dev = Some(token.to_string());
                 } else if inode.is_none() {
                     inode = Some(token.parse::<u64>()?);
-                } else if pathname.is_none() {
-                    pathname = Some(token.to_string());
+                } else if pathname.is_none() || entered_pathname {
+                    entered_pathname = true;
+                    pathname_tokens.push(token);
                 } else {
                     break;
                 }
             }
 
-            pathname
+            pathname_tokens.join(" ")
         };
 
         let mut size: Option<u64> = None;
@@ -216,7 +219,7 @@ impl Region {
         };
 
         Ok(Region {
-            pathname: pathname.unwrap_or_default(),
+            pathname,
             size,
             pss,
             swap,
@@ -731,4 +734,38 @@ VmFlags:               rd ex mr mw me de sd";
 
         let _region = Region::from_str(region).expect("Parsing failed");
     }
+
+    #[test]
+    fn test_pathnames_with_whitespace() {
+        let region =
+            "7514356d1000-7514356d3000 rw-p 00000000 00:00 0                          [anon: glibc: loader malloc]
+Size:                  8 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                   8 kB
+Pss:                   8 kB
+Pss_Dirty:             8 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:         0 kB
+Private_Dirty:         8 kB
+Referenced:            8 kB
+Anonymous:             8 kB
+KSM:                   0 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+FilePmdMapped:         0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                  0 kB
+SwapPss:               0 kB
+Locked:                0 kB
+THPeligible:           0
+ProtectionKey:         0
+VmFlags: rd wr mr mw me ac sd";
+        let parsed_region = Region::from_str(region).expect("Parsing failed");
+
+        assert_eq!(parsed_region.pathname, ("[anon: glibc: loader malloc]"));
+    }
 }