[sdk-metrics] Remove some reflection used by tests (#5338)

CodeBlanch · utpilla · web-flow · commit f1a1835479b5 · 2024-02-09T13:09:56.000-08:00
Co-authored-by: Utkarsh Umesan Pillai &lt;66651184+utpilla@users.noreply.github.com&gt;
diff --git a/src/OpenTelemetry/Metrics/AggregatorStore.cs b/src/OpenTelemetry/Metrics/AggregatorStore.cs
@@ -15,6 +15,7 @@ internal sealed class AggregatorStore
     internal readonly bool OutputDeltaWithUnusedMetricPointReclaimEnabled;
     internal readonly int CardinalityLimit;
     internal readonly bool EmitOverflowAttribute;
+    internal readonly ConcurrentDictionary<Tags, LookupData>? TagsToMetricPointIndexDictionaryDelta;
     internal long DroppedMeasurements = 0;
 
     private static readonly string MetricPointCapHitFixMessage = "Consider opting in for the experimental SDK feature to emit all the throttled metrics under the overflow attribute by setting env variable OTEL_DOTNET_EXPERIMENTAL_METRICS_EMIT_OVERFLOW_ATTRIBUTE = true. You could also modify instrumentation to reduce the number of unique key/value pair combinations. Or use Views to drop unwanted tags. Or use MeterProviderBuilder.SetMaxMetricPointsPerMetricStream to set higher limit.";
@@ -32,8 +33,6 @@ internal sealed class AggregatorStore
     private readonly ConcurrentDictionary<Tags, int> tagsToMetricPointIndexDictionary =
         new();
 
-    private readonly ConcurrentDictionary<Tags, LookupData>? tagsToMetricPointIndexDictionaryDelta;
-
     private readonly string name;
     private readonly string metricPointCapHitMessage;
     private readonly MetricPoint[] metricPoints;
@@ -110,7 +109,7 @@ internal AggregatorStore(
             // There is no overload which only takes capacity as the parameter
             // Using the DefaultConcurrencyLevel defined in the ConcurrentDictionary class: https://github.com/dotnet/runtime/blob/v7.0.5/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs#L2020
             // We expect at the most (maxMetricPoints - reservedMetricPointsCount) * 2 entries- one for sorted and one for unsorted input
-            this.tagsToMetricPointIndexDictionaryDelta =
+            this.TagsToMetricPointIndexDictionaryDelta =
                 new ConcurrentDictionary<Tags, LookupData>(concurrencyLevel: Environment.ProcessorCount, capacity: (cardinalityLimit - reservedMetricPointsCount) * 2);
 
             // Add all the indices except for the reserved ones to the queue so that threads have
@@ -266,28 +265,28 @@ internal void SnapshotDeltaWithMetricPointReclaim()
                     // Snapshot method can use this to skip trying to reclaim indices which have already been reclaimed and added to the queue.
                     metricPoint.LookupData = null;
 
-                    Debug.Assert(this.tagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");
+                    Debug.Assert(this.TagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");
 
-                    lock (this.tagsToMetricPointIndexDictionaryDelta!)
+                    lock (this.TagsToMetricPointIndexDictionaryDelta!)
                     {
                         LookupData? dictionaryValue;
                         if (lookupData.SortedTags != Tags.EmptyTags)
                         {
                             // Check if no other thread added a new entry for the same Tags.
                             // If no, then remove the existing entries.
-                            if (this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.SortedTags, out dictionaryValue) &&
+                            if (this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.SortedTags, out dictionaryValue) &&
                                 dictionaryValue == lookupData)
                             {
-                                this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.SortedTags, out var _);
-                                this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out var _);
+                                this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.SortedTags, out var _);
+                                this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out var _);
                             }
                         }
                         else
                         {
-                            if (this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.GivenTags, out dictionaryValue) &&
+                            if (this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.GivenTags, out dictionaryValue) &&
                                 dictionaryValue == lookupData)
                             {
-                                this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out var _);
+                                this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out var _);
                             }
                         }
 
@@ -550,11 +549,11 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object
         int index;
         var givenTags = new Tags(tagKeysAndValues);
 
-        Debug.Assert(this.tagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");
+        Debug.Assert(this.TagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");
 
         bool newMetricPointCreated = false;
 
-        if (!this.tagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out var lookupData))
+        if (!this.TagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out var lookupData))
         {
             if (length > 1)
             {
@@ -567,7 +566,7 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object
 
                 var sortedTags = new Tags(tempSortedTagKeysAndValues);
 
-                if (!this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))
+                if (!this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))
                 {
                     // Note: We are using storage from ThreadStatic (for up to MaxTagCacheSize tags) for both the input order of tags and the sorted order of tags,
                     // so we need to make a deep copy for Dictionary storage.
@@ -585,10 +584,10 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object
 
                     Debug.Assert(this.availableMetricPoints != null, "this.availableMetricPoints was null");
 
-                    lock (this.tagsToMetricPointIndexDictionaryDelta)
+                    lock (this.TagsToMetricPointIndexDictionaryDelta)
                     {
                         // check again after acquiring lock.
-                        if (!this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))
+                        if (!this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))
                         {
                             // Check for an available MetricPoint
                             if (this.availableMetricPoints!.Count > 0)
@@ -612,8 +611,8 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object
                             // MetricPoint, if dictionary entry found.
 
                             // Add the sorted order along with the given order of tags
-                            this.tagsToMetricPointIndexDictionaryDelta.TryAdd(sortedTags, lookupData);
-                            this.tagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);
+                            this.TagsToMetricPointIndexDictionaryDelta.TryAdd(sortedTags, lookupData);
+                            this.TagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);
                         }
                     }
                 }
@@ -631,10 +630,10 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object
 
                 Debug.Assert(this.availableMetricPoints != null, "this.availableMetricPoints was null");
 
-                lock (this.tagsToMetricPointIndexDictionaryDelta)
+                lock (this.TagsToMetricPointIndexDictionaryDelta)
                 {
                     // check again after acquiring lock.
-                    if (!this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(givenTags, out lookupData))
+                    if (!this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(givenTags, out lookupData))
                     {
                         // Check for an available MetricPoint
                         if (this.availableMetricPoints!.Count > 0)
@@ -658,7 +657,7 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object
                         // MetricPoint, if dictionary entry found.
 
                         // givenTags will always be sorted when tags length == 1
-                        this.tagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);
+                        this.TagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);
                     }
                 }
             }
@@ -735,7 +734,7 @@ private bool TryGetAvailableMetricPointRare(
         out LookupData? lookupData,
         out bool newMetricPointCreated)
     {
-        Debug.Assert(this.tagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");
+        Debug.Assert(this.TagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");
         Debug.Assert(this.availableMetricPoints != null, "this.availableMetricPoints was null");
 
         int index;
@@ -744,8 +743,8 @@ private bool TryGetAvailableMetricPointRare(
         if (length > 1)
         {
             // check again after acquiring lock.
-            if (!this.tagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out lookupData) &&
-                !this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))
+            if (!this.TagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out lookupData) &&
+                !this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))
             {
                 // Check for an available MetricPoint
                 if (this.availableMetricPoints!.Count > 0)
@@ -769,14 +768,14 @@ private bool TryGetAvailableMetricPointRare(
                 // MetricPoint, if dictionary entry found.
 
                 // Add the sorted order along with the given order of tags
-                this.tagsToMetricPointIndexDictionaryDelta.TryAdd(sortedTags, lookupData);
-                this.tagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);
+                this.TagsToMetricPointIndexDictionaryDelta.TryAdd(sortedTags, lookupData);
+                this.TagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);
             }
         }
         else
         {
             // check again after acquiring lock.
-            if (!this.tagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out lookupData))
+            if (!this.TagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out lookupData))
             {
                 // Check for an available MetricPoint
                 if (this.availableMetricPoints!.Count > 0)
@@ -800,7 +799,7 @@ private bool TryGetAvailableMetricPointRare(
                 // MetricPoint, if dictionary entry found.
 
                 // givenTags will always be sorted when tags length == 1
-                this.tagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);
+                this.TagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);
             }
         }
 
@@ -823,23 +822,23 @@ private int RemoveStaleEntriesAndGetAvailableMetricPointRare(LookupData lookupDa
         // If self-claimed, then add a fresh entry to the dictionary
         // If an available MetricPoint is found, then only increment the ReferenceCount
 
-        Debug.Assert(this.tagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");
+        Debug.Assert(this.TagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");
 
         // Delete the entry for these Tags and get another MetricPoint.
-        lock (this.tagsToMetricPointIndexDictionaryDelta!)
+        lock (this.TagsToMetricPointIndexDictionaryDelta!)
         {
             LookupData? dictionaryValue;
             if (lookupData.SortedTags != Tags.EmptyTags)
             {
                 // Check if no other thread added a new entry for the same Tags in the meantime.
                 // If no, then remove the existing entries.
-                if (this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.SortedTags, out dictionaryValue))
+                if (this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.SortedTags, out dictionaryValue))
                 {
                     if (dictionaryValue == lookupData)
                     {
                         // No other thread added a new entry for the same Tags.
-                        this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.SortedTags, out _);
-                        this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out _);
+                        this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.SortedTags, out _);
+                        this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out _);
                     }
                     else
                     {
@@ -851,12 +850,12 @@ private int RemoveStaleEntriesAndGetAvailableMetricPointRare(LookupData lookupDa
             }
             else
             {
-                if (this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.GivenTags, out dictionaryValue))
+                if (this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.GivenTags, out dictionaryValue))
                 {
                     if (dictionaryValue == lookupData)
                     {
                         // No other thread added a new entry for the same Tags.
-                        this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out _);
+                        this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out _);
                     }
                     else
                     {
diff --git a/test/OpenTelemetry.Tests/Metrics/MetricPointReclaimTestsBase.cs b/test/OpenTelemetry.Tests/Metrics/MetricPointReclaimTestsBase.cs
@@ -1,9 +1,7 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
-using System.Collections.Concurrent;
 using System.Diagnostics.Metrics;
-using System.Reflection;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using OpenTelemetry.Tests;
@@ -286,23 +284,17 @@ private sealed class CustomExporter : BaseExporter<Metric>
 
         private readonly bool assertNoDroppedMeasurements;
 
-        private readonly FieldInfo metricPointLookupDictionaryFieldInfo;
-
         public CustomExporter(bool assertNoDroppedMeasurements)
         {
             this.assertNoDroppedMeasurements = assertNoDroppedMeasurements;
-
-            var aggregatorStoreFields = typeof(AggregatorStore).GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
-            this.metricPointLookupDictionaryFieldInfo = aggregatorStoreFields!.FirstOrDefault(field => field.Name == "tagsToMetricPointIndexDictionaryDelta");
         }
 
         public override ExportResult Export(in Batch<Metric> batch)
         {
             foreach (var metric in batch)
             {
                 var aggStore = metric.AggregatorStore;
-                var metricPointLookupDictionary = this.metricPointLookupDictionaryFieldInfo.GetValue(aggStore) as ConcurrentDictionary<Tags, LookupData>;
-
+                var metricPointLookupDictionary = aggStore.TagsToMetricPointIndexDictionaryDelta;
                 var droppedMeasurements = aggStore.DroppedMeasurements;
 
                 if (this.assertNoDroppedMeasurements)

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ internal sealed class AggregatorStore`
`15`	`15`	`internal readonly bool OutputDeltaWithUnusedMetricPointReclaimEnabled;`
`16`	`16`	`internal readonly int CardinalityLimit;`
`17`	`17`	`internal readonly bool EmitOverflowAttribute;`
	`18`	`+ internal readonly ConcurrentDictionary<Tags, LookupData>? TagsToMetricPointIndexDictionaryDelta;`
`18`	`19`	`internal long DroppedMeasurements = 0;`
`19`	`20`
`20`	`21`	`private static readonly string MetricPointCapHitFixMessage = "Consider opting in for the experimental SDK feature to emit all the throttled metrics under the overflow attribute by setting env variable OTEL_DOTNET_EXPERIMENTAL_METRICS_EMIT_OVERFLOW_ATTRIBUTE = true. You could also modify instrumentation to reduce the number of unique key/value pair combinations. Or use Views to drop unwanted tags. Or use MeterProviderBuilder.SetMaxMetricPointsPerMetricStream to set higher limit.";`
`@@ -32,8 +33,6 @@ internal sealed class AggregatorStore`
`32`	`33`	`private readonly ConcurrentDictionary<Tags, int> tagsToMetricPointIndexDictionary =`
`33`	`34`	`new();`
`34`	`35`
`35`		`- private readonly ConcurrentDictionary<Tags, LookupData>? tagsToMetricPointIndexDictionaryDelta;`
`36`		`-`
`37`	`36`	`private readonly string name;`
`38`	`37`	`private readonly string metricPointCapHitMessage;`
`39`	`38`	`private readonly MetricPoint[] metricPoints;`
`@@ -110,7 +109,7 @@ internal AggregatorStore(`
`110`	`109`	`// There is no overload which only takes capacity as the parameter`
`111`	`110`	`// Using the DefaultConcurrencyLevel defined in the ConcurrentDictionary class: https://github.com/dotnet/runtime/blob/v7.0.5/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs#L2020`
`112`	`111`	`// We expect at the most (maxMetricPoints - reservedMetricPointsCount) * 2 entries- one for sorted and one for unsorted input`
`113`		`- this.tagsToMetricPointIndexDictionaryDelta =`
	`112`	`+ this.TagsToMetricPointIndexDictionaryDelta =`
`114`	`113`	`new ConcurrentDictionary<Tags, LookupData>(concurrencyLevel: Environment.ProcessorCount, capacity: (cardinalityLimit - reservedMetricPointsCount) * 2);`
`115`	`114`
`116`	`115`	`// Add all the indices except for the reserved ones to the queue so that threads have`
`@@ -266,28 +265,28 @@ internal void SnapshotDeltaWithMetricPointReclaim()`
`266`	`265`	`// Snapshot method can use this to skip trying to reclaim indices which have already been reclaimed and added to the queue.`
`267`	`266`	`metricPoint.LookupData = null;`
`268`	`267`
`269`		`- Debug.Assert(this.tagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");`
	`268`	`+ Debug.Assert(this.TagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");`
`270`	`269`
`271`		`- lock (this.tagsToMetricPointIndexDictionaryDelta!)`
	`270`	`+ lock (this.TagsToMetricPointIndexDictionaryDelta!)`
`272`	`271`	`{`
`273`	`272`	`LookupData? dictionaryValue;`
`274`	`273`	`if (lookupData.SortedTags != Tags.EmptyTags)`
`275`	`274`	`{`
`276`	`275`	`// Check if no other thread added a new entry for the same Tags.`
`277`	`276`	`// If no, then remove the existing entries.`
`278`		`- if (this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.SortedTags, out dictionaryValue) &&`
	`277`	`+ if (this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.SortedTags, out dictionaryValue) &&`
`279`	`278`	`dictionaryValue == lookupData)`
`280`	`279`	`{`
`281`		`- this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.SortedTags, out var _);`
`282`		`- this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out var _);`
	`280`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.SortedTags, out var _);`
	`281`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out var _);`
`283`	`282`	`}`
`284`	`283`	`}`
`285`	`284`	`else`
`286`	`285`	`{`
`287`		`- if (this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.GivenTags, out dictionaryValue) &&`
	`286`	`+ if (this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.GivenTags, out dictionaryValue) &&`
`288`	`287`	`dictionaryValue == lookupData)`
`289`	`288`	`{`
`290`		`- this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out var _);`
	`289`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out var _);`
`291`	`290`	`}`
`292`	`291`	`}`
`293`	`292`
`@@ -550,11 +549,11 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object`
`550`	`549`	`int index;`
`551`	`550`	`var givenTags = new Tags(tagKeysAndValues);`
`552`	`551`
`553`		`- Debug.Assert(this.tagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");`
	`552`	`+ Debug.Assert(this.TagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");`
`554`	`553`
`555`	`554`	`bool newMetricPointCreated = false;`
`556`	`555`
`557`		`- if (!this.tagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out var lookupData))`
	`556`	`+ if (!this.TagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out var lookupData))`
`558`	`557`	`{`
`559`	`558`	`if (length > 1)`
`560`	`559`	`{`
`@@ -567,7 +566,7 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object`
`567`	`566`
`568`	`567`	`var sortedTags = new Tags(tempSortedTagKeysAndValues);`
`569`	`568`
`570`		`- if (!this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))`
	`569`	`+ if (!this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))`
`571`	`570`	`{`
`572`	`571`	`// Note: We are using storage from ThreadStatic (for up to MaxTagCacheSize tags) for both the input order of tags and the sorted order of tags,`
`573`	`572`	`// so we need to make a deep copy for Dictionary storage.`
`@@ -585,10 +584,10 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object`
`585`	`584`
`586`	`585`	`Debug.Assert(this.availableMetricPoints != null, "this.availableMetricPoints was null");`
`587`	`586`
`588`		`- lock (this.tagsToMetricPointIndexDictionaryDelta)`
	`587`	`+ lock (this.TagsToMetricPointIndexDictionaryDelta)`
`589`	`588`	`{`
`590`	`589`	`// check again after acquiring lock.`
`591`		`- if (!this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))`
	`590`	`+ if (!this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))`
`592`	`591`	`{`
`593`	`592`	`// Check for an available MetricPoint`
`594`	`593`	`if (this.availableMetricPoints!.Count > 0)`
`@@ -612,8 +611,8 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object`
`612`	`611`	`// MetricPoint, if dictionary entry found.`
`613`	`612`
`614`	`613`	`// Add the sorted order along with the given order of tags`
`615`		`- this.tagsToMetricPointIndexDictionaryDelta.TryAdd(sortedTags, lookupData);`
`616`		`- this.tagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);`
	`614`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryAdd(sortedTags, lookupData);`
	`615`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);`
`617`	`616`	`}`
`618`	`617`	`}`
`619`	`618`	`}`
`@@ -631,10 +630,10 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object`
`631`	`630`
`632`	`631`	`Debug.Assert(this.availableMetricPoints != null, "this.availableMetricPoints was null");`
`633`	`632`
`634`		`- lock (this.tagsToMetricPointIndexDictionaryDelta)`
	`633`	`+ lock (this.TagsToMetricPointIndexDictionaryDelta)`
`635`	`634`	`{`
`636`	`635`	`// check again after acquiring lock.`
`637`		`- if (!this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(givenTags, out lookupData))`
	`636`	`+ if (!this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(givenTags, out lookupData))`
`638`	`637`	`{`
`639`	`638`	`// Check for an available MetricPoint`
`640`	`639`	`if (this.availableMetricPoints!.Count > 0)`
`@@ -658,7 +657,7 @@ private int LookupAggregatorStoreForDeltaWithReclaim(KeyValuePair<string, object`
`658`	`657`	`// MetricPoint, if dictionary entry found.`
`659`	`658`
`660`	`659`	`// givenTags will always be sorted when tags length == 1`
`661`		`- this.tagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);`
	`660`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);`
`662`	`661`	`}`
`663`	`662`	`}`
`664`	`663`	`}`
`@@ -735,7 +734,7 @@ private bool TryGetAvailableMetricPointRare(`
`735`	`734`	`out LookupData? lookupData,`
`736`	`735`	`out bool newMetricPointCreated)`
`737`	`736`	`{`
`738`		`- Debug.Assert(this.tagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");`
	`737`	`+ Debug.Assert(this.TagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");`
`739`	`738`	`Debug.Assert(this.availableMetricPoints != null, "this.availableMetricPoints was null");`
`740`	`739`
`741`	`740`	`int index;`
`@@ -744,8 +743,8 @@ private bool TryGetAvailableMetricPointRare(`
`744`	`743`	`if (length > 1)`
`745`	`744`	`{`
`746`	`745`	`// check again after acquiring lock.`
`747`		`- if (!this.tagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out lookupData) &&`
`748`		`- !this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))`
	`746`	`+ if (!this.TagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out lookupData) &&`
	`747`	`+ !this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(sortedTags, out lookupData))`
`749`	`748`	`{`
`750`	`749`	`// Check for an available MetricPoint`
`751`	`750`	`if (this.availableMetricPoints!.Count > 0)`
`@@ -769,14 +768,14 @@ private bool TryGetAvailableMetricPointRare(`
`769`	`768`	`// MetricPoint, if dictionary entry found.`
`770`	`769`
`771`	`770`	`// Add the sorted order along with the given order of tags`
`772`		`- this.tagsToMetricPointIndexDictionaryDelta.TryAdd(sortedTags, lookupData);`
`773`		`- this.tagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);`
	`771`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryAdd(sortedTags, lookupData);`
	`772`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);`
`774`	`773`	`}`
`775`	`774`	`}`
`776`	`775`	`else`
`777`	`776`	`{`
`778`	`777`	`// check again after acquiring lock.`
`779`		`- if (!this.tagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out lookupData))`
	`778`	`+ if (!this.TagsToMetricPointIndexDictionaryDelta!.TryGetValue(givenTags, out lookupData))`
`780`	`779`	`{`
`781`	`780`	`// Check for an available MetricPoint`
`782`	`781`	`if (this.availableMetricPoints!.Count > 0)`
`@@ -800,7 +799,7 @@ private bool TryGetAvailableMetricPointRare(`
`800`	`799`	`// MetricPoint, if dictionary entry found.`
`801`	`800`
`802`	`801`	`// givenTags will always be sorted when tags length == 1`
`803`		`- this.tagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);`
	`802`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryAdd(givenTags, lookupData);`
`804`	`803`	`}`
`805`	`804`	`}`
`806`	`805`
`@@ -823,23 +822,23 @@ private int RemoveStaleEntriesAndGetAvailableMetricPointRare(LookupData lookupDa`
`823`	`822`	`// If self-claimed, then add a fresh entry to the dictionary`
`824`	`823`	`// If an available MetricPoint is found, then only increment the ReferenceCount`
`825`	`824`
`826`		`- Debug.Assert(this.tagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");`
	`825`	`+ Debug.Assert(this.TagsToMetricPointIndexDictionaryDelta != null, "this.tagsToMetricPointIndexDictionaryDelta was null");`
`827`	`826`
`828`	`827`	`// Delete the entry for these Tags and get another MetricPoint.`
`829`		`- lock (this.tagsToMetricPointIndexDictionaryDelta!)`
	`828`	`+ lock (this.TagsToMetricPointIndexDictionaryDelta!)`
`830`	`829`	`{`
`831`	`830`	`LookupData? dictionaryValue;`
`832`	`831`	`if (lookupData.SortedTags != Tags.EmptyTags)`
`833`	`832`	`{`
`834`	`833`	`// Check if no other thread added a new entry for the same Tags in the meantime.`
`835`	`834`	`// If no, then remove the existing entries.`
`836`		`- if (this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.SortedTags, out dictionaryValue))`
	`835`	`+ if (this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.SortedTags, out dictionaryValue))`
`837`	`836`	`{`
`838`	`837`	`if (dictionaryValue == lookupData)`
`839`	`838`	`{`
`840`	`839`	`// No other thread added a new entry for the same Tags.`
`841`		`- this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.SortedTags, out _);`
`842`		`- this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out _);`
	`840`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.SortedTags, out _);`
	`841`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out _);`
`843`	`842`	`}`
`844`	`843`	`else`
`845`	`844`	`{`
`@@ -851,12 +850,12 @@ private int RemoveStaleEntriesAndGetAvailableMetricPointRare(LookupData lookupDa`
`851`	`850`	`}`
`852`	`851`	`else`
`853`	`852`	`{`
`854`		`- if (this.tagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.GivenTags, out dictionaryValue))`
	`853`	`+ if (this.TagsToMetricPointIndexDictionaryDelta.TryGetValue(lookupData.GivenTags, out dictionaryValue))`
`855`	`854`	`{`
`856`	`855`	`if (dictionaryValue == lookupData)`
`857`	`856`	`{`
`858`	`857`	`// No other thread added a new entry for the same Tags.`
`859`		`- this.tagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out _);`
	`858`	`+ this.TagsToMetricPointIndexDictionaryDelta.TryRemove(lookupData.GivenTags, out _);`
`860`	`859`	`}`
`861`	`860`	`else`
`862`	`861`	`{`