Struct TracedResponse

pub struct TracedResponse<T = Incoming> {
    pub trace_id: TraceId,
    pub span_id: SpanId,
    /* private fields */
}

HTTP response wrapper that includes OpenTelemetry trace information.

This struct wraps an HTTP response and provides easy access to the associated trace ID and span ID for testing and debugging purposes. It’s particularly useful in integration tests where you need to verify trace propagation.

Example

use telemetry_rust::test::{TracedResponse, Traceparent};

async fn send_traced_request() -> TracedResponse<&'static str> {
    let traceparent = Traceparent::generate();

    // Send request and get response
    let resp = hyper::Response::new("Hello world!");

    TracedResponse::new(resp, traceparent)
}

Fields

trace_id: TraceId

The OpenTelemetry trace ID associated with this response

span_id: SpanId

The OpenTelemetry span ID associated with this response

Implementations

impl<T> TracedResponse<T>

pub fn new(resp: Response<T>, traceparent: Traceparent) -> Self

Creates a new traced response from an HTTP response and trace parent information.

Arguments

• resp: The HTTP response to wrap
• traceparent: The trace parent containing trace and span IDs

Returns

A new TracedResponse instance

pub async fn into_inner(self) -> Response<T>

Consumes the traced response and returns the inner HTTP response.

Returns

The wrapped hyper::Response instance.

impl<E, T: Body<Data = Bytes, Error = E>> TracedResponse<T>

pub async fn into_bytes(self) -> Result<Bytes, E>

Consumes the response and returns the body as bytes.

Returns

A future that resolves to the response body as bytes::Bytes

Errors

Returns an error if the response body cannot be read

Methods from Deref<Target = Response<T>>

pub fn status(&self) -> StatusCode

Returns the StatusCode.

Examples

let response: Response<()> = Response::default();
assert_eq!(response.status(), StatusCode::OK);

pub fn status_mut(&mut self) -> &mut StatusCode

Returns a mutable reference to the associated StatusCode.

Examples

let mut response: Response<()> = Response::default();
*response.status_mut() = StatusCode::CREATED;
assert_eq!(response.status(), StatusCode::CREATED);

pub fn version(&self) -> Version

Returns a reference to the associated version.

Examples

let response: Response<()> = Response::default();
assert_eq!(response.version(), Version::HTTP_11);

pub fn version_mut(&mut self) -> &mut Version

Returns a mutable reference to the associated version.

Examples

let mut response: Response<()> = Response::default();
*response.version_mut() = Version::HTTP_2;
assert_eq!(response.version(), Version::HTTP_2);

pub fn headers(&self) -> &HeaderMap

Returns a reference to the associated header field map.

Examples

let response: Response<()> = Response::default();
assert!(response.headers().is_empty());

pub fn headers_mut(&mut self) -> &mut HeaderMap

Returns a mutable reference to the associated header field map.

Examples

let mut response: Response<()> = Response::default();
response.headers_mut().insert(HOST, HeaderValue::from_static("world"));
assert!(!response.headers().is_empty());

pub fn extensions(&self) -> &Extensions

Returns a reference to the associated extensions.

Examples

let response: Response<()> = Response::default();
assert!(response.extensions().get::<i32>().is_none());

pub fn extensions_mut(&mut self) -> &mut Extensions

Returns a mutable reference to the associated extensions.

Examples

let mut response: Response<()> = Response::default();
response.extensions_mut().insert("hello");
assert_eq!(response.extensions().get(), Some(&"hello"));

pub fn body(&self) -> &T

Returns a reference to the associated HTTP body.

Examples

let response: Response<String> = Response::default();
assert!(response.body().is_empty());

pub fn body_mut(&mut self) -> &mut T

Returns a mutable reference to the associated HTTP body.

Examples

let mut response: Response<String> = Response::default();
response.body_mut().push_str("hello world");
assert!(!response.body().is_empty());

Trait Implementations

impl<T: Debug> Debug for TracedResponse<T>

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

Formats the value using the given formatter.

impl<T> Deref for TracedResponse<T>

type Target = Response<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for TracedResponse<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.