diagnostics_hierarchy/serialization/
serialize.rs

1// Copyright 2020 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::{ArrayContent, DiagnosticsHierarchy, ExponentialHistogram, LinearHistogram, Property};
6use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
7use base64::engine::Engine as _;
8use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
9
10impl<Key> Serialize for DiagnosticsHierarchy<Key>
11where
12    Key: AsRef<str>,
13{
14    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
15        let mut s = serializer.serialize_map(Some(1))?;
16        let name = self.name.clone();
17        s.serialize_entry(&name, &SerializableHierarchyFields { hierarchy: self })?;
18        s.end()
19    }
20}
21
22pub struct SerializableHierarchyFields<'a, Key> {
23    pub(crate) hierarchy: &'a DiagnosticsHierarchy<Key>,
24}
25
26impl<Key> Serialize for SerializableHierarchyFields<'_, Key>
27where
28    Key: AsRef<str>,
29{
30    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
31        let items = self.hierarchy.properties.len() + self.hierarchy.children.len();
32        let mut s = serializer.serialize_map(Some(items))?;
33        for property in self.hierarchy.properties.iter() {
34            let name = property.name();
35            match property {
36                Property::String(_, value) => s.serialize_entry(name, &value)?,
37                Property::Int(_, value) => s.serialize_entry(name, &value)?,
38                Property::Uint(_, value) => s.serialize_entry(name, &value)?,
39                Property::Double(_, value) => {
40                    let value =
41                        if value.is_nan() || (value.is_infinite() && value.is_sign_positive()) {
42                            f64::MAX
43                        } else if value.is_infinite() && value.is_sign_negative() {
44                            f64::MIN
45                        } else {
46                            *value
47                        };
48                    s.serialize_entry(name, &value)?;
49                }
50                Property::Bool(_, value) => s.serialize_entry(name, &value)?,
51                Property::Bytes(_, array) => {
52                    s.serialize_entry(name, &format!("b64:{}", BASE64_STANDARD.encode(array)))?
53                }
54                Property::DoubleArray(_, array) => {
55                    s.serialize_entry(name, &array)?;
56                }
57                Property::IntArray(_, array) => {
58                    s.serialize_entry(name, &array)?;
59                }
60                Property::UintArray(_, array) => {
61                    s.serialize_entry(name, &array)?;
62                }
63                Property::StringList(_, list) => {
64                    s.serialize_entry(name, &list)?;
65                }
66            }
67        }
68        for child in self.hierarchy.children.iter() {
69            s.serialize_entry(&child.name, &SerializableHierarchyFields { hierarchy: child })?;
70        }
71        s.end()
72    }
73}
74
75// A condensed histogram has a vec of counts and a vec of corresponding indexes.
76// For serialization, histograms should be condensed if fewer than 50% of the
77// counts are nonzero. We don't worry about decondensing histograms with more
78// than 50% nonzero counts - they'd still be correct, but we shouldn't get them.
79pub(crate) fn maybe_condense_histogram<T>(
80    counts: &[T],
81    indexes: &Option<Vec<usize>>,
82) -> Option<(Vec<T>, Vec<usize>)>
83where
84    T: PartialEq + num_traits::Zero + Copy,
85{
86    if indexes.is_some() {
87        return None;
88    }
89    let mut condensed_counts = vec![];
90    let mut indexes = vec![];
91    let cutoff_len = counts.len() / 2;
92    for (index, count) in counts.iter().enumerate() {
93        if *count != T::zero() {
94            indexes.push(index);
95            condensed_counts.push(*count);
96            if condensed_counts.len() > cutoff_len {
97                return None;
98            }
99        }
100    }
101    Some((condensed_counts, indexes))
102}
103
104macro_rules! impl_serialize_for_array_value {
105    ($($type:ty,)*) => {
106        $(
107            impl Serialize for ArrayContent<$type> {
108                fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
109                    match self {
110                        ArrayContent::LinearHistogram(LinearHistogram {
111                            floor,
112                            step,
113                            counts,
114                            indexes,
115                            size,
116                        }) => {
117                            let condensation = maybe_condense_histogram(counts, indexes);
118                            let (counts, indexes) = match condensation {
119                                None => (counts.to_vec(), indexes.as_ref().map(|v| v.to_vec())),
120                                Some((cc, ci)) => (cc, Some(ci)),
121                            };
122                            LinearHistogram {
123                                floor: *floor,
124                                step: *step,
125                                counts,
126                                indexes,
127                                size: *size,
128                            }.serialize(serializer)
129                        }
130                        ArrayContent::ExponentialHistogram(ExponentialHistogram {
131                            floor,
132                            initial_step,
133                            step_multiplier,
134                            counts,
135                            indexes,
136                            size,
137                        }) => {
138                            let condensation = maybe_condense_histogram(counts, indexes);
139                            let (counts, indexes) = match condensation {
140                                None => (counts.to_vec(), indexes.as_ref().map(|v| v.to_vec())),
141                                Some((cc, ci)) => (cc, Some(ci)),
142                            };
143                            ExponentialHistogram {
144                                floor: *floor,
145                                size: *size,
146                                initial_step: *initial_step,
147                                step_multiplier: *step_multiplier,
148                                counts,
149                                indexes,
150                            }
151                            .serialize(serializer)
152                        }
153                        ArrayContent::Values(values) => {
154                            let mut s = serializer.serialize_seq(Some(values.len()))?;
155                            for value in values {
156                                s.serialize_element(&value)?;
157                            }
158                            s.end()
159                        }
160                    }
161                }
162            }
163        )*
164    }
165}
166
167impl_serialize_for_array_value![i64, u64, f64,];
168
169#[cfg(test)]
170mod tests {
171    use super::*;
172    use crate::{hierarchy, ArrayFormat};
173
174    #[fuchsia::test]
175    fn serialize_json() {
176        let mut hierarchy = test_hierarchy();
177        hierarchy.sort();
178        let expected = expected_json();
179        let result = serde_json::to_string_pretty(&hierarchy).expect("failed to serialize");
180        let parsed_json_expected: serde_json::Value = serde_json::from_str(&expected).unwrap();
181        let parsed_json_result: serde_json::Value = serde_json::from_str(&result).unwrap();
182        assert_eq!(parsed_json_result, parsed_json_expected);
183    }
184
185    #[fuchsia::test]
186    fn serialize_doubles() {
187        let hierarchy = hierarchy! {
188            root: {
189                inf: f64::INFINITY,
190                neg_inf: f64::NEG_INFINITY,
191                nan: f64::NAN,
192            }
193        };
194        let result = serde_json::to_string_pretty(&hierarchy).expect("serialized");
195        assert_eq!(
196            result,
197            r#"{
198  "root": {
199    "inf": 1.7976931348623157e308,
200    "neg_inf": -1.7976931348623157e308,
201    "nan": 1.7976931348623157e308
202  }
203}"#
204        );
205    }
206
207    fn test_hierarchy() -> DiagnosticsHierarchy {
208        DiagnosticsHierarchy::new(
209            "root",
210            vec![
211                Property::UintArray("array".to_string(), ArrayContent::Values(vec![0, 2, 4])),
212                Property::Bool("bool_true".to_string(), true),
213                Property::Bool("bool_false".to_string(), false),
214                Property::StringList(
215                    "string_list".to_string(),
216                    vec!["foo".to_string(), "bar".to_string()],
217                ),
218                Property::StringList("empty_string_list".to_string(), vec![]),
219            ],
220            vec![
221                DiagnosticsHierarchy::new(
222                    "a",
223                    vec![
224                        Property::Double("double".to_string(), 2.5),
225                        Property::DoubleArray(
226                            "histogram".to_string(),
227                            ArrayContent::new(
228                                vec![0.0, 2.0, 4.0, 1.0, 3.0, 4.0],
229                                ArrayFormat::ExponentialHistogram,
230                            )
231                            .unwrap(),
232                        ),
233                        Property::Bytes("bytes".to_string(), vec![5u8, 0xf1, 0xab]),
234                    ],
235                    vec![],
236                ),
237                DiagnosticsHierarchy::new(
238                    "b",
239                    vec![
240                        Property::Int("int".to_string(), -2),
241                        Property::String("string".to_string(), "some value".to_string()),
242                        Property::IntArray(
243                            "histogram".to_string(),
244                            ArrayContent::new(vec![0, 2, 4, 1, 3], ArrayFormat::LinearHistogram)
245                                .unwrap(),
246                        ),
247                        Property::IntArray(
248                            "condensed_histogram".to_string(),
249                            ArrayContent::new(vec![0, 2, 0, 1, 0], ArrayFormat::LinearHistogram)
250                                .unwrap(),
251                        ),
252                    ],
253                    vec![],
254                ),
255            ],
256        )
257    }
258
259    fn expected_json() -> String {
260        r#"{
261  "root": {
262    "array": [
263      0,
264      2,
265      4
266    ],
267    "bool_false": false,
268    "bool_true": true,
269    "empty_string_list": [],
270    "string_list": [
271      "foo",
272      "bar"
273    ],
274    "a": {
275      "bytes": "b64:BfGr",
276      "double": 2.5,
277      "histogram": {
278        "size": 3,
279        "floor": 0.0,
280        "initial_step": 2.0,
281        "step_multiplier": 4.0,
282        "counts": [1.0, 3.0, 4.0]
283      }
284    },
285    "b": {
286      "histogram": {
287        "floor": 0,
288        "step": 2,
289        "counts": [
290          4,
291          1,
292          3
293        ],
294        "size": 3
295      },
296    "condensed_histogram": {
297        "size": 3,
298        "floor": 0,
299        "step": 2,
300        "counts": [
301          1
302        ],
303        "indexes": [
304          1
305        ]
306      },
307      "int": -2,
308      "string": "some value"
309    }
310  }
311}"#
312        .to_string()
313    }
314}
diagnostics_hierarchy/serialization/serialize.rs

diagnostics_hierarchy/serialization/
serialize.rs
