Struct trillium_conn_id::ConnId
source · pub struct ConnId { /* private fields */ }
Expand description
Trillium handler to set a identifier for every Conn.
By default, it will use an inbound x-request-id
request header or if
that is missing, populate a ten character random id. This handler will
set an outbound x-request-id
header as well by default. All of this
behavior can be customized with ConnId::with_request_header
,
ConnId::with_response_header
and ConnId::with_id_generator
Implementations§
source§impl ConnId
impl ConnId
sourcepub fn new() -> Self
pub fn new() -> Self
Constructs a new ConnId handler
let app = (ConnId::new().with_seed(1000), "ok"); // seeded for testing
assert_ok!(
get("/").on(&app),
"ok",
"x-request-id" => "J4lzoPXcT5"
);
assert_headers!(
get("/")
.with_request_header("x-request-id", "inbound")
.on(&app),
"x-request-id" => "inbound"
);
sourcepub fn with_request_header(
self,
request_header: impl Into<HeaderName<'static>>,
) -> Self
pub fn with_request_header( self, request_header: impl Into<HeaderName<'static>>, ) -> Self
Specifies a request header to use. If this header is provided on
the inbound request, the id will be used unmodified. To disable
this behavior, see ConnId::without_request_header
let app = (
ConnId::new().with_request_header("x-custom-id"),
"ok"
);
assert_headers!(
get("/")
.with_request_header("x-custom-id", "inbound")
.on(&app),
"x-request-id" => "inbound"
);
sourcepub fn without_request_header(self) -> Self
pub fn without_request_header(self) -> Self
disables the default behavior of reusing an inbound header for
the request id. If a ConnId is configured
without_request_header
, a new id will always be generated
sourcepub fn with_response_header(
self,
response_header: impl Into<HeaderName<'static>>,
) -> Self
pub fn with_response_header( self, response_header: impl Into<HeaderName<'static>>, ) -> Self
Specifies a response header to set. To disable this behavior, see
ConnId::without_response_header
let app = (
ConnId::new()
.with_seed(1000) // for testing
.with_response_header("x-custom-header"),
"ok"
);
assert_headers!(
get("/").on(&app),
"x-custom-header" => "J4lzoPXcT5"
);
sourcepub fn without_response_header(self) -> Self
pub fn without_response_header(self) -> Self
Disables the default behavior of sending the conn id as a response
header. A request id will be available within the application
through use of ConnIdExt
but will not be sent as part of the
response.
sourcepub fn with_id_generator<F>(self, id_generator: F) -> Self
pub fn with_id_generator<F>(self, id_generator: F) -> Self
Provide an alternative generator function for ids. The default is a ten-character alphanumeric random sequence.
let app = (
ConnId::new().with_id_generator(|| Uuid::new_v4().to_string()),
"ok"
);
// assert that the id is a valid uuid, even if we can't assert a specific value
assert!(Uuid::parse_str(get("/").on(&app).response_headers().get_str("x-request-id").unwrap()).is_ok());
Trait Implementations§
source§impl Handler for ConnId
impl Handler for ConnId
source§fn run<'life0, 'async_trait>(
&'life0 self,
conn: Conn,
) -> Pin<Box<dyn Future<Output = Conn> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
fn run<'life0, 'async_trait>(
&'life0 self,
conn: Conn,
) -> Pin<Box<dyn Future<Output = Conn> + Send + 'async_trait>>where
Self: 'async_trait,
'life0: 'async_trait,
source§fn init<'life0, 'life1, 'async_trait>(
&'life0 mut self,
_info: &'life1 mut Info,
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn init<'life0, 'life1, 'async_trait>(
&'life0 mut self,
_info: &'life1 mut Info,
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
source§fn before_send<'life0, 'async_trait>(
&'life0 self,
conn: Conn,
) -> Pin<Box<dyn Future<Output = Conn> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
fn before_send<'life0, 'async_trait>(
&'life0 self,
conn: Conn,
) -> Pin<Box<dyn Future<Output = Conn> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
source§fn has_upgrade(&self, _upgrade: &Upgrade<BoxedTransport>) -> bool
fn has_upgrade(&self, _upgrade: &Upgrade<BoxedTransport>) -> bool
Handler::upgrade
. The first
handler that responds true to this will receive ownership of the
trillium::Upgrade
in a subsequent call to Handler::upgrade
source§fn upgrade<'life0, 'async_trait>(
&'life0 self,
_upgrade: Upgrade<BoxedTransport>,
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
fn upgrade<'life0, 'async_trait>(
&'life0 self,
_upgrade: Upgrade<BoxedTransport>,
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,
Handler::has_upgrade
and will only be called once for this
upgrade. There is no return value, and this function takes
exclusive ownership of the underlying transport once this is
called. You can downcast the transport to whatever the source
transport type is and perform any non-http protocol communication
that has been negotiated. You probably don’t want this unless
you’re implementing something like websockets. Please note that
for many transports such as TcpStreams, dropping the transport
(and therefore the Upgrade) will hang up / disconnect.