Collecting and capturing all metrics types

Author: link04

tracer/src/Datadog.Trace/ClrProfiler/Instrumentation.cs

@@ -326,19 +326,23 @@ internal static void InitializeNoNativeParts(Stopwatch sw = null)
             {
                 if (Tracer.Instance.Settings.OpenTelemetryMetricsEnabled)
                 {
-                    Log.Debug("Initializing OTel Metrics Exporter.");
-                    OTelMetrics.MeterListener.Initialize();
-                    OTelMetrics.OtlpMetricsExporter.Initialize();
+                    if (Tracer.Instance.Settings.OpenTelemetryMeterNames.Length > 0)
+                    {
+                        Log.Debug("Initializing OTel Metrics Exporter.");
+                        OTelMetrics.OtlpMetricsExporter.Initialize();
+                        Log.Debug("Initializing OTel Metrics Reader.");
+                        OTelMetrics.MetricReader.Initialize();
+                    }
                 }
             }
             catch (Exception ex)
             {
-                Log.Error(ex, "Error initializing OTel Metrics Exporter");
+                Log.Error(ex, "Error initializing OTel Metrics Reader");
             }
 #else
             if (Tracer.Instance.Settings.OpenTelemetryMetricsEnabled)
             {
-                Log.Information("Unable to initialize OTel Metrics collection, this is only available starting with .NET 6.0..");
+                Log.Information("Unable to initialize OTel Metrics collection, this is only available starting with .NET 6.0.");
             }
 #endif
 

tracer/src/Datadog.Trace/OTelMetrics/MeterListenerHandler.cs

@@ -14,69 +14,44 @@
 
 namespace Datadog.Trace.OTelMetrics
 {
-    internal class MetricPoint
+    internal class MetricPoint(string instrumentName, string meterName, string instrumentType, string temporality, Dictionary<string, object?> tags, bool isIntegerValue = false)
     {
-        private static readonly double[] DefaultHistogramBounds = [0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000];
+        // Static fields first
+        internal static readonly double[] DefaultHistogramBounds = [0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000];
 
-        // Histogram-specific
-        private readonly long[] _runningBucketCounts;
+        // Instance fields
+        private readonly long[] _runningBucketCounts = instrumentType == "Histogram" ? new long[DefaultHistogramBounds.Length + 1] : [];
         private readonly object _histogramLock = new();
-
-        // Thread-safe running values (hot path)
         private long _runningCountValue;     // For counters and histogram count
         private double _runningDoubleValue;  // For gauges and histogram sum
         private double _runningMin = double.PositiveInfinity;
         private double _runningMax = double.NegativeInfinity;
 
-        public MetricPoint(string instrumentName, string meterName, string instrumentType, string temporality, Dictionary<string, object?> tags)
-        {
-            // Initialize histogram buckets if needed
-            if (instrumentType == "Histogram")
-            {
-                _runningBucketCounts = new long[DefaultHistogramBounds.Length + 1]; // +1 for overflow
-                SnapshotBucketCounts = new long[DefaultHistogramBounds.Length + 1];
-            }
-            else
-            {
-                _runningBucketCounts = [];
-                SnapshotBucketCounts = [];
-            }
-
-            InstrumentName = instrumentName;
-            MeterName = meterName;
-            InstrumentType = instrumentType;
-            AggregationTemporality = temporality;
-            Tags = tags;
-            StartTime = DateTimeOffset.UtcNow;
-            EndTime = DateTimeOffset.UtcNow;
-        }
-
-        public string InstrumentName { get; }
+        // Constructor
 
-        public string MeterName { get; }
+        // Public properties
+        public string InstrumentName { get; } = instrumentName;
 
-        public string InstrumentType { get; }
+        public string MeterName { get; } = meterName;
 
-        public string AggregationTemporality { get; }
+        public string InstrumentType { get; } = instrumentType;
 
-        public Dictionary<string, object?> Tags { get; }
+        public string AggregationTemporality { get; } = temporality;
 
-        public DateTimeOffset StartTime { get; private set; }
+        public Dictionary<string, object?> Tags { get; } = tags;
 
-        public DateTimeOffset EndTime { get; private set; }
+        public bool IsIntegerValue { get; set; } = isIntegerValue;
 
-        // Snapshot values (export time)
-        public long SnapshotCount { get; private set; }
+        // Internal properties for collection access
+        internal long RunningCount => _runningCountValue;
 
-        public double SnapshotSum { get; private set; }
+        internal double RunningSum => _runningDoubleValue;
 
-        public double SnapshotGaugeValue { get; private set; }
+        internal double RunningMin => _runningMin;
 
-        public double SnapshotMin { get; private set; }
+        internal double RunningMax => _runningMax;
 
-        public double SnapshotMax { get; private set; }
-
-        public long[] SnapshotBucketCounts { get; private set; }
+        internal long[] RunningBucketCounts => _runningBucketCounts;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void UpdateCounter(double value)
@@ -86,16 +61,12 @@ public void UpdateCounter(double value)
             {
                 _runningDoubleValue += value;
             }
-
-            EndTime = DateTimeOffset.UtcNow;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void UpdateGauge(double value)
         {
-            // Lock-free gauge update (like OTel)
             Interlocked.Exchange(ref _runningDoubleValue, value);
-            EndTime = DateTimeOffset.UtcNow;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -104,7 +75,6 @@ public void UpdateHistogram(double value)
             // Find bucket index first (outside lock for performance)
             var bucketIndex = FindBucketIndex(value);
 
-            // Minimal lock scope (like OTel)
             lock (_histogramLock)
             {
                 unchecked
@@ -117,57 +87,6 @@ public void UpdateHistogram(double value)
                 _runningMin = Math.Min(_runningMin, value);
                 _runningMax = Math.Max(_runningMax, value);
             }
-
-            EndTime = DateTimeOffset.UtcNow;
-        }
-
-        public void TakeSnapshot(bool outputDelta)
-        {
-            EndTime = DateTimeOffset.UtcNow;
-
-            switch (InstrumentType)
-            {
-                case "Counter":
-                    if (outputDelta)
-                    {
-                        var currentValue = Interlocked.CompareExchange(ref _runningDoubleValue, 0, 0); // Datadog read pattern
-                        SnapshotSum = currentValue - SnapshotSum; // Delta calculation
-                    }
-                    else
-                    {
-                        SnapshotSum = Interlocked.CompareExchange(ref _runningDoubleValue, 0, 0); // Cumulative
-                    }
-
-                    break;
-
-                case "Gauge":
-                    SnapshotGaugeValue = Interlocked.CompareExchange(ref _runningDoubleValue, 0, 0);
-                    break;
-
-                case "Histogram":
-                    lock (_histogramLock)
-                    {
-                        SnapshotCount = _runningCountValue;
-                        SnapshotSum = _runningDoubleValue;
-                        SnapshotMin = _runningMin;
-                        SnapshotMax = _runningMax;
-
-                        // Copy bucket counts
-                        Array.Copy(_runningBucketCounts, SnapshotBucketCounts, _runningBucketCounts.Length);
-
-                        if (outputDelta)
-                        {
-                            // Reset for delta
-                            _runningCountValue = 0;
-                            _runningDoubleValue = 0;
-                            _runningMin = double.PositiveInfinity;
-                            _runningMax = double.NegativeInfinity;
-                            Array.Clear(_runningBucketCounts);
-                        }
-                    }
-
-                    break;
-            }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]