Implement Deserialize on Vector, Matrix, Sample

Author: puetzp

Cargo.toml

@@ -11,6 +11,7 @@ description = "Prometheus HTTP API client"
 
 [dependencies]
 reqwest = { version = "0.11", features = ["json"] }
+serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 
 [dev-dependencies]

src/client.rs

@@ -703,23 +703,15 @@ fn parse_query_response(response: HashMap<String, serde_json::Value>) -> Result<
         "success" => {
             let data_obj = response["data"].as_object().unwrap();
             let data_type = data_obj["resultType"].as_str().unwrap();
-            let data = data_obj["result"].as_array().unwrap();
+            let data = data_obj["result"].as_array().unwrap().to_owned();
 
             match data_type {
                 "vector" => {
                     let mut result: Vec<Vector> = vec![];
 
                     for datum in data {
-                        let metric = parse_metric(datum["metric"].as_object().unwrap());
-
-                        let raw_value = datum["value"].as_array().unwrap();
-
-                        let sample = Sample {
-                            timestamp: raw_value[0].as_f64().unwrap(),
-                            value: raw_value[1].as_str().unwrap().to_string(),
-                        };
-
-                        result.push(Vector { metric, sample });
+                        let vector: Vector = serde_json::from_value(datum).unwrap();
+                        result.push(vector);
                     }
 
                     Ok(Response::Vector(result))
@@ -728,18 +720,8 @@ fn parse_query_response(response: HashMap<String, serde_json::Value>) -> Result<
                     let mut result: Vec<Matrix> = vec![];
 
                     for datum in data {
-                        let metric = parse_metric(datum["metric"].as_object().unwrap());
-
-                        let mut samples: Vec<Sample> = vec![];
-
-                        for sample in datum["values"].as_array().unwrap() {
-                            samples.push(Sample {
-                                timestamp: sample[0].as_f64().unwrap(),
-                                value: sample[1].as_str().unwrap().to_string(),
-                            });
-                        }
-
-                        result.push(Matrix { metric, samples });
+                        let matrix: Matrix = serde_json::from_value(datum).unwrap();
+                        result.push(matrix);
                     }
 
                     Ok(Response::Matrix(result))

src/response.rs

@@ -1,5 +1,6 @@
 //! Collection of response types, most importantly the [Response] enum
 use crate::util::TargetHealth;
+use serde::Deserialize;
 use std::collections::HashMap;
 
 /// A wrapper for any kind of response the API returns.
@@ -14,9 +15,10 @@ pub enum Response {
 }
 
 /// A single time series containing a single data point ([Sample]).
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Deserialize)]
 pub struct Vector {
     pub(crate) metric: HashMap<String, String>,
+    #[serde(alias = "value")]
     pub(crate) sample: Sample,
 }
 
@@ -34,9 +36,10 @@ impl Vector {
 }
 
 /// A single time series containing a range of data points ([Sample]s).
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Deserialize)]
 pub struct Matrix {
     pub(crate) metric: HashMap<String, String>,
+    #[serde(alias = "values")]
     pub(crate) samples: Vec<Sample>,
 }
 
@@ -54,7 +57,7 @@ impl Matrix {
 }
 
 /// A single data point.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Deserialize)]
 pub struct Sample {
     pub(crate) timestamp: f64,
     pub(crate) value: String,