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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96d81412cc07d51c07e2a4d3d63d24a0977f8f3218a469bace79a9d2abc929b6
-  data.tar.gz: 61c024688e436092d09d4b77214603e1c374be69e6b4b289d0d2997f10218c24
+  metadata.gz: 1207aad86766a410bc9b90eee5b83ae1785f9c36fb34ac79a3bc56a44ce9d7ed
+  data.tar.gz: b1cc8b946f96ff5f26de048492159e162cb7831d11f3b724f01988aca1e1da94
 SHA512:
-  metadata.gz: a030d17f52d1530a30e8ff892632a00ff8cd10489ded1a7268eca58898dfd73c627f56f38bd8382066c70d9e58400719e37f1485790fcea723d377080512712c
-  data.tar.gz: 6a2bf596a09c5a7a255051f4c6945f2f325d6d0db03b0a9f537af50ade9b1b17356240628723401391b8eaa27ad66e2d9b7730c9c65b5a040049d19663b429b1
+  metadata.gz: ca3048cd9a5829d78a1a091554d33434188b6a49babe0b73ece6c508c0c7514cf54da7dc89c74bf26ecae9642fd54a89da9990be03877631942d99c81113306c
+  data.tar.gz: 554ca7fa38267fa42e13d024e22f03cb96c34cc882f97d21a351b1248827cc6ab41104ad067ed2f33e3b03f4f507b344e94a9887a6d5bff737ef0878c6175d40

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.3'.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.3
+  version: 0.24.5
 platform: x86_64-linux
 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-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,346 +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;
-    }
-
-    // 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)?;
-
-    // Split on commas into:
-    // family_name","metric_name",
-    // ^^^^one^^^^^ ^^^^^two^^^^^
-    let mut token_iter = remainder.split(',');
-
-    // Captured: family_name","metric_name",
-    //           ^^^^^^^^^^^
-    let family_name = token_iter.next()?.trim_end_matches('"');
-
-    // Captured: "family_name","metric_name",
-    //                          ^^^^^^^^^^^
-    let metric_name = token_iter.next()?.trim_matches('"');
-
-    // Confirm the final entry of the iter is empty, the the trailing ','.
-    if !token_iter.next()?.is_empty() {
-        return None;
-    }
-
-    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('[') && json.ends_with("]]")) {
-        return None;
-    }
-
-    // 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('"'));
-        }
-    }
-
-    // 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'[') {
-        return None;
-    }
-
-    // Now: "value_a", "value_b"]]
-    values_range = values_range.get(3..)?;
-
-    let values_end = values_range.find(']')?;
-
-    // Validate we have only two trailing brackets.
-    if values_range.get(values_end..)?.len() > 2 {
-        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('"'));
-        }
-    }
-
-    if values.len() != labels.len() {
-        return None;
-    }
-
-    Some(MetricLabelVals { labels, values })
-}
-
-#[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: "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![],
-                }),
-            },
-        ];
-
-        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: "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"]]"#,
-                expected: None,
-            },
-            TestCase {
-                name: "comma in value",
-                input: r#"["metric","na,me",["label_a","label_b"],["val,ue_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,
-            },
-        ];
-
-        for case in tc {
-            assert_eq!(
-                case.expected,
-                parse_metrics(case.input),
-                "test case: {}",
-                case.name,
-            );
-        }
-    }
-}