Struct soup::Logger

pub struct Logger { /* private fields */ }

Debug logging support

#SoupLogger watches a Session and logs the HTTP traffic that it generates, for debugging purposes. Many applications use an environment variable to determine whether or not to use #SoupLogger, and to determine the amount of debugging output.

To use #SoupLogger, first create a logger with new(), optionally configure it with set_request_filter(), set_response_filter(), and [set_printer()][Self::set_printer()], and then attach it to a session (or multiple sessions) with SessionExt::add_feature().

By default, the debugging output is sent to stdout, and looks something like:

> POST /unauth HTTP/1.1
> Soup-Debug-Timestamp: 1200171744
> Soup-Debug: SoupSession 1 (0x612190), SoupMessage 1 (0x617000), GSocket 1 (0x612220)
> Host: localhost
> Content-Type: text/plain
> Connection: close

< HTTP/1.1 201 Created
< Soup-Debug-Timestamp: 1200171744
< Soup-Debug: SoupMessage 1 (0x617000)
< Date: Sun, 12 Jan 2008 21:02:24 GMT
< Content-Length: 0

The Soup-Debug-Timestamp line gives the time (as a time_t) when the request was sent, or the response fully received.

The Soup-Debug line gives further debugging information about the Session, Message, and gio::Socket involved; the hex numbers are the addresses of the objects in question (which may be useful if you are running in a debugger). The decimal IDs are simply counters that uniquely identify objects across the lifetime of the #SoupLogger. In particular, this can be used to identify when multiple messages are sent across the same connection.

Currently, the request half of the message is logged just before the first byte of the request gets written to the network (from the starting signal).

The response is logged just after the last byte of the response body is read from the network (from the got-body or got-informational signal), which means that the got-headers signal, and anything triggered off it (such as #SoupMessage::authenticate) will be emitted before the response headers are actually logged.

If the response doesn’t happen to trigger the got-body nor got-informational signals due to, for example, a cancellation before receiving the last byte of the response body, the response will still be logged on the event of the finished signal.

Properties

level

The level of logging output.

Readable | Writeable

max-body-size

If level is LoggerLogLevel::Body, this gives the maximum number of bytes of the body that will be logged. (-1 means “no limit”.)

Readable | Writeable | Construct

Implements

[trait@glib::ObjectExt], SessionFeatureExt

Implementations

impl Logger

pub fn new(level: LoggerLogLevel) -> Logger

Creates a new #SoupLogger with the given debug level.

If you need finer control over what message parts are and aren’t logged, use set_request_filter() and set_response_filter().

level

the debug level

Returns

a new #SoupLogger

pub fn builder() -> LoggerBuilder

Creates a new builder-pattern struct instance to construct Logger objects.

This method returns an instance of LoggerBuilder which can be used to create Logger objects.

pub fn max_body_size(&self) -> i32

Get the maximum body size for @self.

Returns

the maximum body size, or -1 if unlimited

pub fn set_max_body_size(&self, max_body_size: i32)

Sets the maximum body size for @self (-1 means no limit).

max_body_size

the maximum body size to log

pub fn set_request_filter<P: Fn(&Logger, &Message) -> LoggerLogLevel + 'static>( &self, request_filter: P )

Sets up a filter to determine the log level for a given request.

For each HTTP request @self will invoke @request_filter to determine how much (if any) of that request to log. (If you do not set a request filter, @self will just always log requests at the level passed to new().)

request_filter

the callback for request debugging

filter_data

data to pass to the callback

pub fn set_response_filter<P: Fn(&Logger, &Message) -> LoggerLogLevel + 'static>( &self, response_filter: P )

Sets up a filter to determine the log level for a given response.

For each HTTP response @self will invoke @response_filter to determine how much (if any) of that response to log. (If you do not set a response filter, @self will just always log responses at the level passed to new().)

response_filter

the callback for response debugging

filter_data

data to pass to the callback

pub fn level(&self) -> LoggerLogLevel

The level of logging output.

pub fn set_level(&self, level: LoggerLogLevel)

The level of logging output.

pub fn connect_level_notify<F: Fn(&Self) + 'static>( &self, f: F ) -> SignalHandlerId

pub fn connect_max_body_size_notify<F: Fn(&Self) + 'static>( &self, f: F ) -> SignalHandlerId

Trait Implementations

impl Clone for Logger

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Logger

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

Formats the value using the given formatter.

impl Default for Logger

fn default() -> Self

Returns the “default value” for a type.

impl HasParamSpec for Logger

type ParamSpec = ParamSpecObject

type SetValue = Logger

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecObjectBuilder<'_, Logger>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Logger

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Logger

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl ParentClassIs for Logger

type Parent = Object

impl<OT: ObjectType> PartialEq<OT> for Logger

fn eq(&self, other: &OT) -> 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<OT: ObjectType> PartialOrd<OT> for Logger

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Logger

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Logger

impl IsA<SessionFeature> for Logger