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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11eecc761b0bd7cbcc8137e7097cb81595b0bbbe5b01058b1a601f01fd0405e9
-  data.tar.gz: c9d175042f2a64f0735d5a4b973506c56690a555e20bb115062c207e4389ba01
+  metadata.gz: c288a4602307bbeedfe916df669c95d80d555f1c95beb7a2c946c58368c0f86b
+  data.tar.gz: 41b3bc2a51e0aee5de6d1511a9feb7285270c1d8366e683befdb1564a025f3f3
 SHA512:
-  metadata.gz: 3f5428ee9d38050a212df5d313c73ac4734ee6d0d174608ee5b72cd1d8ba586db82b41d30f356373b33a350ce9fa291d515b4e965dde309b83ca449dcd0d0b6b
-  data.tar.gz: e67748cf4f5d979b25068bf1d86fc828419301fc09425c40f54cb24aa0247dcf69aa9a295daca22b8458cd04597182603a62ae1b02e9195a88350c33c2efc885
+  metadata.gz: 7c4bb28ac28b8ca1b12716fe291516aeb9404b1fb553ce8c6aee0126554e2bcec8a9372cef93f2be4b429b09b32c7096f9c0fe8fbeb52876ccdd44d1d179a411
+  data.tar.gz: 1fce85abecdbdd8c0f85090eae0294b39f6cf00524dd67d950a046f8890ed31bb52ea0a5c9952c2c6b2aabc66918d766356c72683b4116731002e298b16fbac4

data/ext/fast_mmaped_file_rs/Cargo.lock

@@ -169,6 +169,8 @@ dependencies = [
  "nix",
  "rand",
  "rb-sys",
+ "serde",
+ "serde_json",
  "sha2",
  "smallvec",
  "tempfile",
@@ -252,6 +254,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"
@@ -515,6 +523,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 +540,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 +594,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]

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/lib/prometheus/client/version.rb

@@ -1,5 +1,5 @@
 module Prometheus
   module Client
-    VERSION = '0.24.4'.freeze
+    VERSION = '0.24.5'.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.24.5
 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-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -159,7 +159,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,
-            );
-        }
-    }
-}