Benchmark: delay ping lifetime IO

Author: badboy

glean-core/benchmark/Cargo.toml

@@ -13,7 +13,7 @@ rust-version = "1.87"
 
 [dependencies]
 glean-core = { path = "../", features = ["benchmark"] }
-criterion = "0.8.0"
+criterion = { version = "0.8.0", features = ["html_reports"] }
 tempfile = "3.8.0"
 gungraun = { version = "0.17.0", features = ["cachegrind"], optional = true }
 
@@ -27,6 +27,10 @@ bench = false
 name = "dispatcher"
 harness = false
 
+[[bench]]
+name = "lifetime_buffering"
+harness = false
+
 [[bench]]
 name = "instruction-count"
 harness = false

glean-core/benchmark/benches/lifetime_buffering.rs

@@ -0,0 +1,143 @@
+// 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 https://mozilla.org/MPL/2.0/.
+
+//! Benchmark the impact of `delay_ping_lifetime_io` and automatic flushing on the overall performance.
+
+use criterion::{Criterion, criterion_group, criterion_main};
+use glean_core::{CommonMetricData, CounterMetric, Glean, Lifetime};
+
+pub fn delay_io_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("IO delay");
+
+    {
+        let dir = tempfile::tempdir().unwrap();
+        let data_path = dir.path().display().to_string();
+        let cfg = glean_core::InternalConfiguration {
+            upload_enabled: true,
+            data_path,
+            application_id: String::from("glean-bench"),
+            language_binding_name: String::from("rust"),
+            max_events: None,
+            delay_ping_lifetime_io: false,
+            app_build: String::from("1"),
+            use_core_mps: true,
+            trim_data_to_registered_pings: true,
+            log_level: None,
+            rate_limit: None,
+            enable_event_timestamps: true,
+            experimentation_id: None,
+            enable_internal_pings: true,
+            ping_schedule: Default::default(),
+            ping_lifetime_threshold: 0,
+            ping_lifetime_max_time: 0,
+        };
+        let glean = Glean::new(cfg).unwrap();
+
+        let metric = CounterMetric::new(CommonMetricData {
+            name: "counter".into(),
+            category: "telemetry".into(),
+            send_in_pings: vec!["baseline".into()],
+            disabled: false,
+            lifetime: Lifetime::Ping,
+            ..Default::default()
+        });
+
+        group.bench_function("no delay", |b| {
+            b.iter(|| {
+                metric.add_sync(&glean, 1);
+            })
+        });
+
+        assert!(metric.get_value(&glean, None).is_some());
+    }
+
+    {
+        let dir = tempfile::tempdir().unwrap();
+        let data_path = dir.path().display().to_string();
+        let cfg = glean_core::InternalConfiguration {
+            upload_enabled: true,
+            data_path,
+            application_id: String::from("glean-bench"),
+            language_binding_name: String::from("rust"),
+            max_events: None,
+            delay_ping_lifetime_io: true,
+            app_build: String::from("1"),
+            use_core_mps: true,
+            trim_data_to_registered_pings: true,
+            log_level: None,
+            rate_limit: None,
+            enable_event_timestamps: true,
+            experimentation_id: None,
+            enable_internal_pings: true,
+            ping_schedule: Default::default(),
+            ping_lifetime_threshold: 0,
+            ping_lifetime_max_time: 0,
+        };
+        let glean = Glean::new(cfg).unwrap();
+
+        let metric = CounterMetric::new(CommonMetricData {
+            name: "counter".into(),
+            category: "telemetry".into(),
+            send_in_pings: vec!["baseline".into()],
+            disabled: false,
+            lifetime: Lifetime::Ping,
+            ..Default::default()
+        });
+
+        group.bench_function("delayed - no flush", |b| {
+            b.iter(|| {
+                metric.add_sync(&glean, 1);
+            })
+        });
+
+        assert!(metric.get_value(&glean, None).is_some());
+    }
+
+    {
+        let dir = tempfile::tempdir().unwrap();
+        let data_path = dir.path().display().to_string();
+        let cfg = glean_core::InternalConfiguration {
+            upload_enabled: true,
+            data_path,
+            application_id: String::from("glean-bench"),
+            language_binding_name: String::from("rust"),
+            max_events: None,
+            delay_ping_lifetime_io: true,
+            app_build: String::from("1"),
+            use_core_mps: true,
+            trim_data_to_registered_pings: true,
+            log_level: None,
+            rate_limit: None,
+            enable_event_timestamps: true,
+            experimentation_id: None,
+            enable_internal_pings: true,
+            ping_schedule: Default::default(),
+            ping_lifetime_threshold: 1000,
+            ping_lifetime_max_time: 0,
+        };
+        let glean = Glean::new(cfg).unwrap();
+
+        let metric = CounterMetric::new(CommonMetricData {
+            name: "counter".into(),
+            category: "telemetry".into(),
+            send_in_pings: vec!["baseline".into()],
+            disabled: false,
+            lifetime: Lifetime::Ping,
+            ..Default::default()
+        });
+
+        group.bench_function("delayed - flushed after 1000", |b| {
+            b.iter(|| {
+                metric.add_sync(&glean, 1);
+            })
+        });
+
+        assert!(metric.get_value(&glean, None).is_some());
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, delay_io_benchmark);
+criterion_main!(benches);