Allow duplicate instrument registration

src/OpenTelemetry/Internal/OpenTelemetrySdkEventSource.cs

@@ -360,6 +360,12 @@ public void ProviderDisposed(string providerName)
             this.WriteEvent(37, providerName);
         }
 
+        [Event(38, Message = "Duplicate Instrument '{0}', Meter '{1}' encountered. Reason: '{2}'. Suggested action: '{3}'", Level = EventLevel.Warning)]
+        public void DuplicateMetricInstrument(string instrumentName, string meterName, string reason, string fix)
+        {
+            this.WriteEvent(38, instrumentName, meterName, reason, fix);
+        }
+
 #if DEBUG
         public class OpenTelemetryEventListener : EventListener
         {

src/OpenTelemetry/Metrics/InstrumentIdentity.cs

@@ -0,0 +1,74 @@
+// <copyright file="InstrumentIdentity.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System;
+
+namespace OpenTelemetry.Metrics
+{
+    internal readonly struct InstrumentIdentity : IEquatable<InstrumentIdentity>
+    {
+        public InstrumentIdentity(string meterName, string instrumentName, string unit, string description, Type instrumentType)
+        {
+            this.MeterName = meterName;
+            this.InstrumentName = instrumentName;
+            this.Unit = unit;
+            this.Description = description;
+            this.InstrumentType = instrumentType;
+        }
+
+        public readonly string MeterName { get; }
+
+        public readonly string InstrumentName { get; }
+
+        public readonly string Unit { get; }
+
+        public readonly string Description { get; }
+
+        public readonly Type InstrumentType { get; }
+
+        public static bool operator ==(InstrumentIdentity metricIdentity1, InstrumentIdentity metricIdentity2) => metricIdentity1.Equals(metricIdentity2);
+
+        public static bool operator !=(InstrumentIdentity metricIdentity1, InstrumentIdentity metricIdentity2) => !metricIdentity1.Equals(metricIdentity2);
+
+        public readonly override bool Equals(object obj)
+        {
+            return obj is InstrumentIdentity other && this.Equals(other);
+        }
+
+        public bool Equals(InstrumentIdentity other)
+        {
+            return this.InstrumentType == other.InstrumentType
+                && this.MeterName == other.MeterName
+                && this.InstrumentName == other.InstrumentName
+                && this.Unit == other.Unit
+                && this.Description == other.Description;
+        }
+
+        public readonly override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+                hash = (hash * 31) + this.InstrumentType.GetHashCode();
+                hash = (hash * 31) + this.MeterName.GetHashCode();
+                hash = (hash * 31) + this.InstrumentName.GetHashCode();
+                hash = this.Unit == null ? hash : (hash * 31) + this.Unit.GetHashCode();
+                hash = this.Description == null ? hash : (hash * 31) + this.Description.GetHashCode();
+                return hash;
+            }
+        }
+    }
+}

src/OpenTelemetry/Metrics/MetricReaderExt.cs

@@ -27,6 +27,7 @@ namespace OpenTelemetry.Metrics
     public abstract partial class MetricReader
     {
         private readonly HashSet<string> metricStreamNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<InstrumentIdentity, Metric> instrumentIdentityToMetric = new Dictionary<InstrumentIdentity, Metric>();
         private readonly object instrumentCreationLock = new object();
         private int maxMetricStreams;
         private int maxMetricPointsPerMetricStream;
@@ -39,12 +40,17 @@ internal Metric AddMetricWithNoViews(Instrument instrument)
             var meterName = instrument.Meter.Name;
             var metricName = instrument.Name;
             var metricStreamName = $"{meterName}.{metricName}";
+            var instrumentIdentity = new InstrumentIdentity(meterName, metricName, instrument.Unit, instrument.Description, instrument.GetType());
             lock (this.instrumentCreationLock)
             {
+                if (this.instrumentIdentityToMetric.TryGetValue(instrumentIdentity, out var existingMetric))
+                {
+                    return existingMetric;
+                }
+
                 if (this.metricStreamNames.Contains(metricStreamName))
                 {
-                    OpenTelemetrySdkEventSource.Log.MetricInstrumentIgnored(metricName, instrument.Meter.Name, "Metric name conflicting with existing name.", "Either change the name of the instrument or change name using View.");
-                    return null;
+                    OpenTelemetrySdkEventSource.Log.DuplicateMetricInstrument(metricName, instrument.Meter.Name, "Metric instrument has the same name as an existing one but differs by description, unit, or instrument type.", "Either change the name of the instrument or use MeterProviderBuilder.AddView to resolve the conflict.");
                 }
 
                 var index = ++this.metricIndex;
@@ -56,6 +62,7 @@ internal Metric AddMetricWithNoViews(Instrument instrument)
                 else
                 {
                     var metric = new Metric(instrument, this.Temporality, metricName, instrument.Description, this.maxMetricPointsPerMetricStream);
+                    this.instrumentIdentityToMetric[instrumentIdentity] = metric;
                     this.metrics[index] = metric;
                     this.metricStreamNames.Add(metricStreamName);
                     return metric;
@@ -90,6 +97,8 @@ internal List<Metric> AddMetricsListWithViews(Instrument instrument, List<Metric
                     var meterName = instrument.Meter.Name;
                     var metricName = metricStreamConfig?.Name ?? instrument.Name;
                     var metricStreamName = $"{meterName}.{metricName}";
+                    var metricDescription = metricStreamConfig?.Description ?? instrument.Description;
+                    var instrumentIdentity = new InstrumentIdentity(meterName, metricName, instrument.Unit, metricDescription, instrument.GetType());
 
                     if (!MeterProviderBuilderSdk.IsValidInstrumentName(metricName))
                     {
@@ -102,12 +111,16 @@ internal List<Metric> AddMetricsListWithViews(Instrument instrument, List<Metric
                         continue;
                     }
 
-                    if (this.metricStreamNames.Contains(metricStreamName))
+                    if (this.instrumentIdentityToMetric.TryGetValue(instrumentIdentity, out var existingMetric))
                     {
-                        OpenTelemetrySdkEventSource.Log.MetricInstrumentIgnored(metricName, instrument.Meter.Name, "Metric name conflicting with existing name.", "Either change the name of the instrument or change name using MeterProviderBuilder.AddView.");
                         continue;
                     }
 
+                    if (this.metricStreamNames.Contains(metricStreamName))
+                    {
+                        OpenTelemetrySdkEventSource.Log.DuplicateMetricInstrument(metricName, instrument.Meter.Name, "Metric instrument has the same name as an existing one but differs by description, unit, or instrument type.", "Either change the name of the instrument or use MeterProviderBuilder.AddView to resolve the conflict.");
+                    }
+
                     if (metricStreamConfig?.Aggregation == Aggregation.Drop)
                     {
                         OpenTelemetrySdkEventSource.Log.MetricInstrumentIgnored(metricName, instrument.Meter.Name, "View configuration asks to drop this instrument.", "Modify view configuration to allow this instrument, if desired.");
@@ -122,12 +135,12 @@ internal List<Metric> AddMetricsListWithViews(Instrument instrument, List<Metric
                     else
                     {
                         Metric metric;
-                        var metricDescription = metricStreamConfig?.Description ?? instrument.Description;
                         string[] tagKeysInteresting = metricStreamConfig?.TagKeys;
                         double[] histogramBucketBounds = (metricStreamConfig is ExplicitBucketHistogramConfiguration histogramConfig
                             && histogramConfig.Boundaries != null) ? histogramConfig.Boundaries : null;
                         metric = new Metric(instrument, this.Temporality, metricName, metricDescription, this.maxMetricPointsPerMetricStream, histogramBucketBounds, tagKeysInteresting);
 
+                        this.instrumentIdentityToMetric[instrumentIdentity] = metric;
                         this.metrics[index] = metric;
                         metrics.Add(metric);
                         this.metricStreamNames.Add(metricStreamName);