高效快速地读取 Windows 日志

Question

我想要完成的是一个 C# 应用程序，它将从 Windows 事件日志中读取日志并将它们存储在其他地方。这必须很快，因为将安装它的某些设备会产生大量的日志/秒。

到目前为止，我已经尝试了三种方法：

Local WMI：效果不好，由于需要加载的集合大小导致的错误和异常太多。 EventLogReader：我认为这是一个完美的解决方案，因为它允许您使用 XPath 表达式查询事件日志。问题在于，当您想要获取每个日志的消息内容（通过调用 FormatDescription()）时，对于长时间的收集来说，时间太长了。 例如：如果我浏览它们，我可以在 0.11 秒内读取 12k 条日志。 如果我为每个日志添加一行来存储消息，则需要将近 6 分钟才能完成完全相同的操作，这对于如此少的日志数量来说是完全疯狂的。 我不知道是否可以对 EventLogReader 进行任何优化以更快地获取消息，我在 MS 文档和 Internet 上都找不到任何内容。

我还发现您可以使用名为 EventLog 的类来读取日志条目。但是，该技术不允许您输入任何类型的过滤器，因此您基本上必须将整个日志列表加载到内存中，然后根据需要将其过滤掉。 这是一个例子：

EventLog eventLog = EventLog.GetEventLogs().FirstOrDefault(el => el.Log.Equals("Security", StringComparison.OrdinalIgnoreCase));
var newEntries = (from entry in eventLog.Entries.OfType()
orderby entry.TimeWritten ascending
where entry.TimeWritten > takefrom
select entry);

尽管在获取消息方面速度更快，但内存使用率可能很高，我不想在部署此解决方案的设备上造成任何问题。

谁能帮我解决这个问题？我找不到任何解决方法或方法来实现这样的目标。

谢谢！

Answer 1

你可以试试 EventLogReader 类。见https://docs.microsoft.com/en-us/previous-versions/bb671200(v=vs.90)。

它比 EventLog 类更好，因为访问 EventLog.Entries 集合具有令人讨厌的属性，当您从它读取时，它的计数可能会改变。更糟糕的是，读取发生在 IO 线程池线程上，这将使您的应用程序因未处理的异常而崩溃。至少几年前是这样的。

EventLogReader 还使您能够提供查询字符串来过滤您感兴趣的事件。如果您编写一个新的应用程序，这就是要走的路。

这是一个展示如何并行阅读的应用程序：

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Eventing.Reader;
using System.Linq;
using System.Threading.Tasks;

namespace EventLogReading
{
    class Program
    {
        static volatile bool myHasStoppedReading = false;

        static void ParseEventsParallel()
        {
            var sw = Stopwatch.StartNew();
            var query = new EventLogQuery("Application", PathType.LogName, "*");

            const int BatchSize = 100;

            ConcurrentQueue<EventRecord> events = new ConcurrentQueue<EventRecord>();
            var readerTask = Task.Factory.StartNew(() =>
            {
                using (EventLogReader reader = new EventLogReader(query))
                {
                    EventRecord ev;
                    bool bFirst = true;
                    int count = 0;
                    while ((ev = reader.ReadEvent()) != null)
                    {
                        if ( count % BatchSize == 0)
                        {
                            events.Enqueue(ev);
                        }
                        count++;
                    }
                }
                myHasStoppedReading = true;
            });

            ConcurrentQueue<KeyValuePair<string, EventRecord>> eventsWithStrings = new ConcurrentQueue<KeyValuePair<string, EventRecord>>();

            Action conversion = () =>
            {
                EventRecord ev = null;
                using (var reader = new EventLogReader(query))
                {
                    while (!myHasStoppedReading || events.TryDequeue(out ev))
                    {
                        if (ev != null)
                        {
                            reader.Seek(ev.Bookmark);
                            for (int i = 0; i < BatchSize; i++)
                            {
                                ev = reader.ReadEvent();
                                if (ev == null)
                                {
                                    break;
                                }
                                eventsWithStrings.Enqueue(new KeyValuePair<string, EventRecord>(ev.FormatDescription(), ev));
                            }
                        }
                    }
                }
            };

            Parallel.Invoke(Enumerable.Repeat(conversion, 8).ToArray());

            sw.Stop();
            Console.WriteLine($"Got {eventsWithStrings.Count} events with strings in {sw.Elapsed.TotalMilliseconds:N3}ms");
        }

        static void ParseEvents()
        {
            var sw = Stopwatch.StartNew();
            List<KeyValuePair<string, EventRecord>> parsedEvents = new List<KeyValuePair<string, EventRecord>>();
                
            using (EventLogReader reader = new EventLogReader(new EventLogQuery("Application", PathType.LogName, "*")))
            {
                EventRecord ev;
                while ((ev = reader.ReadEvent()) != null)
                {
                    parsedEvents.Add(new KeyValuePair<string, EventRecord>(ev.FormatDescription(), ev));
                }
            }

            sw.Stop();
            Console.WriteLine($"Got {parsedEvents.Count} events with strings in {sw.Elapsed.TotalMilliseconds:N3}ms");
        }

        static void Main(string[] args)
        {
            ParseEvents();
            ParseEventsParallel();
        }
    }
}

Got 20322 events with strings in 19,320.047ms
Got 20323 events with strings in 5,327.064ms

这提供了一个不错的 4 倍加速。我需要使用一些技巧来提高速度，因为出于某种奇怪的原因，类 ProviderMetadataCachedInformation 不是线程安全的，并且在内部使用 Format 方法周围的锁（this），这会破坏并行读取. 关键技巧是再次打开转换线程中的事件日志，然后通过事件书签 Api 读取一堆查询事件。这样你就可以独立地格式化字符串了。

更新1

我在 .NET 5 中进行了更改，将性能提高了 3 倍，最高可达 20。请参阅 https://github.com/dotnet/runtime/issues/34568。 您还可以从 .NET Core 复制 EventLogReader 类并改用这个类，这将为您提供相同的加速。

我的博文描述了完整的传奇：https://aloiskraus.wordpress.com/2020/07/20/ms-performance-hud-analyze-eventlog-reading-performance-in-realtime/

Answer 2

我们讨论了一点关于读取 cmets 中现有日志的内容，可以通过以下方式访问带有Security 标记的日志：

 var eventLog = new EventLog("Security");
 for (int i = 0; i < eventLog.Entries.Count; i++)
 {
      Console.WriteLine($"{eventLog.Entries[i].Message}");
 }

这可能不是最干净（性能方面）的方式，但我怀疑任何其他方式都会更快，因为您自己已经通过尝试不同的技术发现了这一点。 对 Alois 帖子的一个小编辑二人组：EventLogReader 开箱即用并不比EventLog 快，尤其是在使用上面代码块中显示的for-loop 机制时，我认为EventLog 更快——它只访问循环内的条目使用它们的索引，Entries 集合只是一个参考，而在使用EventLogReader 时，它将首先执行查询并循环该结果，这应该会更慢。正如对 Alois 帖子的评论：如果您不需要使用查询选项，只需使用 EventLog 变体。如果确实需要查询，请按原样使用EventLogReader 可以在比使用EventLog 时更低的级别进行查询（仅限LINQ 查询，这当然比在执行查找时查询要慢）。

为了防止您将来再次遇到这种麻烦，并且因为您说您正在运行服务，我将使用 EventLog 类的 EntryWritten 事件：

    var eventLog = new EventLog("Security")
    {
        EnableRaisingEvents = true
    };
    eventLog.EntryWritten += EventLog_EntryWritten;

    // .. read existing logs or do other work ..

    private static void EventLog_EntryWritten(object sender, EntryWrittenEventArgs e)
    {
        Console.WriteLine($"received new entry: {e.Entry.Message}");
    }

请注意，您必须将EnableRaisingEvents 设置为true，以便在记录新条目时触发事件。启动（例如）Task 也是一个很好的做法（同样，性能方面），这样系统就不会在排队调用您的事件时锁定自己。

如果您想检索 所有 新创建的事件，此方法可以正常工作，如果您想检索新创建的事件但对这些事件使用查询（过滤器），您可以查看 @987654325 @ 类，但在你的情况下，当没有限制时，我只使用 EntryWritten 事件，因为你不需要过滤器并且为了简单而简单。