Struct relay_event_normalization::ClientHints

pub struct ClientHints<S>
where
    S: Default + AsRef<str>,
{
    pub sec_ch_ua_platform: Option<S>,
    pub sec_ch_ua_platform_version: Option<S>,
    pub sec_ch_ua: Option<S>,
    pub sec_ch_ua_model: Option<S>,
}

The client hint variable names mirror the name of the “SEC-CH” headers.

See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers#user_agent_client_hints

Fields

sec_ch_ua_platform: Option<S>

The client’s OS, e.g. macos, android…

sec_ch_ua_platform_version: Option<S>

The version number of the client’s OS.

sec_ch_ua: Option<S>

Name of the client’s web browser and its version.

sec_ch_ua_model: Option<S>

Device model, e.g. samsung galaxy 3.

Implementations

impl<S> ClientHints<S>

where S: AsRef<str> + Default,

pub fn copy_from(&mut self, other: ClientHints<S>)

Checks every field of a passed-in ClientHints instance if it contains a value, and if it does, copy it to self.

pub fn is_empty(&self) -> bool

Checks if every field is of value None.

impl ClientHints<String>

pub const SEC_CH_UA_PLATFORM: &'static str = "SEC-CH-UA-Platform"

Provides the platform or operating system on which the user agent is running.

For example: "Windows" or "Android".

Sec-CH-UA-Platform is a low entropy hint. Unless blocked by a user agent permission policy, it is sent by default (without the server opting in by sending Accept-CH).

pub const SEC_CH_UA_PLATFORM_VERSION: &'static str = "SEC-CH-UA-Platform-Version"

Provides the version of the operating system on which the user agent is running.

pub const SEC_CH_UA: &'static str = "SEC-CH-UA"

Provides the user agent’s branding and significant version information.

A brand is a commercial name for the user agent like: Chromium, Opera, Google Chrome, Microsoft Edge, Firefox, and Safari. A user agent might have several associated brands. For example, Opera, Chrome, and Edge are all based on Chromium, and will provide both brands in the Sec-CH-UA header.

The significant version is the “marketing” version identifier that is used to distinguish between major releases of the brand. For example a Chromium build with full version number “96.0.4664.45” has a significant version number of “96”.

The header may include “fake” brands in any position and with any name. This is a feature designed to prevent servers from rejecting unknown user agents outright, forcing user agents to lie about their brand identity.

Sec-CH-UA is a low entropy hint. Unless blocked by a user agent permission policy, it is sent by default (without the server opting in by sending Accept-CH).

pub const SEC_CH_UA_MODEL: &'static str = "SEC-CH-UA-Model"

Indicates the device model on which the browser is running.

pub fn as_deref(&self) -> ClientHints<&str>

Returns an instance of ClientHints that borrows from the original data.

Trait Implementations

impl<S> Clone for ClientHints<S>

where S: Default + AsRef<str> + Clone,

fn clone(&self) -> ClientHints<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S> Debug for ClientHints<S>

where S: Default + AsRef<str> + Debug,

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

Formats the value using the given formatter.

impl<S> Default for ClientHints<S>

where S: Default + AsRef<str> + Default,

fn default() -> ClientHints<S>

Returns the “default value” for a type.

impl<'de, S> Deserialize<'de> for ClientHints<S>

where S: Default + AsRef<str> + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> PartialEq for ClientHints<S>

where S: Default + AsRef<str> + PartialEq,

fn eq(&self, other: &ClientHints<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> Serialize for ClientHints<S>

where S: Default + AsRef<str> + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S> StructuralPartialEq for ClientHints<S>

where S: Default + AsRef<str>,