Add benchmarking feature in order to re-export pub(crate) function to benches.

Author: hoolioh

benchmark/run_benchmarks_ci.sh

@@ -22,7 +22,7 @@ pushd "${PROJECT_DIR}" > /dev/null
 
 # Run benchmarks
 message "Running benchmarks"
-cargo bench --workspace -- --warm-up-time 1 --measurement-time 5 --sample-size=200
+cargo bench --workspace --features datadog-crashtracker/benchmarking -- --warm-up-time 1 --measurement-time 5 --sample-size=200
 message "Finished running benchmarks"
 
 # Copy the benchmark results to the output directory

datadog-crashtracker/Cargo.toml

@@ -6,19 +6,21 @@ edition.workspace = true
 version.workspace = true
 rust-version.workspace = true
 license.workspace = true
+autobenches = false
 
 [lib]
 crate-type = ["lib"]
-bench = true
+bench = false
 
 [[bin]]
 name = "crashtracker-receiver"
 path = "src/bin/crashtracker_receiver.rs"
 bench = false
 
 [[bench]]
-name = "receiver_bench"
+name = "main"
 harness = false
+path = "benches/main.rs"
 
 [features]
 default = ["collector", "receiver", "collector_windows"]
@@ -64,7 +66,7 @@ thiserror = "1.0"
 windows = { version = "0.59.0", features = ["Win32_System_Diagnostics_Debug", "Win32_System_Diagnostics_ToolHelp", "Win32_System_ErrorReporting", "Win32_System_Kernel", "Win32_System_ProcessStatus", "Win32_System_Registry", "Win32_System_SystemInformation", "Win32_System_SystemServices", "Win32_System_Threading", "Win32_Security"] }
 
 [dev-dependencies]
-criterion = { version = "0.5.1", features = ["html_reports"] }
+criterion = { version = "0.5.1" }
 goblin = "0.9.3"
 tempfile = { version = "3.3" }
 

datadog-crashtracker/benches/main.rs

@@ -1,14 +1,21 @@
 // Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
-#[cfg(feature = "benchmarking")]
-use criterion::criterion_main;
+use criterion::{criterion_main, criterion_group, Criterion};
 
 #[cfg(feature = "benchmarking")]
 mod receiver_bench;
 
 #[cfg(feature = "benchmarking")]
-use datadog_crashtracker::receiver_entry_point_bench as receiver_entry_point;
+fn active_benches(c: &mut Criterion) {
+    receiver_bench::benches();
+}
 
-#[cfg(feature = "benchmarking")]
-criterion_main!(receiver_bench::benches);
+#[cfg(not(feature = "benchmarking"))]
+fn active_benches(_: &mut Criterion) {
+    println!(
+        "Benchmarks are disabled. Enable with `--features datadog-crashtracker/benchmarking`."
+    );
+}
+criterion_group!(benches, active_benches);
+criterion_main!(benches);

datadog-crashtracker/benches/receiver_bench.rs

@@ -2,138 +2,44 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use criterion::{black_box, criterion_group, BenchmarkId, Criterion, Throughput};
-#[cfg(feature = "benchmarking")]
-use datadog_crashtracker::receiver_entry_point_bench;
-use datadog_crashtracker::{CrashtrackerConfiguration, CrashtrackerReceiverConfig};
+use datadog_crashtracker::benchmark::receiver_entry_point;
 use std::time::Duration;
 use tokio::io::BufReader;
 
-fn create_mock_crash_report() -> String {
-    r#"DD_CRASHTRACK_BEGIN_CONFIG
-{"resolve_frames": "Disabled","demangle_names": true,"path_replacements": [], "additional_files": []}
-DD_CRASHTRACK_END_CONFIG
-DD_CRASHTRACK_BEGIN_PROC_INFO
-{"pid": 12345, "signal": 6}
-DD_CRASHTRACK_END_PROC_INFO
-DD_CRASHTRACK_BEGIN_SIG_INFO
-{"sig": 6, "errno": 0, "addr": "0x0"}
-DD_CRASHTRACK_END_SIG_INFO
-DD_CRASHTRACK_BEGIN_METADATA
-["log1", "log2", "log3"]
-DD_CRASHTRACK_END_METADATA
-DD_CRASHTRACK_BEGIN_STACKTRACE
-[{"ip": "0x7f8b8c0d1234", "sp": "0x7f8b8c0d5678", "symbol_address": "0x7f8b8c0d0000", "module_base_address": "0x7f8b8c0d0000", "module": "test_module"}]
-DD_CRASHTRACK_END_STACKTRACE
-DD_CRASHTRACK_DONE"#.to_string()
-}
 
-fn create_mock_simple_crash_report() -> String {
+fn create_dummy_crash_report() -> String {
     r#"DD_CRASHTRACK_BEGIN_STACKTRACE
 { "ip": "0x42", "module_address": "0x21", "sp": "0x11", "symbol_address": "0x73" }
 DD_CRASHTRACK_END_STACKTRACE
 DD_CRASHTRACK_DONE"#.to_string()
 }
 
-fn create_empty_report() -> String {
-    "DD_CRASHTRACK_BEGIN_CONFIG\nDD_CRASHTRACK_FINISHED\n".to_string()
-}
-
-async fn bench_receiver_entry_point_valid(data: &str) {
+async fn bench_receiver_entry_point_from_str(data: &str) {
     let cursor = std::io::Cursor::new(data.as_bytes());
     let reader = BufReader::new(cursor);
     let timeout = Duration::from_millis(5000);
 
-    let _ = receiver_entry_point_bench(timeout, reader).await;
+    let _ = receiver_entry_point(timeout, reader).await;
 }
 
-async fn bench_receiver_entry_point_invalid(data: &str) {
-    let cursor = std::io::Cursor::new(data.as_bytes());
-    let reader = BufReader::new(cursor);
-    let timeout = Duration::from_millis(5000);
-    
-    let _ = receiver_entry_point_bench(timeout, reader).await;
-}
-
-fn receiver_entry_point_benchmarks(c: &mut Criterion) {
+pub fn receiver_entry_point_benchmarks(c: &mut Criterion) {
     let mut group = c.benchmark_group("receiver_entry_point");
 
-    let valid_report = create_mock_crash_report();
-    group.throughput(Throughput::Bytes(valid_report.len() as u64));
+    let report = create_dummy_crash_report();
+    group.throughput(Throughput::Bytes(report.len() as u64));
     group.bench_with_input(
-        BenchmarkId::new("valid_report", valid_report.len()),
-        &valid_report,
+        BenchmarkId::new("report", report.len()),
+        &report,
         |b, data| {
             b.iter(|| {
                 let rt = tokio::runtime::Builder::new_current_thread()
                     .enable_all()
                     .build()
                     .unwrap();
-                rt.block_on(bench_receiver_entry_point_valid(black_box(data)))
+                rt.block_on(bench_receiver_entry_point_from_str(black_box(data)))
             });
         },
     );
-
-    group.finish();
-}
-
-fn receiver_entry_point_memory_benchmarks(c: &mut Criterion) {
-    let mut group = c.benchmark_group("receiver_entry_point_memory");
-    
-    // Benchmark with varying sizes of crash reports
-    for size_multiplier in [1, 10, 100].iter() {
-        let mut large_report = create_mock_crash_report();
-        
-        // Create a larger stacktrace section
-        let mut large_stacktrace = String::new();
-        large_stacktrace.push_str("DD_CRASHTRACK_BEGIN_STACKTRACE\n");
-        large_stacktrace.push('[');
-        
-        for i in 0..*size_multiplier {
-            if i > 0 {
-                large_stacktrace.push(',');
-            }
-            large_stacktrace.push_str(&format!(
-                r#"{{"ip": "0x7f8b8c0d{:04x}", "sp": "0x7f8b8c0d{:04x}", "symbol_address": "0x7f8b8c0d0000", "module_base_address": "0x7f8b8c0d0000", "module": "test_module_{}"}}"#,
-                i, i + 1000, i
-            ));
-        }
-        
-        large_stacktrace.push_str("]\nDD_CRASHTRACK_END_STACKTRACE\nDD_CRASHTRACK_FINISHED\n");
-        
-        // Replace the stacktrace section in the report
-        let begin_idx = large_report.find("DD_CRASHTRACK_BEGIN_STACKTRACE").unwrap();
-        let end_idx = large_report.find("DD_CRASHTRACK_FINISHED").unwrap() + "DD_CRASHTRACK_FINISHED".len();
-        large_report.replace_range(begin_idx..end_idx, &large_stacktrace);
-        
-        group.throughput(Throughput::Bytes(large_report.len() as u64));
-        group.bench_with_input(
-            BenchmarkId::new("large_report", size_multiplier),
-            &large_report,
-            |b, data| {
-                b.iter(|| {
-                    let rt = tokio::runtime::Builder::new_current_thread()
-                        .enable_all()
-                        .build()
-                        .unwrap();
-                    rt.block_on(async {
-                        let cursor = std::io::Cursor::new(data.as_bytes());
-                        let reader = BufReader::new(cursor);
-                        let timeout = Duration::from_millis(5000);
-                        
-                        let _ = receiver_entry_point_bench(black_box(timeout), black_box(reader)).await;
-                    })
-                });
-            },
-        );
-    }
-    
-    group.finish();
 }
 
-criterion_group!(
-    benches,
-    receiver_entry_point_benchmarks,
-    // receiver_entry_point_memory_benchmarks
-);
-
-criterion::criterion_main!(benches);
+criterion_group!(benches, receiver_entry_point_benchmarks);

datadog-crashtracker/src/lib.rs

@@ -85,4 +85,4 @@ pub use shared::configuration::{
 };
 
 #[cfg(all(unix, feature = "benchmarking"))]
-pub use receiver::benchmark::receiver_entry_point_bench;
+pub use receiver::benchmark;

datadog-crashtracker/src/receiver/benchmark.rs

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
+
+use std::time::Duration;
+use tokio::{
+    io::{AsyncBufReadExt},
+};
+
+pub async fn receiver_entry_point(
+    timeout: Duration,
+    stream: impl AsyncBufReadExt + std::marker::Unpin,
+) -> anyhow::Result<()> {
+    crate::receiver::entry_points::receiver_entry_point(timeout, stream).await
+}

datadog-crashtracker/src/receiver/entry_points.rs

@@ -1,5 +1,5 @@
-// Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
+// Copyright 2023-Present Datadog, Inc. https://www.datadoghq.com/
 
 use super::receive_report::receive_report_from_stream;
 use crate::{crash_info::CrashInfo, CrashtrackerConfiguration, StacktraceCollection};
@@ -85,14 +85,6 @@ pub fn get_receiver_unix_socket(socket_path: impl AsRef<str>) -> anyhow::Result<
     unix_listener.context("Could not create the unix socket")
 }
 
-#[cfg(feature = "benchmarking")]
-pub async fn receiver_entry_point_bench(
-    timeout: Duration,
-    stream: impl AsyncBufReadExt + std::marker::Unpin,
-) -> anyhow::Result<()> {
-    receiver_entry_point(timeout, stream).await
-}
-
 /// Receives data from a crash collector via a stream, formats it into
 /// `CrashInfo` json, and emits it to the endpoint/file defined in `config`.
 ///
@@ -102,7 +94,7 @@ pub async fn receiver_entry_point_bench(
 ///
 /// See comments in [datadog-crashtracker/lib.rs] for a full architecture
 /// description.
-async fn receiver_entry_point(
+pub(crate) async fn receiver_entry_point(
     timeout: Duration,
     stream: impl AsyncBufReadExt + std::marker::Unpin,
 ) -> anyhow::Result<()> {

datadog-crashtracker/src/receiver/mod.rs

@@ -10,9 +10,7 @@ pub use entry_points::{
 mod receive_report;
 
 #[cfg(feature = "benchmarking")]
-pub mod benchmark {
-    pub use super::entry_points::receiver_entry_point_bench;
-}
+pub mod benchmark;
 
 #[cfg(test)]
 mod tests {