prometheus-client-mmap 0.24.4-x86_64-darwin → 0.25.0-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11eecc761b0bd7cbcc8137e7097cb81595b0bbbe5b01058b1a601f01fd0405e9
-  data.tar.gz: c9d175042f2a64f0735d5a4b973506c56690a555e20bb115062c207e4389ba01
+  metadata.gz: 74773c45b9ddb83dfa6b24c8ebbc0cef9b5c42e25130739abe1a9c5e31303606
+  data.tar.gz: c0ecad5a2f9cc1208929857d044fdf15e5dfe4b7ead267098ce294beb96f9fa3
 SHA512:
-  metadata.gz: 3f5428ee9d38050a212df5d313c73ac4734ee6d0d174608ee5b72cd1d8ba586db82b41d30f356373b33a350ce9fa291d515b4e965dde309b83ca449dcd0d0b6b
-  data.tar.gz: e67748cf4f5d979b25068bf1d86fc828419301fc09425c40f54cb24aa0247dcf69aa9a295daca22b8458cd04597182603a62ae1b02e9195a88350c33c2efc885
+  metadata.gz: 9c24415dcfceadf7b6c569afd67ec520a965ed220cc8e5a1e5d884cf8e23d948fccaaf57fd2fb74a20a294179a0d76ff15059a0b72d270aa351d08b7aadbe91b
+  data.tar.gz: b972c38fad8aacc72692a4a12292955d1be095510c701f4ccfc1121aeeb57a8a20102cf004230b53ce237068cba0a89bff5cd63845ea36d498061f22c0675dad

data/ext/fast_mmaped_file/mmap.c

@@ -3,6 +3,7 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <ruby/util.h>
+#include <ruby/version.h>
 #include <sys/mman.h>
 
 #include "file_format.h"
@@ -27,6 +28,16 @@
  */
 static VALUE weak_obj_tracker_get_key(VALUE val) { return val; }
 
+static void update_rstring_len(VALUE val, size_t len) {
+#if defined(RUBY_API_VERSION_MAJOR) && defined(RUBY_API_VERSION_MINOR) && (RUBY_API_VERSION_MAJOR == 3) && \
+    (RUBY_API_VERSION_MINOR >= 3)
+
+    RSTRING(val)->len = len;
+#else
+    RSTRING(val)->as.heap.len = len;
+#endif
+}
+
 /**
  * Adds a T_STRING type to the WeakMap. The WeakMap should be stored
  * as an instance variable.
@@ -52,7 +63,7 @@ VALUE mm_update_obj_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, self)) {
     GET_MMAP(self, i_mm, MM_MODIFY);
 
     RSTRING(i)->as.heap.ptr = i_mm->t->addr;
-    RSTRING(i)->as.heap.len = i_mm->t->real;
+    update_rstring_len(i, i_mm->t->real);
 
     return Qtrue;
 }
@@ -98,7 +109,7 @@ static VALUE mm_str(VALUE obj, int modify) {
     ret = rb_obj_alloc(rb_cString);
     RSTRING(ret)->as.heap.ptr = i_mm->t->addr;
     RSTRING(ret)->as.heap.aux.capa = i_mm->t->len;
-    RSTRING(ret)->as.heap.len = i_mm->t->real;
+    update_rstring_len(ret, i_mm->t->real);
 
     weak_obj_tracker_add(obj, ret);
 

data/ext/fast_mmaped_file_rs/Cargo.lock

@@ -30,9 +30,9 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "bindgen"
-version = "0.60.1"
+version = "0.62.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "062dddbc1ba4aca46de6338e2bf87771414c335f7b2f2036e8f3e9befebf88e6"
+checksum = "c6720a8b7b2d39dd533285ed438d458f65b31b5c257e6ac7bb3d7e82844dd722"
 dependencies = [
  "bitflags",
  "cexpr",
@@ -45,6 +45,7 @@ dependencies = [
  "regex",
  "rustc-hash",
  "shlex",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -169,6 +170,9 @@ dependencies = [
  "nix",
  "rand",
  "rb-sys",
+ "rb-sys-env",
+ "serde",
+ "serde_json",
  "sha2",
  "smallvec",
  "tempfile",
@@ -252,6 +256,12 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -289,7 +299,7 @@ checksum = "d59d8c75012853d2e872fb56bc8a2e53718e2cafe1a4c823143141c6d90c322f"
 [[package]]
 name = "magnus"
 version = "0.5.0"
-source = "git+https://github.com/matsadler/magnus?branch=main#b10aab48119eb87a872bf0bb4480b1fcebe5d1b9"
+source = "git+https://github.com/matsadler/magnus?branch=main#50cab2380103c39c14765a10bdc4b38a74082285"
 dependencies = [
  "magnus-macros",
  "rb-sys",
@@ -300,7 +310,7 @@ dependencies = [
 [[package]]
 name = "magnus-macros"
 version = "0.4.0"
-source = "git+https://github.com/matsadler/magnus?branch=main#b10aab48119eb87a872bf0bb4480b1fcebe5d1b9"
+source = "git+https://github.com/matsadler/magnus?branch=main#50cab2380103c39c14765a10bdc4b38a74082285"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -435,18 +445,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.71"
+version = "0.9.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "156bfedced1e236600bcaad538477097ff2ed5c6b474e411d15b791e1d24c0f1"
+checksum = "939fb78db3e4f26665c1d4c7b91ca66d3578335a19aba552d4a6445811d07072"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.71"
+version = "0.9.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cb2e4a32cbc290b543a74567072ad24b708aff7bb5dde5a68d5690379cd7938"
+checksum = "335a95eb0420d52fa94ef12019df3c2c250c6b19cbb3c60bd05cb7e9c362072c"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -515,6 +525,12 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
 [[package]]
 name = "seq-macro"
 version = "0.3.3"
@@ -526,6 +542,31 @@ name = "serde"
 version = "1.0.159"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c04e8343c3daeec41f58990b9d77068df31209f2af111e059e9fe9646693065"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.159"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c614d17805b093df4b147b51339e7e44bf05ef59fba1e45d83500bcfb4d8585"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.13",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.96"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "057d394a50403bcac12672b2b18fb387ab6d289d957dab67dd201875391e52f1"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
 
 [[package]]
 name = "sha2"
@@ -555,6 +596,9 @@ name = "smallvec"
 version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "syn"

data/ext/fast_mmaped_file_rs/Cargo.toml

@@ -13,7 +13,9 @@ memmap2 = "0.5"
 # v0.26 cannot be built on CentOS 7 https://github.com/nix-rust/nix/issues/1972
 nix = { version = "0.25", features = ["mman"] } # mman used for MsFlags
 rb-sys = "0.9"
-smallvec = "1.10"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0", features = ["raw_value"] }
+smallvec = { version = "1.10", features = ["serde"] }
 thiserror = "1.0"
 
 [dev-dependencies]
@@ -25,6 +27,9 @@ rand = "0.8"
 sha2 = "0.10"
 tempfile = "3.5"
 
+[build-dependencies]
+rb-sys-env = "0.1"
+
 [lib]
 # Integration tests won't work if crate is only `cdylib`.
 crate-type = ["cdylib","lib"]

data/ext/fast_mmaped_file_rs/build.rs

@@ -0,0 +1,5 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let _ = rb_sys_env::activate()?;
+
+    Ok(())
+}

data/ext/fast_mmaped_file_rs/src/file_entry.rs

@@ -1,10 +1,12 @@
 use magnus::Symbol;
+use serde::Deserialize;
+use serde_json::value::RawValue;
+use smallvec::SmallVec;
 use std::fmt::Write;
 use std::str;
 
 use crate::error::{MmapError, RubyError};
 use crate::file_info::FileInfo;
-use crate::parser::{self, MetricText};
 use crate::raw_entry::RawEntry;
 use crate::Result;
 use crate::{SYM_GAUGE, SYM_LIVESUM, SYM_MAX, SYM_MIN};
@@ -16,6 +18,16 @@ pub struct FileEntry {
     pub meta: EntryMetadata,
 }
 
+/// String slices pointing to the fields of a borrowed `Entry`'s JSON data.
+#[derive(Deserialize, Debug)]
+pub struct MetricText<'a> {
+    pub family_name: &'a str,
+    pub metric_name: &'a str,
+    pub labels: SmallVec<[&'a str; 4]>,
+    #[serde(borrow)]
+    pub values: SmallVec<[&'a RawValue; 4]>,
+}
+
 /// The primary data payload for a `FileEntry`, the JSON string and the
 /// associated pid, if significant. Used as the key for `EntryMap`.
 #[derive(Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Debug)]
@@ -134,11 +146,16 @@ impl FileEntry {
         let mut processed_count = 0;
 
         for entry in entries {
-            let metrics_data = match parser::parse_metrics(&entry.data.json) {
-                Some(m) => m,
+            let metrics_data = match serde_json::from_str::<MetricText>(&entry.data.json) {
+                Ok(m) => {
+                    if m.labels.len() != m.values.len() {
+                        continue;
+                    }
+                    m
+                }
                 // We don't exit the function here so the total number of invalid
                 // entries can be calculated below.
-                None => continue,
+                Err(_) => continue,
             };
 
             match prev_name.as_ref() {
@@ -197,16 +214,20 @@ impl FileEntry {
 
         let it = json_data.labels.iter().zip(json_data.values.iter());
 
-        for (i, (&key, &val)) in it.enumerate() {
+        for (i, (&key, val)) in it.enumerate() {
             out.push_str(key);
-
-            out.push_str("=\"");
-
-            // `null` values will be output as `""`.
-            if val != "null" {
-                out.push_str(val);
+            out.push('=');
+
+            match val.get() {
+                "null" => out.push_str("\"\""),
+                s if s.starts_with('"') => out.push_str(s),
+                s => {
+                    // Quote numeric values.
+                    out.push('"');
+                    out.push_str(s);
+                    out.push('"');
+                }
             }
-            out.push('"');
 
             if i < json_data.labels.len() - 1 {
                 out.push(',');
@@ -276,6 +297,20 @@ mod test {
                     "##}),
                 expected_err: None,
             },
+            TestCase {
+                name: "many labels",
+                multiprocess_mode: "min",
+                json: &[
+                    r#"["family","name",["label_a","label_b","label_c","label_d","label_e"],["value_a","value_b","value_c","value_d","value_e"]]"#,
+                ],
+                values: &[1.0],
+                pids: &["worker-1"],
+                expected_out: Some(indoc! {r##"# HELP family Multiprocess metric
+                    # TYPE family gauge
+                    name{label_a="value_a",label_b="value_b",label_c="value_c",label_d="value_d",label_e="value_e"} 1
+                    "##}),
+                expected_err: None,
+            },
             TestCase {
                 name: "floating point shown",
                 multiprocess_mode: "min",
@@ -288,6 +323,44 @@ mod test {
                     "##}),
                 expected_err: None,
             },
+            TestCase {
+                name: "numeric value",
+                multiprocess_mode: "min",
+                json: &[
+                    r#"["family","name",["label_a","label_b","label_c"],["value_a",403,-0.2E5]]"#,
+                ],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: Some(indoc! {r##"# HELP family Multiprocess metric
+                    # TYPE family gauge
+                    name{label_a="value_a",label_b="403",label_c="-0.2E5"} 1.5
+                    "##}),
+                expected_err: None,
+            },
+            TestCase {
+                name: "null value",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",["label_a","label_b"],["value_a",null]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: Some(indoc! {r##"# HELP family Multiprocess metric
+                    # TYPE family gauge
+                    name{label_a="value_a",label_b=""} 1.5
+                    "##}),
+                expected_err: None,
+            },
+            TestCase {
+                name: "comma in value",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",["label_a","label_b"],["value_a","value,_b"]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: Some(indoc! {r##"# HELP family Multiprocess metric
+                    # TYPE family gauge
+                    name{label_a="value_a",label_b="value,_b"} 1.5
+                    "##}),
+                expected_err: None,
+            },
             TestCase {
                 name: "no labels, pid significant",
                 multiprocess_mode: "all",
@@ -413,6 +486,138 @@ mod test {
                     RubyError::Runtime,
                 )),
             },
+            TestCase {
+                name: "too many values",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",["label_a"],["value_a","value,_b"]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
+            TestCase {
+                name: "no values",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",["label_a"]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
+            TestCase {
+                name: "no labels or values",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name","foo"]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
+            TestCase {
+                name: "too many leading brackets",
+                multiprocess_mode: "min",
+                json: &[r#"[["family","name",["label_a","label_b"],["value_a","value_b"]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
+            TestCase {
+                name: "too many trailing brackets",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",["label_a","label_b"],["value_a","value_b"]]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
+            TestCase {
+                name: "too many leading label brackets",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",[["label_a","label_b"],["value_a","value_b"]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
+            TestCase {
+                name: "too many leading label brackets",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",[["label_a","label_b"],["value_a","value_b"]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
+            TestCase {
+                name: "too many leading value brackets",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",["label_a","label_b"],[["value_a","value_b"]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
+            TestCase {
+                name: "misplaced bracket",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",["label_a","label_b"],]["value_a","value_b"]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
+            TestCase {
+                name: "comma in numeric",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",["label_a","label_b"],["value_a",403,0]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
+            TestCase {
+                name: "non-e letter in numeric",
+                multiprocess_mode: "min",
+                json: &[r#"["family","name",["label_a","label_b"],["value_a",-2.0c5]]"#],
+                values: &[1.5],
+                pids: &["worker-1"],
+                expected_out: None,
+                expected_err: Some(MmapError::legacy(
+                    "Processed entries 0 != map entries 1".to_owned(),
+                    RubyError::Runtime,
+                )),
+            },
         ];
 
         for case in tc {

data/ext/fast_mmaped_file_rs/src/lib.rs

@@ -12,7 +12,6 @@ pub mod file_info;
 mod macros;
 pub mod map;
 pub mod mmap;
-pub mod parser;
 pub mod raw_entry;
 pub mod util;
 

data/ext/fast_mmaped_file_rs/src/mmap.rs

@@ -418,10 +418,10 @@ impl MmapedFile {
 
                     raw_str.as_mut().as_.heap.ptr = self.as_mut_ptr().offset(offset);
 
-                    let current_len = raw_str.as_ref().as_.heap.len;
+                    let current_len = str.len() as c_long;
                     let new_shared_len = old_cap + current_len;
 
-                    raw_str.as_mut().as_.heap.len = new_shared_len;
+                    self.update_rstring_len(raw_str, new_shared_len);
                     continue;
                 }
 
@@ -436,7 +436,7 @@ impl MmapedFile {
                 //
                 // 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;
+                self.update_rstring_len(raw_str, new_len);
             }
         }
 
@@ -632,6 +632,16 @@ impl MmapedFile {
     unsafe fn rb_string_internal(rb_str: RString) -> NonNull<rb_sys::RString> {
         mem::transmute::<RString, NonNull<rb_sys::RString>>(rb_str)
     }
+
+    #[cfg(ruby_lte_3_2)]
+    unsafe fn update_rstring_len(&self, mut raw_str: NonNull<rb_sys::RString>, new_len: c_long) {
+        raw_str.as_mut().as_.heap.len = new_len;
+    }
+
+    #[cfg(ruby_gte_3_3)]
+    unsafe fn update_rstring_len(&self, mut raw_str: NonNull<rb_sys::RString>, new_len: c_long) {
+        raw_str.as_mut().len = new_len;
+    }
 }
 
 #[cfg(test)]
@@ -772,8 +782,7 @@ mod test {
                     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;
+                        let child_offset = mmap_len as isize - str.len() as isize;
                         assert_eq!(mmap_ptr.offset(child_offset), raw_str.as_ref().as_.heap.ptr);
 
                         child_checked = true;
@@ -781,7 +790,7 @@ mod test {
                         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_eq!(mmap_len as c_long, str.len() as c_long);
                         assert!(raw_str.as_ref().basic.flags & (STR_SHARED | STR_NOEMBED) > 0);
                         assert!(str.is_frozen());
 

data/lib/prometheus/client/version.rb

@@ -1,5 +1,5 @@
 module Prometheus
   module Client
-    VERSION = '0.24.4'.freeze
+    VERSION = '0.25.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prometheus-client-mmap
 version: !ruby/object:Gem::Version
-  version: 0.24.4
+  version: 0.25.0
 platform: x86_64-darwin
 authors:
 - Tobias Schmidt
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-12 00:00:00.000000000 Z
+date: 2023-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -150,6 +150,7 @@ files:
 - ext/fast_mmaped_file_rs/Cargo.lock
 - ext/fast_mmaped_file_rs/Cargo.toml
 - ext/fast_mmaped_file_rs/README.md
+- ext/fast_mmaped_file_rs/build.rs
 - ext/fast_mmaped_file_rs/extconf.rb
 - ext/fast_mmaped_file_rs/src/error.rs
 - ext/fast_mmaped_file_rs/src/file_entry.rs
@@ -159,7 +160,6 @@ files:
 - ext/fast_mmaped_file_rs/src/map.rs
 - ext/fast_mmaped_file_rs/src/mmap.rs
 - ext/fast_mmaped_file_rs/src/mmap/inner.rs
-- ext/fast_mmaped_file_rs/src/parser.rs
 - ext/fast_mmaped_file_rs/src/raw_entry.rs
 - ext/fast_mmaped_file_rs/src/testhelper.rs
 - ext/fast_mmaped_file_rs/src/util.rs

data/ext/fast_mmaped_file_rs/src/parser.rs

@@ -1,448 +0,0 @@
-use smallvec::SmallVec;
-use std::str;
-
-/// String slices pointing to the fields of a borrowed `Entry`'s JSON data.
-#[derive(PartialEq, Eq, Debug)]
-pub struct MetricText<'a> {
-    pub family_name: &'a str,
-    pub metric_name: &'a str,
-    pub labels: SmallVec<[&'a str; 4]>,
-    pub values: SmallVec<[&'a str; 4]>,
-}
-
-#[derive(PartialEq, Eq, Debug)]
-struct MetricNames<'a> {
-    label_json: &'a str,
-    family_name: &'a str,
-    metric_name: &'a str,
-}
-
-#[derive(PartialEq, Eq, Debug)]
-struct MetricLabelVals<'a> {
-    labels: SmallVec<[&'a str; 4]>,
-    values: SmallVec<[&'a str; 4]>,
-}
-
-/// Parse Prometheus metric data stored in the following format:
-///
-/// ["metric","name",["label_a","label_b"],["value_a","value_b"]]
-///
-/// There will be 1-8 trailing spaces to ensure at least a one-byte
-/// gap between the json and value, and to pad to an 8-byte alignment.
-/// We strip the surrounding double quotes from all items. Values may
-/// or may not have surrounding double quotes, depending on their type.
-pub fn parse_metrics(json: &str) -> Option<MetricText> {
-    // It would be preferable to use `serde_json` here, but the values
-    // may be strings, numbers, or null, and so don't parse easily to a
-    // defined struct. Using `serde_json::Value` is an option, but since
-    // we're just copying the literal values into a buffer this will be
-    // inefficient and verbose.
-
-    // Trim trailing spaces from string before processing. We use
-    // `trim_end_matches()` instead of `trim_end()` because we know the
-    // trailing bytes are always ASCII 0x20 bytes. `trim_end()` will also
-    // check for unicode spaces and consume a few more CPU cycles.
-    let trimmed = json.trim_end_matches(' ');
-
-    let names = parse_names(trimmed)?;
-    let label_json = names.label_json;
-
-    let label_vals = parse_label_values(label_json)?;
-
-    Some(MetricText {
-        family_name: names.family_name,
-        metric_name: names.metric_name,
-        labels: label_vals.labels,
-        values: label_vals.values,
-    })
-}
-
-fn parse_names(json: &str) -> Option<MetricNames> {
-    // Starting with: ["family_name","metric_name",[...
-    if !json.starts_with("[\"") {
-        return None;
-    }
-
-    // Captured: "family_name","metric_name",
-    //            ^^^^^^^^^^^
-    let (family_name, remainder) = scan_str(json.get(1..)?)?;
-
-    //  Validate comma separated names
-    // ["family_name","metric_name",[...
-    //               ^
-    if !remainder.starts_with("\",") {
-        return None;
-    }
-
-    // Now: "metric_name",[...
-    let remainder = remainder.get(2..)?;
-
-    // Captured: "family_name","metric_name",
-    //                          ^^^^^^^^^^^
-    let (metric_name, remainder) = scan_str(remainder)?;
-
-    //  Validate comma separated names
-    // ["family_name","metric_name",[...
-    //                            ^^
-    if !remainder.starts_with("\",") {
-        return None;
-    }
-
-    // Save the rest of the slice to parse for labels later.
-    // Now: [...
-    let label_json = remainder.get(2..)?;
-
-    Some(MetricNames {
-        label_json,
-        family_name,
-        metric_name,
-    })
-}
-
-fn parse_label_values(json: &str) -> Option<MetricLabelVals> {
-    // Starting with: ["label_a","label_b"],["value_a", "value_b"]]
-    if !json.starts_with('[') {
-        return None;
-    }
-
-    // Now: "label_a","label_b"],["value_a", "value_b"]]
-    let mut remainder = json.get(1..)?;
-
-    // Validate we either have the start of a label string or an
-    // empty array, e.g. `["` or `[]`.
-    if !matches!(json.as_bytes().get(1)?, b'"' | b']') {
-        return None;
-    }
-
-    let mut labels = SmallVec::new();
-
-    // Split on commas into:
-    // "label_a","label_b"
-    // ^^^one^^^ ^^^two^^^
-    loop {
-        let Some((label, label_rem)) = scan_str(remainder) else {
-            // No further keys.
-            break;
-        };
-        labels.push(label);
-
-        // Advance past trailing quote.
-        remainder = label_rem.get(1..)?;
-        match remainder.as_bytes().first() {
-            Some(b']') => break, // No further labels.
-            Some(b',') => {}     // More labels expected.
-            _ => return None,    // Invalid.
-        };
-
-        // Advance past comma.
-        remainder = remainder.get(1..)?;
-    }
-
-    if !remainder.starts_with("],[") {
-        return None;
-    }
-    // Now: "value_a", "value_b"]]
-    remainder = remainder.get(3..)?;
-
-    // Validate we don't have extra brackets.
-    if remainder.starts_with('[') {
-        return None;
-    }
-
-    let mut values = SmallVec::new();
-    // Split on commas into:
-    // "value_a","value_b"
-    // ^^^one^^^ ^^^two^^^
-    loop {
-        if remainder.starts_with('"') {
-            let (value, value_rem) = scan_str(remainder)?;
-            values.push(value);
-
-            // Advance past trailing quote.
-            remainder = value_rem.get(1..)?;
-        } else {
-            // An unquoted value, such as `true` or `404`.
-            let i = remainder.find(|c| c == ',' || c == ']')?;
-            let value = &remainder[..i];
-
-            match (value.is_empty(), is_valid_json_literal(value)) {
-                (true, _) => {}                      // Empty string, do nothing.
-                (false, true) => values.push(value), // Valid literal.
-                (false, false) => return None,       // Invalid literal, fail.
-            }
-
-            remainder = &remainder[i..];
-        }
-
-        match remainder.as_bytes().first() {
-            Some(b']') => break, // End of values.
-            Some(b',') => {}     // More values expected.
-            _ => return None,    // Invalid.
-        };
-
-        // Advance past comma.
-        remainder = remainder.get(1..)?;
-    }
-
-    if values.len() != labels.len() {
-        return None;
-    }
-
-    // Now: ]]
-    if remainder != "]]" {
-        return None;
-    }
-
-    Some(MetricLabelVals { labels, values })
-}
-
-// Read a JSON-encoded str that includes starting and ending double quotes.
-// Returns the validated str with the double quotes trimmed and the remainder
-// of the input str.
-fn scan_str(json: &str) -> Option<(&str, &str)> {
-    let mut escaping = false;
-
-    if !json.starts_with('"') {
-        return None;
-    }
-
-    // Trim leading double quote.
-    let json = json.get(1..)?;
-
-    for (i, &c) in json.as_bytes().iter().enumerate() {
-        if c == b'\\' {
-            escaping = true;
-            continue;
-        }
-
-        if c == b'"' && !escaping {
-            return Some((json.get(..i)?, json.get(i..)?));
-        }
-
-        escaping = false;
-    }
-
-    None
-}
-
-// Confirm an unquoted JSON literal is a boolean, null, or has a passing
-// resemblance to a number. We do not confirm numeric formatting, only
-// that all characters are valid. See https://www.json.org/json-en.html
-// for details.
-fn is_valid_json_literal(s: &str) -> bool {
-    match s {
-        "true" | "false" | "null" => true,
-        _ => s.chars().all(|c| {
-            c.is_ascii_digit() || c == '.' || c == '+' || c == '-' || c == 'e' || c == 'E'
-        }),
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use smallvec::smallvec;
-
-    use super::*;
-
-    struct TestCase {
-        name: &'static str,
-        input: &'static str,
-        expected: Option<MetricText<'static>>,
-    }
-
-    #[test]
-    fn valid_json() {
-        let tc = vec![
-            TestCase {
-                name: "basic",
-                input: r#"["metric","name",["label_a","label_b"],["value_a","value_b"]]"#,
-                expected: Some(MetricText {
-                    family_name: "metric",
-                    metric_name: "name",
-                    labels: smallvec!["label_a", "label_b"],
-                    values: smallvec!["value_a", "value_b"],
-                }),
-            },
-            TestCase {
-                name: "many labels",
-                input: r#"["metric","name",["label_a","label_b","label_c","label_d","label_e"],["value_a","value_b","value_c","value_d","value_e"]]"#,
-
-                expected: Some(MetricText {
-                    family_name: "metric",
-                    metric_name: "name",
-                    labels: smallvec!["label_a", "label_b", "label_c", "label_d", "label_e"],
-                    values: smallvec!["value_a", "value_b", "value_c", "value_d", "value_e"],
-                }),
-            },
-            TestCase {
-                name: "numeric value",
-                input: r#"["metric","name",["label_a","label_b"],["value_a",403]]"#,
-                expected: Some(MetricText {
-                    family_name: "metric",
-                    metric_name: "name",
-                    labels: smallvec!["label_a", "label_b"],
-                    values: smallvec!["value_a", "403"],
-                }),
-            },
-            TestCase {
-                name: "scientific notation literal",
-                input: r#"["metric","name",["label_a"],[-2.0e-5]]"#,
-                expected: Some(MetricText {
-                    family_name: "metric",
-                    metric_name: "name",
-                    labels: smallvec!["label_a"],
-                    values: smallvec!["-2.0e-5"],
-                }),
-            },
-            TestCase {
-                name: "null value",
-                input: r#"["metric","name",["label_a","label_b"],[null,"value_b"]]"#,
-                expected: Some(MetricText {
-                    family_name: "metric",
-                    metric_name: "name",
-                    labels: smallvec!["label_a", "label_b"],
-                    values: smallvec!["null", "value_b"],
-                }),
-            },
-            TestCase {
-                name: "no labels",
-                input: r#"["metric","name",[],[]]"#,
-                expected: Some(MetricText {
-                    family_name: "metric",
-                    metric_name: "name",
-                    labels: smallvec![],
-                    values: smallvec![],
-                }),
-            },
-            TestCase {
-                name: "comma in items",
-                input: r#"["met,ric","na,me",["label,_a","label_b"],["value,_a","value_b"]]"#,
-                expected: Some(MetricText {
-                    family_name: "met,ric",
-                    metric_name: "na,me",
-                    labels: smallvec!["label,_a", "label_b"],
-                    values: smallvec!["value,_a", "value_b"],
-                }),
-            },
-            TestCase {
-                name: "bracket in value",
-                input: r#"["met[r]ic","na[m]e",["label[_]a","label_b"],["value_a","val[ue]_b"]]"#,
-                expected: Some(MetricText {
-                    family_name: "met[r]ic",
-                    metric_name: "na[m]e",
-                    labels: smallvec!["label[_]a", "label_b"],
-                    values: smallvec!["value_a", "val[ue]_b"],
-                }),
-            },
-            TestCase {
-                name: "escaped quotes",
-                input: r#"["met\"ric","na\"me",["label\"_a","label_b"],["value\"_a","value_b"]]"#,
-                expected: Some(MetricText {
-                    family_name: r#"met\"ric"#,
-                    metric_name: r#"na\"me"#,
-                    labels: smallvec![r#"label\"_a"#, "label_b"],
-                    values: smallvec![r#"value\"_a"#, "value_b"],
-                }),
-            },
-        ];
-
-        for case in tc {
-            assert_eq!(
-                parse_metrics(case.input),
-                case.expected,
-                "test case: {}",
-                case.name,
-            );
-        }
-    }
-
-    #[test]
-    fn invalid_json() {
-        let tc = vec![
-            TestCase {
-                name: "not json",
-                input: "hello, world",
-                expected: None,
-            },
-            TestCase {
-                name: "no names",
-                input: r#"[["label_a","label_b"],["value_a","value_b"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "too many names",
-                input: r#"["metric","name","unexpected_name",["label_a","label_b"],["value_a","value_b"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "too many labels",
-                input: r#"["metric","name","unexpected_name",["label_a","label_b","label_c"],["value_a","value_b"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "too many values",
-                input: r#"["metric","name",["label_a","label_b"],["value_a","value_b",null]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "no values",
-                input: r#"["metric","name",["label_a","label_b"]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "no arrays",
-                input: r#"["metric","name","label_a","value_a"]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "too many leading brackets",
-                input: r#"[["metric","name",["label_a","label_b"],["value_a","value_b"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "too many trailing brackets",
-                input: r#"["metric","name",["label_a","label_b"],["value_a","value_b"]]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "too many leading label brackets",
-                input: r#"["metric","name",[["label_a","label_b"],["value_a","value_b"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "too many trailing label brackets",
-                input: r#"["metric","name",["label_a","label_b"]],["value_a","value_b"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "too many leading value brackets",
-                input: r#"["metric","name",["label_a","label_b"],[["value_a","value_b"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "misplaced bracket",
-                input: r#"["metric","name",["label_a","label_b"],]["value_a","value_b"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "comma in numeric value",
-                input: r#"["metric","name",["label_a","label_b"],[400,0,"value_b"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "non-e letter in numeric value",
-                input: r#"["metric","name",["label_a","label_b"],[400x0,"value_b"]]"#,
-                expected: None,
-            },
-        ];
-
-        for case in tc {
-            assert_eq!(
-                case.expected,
-                parse_metrics(case.input),
-                "test case: {}",
-                case.name,
-            );
-        }
-    }
-}