diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSourceActivity.cs b/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSourceActivity.cs
index 5fcfa8f27ae44..b44e5e98c9c7c 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSourceActivity.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/ref/System.Diagnostics.DiagnosticSourceActivity.cs
@@ -350,6 +350,18 @@ public sealed class Counter<T> : Instrument<T> where T : struct
         internal Counter(Meter meter, string name, string? unit, string? description) :
                         base(meter, name, unit, description) { throw null; }
     }
+    public sealed class Gauge<T> : Instrument<T> where T : struct
+    {
+        public void Record(T value) { throw null; }
+        public void Record(T value, System.Collections.Generic.KeyValuePair<string, object?> tag) { throw null; }
+        public void Record(T value, System.Collections.Generic.KeyValuePair<string, object?> tag1, System.Collections.Generic.KeyValuePair<string, object?> tag2) { throw null; }
+        public void Record(T value, System.Collections.Generic.KeyValuePair<string, object?> tag1, System.Collections.Generic.KeyValuePair<string, object?> tag2, System.Collections.Generic.KeyValuePair<string, object?> tag3) { throw null; }
+        public void Record(T value, params System.ReadOnlySpan<System.Collections.Generic.KeyValuePair<string, object?>> tags) { throw null; }
+        public void Record(T value, params System.Collections.Generic.KeyValuePair<string, object?>[] tags) { throw null; }
+        public void Record(T value, in TagList tagList) { throw null; }
+        internal Gauge(Meter meter, string name, string? unit, string? description, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, object?>>? tags) :
+                        base(meter, name, unit, description, tags) { throw null; }
+    }
     public sealed class UpDownCounter<T> : Instrument<T> where T : struct
     {
         public void Add(T delta) { throw null; }
@@ -413,10 +425,12 @@ public abstract class Instrument<T> : Instrument where T : struct
     public delegate void MeasurementCallback<T>(Instrument instrument, T measurement, ReadOnlySpan<System.Collections.Generic.KeyValuePair<string, object?>> tags, object? state) where T : struct;
     public class Meter : IDisposable
     {
-        public Counter<T> CreateCounter<T>(string name, string? unit = null, string? description = null) where T : struct  { throw null; }
-        public Counter<T> CreateCounter<T>(string name, string? unit, string? description, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, object?>> tags) where T : struct  { throw null; }
-        public UpDownCounter<T> CreateUpDownCounter<T>(string name, string? unit = null, string? description = null) where T : struct  { throw null; }
-        public UpDownCounter<T> CreateUpDownCounter<T>(string name, string? unit, string? description, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, object?>> tags) where T : struct  { throw null; }
+        public Counter<T> CreateCounter<T>(string name, string? unit = null, string? description = null) where T : struct { throw null; }
+        public Counter<T> CreateCounter<T>(string name, string? unit, string? description, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, object?>> tags) where T : struct { throw null; }
+        public Gauge<T> CreateGauge<T>(string name) where T : struct { throw null; }
+        public Gauge<T> CreateGauge<T>(string name, string? unit = null, string? description = null, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, object?>>? tags = null) where T : struct { throw null; }
+        public UpDownCounter<T> CreateUpDownCounter<T>(string name, string? unit = null, string? description = null) where T : struct { throw null; }
+        public UpDownCounter<T> CreateUpDownCounter<T>(string name, string? unit, string? description, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, object?>> tags) where T : struct { throw null; }
         public Histogram<T> CreateHistogram<T>(string name, string? unit = null, string? description = null) where T : struct { throw null; }
         public Histogram<T> CreateHistogram<T>(string name, string? unit, string? description, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, object?>> tags) where T : struct { throw null; }
         public ObservableCounter<T> CreateObservableCounter<T>(
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj b/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj
index fb55fdbebd23b..88f8f0b2cd90f 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj
@@ -53,6 +53,7 @@ System.Diagnostics.DiagnosticSource</PackageDescription>
     <Compile Include="System\Diagnostics\Metrics\AggregatorStore.cs" />
     <Compile Include="System\Diagnostics\Metrics\Counter.cs" />
     <Compile Include="System\Diagnostics\Metrics\ExponentialHistogramAggregator.cs" />
+    <Compile Include="System\Diagnostics\Metrics\Gauge.cs" />
     <Compile Include="System\Diagnostics\Metrics\Histogram.cs" />
     <Compile Include="System\Diagnostics\Metrics\IMeterFactory.cs" />
     <Compile Include="System\Diagnostics\Metrics\Instrument.cs" />
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/AggregationManager.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/AggregationManager.cs
index e4adce2f275c1..34ecde9bf1a26 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/AggregationManager.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/AggregationManager.cs
@@ -316,7 +316,7 @@ private void RemoveInstrumentState(Instrument instrument)
                     }
                 };
             }
-            else if (genericDefType == typeof(ObservableGauge<>))
+            else if (genericDefType == typeof(ObservableGauge<>) || genericDefType == typeof(Gauge<>))
             {
                 return () =>
                 {
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Gauge.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Gauge.cs
new file mode 100644
index 0000000000000..fb82c3e09da22
--- /dev/null
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Gauge.cs
@@ -0,0 +1,76 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+
+namespace System.Diagnostics.Metrics
+{
+    /// <summary>
+    /// The Gauge is an instrument used to record non-additive values whenever changes occur. For example, record the room background noise level value when changes occur.
+    /// </summary>
+    /// <remarks>
+    /// This class supports only the following generic parameter types: <see cref="byte" />, <see cref="short" />, <see cref="int" />, <see cref="long" />, <see cref="float" />, <see cref="double" />, and <see cref="decimal" />
+    /// </remarks>
+    public sealed class Gauge<T> : Instrument<T> where T : struct
+    {
+        internal Gauge(Meter meter, string name, string? unit, string? description) : this(meter, name, unit, description, null)
+        {
+        }
+
+        internal Gauge(Meter meter, string name, string? unit, string? description, IEnumerable<KeyValuePair<string, object?>>? tags) : base(meter, name, unit, description, tags)
+        {
+            Publish();
+        }
+
+        /// <summary>
+        /// Record the Gauge current value.
+        /// </summary>
+        /// <param name="value">The Gauge current value.</param>
+        public void Record(T value) => RecordMeasurement(value);
+
+        /// <summary>
+        /// Record the Gauge current value.
+        /// </summary>
+        /// <param name="value">The Gauge current value.</param>
+        /// <param name="tag">A key-value pair tag associated with the measurement.</param>
+        public void Record(T value, KeyValuePair<string, object?> tag) => RecordMeasurement(value, tag);
+
+        /// <summary>
+        /// Record the Gauge current value.
+        /// </summary>
+        /// <param name="value">The Gauge current value.</param>
+        /// <param name="tag1">A first key-value pair tag associated with the measurement.</param>
+        /// <param name="tag2">A second key-value pair tag associated with the measurement.</param>
+        public void Record(T value, KeyValuePair<string, object?> tag1, KeyValuePair<string, object?> tag2) => RecordMeasurement(value, tag1, tag2);
+
+        /// <summary>
+        /// Record the Gauge current value.
+        /// </summary>
+        /// <param name="value">The Gauge current value.</param>
+        /// <param name="tag1">A first key-value pair tag associated with the measurement.</param>
+        /// <param name="tag2">A second key-value pair tag associated with the measurement.</param>
+        /// <param name="tag3">A third key-value pair tag associated with the measurement.</param>
+        public void Record(T value, KeyValuePair<string, object?> tag1, KeyValuePair<string, object?> tag2, KeyValuePair<string, object?> tag3) => RecordMeasurement(value, tag1, tag2, tag3);
+
+        /// <summary>
+        /// Record the Gauge current value.
+        /// </summary>
+        /// <param name="value">The Gauge current value.</param>
+        /// <param name="tags">A span of key-value pair tags associated with the measurement.</param>
+        public void Record(T value, params ReadOnlySpan<KeyValuePair<string, object?>> tags) => RecordMeasurement(value, tags);
+
+        /// <summary>
+        /// Record the Gauge current value.
+        /// </summary>
+        /// <param name="value">The Gauge current value.</param>
+        /// <param name="tags">A list of key-value pair tags associated with the measurement.</param>
+        public void Record(T value, params KeyValuePair<string, object?>[] tags) => RecordMeasurement(value, tags.AsSpan());
+
+        /// <summary>
+        /// Record the Gauge current value.
+        /// </summary>
+        /// <param name="value">The Gauge current value.</param>
+        /// <param name="tagList">A <see cref="T:System.Diagnostics.TagList" /> of tags associated with the measurement.</param>
+        public void Record(T value, in TagList tagList) => RecordMeasurement(value, in tagList);
+    }
+}
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs
index b91631822585b..b9a6e0e8885ad 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs
@@ -143,6 +143,30 @@ private void Initialize(string name, string? version, IEnumerable<KeyValuePair<s
         public Counter<T> CreateCounter<T>(string name, string? unit, string? description, IEnumerable<KeyValuePair<string, object?>>? tags) where T : struct
                 => (Counter<T>)GetOrCreateInstrument<T>(typeof(Counter<T>), name, unit, description, tags, () => new Counter<T>(this, name, unit, description, tags));
 
+        /// <summary>
+        /// Creates a Gauge instrument, which can be used to record non-additive values.
+        /// </summary>
+        /// <param name="name">The instrument name. cannot be null.</param>
+        /// <remarks>
+        /// Gauge is an Instrument which used to record non-additive values.
+        /// Example uses for Gauge: record the room background noise level value when changes occur.
+        /// </remarks>
+        public Gauge<T> CreateGauge<T>(string name) where T : struct => CreateGauge<T>(name, unit: null, description: null, tags: null);
+
+        /// <summary>
+        /// Create a metrics Gauge object.
+        /// </summary>
+        /// <param name="name">The instrument name. cannot be null.</param>
+        /// <param name="unit">Optional instrument unit of measurements.</param>
+        /// <param name="description">Optional instrument description.</param>
+        /// <param name="tags">tags to attach to the Gauge.</param>
+        /// <remarks>
+        /// Gauge is an Instrument which used to record non-additive values.
+        /// Example uses for Gauge: record the room background noise level value when changes occur.
+        /// </remarks>
+        public Gauge<T> CreateGauge<T>(string name, string? unit = null, string? description = null, IEnumerable<KeyValuePair<string, object?>>? tags = null) where T : struct
+                => (Gauge<T>)GetOrCreateInstrument<T>(typeof(Gauge<T>), name, unit, description, tags, () => new Gauge<T>(this, name, unit, description, tags));
+
         /// <summary>
         /// Histogram is an Instrument which can be used to report arbitrary values that are likely to be statistically meaningful. It is intended for statistics such as histograms, summaries, and percentile.
         /// </summary>
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricEventSourceTests.cs b/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricEventSourceTests.cs
index 8eec15c60c79a..43aeb17afa2bc 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricEventSourceTests.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricEventSourceTests.cs
@@ -268,6 +268,7 @@ public void MultipleListeners_UnsharedSessionRejectsUnsharedListener()
             UpDownCounter<int> udc = meter.CreateUpDownCounter<int>("upDownCounter1", "udc unit", "udc description", new TagList() { { "udck1", "udcv1" }, { "udck2", "udcv2" } });
             int upDownCounterState = 0;
             ObservableUpDownCounter<int> oudc = meter.CreateObservableUpDownCounter<int>("observableUpDownCounter1", () => { upDownCounterState += 11; return upDownCounterState; }, "oudc unit", "oudc description");
+            Gauge<int> g = meter.CreateGauge<int>("gauge1", "C", "Temperature", new TagList() { { "Ck1", "Cv1" }, { "Ck2", "Cv2" } });
 
             EventWrittenEventArgs[] events;
             using (MetricsEventListener listener = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, IntervalSecs, "TestMeter7"))
@@ -276,21 +277,23 @@ public void MultipleListeners_UnsharedSessionRejectsUnsharedListener()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(-10);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(9);
 
                 using MetricsEventListener listener2 = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, IntervalSecs, "TestMeter7");
                 listener2.WaitForMultipleSessionsNotSupportedError(s_waitForEventTimeout);
 
-
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertCounterEventsPresent(events, meter.Name, c.Name, "", c.Unit, ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "", g.Unit, "-10", "9");
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "", oc.Unit, ("", "10"), ("7", "17"), ("7", "24"));
             AssertGaugeEventsPresent(events, meter.Name, og.Name, "", og.Unit, "9", "18", "27");
             AssertHistogramEventsPresent(events, meter.Name, h.Name, "", h.Unit, ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"));
@@ -314,6 +317,7 @@ public void MultipleListeners_UnsharedSessionRejectsSharedListener()
             int upDownCounterState = 0;
             ObservableUpDownCounter<int> oudc = meter.CreateObservableUpDownCounter<int>("observableUpDownCounter1", () =>
                     { upDownCounterState += 11; return upDownCounterState; }, "oudc unit", "oudc description", new TagList() { { "Ck1", "Cv1" }, { "Ck2", "Cv2" } });
+            Gauge<int> g = meter.CreateGauge<int>("gauge1", "C", "Temperature", new TagList() { { "Ck1", "Cv1" }, { "Ck2", "Cv2" } });
 
             EventWrittenEventArgs[] events;
             using (MetricsEventListener listener = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, IntervalSecs, "TestMeter7"))
@@ -322,10 +326,12 @@ public void MultipleListeners_UnsharedSessionRejectsSharedListener()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(-1);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(32);
 
                 using (MetricsEventListener listener2 = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, isShared: true, IntervalSecs, "TestMeter7"))
                 {
@@ -336,8 +342,9 @@ public void MultipleListeners_UnsharedSessionRejectsSharedListener()
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertCounterEventsPresent(events, meter.Name, c.Name, "", c.Unit, ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "", g.Unit, "-1", "32");
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "", oc.Unit, ("", "10"), ("7", "17"), ("7", "24"));
             AssertGaugeEventsPresent(events, meter.Name, og.Name, "", og.Unit, "9", "18", "27");
             AssertHistogramEventsPresent(events, meter.Name, h.Name, "", h.Unit, ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"));
@@ -360,6 +367,7 @@ public void MultipleListeners_SharedSessionRejectsUnsharedListener()
             UpDownCounter<int> udc = meter.CreateUpDownCounter<int>("upDownCounter1", "udc unit", "udc description");
             int upDownCounterState = 0;
             ObservableUpDownCounter<int> oudc = meter.CreateObservableUpDownCounter<int>("observableUpDownCounter1", () => { upDownCounterState += 11; return upDownCounterState; }, "oudc unit", "oudc description");
+            Gauge<int> g = meter.CreateGauge<int>("gauge1", "C", "Temperature");
 
             EventWrittenEventArgs[] events;
             using (MetricsEventListener listener = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, isShared: true, IntervalSecs, "TestMeter7"))
@@ -368,10 +376,12 @@ public void MultipleListeners_SharedSessionRejectsUnsharedListener()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(100);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(-70);
 
                 using (MetricsEventListener listener2 = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, IntervalSecs, "TestMeter7"))
                 {
@@ -382,8 +392,9 @@ public void MultipleListeners_SharedSessionRejectsUnsharedListener()
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertCounterEventsPresent(events, meter.Name, c.Name, "", c.Unit, ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "", g.Unit, "100", "-70");
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "", oc.Unit, ("", "10"), ("7", "17"), ("7", "24"));
             AssertGaugeEventsPresent(events, meter.Name, og.Name, "", og.Unit, "9", "18", "27");
             AssertHistogramEventsPresent(events, meter.Name, h.Name, "", h.Unit, ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"));
@@ -472,6 +483,7 @@ public void MultipleListeners_SharedSessionRejectsListenerWithDifferentInterval(
             UpDownCounter<int> udc = meter.CreateUpDownCounter<int>("upDownCounter1", "udc unit", "udc description");
             int upDownCounterState = 0;
             ObservableUpDownCounter<int> oudc = meter.CreateObservableUpDownCounter<int>("observableUpDownCounter1", () => { upDownCounterState += 11; return upDownCounterState; }, "oudc unit", "oudc description");
+            Gauge<int> g = meter.CreateGauge<int>("gauge1", "C", "Temperature");
 
             EventWrittenEventArgs[] events, events2;
             using (MetricsEventListener listener = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, isShared: true, IntervalSecs, "TestMeter7"))
@@ -480,10 +492,12 @@ public void MultipleListeners_SharedSessionRejectsListenerWithDifferentInterval(
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(5);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(10);
 
                 using (MetricsEventListener listener2 = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, isShared: true, IntervalSecs + 1, "TestMeter7"))
                 {
@@ -497,8 +511,9 @@ public void MultipleListeners_SharedSessionRejectsListenerWithDifferentInterval(
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertCounterEventsPresent(events, meter.Name, c.Name, "", c.Unit, ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "", g.Unit, "5", "10");
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "", oc.Unit, ("", "10"), ("7", "17"), ("7", "24"));
             AssertGaugeEventsPresent(events, meter.Name, og.Name, "", og.Unit, "9", "18", "27");
             AssertHistogramEventsPresent(events, meter.Name, h.Name, "", h.Unit, ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"));
@@ -522,6 +537,7 @@ public void MultipleListeners_DisposeMeterBeforeSecondListener()
             UpDownCounter<int> udc = meterA.CreateUpDownCounter<int>("upDownCounter1", "udc unit", "udc description");
             int upDownCounterState = 0;
             ObservableUpDownCounter<int> oudc = meterA.CreateObservableUpDownCounter<int>("observableUpDownCounter1", () => { upDownCounterState += 11; return upDownCounterState; }, "oudc unit", "oudc description");
+            Gauge<int> g = meterA.CreateGauge<int>("gauge1", "C", "Temperature");
 
             EventWrittenEventArgs[] events, events2;
             using (MetricsEventListener listener = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, isShared: true, IntervalSecs, "TestMeter8;TestMeter9"))
@@ -530,10 +546,12 @@ public void MultipleListeners_DisposeMeterBeforeSecondListener()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(-100);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(100);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
 
                 meterA.Dispose();
@@ -549,18 +567,19 @@ public void MultipleListeners_DisposeMeterBeforeSecondListener()
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, h); // only h occurs twice because meterA is disposed before listener2 is created
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, h, g); // only h occurs twice because meterA is disposed before listener2 is created
             AssertBeginInstrumentReportingEventsPresent(events2, h);
             AssertInitialEnumerationCompleteEventPresent(events, 2);
             AssertInitialEnumerationCompleteEventPresent(events2);
             AssertCounterEventsPresent(events, meterA.Name, c.Name, "", c.Unit, ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meterA.Name, g.Name, "", g.Unit, "-100", "100");
             AssertCounterEventsPresent(events, meterA.Name, oc.Name, "", oc.Unit, ("", "10"), ("7", "17"), ("7", "24"));
             AssertGaugeEventsPresent(events, meterA.Name, og.Name, "", og.Unit, "9", "18", "27");
             AssertHistogramEventsPresent(events, meterB.Name, h.Name, "", h.Unit, ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"), ("0.5=21;0.95=21;0.99=21", "1", "21"));
             AssertUpDownCounterEventsPresent(events, meterA.Name, udc.Name, "", udc.Unit, ("33", "33"), ("40", "73"));
             AssertUpDownCounterEventsPresent(events, meterA.Name, oudc.Name, "", oudc.Unit, ("", "11"), ("11", "22"), ("11", "33"));
             AssertCollectStartStopEventsPresent(events, IntervalSecs, 4);
-            AssertEndInstrumentReportingEventsPresent(events, c, oc, og, udc, oudc);
+            AssertEndInstrumentReportingEventsPresent(events, c, oc, og, udc, oudc, g);
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
@@ -570,6 +589,7 @@ public void MultipleListeners_DisposeMetersDuringAndAfterSecondListener()
             using Meter meterA = new Meter("TestMeter8", null, new TagList() { { "1Mk1", "1Mv1" }, { "1Mk2", "Mv2" } });
             using Meter meterB = new Meter("TestMeter9", null, new TagList() { { "2Mk1", "2Mv1" } }, new object());
             Counter<int> c = meterA.CreateCounter<int>("counter1", "hat", "Fooz!!", new TagList() { { "Ck1", "Cv1" } });
+            Gauge<int> g = meterA.CreateGauge<int>("gauge1", "C", "Temperature", new TagList() { { "Ck1", "Cv1" } });
             int counterState = 3;
             ObservableCounter<int> oc = meterA.CreateObservableCounter<int>("observableCounter1", () => { counterState += 7; return counterState; }, "MB", "Size of universe");
             int gaugeState = 0;
@@ -586,10 +606,12 @@ public void MultipleListeners_DisposeMetersDuringAndAfterSecondListener()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(-10);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(9);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
 
                 using (MetricsEventListener listener2 = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, isShared: true, IntervalSecs, "TestMeter8;TestMeter9"))
@@ -609,19 +631,20 @@ public void MultipleListeners_DisposeMetersDuringAndAfterSecondListener()
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, c, oc, og, h, udc, oudc);
-            AssertBeginInstrumentReportingEventsPresent(events2, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g, c, oc, og, h, udc, oudc, g);
+            AssertBeginInstrumentReportingEventsPresent(events2, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events, 2);
             AssertInitialEnumerationCompleteEventPresent(events2);
             AssertCounterEventsPresent(events, meterA.Name, c.Name, "", c.Unit, ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meterA.Name, g.Name, "", g.Unit, "-10", "9");
             AssertCounterEventsPresent(events, meterA.Name, oc.Name, "", oc.Unit, ("", "10"), ("7", "17"), ("7", "24"));
             AssertGaugeEventsPresent(events, meterA.Name, og.Name, "", og.Unit, "9", "18", "27");
             AssertHistogramEventsPresent(events, meterB.Name, h.Name, "", h.Unit, ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"), ("0.5=21;0.95=21;0.99=21", "1", "21"));
             AssertUpDownCounterEventsPresent(events, meterA.Name, udc.Name, "", udc.Unit, ("33", "33"), ("40", "73"));
             AssertUpDownCounterEventsPresent(events, meterA.Name, oudc.Name, "", oudc.Unit, ("", "11"), ("11", "22"), ("11", "33"));
             AssertCollectStartStopEventsPresent(events, IntervalSecs, 4);
-            AssertEndInstrumentReportingEventsPresent(events, c, oc, og, udc, oudc, h);
-            AssertEndInstrumentReportingEventsPresent(events2, c, oc, og, udc, oudc);
+            AssertEndInstrumentReportingEventsPresent(events, c, oc, og, udc, oudc, h, g);
+            AssertEndInstrumentReportingEventsPresent(events2, c, oc, og, udc, oudc, g);
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
@@ -631,6 +654,7 @@ public void MultipleListeners_PublishingInstruments()
             using Meter meterA = new Meter("TestMeter10", null, new TagList() { { "Mk1", "Mv1" }, { "Mk2", "Mv2"}, { "Mk3", null }});
             using Meter meterB = new Meter("TestMeter11", null, null, new object());
             Counter<int> c = meterA.CreateCounter<int>("counter1", "hat", "Fooz!!", new TagList() { { "Ck1", "Cv1" } });
+            Gauge<int> g = meterA.CreateGauge<int>("gauge1", "C", "Temperature", new TagList() { { "Ck1", "Cv1" } });
             int counterState = 3;
             ObservableCounter<int> oc = meterA.CreateObservableCounter<int>("observableCounter1", () => { counterState += 7; return counterState; }, "MB", "Size of universe");
             int gaugeState = 0;
@@ -652,9 +676,9 @@ public void MultipleListeners_PublishingInstruments()
                 }
             }
 
-            AssertInstrumentPublishingEventsPresent(events, c, oc, og, h, udc, oudc, c, oc, og, h, udc, oudc);
+            AssertInstrumentPublishingEventsPresent(events, c, oc, og, h, udc, oudc, g, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events, 2);
-            AssertInstrumentPublishingEventsPresent(events2, c, oc, og, h, udc, oudc);
+            AssertInstrumentPublishingEventsPresent(events2, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events2);
         }
 
@@ -670,6 +694,7 @@ public void EventSourcePublishesTimeSeriesWithEmptyMetadata()
 
                 using Meter meter = new Meter("TestMeter1", null, new TagList() { { "Mk1", "Mv1" }, { "Mk2", "Mv2" } }, new object());
                 Counter<int> c = meter.CreateCounter<int>("counter1");
+                Gauge<int> g = meter.CreateGauge<int>("gauge1");
                 int counterState = 3;
                 ObservableCounter<int> oc = meter.CreateObservableCounter<int>("observableCounter1", () => { counterState += 7; return counterState; });
                 int gaugeState = 0;
@@ -686,17 +711,20 @@ public void EventSourcePublishesTimeSeriesWithEmptyMetadata()
                     c.Add(5);
                     h.Record(19);
                     udc.Add(-33);
+                    g.Record(200);
                     listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                     c.Add(12);
                     h.Record(26);
                     udc.Add(-40);
+                    g.Record(-200);
                     listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
                     events = listener.Events.ToArray();
                 }
 
-                AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+                AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
                 AssertInitialEnumerationCompleteEventPresent(events);
                 AssertCounterEventsPresent(events, meter.Name, c.Name, "", "", ("5", "5"), ("12", "17"));
+                AssertGaugeEventsPresent(events, meter.Name, g.Name, "", "", "200", "-200");
                 AssertCounterEventsPresent(events, meter.Name, oc.Name, "", "", ("", "10"), ("7", "17"));
                 AssertGaugeEventsPresent(events, meter.Name, og.Name, "", "", "9", "18");
                 AssertHistogramEventsPresent(events, meter.Name, h.Name, "", "", ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"));
@@ -719,6 +747,7 @@ public void EventSourcePublishesTimeSeriesWithMetadata()
         {
             using Meter meter = new Meter("TestMeter2");
             Counter<int> c = meter.CreateCounter<int>("counter1", "hat", "Fooz!!", new TagList() { { "Ck1", "Cv1" }, { "Ck2", "Cv2" } });
+            Gauge<int> g = meter.CreateGauge<int>("gauge1", "C", "Temperature", new TagList() { { "Ck1", "Cv1" } });
             int counterState = 3;
             ObservableCounter<int> oc = meter.CreateObservableCounter<int>("observableCounter1", () => { counterState += 7; return counterState; } , "MB", "Size of universe", new TagList() { { "oCk1", "oCv1" } });
             int gaugeState = 0;
@@ -735,17 +764,20 @@ public void EventSourcePublishesTimeSeriesWithMetadata()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(77);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(-177);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events);
             AssertCounterEventsPresent(events, meter.Name, c.Name, "", c.Unit, ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "", g.Unit, "77", "-177");
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "", oc.Unit, ("", "10"), ("7", "17"), ("7", "24"));
             AssertGaugeEventsPresent(events, meter.Name, og.Name, "", og.Unit, "9", "18", "27");
             AssertHistogramEventsPresent(events, meter.Name, h.Name, "", h.Unit, ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"));
@@ -769,6 +801,7 @@ public void EventSourcePublishesTimeSeriesForLateMeter()
                 Histogram<int> h;
                 UpDownCounter<int> udc;
                 ObservableUpDownCounter<int> oudc;
+                Gauge<int> g;
 
                 EventWrittenEventArgs[] events;
                 using (MetricsEventListener listener = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, IntervalSecs, "TestMeter3"))
@@ -778,6 +811,8 @@ public void EventSourcePublishesTimeSeriesForLateMeter()
                     // the Meter is created after the EventSource was already monitoring
                     meter = new Meter("TestMeter3");
                     c = meter.CreateCounter<int>("counter1");
+                    g = meter.CreateGauge<int>("gauge1");
+
                     int counterState = 3;
                     oc = meter.CreateObservableCounter<int>("observableCounter1", () => { counterState += 7; return counterState; });
                     int gaugeState = 0;
@@ -790,17 +825,20 @@ public void EventSourcePublishesTimeSeriesForLateMeter()
                     c.Add(5);
                     h.Record(19);
                     udc.Add(33);
+                    g.Record(1);
                     listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                     c.Add(12);
                     h.Record(26);
                     udc.Add(40);
+                    g.Record(-1);
                     listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
                     events = listener.Events.ToArray();
                 }
 
-                AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+                AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
                 AssertInitialEnumerationCompleteEventPresent(events);
                 AssertCounterEventsPresent(events, meter.Name, c.Name, "", "", ("5", "5"), ("12", "17"));
+                AssertGaugeEventsPresent(events, meter.Name, g.Name, "", "", "1", "-1");
                 AssertCounterEventsPresent(events, meter.Name, oc.Name, "", "", ("", "10"), ("7", "17"));
                 AssertGaugeEventsPresent(events, meter.Name, og.Name, "", "", "9", "18");
                 AssertHistogramEventsPresent(events, meter.Name, h.Name, "", "", ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"));
@@ -826,6 +864,7 @@ public void EventSourcePublishesTimeSeriesForLateInstruments()
             Histogram<int> h;
             UpDownCounter<int> udc;
             ObservableUpDownCounter<int> oudc;
+            Gauge<int> g;
 
             EventWrittenEventArgs[] events;
             using (MetricsEventListener listener = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, IntervalSecs, "TestMeter4"))
@@ -834,6 +873,7 @@ public void EventSourcePublishesTimeSeriesForLateInstruments()
 
                 // Instruments are created after the EventSource was already monitoring
                 c = meter.CreateCounter<int>("counter1", null, null, new TagList() { { "Ck1", "Cv1" }, { "Ck2", "Cv2" } });
+                g = meter.CreateGauge<int>("gauge1", null, null, new TagList() { { "Ck1", "Cv1" }, { "Ck2", "Cv2" } });
                 int counterState = 3;
                 oc = meter.CreateObservableCounter<int>("observableCounter1", () => { counterState += 7; return counterState; });
                 int gaugeState = 0;
@@ -846,17 +886,20 @@ public void EventSourcePublishesTimeSeriesForLateInstruments()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(-33);
+                g.Record(-1000);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(-40);
+                g.Record(2000);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events);
             AssertCounterEventsPresent(events, meter.Name, c.Name, "", "", ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "", "", "-1000", "2000");
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "", "", ("", "10"), ("7", "17"));
             AssertGaugeEventsPresent(events, meter.Name, og.Name, "", "", "9", "18");
             AssertHistogramEventsPresent(events, meter.Name, h.Name, "", "", ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"));
@@ -893,6 +936,7 @@ public void EventSourcePublishesTimeSeriesWithTags()
             });
             Histogram<int> h = meter.CreateHistogram<int>("histogram1");
             UpDownCounter<int> udc = meter.CreateUpDownCounter<int>("upDownCounter1");
+            Gauge<int> g = meter.CreateGauge<int>("gauge1");
             int upDownCounterState = 0;
             ObservableUpDownCounter<int> oudc = meter.CreateObservableUpDownCounter<int>("observableUpDownCounter1", () =>
             {
@@ -915,6 +959,8 @@ public void EventSourcePublishesTimeSeriesWithTags()
                 h.Record(20, new KeyValuePair<string, object?>("Size", 124));
                 udc.Add(-33, new KeyValuePair<string, object?>("Color", "red"));
                 udc.Add(-34, new KeyValuePair<string, object?>("Color", "blue"));
+                g.Record(1, new KeyValuePair<string, object?>("Color", "black"));
+                g.Record(2, new KeyValuePair<string, object?>("Color", "white"));
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
 
                 c.Add(12, new KeyValuePair<string, object?>("Color", "red"));
@@ -923,14 +969,18 @@ public void EventSourcePublishesTimeSeriesWithTags()
                 h.Record(27, new KeyValuePair<string, object?>("Size", 124));
                 udc.Add(40, new KeyValuePair<string, object?>("Color", "red"));
                 udc.Add(41, new KeyValuePair<string, object?>("Color", "blue"));
+                g.Record(3, new KeyValuePair<string, object?>("Color", "black"));
+                g.Record(4, new KeyValuePair<string, object?>("Color", "white"));
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events);
             AssertCounterEventsPresent(events, meter.Name, c.Name, "Color=red", "", ("5", "5"), ("12", "17"));
             AssertCounterEventsPresent(events, meter.Name, c.Name, "Color=blue", "", ("6", "6"), ("13", "19"));
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "Color=black", "", "1", "3");
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "Color=white", "", "2", "4");
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "Color=red,Size=19", "", ("", "10"), ("7", "17"));
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "Color=blue,Size=4", "", ("", "20"), ("14", "34"));
             AssertGaugeEventsPresent(events, meter.Name, og.Name, "Color=red,Size=19", "", "9", "18");
@@ -1049,6 +1099,7 @@ public void EventSourcePublishesMissingDataPoints()
             Histogram<int> h = meter.CreateHistogram<int>("histogram1");
 
             UpDownCounter<int> udc = meter.CreateUpDownCounter<int>("upDownCounter1");
+            Gauge<int> g = meter.CreateGauge<int>("gauge1");
             int upDownCounterState = 0;
             int upDownCounterCollectInterval = 0;
             ObservableUpDownCounter<int> oudc = meter.CreateObservableUpDownCounter<int>("observableUpDownCounter1", () =>
@@ -1073,21 +1124,24 @@ public void EventSourcePublishesMissingDataPoints()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(-123);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 // no measurements in interval 3
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(123);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 4);
                 // no measurements in interval 5
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 5);
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events);
             AssertCounterEventsPresent(events, meter.Name, c.Name, "", "", ("5", "5"), ("0", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "", "", "-123", "", "123", "");
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "", "", ("",  "17"), ("0", "17"), ("14", "31"), ("0", "31"));
             AssertGaugeEventsPresent(events, meter.Name, og.Name, "", "", "18", "", "36", "");
             AssertHistogramEventsPresent(events, meter.Name, h.Name, "", "", ("0.5=19;0.95=19;0.99=19", "1", "19"), ("", "0", "0"), ("0.5=26;0.95=26;0.99=26", "1", "26"), ("", "0", "0"));
@@ -1104,6 +1158,7 @@ public void EventSourcePublishesEndEventsOnMeterDispose()
             using Meter meterA = new Meter("TestMeter8", null, new TagList() { { "Mk1", "Mv1" }, { "Mk2", null } }, scope);
             using Meter meterB = new Meter("TestMeter9", null, new TagList() { { "Mk1", null }, { "Mk2", "Mv2" } }, scope);
             Counter<int> c = meterA.CreateCounter<int>("counter1", "hat", "Fooz!!");
+            Gauge<int> g = meterA.CreateGauge<int>("gauge1", "C", "Temperature");
             int counterState = 3;
             ObservableCounter<int> oc = meterA.CreateObservableCounter<int>("observableCounter1", () => { counterState += 7; return counterState; }, "MB", "Size of universe");
             int gaugeState = 0;
@@ -1120,10 +1175,12 @@ public void EventSourcePublishesEndEventsOnMeterDispose()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(9);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(90);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
 
                 meterA.Dispose();
@@ -1134,19 +1191,19 @@ public void EventSourcePublishesEndEventsOnMeterDispose()
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events);
             AssertCounterEventsPresent(events, meterA.Name, c.Name, "", c.Unit, ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meterA.Name, g.Name, "", g.Unit, "9", "90");
             AssertCounterEventsPresent(events, meterA.Name, oc.Name, "", oc.Unit, ("", "10"), ("7", "17"), ("7", "24"));
             AssertGaugeEventsPresent(events, meterA.Name, og.Name, "", og.Unit, "9", "18", "27");
             AssertHistogramEventsPresent(events, meterB.Name, h.Name, "", h.Unit, ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"), ("0.5=21;0.95=21;0.99=21", "1", "21"));
             AssertUpDownCounterEventsPresent(events, meterA.Name, udc.Name, "", udc.Unit, ("33", "33"), ("40", "73"));
             AssertUpDownCounterEventsPresent(events, meterA.Name, oudc.Name, "", oudc.Unit, ("", "11"), ("11", "22"), ("11", "33"));
             AssertCollectStartStopEventsPresent(events, IntervalSecs, 4);
-            AssertEndInstrumentReportingEventsPresent(events, c, oc, og, udc, oudc);
+            AssertEndInstrumentReportingEventsPresent(events, c, oc, og, udc, oudc, g);
         }
 
-
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))]
         [OuterLoop("Slow and has lots of console spew")]
         public void EventSourcePublishesInstruments()
@@ -1156,6 +1213,7 @@ public void EventSourcePublishesInstruments()
             using Meter meterA = new Meter("TestMeter10", null, null, scope);
             using Meter meterB = new Meter("TestMeter11", null, new TagList() { { "Mk1", "Mv1" }, { "Mk2", null } }, scope);
             Counter<int> c = meterA.CreateCounter<int>("counter1", "hat", "Fooz!!");
+            Gauge<int> g = meterA.CreateGauge<int>("gauge1", "C", "Temperature");
             int counterState = 3;
             ObservableCounter<int> oc = meterA.CreateObservableCounter<int>("observableCounter1", () => { counterState += 7; return counterState; }, "MB", "Size of universe",
                                             new TagList() { { "ock1", "ocv1" }, { "ock2", "ocv2" }, { "ock3", "ocv3" } });
@@ -1174,7 +1232,7 @@ public void EventSourcePublishesInstruments()
                 events = listener.Events.ToArray();
             }
 
-            AssertInstrumentPublishingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertInstrumentPublishingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events);
         }
 
@@ -1350,6 +1408,7 @@ public void EventSourceWorksWithSequentialListeners()
         {
             using Meter meter = new Meter("TestMeter16");
             Counter<int> c = meter.CreateCounter<int>("counter1");
+            Gauge<int> g = meter.CreateGauge<int>("gauge1");
             int counterState = 3;
             ObservableCounter<int> oc = meter.CreateObservableCounter<int>("observableCounter1", () => { counterState += 7; return counterState; });
             int gaugeState = 0;
@@ -1366,17 +1425,20 @@ public void EventSourceWorksWithSequentialListeners()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(-10);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(10);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events);
             AssertCounterEventsPresent(events, meter.Name, c.Name, "", "", ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "", "", "-10", "10");
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "", "", ("", "10"), ("7", "17"));
             AssertGaugeEventsPresent(events, meter.Name, og.Name, "", "", "9", "18");
             AssertHistogramEventsPresent(events, meter.Name, h.Name, "", "", ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"));
@@ -1393,17 +1455,20 @@ public void EventSourceWorksWithSequentialListeners()
                 c.Add(5);
                 h.Record(19);
                 udc.Add(33);
+                g.Record(-10);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 2);
                 c.Add(12);
                 h.Record(26);
                 udc.Add(40);
+                g.Record(10);
                 listener.WaitForCollectionStop(s_waitForEventTimeout, 3);
                 events = listener.Events.ToArray();
             }
 
-            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc);
+            AssertBeginInstrumentReportingEventsPresent(events, c, oc, og, h, udc, oudc, g);
             AssertInitialEnumerationCompleteEventPresent(events);
             AssertCounterEventsPresent(events, meter.Name, c.Name, "", "", ("5", "5"), ("12", "17"));
+            AssertGaugeEventsPresent(events, meter.Name, g.Name, "", "", "-10", "10");
             AssertCounterEventsPresent(events, meter.Name, oc.Name, "", "", ("", "31"), ("7", "38"));
             AssertGaugeEventsPresent(events, meter.Name, og.Name, "", "", "36", "45");
             AssertHistogramEventsPresent(events, meter.Name, h.Name, "", "", ("0.5=19;0.95=19;0.99=19", "1", "19"), ("0.5=26;0.95=26;0.99=26", "1", "26"));
@@ -1954,8 +2019,6 @@ void WaitForEvent(TimeSpan timeout, int numEvents, string eventName)
             }
         }
 
-
-
         private void AssertOnError()
         {
             lock (this)
diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricsTests.cs b/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricsTests.cs
index db5bd31d38821..cc512d20d4baa 100644
--- a/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricsTests.cs
+++ b/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricsTests.cs
@@ -26,7 +26,7 @@ public void MeasurementConstructionTest()
                 var measurement = new Measurement<int>(i, tags);
                 Assert.Equal(i, measurement.Value);
                 TagListTests.ValidateTags(new TagList(measurement.Tags), tagsArray);
-                
+
                 measurement = new Measurement<int>(i, tagsArray);
                 Assert.Equal(i, measurement.Value);
                 TagListTests.ValidateTags(new TagList(measurement.Tags), tagsArray);
@@ -74,6 +74,9 @@ public void InstrumentCreationTest()
                 ObservableUpDownCounter<long> observableUpDownCounter = meter.CreateObservableUpDownCounter<long>("ObservableUpDownCounter", () => -1, "request", "request ObservableUpDownCounter");
                 ValidateInstrumentInfo(observableUpDownCounter, "ObservableUpDownCounter", "request", "request ObservableUpDownCounter", false, true);
 
+                Gauge<int> gauge = meter.CreateGauge<int>("Gauge", "C", "Temperature Gauge");
+                ValidateInstrumentInfo(gauge, "Gauge", "C", "Temperature Gauge", false, false);
+
                 ObservableGauge<double> observableGauge = meter.CreateObservableGauge<double>("ObservableGauge", () => 10, "Fahrenheit", "Fahrenheit ObservableGauge");
                 ValidateInstrumentInfo(observableGauge, "ObservableGauge", "Fahrenheit", "Fahrenheit ObservableGauge", false, true);
             }).Dispose();
@@ -86,6 +89,7 @@ public void CreateInstrumentParametersTest()
                 Meter meter = new Meter("CreateInstrumentParametersTest");
 
                 Assert.Throws<ArgumentNullException>(() => meter.CreateCounter<byte>(null, "seconds", "Seconds Counter"));
+                Assert.Throws<ArgumentNullException>(() => meter.CreateGauge<byte>(null, "C", "Temperature Gauge"));
                 Assert.Throws<ArgumentNullException>(() => meter.CreateUpDownCounter<float>(null, "items", "Items UpDownCounter"));
                 Assert.Throws<ArgumentNullException>(() => meter.CreateHistogram<short>(null, "seconds", "Seconds Counter"));
                 Assert.Throws<ArgumentNullException>(() => meter.CreateObservableCounter<long>(null, () => 0, "seconds", "Seconds ObservableCounter"));
@@ -109,6 +113,14 @@ public void SupportedGenericParameterTypesTest()
                 Counter<double> counter6 = meter.CreateCounter<double>("Counter6", "seconds", "Seconds Counter");
                 Counter<decimal> counter7 = meter.CreateCounter<decimal>("Counter7", "seconds", "Seconds Counter");
 
+                Gauge<byte> gauge1 = meter.CreateGauge<byte>("Gauge1", "C", "Temperature Gauge");
+                Gauge<short> gauge2 = meter.CreateGauge<short>("Gauge2", "C", "Temperature Gauge");
+                Gauge<int> gauge3 = meter.CreateGauge<int>("Gauge3", "C", "Temperature Gauge");
+                Gauge<long> gauge4 = meter.CreateGauge<long>("Gauge4", "C", "Temperature Gauge");
+                Gauge<float> gauge5 = meter.CreateGauge<float>("Gauge5", "C", "Temperature Gauge");
+                Gauge<double> gauge6 = meter.CreateGauge<double>("Gauge6", "C", "Temperature Gauge");
+                Gauge<decimal> gauge7 = meter.CreateGauge<decimal>("Gauge7", "C", "Temperature Gauge");
+
                 UpDownCounter<byte> upDownCounter1 = meter.CreateUpDownCounter<byte>("UpDownCounter1", "seconds", "Seconds UpDownCounter");
                 UpDownCounter<short> upDownCounter2 = meter.CreateUpDownCounter<short>("UpDownCounter2", "seconds", "Seconds Counter");
                 UpDownCounter<int> upDownCounter3 = meter.CreateUpDownCounter<int>("UpDownCounter3", "seconds", "Seconds UpDownCounter");
@@ -182,16 +194,18 @@ public void ListeningToInstrumentsPublishingTest()
 
                     Assert.Equal(2, instrumentsEncountered);
 
+                    Gauge<double> gauge = meter.CreateGauge<double>("Gauge1", "C", "Temperature Gauge");
                     Histogram<byte> histogram = meter.CreateHistogram<byte>("histogram1", "seconds", "Seconds histogram");
                     ObservableCounter<byte> observableCounter = meter.CreateObservableCounter<byte>("observableCounter1", () => 0, "seconds", "Seconds ObservableCounter");
                     UpDownCounter<long> upDownCounter = meter.CreateUpDownCounter<long>("UpDownCounter4", "request", "Requests UpDownCounter");
                     ObservableUpDownCounter<byte> observableUpDownCounter = meter.CreateObservableUpDownCounter<byte>("observableUpDownCounter1", () => 0, "items", "Items ObservableCounter");
 
-                    Assert.Equal(6, instrumentsEncountered);
+                    Assert.Equal(7, instrumentsEncountered);
 
-                    // Enable listening to the 4 instruments
+                    // Enable listening to the 5 instruments
 
                     listener.EnableMeasurementEvents(counter, counter);
+                    listener.EnableMeasurementEvents(gauge, gauge);
                     listener.EnableMeasurementEvents(observableGauge, observableGauge);
                     listener.EnableMeasurementEvents(histogram, histogram);
                     listener.EnableMeasurementEvents(observableCounter, observableCounter);
@@ -274,42 +288,63 @@ public void InstrumentMeasurementTest(bool useSpan)
                 Counter<byte> counter = meter.CreateCounter<byte>("byteCounter");
                 InstrumentMeasurementAggregationValidation(counter, (value, tags) => { AddToCounter(counter, value, tags, useSpan); } );
 
+                Gauge<byte> gauge = meter.CreateGauge<byte>("byteGauge");
+                InstrumentMeasurementAggregationValidation(gauge, (value, tags) => { RecordToGauge(gauge, value, tags, useSpan); }, allowNegative: true);
+
                 UpDownCounter<byte> upDownCounter = meter.CreateUpDownCounter<byte>("byteUpDownCounter");
                 InstrumentMeasurementAggregationValidation(upDownCounter, (value, tags) => { AddToUpDownCounter(upDownCounter, value, tags, useSpan); });
 
                 Counter<short> counter1 = meter.CreateCounter<short>("shortCounter");
                 InstrumentMeasurementAggregationValidation(counter1, (value, tags) => { AddToCounter(counter1, value, tags, useSpan); } );
 
+                Gauge<short> gauge1 = meter.CreateGauge<short>("shortGauge");
+                InstrumentMeasurementAggregationValidation(gauge1, (value, tags) => { RecordToGauge(gauge1, value, tags, useSpan); }, allowNegative: true);
+
                 UpDownCounter<short> upDownCounter1 = meter.CreateUpDownCounter<short>("shortUpDownCounter");
                 InstrumentMeasurementAggregationValidation(upDownCounter1, (value, tags) => { AddToUpDownCounter(upDownCounter1, value, tags, useSpan); }, true);
 
                 Counter<int> counter2 = meter.CreateCounter<int>("intCounter");
                 InstrumentMeasurementAggregationValidation(counter2, (value, tags) => { AddToCounter(counter2, value, tags, useSpan); } );
 
+                Gauge<int> gauge2 = meter.CreateGauge<int>("intGauge");
+                InstrumentMeasurementAggregationValidation(gauge2, (value, tags) => { RecordToGauge(gauge2, value, tags, useSpan); }, allowNegative: true);
+
                 UpDownCounter<int> upDownCounter2 = meter.CreateUpDownCounter<int>("intUpDownCounter");
                 InstrumentMeasurementAggregationValidation(upDownCounter2, (value, tags) => { AddToUpDownCounter(upDownCounter2, value, tags, useSpan); }, true);
 
                 Counter<long> counter3 = meter.CreateCounter<long>("longCounter");
                 InstrumentMeasurementAggregationValidation(counter3, (value, tags) => { AddToCounter(counter3, value, tags, useSpan); } );
 
+                Gauge<long> gauge3 = meter.CreateGauge<long>("longGauge");
+                InstrumentMeasurementAggregationValidation(gauge3, (value, tags) => { RecordToGauge(gauge3, value, tags, useSpan); }, allowNegative: true);
+
                 UpDownCounter<long> upDownCounter3 = meter.CreateUpDownCounter<long>("longUpDownCounter");
                 InstrumentMeasurementAggregationValidation(upDownCounter3, (value, tags) => { AddToUpDownCounter(upDownCounter3, value, tags, useSpan); }, true);
 
                 Counter<float> counter4 = meter.CreateCounter<float>("floatCounter");
                 InstrumentMeasurementAggregationValidation(counter4, (value, tags) => { AddToCounter(counter4, value, tags, useSpan); } );
 
+                Gauge<float> gauge4 = meter.CreateGauge<float>("floatGauge");
+                InstrumentMeasurementAggregationValidation(gauge4, (value, tags) => { RecordToGauge(gauge4, value, tags, useSpan); }, allowNegative: true);
+
                 UpDownCounter<float> upDownCounter4 = meter.CreateUpDownCounter<float>("floatUpDownCounter");
                 InstrumentMeasurementAggregationValidation(upDownCounter4, (value, tags) => { AddToUpDownCounter(upDownCounter4, value, tags, useSpan); }, true);
 
                 Counter<double> counter5 = meter.CreateCounter<double>("doubleCounter");
                 InstrumentMeasurementAggregationValidation(counter5, (value, tags) => { AddToCounter(counter5, value, tags, useSpan); } );
 
+                Gauge<double> gauge5 = meter.CreateGauge<double>("doubleGauge");
+                InstrumentMeasurementAggregationValidation(gauge5, (value, tags) => { RecordToGauge(gauge5, value, tags, useSpan); }, allowNegative: true);
+
                 UpDownCounter<double> upDownCounter5 = meter.CreateUpDownCounter<double>("doubleUpDownCounter");
                 InstrumentMeasurementAggregationValidation(upDownCounter5, (value, tags) => { AddToUpDownCounter(upDownCounter5, value, tags, useSpan); }, true);
 
                 Counter<decimal> counter6 = meter.CreateCounter<decimal>("decimalCounter");
                 InstrumentMeasurementAggregationValidation(counter6, (value, tags) => { AddToCounter(counter6, value, tags, useSpan); } );
 
+                Gauge<decimal> gauge6 = meter.CreateGauge<decimal>("decimalGauge");
+                InstrumentMeasurementAggregationValidation(gauge6, (value, tags) => { RecordToGauge(gauge6, value, tags, useSpan); }, allowNegative: true);
+
                 UpDownCounter<decimal> upDownCounter6 = meter.CreateUpDownCounter<decimal>("decimalUpDownCounter");
                 InstrumentMeasurementAggregationValidation(upDownCounter6, (value, tags) => { AddToUpDownCounter(upDownCounter6, value, tags, useSpan); }, true);
 
@@ -335,7 +370,7 @@ public void InstrumentMeasurementTest(bool useSpan)
                 InstrumentMeasurementAggregationValidation(histogram6, (value, tags) => { Record(histogram6, value, tags, useSpan); } );
 
             }, useSpan.ToString()).Dispose();
-            
+
             void AddToCounter<T>(Counter<T> counter, T delta, KeyValuePair<string, object?>[] tags, bool useSpan) where T : struct
             {
                 if (useSpan)
@@ -348,6 +383,18 @@ void AddToCounter<T>(Counter<T> counter, T delta, KeyValuePair<string, object?>[
                 }
             }
 
+            void RecordToGauge<T>(Gauge<T> gauge, T value, KeyValuePair<string, object?>[] tags, bool useSpan) where T : struct
+            {
+                if (useSpan)
+                {
+                    gauge.Record(value, (ReadOnlySpan<KeyValuePair<string, object?>>)tags);
+                }
+                else
+                {
+                    gauge.Record(value, tags);
+                }
+            }
+
             void AddToUpDownCounter<T>(UpDownCounter<T> upDownCounter, T delta, KeyValuePair<string, object?>[] tags, bool useSpan) where T : struct
             {
                 if (useSpan)
@@ -714,6 +761,42 @@ public void PassingVariableTagsParametersTest()
                                                             return (decimal)(value * 2);
                                                         });
 
+                InstrumentPassingVariableTagsParametersTest<byte>(meter.CreateGauge<byte>("Gauge"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishGaugeMeasurement(instrument as Gauge<byte>, value, tags);
+                                                            return (byte)(value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<short>(meter.CreateGauge<short>("Gauge"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishGaugeMeasurement(instrument as Gauge<short>, value, tags);
+                                                            return (short)(value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<int>(meter.CreateGauge<int>("Gauge"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishGaugeMeasurement(instrument as Gauge<int>, value, tags);
+                                                            return (int)(value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<long>(meter.CreateGauge<long>("Gauge"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishGaugeMeasurement(instrument as Gauge<long>, value, tags);
+                                                            return (long)(value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<float>(meter.CreateGauge<float>("Gauge"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishGaugeMeasurement(instrument as Gauge<float>, value, tags);
+                                                            return (float)(value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<double>(meter.CreateGauge<double>("Gauge"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishGaugeMeasurement(instrument as Gauge<double>, value, tags);
+                                                            return (double)(value * 2);
+                                                        });
+                InstrumentPassingVariableTagsParametersTest<decimal>(meter.CreateGauge<decimal>("Gauge"), (instrument, value, tags) =>
+                                                        {
+                                                            PublishGaugeMeasurement(instrument as Gauge<decimal>, value, tags);
+                                                            return (decimal)(value * 2);
+                                                        });
+
                 InstrumentPassingVariableTagsParametersTest<byte>(meter.CreateUpDownCounter<byte>("Counter"), (instrument, value, tags) =>
                                                         {
                                                             PublishUpDownCounterMeasurement(instrument as UpDownCounter<byte>, value, tags);
@@ -798,6 +881,7 @@ public void MeterDisposalsTest()
                 Meter meter4 = new Meter("MeterDisposalsTest4");
                 Meter meter5 = new Meter("MeterDisposalsTest5");
                 Meter meter6 = new Meter("MeterDisposalsTest6");
+                Meter meter7 = new Meter("MeterDisposalsTest7");
 
                 Counter<int> counter = meter1.CreateCounter<int>("Counter");
                 Histogram<double> histogram = meter2.CreateHistogram<double>("Histogram");
@@ -805,6 +889,7 @@ public void MeterDisposalsTest()
                 ObservableGauge<decimal> observableGauge = meter4.CreateObservableGauge<decimal>("ObservableGauge", () => new Measurement<decimal>(5.7m, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key", "value")}));
                 UpDownCounter<short> upDownCounter = meter5.CreateUpDownCounter<short>("UpDownCounter");
                 ObservableUpDownCounter<int> observableUpDownCounter = meter6.CreateObservableUpDownCounter<int>("ObservableUpDownCounter", () => new Measurement<int>(-5, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key", "value")}));
+                Gauge<int> gauge = meter7.CreateGauge<int>("Gauge");
 
                 using MeterListener listener = new MeterListener();
                 listener.InstrumentPublished = (theInstrument, theListener) => theListener.EnableMeasurementEvents(theInstrument, theInstrument);
@@ -830,35 +915,42 @@ public void MeterDisposalsTest()
                 histogram.Record(1);
                 Assert.Equal(3, count);
 
+                gauge.Record(1);
+                Assert.Equal(4, count);
+
                 listener.RecordObservableInstruments();
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
 
                 meter1.Dispose();
                 counter.Add(1);
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
 
                 meter2.Dispose();
                 histogram.Record(1);
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
 
                 meter5.Dispose();
                 upDownCounter.Add(-10);
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
+
+                meter7.Dispose();
+                gauge.Record(-10);
+                Assert.Equal(7, count);
 
                 listener.RecordObservableInstruments();
-                Assert.Equal(9, count);
+                Assert.Equal(10, count);
 
                 meter3.Dispose();
                 listener.RecordObservableInstruments();
-                Assert.Equal(11, count);
+                Assert.Equal(12, count);
 
                 meter4.Dispose();
                 listener.RecordObservableInstruments();
-                Assert.Equal(12, count);
+                Assert.Equal(13, count);
 
                 meter6.Dispose();
                 listener.RecordObservableInstruments();
-                Assert.Equal(12, count);
+                Assert.Equal(13, count);
 
             }).Dispose();
         }
@@ -870,6 +962,7 @@ public void ListenerDisposalsTest()
                 Meter meter = new Meter("ListenerDisposalsTest");
 
                 Counter<int> counter = meter.CreateCounter<int>("Counter");
+                Gauge<int> gauge = meter.CreateGauge<int>("Gauge");
                 UpDownCounter<short> upDownCounter = meter.CreateUpDownCounter<short>("upDownCounter");
                 Histogram<double> histogram = meter.CreateHistogram<double>("Histogram");
                 ObservableCounter<long> observableCounter = meter.CreateObservableCounter<long>("ObservableCounter", () => new Measurement<long>(10, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key", "value")}));
@@ -903,23 +996,29 @@ public void ListenerDisposalsTest()
                 histogram.Record(1);
                 Assert.Equal(3, count);
 
+                gauge.Record(1);
+                Assert.Equal(4, count);
+
                 listener.RecordObservableInstruments();
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
 
                 listener.Dispose();
-                Assert.Equal(6, completedMeasurements);
+                Assert.Equal(7, completedMeasurements);
 
                 counter.Add(1);
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
 
                 upDownCounter.Add(-1);
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
 
                 histogram.Record(1);
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
+
+                gauge.Record(1);
+                Assert.Equal(7, count);
 
                 listener.RecordObservableInstruments();
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
             }).Dispose();
         }
 
@@ -930,6 +1029,7 @@ public void ListenerWithoutMeasurementsCompletedDisposalsTest()
                 Meter meter = new Meter("MinimalListenerDisposalsTest");
 
                 Counter<int> counter = meter.CreateCounter<int>("Counter");
+                Gauge<int> gauge = meter.CreateGauge<int>("Gauge");
                 UpDownCounter<short> upDownCounter = meter.CreateUpDownCounter<short>("upDownCounter");
                 Histogram<double> histogram = meter.CreateHistogram<double>("Histogram");
                 ObservableCounter<long> observableCounter = meter.CreateObservableCounter("ObservableCounter", () => new Measurement<long>(10, new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key", "value")}));
@@ -961,22 +1061,28 @@ public void ListenerWithoutMeasurementsCompletedDisposalsTest()
                 histogram.Record(1);
                 Assert.Equal(3, count);
 
+                gauge.Record(1);
+                Assert.Equal(4, count);
+
                 listener.RecordObservableInstruments();
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
 
                 listener.Dispose();
 
                 counter.Add(1);
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
 
                 upDownCounter.Add(-1);
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
 
                 histogram.Record(1);
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
+
+                gauge.Record(1);
+                Assert.Equal(7, count);
 
                 listener.RecordObservableInstruments();
-                Assert.Equal(6, count);
+                Assert.Equal(7, count);
             }).Dispose();
         }
 
@@ -1014,6 +1120,14 @@ public void MultipleListenersTest()
 
                 counter.Add(1);
                 Assert.Equal(9, count);
+
+                Gauge<int> gauge = meter.CreateGauge<int>("Gauge");
+
+                gauge.Record(1);
+                Assert.Equal(12, count);
+
+                gauge.Record(1);
+                Assert.Equal(15, count);
             }).Dispose();
         }
 
@@ -1024,6 +1138,7 @@ public void NullMeasurementEventCallbackTest()
                 Meter meter = new Meter("NullMeasurementEventCallbackTest");
 
                 Counter<int> counter = meter.CreateCounter<int>("Counter");
+                Gauge<int> gauge = meter.CreateGauge<int>("Gauge");
 
                 MeterListener listener = new MeterListener();
 
@@ -1039,9 +1154,15 @@ public void NullMeasurementEventCallbackTest()
                 counter.Add(1);
                 Assert.Equal(1, count);
 
+                gauge.Record(1);
+                Assert.Equal(2, count);
+
                 listener.SetMeasurementEventCallback<int>(null);
                 counter.Add(1);
-                Assert.Equal(1, count);
+                Assert.Equal(2, count);
+
+                gauge.Record(1);
+                Assert.Equal(2, count);
 
                 Assert.Throws<InvalidOperationException>(() => listener.SetMeasurementEventCallback<ulong>(null));
             }).Dispose();
@@ -1064,6 +1185,7 @@ public void EnableListeningMultipleTimesWithDifferentState()
                 listener.Start();
 
                 string newState = "2";
+                // EnableMeasurementEvents will cause MeasurementsCompleted get invoked because measurements were registered before with a different state.
                 listener.EnableMeasurementEvents(counter, newState);
                 Assert.Equal(1, completedCount);
                 lastState = newState;
@@ -1090,6 +1212,7 @@ public void ParallelRunningTest()
                 Meter meter = new Meter("ParallelRunningTest");
 
                 Counter<int> counter = meter.CreateCounter<int>("Counter");
+                Gauge<int> gauge = meter.CreateGauge<int>("Gauge");
                 UpDownCounter<int> upDownCounter = meter.CreateUpDownCounter<int>("UpDownCounter");
                 Histogram<int> histogram = meter.CreateHistogram<int>("Histogram");
                 ObservableCounter<int> observableCounter = meter.CreateObservableCounter<int>("ObservableCounter", () => 1);
@@ -1103,7 +1226,7 @@ public void ParallelRunningTest()
                 listener.SetMeasurementEventCallback<int>((inst, measurement, tags, state) => Interlocked.Add(ref totalCount, measurement));
                 listener.Start();
 
-                Task[] taskList = new Task[9];
+                Task[] taskList = new Task[11];
 
                 int loopLength = 10_000;
 
@@ -1116,10 +1239,12 @@ public void ParallelRunningTest()
                 taskList[6] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { upDownCounter.Add(1); } });
                 taskList[7] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { upDownCounter.Add(1); } });
                 taskList[8] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { listener.RecordObservableInstruments(); } });
+                taskList[9] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { gauge.Record(1); } });
+                taskList[10] = Task.Factory.StartNew(() => { for (int i = 0; i < loopLength; i++) { gauge.Record(1); } });
 
                 Task.WaitAll(taskList);
 
-                Assert.Equal(loopLength * 15, totalCount);
+                Assert.Equal(loopLength * 17, totalCount);
             }).Dispose();
         }
 
@@ -1177,6 +1302,8 @@ public void SerializedEventsTest()
                                 int c = Interlocked.Increment(ref counterCounter);
                                 Counter<int> counter = meters[index].CreateCounter<int>("Counter");
                                 counter.Add(1);
+                                Gauge<int> gauge = meters[index].CreateGauge<int>("Gauge");
+                                gauge.Record(1);
                             }
 
                             meters[index].Dispose();
@@ -1200,10 +1327,12 @@ public void TestRecordingMeasurementsWithTagList()
                 using (MeterListener listener = new MeterListener())
                 {
                     Counter<int> counter = meter.CreateCounter<int>("Counter");
+                    Gauge<int> gauge = meter.CreateGauge<int>("Gauge");
                     UpDownCounter<int> upDownCounter = meter.CreateUpDownCounter<int>("UpDownCounter");
                     Histogram<int> histogram = meter.CreateHistogram<int>("histogram");
 
                     listener.EnableMeasurementEvents(counter, counter);
+                    listener.EnableMeasurementEvents(gauge, gauge);
                     listener.EnableMeasurementEvents(upDownCounter, upDownCounter);
                     listener.EnableMeasurementEvents(histogram, histogram);
 
@@ -1220,12 +1349,14 @@ public void TestRecordingMeasurementsWithTagList()
 
                     expectedTags = new KeyValuePair<string, object?>[0];
                     counter.Add(10, new TagList());
+                    gauge.Record(5);
                     upDownCounter.Add(-1, new TagList());
                     histogram.Record(10, new TagList());
 
                     // 1 Tags
                     expectedTags = new KeyValuePair<string, object?>[] { new KeyValuePair<string, object?>("Key1", "Value1") };
                     counter.Add(10, new TagList() { expectedTags[0] });
+                    gauge.Record(1, new TagList() { expectedTags[0] });
                     upDownCounter.Add(-2, new TagList() { expectedTags[0] });
                     histogram.Record(10, new TagList() { new KeyValuePair<string, object?>("Key1", "Value1") });
 
@@ -1237,6 +1368,7 @@ public void TestRecordingMeasurementsWithTagList()
                     }.ToArray();
 
                     counter.Add(10, new TagList() { expectedTags[0], expectedTags[1] });
+                    gauge.Record(2, new TagList() { expectedTags[0], expectedTags[1] });
                     upDownCounter.Add(-3, new TagList() { expectedTags[0], expectedTags[1] });
                     histogram.Record(10, new TagList() { expectedTags[0], expectedTags[1] });
 
@@ -1254,6 +1386,7 @@ public void TestRecordingMeasurementsWithTagList()
                     }.ToArray();
 
                     counter.Add(10, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7] });
+                    gauge.Record(3, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7] });
                     upDownCounter.Add(-4, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7] });
                     histogram.Record(10, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7] });
 
@@ -1277,6 +1410,8 @@ public void TestRecordingMeasurementsWithTagList()
 
                     counter.Add(10, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7],
                                                      expectedTags[8], expectedTags[9], expectedTags[10], expectedTags[11], expectedTags[12] });
+                    gauge.Record(3, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7],
+                                                     expectedTags[8], expectedTags[9], expectedTags[10], expectedTags[11], expectedTags[12] });
                     upDownCounter.Add(-5, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7],
                                                      expectedTags[8], expectedTags[9], expectedTags[10], expectedTags[11], expectedTags[12] });
                     histogram.Record(10, new TagList() { expectedTags[0], expectedTags[1], expectedTags[2], expectedTags[3], expectedTags[4], expectedTags[5], expectedTags[6], expectedTags[7],
@@ -1364,10 +1499,17 @@ public void TestCachedInstruments()
                 Counter<int> counter1 = meter.CreateCounter<int>("name1");
                 Counter<int> counter2 = meter.CreateCounter<int>("name1");
 
+                Gauge<int> gauge1 = meter.CreateGauge<int>("name1");
+                Gauge<int> gauge2 = meter.CreateGauge<int>("name1");
+
                 Assert.True(object.ReferenceEquals(counter1, counter2));
+                Assert.True(object.ReferenceEquals(gauge1, gauge2));
 
                 Counter<int> counter3 = meter.CreateCounter<int>("name1", "unique");
+                Gauge<int> gauge3 = meter.CreateGauge<int>("name1", "unique");
+
                 Assert.False(object.ReferenceEquals(counter1, counter3));
+                Assert.False(object.ReferenceEquals(gauge1, gauge3));
 
                 var list1 = new List<KeyValuePair<string, object?>>
                 {
@@ -1378,15 +1520,23 @@ public void TestCachedInstruments()
                 Counter<int> counter4 = meter.CreateCounter<int>("name", null, null, list1);
                 Counter<int> counter5 = meter.CreateCounter<int>("name", null, null, list1);
 
+                Gauge<int> gauge4 = meter.CreateGauge<int>("name", null, null, list1);
+                Gauge<int> gauge5 = meter.CreateGauge<int>("name", null, null, list1);
+
                 Assert.True(object.ReferenceEquals(counter4, counter5));
+                Assert.True(object.ReferenceEquals(gauge4, gauge5));
 
                 Counter<int> counter6 = meter.CreateCounter<int>("name", "diff", null, list1);
+                Gauge<int> gauge6 = meter.CreateGauge<int>("name", "diff", null, list1);
 
                 Assert.False(object.ReferenceEquals(counter4, counter6));
+                Assert.False(object.ReferenceEquals(gauge4, gauge6));
 
                 Counter<long> counter7 = meter.CreateCounter<long>("name", null, null, list1);
+                Gauge<long> gauge7 = meter.CreateGauge<long>("name", null, null, list1);
 
                 Assert.False(object.ReferenceEquals(counter4, counter7));
+                Assert.False(object.ReferenceEquals(gauge4, gauge7));
 
                 var list2 = new List<KeyValuePair<string, object?>>
                 {
@@ -1395,8 +1545,10 @@ public void TestCachedInstruments()
                 };
 
                 Counter<int> counter8 = meter.CreateCounter<int>("name", null, null, list2);
+                Gauge<int> gauge8 = meter.CreateGauge<int>("name", null, null, list2);
 
                 Assert.False(object.ReferenceEquals(counter4, counter8));
+                Assert.False(object.ReferenceEquals(gauge4, gauge8));
 
                 Histogram<int> histogram1 = meter.CreateHistogram<int>("name", null, null, list2);
 
@@ -1453,12 +1605,20 @@ public void TestCachedInstruments()
                 Assert.Same(counter9, counter10);
                 Assert.Same(counter9, counter11);
 
+                Gauge<int> gauge9 = meter.CreateGauge<int>("name9", null, null, l1);
+                Gauge<int> gauge10 = meter.CreateGauge<int>("name9", null, null, l2);
+                Gauge<int> gauge11 = meter.CreateGauge<int>("name9", null, null, l3);
+                Assert.Same(gauge9, gauge10);
+                Assert.Same(gauge9, gauge11);
+
                 KeyValuePair<string, object?>[] t1 = counter9.Tags.ToArray();
                 Assert.Equal(l1.Count, t1.Length);
                 t1[0] = new KeyValuePair<string, object?>(t1[0].Key, "newValue"); // change value of one item;
                 Counter<int> counter12 = meter.CreateCounter<int>("name9", null, null, t1);
                 Assert.NotSame(counter9, counter12);
 
+                Gauge<int> gauge12 = meter.CreateGauge<int>("name9", null, null, t1);
+                Assert.NotSame(gauge9, gauge12);
             }).Dispose();
         }
 
@@ -1515,10 +1675,19 @@ public void TestInstrumentCreationWithTags()
                     Assert.True(string.Compare(insArray[i].Key, insArray[i + 1].Key, StringComparison.Ordinal) <= 0);
                 }
 
+                Instrument ins14 = meter.CreateGauge<int>("Gauge", null, null, new TagList() { { "c1", "cv-1" } });
+                Assert.Equal(new[] { new KeyValuePair<string, object?>("c1", "cv-1") }, ins14.Tags);
+
+                Instrument ins15 = meter.CreateGauge<int>("counter", null, null, l);
+                insArray = ins15.Tags.ToArray();
+                Assert.Equal(l.Count, insArray.Length);
+                for (int i = 0; i < insArray.Length - 1; i++)
+                {
+                    Assert.True(string.Compare(insArray[i].Key, insArray[i + 1].Key, StringComparison.Ordinal) <= 0);
+                }
             }).Dispose();
         }
 
-
         private void PublishCounterMeasurement<T>(Counter<T> counter, T value, KeyValuePair<string, object?>[] tags) where T : struct
         {
             switch (tags.Length)
@@ -1537,6 +1706,24 @@ private void PublishCounterMeasurement<T>(Counter<T> counter, T value, KeyValueP
             }
         }
 
+        private void PublishGaugeMeasurement<T>(Gauge<T> gauge, T value, KeyValuePair<string, object?>[] tags) where T : struct
+        {
+            switch (tags.Length)
+            {
+                case 0: gauge.Record(value); break;
+                case 1: gauge.Record(value, tags[0]); break;
+                case 2: gauge.Record(value, tags[0], tags[1]); break;
+                case 3: gauge.Record(value, tags[0], tags[1], tags[2]); break;
+                case 4: gauge.Record(value, tags[0], tags[1], tags[2], tags[3]); break;
+                case 5: gauge.Record(value, tags[0], tags[1], tags[2], tags[3], tags[4]); break;
+                case 6: gauge.Record(value, tags[0], tags[1], tags[2], tags[3], tags[4], tags[5]); break;
+                case 7: gauge.Record(value, tags[0], tags[1], tags[2], tags[3], tags[4], tags[5], tags[6]); break;
+                case 8: gauge.Record(value, tags[0], tags[1], tags[2], tags[3], tags[4], tags[5], tags[6], tags[7]); break;
+                case 9: gauge.Record(value, tags[0], tags[1], tags[2], tags[3], tags[4], tags[5], tags[6], tags[7], tags[8]); break;
+                default: gauge.Record(value, tags); break;
+            }
+        }
+
         private void PublishUpDownCounterMeasurement<T>(UpDownCounter<T> counter, T value, KeyValuePair<string, object?>[] tags) where T : struct
         {
             switch (tags.Length)