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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c58c90cb1e3ac8174e6ca96573bb7df98b91336319b17ad8caf0d4344897d8b4
-  data.tar.gz: 0eff1ae02932caf5eadd3004ae86863b6c5071bc39ae4124a41fabc015f99153
+  metadata.gz: 11eecc761b0bd7cbcc8137e7097cb81595b0bbbe5b01058b1a601f01fd0405e9
+  data.tar.gz: c9d175042f2a64f0735d5a4b973506c56690a555e20bb115062c207e4389ba01
 SHA512:
-  metadata.gz: 65ca839f4132775e1684c75a0249e743f4b4e4bd2feacd2bc7e7fbfdd85bdb2fb238259584baef9f9d9474ad1bec417752a4e023ed568971f0e3cfc80db98018
-  data.tar.gz: ab007738aa9e525625ac086fb1a923c97df328646f9a52abc82761db6c7c46826566f690f27c7b3a50d11c5dab4360dff01c727694dbea494ad5fbe71997a05d
+  metadata.gz: 3f5428ee9d38050a212df5d313c73ac4734ee6d0d174608ee5b72cd1d8ba586db82b41d30f356373b33a350ce9fa291d515b4e965dde309b83ca449dcd0d0b6b
+  data.tar.gz: e67748cf4f5d979b25068bf1d86fc828419301fc09425c40f54cb24aa0247dcf69aa9a295daca22b8458cd04597182603a62ae1b02e9195a88350c33c2efc885

data/ext/fast_mmaped_file_rs/src/parser.rs

@@ -63,35 +63,35 @@ fn parse_names(json: &str) -> Option<MetricNames> {
         return None;
     }
 
-    // Now: family_name","metric_name",[...
-    let remainder = json.get(2..)?;
-
-    let names_end = remainder.find('[')?;
-
-    // Save the rest of the slice to parse for labels later.
-    let label_json = remainder.get(names_end..)?;
-
-    //  Now: family_name","metric_name",
-    let remainder = remainder.get(..names_end)?;
+    // Captured: "family_name","metric_name",
+    //            ^^^^^^^^^^^
+    let (family_name, remainder) = scan_str(json.get(1..)?)?;
 
-    // Split on commas into:
-    // family_name","metric_name",
-    // ^^^^one^^^^^ ^^^^^two^^^^^
-    let mut token_iter = remainder.split(',');
+    //  Validate comma separated names
+    // ["family_name","metric_name",[...
+    //               ^
+    if !remainder.starts_with("\",") {
+        return None;
+    }
 
-    // Captured: family_name","metric_name",
-    //           ^^^^^^^^^^^
-    let family_name = token_iter.next()?.trim_end_matches('"');
+    // Now: "metric_name",[...
+    let remainder = remainder.get(2..)?;
 
     // Captured: "family_name","metric_name",
     //                          ^^^^^^^^^^^
-    let metric_name = token_iter.next()?.trim_matches('"');
+    let (metric_name, remainder) = scan_str(remainder)?;
 
-    // Confirm the final entry of the iter is empty, the the trailing ','.
-    if !token_iter.next()?.is_empty() {
+    //  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,
@@ -101,76 +101,143 @@ fn parse_names(json: &str) -> Option<MetricNames> {
 
 fn parse_label_values(json: &str) -> Option<MetricLabelVals> {
     // Starting with: ["label_a","label_b"],["value_a", "value_b"]]
-    if !(json.starts_with('[') && json.ends_with("]]")) {
+    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;
     }
 
-    // Now: "label_a","label_b"
-    let labels_end = json.find(']')?;
-    let label_range = json.get(1..labels_end)?;
-
     let mut labels = SmallVec::new();
 
     // Split on commas into:
     // "label_a","label_b"
     // ^^^one^^^ ^^^two^^^
-    for label in label_range.split(',') {
-        // Captured: "label_a","label_b"
-        //            ^^^^^^^
-        // If there are no labels, e.g. `[][]`, then don't capture anything.
-        if !label.is_empty() {
-            labels.push(label.trim_matches('"'));
-        }
+    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..)?;
     }
 
-    // Now: ],["value_a", "value_b"]]
-    let mut values_range = json.get(labels_end..)?;
-
-    // Validate we have a separating comma with one and only one leading bracket.
-    if !(values_range.starts_with("],[") && values_range.as_bytes().get(3)? != &b'[') {
+    if !remainder.starts_with("],[") {
         return None;
     }
-
     // Now: "value_a", "value_b"]]
-    values_range = values_range.get(3..)?;
-
-    let values_end = values_range.find(']')?;
+    remainder = remainder.get(3..)?;
 
-    // Validate we have only two trailing brackets.
-    if values_range.get(values_end..)?.len() > 2 {
+    // Validate we don't have extra brackets.
+    if remainder.starts_with('[') {
         return None;
     }
 
-    // Now: "value_a", "value_b"
-    values_range = values_range.get(..values_end)?;
-
     let mut values = SmallVec::new();
-
     // Split on commas into:
     // "value_a","value_b"
     // ^^^one^^^ ^^^two^^^
-    for value in values_range.split(',') {
-        // Captured: "value_a","value_b"
-        //           ^^^^^^^^^
-        // If there are no values, e.g. `[][]`, then don't capture anything.
-        if !value.is_empty() {
-            values.push(value.trim_matches('"'));
+    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;
@@ -217,6 +284,16 @@ mod test {
                     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"]]"#,
@@ -237,6 +314,36 @@ mod test {
                     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 {
@@ -313,23 +420,18 @@ mod test {
                 expected: None,
             },
             TestCase {
-                name: "comma in family name",
-                input: r#"["met,ric","name",["label_a","label_b"],["value_a","value_b"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "comma in metric name",
-                input: r#"["metric","na,me",["label_a","label_b"],["value_a","value_b"]]"#,
+                name: "misplaced bracket",
+                input: r#"["metric","name",["label_a","label_b"],]["value_a","value_b"]]"#,
                 expected: None,
             },
             TestCase {
-                name: "comma in value",
-                input: r#"["metric","na,me",["label_a","label_b"],["val,ue_a","value_b"]]"#,
+                name: "comma in numeric value",
+                input: r#"["metric","name",["label_a","label_b"],[400,0,"value_b"]]"#,
                 expected: None,
             },
             TestCase {
-                name: "comma in numeric value",
-                input: r#"["metric","name",["label_a","label_b"],[400,0,"value_b"]]"#,
+                name: "non-e letter in numeric value",
+                input: r#"["metric","name",["label_a","label_b"],[400x0,"value_b"]]"#,
                 expected: None,
             },
         ];

data/lib/prometheus/client/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prometheus-client-mmap
 version: !ruby/object:Gem::Version
-  version: 0.24.3
+  version: 0.24.4
 platform: x86_64-darwin
 authors:
 - Tobias Schmidt
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-20 00:00:00.000000000 Z
+date: 2023-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys