Struct Serde

pub struct Serde<T>(pub T)
where
    T: Serialize + Clone + Send + 'static;

Use to wrap a value that implements serde::Serialize so it’s written to the log record as an object, rather than a primitive.

Examples

#[derive(Clone, Serialize)]
struct Thing {
    one: String,
    two: String,
}


    let thing = get_thing();

    info!(log, "Got a thing"; "thing" => slog::Serde(thing.clone()));

Tuple Fields

0: T

Trait Implementations

impl<T> Clone for Serde<T>

where T: Serialize + Clone + Send + 'static + Clone,

fn clone(&self) -> Serde<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> SerdeValue for Serde<T>

where T: Serialize + Clone + Send + 'static,

fn as_serde(&self) -> &dyn Serialize

Convert to erased_serialize::Serialize of the underlying value, so slog::Serializers can use it to serialize via serde.

fn to_sendable(&self) -> Box<dyn SerdeValue + Send + 'static>

Convert to a boxed value that can be sent across threads

fn serialize_fallback( &self, _key: Key, _serializer: &mut dyn Serializer, ) -> Result<()>

Serialize the value in a way that is compatible with slog::Serializers that do not support serde.

impl<T: Serialize + Clone + Send + 'static> Serialize for Serde<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Value for Serde<T>

where T: Serialize + Clone + Send + 'static,

fn serialize( &self, _: &Record<'_>, key: Key, serializer: &mut dyn Serializer, ) -> Result

Serialize self into Serializer