How to serialise an object as a string in Serilog?

user_188826 0
Viewed 1594

I have a number of logs like this:

Log.Information("Submitting order {@order}", order);

This log goes through RabbitMq -> LogStash -> Elastic and ends up generating a lot of fields (I assume one field for each propery). Eventually I have thousands and thousands of fields in Elastic which brings all kinds of problems.

If I specify the whole object as a parameter, it usually means I don't care much about having all its fields being parsed, I would be more than happy if it was stored as a single string object (but still serlialised as json). Is there a way to customise it in Serilog?

serilog
2 Answers

I think you can force stringification with the $ operator. And I think you can then override the ToString method to adjust the output. There is also a short example in the documentation of serilog how to force stringification:

var unknown = new[] { 1, 2, 3 }
Log.Information("Received {$Data}", unknown);

And this is the output of the logging function:

Received "System.Int32[]"
user_109517520

@flaxel's answer works well if you're happy to change the ToString() representation of your object. If you have already overriden ToString() or you don't want it to return a JSON string then consider one of the following options.

If you don't want to log the type as JSON all the time, consider just serializing the object when you log the message. This is the most explicit approach, and allows you to pick and choose which messages have the serialized form and which have the destructured form, but it might make your log statements quite verbose:

// Using Newtonsoft.Json to serialize.
Log.Information("Submitting order {Order}", JsonConvert.SerializeObject(order));

If you always want to serialize a type to JSON, you could register a destructuring policy for that specific type. This keeps your log statements concise and ensures that type is always serialized in the same way:

// When configuring your logger.
Log.Logger = new LoggerConfiguration()
    .Destructure.ByTransforming<Order>(order => JsonConvert.SerializeObject(order))
    // ...

// This will use the destructurer registered above, so will convert to a JSON string.
Log.Information("Submitting order {@Order}", order);

// These will still use the ToString() method.
Log.Information("Submitting order {Order}", order);
Log.Information("Submitting order {$Order}", order);

Another advantage of this approach is that if you want to change the way you're representing objects of that type, or if you want to revert to the default destructuring approach, you just have to change the policy used when configuring the logger (i.e. the lambda in the snippet above).

If your serialization approach is too complicated to fit in a lambda, or you want to use the same serialization approach for a large number of types, you could define your own IDestructuringPolicy and then register it in a similar way:

class SerializationPolicy : IDestructuringPolicy
{
    public bool TryDestructure(object value, ILogEventPropertyValueFactory propertyValueFactory, out LogEventPropertyValue result)
    {
        // Check type of `value` and serialize if required.
    }
}

// When configuring your logger.
Log.Logger = new LoggerConfiguration()
    .Destructure.With<SerializationPolicy>()
    // ...
user_76945770
Related