Generate units according to OTel required spec

This commit adds a generator for UCUM units and replaces the purely random
strings we were using previously. We use an explicitly enumeraged table which
won't work forever but probably will work for many years until we learn
otherwise. Note that UCUM specifies a number of units do not produce.

REF SMPTNG-659

Signed-off-by: Brian L. Troutwine <brian.troutwine@datadoghq.com>

Author: blt

lading_payload/src/lib.rs

@@ -81,6 +81,9 @@ pub enum Error {
     /// See [`weighted::Error`]
     #[error(transparent)]
     Weights(#[from] weighted::Error),
+    /// See [`unit::Error`]
+    #[error(transparent)]
+    Unit(#[from] opentelemetry_metric::unit::Error),
 }
 
 /// To serialize into bytes

lading_payload/src/opentelemetry_metric.rs

@@ -38,6 +38,8 @@
 // * value: enum { u64, f64 } -- the value
 // * flags: uu32 -- I'm not sure what to make of this yet
 
+pub(crate) mod unit;
+
 use std::io::Write;
 use std::rc::Rc;
 
@@ -55,6 +57,7 @@ use rand::{
     seq::IndexedRandom,
 };
 use serde::{Deserialize, Serialize as SerdeSerialize};
+use unit::UnitGenerator;
 
 /// Configure the OpenTelemetry metric payload.
 #[derive(Debug, Default, Deserialize, SerdeSerialize, Clone, PartialEq, Copy)]
@@ -247,6 +250,7 @@ impl<'a> Generator<'a> for ScopeGenerator {
 pub(crate) struct MetricGenerator {
     metric_weights: WeightedIndex<u16>,
     attributes_per_metric: ConfRange<u32>,
+    unit_generator: UnitGenerator,
     str_pool: Rc<strings::Pool>,
 }
 
@@ -259,6 +263,7 @@ impl MetricGenerator {
         Ok(Self {
             str_pool: Rc::clone(str_pool),
             metric_weights: WeightedIndex::new(member_choices)?,
+            unit_generator: UnitGenerator::new(),
             attributes_per_metric: config.contexts.attributes_per_metric,
         })
     }
@@ -289,12 +294,12 @@ impl<'a> Generator<'a> for MetricGenerator {
             .of_size_range(rng, 1_u8..16)
             .ok_or(Error::StringGenerate)?;
 
-        // TODO this is not correct and must be fixed to accord with http://unitsofmeasure.org/ucum.html.
-        let unit = self
-            .str_pool
-            .of_size_range(rng, 1_u8..16)
-            .ok_or(Error::StringGenerate)?;
-
+        // Units are optional, "" is the None unit.
+        let unit = if rng.random_bool(0.1) {
+            self.unit_generator.generate(rng)?
+        } else {
+            ""
+        };
         let count = self.attributes_per_metric.sample(rng);
         let metadata = generate_attributes(&self.str_pool, rng, count)?;
 

lading_payload/src/opentelemetry_metric/unit.rs

@@ -0,0 +1,43 @@
+//! Code to generate units according to
+//! <http://unitsofmeasure.org/ucum.html>. This may be generally
+//! useful in the project and is not specifically tied to the OpenTelemetry metrics
+//! implementation.
+
+// The spec defines a fairly elaborate grammar. It's unclear that we need _all_
+// that for our purposes, so for now we rely on a simple table method. I imagine
+// we can just keep stuffing the table for a while as seems desirable.
+
+const UNITS: &[&str] = &[
+    "bit", "Kbit", "Mbit", "Gbit", // data size, bits, decimal
+    "Kibit", "Mibit", "Gibit", // data size, bits, binary
+    "By", "KBy", "MBy", "GBy", // data size, bytes, decimal
+    "KiBy", "MiBy", "GiBy", // data size, bytes, binary
+    "By/s", "KiBy/s", "bit/s", "Mbit/s", // transfer rate
+    "s", "ms", "us", "ns", // time
+    "W", "kW", "kWh", // power
+];
+
+/// Errors related to generation
+#[derive(thiserror::Error, Debug, Clone, Copy)]
+pub enum Error {}
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct UnitGenerator {}
+
+impl UnitGenerator {
+    pub(crate) fn new() -> Self {
+        Self {}
+    }
+}
+
+impl crate::Generator<'_> for UnitGenerator {
+    type Output = &'static str;
+    type Error = Error;
+
+    fn generate<R>(&self, rng: &mut R) -> Result<Self::Output, Self::Error>
+    where
+        R: rand::Rng + ?Sized,
+    {
+        Ok(UNITS[rng.random_range(0..UNITS.len())])
+    }
+}