Struct ClientInfo 

pub struct ClientInfo { /* private fields */ }

Client request context: IP, user-agent, parsed device fields, and a server-computed browser fingerprint.

Implements FromRequestParts for automatic extraction in handlers. Requires ClientIpLayer for the ip field; if the layer is absent, ip will be None.

For non-HTTP contexts (background jobs, CLI tools), use the builder:

use modo::client::ClientInfo;

let info = ClientInfo::new()
    .ip("1.2.3.4")
    .user_agent("my-script/1.0");

To populate device and fingerprint fields from request headers (e.g. inside middleware that already holds a &HeaderMap), use ClientInfo::from_headers.

Implementations

impl ClientInfo

pub fn new() -> Self

Create an empty ClientInfo with all fields set to None.

pub fn ip(self, ip: impl Into<String>) -> Self

Set the client IP address.

pub fn user_agent(self, ua: impl Into<String>) -> Self

Set the user-agent string.

pub fn device_name(self, name: impl Into<String>) -> Self

Set the parsed device name (e.g. "Chrome on macOS").

pub fn device_type(self, kind: impl Into<String>) -> Self

Set the device type ("desktop", "mobile", or "tablet").

pub fn fingerprint(self, fp: impl Into<String>) -> Self

Set the SHA-256 browser fingerprint.

pub fn from_headers( ip: Option<String>, user_agent: &str, accept_language: &str, accept_encoding: &str, ) -> Self

Build a fully-populated ClientInfo from the headers a server already has at hand.

Parses device_name and device_type from user_agent, and computes the fingerprint from user_agent + accept_language + accept_encoding. An empty user_agent still yields meaningful values ("Unknown on Unknown" / "desktop" / a stable hash).

pub fn ip_value(&self) -> Option<&str>

The client IP address, if available.

pub fn user_agent_value(&self) -> Option<&str>

The client user-agent string, if available.

pub fn device_name_value(&self) -> Option<&str>

The parsed human-readable device name, if available.

pub fn device_type_value(&self) -> Option<&str>

The parsed device type ("desktop"/"mobile"/"tablet"), if available.

pub fn fingerprint_value(&self) -> Option<&str>

The server-computed browser fingerprint, if available.

Trait Implementations

impl Clone for ClientInfo

fn clone(&self) -> ClientInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClientInfo

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

Formats the value using the given formatter.

impl Default for ClientInfo

fn default() -> ClientInfo

Returns the “default value” for a type.

impl<S: Send + Sync> FromRequestParts<S> for ClientInfo

async fn from_request_parts( parts: &mut Parts, _state: &S, ) -> Result<Self, Self::Rejection>

Builds ClientInfo from request extensions and headers.

Reads the IP from the ClientIp extension (inserted by ClientIpLayer) and the user-agent from the User-Agent header. Device fields are derived only when the user-agent header is present; when it is absent they remain None so callers can reliably distinguish “no UA was sent” from “UA was sent but unrecognized”. The fingerprint is server-computed from whatever combination of User-Agent, Accept-Language, and Accept-Encoding headers were present (each defaulting to "") and is therefore always populated.

Errors

This extractor never fails — the Result type is required by FromRequestParts but the implementation always returns Ok.

type Rejection = Error

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.