prometheus-client-mmap 0.23.0-x86_64-linux → 0.24.3-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7851e4bc5f33acf49fffc52ff51d7fb63061df60da9e383dc0cc15e4704917c2
-  data.tar.gz: 00d412c3d379bcde0690f25f64609feed218541537bb198bbf1adbcbeecc72ce
+  metadata.gz: 96d81412cc07d51c07e2a4d3d63d24a0977f8f3218a469bace79a9d2abc929b6
+  data.tar.gz: 61c024688e436092d09d4b77214603e1c374be69e6b4b289d0d2997f10218c24
 SHA512:
-  metadata.gz: fe5642626ed2434a3a279e4eed3b548baa0c4a97bde02961a6346fcd456217d10b2b65fe53cd16d13554b5af50cd3a3ecba4b86bd539ab6fa351ead690339d74
-  data.tar.gz: 68c9990cd351879d489c09251118f03cecb1f4f3c2a0f47a8d6380061a2172c17a2377e6d3fa902b7002ee735f3363b1b7376811495f65758acfd88710eb3ec9
+  metadata.gz: a030d17f52d1530a30e8ff892632a00ff8cd10489ded1a7268eca58898dfd73c627f56f38bd8382066c70d9e58400719e37f1485790fcea723d377080512712c
+  data.tar.gz: 6a2bf596a09c5a7a255051f4c6945f2f325d6d0db03b0a9f537af50ade9b1b17356240628723401391b8eaa27ad66e2d9b7730c9c65b5a040049d19663b429b1

data/.tool-versions

@@ -0,0 +1 @@
+rust 1.65.0

data/README.md

@@ -200,6 +200,17 @@ Set `prometheus_multiproc_dir` environment variable to the path where you want m
 prometheus_multiproc_dir=/tmp
 ```
 
+### Multiprocess metrics via Rust extension
+
+If the environment variable `prometheus_rust_multiprocess_metrics=true` is set or if the `rust_multiprocess_metrics`
+configuration setting is `true` and the `fast_mmaped_file_rs` extension is available, it will be used to generate
+multiprocess metrics. This should be significantly faster than the C extension.
+
+### Read and write metrics via Rust extension
+
+If the environment variable `prometheus_rust_mmaped_file=true` is set then if the `fast_mmaped_file_rs`
+extension is available it will be used to read and write metrics from the mmapped file.
+
 ## Pitfalls
 
 ### PID cardinality

data/ext/fast_mmaped_file_rs/src/error.rs

@@ -9,7 +9,7 @@ use crate::util;
 use crate::PROM_EPARSING_ERROR;
 
 /// A lightweight representation of Ruby ExceptionClasses.
-#[derive(PartialEq, Clone, Copy, Debug)]
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
 pub enum RubyError {
     Arg,
     Encoding,
@@ -45,7 +45,7 @@ impl From<RubyError> for magnus::ExceptionClass {
 /// Errors returned internally within the crate. Methods called directly by Ruby return
 /// `magnus::error::Error` as do functions that interact heavily with Ruby. This can be
 /// converted into a `magnus::error::Error` at the boundary between Rust and Ruby.
-#[derive(PartialEq, Error, Debug)]
+#[derive(PartialEq, Eq, Error, Debug)]
 pub enum MmapError {
     /// A read or write was made while another thread had mutable access to the mmap.
     #[error("read/write operation attempted while mmap was being written to")]

data/ext/fast_mmaped_file_rs/src/file_entry.rs

@@ -1,4 +1,4 @@
-use magnus::{StaticSymbol, Symbol};
+use magnus::Symbol;
 use std::fmt::Write;
 use std::str;
 
@@ -80,7 +80,7 @@ impl<'a> BorrowedData<'a> {
 #[derive(Clone, Debug)]
 pub struct EntryMetadata {
     pub multiprocess_mode: Symbol,
-    pub type_: StaticSymbol,
+    pub type_: Symbol,
     pub value: f64,
 }
 
@@ -176,7 +176,7 @@ impl FileEntry {
         out.push_str(family_name);
         out.push(' ');
 
-        out.push_str(self.meta.type_.name().expect("name was invalid UTF-8"));
+        out.push_str(&self.meta.type_.name().expect("name was invalid UTF-8"));
         out.push('\n');
     }
 
@@ -438,7 +438,7 @@ mod test {
                     path,
                     len: case.json.len(),
                     multiprocess_mode: Symbol::new(case.multiprocess_mode),
-                    type_: StaticSymbol::new("gauge"),
+                    type_: Symbol::new("gauge"),
                     pid: pid.to_string(),
                 };
                 file_infos.push(info);
@@ -544,7 +544,7 @@ mod test {
                 path,
                 len: json.len(),
                 multiprocess_mode: Symbol::new(case.multiprocess_mode),
-                type_: StaticSymbol::new(case.metric_type),
+                type_: Symbol::new(case.metric_type),
                 pid: "worker-1".to_string(),
             };
 

data/ext/fast_mmaped_file_rs/src/file_info.rs

@@ -1,5 +1,5 @@
 use magnus::exception::*;
-use magnus::{Error, RString, StaticSymbol, Symbol, Value};
+use magnus::{Error, RString, Symbol, Value};
 use std::ffi::OsString;
 use std::fs::File;
 use std::io::{self, Read, Seek};
@@ -18,7 +18,7 @@ pub struct FileInfo {
     pub path: PathBuf,
     pub len: usize,
     pub multiprocess_mode: Symbol,
-    pub type_: StaticSymbol,
+    pub type_: Symbol,
     pub pid: String,
 }
 
@@ -59,7 +59,7 @@ impl FileInfo {
         let multiprocess_mode = Symbol::from_value(params[1])
             .ok_or_else(|| err!(arg_error(), "expected multiprocess_mode to be a symbol"))?;
 
-        let type_ = StaticSymbol::from_value(params[2])
+        let type_ = Symbol::from_value(params[2])
             .ok_or_else(|| err!(arg_error(), "expected file type to be a symbol"))?;
 
         let pid = RString::from_value(params[3])
@@ -103,7 +103,7 @@ impl FileInfo {
 
 #[cfg(test)]
 mod test {
-    use magnus::{eval, RArray, StaticSymbol, Symbol};
+    use magnus::{eval, RArray, Symbol};
     use rand::{thread_rng, Rng};
     use sha2::{Digest, Sha256};
 
@@ -168,7 +168,7 @@ mod test {
             path,
             len: buf.len(),
             multiprocess_mode: Symbol::new("puma"),
-            type_: StaticSymbol::new("max"),
+            type_: Symbol::new("max"),
             pid: "worker-0_0".to_string(),
         };
 

data/ext/fast_mmaped_file_rs/src/map.rs

@@ -166,7 +166,7 @@ impl EntryMap {
 
 #[cfg(test)]
 mod test {
-    use magnus::{StaticSymbol, Symbol};
+    use magnus::Symbol;
     use std::mem;
 
     use super::*;
@@ -197,7 +197,7 @@ mod test {
                 },
                 meta: EntryMetadata {
                     multiprocess_mode: Symbol::new("max"),
-                    type_: StaticSymbol::new("gauge"),
+                    type_: Symbol::new("gauge"),
                     value: 1.0,
                 },
             },
@@ -208,7 +208,7 @@ mod test {
                 },
                 meta: EntryMetadata {
                     multiprocess_mode: Symbol::new("max"),
-                    type_: StaticSymbol::new("gauge"),
+                    type_: Symbol::new("gauge"),
                     value: 1.0,
                 },
             },
@@ -219,7 +219,7 @@ mod test {
                 },
                 meta: EntryMetadata {
                     multiprocess_mode: Symbol::new("max"),
-                    type_: StaticSymbol::new("gauge"),
+                    type_: Symbol::new("gauge"),
                     value: 1.0,
                 },
             },
@@ -230,7 +230,7 @@ mod test {
                 },
                 meta: EntryMetadata {
                     multiprocess_mode: Symbol::new("max"),
-                    type_: StaticSymbol::new("gauge"),
+                    type_: Symbol::new("gauge"),
                     value: 1.0,
                 },
             },
@@ -241,7 +241,7 @@ mod test {
                 },
                 meta: EntryMetadata {
                     multiprocess_mode: Symbol::new("all"),
-                    type_: StaticSymbol::new("gauge"),
+                    type_: Symbol::new("gauge"),
                     value: 1.0,
                 },
             },
@@ -252,7 +252,7 @@ mod test {
                 },
                 meta: EntryMetadata {
                     multiprocess_mode: Symbol::new("all"),
-                    type_: StaticSymbol::new("gauge"),
+                    type_: Symbol::new("gauge"),
                     value: 1.0,
                 },
             },
@@ -293,7 +293,7 @@ mod test {
             },
             meta: EntryMetadata {
                 multiprocess_mode: Symbol::new("all"),
-                type_: StaticSymbol::new("gauge"),
+                type_: Symbol::new("gauge"),
                 value: 1.0,
             },
         };
@@ -305,7 +305,7 @@ mod test {
             },
             meta: EntryMetadata {
                 multiprocess_mode: Symbol::new("all"),
-                type_: StaticSymbol::new("gauge"),
+                type_: Symbol::new("gauge"),
                 value: 5.0,
             },
         };
@@ -317,7 +317,7 @@ mod test {
             },
             meta: EntryMetadata {
                 multiprocess_mode: Symbol::new("all"),
-                type_: StaticSymbol::new("gauge"),
+                type_: Symbol::new("gauge"),
                 value: 100.0,
             },
         };
@@ -329,7 +329,7 @@ mod test {
             },
             meta: EntryMetadata {
                 multiprocess_mode: Symbol::new("all"),
-                type_: StaticSymbol::new("gauge"),
+                type_: Symbol::new("gauge"),
                 value: 1.0,
             },
         };
@@ -460,7 +460,7 @@ mod test {
                 path,
                 len: case.json.len(),
                 multiprocess_mode: Symbol::new("max"),
-                type_: StaticSymbol::new("gauge"),
+                type_: Symbol::new("gauge"),
                 pid: "worker-1".to_string(),
             };
 

data/ext/fast_mmaped_file_rs/src/mmap/inner.rs

@@ -204,6 +204,12 @@ impl InnerMmap {
         self.map.as_ptr()
     }
 
+    /// Returns a mutable raw pointer to the mmap.
+    /// For use in updating RString internals which requires a mutable pointer.
+    pub fn as_mut_ptr(&self) -> *mut u8 {
+        self.map.as_ptr().cast_mut()
+    }
+
     /// Perform an msync(2) on the mmap, flushing all changes written
     /// to disk. The sync may optionally be performed asynchronously.
     pub fn flush(&mut self, f_async: bool) -> Result<()> {

data/ext/fast_mmaped_file_rs/src/mmap.rs

@@ -3,7 +3,8 @@ use magnus::prelude::*;
 use magnus::rb_sys::{AsRawValue, FromRawValue};
 use magnus::typed_data::Obj;
 use magnus::value::Fixnum;
-use magnus::{block::Proc, eval, scan_args, Error, Integer, RArray, RClass, RHash, RString, Value};
+use magnus::{eval, scan_args, Error, Integer, RArray, RClass, RHash, RString, Value};
+use nix::libc::{c_char, c_long, c_ulong};
 use rb_sys::rb_str_new_static;
 use std::fs::File;
 use std::io::{prelude::*, SeekFrom};
@@ -24,6 +25,11 @@ use inner::InnerMmap;
 
 mod inner;
 
+/// The Ruby `STR_NOEMBED` flag, aka `FL_USER1`.
+const STR_NOEMBED: c_ulong = 1 << (13);
+/// The Ruby `STR_SHARED` flag, aka `FL_USER2`.
+const STR_SHARED: c_ulong = 1 << (14);
+
 /// A Rust struct wrapped in a Ruby object, providing access to a memory-mapped
 /// file used to store, update, and read out Prometheus metrics.
 ///
@@ -150,13 +156,28 @@ impl MmapedFile {
     ///
     /// return a substring of <em>lenght</em> characters from <em>start</em>
     pub fn slice(rb_self: Obj<Self>, args: &[Value]) -> magnus::error::Result<RString> {
-        // The C implemenation would trigger a GC cycle via `rb_gc_force_recycle`
+        // The C implementation would trigger a GC cycle via `rb_gc_force_recycle`
         // if the `MM_PROTECT` flag is set, but in practice this is never used.
         // We omit this logic, particularly because `rb_gc_force_recycle` is a
         // no-op as of Ruby 3.1.
+        let rs_self = &*rb_self;
+
+        let str = rs_self.str(rb_self)?;
+        rs_self._slice(rb_self, str, args)
+    }
 
-        let str = (*rb_self).str(rb_self)?;
-        let res = str.funcall("[]", args);
+    fn _slice(
+        &self,
+        rb_self: Obj<Self>,
+        str: RString,
+        args: &[Value],
+    ) -> magnus::error::Result<RString> {
+        let substr: RString = str.funcall("[]", args)?;
+
+        // Track shared child strings which use the same backing storage.
+        if Self::rb_string_is_shared(substr) {
+            (*rb_self).track_rstring(rb_self, substr)?;
+        }
 
         // The C implementation does this, perhaps to validate that the len we
         // provided is actually being used.
@@ -165,7 +186,7 @@ impl MmapedFile {
             Ok(())
         })?;
 
-        res
+        Ok(substr)
     }
 
     /// Document-method: msync
@@ -222,7 +243,8 @@ impl MmapedFile {
         })?;
 
         // Update each String object to be zero-length.
-        rs_self.update_weak_map(rb_self)?;
+        let cap = util::cast_chk::<_, c_long>(rs_self.capacity(), "capacity")?;
+        rs_self.update_weak_map(rb_self, rs_self.as_mut_ptr(), cap)?;
 
         // Remove the `InnerMmap` from the `RwLock`. This will drop
         // end of this function, unmapping and closing the file.
@@ -336,44 +358,44 @@ impl MmapedFile {
 
             // SAFETY: This is safe so long as the data provided to Ruby meets its
             // requirements. When unmapping the file this will no longer be the
-            // case, see the comment on `munmap` how we handle this.
+            // case, see the comment on `munmap` for how we handle this.
             Ok(unsafe { rb_str_new_static(ptr as _, len as _) })
         })?;
 
+        // SAFETY: We know that rb_str_new_static returns a VALUE.
         let val = unsafe { Value::from_raw(val_id) };
 
         // UNWRAP: We created this value as a string above.
         let str = RString::from_value(val).unwrap();
 
-        let tracker: Value = rb_self.ivar_get("@weak_obj_tracker")?;
+        // Freeze the root string so it can't be mutated out from under any
+        // substrings created. This object is never exposed to callers.
+        str.freeze();
 
-        // Use the string's Id as the key in the `WeakMap`.
-        let key = str.as_raw();
-        let _: Value = tracker.funcall("[]=", (key, str))?;
+        // Track the RString in our `WeakMap` so we can update its address if
+        // we re-mmap the backing file.
+        (*rb_self).track_rstring(rb_self, str)?;
 
         Ok(str)
     }
 
     /// If we reallocate, any live Ruby strings provided by the `str()` method
-    /// will be will be invalidated. We need to iterate over them using and
-    /// update their heap pointers to the newly allocated memory region.
-    fn update_weak_map(&self, rb_self: Obj<Self>) -> magnus::error::Result<()> {
+    /// will be invalidated. We need to iterate over them using and update their
+    /// heap pointers to the newly allocated memory region.
+    fn update_weak_map(
+        &self,
+        rb_self: Obj<Self>,
+        old_ptr: *const c_char,
+        old_cap: c_long,
+    ) -> magnus::error::Result<()> {
         let tracker: Value = rb_self.ivar_get("@weak_obj_tracker")?;
 
-        let (new_ptr, new_len) = (*rb_self).inner(|inner| {
-            // Pointers are not `Send`, convert it to usize to allow capture in closure.
-            let new_ptr = inner.as_ptr() as usize;
-            let new_len = util::cast_chk::<_, i64>(inner.len(), "mmap len")?;
+        let new_len = self.inner(|inner| util::cast_chk::<_, c_long>(inner.len(), "mmap len"))?;
 
-            Ok((new_ptr, new_len))
-        })?;
-
-        // Allocate a block with a closure that updates the string details.
-        let block = Proc::from_fn(move |args, _block| {
-            let val = args
-                .get(0)
-                .ok_or_else(|| err!(arg_error(), "no argument received from `each_value`"))?;
-            let str = RString::from_value(*val)
+        // Iterate over the values of the `WeakMap`.
+        for val in tracker.enumeratorize("each_value", ()) {
+            let rb_string = val?;
+            let str = RString::from_value(rb_string)
                 .ok_or_else(|| err!(arg_error(), "weakmap value was not a string"))?;
 
             // SAFETY: We're messing with Ruby's internals here, YOLO.
@@ -382,18 +404,42 @@ impl MmapedFile {
                 // which provides access to its internals.
                 let mut raw_str = Self::rb_string_internal(str);
 
+                // Shared string have their own `ptr` and `len` values, but `aux`
+                // is the id of the parent string so the GC can track this
+                // dependency. The `ptr` will always be an offset from the base
+                // address of the mmap, and `len` will be the length of the mmap
+                // less the offset from the base.
+                if Self::rb_string_is_shared(str) && new_len > 0 {
+                    // Calculate how far into the original mmap the shared string
+                    // started and update to the equivalent address in the new
+                    // one.
+                    let substr_ptr = raw_str.as_ref().as_.heap.ptr;
+                    let offset = substr_ptr.offset_from(old_ptr);
+
+                    raw_str.as_mut().as_.heap.ptr = self.as_mut_ptr().offset(offset);
+
+                    let current_len = raw_str.as_ref().as_.heap.len;
+                    let new_shared_len = old_cap + current_len;
+
+                    raw_str.as_mut().as_.heap.len = new_shared_len;
+                    continue;
+                }
+
                 // Update the string to point to the new mmapped file.
                 // We're matching the behavior of Ruby's `str_new_static` function.
                 // See https://github.com/ruby/ruby/blob/e51014f9c05aa65cbf203442d37fef7c12390015/string.c#L1030-L1053
-                raw_str.as_mut().as_.heap.ptr = new_ptr as _;
+                //
+                // We deliberately do _NOT_ increment the `capa` field of the
+                // string to match the new `len`. We were initially doing this,
+                // but consistently triggered GCs in the middle of updating the
+                // string pointers, causing a segfault.
+                //
+                // See https://gitlab.com/gitlab-org/ruby/gems/prometheus-client-mmap/-/issues/45
+                raw_str.as_mut().as_.heap.ptr = self.as_mut_ptr();
                 raw_str.as_mut().as_.heap.len = new_len;
-                raw_str.as_mut().as_.heap.aux.capa = new_len;
             }
-            Ok(())
-        });
+        }
 
-        // Execute the block.
-        let _: Value = tracker.funcall_with_block("each_value", (), block)?;
         Ok(())
     }
 
@@ -406,8 +452,7 @@ impl MmapedFile {
 
         // We need the mmapped region to contain at least one byte beyond the
         // written data to create a NUL- terminated C string. Validate that
-        // new length does not exactly match the length of the mmap or exceed
-        // it.
+        // new length does not exactly match or exceed the length of the mmap.
         while self.capacity() <= used.add_chk(entry_len)? {
             self.expand_to_fit(rb_self, self.capacity().mul_chk(2)?)?;
         }
@@ -429,6 +474,9 @@ impl MmapedFile {
         }
 
         if new_cap != self.capacity() {
+            let old_ptr = self.as_mut_ptr();
+            let old_cap = util::cast_chk::<_, c_long>(self.capacity(), "capacity")?;
+
             // Drop the old mmap.
             let (mut file, path) = self.take_inner()?.munmap();
 
@@ -439,7 +487,7 @@ impl MmapedFile {
 
             self.insert_inner(new_inner)?;
 
-            return self.update_weak_map(rb_self);
+            return self.update_weak_map(rb_self, old_ptr, old_cap);
         }
 
         Ok(())
@@ -476,6 +524,15 @@ impl MmapedFile {
         Ok(())
     }
 
+    fn track_rstring(&self, rb_self: Obj<Self>, str: RString) -> magnus::error::Result<()> {
+        let tracker: Value = rb_self.ivar_get("@weak_obj_tracker")?;
+
+        // Use the string's Id as the key in the `WeakMap`.
+        let key = str.as_raw();
+        let _: Value = tracker.funcall("[]=", (key, str))?;
+        Ok(())
+    }
+
     /// The total capacity of the underlying mmap.
     #[inline]
     fn capacity(&self) -> usize {
@@ -489,6 +546,13 @@ impl MmapedFile {
             .map_err(|e| e.into())
     }
 
+    fn as_mut_ptr(&self) -> *mut c_char {
+        // UNWRAP: This is actually infallible, but we need to
+        // wrap it in a `Result` for use with `inner()`.
+        self.inner(|inner| Ok(inner.as_mut_ptr() as *mut c_char))
+            .unwrap()
+    }
+
     /// Takes a closure with immutable access to InnerMmap. Will fail if the inner
     /// object has a mutable borrow or has been dropped.
     fn inner<F, T>(&self, func: F) -> Result<T>
@@ -544,9 +608,27 @@ impl MmapedFile {
         Ok(())
     }
 
+    /// Check if an RString is shared. Shared string use the same underlying
+    /// storage as their parent, taking an offset from the start. By default
+    /// they must run to the end of the parent string.
+    fn rb_string_is_shared(rb_str: RString) -> bool {
+        // SAFETY: We only hold a reference to the raw object for the duration
+        // of this function, and no Ruby code is called.
+        let flags = unsafe {
+            let raw_str = Self::rb_string_internal(rb_str);
+            raw_str.as_ref().basic.flags
+        };
+        let shared_flags = STR_SHARED | STR_NOEMBED;
+
+        flags & shared_flags == shared_flags
+    }
+
     /// Convert `magnus::RString` into the raw binding used by `rb_sys::RString`.
     /// We need this to manually change the pointer and length values for strings
     /// when moving the mmap to a new file.
+    ///
+    /// SAFETY: Calling Ruby code while the returned object is held may result
+    /// in it being mutated or dropped.
     unsafe fn rb_string_internal(rb_str: RString) -> NonNull<rb_sys::RString> {
         mem::transmute::<RString, NonNull<rb_sys::RString>>(rb_str)
     }
@@ -666,18 +748,101 @@ mod test {
         let ruby = magnus::Ruby::get().unwrap();
         crate::init(&ruby).unwrap();
 
+        fn assert_internals(
+            obj: Obj<MmapedFile>,
+            parent_id: c_ulong,
+            child_id: c_ulong,
+            unshared_id: c_ulong,
+        ) {
+            let rs_self = &*obj;
+            let tracker: Value = obj.ivar_get("@weak_obj_tracker").unwrap();
+
+            let mmap_ptr = rs_self.as_mut_ptr();
+            let mmap_len = rs_self.capacity();
+
+            let mut parent_checked = false;
+            let mut child_checked = false;
+
+            for val in tracker.enumeratorize("each_value", ()) {
+                let rb_string = val.unwrap();
+                let str = RString::from_value(rb_string).unwrap();
+
+                unsafe {
+                    let raw_str = MmapedFile::rb_string_internal(str);
+                    if str.as_raw() == child_id {
+                        assert_eq!(parent_id, raw_str.as_ref().as_.heap.aux.shared);
+
+                        let child_offset =
+                            mmap_len as isize - raw_str.as_ref().as_.heap.len as isize;
+                        assert_eq!(mmap_ptr.offset(child_offset), raw_str.as_ref().as_.heap.ptr);
+
+                        child_checked = true;
+                    } else if str.as_raw() == parent_id {
+                        assert_eq!(parent_id, str.as_raw());
+
+                        assert_eq!(mmap_ptr, raw_str.as_ref().as_.heap.ptr);
+                        assert_eq!(mmap_len as c_long, raw_str.as_ref().as_.heap.len);
+                        assert!(raw_str.as_ref().basic.flags & (STR_SHARED | STR_NOEMBED) > 0);
+                        assert!(str.is_frozen());
+
+                        parent_checked = true;
+                    } else if str.as_raw() == unshared_id {
+                        panic!("tracking unshared string");
+                    } else {
+                        panic!("unknown string");
+                    }
+                }
+            }
+            assert!(parent_checked && child_checked);
+        }
+
         let obj = create_obj();
         let _ = populate_entries(&obj);
 
         let rs_self = &*obj;
 
-        let value_range = Range::new(HEADER_SIZE, 24, false).unwrap().as_value();
-        let value_slice = MmapedFile::slice(obj, &[value_range]).unwrap();
-
-        rs_self.expand_to_fit(obj, rs_self.capacity() * 2).unwrap();
+        // Create a string containing the full mmap.
+        let parent_str = rs_self.str(obj).unwrap();
+        let parent_id = parent_str.as_raw();
+
+        // Ruby's shared strings are only created when they go to the end of
+        // original string.
+        let len = rs_self.inner(|inner| Ok(inner.len())).unwrap();
+        let shareable_range = Range::new(1, len - 1, false).unwrap().as_value();
+
+        // This string should re-use the parent's buffer with an offset and have
+        // the parent's id in `as.heap.aux.shared`
+        let child_str = rs_self._slice(obj, parent_str, &[shareable_range]).unwrap();
+        let child_id = child_str.as_raw();
+
+        // A range that does not reach the end of the parent will not be shared.
+        assert!(len > 4);
+        let unshareable_range = Range::new(0, 4, false).unwrap().as_value();
+
+        // This string should NOT be tracked, it should own its own buffer.
+        let unshared_str = rs_self
+            ._slice(obj, parent_str, &[unshareable_range])
+            .unwrap();
+        let unshared_id = unshared_str.as_raw();
+        assert!(!MmapedFile::rb_string_is_shared(unshared_str));
+
+        assert_internals(obj, parent_id, child_id, unshared_id);
+
+        let orig_ptr = rs_self.as_mut_ptr();
+        // Expand a bunch to ensure we remap
+        for _ in 0..16 {
+            rs_self.expand_to_fit(obj, rs_self.capacity() * 2).unwrap();
+        }
+        let new_ptr = rs_self.as_mut_ptr();
+        assert!(orig_ptr != new_ptr);
 
         // If we haven't updated the pointer to the newly remapped file this will segfault.
-        let _: Value = eval!("puts str", str = value_slice).unwrap();
+        let _: Value = eval!("puts parent", parent = parent_str).unwrap();
+        let _: Value = eval!("puts child", child = child_str).unwrap();
+        let _: Value = eval!("puts unshared", unshared = unshared_str).unwrap();
+
+        // Confirm that tracked strings are still valid.
+        assert_internals(obj, parent_id, child_id, unshared_id);
     }
 
     #[test]

data/ext/fast_mmaped_file_rs/src/parser.rs

@@ -2,7 +2,7 @@ use smallvec::SmallVec;
 use std::str;
 
 /// String slices pointing to the fields of a borrowed `Entry`'s JSON data.
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Eq, Debug)]
 pub struct MetricText<'a> {
     pub family_name: &'a str,
     pub metric_name: &'a str,
@@ -10,14 +10,14 @@ pub struct MetricText<'a> {
     pub values: SmallVec<[&'a str; 4]>,
 }
 
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Eq, Debug)]
 struct MetricNames<'a> {
     label_json: &'a str,
     family_name: &'a str,
     metric_name: &'a str,
 }
 
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Eq, Debug)]
 struct MetricLabelVals<'a> {
     labels: SmallVec<[&'a str; 4]>,
     values: SmallVec<[&'a str; 4]>,

data/ext/fast_mmaped_file_rs/src/raw_entry.rs

@@ -6,7 +6,7 @@ use crate::util::CheckedOps;
 use crate::Result;
 
 /// The logic to save a `MetricsEntry`, or parse one from a byte slice.
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq, Eq, Clone, Debug)]
 pub struct RawEntry<'a> {
     bytes: &'a [u8],
     encoded_len: usize,

data/ext/fast_mmaped_file_rs/src/testhelper.rs

@@ -73,7 +73,7 @@ pub fn entries_to_db(entries: &[&'static str], values: &[f64], header: Option<u3
     };
 
     out.extend(used.to_ne_bytes());
-    out.extend(&[0x0u8; 4]); // Padding.
+    out.extend([0x0u8; 4]); // Padding.
     out.extend(entry_bytes);
 
     out

data/lib/prometheus/client/configuration.rb

@@ -7,13 +7,14 @@ require 'tmpdir'
 module Prometheus
   module Client
     class Configuration
-      attr_accessor :value_class, :multiprocess_files_dir, :initial_mmap_file_size, :logger, :pid_provider
+      attr_accessor :value_class, :multiprocess_files_dir, :initial_mmap_file_size, :logger, :pid_provider, :rust_multiprocess_metrics
 
       def initialize
         @value_class = ::Prometheus::Client::MmapedValue
         @initial_mmap_file_size = ::Prometheus::Client::PageSize.page_size(fallback_page_size: 4096)
         @logger = Logger.new($stdout)
         @pid_provider = Process.method(:pid)
+        @rust_multiprocess_metrics = ENV.fetch('prometheus_rust_multiprocess_metrics', nil) == 'true'
         @multiprocess_files_dir = ENV.fetch('prometheus_multiproc_dir') do
           Dir.mktmpdir("prometheus-mmap")
         end

data/lib/prometheus/client/formats/text.rb

@@ -1,5 +1,6 @@
 require 'prometheus/client/uses_value_type'
 require 'prometheus/client/helper/json_parser'
+require 'prometheus/client/helper/loader'
 require 'prometheus/client/helper/plain_file'
 require 'prometheus/client/helper/metrics_processing'
 require 'prometheus/client/helper/metrics_representation'
@@ -31,7 +32,7 @@ module Prometheus
               .map {|f| Helper::PlainFile.new(f) }
               .map {|f| [f.filepath, f.multiprocess_mode.to_sym, f.type.to_sym, f.pid] }
 
-            if use_rust && rust_impl_available?
+            if use_rust && Prometheus::Client::Helper::Loader.rust_impl_available?
               FastMmapedFileRs.to_metrics(file_list.to_a)
             else
               FastMmapedFile.to_metrics(file_list.to_a)
@@ -46,29 +47,6 @@ module Prometheus
 
           private
 
-          def load_rust_extension
-            begin
-              ruby_version = /(\d+\.\d+)/.match(RUBY_VERSION)
-              require_relative "../../../#{ruby_version}/fast_mmaped_file_rs"
-            rescue LoadError
-              require 'fast_mmaped_file_rs'
-            end
-          end
-
-          def check_for_rust
-            # This will be evaluated on each invocation even with `||=` if
-            # `@rust_available` if false. Running a `require` statement is slow,
-            # so the `rust_impl_available?` method memoizes the result, external
-            # callers can only trigger this method a single time.
-            @rust_available = begin
-              load_rust_extension
-              true
-            rescue LoadError
-              Prometheus::Client.logger.info('FastMmapedFileRs unavailable')
-              false
-            end
-          end
-
           def load_metrics(path)
             metrics = {}
             Dir.glob(File.join(path, '*.db')).sort.each do |f|

data/lib/prometheus/client/helper/loader.rb

@@ -0,0 +1,40 @@
+module Prometheus
+  module Client
+    module Helper
+      module Loader
+        class << self
+          def rust_impl_available?
+            return @rust_available unless @rust_available.nil?
+
+            check_for_rust
+          end
+
+          private
+
+          def load_rust_extension
+            begin
+              ruby_version = /(\d+\.\d+)/.match(RUBY_VERSION)
+              require_relative "../../../#{ruby_version}/fast_mmaped_file_rs"
+            rescue LoadError
+              require 'fast_mmaped_file_rs'
+            end
+          end
+
+          def check_for_rust
+            # This will be evaluated on each invocation even with `||=` if
+            # `@rust_available` if false. Running a `require` statement is slow,
+            # so the `rust_impl_available?` method memoizes the result, external
+            # callers can only trigger this method a single time.
+            @rust_available = begin
+              load_rust_extension
+              true
+            rescue LoadError
+              Prometheus::Client.logger.info('FastMmapedFileRs unavailable')
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prometheus/client/helper/mmaped_file.rb

@@ -1,5 +1,6 @@
 require 'prometheus/client/helper/entry_parser'
 require 'prometheus/client/helper/file_locker'
+require 'prometheus/client/helper/loader'
 
 # load precompiled extension if available
 begin
@@ -12,7 +13,17 @@ end
 module Prometheus
   module Client
     module Helper
-      class MmapedFile < FastMmapedFile
+      # We can't check `Prometheus::Client.configuration` as this creates a circular dependency
+      if (ENV.fetch('prometheus_rust_mmaped_file', nil) == "true" &&
+          Prometheus::Client::Helper::Loader.rust_impl_available?)
+        class MmapedFile < FastMmapedFileRs
+        end
+      else
+        class MmapedFile < FastMmapedFile
+        end
+      end
+
+      class MmapedFile
         include EntryParser
 
         attr_reader :filepath, :size

data/lib/prometheus/client/rack/exporter.rb

@@ -62,8 +62,10 @@ module Prometheus
         end
 
         def respond_with(format)
+          rust_enabled = Prometheus::Client.configuration.rust_multiprocess_metrics
+
           response = if Prometheus::Client.configuration.value_class.multiprocess
-                       format.marshal_multiprocess
+                       format.marshal_multiprocess(use_rust: rust_enabled)
                      else
                        format.marshal
                      end

data/lib/prometheus/client/version.rb

@@ -1,5 +1,5 @@
 module Prometheus
   module Client
-    VERSION = '0.23.0'.freeze
+    VERSION = '0.24.3'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prometheus-client-mmap
 version: !ruby/object:Gem::Version
-  version: 0.23.0
+  version: 0.24.3
 platform: x86_64-linux
 authors:
 - Tobias Schmidt
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-01 00:00:00.000000000 Z
+date: 2023-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -127,6 +127,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".tool-versions"
 - README.md
 - ext/fast_mmaped_file/extconf.rb
 - ext/fast_mmaped_file/fast_mmaped_file.c
@@ -179,6 +180,7 @@ files:
 - lib/prometheus/client/helper/entry_parser.rb
 - lib/prometheus/client/helper/file_locker.rb
 - lib/prometheus/client/helper/json_parser.rb
+- lib/prometheus/client/helper/loader.rb
 - lib/prometheus/client/helper/metrics_processing.rb
 - lib/prometheus/client/helper/metrics_representation.rb
 - lib/prometheus/client/helper/mmaped_file.rb