pyroscope 1.0.9 → 1.1.0

data/ext/rbspy/src/backend/types.rs

@@ -0,0 +1,303 @@
+use super::BackendConfig;
+use crate::error::Result;
+use std::{
+    collections::{hash_map::DefaultHasher, BTreeSet, HashMap},
+    hash::{Hash, Hasher},
+};
+
+/// Pyroscope Tag
+#[derive(Debug, PartialOrd, Ord, Eq, PartialEq, Hash, Clone)]
+pub struct Tag {
+    /// Tag key
+    pub key: String,
+    /// Tag value
+    pub value: String,
+}
+
+impl Tag {
+    /// Create a new Tag
+    pub fn new(key: String, value: String) -> Self {
+        Self { key, value }
+    }
+}
+
+impl std::fmt::Display for Tag {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}={}", self.key, self.value)
+    }
+}
+
+/// Stack buffer
+#[derive(Debug, Default, Clone)]
+pub struct StackBuffer {
+    /// Buffer data bucket
+    pub data: HashMap<StackTrace, usize>,
+}
+
+impl StackBuffer {
+    /// Create a new StackBuffer with the given data
+    pub fn new(data: HashMap<StackTrace, usize>) -> Self {
+        Self { data }
+    }
+
+    /// Record a new stack trace
+    pub fn record(&mut self, stack_trace: StackTrace) -> Result<()> {
+        *self.data.entry(stack_trace).or_insert(0) += 1;
+
+        Ok(())
+    }
+
+    /// Record a new stack trace with count
+    pub fn record_with_count(&mut self, stack_trace: StackTrace, count: usize) -> Result<()> {
+        *self.data.entry(stack_trace).or_insert(0) += count;
+
+        Ok(())
+    }
+
+    /// Clear the buffer
+    pub fn clear(&mut self) {
+        self.data.clear();
+    }
+}
+
+impl From<StackBuffer> for Vec<Report> {
+    fn from(stack_buffer: StackBuffer) -> Self {
+        stack_buffer
+            .data
+            .into_iter()
+            .fold(
+                HashMap::new(),
+                |acc: HashMap<usize, Report>, (stacktrace, count): (StackTrace, usize)| {
+                    let mut acc = acc;
+                    if let Some(report) = acc.get_mut(&stacktrace.metadata.get_id()) {
+                        report.record_with_count(stacktrace, count);
+                    } else {
+                        let report = Report::new(HashMap::new());
+                        let report_id = stacktrace.metadata.get_id();
+                        let mut report = report.metadata(stacktrace.metadata.clone());
+                        report.record_with_count(stacktrace, count);
+                        acc.insert(report_id, report);
+                    }
+                    acc
+                },
+            )
+            .into_values()
+            .collect()
+    }
+}
+
+/// Metdata
+/// Metadata attached to a StackTrace or a Report. For now, this is just tags.
+#[derive(Debug, Default, Clone, Hash, PartialEq, Eq)]
+pub struct Metadata {
+    /// Tags
+    pub tags: BTreeSet<Tag>,
+}
+
+impl Metadata {
+    /// Add a tag to the metadata
+    pub fn add_tag(&mut self, tag: Tag) {
+        self.tags.insert(tag);
+    }
+
+    /// Get the id of the metadata. This uses the hash of the Metadata type.
+    pub fn get_id(&self) -> usize {
+        let mut hasher = DefaultHasher::new();
+        self.hash(&mut hasher);
+        hasher.finish() as usize
+    }
+}
+
+/// The payload of a report batch: either structured stack-trace reports
+/// (which will be encoded into pprof by the session layer) or pre-encoded
+/// pprof bytes produced directly by a backend (e.g. jemalloc).
+pub enum ReportData {
+    /// Structured stack-trace reports that must be pprof-encoded before sending.
+    Reports(Vec<Report>),
+    /// Pre-encoded pprof bytes (may already be gzipped). Used by backends
+    /// like jemalloc that produce a complete pprof profile directly.
+    RawPprof(Vec<u8>),
+}
+
+/// A batch of reports with a shared profile type.
+pub struct ReportBatch {
+    /// Profile type name (e.g. "process_cpu", "memory")
+    pub profile_type: String,
+    /// Report data in this batch
+    pub data: ReportData,
+}
+
+/// Report
+#[derive(Debug, Default, Clone)]
+pub struct Report {
+    /// Report StackTraces
+    pub data: HashMap<StackTrace, usize>,
+    /// Metadata
+    pub metadata: Metadata,
+}
+
+/// Custom implementation of the Hash trait for Report.
+/// Only the metadata is hashed.
+impl Hash for Report {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.metadata.hash(state);
+    }
+}
+
+impl Report {
+    /// Create a new Report.
+    pub fn new(data: HashMap<StackTrace, usize>) -> Self {
+        Self {
+            data,
+            metadata: Metadata::default(),
+        }
+    }
+
+    /// Return an iterator over the StackTraces of the Report.
+    pub fn iter(&self) -> impl Iterator<Item = (&StackTrace, &usize)> {
+        self.data.iter()
+    }
+
+    /// Set the metadata of the report.
+    pub fn metadata(self, metadata: Metadata) -> Self {
+        Self {
+            data: self.data,
+            metadata,
+        }
+    }
+
+    pub fn record(&mut self, stack_trace: StackTrace) {
+        *self.data.entry(stack_trace).or_insert(0) += 1;
+    }
+
+    pub fn record_with_count(&mut self, stack_trace: StackTrace, count: usize) {
+        *self.data.entry(stack_trace).or_insert(0) += count;
+    }
+}
+
+/// StackTrace
+/// A representation of a stack trace.
+#[derive(Debug, Default, PartialEq, Eq, Hash, Clone)]
+pub struct StackTrace {
+    /// Process ID
+    pub pid: Option<u32>,
+    /// Thread ID
+    pub thread_id: Option<crate::utils::ThreadId>,
+    /// Thread Name
+    pub thread_name: Option<String>,
+    /// Stack Trace
+    pub frames: Vec<StackFrame>,
+    /// Metadata
+    pub metadata: Metadata,
+}
+
+impl std::fmt::Display for StackTrace {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            &self
+                .frames
+                .iter()
+                .rev()
+                .map(|frame| format!("{frame}"))
+                .collect::<Vec<_>>()
+                .join(";")
+        )
+    }
+}
+
+impl StackTrace {
+    /// Create a new StackTrace
+    pub fn new(
+        config: &BackendConfig,
+        pid: Option<u32>,
+        thread_id: Option<crate::utils::ThreadId>,
+        thread_name: Option<String>,
+        frames: Vec<StackFrame>,
+    ) -> Self {
+        let mut metadata = Metadata::default();
+
+        if config.report_pid {
+            if let Some(pid) = pid {
+                metadata.add_tag(Tag::new("pid".to_owned(), pid.to_string()));
+            }
+        }
+
+        if config.report_thread_id {
+            if let Some(thread_id) = &thread_id {
+                metadata.add_tag(Tag::new("thread_id".to_owned(), thread_id.to_string()));
+            }
+        }
+
+        if config.report_thread_name {
+            if let Some(thread_name) = thread_name.clone() {
+                metadata.add_tag(Tag::new("thread_name".to_owned(), thread_name));
+            }
+        }
+
+        Self {
+            pid,
+            thread_id,
+            thread_name,
+            frames,
+            metadata,
+        }
+    }
+
+    /// Return an iterator over the frames of the stacktrace.
+    pub fn iter(&self) -> impl Iterator<Item = &StackFrame> {
+        self.frames.iter()
+    }
+}
+
+/// StackFrame
+/// A representation of a stack frame.
+#[derive(Debug, Default, PartialEq, Eq, Hash, Clone)]
+pub struct StackFrame {
+    /// Module name
+    pub module: Option<String>,
+    /// Function name
+    pub name: Option<String>,
+    /// File name
+    pub filename: Option<String>,
+    /// File relative path
+    pub relative_path: Option<String>,
+    /// File absolute path
+    pub absolute_path: Option<String>,
+    /// Line number
+    pub line: Option<u32>,
+}
+
+impl StackFrame {
+    /// Create a new StackFrame.
+    pub fn new(
+        module: Option<String>,
+        name: Option<String>,
+        filename: Option<String>,
+        relative_path: Option<String>,
+        absolute_path: Option<String>,
+        line: Option<u32>,
+    ) -> Self {
+        Self {
+            module,
+            name,
+            filename,
+            relative_path,
+            absolute_path,
+            line,
+        }
+    }
+}
+
+impl std::fmt::Display for StackFrame {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}:{} - {}",
+            self.filename.as_ref().unwrap_or(&"".to_string()),
+            self.line.unwrap_or(0),
+            self.name.as_ref().unwrap_or(&"".to_string())
+        )
+    }
+}

data/ext/rbspy/src/encode/gen/google.rs

@@ -0,0 +1,233 @@
+// @generated
+// This file is @generated by prost-build.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Profile {
+    /// A description of the samples associated with each Sample.value.
+    /// For a cpu profile this might be:
+    ///    \[["cpu","nanoseconds"]\] or \[["wall","seconds"]\] or \[["syscall","count"]\]
+    /// For a heap profile, this might be:
+    ///    \[["allocations","count"\], \["space","bytes"]\],
+    /// If one of the values represents the number of events represented
+    /// by the sample, by convention it should be at index 0 and use
+    /// sample_type.unit == "count".
+    #[prost(message, repeated, tag = "1")]
+    pub sample_type: ::prost::alloc::vec::Vec<ValueType>,
+    /// The set of samples recorded in this profile.
+    #[prost(message, repeated, tag = "2")]
+    pub sample: ::prost::alloc::vec::Vec<Sample>,
+    /// Mapping from address ranges to the image/binary/library mapped
+    /// into that address range.  mapping\[0\] will be the main binary.
+    #[prost(message, repeated, tag = "3")]
+    pub mapping: ::prost::alloc::vec::Vec<Mapping>,
+    /// Useful program location
+    #[prost(message, repeated, tag = "4")]
+    pub location: ::prost::alloc::vec::Vec<Location>,
+    /// Functions referenced by locations
+    #[prost(message, repeated, tag = "5")]
+    pub function: ::prost::alloc::vec::Vec<Function>,
+    /// A common table for strings referenced by various messages.
+    /// string_table\[0\] must always be "".
+    #[prost(string, repeated, tag = "6")]
+    pub string_table: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    /// frames with Function.function_name fully matching the following
+    /// regexp will be dropped from the samples, along with their successors.
+    ///
+    /// Index into string table.
+    #[prost(int64, tag = "7")]
+    pub drop_frames: i64,
+    /// frames with Function.function_name fully matching the following
+    /// regexp will be kept, even if it matches drop_frames.
+    ///
+    /// Index into string table.
+    #[prost(int64, tag = "8")]
+    pub keep_frames: i64,
+    // The following fields are informational, do not affect
+    // interpretation of results.
+    /// Time of collection (UTC) represented as nanoseconds past the epoch.
+    #[prost(int64, tag = "9")]
+    pub time_nanos: i64,
+    /// Duration of the profile, if a duration makes sense.
+    #[prost(int64, tag = "10")]
+    pub duration_nanos: i64,
+    /// The kind of events between sampled ocurrences.
+    /// e.g \[ "cpu","cycles" \] or \[ "heap","bytes" \]
+    #[prost(message, optional, tag = "11")]
+    pub period_type: ::core::option::Option<ValueType>,
+    /// The number of events between sampled occurrences.
+    #[prost(int64, tag = "12")]
+    pub period: i64,
+    /// Freeform text associated to the profile.
+    ///
+    /// Indices into string table.
+    #[prost(int64, repeated, tag = "13")]
+    pub comment: ::prost::alloc::vec::Vec<i64>,
+    /// Index into the string table of the type of the preferred sample
+    /// value. If unset, clients should default to the last sample value.
+    #[prost(int64, tag = "14")]
+    pub default_sample_type: i64,
+}
+/// ValueType describes the semantics and measurement units of a value.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct ValueType {
+    /// Index into string table.
+    #[prost(int64, tag = "1")]
+    pub r#type: i64,
+    /// Index into string table.
+    #[prost(int64, tag = "2")]
+    pub unit: i64,
+}
+/// Each Sample records values encountered in some program
+/// context. The program context is typically a stack trace, perhaps
+/// augmented with auxiliary information like the thread-id, some
+/// indicator of a higher level request being handled etc.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Sample {
+    /// The ids recorded here correspond to a Profile.location.id.
+    /// The leaf is at location_id\[0\].
+    #[prost(uint64, repeated, tag = "1")]
+    pub location_id: ::prost::alloc::vec::Vec<u64>,
+    /// The type and unit of each value is defined by the corresponding
+    /// entry in Profile.sample_type. All samples must have the same
+    /// number of values, the same as the length of Profile.sample_type.
+    /// When aggregating multiple samples into a single sample, the
+    /// result has a list of values that is the element-wise sum of the
+    /// lists of the originals.
+    #[prost(int64, repeated, tag = "2")]
+    pub value: ::prost::alloc::vec::Vec<i64>,
+    /// label includes additional context for this sample. It can include
+    /// things like a thread id, allocation size, etc
+    #[prost(message, repeated, tag = "3")]
+    pub label: ::prost::alloc::vec::Vec<Label>,
+}
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct Label {
+    /// Index into string table
+    #[prost(int64, tag = "1")]
+    pub key: i64,
+    /// At most one of the following must be present
+    ///
+    /// Index into string table
+    #[prost(int64, tag = "2")]
+    pub str: i64,
+    #[prost(int64, tag = "3")]
+    pub num: i64,
+    /// Should only be present when num is present.
+    /// Specifies the units of num.
+    /// Use arbitrary string (for example, "requests") as a custom count unit.
+    /// If no unit is specified, consumer may apply heuristic to deduce the unit.
+    /// Consumers may also  interpret units like "bytes" and "kilobytes" as memory
+    /// units and units like "seconds" and "nanoseconds" as time units,
+    /// and apply appropriate unit conversions to these.
+    ///
+    /// Index into string table
+    #[prost(int64, tag = "4")]
+    pub num_unit: i64,
+}
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct Mapping {
+    /// Unique nonzero id for the mapping.
+    #[prost(uint64, tag = "1")]
+    pub id: u64,
+    /// Address at which the binary (or DLL) is loaded into memory.
+    #[prost(uint64, tag = "2")]
+    pub memory_start: u64,
+    /// The limit of the address range occupied by this mapping.
+    #[prost(uint64, tag = "3")]
+    pub memory_limit: u64,
+    /// Offset in the binary that corresponds to the first mapped address.
+    #[prost(uint64, tag = "4")]
+    pub file_offset: u64,
+    /// The object this entry is loaded from.  This can be a filename on
+    /// disk for the main binary and shared libraries, or virtual
+    /// abstractions like "\[vdso\]".
+    ///
+    /// Index into string table
+    #[prost(int64, tag = "5")]
+    pub filename: i64,
+    /// A string that uniquely identifies a particular program version
+    /// with high probability. E.g., for binaries generated by GNU tools,
+    /// it could be the contents of the .note.gnu.build-id field.
+    ///
+    /// Index into string table
+    #[prost(int64, tag = "6")]
+    pub build_id: i64,
+    /// The following fields indicate the resolution of symbolic info.
+    #[prost(bool, tag = "7")]
+    pub has_functions: bool,
+    #[prost(bool, tag = "8")]
+    pub has_filenames: bool,
+    #[prost(bool, tag = "9")]
+    pub has_line_numbers: bool,
+    #[prost(bool, tag = "10")]
+    pub has_inline_frames: bool,
+}
+/// Describes function and line table debug information.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Location {
+    /// Unique nonzero id for the location.  A profile could use
+    /// instruction addresses or any integer sequence as ids.
+    #[prost(uint64, tag = "1")]
+    pub id: u64,
+    /// The id of the corresponding profile.Mapping for this location.
+    /// It can be unset if the mapping is unknown or not applicable for
+    /// this profile type.
+    #[prost(uint64, tag = "2")]
+    pub mapping_id: u64,
+    /// The instruction address for this location, if available.  It
+    /// should be within \[Mapping.memory_start...Mapping.memory_limit\]
+    /// for the corresponding mapping. A non-leaf address may be in the
+    /// middle of a call instruction. It is up to display tools to find
+    /// the beginning of the instruction if necessary.
+    #[prost(uint64, tag = "3")]
+    pub address: u64,
+    /// Multiple line indicates this location has inlined functions,
+    /// where the last entry represents the caller into which the
+    /// preceding entries were inlined.
+    ///
+    /// E.g., if memcpy() is inlined into printf:
+    ///     line\[0\].function_name == "memcpy"
+    ///     line\[1\].function_name == "printf"
+    #[prost(message, repeated, tag = "4")]
+    pub line: ::prost::alloc::vec::Vec<Line>,
+    /// Provides an indication that multiple symbols map to this location's
+    /// address, for example due to identical code folding by the linker. In that
+    /// case the line information above represents one of the multiple
+    /// symbols. This field must be recomputed when the symbolization state of the
+    /// profile changes.
+    #[prost(bool, tag = "5")]
+    pub is_folded: bool,
+}
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct Line {
+    /// The id of the corresponding profile.Function for this line.
+    #[prost(uint64, tag = "1")]
+    pub function_id: u64,
+    /// Line number in source code.
+    #[prost(int64, tag = "2")]
+    pub line: i64,
+}
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct Function {
+    /// Unique nonzero id for the function.
+    #[prost(uint64, tag = "1")]
+    pub id: u64,
+    /// Name of the function, in human-readable form if available.
+    ///
+    /// Index into string table
+    #[prost(int64, tag = "2")]
+    pub name: i64,
+    /// Name of the function, as identified by the system.
+    /// For instance, it can be a C++ mangled name.
+    ///
+    /// Index into string table
+    #[prost(int64, tag = "3")]
+    pub system_name: i64,
+    /// Source file containing the function.
+    ///
+    /// Index into string table
+    #[prost(int64, tag = "4")]
+    pub filename: i64,
+    /// Line number in source file.
+    #[prost(int64, tag = "5")]
+    pub start_line: i64,
+}

data/ext/rbspy/src/encode/gen/mod.rs

@@ -0,0 +1,3 @@
+pub mod google;
+pub mod push;
+pub mod types;

data/ext/rbspy/src/encode/gen/push.rs

@@ -0,0 +1,31 @@
+// @generated
+// This file is @generated by prost-build.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct PushResponse {}
+/// WriteRawRequest writes a pprof profile
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PushRequest {
+    /// series is a set raw pprof profiles and accompanying labels
+    #[prost(message, repeated, tag = "1")]
+    pub series: ::prost::alloc::vec::Vec<RawProfileSeries>,
+}
+/// RawProfileSeries represents the pprof profile and its associated labels
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RawProfileSeries {
+    /// LabelPair is the key value pairs to identify the corresponding profile
+    #[prost(message, repeated, tag = "1")]
+    pub labels: ::prost::alloc::vec::Vec<super::types::LabelPair>,
+    /// samples are the set of profile bytes
+    #[prost(message, repeated, tag = "2")]
+    pub samples: ::prost::alloc::vec::Vec<RawSample>,
+}
+/// RawSample is the set of bytes that correspond to a pprof profile
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct RawSample {
+    /// raw_profile is the set of bytes of the pprof profile
+    #[prost(bytes = "vec", tag = "1")]
+    pub raw_profile: ::prost::alloc::vec::Vec<u8>,
+    /// UUID of the profile
+    #[prost(string, tag = "2")]
+    pub id: ::prost::alloc::string::String,
+}

data/ext/rbspy/src/encode/gen/types.rs

@@ -0,0 +1,11 @@
+// @generated
+// This file is @generated by prost-build.
+#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
+pub struct LabelPair {
+    /// Label name
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    /// Label value
+    #[prost(string, tag = "2")]
+    pub value: ::prost::alloc::string::String,
+}

data/ext/rbspy/src/encode/mod.rs

@@ -0,0 +1,2 @@
+pub mod gen;
+pub mod pprof;