Struct Baggage

pub struct Baggage { /* private fields */ }

A set of name/value pairs describing user-defined properties.

Baggage Names

• ASCII strings according to the token format, defined in [RFC2616, Section 2.2]

Baggage Values

• URL encoded UTF-8 strings.

Baggage Value Metadata

Additional metadata can be added to values in the form of a property set, represented as semi-colon ; delimited list of names and/or name/value pairs, e.g. ;k1=v1;k2;k3=v3.

Limits

• Maximum number of name/value pairs: 64.
• Maximum total length of all name/value pairs: 8192.

https://www.w3.org/TR/baggage/#limits

Implementations

impl Baggage

pub fn new() -> Baggage

Creates an empty Baggage.

pub fn get<K>(&self, key: K) -> Option<&StringValue>

where K: AsRef<str>,

Returns a reference to the value associated with a given name

Examples

use opentelemetry::{baggage::Baggage, StringValue};

let mut baggage = Baggage::new();
let _ = baggage.insert("my-name", "my-value");

assert_eq!(baggage.get("my-name"), Some(&StringValue::from("my-value")))

pub fn get_with_metadata<K>( &self, key: K, ) -> Option<&(StringValue, BaggageMetadata)>

where K: AsRef<str>,

Returns a reference to the value and metadata associated with a given name

Examples

use opentelemetry::{baggage::{Baggage, BaggageMetadata}, StringValue};

let mut baggage = Baggage::new();
let _ = baggage.insert("my-name", "my-value");

// By default, the metadata is empty
assert_eq!(baggage.get_with_metadata("my-name"), Some(&(StringValue::from("my-value"), BaggageMetadata::from(""))))

pub fn insert<K, V>(&mut self, key: K, value: V) -> Option<StringValue>

where K: Into<Key>, V: Into<StringValue>,

Inserts a name/value pair into the baggage.

If the name was not present, None is returned. If the name was present, the value is updated, and the old value is returned.

Examples

use opentelemetry::{baggage::Baggage, StringValue};

let mut baggage = Baggage::new();
let _ = baggage.insert("my-name", "my-value");

assert_eq!(baggage.get("my-name"), Some(&StringValue::from("my-value")))

pub fn insert_with_metadata<K, V, S>( &mut self, key: K, value: V, metadata: S, ) -> Option<(StringValue, BaggageMetadata)>

where K: Into<Key>, V: Into<StringValue>, S: Into<BaggageMetadata>,

Inserts a name/value(+metadata) pair into the baggage.

Same with insert, if the name was not present, None will be returned. If the name is present, the old value and metadata will be returned.

Also checks for limits.

Examples

use opentelemetry::{baggage::{Baggage, BaggageMetadata}, StringValue};

let mut baggage = Baggage::new();
let _ = baggage.insert_with_metadata("my-name", "my-value", "test");

assert_eq!(baggage.get_with_metadata("my-name"), Some(&(StringValue::from("my-value"), BaggageMetadata::from("test"))))

pub fn remove<K>(&mut self, key: K) -> Option<(StringValue, BaggageMetadata)>

where K: AsRef<str>,

Removes a name from the baggage, returning the value corresponding to the name if the pair was previously in the map.

pub fn len(&self) -> usize

Returns the number of attributes for this baggage

pub fn is_empty(&self) -> bool

Returns true if the baggage contains no items.

pub fn iter(&self) -> Iter<'_>

Gets an iterator over the baggage items, in any order.

Trait Implementations

impl Debug for Baggage

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

Formats the value using the given formatter.

impl Default for Baggage

fn default() -> Baggage

Returns the “default value” for a type.

impl Display for Baggage

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

Formats the value using the given formatter.

impl<I> From<I> for Baggage

where I: IntoIterator, <I as IntoIterator>::Item: Into<KeyValueMetadata>,

fn from(value: I) -> Baggage

Converts to this type from the input type.

impl FromIterator<(Key, (StringValue, BaggageMetadata))> for Baggage

fn from_iter<I>(iter: I) -> Baggage

where I: IntoIterator<Item = (Key, (StringValue, BaggageMetadata))>,

Creates a value from an iterator.

impl FromIterator<KeyValue> for Baggage

fn from_iter<I>(iter: I) -> Baggage

where I: IntoIterator<Item = KeyValue>,

Creates a value from an iterator.

impl FromIterator<KeyValueMetadata> for Baggage

fn from_iter<I>(iter: I) -> Baggage

where I: IntoIterator<Item = KeyValueMetadata>,

Creates a value from an iterator.

impl<'a> IntoIterator for &'a Baggage

type Item = (&'a Key, &'a (StringValue, BaggageMetadata))

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Baggage as IntoIterator>::IntoIter

Creates an iterator from a value.