[Metrics] Exclude list for tags on Metrics

src/OpenTelemetry/.publicApi/Stable/PublicAPI.Unshipped.txt

@@ -0,0 +1,2 @@
+OpenTelemetry.Metrics.MetricStreamConfiguration.ExcludedTagKeys.get -> string![]?
+OpenTelemetry.Metrics.MetricStreamConfiguration.ExcludedTagKeys.set -> void

src/OpenTelemetry/CHANGELOG.md

@@ -9,6 +9,10 @@ Notes](../../RELEASENOTES.md).
 * Fixed a metric point reclaim data race on CPU ARM architectures.
   ([#7401](https://github.com/open-telemetry/opentelemetry-dotnet/pull/7401))
 
+* Added `ExcludedTagKeys` property to `MetricStreamConfiguration` and exemplar
+  filtering for excluding tag keys from metrics.
+  ([#7373](https://github.com/open-telemetry/opentelemetry-dotnet/pull/7373))
+
 ## 1.16.0
 
 Released 2026-Jun-10

src/OpenTelemetry/Metrics/AggregatorStore.cs

@@ -16,8 +16,10 @@ internal sealed class AggregatorStore
 {
 #if NET
     internal readonly FrozenSet<string>? TagKeysInteresting;
+    internal readonly FrozenSet<string>? ExcludedTagKeysInteresting;
 #else
     internal readonly HashSet<string>? TagKeysInteresting;
+    internal readonly HashSet<string>? ExcludedTagKeysInteresting;
 #endif
     internal readonly bool OutputDelta;
     internal readonly bool IsAsynchronous;
@@ -81,12 +83,7 @@ internal AggregatorStore(
         this.exponentialHistogramMaxScale = metricStreamIdentity.ExponentialHistogramMaxScale;
         this.StartTimeExclusive = DateTimeOffset.UtcNow;
         this.ExemplarReservoirFactory = exemplarReservoirFactory;
-        if (metricStreamIdentity.TagKeys == null)
-        {
-            this.updateLongCallback = this.UpdateLong;
-            this.updateDoubleCallback = this.UpdateDouble;
-        }
-        else
+        if (metricStreamIdentity.TagKeys != null)
         {
             this.updateLongCallback = this.UpdateLongCustomTags;
             this.updateDoubleCallback = this.UpdateDoubleCustomTags;
@@ -98,6 +95,22 @@ internal AggregatorStore(
             this.TagKeysInteresting = hs;
             this.tagsKeysInterestingCount = hs.Count;
         }
+        else if (metricStreamIdentity.ExcludedTagKeys != null)
+        {
+            this.updateLongCallback = this.UpdateLongExcludeTags;
+            this.updateDoubleCallback = this.UpdateDoubleExcludeTags;
+#if NET
+            var hs = FrozenSet.ToFrozenSet(metricStreamIdentity.ExcludedTagKeys, StringComparer.Ordinal);
+#else
+            var hs = new HashSet<string>(metricStreamIdentity.ExcludedTagKeys, StringComparer.Ordinal);
+#endif
+            this.ExcludedTagKeysInteresting = hs;
+        }
+        else
+        {
+            this.updateLongCallback = this.UpdateLong;
+            this.updateDoubleCallback = this.UpdateDouble;
+        }
 
         this.exemplarFilter = exemplarFilter ?? DefaultExemplarFilter;
         Debug.Assert(
@@ -991,6 +1004,20 @@ private void UpdateDoubleCustomTags(double value, ReadOnlySpan<KeyValuePair<stri
         this.UpdateDoubleMetricPoint(index, value, tags);
     }
 
+    private void UpdateLongExcludeTags(long value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
+    {
+        var index = this.FindMetricAggregatorsExcludeTag(tags);
+
+        this.UpdateLongMetricPoint(index, value, tags);
+    }
+
+    private void UpdateDoubleExcludeTags(double value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
+    {
+        var index = this.FindMetricAggregatorsExcludeTag(tags);
+
+        this.UpdateDoubleMetricPoint(index, value, tags);
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void UpdateDoubleMetricPoint(int metricPointIndex, double value, ReadOnlySpan<KeyValuePair<string, object?>> tags)
     {
@@ -1064,4 +1091,25 @@ private int FindMetricAggregatorsCustomTag(ReadOnlySpan<KeyValuePair<string, obj
 
         return this.lookupAggregatorStore(tagKeysAndValues!, actualLength);
     }
+
+    private int FindMetricAggregatorsExcludeTag(ReadOnlySpan<KeyValuePair<string, object?>> tags)
+    {
+        var tagLength = tags.Length;
+        if (tagLength == 0)
+        {
+            this.InitializeZeroTagPointIfNotInitialized();
+            return 0;
+        }
+
+        var storage = ThreadStaticStorage.GetStorage();
+        storage.SplitToKeysAndValuesExclude(tags, tagLength, this.ExcludedTagKeysInteresting!, out var tagKeysAndValues, out var actualLength);
+
+        if (actualLength == 0)
+        {
+            this.InitializeZeroTagPointIfNotInitialized();
+            return 0;
+        }
+
+        return this.lookupAggregatorStore(tagKeysAndValues!, actualLength);
+    }
 }

src/OpenTelemetry/Metrics/Exemplar/Exemplar.cs

@@ -20,11 +20,13 @@ public struct Exemplar
 {
 #if NET
     internal FrozenSet<string>? ViewDefinedTagKeys;
+    internal FrozenSet<string>? ExcludedTagKeys;
 #else
     internal HashSet<string>? ViewDefinedTagKeys;
+    internal HashSet<string>? ExcludedTagKeys;
 #endif
 
-    private static readonly ReadOnlyFilteredTagCollection Empty = new(excludedKeys: null, [], count: 0);
+    private static readonly ReadOnlyFilteredTagCollection Empty = new(includeKeys: null, excludeKeys: null, [], count: 0);
     private int tagCount;
     private KeyValuePair<string, object?>[]? tagStorage;
     private MetricPointValueStorage valueStorage;
@@ -69,10 +71,11 @@ public double DoubleValue
     /// <remarks>
     /// Note: <see cref="FilteredTags"/> represents the set of tags which were
     /// supplied at measurement but dropped due to filtering configured by a
-    /// view (<see cref="MetricStreamConfiguration.TagKeys"/>). If view tag
+    /// view (<see cref="MetricStreamConfiguration.TagKeys"/> or
+    /// <see cref="MetricStreamConfiguration.ExcludedTagKeys"/>). If view tag
     /// filtering is not configured <see cref="FilteredTags"/> will be empty.
     /// </remarks>
-    public readonly ReadOnlyFilteredTagCollection FilteredTags => this.tagCount == 0 ? Empty : new(this.ViewDefinedTagKeys, this.tagStorage!, this.tagCount);
+    public readonly ReadOnlyFilteredTagCollection FilteredTags => this.tagCount == 0 ? Empty : new(this.ViewDefinedTagKeys, this.ExcludedTagKeys, this.tagStorage!, this.tagCount);
 
     internal void Update<T>(in ExemplarMeasurement<T> measurement)
         where T : struct
@@ -116,7 +119,7 @@ internal void Update<T>(in ExemplarMeasurement<T> measurement)
             this.SpanId = default;
         }
 
-        if (this.ViewDefinedTagKeys != null)
+        if (this.ViewDefinedTagKeys != null || this.ExcludedTagKeys != null)
         {
             this.StoreRawTags(measurement.Tags);
         }
@@ -160,6 +163,7 @@ internal readonly void Copy(ref Exemplar destination)
         destination.SpanId = this.SpanId;
         destination.valueStorage = this.valueStorage;
         destination.ViewDefinedTagKeys = this.ViewDefinedTagKeys;
+        destination.ExcludedTagKeys = this.ExcludedTagKeys;
         destination.tagCount = this.tagCount;
         if (destination.tagCount > 0)
         {

src/OpenTelemetry/Metrics/Exemplar/FixedSizeExemplarReservoir.cs

@@ -75,11 +75,14 @@ public sealed override ReadOnlyExemplarCollection Collect()
     internal sealed override void Initialize(AggregatorStore aggregatorStore)
     {
         var viewDefinedTagKeys = aggregatorStore.TagKeysInteresting;
+        var excludedTagKeys = aggregatorStore.ExcludedTagKeysInteresting;
 
         for (var i = 0; i < this.runningExemplars.Length; i++)
         {
             this.runningExemplars[i].ViewDefinedTagKeys = viewDefinedTagKeys;
+            this.runningExemplars[i].ExcludedTagKeys = excludedTagKeys;
             this.snapshotExemplars[i].ViewDefinedTagKeys = viewDefinedTagKeys;
+            this.snapshotExemplars[i].ExcludedTagKeys = excludedTagKeys;
         }
 
         base.Initialize(aggregatorStore);

src/OpenTelemetry/Metrics/MeterProviderSdk.cs

@@ -320,6 +320,19 @@ internal static void MeasurementRecordedDouble(Instrument instrument, double val
                         OpenTelemetrySdkEventSource.Log.MetricViewIgnored(instrument.Name, instrument.Meter.Name, ex.Message, "Fix the view configuration.");
                     }
 
+                    if (metricStreamConfig != null)
+                    {
+                        try
+                        {
+                            metricStreamConfig.Validate();
+                        }
+                        catch (Exception ex)
+                        {
+                            OpenTelemetrySdkEventSource.Log.MetricViewIgnored(instrument.Name, instrument.Meter.Name, ex.Message, "Fix the view configuration.");
+                            metricStreamConfig = null;
+                        }
+                    }
+
                     if (metricStreamConfig != null)
                     {
                         metricStreamConfigs.Add(metricStreamConfig);

src/OpenTelemetry/Metrics/MetricStreamIdentity.cs

@@ -24,6 +24,7 @@ public MetricStreamIdentity(Instrument instrument, MetricStreamConfiguration? me
         this.ViewId = metricStreamConfiguration?.ViewId;
         this.MetricStreamName = $"{this.MeterName}.{this.MeterVersion}.{this.InstrumentName}";
         this.TagKeys = metricStreamConfiguration?.CopiedTagKeys;
+        this.ExcludedTagKeys = metricStreamConfiguration?.CopiedExcludedTagKeys;
         this.HistogramBucketBounds = GetExplicitBucketHistogramBounds(instrument, metricStreamConfiguration);
         this.HistogramBucketDisplayBounds = GetExplicitBucketHistogramDisplayBounds(instrument, this.HistogramBucketBounds);
         this.ExponentialHistogramMaxSize = (metricStreamConfiguration as Base2ExponentialBucketHistogramConfiguration)?.MaxSize ?? 0;
@@ -43,12 +44,13 @@ public MetricStreamIdentity(Instrument instrument, MetricStreamConfiguration? me
         hashCode.Add(this.Description);
         hashCode.Add(this.ViewId);
 
-        // Note: The this.TagKeys! here is strange but it is fine for the value
-        // to be null. HashCode.Add is coded to handle the value being null. We
-        // are essentially suppressing a false positive due to an issue/quirk
-        // with the annotations. See:
+        // Note: The this.TagKeys! / this.ExcludedTagKeys! here is strange but
+        // it is fine for the value to be null. HashCode.Add is coded to handle
+        // the value being null. We are essentially suppressing a false positive
+        // due to an issue/quirk with the annotations. See:
         // https://github.com/dotnet/runtime/pull/91905.
         hashCode.Add(this.TagKeys!, StringArrayComparer);
+        hashCode.Add(this.ExcludedTagKeys!, StringArrayComparer);
 
         hashCode.Add(this.ExponentialHistogramMaxSize);
         hashCode.Add(this.ExponentialHistogramMaxScale);
@@ -78,6 +80,7 @@ public MetricStreamIdentity(Instrument instrument, MetricStreamConfiguration? me
             hash = (hash * 31) + this.Description.GetHashCode();
             hash = (hash * 31) + (this.ViewId ?? 0);
             hash = (hash * 31) + (this.TagKeys != null ? StringArrayComparer.GetHashCode(this.TagKeys) : 0);
+            hash = (hash * 31) + (this.ExcludedTagKeys != null ? StringArrayComparer.GetHashCode(this.ExcludedTagKeys) : 0);
             if (this.HistogramBucketBounds != null)
             {
                 var len = this.HistogramBucketBounds.Length;
@@ -114,6 +117,12 @@ public MetricStreamIdentity(Instrument instrument, MetricStreamConfiguration? me
 
     public string[]? TagKeys { get; }
 
+    // Note: ExcludedTagKeys uses element-wise comparison (same as TagKeys).
+    // ["a","b"] and ["b","a"] produce different stream identities even though
+    // the filtering behavior is identical. This is a pre-existing limitation
+    // inherited from TagKeys.
+    public string[]? ExcludedTagKeys { get; }
+
     public double[]? HistogramBucketBounds { get; }
 
     public double[]? HistogramBucketDisplayBounds { get; }
@@ -173,6 +182,7 @@ public bool Equals(MetricStreamIdentity other)
         && this.ExponentialHistogramMaxSize == other.ExponentialHistogramMaxSize
         && this.ExponentialHistogramMaxScale == other.ExponentialHistogramMaxScale
         && StringArrayComparer.Equals(this.TagKeys, other.TagKeys)
+        && StringArrayComparer.Equals(this.ExcludedTagKeys, other.ExcludedTagKeys)
         && HistogramBoundsEqual(this.HistogramBucketBounds, other.HistogramBucketBounds);
 
     public override readonly int GetHashCode() => this.hashCode;

src/OpenTelemetry/Metrics/ThreadStaticStorage.cs

@@ -116,6 +116,66 @@ internal void SplitToKeysAndValues(
         }
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal void SplitToKeysAndValuesExclude(
+        ReadOnlySpan<KeyValuePair<string, object?>> tags,
+        int tagLength,
+#if NET
+        FrozenSet<string> excludedTagKeys,
+#else
+        HashSet<string> excludedTagKeys,
+#endif
+        out KeyValuePair<string, object?>[]? tagKeysAndValues,
+        out int actualLength)
+    {
+        // Worst case: no tags excluded, all survive.
+        var maxLength = tagLength;
+        tagKeysAndValues = maxLength == 0
+            ? null
+            : maxLength <= MaxTagCacheSize
+                ? this.primaryTagStorage[maxLength - 1].TagKeysAndValues
+                : (new KeyValuePair<string, object?>[maxLength]);
+
+        actualLength = 0;
+        for (var n = 0; n < tagLength; n++)
+        {
+            // Copy only tags NOT in the excluded set.
+            if (!excludedTagKeys.Contains(tags[n].Key))
+            {
+                tagKeysAndValues![actualLength] = tags[n];
+                actualLength++;
+            }
+        }
+
+        if (actualLength < maxLength)
+        {
+            if (actualLength == 0)
+            {
+                tagKeysAndValues = null;
+                return;
+            }
+
+            Debug.Assert(tagKeysAndValues != null, "tagKeysAndValues was null");
+
+            if (actualLength <= MaxTagCacheSize)
+            {
+                var tmpTagKeysAndValues = this.primaryTagStorage[actualLength - 1].TagKeysAndValues;
+
+                Array.Copy(tagKeysAndValues, 0, tmpTagKeysAndValues, 0, actualLength);
+
+                tagKeysAndValues = tmpTagKeysAndValues;
+            }
+            else
+            {
+                var tmpTagKeysAndValues = new KeyValuePair<string, object?>[actualLength];
+
+                Array.Copy(tagKeysAndValues, 0, tmpTagKeysAndValues, 0, actualLength);
+
+                tagKeysAndValues = tmpTagKeysAndValues;
+            }
+        }
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal void CloneKeysAndValues(
         KeyValuePair<string, object?>[] inputTagKeysAndValues,

src/OpenTelemetry/Metrics/View/MetricStreamConfiguration.cs

@@ -95,6 +95,32 @@ public int? CardinalityLimit
         }
     }
 
+#pragma warning disable CA1819 // Properties should not return arrays
+    /// <summary>
+    /// Gets or sets the optional tag keys to exclude from the metric stream.
+    /// </summary>
+    /// <remarks>
+    /// Notes:
+    /// <list type="bullet">
+    /// <item>If not provided, all the tags provided by the instrument
+    /// while reporting measurements will be used for aggregation.
+    /// If provided, only those tags not in this list will be used
+    /// for aggregation. Providing an empty array will result in no tags
+    /// being excluded (same effect as default behavior
+    /// all attributes are preserved).
+    /// </item>
+    /// <item>A copy is made of the provided array.</item>
+    /// <item>This is mutually exclusive with <see cref="TagKeys"/>
+    /// setting both will cause the view to be ignored.</item>
+    /// </list>
+    /// </remarks>
+    public string[]? ExcludedTagKeys
+#pragma warning restore CA1819 // Properties should not return arrays
+    {
+        get => this.CopiedExcludedTagKeys?.ToArray();
+        set => this.CopiedExcludedTagKeys = value?.ToArray();
+    }
+
 #if EXPOSE_EXPERIMENTAL_FEATURES
     /// <summary>
     /// Gets or sets a factory function used to generate an <see
@@ -117,5 +143,18 @@ public int? CardinalityLimit
 
     internal string[]? CopiedTagKeys { get; private set; }
 
+    internal string[]? CopiedExcludedTagKeys { get; private set; }
+
     internal int? ViewId { get; set; }
+
+    internal void Validate()
+    {
+        if (this.CopiedTagKeys != null && this.CopiedExcludedTagKeys != null)
+        {
+            throw new InvalidOperationException(
+                "TagKeys and ExcludedTagKeys cannot both be set. They are mutually exclusive. " +
+                "Use only one filtering strategy per view. For combined behavior, use the " +
+                "Func<Instrument, MetricStreamConfiguration> overload of AddView with custom logic.");
+        }
+    }
 }