test(metrics): Trace-connected Metrics (Tests)

test/Sentry.Tests/Extensibility/DisabledHubTests.cs

@@ -39,4 +39,8 @@ public void CaptureEvent_EmptyGuid()
     [Fact]
     public void Logger_IsDisabled()
         => Assert.IsType<DisabledSentryStructuredLogger>(DisabledHub.Instance.Logger);
+
+    [Fact]
+    public void Metrics_IsDisabled()
+        => Assert.IsType<DisabledSentryTraceMetrics>(DisabledHub.Instance.Metrics);
 }

test/Sentry.Tests/Extensibility/HubAdapterTests.cs

@@ -82,6 +82,18 @@ public void Logger_MockInvoked()
             element => element.AssertEqual(SentryLogLevel.Warning, "Message"));
     }
 
+    [Fact]
+    public void Metrics_MockInvoked()
+    {
+        var metrics = new InMemorySentryTraceMetrics();
+        Hub.Metrics.Returns(metrics);
+
+        HubAdapter.Instance.Metrics.EmitCounter("sentry_tests.hub_adapter_tests.counter", 1);
+
+        Assert.Collection(metrics.Entries,
+            element => element.AssertEqual(SentryMetricType.Counter, "sentry_tests.hub_adapter_tests.counter", 1));
+    }
+
     [Fact]
     public void EndSession_CrashedStatus_MockInvoked()
     {

test/Sentry.Tests/HubTests.cs

@@ -1879,6 +1879,124 @@ public void Logger_Dispose_DoesCaptureLog()
         hub.Logger.Should().BeOfType<DefaultSentryStructuredLogger>();
     }
 
+    [Fact]
+    public void Metrics_IsDisabled_DoesNotCaptureMetric()
+    {
+        // Arrange
+        _fixture.Options.Experimental.EnableMetrics = false;
+        var hub = _fixture.GetSut();
+
+        // Act
+        hub.Metrics.EmitCounter("sentry_tests.hub_tests.counter", 1);
+        hub.Metrics.Flush();
+
+        // Assert
+        _fixture.Client.Received(0).CaptureEnvelope(
+            Arg.Is<Envelope>(envelope =>
+                envelope.Items.Single(item => item.Header["type"].Equals("trace_metric")).Payload.GetType().IsAssignableFrom(typeof(JsonSerializable))
+            )
+        );
+        hub.Metrics.Should().BeOfType<DisabledSentryTraceMetrics>();
+    }
+
+    [Fact]
+    public void Metrics_IsEnabled_DoesCaptureMetric()
+    {
+        // Arrange
+        Assert.True(_fixture.Options.Experimental.EnableMetrics);
+        var hub = _fixture.GetSut();
+
+        // Act
+        hub.Metrics.EmitCounter("sentry_tests.hub_tests.counter", 1);
+        hub.Metrics.Flush();
+
+        // Assert
+        _fixture.Client.Received(1).CaptureEnvelope(
+            Arg.Is<Envelope>(envelope =>
+                envelope.Items.Single(item => item.Header["type"].Equals("trace_metric")).Payload.GetType().IsAssignableFrom(typeof(JsonSerializable))
+            )
+        );
+        hub.Metrics.Should().BeOfType<DefaultSentryTraceMetrics>();
+    }
+
+    [Fact]
+    public void Metrics_EnableAfterCreate_HasNoEffect()
+    {
+        // Arrange
+        _fixture.Options.Experimental.EnableMetrics = false;
+        var hub = _fixture.GetSut();
+
+        // Act
+        _fixture.Options.Experimental.EnableMetrics = true;
+
+        // Assert
+        hub.Metrics.Should().BeOfType<DisabledSentryTraceMetrics>();
+    }
+
+    [Fact]
+    public void Metrics_DisableAfterCreate_HasNoEffect()
+    {
+        // Arrange
+        Assert.True(_fixture.Options.Experimental.EnableMetrics);
+        var hub = _fixture.GetSut();
+
+        // Act
+        _fixture.Options.Experimental.EnableMetrics = false;
+
+        // Assert
+        hub.Metrics.Should().BeOfType<DefaultSentryTraceMetrics>();
+    }
+
+    [Fact]
+    public async Task Metrics_FlushAsync_DoesCaptureMetric()
+    {
+        // Arrange
+        Assert.True(_fixture.Options.Experimental.EnableMetrics);
+        var hub = _fixture.GetSut();
+
+        // Act
+        hub.Metrics.EmitCounter("sentry_tests.hub_tests.counter", 1);
+        await hub.FlushAsync();
+
+        // Assert
+        _fixture.Client.Received(1).CaptureEnvelope(
+            Arg.Is<Envelope>(envelope =>
+                envelope.Items.Single(item => item.Header["type"].Equals("trace_metric")).Payload.GetType().IsAssignableFrom(typeof(JsonSerializable))
+            )
+        );
+        await _fixture.Client.Received(1).FlushAsync(
+            Arg.Is<TimeSpan>(timeout =>
+                timeout.Equals(_fixture.Options.FlushTimeout)
+            )
+        );
+        hub.Metrics.Should().BeOfType<DefaultSentryTraceMetrics>();
+    }
+
+    [Fact]
+    public void Metrics_Dispose_DoesCaptureMetric()
+    {
+        // Arrange
+        Assert.True(_fixture.Options.Experimental.EnableMetrics);
+        var hub = _fixture.GetSut();
+
+        // Act
+        hub.Metrics.EmitCounter("sentry_tests.hub_tests.counter", 1);
+        hub.Dispose();
+
+        // Assert
+        _fixture.Client.Received(1).CaptureEnvelope(
+            Arg.Is<Envelope>(envelope =>
+                envelope.Items.Single(item => item.Header["type"].Equals("trace_metric")).Payload.GetType().IsAssignableFrom(typeof(JsonSerializable))
+            )
+        );
+        _fixture.Client.Received(1).FlushAsync(
+            Arg.Is<TimeSpan>(timeout =>
+                timeout.Equals(_fixture.Options.ShutdownTimeout)
+            )
+        );
+        hub.Metrics.Should().BeOfType<DefaultSentryTraceMetrics>();
+    }
+
     [Fact]
     public void Dispose_IsEnabled_SetToFalse()
     {

test/Sentry.Tests/Protocol/TraceMetricTests.cs

@@ -0,0 +1,58 @@
+namespace Sentry.Tests.Protocol;
+
+/// <summary>
+/// See <see href="https://develop.sentry.dev/sdk/telemetry/metrics/"/>.
+/// See also <see cref="Sentry.Tests.SentryMetricTests"/>.
+/// </summary>
+public class TraceMetricTests
+{
+    private readonly TestOutputDiagnosticLogger _output;
+
+    public TraceMetricTests(ITestOutputHelper output)
+    {
+        _output = new TestOutputDiagnosticLogger(output);
+    }
+
+    [Fact]
+    public void Type_IsAssignableFrom_ISentryJsonSerializable()
+    {
+        var metric = new TraceMetric([]);
+
+        Assert.IsAssignableFrom<ISentryJsonSerializable>(metric);
+    }
+
+    [Fact]
+    public void Length_One_Single()
+    {
+        var metric = new TraceMetric([CreateMetric()]);
+
+        var length = metric.Length;
+
+        Assert.Equal(1, length);
+    }
+
+    [Fact]
+    public void Items_One_Single()
+    {
+        var metric = new TraceMetric([CreateMetric()]);
+
+        var items = metric.Items;
+
+        Assert.Equal(1, items.Length);
+    }
+
+    [Fact]
+    public void WriteTo_Empty_AsJson()
+    {
+        var metric = new TraceMetric([]);
+
+        var document = metric.ToJsonDocument(_output);
+
+        Assert.Equal("""{"items":[]}""", document.RootElement.ToString());
+    }
+
+    private static SentryMetric<int> CreateMetric()
+    {
+        return new SentryMetric<int>(DateTimeOffset.MinValue, SentryId.Empty, SentryMetricType.Counter, "sentry_tests.trace_metric_tests.counter", 1);
+    }
+}

test/Sentry.Tests/SentryLogTests.cs

@@ -33,7 +33,7 @@ public void Protocol_Default_VerifyAttributes()
         var sdk = new SdkVersion
         {
             Name = "Sentry.Test.SDK",
-            Version = "1.2.3-test+Sentry"
+            Version = "1.2.3-test+Sentry",
         };
 
         var log = new SentryLog(Timestamp, TraceId, (SentryLogLevel)24, "message")