Generate benchmark scenario

Author: gleocadie

datadog-crashtracker/Cargo.toml

@@ -32,7 +32,7 @@ receiver = []
 collector_windows = []
 generate-unit-test-files = []
 # Enables benchmark functionality
-benchmarking = []
+benchmarking = ["generate-unit-test-files"]
 
 [target.'cfg(unix)'.dependencies]
 # Should be kept in sync with the libdatadog symbolizer crate (also using blasesym)

datadog-crashtracker/benches/receiver_bench.rs

@@ -3,15 +3,163 @@
 
 use criterion::{black_box, criterion_group, BenchmarkId, Criterion};
 use datadog_crashtracker::benchmark::receiver_entry_point;
+use libc::c_void;
+use std::ffi::CString;
+use std::fmt::Write;
+use std::path::Path;
+use std::path::PathBuf;
 use std::time::Duration;
 use tokio::io::BufReader;
 
-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()
+struct SharedLibrary {
+    handle: *mut c_void,
+}
+
+impl SharedLibrary {
+    fn open(lib_path: &str) -> Result<Self, String> {
+        let cstr = CString::new(lib_path).map_err(|e| e.to_string())?;
+        // Use RTLD_NOW or another flag
+        let handle = unsafe { libc::dlopen(cstr.as_ptr(), libc::RTLD_NOW) };
+        if handle.is_null() {
+            Err("Failed to open library".to_string())
+        } else {
+            Ok(Self { handle })
+        }
+    }
+
+    fn get_symbol_address(&self, symbol: &str) -> Result<String, String> {
+        let cstr = CString::new(symbol).map_err(|e| e.to_string())?;
+        let sym = unsafe { libc::dlsym(self.handle, cstr.as_ptr()) };
+        if sym.is_null() {
+            Err(format!("Failed to find symbol: {}", symbol))
+        } else {
+            Ok(format!("{:p}", sym))
+        }
+    }
+}
+
+impl Drop for SharedLibrary {
+    fn drop(&mut self) {
+        if !self.handle.is_null() {
+            unsafe { libc::dlclose(self.handle) };
+        }
+    }
+}
+
+fn get_data_folder_path() -> PathBuf {
+    Path::new(&env!("CARGO_MANIFEST_DIR"))
+        .join("data")
+        .canonicalize()
+        .expect("Failed to canonicalize base path for libtest")
+}
+
+macro_rules! add_frame {
+    ($report:expr, $fn:expr, $lib:expr) => {
+        add_frame!($report, $lib.get_symbol_address($fn).unwrap().as_str());
+    };
+    ($report:expr, $address:expr) => {
+        writeln!(
+            $report,
+            "{{ \"ip\": \"{}\", \"module_address\": \"0x21\", \"sp\": \"0x11\" }}",
+            $address
+        )
+        .expect("Failed to write frame");
+    };
+}
+
+fn add_proc_info(report: &mut String) {
+    report.push_str("DD_CRASHTRACK_BEGIN_PROCESSINFO\n");
+    writeln!(report, "{{ \"pid\": {} }}", std::process::id()).expect("Failed to write PID");
+    report.push_str("DD_CRASHTRACK_END_PROCESSINFO\n");
+}
+
+fn add_config(report: &mut String) {
+    report.push_str("DD_CRASHTRACK_BEGIN_CONFIG\n");
+    report.push_str("{\"additional_files\":[],\"create_alt_stack\":true,\"demangle_names\":true,\"endpoint\":null,\"resolve_frames\":\"EnabledWithSymbolsInReceiver\",\"signals\":[4,6,7,11],\"timeout\":{\"secs\":10,\"nanos\":0},\"unix_socket_path\":\"\",\"use_alt_stack\":true}\n");
+    report.push_str("DD_CRASHTRACK_END_CONFIG\n");
+}
+
+fn add_stacktrace(report: &mut String, test_cpp_so: &SharedLibrary, test_c_so: &SharedLibrary) {
+    report.push_str("DD_CRASHTRACK_BEGIN_STACKTRACE\n");
+
+    add_frame!(report, "my_function", test_c_so);
+    add_frame!(report, "func1", test_c_so);
+    add_frame!(report, "func2", test_c_so);
+    add_frame!(report, "0x01");
+    add_frame!(report, "0x02");
+    add_frame!(report, "_Z12cpp_functionv", test_cpp_so);
+    add_frame!(
+        report,
+        "_ZN10FirstClass10InnerClass12InnerMethod1Ev",
+        test_cpp_so
+    );
+    add_frame!(
+        report,
+        "_ZN10FirstClass10InnerClass12InnerMethod2Ev",
+        test_cpp_so
+    );
+    add_frame!(report, "0x03");
+    add_frame!(report, "0x03");
+    add_frame!(report, "0x05");
+    add_frame!(report, "func3", test_c_so);
+    add_frame!(report, "_ZN10FirstClass7Method1Ev", test_cpp_so);
+    add_frame!(report, "func4", test_c_so);
+    add_frame!(
+        report,
+        "_ZN10FirstClass7Method2EibNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE",
+        test_cpp_so
+    );
+    add_frame!(report, "0x06");
+    add_frame!(report, "func5", test_c_so);
+    add_frame!(report, "func6", test_c_so);
+    add_frame!(
+        report,
+        "_ZN11MyNamespace16ClassInNamespace18MethodInNamespace1Efx",
+        test_cpp_so
+    );
+    add_frame!(report, "0x07");
+    add_frame!(
+        report,
+        "_ZN11MyNamespace16ClassInNamespace18MethodInNamespace2Edc",
+        test_cpp_so
+    );
+    add_frame!(report, "0x08");
+    add_frame!(report, "func6", test_c_so);
+    add_frame!(report, "0x09");
+    add_frame!(
+        report,
+        "_ZN11MyNamespace16ClassInNamespace21InnerClassInNamespace12InnerMethod1Ev",
+        test_cpp_so
+    );
+    add_frame!(report, "0x0A");
+    add_frame!(
+        report,
+        "_ZN11MyNamespace16ClassInNamespace21InnerClassInNamespace12InnerMethod2Eiix",
+        test_cpp_so
+    );
+    add_frame!(report, "0x0B");
+    add_frame!(report, "func7", test_c_so);
+    add_frame!(report, "func8", test_c_so);
+    add_frame!(
+        report,
+        "_ZN11MyNamespace16ClassInNamespace21InnerClassInNamespace12InnerMethod2Eiix",
+        test_cpp_so
+    );
+    add_frame!(report, "func9", test_c_so);
+    add_frame!(report, "func10", test_c_so);
+    add_frame!(report, "0x00");
+
+    report.push_str("DD_CRASHTRACK_END_STACKTRACE\n");
+}
+
+fn create_crash_report(test_cpp_so: &SharedLibrary, test_c_so: &SharedLibrary) -> String {
+    // Manual test revealed that the report size was arount 3000 bytes
+    let mut report = String::with_capacity(3000);
+    add_proc_info(&mut report);
+    add_config(&mut report);
+    add_stacktrace(&mut report, test_cpp_so, test_c_so);
+    report.push_str("DD_CRASHTRACK_DONE\n");
+    report
 }
 
 async fn bench_receiver_entry_point_from_str(data: &str) {
@@ -22,10 +170,29 @@ async fn bench_receiver_entry_point_from_str(data: &str) {
     let _ = receiver_entry_point(timeout, reader).await;
 }
 
+fn load_test_libraries() -> (SharedLibrary, SharedLibrary) {
+    let sofile_c_path = get_data_folder_path()
+        .join("libtest.so")
+        .canonicalize()
+        .unwrap();
+
+    let sofile_cpp_path = get_data_folder_path()
+        .join("libtest_cpp.so")
+        .canonicalize()
+        .unwrap();
+
+    let test_c_so = SharedLibrary::open(sofile_c_path.to_str().unwrap()).unwrap();
+    let test_cpp_so = SharedLibrary::open(sofile_cpp_path.to_str().unwrap()).unwrap();
+    (test_cpp_so, test_c_so)
+}
+
 pub fn receiver_entry_point_benchmarks(c: &mut Criterion) {
     let mut group = c.benchmark_group("receiver_entry_point");
 
-    let report = create_dummy_crash_report();
+    // the libraries must be opened as long as the benchmark is running
+    // That why we pass them as references
+    let (sofile_cpp, sofile_c) = load_test_libraries();
+    let report = create_crash_report(&sofile_cpp, &sofile_c);
     group.bench_with_input(
         BenchmarkId::new("report", report.len()),
         &report,

datadog-crashtracker/src/receiver/entry_points.rs

@@ -111,6 +111,7 @@ pub(crate) async fn receiver_entry_point(
                     .push(format!("Error demangling names: {e}"));
             }
         }
+        //println!("---- upload crash info {:?}", crash_info);
         crash_info
             .async_upload_to_endpoint(config.endpoint())
             .await?;