mirrors/gecko-dev
1
0
Fork 1
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-11-07 11:48:19 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions
gecko-dev/toolkit/components/glean/pytest/metrics_test_output
Jan-Erik Rediger 8321cd2247 Bug 1693486 - Implement new event extra API. r=chutten 
This drops the _old_ API fully and implements support only for the new object-focused API,
regardless of `type` defintions in metrics.yaml.

The new API will look like the following examples:

Rust

    let extra = AnEventKeys {
        extra1: Some("a-value".into()),
        ..Default::default()
    };
    category::an_event.record(extra);

(Note: not optimal yet, but we can extend this with a builder-like
pattern later)

C++

    AnEventExtra extra = { .extra1 = Some("value"_ns) };
    category::an_event.Record(Some(extra));

JavaScript (actually unchanged!)

    let extra = { extra1: "value" };
    Glean.category.anEvent.record(extra);

(Note: The JavaScript API accepts strings, booleans and integers for any
extra value and will stringify them regardless of their specified type.)

Differential Revision: https://phabricator.services.mozilla.com/D114498
2021-06-02 16:07:56 +00:00

579 lines
21 KiB
Rust
Raw Blame History

// -*- mode: Rust -*-
// AUTOGENERATED BY glean_parser. DO NOT EDIT.
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
pub mod test {
use crate::private::*;
use glean::CommonMetricData;
use once_cell::sync::Lazy;
#[allow(non_upper_case_globals)]
/// generated from test.boolean_metric
///
/// A multi-line
/// description
pub static boolean_metric: Lazy<BooleanMetric> = Lazy::new(|| {
BooleanMetric::new(1.into(), CommonMetricData {
name: "boolean_metric".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
})
});
#[allow(non_upper_case_globals)]
/// generated from test.labeled_boolean_metric
///
/// A multi-line
/// description
pub static labeled_boolean_metric: Lazy<LabeledMetric<LabeledBooleanMetric>> = Lazy::new(|| {
LabeledMetric::new(2.into(), CommonMetricData {
name: "labeled_boolean_metric".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
}, None)
});
#[allow(non_upper_case_globals)]
/// generated from test.labeled_boolean_metric_labels
///
/// A multi-line
/// description
pub static labeled_boolean_metric_labels: Lazy<LabeledMetric<LabeledBooleanMetric>> = Lazy::new(|| {
LabeledMetric::new(3.into(), CommonMetricData {
name: "labeled_boolean_metric_labels".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
}, Some(vec!["one_label".into(), "two_labels".into()]))
});
#[allow(non_upper_case_globals)]
/// generated from test.counter_metric
///
/// A multi-line
/// description
pub static counter_metric: Lazy<CounterMetric> = Lazy::new(|| {
CounterMetric::new(4.into(), CommonMetricData {
name: "counter_metric".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
})
});
#[allow(non_upper_case_globals)]
/// generated from test.labeled_counter_metric
///
/// A multi-line
/// description
pub static labeled_counter_metric: Lazy<LabeledMetric<LabeledCounterMetric>> = Lazy::new(|| {
LabeledMetric::new(5.into(), CommonMetricData {
name: "labeled_counter_metric".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
}, None)
});
#[allow(non_upper_case_globals)]
/// generated from test.labeled_counter_metric_labels
///
/// A multi-line
/// description
pub static labeled_counter_metric_labels: Lazy<LabeledMetric<LabeledCounterMetric>> = Lazy::new(|| {
LabeledMetric::new(6.into(), CommonMetricData {
name: "labeled_counter_metric_labels".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
}, Some(vec!["one_label".into(), "two_labels".into()]))
});
#[allow(non_upper_case_globals)]
/// generated from test.string_metric
///
/// A multi-line
/// description
pub static string_metric: Lazy<StringMetric> = Lazy::new(|| {
StringMetric::new(7.into(), CommonMetricData {
name: "string_metric".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
})
});
#[allow(non_upper_case_globals)]
/// generated from test.labeled_string_metric
///
/// A multi-line
/// description
pub static labeled_string_metric: Lazy<LabeledMetric<LabeledStringMetric>> = Lazy::new(|| {
LabeledMetric::new(8.into(), CommonMetricData {
name: "labeled_string_metric".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
}, None)
});
#[allow(non_upper_case_globals)]
/// generated from test.labeled_string_metric_labels
///
/// A multi-line
/// description
pub static labeled_string_metric_labels: Lazy<LabeledMetric<LabeledStringMetric>> = Lazy::new(|| {
LabeledMetric::new(9.into(), CommonMetricData {
name: "labeled_string_metric_labels".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
}, Some(vec!["one_label".into(), "two_labels".into()]))
});
#[allow(non_upper_case_globals)]
/// generated from test.string_list_metric
///
/// A multi-line
/// description
pub static string_list_metric: Lazy<StringListMetric> = Lazy::new(|| {
StringListMetric::new(10.into(), CommonMetricData {
name: "string_list_metric".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
})
});
#[allow(non_upper_case_globals)]
/// generated from test.timespan_metric
///
/// A multi-line
/// description
pub static timespan_metric: Lazy<TimespanMetric> = Lazy::new(|| {
TimespanMetric::new(11.into(), CommonMetricData {
name: "timespan_metric".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
}, TimeUnit::Millisecond)
});
#[allow(non_upper_case_globals)]
/// generated from test.timing_distribution_metric
///
/// A multi-line
/// description
pub static timing_distribution_metric: Lazy<TimingDistributionMetric> = Lazy::new(|| {
TimingDistributionMetric::new(12.into(), CommonMetricData {
name: "timing_distribution_metric".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
}, TimeUnit::Nanosecond)
});
#[allow(non_upper_case_globals)]
/// generated from test.memory_distribution_metric
///
/// A multi-line
/// description
pub static memory_distribution_metric: Lazy<MemoryDistributionMetric> = Lazy::new(|| {
MemoryDistributionMetric::new(13.into(), CommonMetricData {
name: "memory_distribution_metric".into(),
category: "test".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
}, MemoryUnit::Kilobyte)
});
}
pub mod test_nested {
use crate::private::*;
use glean::CommonMetricData;
use once_cell::sync::Lazy;
#[allow(non_upper_case_globals)]
/// generated from test.nested.uuid_metric
///
/// A multi-line
/// description
pub static uuid_metric: Lazy<UuidMetric> = Lazy::new(|| {
UuidMetric::new(14.into(), CommonMetricData {
name: "uuid_metric".into(),
category: "test.nested".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
})
});
#[allow(non_upper_case_globals)]
/// generated from test.nested.datetime_metric
///
/// A multi-line
/// description
pub static datetime_metric: Lazy<DatetimeMetric> = Lazy::new(|| {
DatetimeMetric::new(15.into(), CommonMetricData {
name: "datetime_metric".into(),
category: "test.nested".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Application,
disabled: false,
..Default::default()
}, TimeUnit::Millisecond)
});
#[allow(non_upper_case_globals)]
/// generated from test.nested.event_metric
///
/// A multi-line
/// description
pub static event_metric: Lazy<EventMetric<NoExtraKeys>> = Lazy::new(|| {
EventMetric::new(16.into(), CommonMetricData {
name: "event_metric".into(),
category: "test.nested".into(),
send_in_pings: vec!["events".into()],
lifetime: Lifetime::Ping,
disabled: false,
..Default::default()
})
});
#[derive(Default, Debug, Clone, Hash, Eq, PartialEq)]
pub struct EventMetricWithExtraExtra {
pub an_extra_key: Option<String>,
pub another_extra_key: Option<String>,
}
impl ExtraKeys for EventMetricWithExtraExtra {
const ALLOWED_KEYS: &'static [&'static str] = &["an_extra_key", "another_extra_key"];
fn into_ffi_extra(self) -> ::std::collections::HashMap<i32, String> {
let mut map = ::std::collections::HashMap::new();
self.an_extra_key.and_then(|val| map.insert(0, val.to_string()));
self.another_extra_key.and_then(|val| map.insert(1, val.to_string()));
map
}
}
#[allow(non_upper_case_globals)]
/// generated from test.nested.event_metric_with_extra
///
/// A multi-line
/// description
pub static event_metric_with_extra: Lazy<EventMetric<EventMetricWithExtraExtra>> = Lazy::new(|| {
EventMetric::new(17.into(), CommonMetricData {
name: "event_metric_with_extra".into(),
category: "test.nested".into(),
send_in_pings: vec!["events".into()],
lifetime: Lifetime::Ping,
disabled: false,
..Default::default()
})
});
#[allow(non_upper_case_globals)]
/// generated from test.nested.quantity_metric
///
/// A multi-line
/// description
pub static quantity_metric: Lazy<QuantityMetric> = Lazy::new(|| {
QuantityMetric::new(18.into(), CommonMetricData {
name: "quantity_metric".into(),
category: "test.nested".into(),
send_in_pings: vec!["metrics".into()],
lifetime: Lifetime::Ping,
disabled: false,
..Default::default()
})
});
}
#[allow(dead_code)]
pub(crate) mod __glean_metric_maps {
use std::collections::HashMap;
use super::{id_for_extra_key, extra_keys_len};
use crate::private::*;
use once_cell::sync::Lazy;
pub static BOOLEAN_MAP: Lazy<HashMap<MetricId, &Lazy<BooleanMetric>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(1);
map.insert(1.into(), &super::test::boolean_metric);
map
});
pub static LABELED_BOOLEAN_MAP: Lazy<HashMap<MetricId, &Lazy<LabeledMetric<LabeledBooleanMetric>>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(2);
map.insert(2.into(), &super::test::labeled_boolean_metric);
map.insert(3.into(), &super::test::labeled_boolean_metric_labels);
map
});
pub static COUNTER_MAP: Lazy<HashMap<MetricId, &Lazy<CounterMetric>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(1);
map.insert(4.into(), &super::test::counter_metric);
map
});
pub static LABELED_COUNTER_MAP: Lazy<HashMap<MetricId, &Lazy<LabeledMetric<LabeledCounterMetric>>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(2);
map.insert(5.into(), &super::test::labeled_counter_metric);
map.insert(6.into(), &super::test::labeled_counter_metric_labels);
map
});
pub static STRING_MAP: Lazy<HashMap<MetricId, &Lazy<StringMetric>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(1);
map.insert(7.into(), &super::test::string_metric);
map
});
pub static LABELED_STRING_MAP: Lazy<HashMap<MetricId, &Lazy<LabeledMetric<LabeledStringMetric>>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(2);
map.insert(8.into(), &super::test::labeled_string_metric);
map.insert(9.into(), &super::test::labeled_string_metric_labels);
map
});
pub static STRING_LIST_MAP: Lazy<HashMap<MetricId, &Lazy<StringListMetric>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(1);
map.insert(10.into(), &super::test::string_list_metric);
map
});
pub static TIMESPAN_MAP: Lazy<HashMap<MetricId, &Lazy<TimespanMetric>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(1);
map.insert(11.into(), &super::test::timespan_metric);
map
});
pub static TIMING_DISTRIBUTION_MAP: Lazy<HashMap<MetricId, &Lazy<TimingDistributionMetric>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(1);
map.insert(12.into(), &super::test::timing_distribution_metric);
map
});
pub static MEMORY_DISTRIBUTION_MAP: Lazy<HashMap<MetricId, &Lazy<MemoryDistributionMetric>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(1);
map.insert(13.into(), &super::test::memory_distribution_metric);
map
});
pub static UUID_MAP: Lazy<HashMap<MetricId, &Lazy<UuidMetric>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(1);
map.insert(14.into(), &super::test_nested::uuid_metric);
map
});
pub static DATETIME_MAP: Lazy<HashMap<MetricId, &Lazy<DatetimeMetric>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(1);
map.insert(15.into(), &super::test_nested::datetime_metric);
map
});
pub static QUANTITY_MAP: Lazy<HashMap<MetricId, &Lazy<QuantityMetric>>> = Lazy::new(|| {
let mut map = HashMap::with_capacity(1);
map.insert(18.into(), &super::test_nested::quantity_metric);
map
});
/// Wrapper to record an event based on its metric ID.
///
/// # Arguments
///
/// * `metric_id` - The metric's ID to look up
/// * `extra` - An map of (extra key id, string) pairs.
/// The map will be decoded into the appropriate `ExtraKeys` type.
/// # Returns
///
/// Returns `Ok(())` if the event was found and `record` was called with the given `extra`,
/// or an `EventRecordingError::InvalidId` if no event by that ID exists
/// or an `EventRecordingError::InvalidExtraKey` if the `extra` map could not be deserialized.
pub(crate) fn record_event_by_id(metric_id: u32, extra: HashMap<i32, String>) -> Result<(), EventRecordingError> {
match metric_id {
16 => {
assert!(
extra_keys_len(&super::test_nested::event_metric) != 0 || extra.is_empty(),
"No extra keys allowed, but some were passed"
);
super::test_nested::event_metric.record_raw(extra);
Ok(())
}
17 => {
assert!(
extra_keys_len(&super::test_nested::event_metric_with_extra) != 0 || extra.is_empty(),
"No extra keys allowed, but some were passed"
);
super::test_nested::event_metric_with_extra.record_raw(extra);
Ok(())
}
_ => Err(EventRecordingError::InvalidId),
}
}
/// Wrapper to record an event based on its metric ID, with a provided timestamp.
///
/// # Arguments
///
/// * `metric_id` - The metric's ID to look up
/// * `timestamp` - The time at which this event was recorded.
/// * `extra` - An map of (extra key id, string) pairs.
/// The map will be decoded into the appropriate `ExtraKeys` type.
/// # Returns
///
/// Returns `Ok(())` if the event was found and `record` was called with the given `extra`,
/// or an `EventRecordingError::InvalidId` if no event by that ID exists
/// or an `EventRecordingError::InvalidExtraKey` if the event doesn't take extra pairs,
/// but some are passed in.
pub(crate) fn record_event_by_id_with_time(metric_id: MetricId, timestamp: u64, extra: HashMap<i32, String>) -> Result<(), EventRecordingError> {
match metric_id {
MetricId(16) => {
if extra_keys_len(&super::test_nested::event_metric) == 0 && !extra.is_empty() {
return Err(EventRecordingError::InvalidExtraKey);
}
super::test_nested::event_metric.record_with_time(timestamp, extra);
Ok(())
}
MetricId(17) => {
if extra_keys_len(&super::test_nested::event_metric_with_extra) == 0 && !extra.is_empty() {
return Err(EventRecordingError::InvalidExtraKey);
}
super::test_nested::event_metric_with_extra.record_with_time(timestamp, extra);
Ok(())
}
_ => Err(EventRecordingError::InvalidId),
}
}
/// Wrapper to record an event based on its metric ID.
///
/// # Arguments
///
/// * `metric_id` - The metric's ID to look up
/// * `extra` - An map of (string, string) pairs.
/// The map will be decoded into the appropriate `ExtraKeys` types.
/// # Returns
///
/// Returns `Ok(())` if the event was found and `record` was called with the given `extra`,
/// or an `EventRecordingError::InvalidId` if no event by that ID exists
/// or an `EventRecordingError::InvalidExtraKey` if the `extra` map could not be deserialized.
pub(crate) fn record_event_by_id_with_strings(metric_id: u32, extra: HashMap<String, String>) -> Result<(), EventRecordingError> {
match metric_id {
16 => {
assert!(
extra_keys_len(&super::test_nested::event_metric) != 0 || extra.is_empty(),
"No extra keys allowed, but some were passed"
);
let extra = extra
.into_iter()
.map(|(k, v)| id_for_extra_key(&*k, &super::test_nested::event_metric).map(|k| (k, v)))
.collect::<Result<HashMap<_, _>, _>>()?;
super::test_nested::event_metric.record_raw(extra);
Ok(())
}
17 => {
assert!(
extra_keys_len(&super::test_nested::event_metric_with_extra) != 0 || extra.is_empty(),
"No extra keys allowed, but some were passed"
);
let extra = extra
.into_iter()
.map(|(k, v)| id_for_extra_key(&*k, &super::test_nested::event_metric_with_extra).map(|k| (k, v)))
.collect::<Result<HashMap<_, _>, _>>()?;
super::test_nested::event_metric_with_extra.record_raw(extra);
Ok(())
}
_ => Err(EventRecordingError::InvalidId),
}
}
/// Wrapper to get the currently stored events for event metric.
///
/// # Arguments
///
/// * `metric_id` - The metric's ID to look up
/// * `ping_name` - (Optional) The ping name to look into.
/// Defaults to the first value in `send_in_pings`.
///
/// # Returns
///
/// Returns the recorded events or `None` if nothing stored.
///
/// # Panics
///
/// Panics if no event by the given metric ID could be found.
pub(crate) fn event_test_get_value_wrapper(metric_id: u32, ping_name: Option<String>) -> Option<Vec<RecordedEvent>> {
match metric_id {
16 => super::test_nested::event_metric.test_get_value(ping_name.as_deref()),
17 => super::test_nested::event_metric_with_extra.test_get_value(ping_name.as_deref()),
_ => panic!("No event for metric id {}", metric_id),
}
}
pub(crate) mod submetric_maps {
use std::sync::{
atomic::AtomicU32,
RwLock,
};
use super::*;
pub(crate) const MIN_LABELED_SUBMETRIC_ID: u32 = 134217729;
pub(crate) static NEXT_LABELED_SUBMETRIC_ID: AtomicU32 = AtomicU32::new(MIN_LABELED_SUBMETRIC_ID);
pub(crate) static LABELED_METRICS_TO_IDS: Lazy<RwLock<HashMap<(u32, String), u32>>> = Lazy::new(||
RwLock::new(HashMap::new())
);
pub static BOOLEAN_MAP: Lazy<RwLock<HashMap<MetricId, LabeledBooleanMetric>>> = Lazy::new(||
RwLock::new(HashMap::new())
);
pub static COUNTER_MAP: Lazy<RwLock<HashMap<MetricId, LabeledCounterMetric>>> = Lazy::new(||
RwLock::new(HashMap::new())
);
pub static STRING_MAP: Lazy<RwLock<HashMap<MetricId, LabeledStringMetric>>> = Lazy::new(||
RwLock::new(HashMap::new())
);
}
}
Reference in a new issue View git blame Copy permalink