Avoid some string clones when serializing response JSON.

Author: mstange

samply-api/src/hex.rs

@@ -6,20 +6,6 @@ where
     serializer.collect_str(&format_args!("{field:#x}"))
 }
 
-pub fn as_optional_hex_string<S, T>(
-    field: &Option<T>,
-    serializer: S,
-) -> std::result::Result<S::Ok, S::Error>
-where
-    S: serde::Serializer,
-    T: std::fmt::LowerHex,
-{
-    match field {
-        Some(field) => serializer.collect_str(&format_args!("{field:#x}")),
-        None => serializer.serialize_none(),
-    }
-}
-
 pub fn from_prefixed_hex_str<'de, D>(deserializer: D) -> Result<u32, D::Error>
 where
     D: serde::Deserializer<'de>,

samply-api/src/symbolicate/mod.rs

@@ -1,19 +1,17 @@
 use std::collections::HashMap;
-use std::num::NonZeroU32;
 
 use samply_symbols::{
     FileAndPathHelper, FramesLookupResult, LibraryInfo, LookupAddress, SymbolManager,
 };
 
-use crate::api_file_path::to_api_file_path;
 use crate::error::Error;
 use crate::to_debug_id;
 
 pub mod looked_up_addresses;
 pub mod request_json;
 pub mod response_json;
 
-use looked_up_addresses::{AddressResults, LookedUpAddresses};
+use looked_up_addresses::LookedUpAddresses;
 use request_json::Lib;
 use serde_json::json;
 
@@ -36,15 +34,15 @@ impl<'a, H: FileAndPathHelper> SymbolicateApi<'a, H> {
 
     pub async fn query_api_fallible_json(&self, request_json: &str) -> Result<String, Error> {
         let request: request_json::Request = serde_json::from_str(request_json)?;
-        let response = self.query_api(&request).await?;
+        let response = self.query_api(request).await?;
         Ok(serde_json::to_string(&response)?)
     }
 
     pub async fn query_api(
         &self,
-        request: &request_json::Request,
+        request: request_json::Request,
     ) -> Result<response_json::Response, Error> {
-        let requested_addresses = gather_requested_addresses(request)?;
+        let requested_addresses = gather_requested_addresses(&request)?;
         let symbolicated_addresses = self
             .symbolicate_requested_addresses(requested_addresses)
             .await;
@@ -157,111 +155,13 @@ fn gather_requested_addresses(
 }
 
 fn create_response(
-    request: &request_json::Request,
+    request: request_json::Request,
     symbolicated_addresses: HashMap<Lib, Result<LookedUpAddresses, samply_symbols::Error>>,
 ) -> response_json::Response {
-    use response_json::{DebugInfo, FrameDebugInfo, Response, Stack, StackFrame, Symbol};
+    use response_json::{Response, Results};
 
-    fn result_for_job(
-        job: &request_json::Job,
-        symbolicated_addresses: &HashMap<Lib, Result<LookedUpAddresses, samply_symbols::Error>>,
-    ) -> response_json::Result {
-        let mut found_modules = HashMap::new();
-        let mut module_errors = HashMap::new();
-        let mut symbols_by_module_index = HashMap::new();
-        for (module_index, lib) in job.memory_map.iter().enumerate() {
-            if let Some(symbol_result) = symbolicated_addresses.get(lib) {
-                let module_key = format!("{}/{}", lib.debug_name, lib.breakpad_id);
-                match symbol_result {
-                    Ok(symbols) => {
-                        symbols_by_module_index
-                            .insert(module_index as u32, &symbols.address_results);
-                    }
-                    Err(err) => {
-                        module_errors.insert(module_key.clone(), vec![err.into()]);
-                    }
-                }
-                found_modules.insert(module_key, symbol_result.is_ok());
-            }
-        }
-
-        let stacks = job.stacks.iter().map(|stack| {
-            response_stack_for_request_stack(stack, &job.memory_map, &symbols_by_module_index)
-        });
-
-        response_json::Result {
-            stacks: stacks.collect(),
-            found_modules,
-            module_errors,
-        }
-    }
-
-    fn response_stack_for_request_stack(
-        stack: &request_json::Stack,
-        memory_map: &[Lib],
-        symbols_by_module_index: &HashMap<u32, &AddressResults>,
-    ) -> Stack {
-        let frames = stack.0.iter().enumerate().map(|(frame_index, frame)| {
-            response_frame_for_request_frame(
-                frame,
-                frame_index as u32,
-                memory_map,
-                symbols_by_module_index,
-            )
-        });
-        Stack(frames.collect())
-    }
-
-    fn response_frame_for_request_frame(
-        frame: &request_json::StackFrame,
-        frame_index: u32,
-        memory_map: &[Lib],
-        symbols_by_module_index: &HashMap<u32, &AddressResults>,
-    ) -> StackFrame {
-        let symbol = symbols_by_module_index
-            .get(&frame.module_index)
-            .and_then(|symbol_map| {
-                // If we have a symbol table for this library, then we know that
-                // this address is present in it.
-                symbol_map
-                    .get(&frame.address)
-                    .unwrap()
-                    .as_ref()
-                    .map(|address_result| Symbol {
-                        function: address_result.symbol_name.clone(),
-                        function_offset: frame.address - address_result.symbol_address,
-                        function_size: address_result.function_size,
-                        debug_info: address_result.inline_frames.as_ref().map(|frames| {
-                            let (outer, inlines) = frames
-                                .split_last()
-                                .expect("inline_frames should always have at least one element");
-                            DebugInfo {
-                                file: outer.file_path.as_ref().map(to_api_file_path),
-                                line: outer.line_number.and_then(NonZeroU32::new),
-                                inlines: inlines
-                                    .iter()
-                                    .map(|inline_frame| FrameDebugInfo {
-                                        function: inline_frame.function.clone(),
-                                        file: inline_frame.file_path.as_ref().map(to_api_file_path),
-                                        line: inline_frame.line_number.and_then(NonZeroU32::new),
-                                    })
-                                    .collect(),
-                            }
-                        }),
-                    })
-            });
-        StackFrame {
-            frame: frame_index,
-            module_offset: frame.address,
-            module: memory_map[frame.module_index as usize].debug_name.clone(),
-            symbol,
-        }
-    }
-
-    Response {
-        results: request
-            .jobs()
-            .map(|job| result_for_job(job, &symbolicated_addresses))
-            .collect(),
-    }
+    Response(Results {
+        request,
+        symbolicated_addresses,
+    })
 }

samply-api/src/symbolicate/request_json.rs

@@ -20,7 +20,7 @@ impl Request {
 #[serde(rename_all = "camelCase")]
 pub struct Job {
     pub memory_map: Vec<Lib>,
-    pub stacks: Vec<Stack>,
+    pub stacks: Vec<RequestStack>,
 }
 
 #[derive(Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
@@ -30,10 +30,10 @@ pub struct Lib {
 }
 
 #[derive(Deserialize, Debug)]
-pub struct Stack(pub Vec<StackFrame>);
+pub struct RequestStack(pub Vec<RequestFrame>);
 
 #[derive(Deserialize, Debug)]
-pub struct StackFrame {
+pub struct RequestFrame {
     /// index into memory_map
     pub module_index: u32,
     /// lib-relative memory offset