Question

Serilog是否可以从LogContext获取所有属性？ LogContext是否支持序列化/反序列化以在进程之间传递上下文？

Answer 1

在进程之间没有通过LogContext状态的防弹方法。但是，有一种解决方案适用于大多数情况（限制列在答案底部）。

LogContext是一个静态类，它公开以下方法：

public static class LogContext
{
    public static ILogEventEnricher Clone();
    public static IDisposable Push(ILogEventEnricher enricher);
    public static IDisposable Push(params ILogEventEnricher[] enrichers);
    [Obsolete("Please use `LogContext.Push(properties)` instead.")]
    public static IDisposable PushProperties(params ILogEventEnricher[] properties);
    public static IDisposable PushProperty(string name, object value, bool destructureObjects = false);
}

这对Clone()和Push(ILogEventEnricher enricher)方法看起来非常有前景，但是如何在进程之间传递返回的ILogEventEnricher实例？

让我们深入研究LogContext source code。首先，我们看到所有Push变体通过添加Enrichers的新实例来改变ImmutableStack<ILogEventEnricher>类型的私有ILogEventEnricher属性。最常用的方法PushProperty(string name, object value, bool destructureObjects = false)添加了PropertyEnricher的实例：

public static IDisposable PushProperty(string name, object value, bool destructureObjects = false)
{
    return Push(new PropertyEnricher(name, value, destructureObjects));
}

Clone()只是回归了SafeAggregateEnricher包含的一堆浓缩物：

public static ILogEventEnricher Clone()
{
    var stack = GetOrCreateEnricherStack();
    return new SafeAggregateEnricher(stack);
}

因此，我们可以通过提取LogContext方法返回的richher中存储的值来传递Clone()的状态。 ILogEventEnricher有唯一的方法：

public interface ILogEventEnricher
{
    void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory);
}

通过将LogEvent的实例添加到其LogEventPropertyValue词典中，加密者会影响Properties。遗憾的是，没有简单的方法来保存事件属性对象的状态，因为LogEventPropertyValue是一个抽象类，其后代有ScalarValue，DictionaryValue等。

但是我们可以使用ILogEventPropertyFactory的自定义实现来收集所有创建的属性并公开它们以便在进程之间进行传输。缺点是并非所有的富集都使用propertyFactory。其中一些直接创建属性，例如ThreadIdEnricher：

public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
{
    logEvent.AddPropertyIfAbsent(new LogEventProperty(ThreadIdPropertyName, new ScalarValue(Environment.CurrentManagedThreadId)));
}

然而PropertyEnricher可能是我们案例中最有趣的{/ 3}}使用工厂：

public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
{
    if (logEvent == null) throw new ArgumentNullException(nameof(logEvent));
    if (propertyFactory == null) throw new ArgumentNullException(nameof(propertyFactory));
    var property = propertyFactory.CreateProperty(_name, _value, _destructureObjects);
    logEvent.AddPropertyIfAbsent(property);
}

现在计划应该清楚：

创建收集所有已创建属性的ILogEventPropertyFactory自定义实现。
克隆LogContext以获得聚合增强。
致电此Enrich上的每个媒体资源CreateProperty，最终致电LogContext。
序列化收到的属性并在进程之间传递。
反序列化另一端的属性并填充上下文。

以下是实现这些步骤的代码：

PropertyValue类：

public class PropertyValue
{
    public string Name { get; set; }

    public object Value { get; set; }

    public bool DestructureObjects { get; set; }

    public PropertyValue(string name, object value, bool destructureObjects)
    {
        Name = name;
        Value = value;
        DestructureObjects = destructureObjects;
    }
}

LogContextDump类：

public class LogContextDump
{
    public ICollection<PropertyValue> Properties { get; set; }

    public LogContextDump(IEnumerable<PropertyValue> properties)
    {
        Properties = new Collection<PropertyValue>(properties.ToList());
    }

    public IDisposable PopulateLogContext()
    {
        return LogContext.Push(Properties.Select(p => new PropertyEnricher(p.Name, p.Value, p.DestructureObjects) as ILogEventEnricher).ToArray());
    }
}

CaptureLogEventPropertyFactory类：

public class CaptureLogEventPropertyFactory : ILogEventPropertyFactory
{
    private readonly List<PropertyValue> values = new List<PropertyValue>();

    public LogEventProperty CreateProperty(string name, object value, bool destructureObjects = false)
    {
        values.Add(new PropertyValue(name, value, destructureObjects));
        return new LogEventProperty(name, new ScalarValue(value));
    }

    public LogContextDump Dump()
    {
        return new LogContextDump((values as IEnumerable<PropertyValue>).Reverse());
    }
}

LogContextSerializer类：

public static class LogContextSerializer
{
    public static LogContextDump Serialize()
    {
        var logContextEnricher = LogContext.Clone();
        var captureFactory = new CaptureLogEventPropertyFactory();
        logContextEnricher.Enrich(new LogEvent(DateTimeOffset.Now, LogEventLevel.Verbose, null, MessageTemplate.Empty, Enumerable.Empty<LogEventProperty>()), captureFactory);

        return captureFactory.Dump();
    }

    public static IDisposable Deserialize(LogContextDump contextDump)
    {
        return contextDump.PopulateLogContext();
    }
}

使用示例：

string jsonData;
using (LogContext.PushProperty("property1", "SomeValue"))
using (LogContext.PushProperty("property2", 123))
{
    var dump = LogContextSerializer.Serialize();
    jsonData = JsonConvert.SerializeObject(dump);
}

//  Pass jsonData between processes

var restoredDump = JsonConvert.DeserializeObject<LogContextDump>(jsonData);
using (LogContextSerializer.Deserialize(restoredDump))
{
    //  LogContext is the same as when Clone() was called above
}

我在这里使用了序列化到JSON，但是使用LogContextDump和PropertyValue这样的原始类型，您可以使用任何所需的序列化机制。

正如我已经说过，这种解决方案有其缺点：

已恢复的LogContext与原始版本不是100％相同。原始LogContext可以有不同类型的限制器，但恢复的上下文只有PropertyEnricher的实例。但是，如果您使用LogContext作为上述示例中的属性的简单包，那应该不是问题。
如果某些上下文丰富程序直接绕过propertyFactory创建属性，则此解决方案将无效。
如果某些添加的值具有无法序列化的类型，则此解决方案将无效。上面Value中的PropertyValue属性的类型为object。您可以将任何类型的属性添加到LogContext，但您应该有一种方法可以序列化其数据以便在进程之间传递。以上对JSON的序列化/反序列化将适用于简单类型，但如果向LogContext添加一些复杂值，则必须对其进行调整。

在进程之间传递Serilog LogContext

1 个答案: