Struct Sample 

pub struct Sample<'a> {
    pub location_ids: Record<&'a [u64], 1, NO_OPT_ZERO>,
    pub values: Record<&'a [i64], 2, NO_OPT_ZERO>,
    pub labels: &'a [Record<Label, 3, NO_OPT_ZERO>],
}

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.

It borrows its data but requires it to be a slice. An iterator wouldn’t work well because we have to walk over the fields twice: one to calculate the length, and one to encode it.

Fields

location_ids: Record<&'a [u64], 1, NO_OPT_ZERO>

The ids recorded here correspond to a Profile.location.id. The leaf is at location_id[0].

values: Record<&'a [i64], 2, NO_OPT_ZERO>

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 original lists.

labels: &'a [Record<Label, 3, NO_OPT_ZERO>]

NOTE: While possible, having multiple values for the same label key is strongly discouraged and should never be used. Most tools (e.g. pprof) do not have good (or any) support for multi-value labels. And an even more discouraged case is having a string label and a numeric label of the same name on a sample. Again, possible to express, but should not be used.

Trait Implementations

impl<'a> Clone for Sample<'a>

fn clone(&self) -> Sample<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Sample<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for Sample<'a>

fn default() -> Sample<'a>

Returns the “default value” for a type.

impl<'a> PartialEq for Sample<'a>

fn eq(&self, other: &Sample<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Value for Sample<'_>

Safety

The Default implementation will return all zero-representations.

const WIRE_TYPE: WireType = WireType::LengthDelimited

The wire type this value uses.

fn proto_len(&self) -> u64

The number of bytes it takes to encode this value. Do not include the number of bytes it takes to encode the length-prefix as a varint. For example, using this snippet of the reference:

fn encode<W: Write>(&self, writer: &mut W) -> Result<()>

Encode the value to the in-wire protobuf format. For length-delimited types, do not include the length-prefix; see Value::proto_len for more details.

impl<'a> Copy for Sample<'a>

impl<'a> Eq for Sample<'a>

impl<'a> StructuralPartialEq for Sample<'a>