Struct rama::telemetry::opentelemetry::Context
pub struct Context { /* private fields */ }
Expand description
An execution-scoped collection of values.
A Context
is a propagation mechanism which carries execution-scoped
values across API boundaries and between logically associated execution
units. Cross-cutting concerns access their data in-process using the same
shared context object.
Context
s are immutable, and their write operations result in the creation
of a new context containing the original values and the new specified values.
§Context state
Concerns can create and retrieve their local state in the current execution
state represented by a context through the get
and with_value
methods. It is recommended to use application-specific types when storing new
context values to avoid unintentionally overwriting existing state.
§Managing the current context
Contexts can be associated with the caller’s current execution unit on a
given thread via the attach
method, and previous contexts can be restored
by dropping the returned ContextGuard
. Context can be nested, and will
restore their parent outer context when detached on drop. To access the
values of the context, a snapshot can be created via the Context::current
method.
§Examples
use opentelemetry::Context;
// Application-specific `a` and `b` values
#[derive(Debug, PartialEq)]
struct ValueA(&'static str);
#[derive(Debug, PartialEq)]
struct ValueB(u64);
let _outer_guard = Context::new().with_value(ValueA("a")).attach();
// Only value a has been set
let current = Context::current();
assert_eq!(current.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(current.get::<ValueB>(), None);
{
let _inner_guard = Context::current_with_value(ValueB(42)).attach();
// Both values are set in inner context
let current = Context::current();
assert_eq!(current.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(current.get::<ValueB>(), Some(&ValueB(42)));
}
// Resets to only the `a` value when inner guard is dropped
let current = Context::current();
assert_eq!(current.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(current.get::<ValueB>(), None);
Implementations§
§impl Context
impl Context
pub fn new() -> Context
pub fn new() -> Context
Creates an empty Context
.
The context is initially created with a capacity of 0, so it will not
allocate. Use with_value
to create a new context that has entries.
pub fn current() -> Context
pub fn current() -> Context
Returns an immutable snapshot of the current thread’s context.
§Examples
use opentelemetry::Context;
#[derive(Debug, PartialEq)]
struct ValueA(&'static str);
fn do_work() {
assert_eq!(Context::current().get(), Some(&ValueA("a")));
}
let _guard = Context::new().with_value(ValueA("a")).attach();
do_work()
pub fn map_current<T>(f: impl FnOnce(&Context) -> T) -> T
pub fn map_current<T>(f: impl FnOnce(&Context) -> T) -> T
Applies a function to the current context returning its value.
This can be used to build higher performing algebraic expressions for optionally creating a new context without the overhead of cloning the current one and dropping it.
Note: This function will panic if you attempt to attach another context while the current one is still borrowed.
pub fn current_with_value<T>(value: T) -> Context
pub fn current_with_value<T>(value: T) -> Context
Returns a clone of the current thread’s context with the given value.
This is a more efficient form of Context::current().with_value(value)
as it avoids the intermediate context clone.
§Examples
use opentelemetry::Context;
// Given some value types defined in your application
#[derive(Debug, PartialEq)]
struct ValueA(&'static str);
#[derive(Debug, PartialEq)]
struct ValueB(u64);
// You can create and attach context with the first value set to "a"
let _guard = Context::new().with_value(ValueA("a")).attach();
// And create another context based on the fist with a new value
let all_current_and_b = Context::current_with_value(ValueB(42));
// The second context now contains all the current values and the addition
assert_eq!(all_current_and_b.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(all_current_and_b.get::<ValueB>(), Some(&ValueB(42)));
pub fn get<T>(&self) -> Option<&T>where
T: 'static,
pub fn get<T>(&self) -> Option<&T>where
T: 'static,
Returns a reference to the entry for the corresponding value type.
§Examples
use opentelemetry::Context;
// Given some value types defined in your application
#[derive(Debug, PartialEq)]
struct ValueA(&'static str);
#[derive(Debug, PartialEq)]
struct MyUser();
let cx = Context::new().with_value(ValueA("a"));
// Values can be queried by type
assert_eq!(cx.get::<ValueA>(), Some(&ValueA("a")));
// And return none if not yet set
assert_eq!(cx.get::<MyUser>(), None);
pub fn with_value<T>(&self, value: T) -> Context
pub fn with_value<T>(&self, value: T) -> Context
Returns a copy of the context with the new value included.
§Examples
use opentelemetry::Context;
// Given some value types defined in your application
#[derive(Debug, PartialEq)]
struct ValueA(&'static str);
#[derive(Debug, PartialEq)]
struct ValueB(u64);
// You can create a context with the first value set to "a"
let cx_with_a = Context::new().with_value(ValueA("a"));
// And create another context based on the fist with a new value
let cx_with_a_and_b = cx_with_a.with_value(ValueB(42));
// The first context is still available and unmodified
assert_eq!(cx_with_a.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(cx_with_a.get::<ValueB>(), None);
// The second context now contains both values
assert_eq!(cx_with_a_and_b.get::<ValueA>(), Some(&ValueA("a")));
assert_eq!(cx_with_a_and_b.get::<ValueB>(), Some(&ValueB(42)));
pub fn attach(self) -> ContextGuard
pub fn attach(self) -> ContextGuard
Replaces the current context on this thread with this context.
Dropping the returned ContextGuard
will reset the current context to the
previous value.
§Examples
use opentelemetry::Context;
#[derive(Debug, PartialEq)]
struct ValueA(&'static str);
let my_cx = Context::new().with_value(ValueA("a"));
// Set the current thread context
let cx_guard = my_cx.attach();
assert_eq!(Context::current().get::<ValueA>(), Some(&ValueA("a")));
// Drop the guard to restore the previous context
drop(cx_guard);
assert_eq!(Context::current().get::<ValueA>(), None);
Guards do not need to be explicitly dropped:
use opentelemetry::Context;
#[derive(Debug, PartialEq)]
struct ValueA(&'static str);
fn my_function() -> String {
// attach a context the duration of this function.
let my_cx = Context::new().with_value(ValueA("a"));
// NOTE: a variable name after the underscore is **required** or rust
// will drop the guard, restoring the previous context _immediately_.
let _guard = my_cx.attach();
// anything happening in functions we call can still access my_cx...
my_other_function();
// returning from the function drops the guard, exiting the span.
return "Hello world".to_owned();
}
fn my_other_function() {
// ...
}
Sub-scopes may be created to limit the duration for which the span is entered:
use opentelemetry::Context;
#[derive(Debug, PartialEq)]
struct ValueA(&'static str);
let my_cx = Context::new().with_value(ValueA("a"));
{
let _guard = my_cx.attach();
// the current context can access variables in
assert_eq!(Context::current().get::<ValueA>(), Some(&ValueA("a")));
// exiting the scope drops the guard, detaching the context.
}
// this is back in the default empty context
assert_eq!(Context::current().get::<ValueA>(), None);
Trait Implementations§
§impl BaggageExt for Context
impl BaggageExt for Context
§fn with_baggage<T, I>(&self, baggage: T) -> Context
fn with_baggage<T, I>(&self, baggage: T) -> Context
§fn current_with_baggage<T, I>(kvs: T) -> Context
fn current_with_baggage<T, I>(kvs: T) -> Context
§fn with_cleared_baggage(&self) -> Context
fn with_cleared_baggage(&self) -> Context
§impl TraceContextExt for Context
impl TraceContextExt for Context
§fn current_with_span<T>(span: T) -> Context
fn current_with_span<T>(span: T) -> Context
§fn with_span<T>(&self, span: T) -> Context
fn with_span<T>(&self, span: T) -> Context
§fn span(&self) -> SpanRef<'_>
fn span(&self) -> SpanRef<'_>
§fn has_active_span(&self) -> bool
fn has_active_span(&self) -> bool
§fn with_remote_span_context(&self, span_context: SpanContext) -> Context
fn with_remote_span_context(&self, span_context: SpanContext) -> Context
Auto Trait Implementations§
impl Freeze for Context
impl !RefUnwindSafe for Context
impl Send for Context
impl Sync for Context
impl Unpin for Context
impl !UnwindSafe for Context
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)§impl<T> Conv for T
impl<T> Conv for T
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
§fn with_current_context(self) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.§impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> PolicyExt for Twhere
T: ?Sized,
§fn and<S, P, B, E>(self, other: P) -> And<T, P>
fn and<S, P, B, E>(self, other: P) -> And<T, P>
Policy
that returns Action::Follow
only if self
and other
return
Action::Follow
. Read more§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.