DefaultSentryStructuredLogger.cs

using Sentry.Extensibility;
using Sentry.Infrastructure;

namespace Sentry.Internal;

internal sealed class DefaultSentryStructuredLogger : SentryStructuredLogger, IDisposable
{
    private readonly IHub _hub;
    private readonly SentryOptions _options;
    private readonly ISystemClock _clock;

    private readonly BatchProcessor<SentryLog> _batchProcessor;

    internal DefaultSentryStructuredLogger(IHub hub, SentryOptions options, ISystemClock clock, int batchCount, TimeSpan batchInterval)
    {
        Debug.Assert(hub.IsEnabled);
        Debug.Assert(options is { EnableLogs: true });

        _hub = hub;
        _options = options;
        _clock = clock;

        _batchProcessor = new SentryLogBatchProcessor(hub, batchCount, batchInterval, _options.ClientReportRecorder, _options.DiagnosticLogger);
    }

    /// <inheritdoc />
    private protected override void CaptureLog(SentryLogLevel level, string template, object[]? parameters, Action<SentryLog>? configureLog)
    {
        var timestamp = _clock.GetUtcNow();
        _hub.GetTraceIdAndSpanId(out var traceId, out var spanId);

        string message;
        try
        {
            message = string.Format(CultureInfo.InvariantCulture, template, parameters ?? []);
        }
        catch (FormatException e)
        {
            _options.DiagnosticLogger?.LogError(e, "Template string does not match the provided argument. The Log will be dropped.");
            return;
        }

        ImmutableArray<KeyValuePair<string, object>> @params = default;
        if (parameters is { Length: > 0 })
        {
            var builder = ImmutableArray.CreateBuilder<KeyValuePair<string, object>>(parameters.Length);
            for (var index = 0; index < parameters.Length; index++)
            {
                builder.Add(new KeyValuePair<string, object>(index.ToString(), parameters[index]));
            }
            @params = builder.DrainToImmutable();
        }

        SentryLog log = new(timestamp, traceId, level, message)
        {
            Template = template,
            Parameters = @params,
            SpanId = spanId,
        };

        try
        {
            configureLog?.Invoke(log);
        }
        catch (Exception e)
        {
            _options.DiagnosticLogger?.LogError(e, "The configureLog callback threw an exception. The Log will be dropped.");
            return;
        }

        var scope = _hub.GetScope();
        var sdk = scope?.Sdk;
        if (sdk is null || (sdk.Name is null && sdk.Version is null))
        {
            sdk = SdkVersion.Instance;
        }
        log.SetDefaultAttributes(_options, scope, sdk);

        CaptureLog(log);
    }

    /// <inheritdoc />
    protected internal override void CaptureLog(SentryLog log)
    {
        var configuredLog = log;

        if (_options.BeforeSendLogInternal is { } beforeSendLog)
        {
            try
            {
                configuredLog = beforeSendLog.Invoke(log);
            }
            catch (Exception e)
            {
                _options.DiagnosticLogger?.LogError(e, "The BeforeSendLog callback threw an exception. The Log will be dropped.");
                return;
            }
        }

        if (configuredLog is not null)
        {
            _batchProcessor.Enqueue(configuredLog);
        }
    }

    /// <inheritdoc />
    protected internal override void Flush()
    {
        _batchProcessor.Flush();
    }

    /// <inheritdoc />
    public void Dispose()
    {
        _batchProcessor.Dispose();
    }
}