Struct svc_agent::mqtt::OutgoingShortTermTimingProperties

pub struct OutgoingShortTermTimingProperties { /* fields omitted */ }

Timing properties of a single message in a chain.

Consider a service that receives a request and in part makes a request to another service. The second service sends the response and then first services sends the response to the client. Here we have a chain of four messages: request -> request -> response -> response.

For monitoring and analytical purposes it's useful to know how long it takes as a whole and which part of the system make the biggest latency.

The conventions contain a number of properties that messages must contain.

For API simplicity in svc-agent they are separated in two structs. Those which gets passed through the whole chain are LongTermTimingProperties and those which are related only to a single message in the chain are in this struct.

When starting processing a request you should save the current time and when it's finished you should call until_now(#method.until_now) function with this value and then pass the result object to OutgoingMessageProperties.

If you make an authorization call to an external system during the processing you may want to measure it during the call and set it to the object to monitor authorization latency as well.

Example

let start_timestamp = Utc::now();
let authz_time = authorize(&request)?;
let response_payload = process_request(&request)?;

let mut short_term_timing = OutgoingShortTermTimingProperties::until_now(start_timestamp);
short_term_timing.set_authorization_time(authz_time);

request.to_response(response_payload, ResponseStatus::OK, short_term_timing, "v1")

Implementations

impl OutgoingShortTermTimingProperties

pub fn until_now(start_timestamp: DateTime<Utc>) -> Self

Builds OutgoingShortTermTimingProperties and sets processing time in one call.

Arguments

• start_timestamp – UTC timestamp of message processing beginning.

Example

let mut short_term_timing = OutgoingShortTermTimingProperties::until_now(start_timestamp);

pub fn new(timestamp: DateTime<Utc>) -> Self

Builds OutgoingShortTermTimingProperties by explicit timestamp.

Arguments

timestamp – UTC timestamp of message processing finish.

Example

let mut short_term_timing = OutgoingShortTermTimingProperties::until_now(Utc::now());

pub fn set_processing_time(&mut self, processing_time: Duration) -> &mut Self

pub fn set_authorization_time(
    &mut self,
    authorization_time: Duration
) -> &mut Self

Trait Implementations

impl Clone for OutgoingShortTermTimingProperties

fn clone(&self) -> OutgoingShortTermTimingProperties

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OutgoingShortTermTimingProperties

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OutgoingShortTermTimingProperties

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for OutgoingShortTermTimingProperties

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.