//! Actix ActorFuture instrumentation for use with [`tracing`]
//!
//! # Example
//!
//! ```rust
//! use actix::prelude::*;
//! use actix::fut::{ready, ActorFuture};
//! use tracing::{span, event, Level};
//! use tracing_actix::ActorInstrument;
//! #
//! # // The response type returned by the actor future
//! # type OriginalActorResponse = ();
//! # // The error type returned by the actor future
//! # type MessageError = ();
//! # // This is the needed result for the DeferredWork message
//! # // It's a result that combine both Response and Error from the future response.
//! # type DeferredWorkResult = Result<OriginalActorResponse, MessageError>;
//! #
//! # struct ActorState {}
//! #
//! # impl ActorState {
//! # fn update_from(&mut self, _result: ()) {}
//! # }
//! #
//! # struct OtherActor {}
//! #
//! # impl Actor for OtherActor {
//! # type Context = Context<Self>;
//! # }
//! #
//! # impl Handler<OtherMessage> for OtherActor {
//! # type Result = ();
//! #
//! # fn handle(&mut self, _msg: OtherMessage, _ctx: &mut Context<Self>) -> Self::Result {
//! # }
//! # }
//! #
//! # struct OriginalActor{
//! # other_actor: Addr<OtherActor>,
//! # inner_state: ActorState
//! # }
//! #
//! # impl Actor for OriginalActor{
//! # type Context = Context<Self>;
//! # }
//! #
//! # #[derive(Message)]
//! # #[rtype(result = "Result<(), MessageError>")]
//! # struct DeferredWork{}
//! #
//! # #[derive(Message)]
//! # #[rtype(result = "()")]
//! # struct OtherMessage{}
//!
//! /// This example is modified from the actix::fut module and intended to show how
//! /// the `ActorInstrument` trait may be used to integrate tracing `Span`s within
//! /// asynchronous message handlers.
//! impl Handler<DeferredWork> for OriginalActor {
//! type Result = ResponseActFuture<Self, Result<OriginalActorResponse, MessageError>>;
//!
//! fn handle(
//! &mut self,
//! _msg: DeferredWork,
//! _ctx: &mut Context<Self>,
//! ) -> Self::Result {
//! // this creates a `Future` representing the `.send` and subsequent `Result` from
//! // `other_actor`
//! let span = span!(Level::INFO, "deferred work context");
//! // Addr<A>::send returns `actix::prelude::Request`, which implements Unpin, so we can wrap
//! // into_actor within an ActorInstrument.
//! Box::pin(
//! self.other_actor
//! .send(OtherMessage {})
//! .into_actor(self)
//! .actor_instrument(span)
//! .map(|result, actor, _ctx| {
//! // Actor's state updated here
//! match result {
//! Ok(v) => {
//! event!(Level::INFO, "I'm within deferred work context");
//! actor.inner_state.update_from(v);
//! Ok(())
//! }
//! // Failed to send message to other_actor
//! Err(e) => {
//! event!(Level::ERROR, "Error from deferred work: {:?}", e);
//! Err(())
//! }
//! }
//! }),
//! )
//! }
//! }
//! #
//! # #[derive(Message)]
//! # #[rtype(result = "Pong")]
//! # struct Ping;
//! #
//! # struct Pong;
//!
//! /// In this example, there isn't an `actix::prelude::Request` in our `ActorFuture`.
//! /// Since `ActorInstrument` needs to wrap `ActorFuture + Unpin`, we can't use
//! /// `async {}.into_actor(self)` because `async {}` doesn't implement `Unpin`.
//! impl Handler<Ping> for OriginalActor {
//! type Result = ResponseActFuture<Self, Pong>;
//!
//! fn handle(
//! &mut self,
//! _msg: Ping,
//! _ctx: &mut Context<Self>,
//! ) -> Self::Result {
//! // `async {}` doesn't implement Unpin, so it can't be used.
//! // `actix::fut::Ready` ActorFutures work fine though.
//! let span = span!(Level::INFO, "ping");
//! Box::pin(
//! ready::<Pong>(Pong {})
//! .actor_instrument(span)
//! .map(|pong, _this, _ctx| {
//! // the pong event occurs in the ping span, even though this is async.
//! event!(Level::INFO, "pong");
//! pong
//! }),
//! )
//! }
//! }
//! ```
use ;
use pin_project;
use ;
use Span;
/// Extension trait allowing actor futures to be instrumented with
/// a `tracing` `Span`.
pin_project!