update data type based on data from otel collector

Author: nikhilsinhaparseable

src/handlers/http/otel/opentelemetry.proto.metrics.v1.rs

@@ -412,7 +412,7 @@ pub struct ExponentialHistogramDataPoint {
     /// count is the number of values in the population. Must be
     /// non-negative. This value must be equal to the sum of the "bucket_counts"
     /// values in the positive and negative Buckets plus the "zero_count" field.
-    pub count: Option<u64>,
+    pub count: Option<String>,
     /// sum of the values in the population. If count is zero then this field
     /// must be zero.
     ///
@@ -516,7 +516,7 @@ pub struct SummaryDataPoint {
     /// 1970.
     pub time_unix_nano: Option<String>,
     /// count is the number of values in the population. Must be non-negative.
-    pub count: Option<u64>,
+    pub count: Option<String>,
     /// sum of the values in the population. If count is zero then this field
     /// must be zero.
     ///
@@ -535,7 +535,7 @@ pub struct SummaryDataPoint {
 }
 /// Nested message and enum types in `SummaryDataPoint`.
 pub mod summary_data_point {
-    use serde::{Deserialize, Serialize};
+    use serde::{Deserialize, Deserializer, Serialize};
     /// Represents the value at a given quantile of a distribution.
     ///
     /// To record Min and Max values following conventions are used:
@@ -553,8 +553,34 @@ pub mod summary_data_point {
         /// The value at the given quantile of a distribution.
         ///
         /// Quantile values must NOT be negative.
+        #[serde(deserialize_with = "deserialize_f64_or_nan")]
         pub value: Option<f64>,
     }
+
+    fn deserialize_f64_or_nan<'de, D>(deserializer: D) -> Result<Option<f64>, D::Error> where D: Deserializer<'de>, 
+    { 
+        struct StringOrFloatVisitor; 
+        impl<'de> serde::de::Visitor<'de> for StringOrFloatVisitor 
+        {
+             type Value = Option<f64>; 
+             fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result 
+             { 
+                formatter.write_str("a string or a floating-point number") 
+            } 
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> where E: serde::de::Error, 
+            {
+                 if value == "NaN" 
+                 {
+                     Ok(Some(f64::NAN)) 
+                    } else {
+                         value.parse::<f64>().map(Some).map_err(E::custom)
+                         } }
+         fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E> where E: serde::de::Error, 
+         {
+             Ok(Some(value))
+             }
+        }
+         deserializer.deserialize_any(StringOrFloatVisitor) }
 }
 /// A representation of an exemplar, which is a sample input measurement.
 /// Exemplars also hold information about the environment when the measurement

src/handlers/http/otel_metrics.rs

@@ -601,7 +601,7 @@ fn flatten_exp_histogram(exp_histogram: &ExponentialHistogram) -> Vec<BTreeMap<S
             if data_point.count.is_some() {
                 data_point_json.insert(
                     "exponential_histogram_data_point_count".to_string(),
-                    Value::Number(serde_json::Number::from(data_point.count.unwrap())),
+                    Value::String(data_point.count.as_ref().unwrap().to_string()),
                 );
             }
 
@@ -791,7 +791,7 @@ fn flatten_summary(summary: &Summary) -> Vec<BTreeMap<String, Value>> {
             if data_point.count.is_some() {
                 data_point_json.insert(
                     "summary_data_point_count".to_string(),
-                    Value::Number(serde_json::Number::from(data_point.count.unwrap())),
+                    Value::String(data_point.count.as_ref().unwrap().to_string()),
                 );
             }
 
@@ -803,10 +803,11 @@ fn flatten_summary(summary: &Summary) -> Vec<BTreeMap<String, Value>> {
             }
 
             if let Some(quantile_values) = data_point.quantile_values.as_ref() {
+                let mut quantile_ctr = 1;
                 for quantile_value in quantile_values.iter() {
                     if quantile_value.quantile.is_some() {
                         data_point_json.insert(
-                            "summary_quantile_value_quantile".to_string(),
+                            format!("summary_quantile_value_quantile_{}", quantile_ctr),
                             Value::Number(
                                 serde_json::Number::from_f64(quantile_value.quantile.unwrap())
                                     .unwrap(),
@@ -816,13 +817,12 @@ fn flatten_summary(summary: &Summary) -> Vec<BTreeMap<String, Value>> {
 
                     if quantile_value.value.is_some() {
                         data_point_json.insert(
-                            "summary_quantile_value_value".to_string(),
-                            Value::Number(
-                                serde_json::Number::from_f64(quantile_value.value.unwrap())
-                                    .unwrap(),
-                            ),
+                            format!("summary_quantile_value_value_{}", quantile_ctr),
+                            Value::String(quantile_value.value.as_ref().unwrap().to_string()),
                         );
                     }
+
+                    quantile_ctr += 1;
                 }
             }