feat!: make public Metrics type non-generic

Author: Flash0ver

samples/Sentry.Samples.Console.Basic/Program.cs

@@ -55,13 +55,21 @@
     });
 
     // Sentry (trace-connected) Metrics via SentrySdk.Experimental.Metrics are enabled by default.
-    options.Experimental.SetBeforeSendMetric<int>(static metric =>
+    options.Experimental.SetBeforeSendMetric(static metric =>
     {
+        if (metric.TryGetValue(out int integer) && integer < 0)
+        {
+            // Return null to drop the metric
+            return null;
+        }
+
         // A demonstration of how you can modify the metric object before sending it to Sentry
-        metric.SetAttribute("operating_system.platform", Environment.OSVersion.Platform.ToString());
-        metric.SetAttribute("operating_system.version", Environment.OSVersion.Version.ToString());
+        if (metric.Type is SentryMetricType.Counter)
+        {
+            metric.SetAttribute("operating_system.platform", Environment.OSVersion.Platform.ToString());
+            metric.SetAttribute("operating_system.version", Environment.OSVersion.Version.ToString());
+        }
 
-        // Return null to drop the metric
         return metric;
     });
 });
@@ -95,10 +103,13 @@ async Task FirstFunction()
     // Info-Log filtered via "BeforeSendLog" callback
     SentrySdk.Logger.LogInfo("HTTP Request completed.");
 
-    // Metric modified via "BeforeSendMetric" callback for type "int" before sending it to Sentry
+    // Counter-Metric prevented from being sent to Sentry via "BeforeSendMetric" callback
+    SentrySdk.Experimental.Metrics.EmitCounter("sentry.samples.console.basic.ignore", -1);
+
+    // Counter-Metric modified before sending it to Sentry via "BeforeSendMetric" callback
     SentrySdk.Experimental.Metrics.EmitCounter("sentry.samples.console.basic.http_requests_completed", 1);
 
-    // Metric sent as is because no "BeforeSendMetric" is set for type "double"
+    // Distribution-Metric sent as is (see "BeforeSendMetric" callback)
     SentrySdk.Experimental.Metrics.EmitDistribution("sentry.samples.console.basic.http_request_duration", stopwatch.Elapsed.TotalSeconds, SentryUnits.Duration.Second,
         [new KeyValuePair<string, object>("http.request.method", HttpMethod.Get.Method), new KeyValuePair<string, object>("http.response.status_code", (int)HttpStatusCode.OK)]);
 }

src/Sentry/IHub.cs

@@ -36,7 +36,7 @@ public interface IHub : ISentryClient, ISentryScopeManager
     /// Available options:
     /// <list type="bullet">
     /// <item><see cref="Sentry.SentryOptions.ExperimentalSentryOptions.EnableMetrics"/></item>
-    /// <item><see cref="Sentry.SentryOptions.ExperimentalSentryOptions.SetBeforeSendMetric{T}(System.Func{SentryMetric{T}, SentryMetric{T}})"/></item>
+    /// <item><see cref="Sentry.SentryOptions.ExperimentalSentryOptions.SetBeforeSendMetric(System.Func{SentryMetric, SentryMetric})"/></item>
     /// </list>
     /// </remarks>
     [Experimental("SENTRYTRACECONNECTEDMETRICS", UrlFormat = "https://github.com/getsentry/sentry-dotnet/discussions/4838")]

src/Sentry/Internal/DefaultSentryTraceMetrics.cs

@@ -10,7 +10,7 @@ internal sealed class DefaultSentryTraceMetrics : SentryTraceMetrics, IDisposabl
     private readonly SentryOptions _options;
     private readonly ISystemClock _clock;
 
-    private readonly BatchProcessor<ISentryMetric> _batchProcessor;
+    private readonly BatchProcessor<SentryMetric> _batchProcessor;
 
     internal DefaultSentryTraceMetrics(IHub hub, SentryOptions options, ISystemClock clock, int batchCount, TimeSpan batchInterval)
     {
@@ -21,7 +21,7 @@ internal DefaultSentryTraceMetrics(IHub hub, SentryOptions options, ISystemClock
         _options = options;
         _clock = clock;
 
-        _batchProcessor = new BatchProcessor<ISentryMetric>(hub, batchCount, batchInterval, TraceMetric.Capture, _options.ClientReportRecorder, _options.DiagnosticLogger);
+        _batchProcessor = new BatchProcessor<SentryMetric>(hub, batchCount, batchInterval, TraceMetric.Capture, _options.ClientReportRecorder, _options.DiagnosticLogger);
     }
 
     /// <inheritdoc />
@@ -63,12 +63,12 @@ private protected override void CaptureMetric<T>(SentryMetricType type, string n
     }
 
     /// <inheritdoc />
-    protected internal override void CaptureMetric<T>(SentryMetric<T> metric) where T : struct
+    private protected override void CaptureMetric<T>(SentryMetric<T> metric) where T : struct
     {
         Debug.Assert(SentryMetric.IsSupported(typeof(T)));
         Debug.Assert(!string.IsNullOrEmpty(metric.Name));
 
-        var configuredMetric = metric;
+        SentryMetric? configuredMetric = metric;
 
         if (_options.Experimental.BeforeSendMetricInternal is { } beforeSendMetric)
         {

src/Sentry/Internal/DisabledSentryTraceMetrics.cs

@@ -21,7 +21,7 @@ private protected override void CaptureMetric<T>(SentryMetricType type, string n
     }
 
     /// <inheritdoc />
-    protected internal override void CaptureMetric<T>(SentryMetric<T> metric) where T : struct
+    private protected override void CaptureMetric<T>(SentryMetric<T> metric) where T : struct
     {
         // disabled
     }

src/Sentry/Internal/Polyfills.cs

@@ -62,3 +62,32 @@ public static void WriteRawValue(this Utf8JsonWriter writer, byte[] utf8Json)
     }
 }
 #endif
+
+// TODO: remove when updating Polyfill: https://github.com/getsentry/sentry-dotnet/pull/4879
+#if !NET6_0_OR_GREATER
+internal static class EnumerableExtensions
+{
+    internal static bool TryGetNonEnumeratedCount<TSource>(this IEnumerable<TSource> source, out int count)
+    {
+        if (source is null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (source is ICollection<TSource> genericCollection)
+        {
+            count = genericCollection.Count;
+            return true;
+        }
+
+        if (source is ICollection collection)
+        {
+            count = collection.Count;
+            return true;
+        }
+
+        count = 0;
+        return false;
+    }
+}
+#endif

src/Sentry/Protocol/TraceMetric.cs

@@ -12,15 +12,15 @@ namespace Sentry.Protocol;
 /// </remarks>
 internal sealed class TraceMetric : ISentryJsonSerializable
 {
-    private readonly ISentryMetric[] _items;
+    private readonly SentryMetric[] _items;
 
-    public TraceMetric(ISentryMetric[] metrics)
+    public TraceMetric(SentryMetric[] metrics)
     {
         _items = metrics;
     }
 
     public int Length => _items.Length;
-    public ReadOnlySpan<ISentryMetric> Items => _items;
+    public ReadOnlySpan<SentryMetric> Items => _items;
 
     public void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
     {
@@ -36,7 +36,7 @@ public void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
         writer.WriteEndObject();
     }
 
-    internal static void Capture(IHub hub, ISentryMetric[] metrics)
+    internal static void Capture(IHub hub, SentryMetric[] metrics)
     {
         _ = hub.CaptureEnvelope(Envelope.FromMetric(new TraceMetric(metrics)));
     }

src/Sentry/SentryLog.cs

@@ -189,6 +189,7 @@ internal void SetOrigin(string origin)
         SetAttribute("sentry.origin", origin);
     }
 
+    /// <inheritdoc cref="ISentryJsonSerializable.WriteTo(Utf8JsonWriter, IDiagnosticLogger)" />
     internal void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
     {
         writer.WriteStartObject();

src/Sentry/SentryMetric.Factory.cs

@@ -3,7 +3,7 @@
 
 namespace Sentry;
 
-internal static class SentryMetric
+public abstract partial class SentryMetric
 {
     internal static SentryMetric<T> Create<T>(IHub hub, SentryOptions options, ISystemClock clock, SentryMetricType type, string name, T value, string? unit, IEnumerable<KeyValuePair<string, object>>? attributes, Scope? scope) where T : struct
     {

src/Sentry/SentryMetric.Generic.cs

@@ -0,0 +1,72 @@
+using Sentry.Extensibility;
+
+namespace Sentry;
+
+/// <summary>
+/// Internal generic representation of <see cref="SentryMetric"/>.
+/// </summary>
+/// <typeparam name="T">The numeric type of the metric.</typeparam>
+/// <remarks>
+/// We hide some of the generic implementation details from user code.
+/// </remarks>
+internal sealed class SentryMetric<T> : SentryMetric where T : struct
+{
+    private readonly T _value;
+
+    [SetsRequiredMembers]
+    internal SentryMetric(DateTimeOffset timestamp, SentryId traceId, SentryMetricType type, string name, T value)
+        : base(timestamp, traceId, type, name)
+    {
+        _value = value;
+    }
+
+    internal override object Value => _value;
+
+    /// <inheritdoc />
+    public override bool TryGetValue<TValue>(out TValue value) where TValue : struct
+    {
+        if (_value is TValue match)
+        {
+            value = match;
+            return true;
+        }
+
+        value = default;
+        return false;
+    }
+
+    private protected override void WriteMetricValueTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
+    {
+        const string propertyName = "value";
+        var type = typeof(T);
+
+        if (type == typeof(long))
+        {
+            writer.WriteNumber(propertyName, (long)(object)_value);
+        }
+        else if (type == typeof(double))
+        {
+            writer.WriteNumber(propertyName, (double)(object)_value);
+        }
+        else if (type == typeof(int))
+        {
+            writer.WriteNumber(propertyName, (int)(object)_value);
+        }
+        else if (type == typeof(float))
+        {
+            writer.WriteNumber(propertyName, (float)(object)_value);
+        }
+        else if (type == typeof(short))
+        {
+            writer.WriteNumber(propertyName, (short)(object)_value);
+        }
+        else if (type == typeof(byte))
+        {
+            writer.WriteNumber(propertyName, (byte)(object)_value);
+        }
+        else
+        {
+            Debug.Fail($"Unhandled Metric Type {typeof(T)}.", "This instruction should be unreachable.");
+        }
+    }
+}