.NET Core日志推Graylog：BufferBlock疑问及无NuGet替代方案咨询

关于BufferBlock的疑问解答 #

1. 是否需要关闭BufferBlock？ #

需要。BufferBlock属于TPL Dataflow组件，虽然空闲时不会占用线程，但当应用关闭时，必须调用Complete()方法标记块不再接收新消息，然后等待Completion任务完成，确保所有已入队的日志都被处理完毕。不这么做可能导致未处理的日志丢失，还可能留下潜在的资源泄漏（比如关联的后续处理块未正常结束）。

2. 持续运行是否正常？内存消耗多少？ #

属于正常情况。TPL Dataflow的块在空闲状态下不会占用线程，仅持有少量内部状态（比如空队列、同步对象），内存消耗极低——通常只有几十KB，完全不会对应用内存造成压力。只有当队列积压大量未处理日志时，内存才会随消息数量增长，只要处理逻辑正常，就不用担心。

3. 数小时无消息传入会发生什么？ #

没有任何问题。BufferBlock会处于空闲状态，不会占用额外资源，也不会触发异常或错误。当新日志消息进来时，它会立即恢复处理，完全适配长时间闲置后接收消息的场景。

不使用BufferBlock且无NuGet依赖的Graylog HTTP推送方案 #

可以基于.NET Core原生的HttpClient和System.Text.Json实现，核心思路是直接构建Graylog的GELF格式消息，通过HTTP请求发送，也可以自己实现简单的批量逻辑减少请求数。

步骤1：定义GELF消息模型 #

Graylog的HTTP输入接受符合GELF 1.1规范的JSON数据，先定义对应模型：

using System.Text.Json.Serialization;

public class GelfMessage
{
    [JsonPropertyName("version")]
    public string Version => "1.1";

    [JsonPropertyName("host")]
    public string Host { get; set; }

    [JsonPropertyName("short_message")]
    public string ShortMessage { get; set; }

    [JsonPropertyName("full_message")]
    public string FullMessage { get; set; }

    [JsonPropertyName("timestamp")]
    public double Timestamp => DateTimeOffset.UtcNow.ToUnixTimeSeconds() + (DateTimeOffset.UtcNow.Millisecond / 1000.0);

    [JsonPropertyName("level")]
    public int Level { get; set; }

    // 自定义字段需加下划线前缀，比如日志分类名
    [JsonPropertyName("_logger")]
    public string LoggerName { get; set; }
}

步骤2：实现日志提供器 #

基于ILoggerProvider和ILogger接口实现，使用单例HttpClient避免套接字耗尽，支持异步发送或简单批量发送：

基础版（单条发送）

using System.Text;
using System.Text.Json;
using Microsoft.Extensions.Logging;

public class GraylogHttpLoggerProvider : ILoggerProvider
{
    private readonly HttpClient _httpClient;
    private readonly string _graylogEndpoint;
    private readonly string _hostName;

    public GraylogHttpLoggerProvider(string graylogEndpoint, string hostName)
    {
        _graylogEndpoint = graylogEndpoint;
        _hostName = hostName;
        _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
    }

    public ILogger CreateLogger(string categoryName)
    {
        return new GraylogHttpLogger(this, categoryName);
    }

    public void Dispose()
    {
        _httpClient.Dispose();
    }

    private class GraylogHttpLogger : ILogger
    {
        private readonly GraylogHttpLoggerProvider _provider;
        private readonly string _categoryName;

        public GraylogHttpLogger(GraylogHttpLoggerProvider provider, string categoryName)
        {
            _provider = provider;
            _categoryName = categoryName;
        }

        public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;

        public bool IsEnabled(LogLevel logLevel) => logLevel != LogLevel.None;

        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
        {
            if (!IsEnabled(logLevel)) return;

            var message = formatter(state, exception);
            var gelfMsg = new GelfMessage
            {
                Host = _provider._hostName,
                ShortMessage = message,
                FullMessage = exception?.ToString(),
                Level = MapLogLevel(logLevel),
                LoggerName = _categoryName
            };

            // 异步发送，避免阻塞业务线程
            _ = SendAsync(gelfMsg);
        }

        private async Task SendAsync(GelfMessage msg)
        {
            try
            {
                var json = JsonSerializer.Serialize(msg);
                var content = new StringContent(json, Encoding.UTF8, "application/json");
                var response = await _provider._httpClient.PostAsync(_provider._graylogEndpoint, content);
                response.EnsureSuccessStatusCode();
            }
            catch (Exception ex)
            {
                // 异常处理：可写入本地日志或忽略，不要抛出影响业务
                Console.WriteLine($"Graylog推送失败: {ex.Message}");
            }
        }

        private int MapLogLevel(LogLevel logLevel)
        {
            // 映射.NET日志级别到Graylog的syslog级别
            return logLevel switch
            {
                LogLevel.Critical => 2,
                LogLevel.Error => 3,
                LogLevel.Warning => 4,
                LogLevel.Information => 6,
                LogLevel.Debug => 7,
                LogLevel.Trace => 7,
                _ => 6
            };
        }
    }

    private class NullScope : IDisposable
    {
        public static NullScope Instance { get; } = new();
        public void Dispose() { }
    }
}

批量版（减少HTTP请求）

如果日志量较大，可通过ConcurrentQueue+Timer实现批量发送：

using System.Collections.Concurrent;
using System.Text;
using System.Text.Json;
using Microsoft.Extensions.Logging;

public class GraylogBatchHttpLoggerProvider : ILoggerProvider
{
    private readonly HttpClient _httpClient;
    private readonly string _graylogEndpoint;
    private readonly string _hostName;
    private readonly ConcurrentQueue<GelfMessage> _messageQueue;
    private readonly Timer _flushTimer;
    private readonly int _maxBatchSize = 20;
    private readonly TimeSpan _flushInterval = TimeSpan.FromSeconds(5);

    public GraylogBatchHttpLoggerProvider(string graylogEndpoint, string hostName)
    {
        _graylogEndpoint = graylogEndpoint;
        _hostName = hostName;
        _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
        _messageQueue = new ConcurrentQueue<GelfMessage>();
        _flushTimer = new Timer(FlushQueue, null, _flushInterval, _flushInterval);
    }

    private void FlushQueue(object state)
    {
        var batch = new List<GelfMessage>();
        while (_messageQueue.TryDequeue(out var msg) && batch.Count < _maxBatchSize)
        {
            batch.Add(msg);
        }

        if (batch.Count == 0) return;

        try
        {
            var json = JsonSerializer.Serialize(batch);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var response = _httpClient.PostAsync(_graylogEndpoint, content).GetAwaiter().GetResult();
            response.EnsureSuccessStatusCode();
        }
        catch (Exception ex)
        {
            // 发送失败时将消息放回队列（可添加重试次数限制避免死循环）
            foreach (var msg in batch) _messageQueue.Enqueue(msg);
            Console.WriteLine($"Graylog批量推送失败: {ex.Message}");
        }
    }

    public ILogger CreateLogger(string categoryName)
    {
        return new GraylogBatchLogger(this, categoryName);
    }

    public void Dispose()
    {
        _flushTimer.Dispose();
        _httpClient.Dispose();
        // 应用关闭时手动刷新剩余消息
        FlushQueue(null);
    }

    private class GraylogBatchLogger : ILogger
    {
        private readonly GraylogBatchHttpLoggerProvider _provider;
        private readonly string _categoryName;

        public GraylogBatchLogger(GraylogBatchHttpLoggerProvider provider, string categoryName)
        {
            _provider = provider;
            _categoryName = categoryName;
        }

        public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;

        public bool IsEnabled(LogLevel logLevel) => logLevel != LogLevel.None;

        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
        {
            if (!IsEnabled(logLevel)) return;

            var message = formatter(state, exception);
            var gelfMsg = new GelfMessage
            {
                Host = _provider._hostName,
                ShortMessage = message,
                FullMessage = exception?.ToString(),
                Level = MapLogLevel(logLevel),
                LoggerName = _categoryName
            };

            _provider._messageQueue.Enqueue(gelfMsg);
        }

        private int MapLogLevel(LogLevel logLevel)
        {
            return logLevel switch
            {
                LogLevel.Critical => 2,
                LogLevel.Error => 3,
                LogLevel.Warning => 4,
                LogLevel.Information => 6,
                LogLevel.Debug => 7,
                LogLevel.Trace => 7,
                _ => 6
            };
        }
    }

    private class NullScope : IDisposable
    {
        public static NullScope Instance { get; } = new();
        public void Dispose() { }
    }
}

步骤3：注册日志提供器 #

在Program.cs中添加注册代码：

var builder = WebApplication.CreateBuilder(args);

// 注册基础版
builder.Logging.AddProvider(new GraylogHttpLoggerProvider(
    "http://your-graylog-server:12201/gelf", 
    Environment.MachineName));

// 或注册批量版
// builder.Logging.AddProvider(new GraylogBatchHttpLoggerProvider(
//     "http://your-graylog-server:12201/gelf", 
//     Environment.MachineName));

var app = builder.Build();
// ... 其他配置 ...
app.Run();

内容的提问来源于stack exchange，提问作者dev