perf(logs): avoid string allocation when no parameters are passed

benchmarks/Sentry.Benchmarks/BenchmarkDotNet.Artifacts/results/Sentry.Benchmarks.SentryStructuredLoggerBenchmarks-report-github.md

@@ -0,0 +1,14 @@
+```
+
+BenchmarkDotNet v0.13.12, macOS 26.3.1 (a) (25D771280a) [Darwin 25.3.0]
+Apple M3 Pro, 1 CPU, 12 logical and 12 physical cores
+.NET SDK 10.0.201
+  [Host]     : .NET 9.0.8 (9.0.825.36511), Arm64 RyuJIT AdvSIMD
+  DefaultJob : .NET 9.0.8 (9.0.825.36511), Arm64 RyuJIT AdvSIMD
+
+
+```
+| Method               | Mean     | Error   | StdDev  | Gen0   | Gen1   | Allocated |
+|--------------------- |---------:|--------:|--------:|-------:|-------:|----------:|
+| LogWithoutParameters | 102.3 ns | 1.28 ns | 1.19 ns | 0.0640 | 0.0001 |     536 B |
+| LogWithParameters    | 248.5 ns | 4.86 ns | 5.40 ns | 0.1087 |      - |     912 B |

benchmarks/Sentry.Benchmarks/SentryStructuredLoggerBenchmarks.cs

@@ -0,0 +1,59 @@
+#nullable enable
+
+using BenchmarkDotNet.Attributes;
+using Sentry.Extensibility;
+using Sentry.Internal;
+using Sentry.Testing;
+
+namespace Sentry.Benchmarks;
+
+public class SentryStructuredLoggerBenchmarks
+{
+    private Hub _hub = null!;
+    private SentryStructuredLogger _logger = null!;
+
+    private SentryLog? _lastLog;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        SentryOptions options = new()
+        {
+            Dsn = DsnSamples.ValidDsn,
+            EnableLogs = true,
+        };
+        options.SetBeforeSendLog((SentryLog log) =>
+        {
+            _lastLog = log;
+            return null;
+        });
+
+        MockClock clock = new(new DateTimeOffset(2025, 04, 22, 14, 51, 00, 789, TimeSpan.FromHours(2)));
+
+        _hub = new Hub(options, DisabledHub.Instance);
+        _logger = SentryStructuredLogger.Create(_hub, options, clock);
+    }
+
+    [Benchmark]
+    public void LogWithoutParameters()
+    {
+        _logger.LogInfo("Message Text");
+    }
+
+    [Benchmark]
+    public void LogWithParameters()
+    {
+        _logger.LogInfo("Template string with arguments: {0}, {1}, {2}, {3}", "string", true, 1, 2.2);
+    }
+
+    [GlobalCleanup]
+    public void Cleanup()
+    {
+        _hub.Dispose();
+
+        if (_lastLog is null)
+        {
+            throw new InvalidOperationException("Last Log is null");
+        }
+    }
+}

src/Sentry/Internal/DefaultSentryStructuredLogger.cs

@@ -30,26 +30,33 @@ private protected override void CaptureLog(SentryLogLevel level, string template
         _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;
 
-        ImmutableArray<KeyValuePair<string, object>> @params = default;
         if (parameters is { Length: > 0 })
         {
+            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;
+            }
+
             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();
         }
+        else
+        {
+            message = template;
+            template = null!; // SentryLog.Template is declared nullable (string?)
+            @params = ImmutableArray<KeyValuePair<string, object>>.Empty;
+        }
 
         SentryLog log = new(timestamp, traceId, level, message)
         {

src/Sentry/SentryLog.cs

@@ -25,6 +25,8 @@ internal SentryLog(DateTimeOffset timestamp, SentryId traceId, SentryLogLevel le
         Message = message;
         // 7 is the number of built-in attributes, so we start with that.
         _attributes = new Dictionary<string, SentryAttribute>(7);
+        // ensure the ImmutableArray`1 is not default, so we can omit IsDefault checks before accessing other members
+        Parameters = ImmutableArray<KeyValuePair<string, object>>.Empty;
     }
 
     /// <summary>
@@ -58,7 +60,15 @@ internal SentryLog(DateTimeOffset timestamp, SentryId traceId, SentryLogLevel le
     /// <summary>
     /// The parameters to the template string.
     /// </summary>
-    public ImmutableArray<KeyValuePair<string, object>> Parameters { get; init; }
+    public ImmutableArray<KeyValuePair<string, object>> Parameters
+    {
+        get;
+        init
+        {
+            Debug.Assert(!value.IsDefault); // DEBUG-only check, because .ctor is internal and set-accessor is init-only
+            field = value;
+        }
+    }
 
     /// <summary>
     /// The span id of the span that was active when the log was collected.
@@ -190,6 +200,8 @@ internal void SetOrigin(string origin)
 
     internal void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
     {
+        Debug.Assert(!Parameters.IsDefault);
+
         writer.WriteStartObject();
 
 #if NET9_0_OR_GREATER
@@ -222,17 +234,14 @@ internal void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
 
         // the SDK MUST NOT attach a sentry.message.template attribute if there are no parameters
         // https://develop.sentry.dev/sdk/telemetry/logs/#default-attributes
-        if (Template is not null && !Parameters.IsDefaultOrEmpty)
+        if (Template is not null && !Parameters.IsEmpty)
         {
             SentryAttributeSerializer.WriteStringAttribute(writer, "sentry.message.template", Template);
         }
 
-        if (!Parameters.IsDefault)
+        foreach (var parameter in Parameters)
         {
-            foreach (var parameter in Parameters)
-            {
-                SentryAttributeSerializer.WriteAttribute(writer, $"sentry.message.parameter.{parameter.Key}", parameter.Value, logger);
-            }
+            SentryAttributeSerializer.WriteAttribute(writer, $"sentry.message.parameter.{parameter.Key}", parameter.Value, logger);
         }
 
         foreach (var attribute in _attributes)

test/Sentry.Tests/SentryLogTests.cs

@@ -22,6 +22,28 @@ public SentryLogTests(ITestOutputHelper output)
         _output = new TestOutputDiagnosticLogger(output);
     }
 
+    [Fact]
+    public void Create_Default_HasMinimalSpecification()
+    {
+        var log = new SentryLog(Timestamp, TraceId, (SentryLogLevel)24, "message");
+
+        log.Timestamp.Should().Be(Timestamp);
+        log.TraceId.Should().Be(TraceId);
+        log.Level.Should().Be((SentryLogLevel)24);
+        log.Message.Should().Be("message");
+        log.Template.Should().Be(null);
+        log.Parameters.Should().BeEmpty();
+        log.SpanId.Should().Be(null);
+
+#if DEBUG
+        var assignDefault = static () => new SentryLog(Timestamp, TraceId, (SentryLogLevel)24, "message")
+        {
+            Parameters = default,
+        };
+        assignDefault.Should().Throw<Exception>("Disallow default ImmutableArray");
+#endif
+    }
+
     [Fact]
     public void Protocol_Default_VerifyAttributes()
     {

test/Sentry.Tests/SentryMetricTests.cs

@@ -22,6 +22,20 @@ public SentryMetricTests(ITestOutputHelper output)
         _output = new TestOutputDiagnosticLogger(output);
     }
 
+    [Fact]
+    public void Create_Default_HasMinimalSpecification()
+    {
+        var metric = new SentryMetric<int>(Timestamp, TraceId, SentryMetricType.Counter, "sentry_tests.sentry_metric_tests.counter", 1);
+
+        metric.Timestamp.Should().Be(Timestamp);
+        metric.TraceId.Should().Be(TraceId);
+        metric.Type.Should().Be(SentryMetricType.Counter);
+        metric.Name.Should().Be("sentry_tests.sentry_metric_tests.counter");
+        metric.Value.Should().Be(1);
+        metric.SpanId.Should().Be(null);
+        metric.Unit.Should().BeEquivalentTo(null);
+    }
+
     [Fact]
     public void Protocol_Default_VerifyAttributes()
     {

test/Sentry.Tests/SentryStructuredLoggerTests.Format.cs

@@ -83,6 +83,36 @@ public void Log_ConfigureLog_Disabled_DoesNotCaptureEnvelope(SentryLogLevel leve
 
         _fixture.Hub.Received(0).CaptureEnvelope(Arg.Any<Envelope>());
     }
+
+    [Theory]
+    [InlineData(SentryLogLevel.Trace)]
+    [InlineData(SentryLogLevel.Debug)]
+    [InlineData(SentryLogLevel.Info)]
+    [InlineData(SentryLogLevel.Warning)]
+    [InlineData(SentryLogLevel.Error)]
+    [InlineData(SentryLogLevel.Fatal)]
+    public void Log_WithoutParameters_DoesNotAttachTemplateAttribute(SentryLogLevel level)
+    {
+        _fixture.Options.EnableLogs = true;
+        var logger = _fixture.GetSut();
+
+        Envelope envelope = null!;
+        _fixture.Hub.CaptureEnvelope(Arg.Do<Envelope>(arg => envelope = arg));
+
+        logger.Log(level, "Message Text");
+        logger.Flush();
+
+        _fixture.Hub.Received(1).CaptureEnvelope(Arg.Any<Envelope>());
+        var log = envelope.ShouldContainSingleLog();
+
+        log.Level.Should().Be(level);
+        log.Message.Should().Be("Message Text");
+        log.Template.Should().BeNull();
+        log.Parameters.Should().BeEmpty();
+
+        log.TryGetAttribute("sentry.message.template", out object? template).Should().BeFalse();
+        template.Should().BeNull();
+    }
 }
 
 file static class SentryStructuredLoggerExtensions

test/Sentry.Tests/SentryStructuredLoggerTests.cs

@@ -301,4 +301,14 @@ public static void AssertLog(this SentryStructuredLoggerTests.Fixture fixture, S
     {
         return new KeyValuePair<string, object?>(name, value);
     }
+
+    public static SentryLog ShouldContainSingleLog(this Envelope envelope)
+    {
+        var envelopeItem = envelope.Items.Should().ContainSingle().Which;
+        var serializable = envelopeItem.Payload.Should().BeOfType<JsonSerializable>().Which;
+        var log = serializable.Source.Should().BeOfType<StructuredLog>().Which;
+
+        log.Items.Length.Should().Be(1);
+        return log.Items[0];
+    }
 }