Struct relay_event_schema::protocol::Request

pub struct Request {

    pub url: Annotated<String>,
    pub method: Annotated<String>,
    pub protocol: Annotated<String>,
    pub data: Annotated<Value>,
    pub query_string: Annotated<Query>,
    pub fragment: Annotated<String>,
    pub cookies: Annotated<Cookies>,
    pub headers: Annotated<Headers>,
    pub body_size: Annotated<u64>,
    pub env: Annotated<Object<Value>>,
    pub inferred_content_type: Annotated<String>,
    pub api_target: Annotated<String>,
    pub other: Object<Value>,
}

Http request information.

The Request interface contains information on a HTTP request related to the event. In client SDKs, this can be an outgoing request, or the request that rendered the current web page. On server SDKs, this could be the incoming web request that is being handled.

The data variable should only contain the request body (not the query string). It can either be a dictionary (for standard HTTP requests) or a raw request body.

Ordered Maps

In the Request interface, several attributes can either be declared as string, object, or list of tuples. Sentry attempts to parse structured information from the string representation in such cases.

Sometimes, keys can be declared multiple times, or the order of elements matters. In such cases, use the tuple representation over a plain object.

Example of request headers as object:

{
  "content-type": "application/json",
  "accept": "application/json, application/xml"
}

Example of the same headers as list of tuples:

[
  ["content-type", "application/json"],
  ["accept", "application/json"],
  ["accept", "application/xml"]
]

Example of a fully populated request object:

{
  "request": {
    "method": "POST",
    "url": "http://absolute.uri/foo",
    "query_string": "query=foobar&page=2",
    "data": {
      "foo": "bar"
    },
    "cookies": "PHPSESSID=298zf09hf012fh2; csrftoken=u32t4o3tb3gg43; _gat=1;",
    "headers": {
      "content-type": "text/html"
    },
    "env": {
      "REMOTE_ADDR": "192.168.0.1"
    }
  }
}

Fields

url: Annotated<String>

The URL of the request if available.

The query string can be declared either as part of the url, or separately in query_string.

method: Annotated<String>

HTTP request method.

protocol: Annotated<String>

HTTP protocol.

data: Annotated<Value>

Request data in any format that makes sense.

SDKs should discard large and binary bodies by default. Can be given as a string or structural data of any format.

query_string: Annotated<Query>

The query string component of the URL.

Can be given as unparsed string, dictionary, or list of tuples.

If the query string is not declared and part of the url, Sentry moves it to the query string.

fragment: Annotated<String>

The fragment of the request URI.

cookies: Annotated<Cookies>

The cookie values.

Can be given unparsed as string, as dictionary, or as a list of tuples.

headers: Annotated<Headers>

A dictionary of submitted headers.

If a header appears multiple times it, needs to be merged according to the HTTP standard for header merging. Header names are treated case-insensitively by Sentry.

body_size: Annotated<u64>

HTTP request body size.

env: Annotated<Object<Value>>

Server environment data, such as CGI/WSGI.

A dictionary containing environment information passed from the server. This is where information such as CGI/WSGI/Rack keys go that are not HTTP headers.

Sentry will explicitly look for REMOTE_ADDR to extract an IP address.

inferred_content_type: Annotated<String>

The inferred content type of the request payload.

api_target: Annotated<String>

The API target/specification that made the request.

Values can be graphql, rest, etc.

The data field should contain the request and response bodies based on its target specification.

This information can be used for better data scrubbing and normalization.

other: Object<Value>

Additional arbitrary fields for forwards compatibility.

Trait Implementations

impl Clone for Request

fn clone(&self) -> Request

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Request

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

Formats the value using the given formatter.

impl Default for Request

fn default() -> Request

Returns the “default value” for a type.

impl Empty for Request

fn is_empty(&self) -> bool

Returns whether this value is empty.

fn is_deep_empty(&self) -> bool

Returns whether this value is empty or all of its descendants are empty.

impl FromValue for Request

fn from_value(__value: Annotated<Value>) -> Annotated<Self>

Creates a meta structure from an annotated boxed value.

impl IntoValue for Request

fn into_value(self) -> Value

Boxes the meta structure back into a value.

fn serialize_payload<S>( &self, __serializer: S, __behavior: SkipSerialization, ) -> Result<S::Ok, S::Error>

where Self: Sized, S: Serializer,

Efficiently serializes the payload directly.

fn extract_child_meta(&self) -> MetaMap

where Self: Sized,

Extracts children meta map out of a value.

fn extract_meta_tree(value: &Annotated<Self>) -> MetaTree

where Self: Sized,

Extracts the meta tree out of annotated value.

impl PartialEq for Request

fn eq(&self, other: &Request) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl ProcessValue for Request

fn value_type(&self) -> EnumSet<ValueType>

Returns the type of the value.

fn process_value<P>( &mut self, __meta: &mut Meta, __processor: &mut P, __state: &ProcessingState<'_>, ) -> ProcessingResult

where P: Processor,

Executes a processor on this value.

fn process_child_values<P>( &mut self, __processor: &mut P, __state: &ProcessingState<'_>, ) -> ProcessingResult

where P: Processor,

Recurses into children of this value.

impl StructuralPartialEq for Request