diff --git a/src/OpenTelemetry.Api/Metrics/Counter.cs b/src/OpenTelemetry.Api/Metrics/CounterMetric.cs
similarity index 91%
rename from src/OpenTelemetry.Api/Metrics/Counter.cs
rename to src/OpenTelemetry.Api/Metrics/CounterMetric.cs
index 76f527465f7..a94136220c3 100644
--- a/src/OpenTelemetry.Api/Metrics/Counter.cs
+++ b/src/OpenTelemetry.Api/Metrics/CounterMetric.cs
@@ -1,4 +1,4 @@
-// <copyright file="Counter.cs" company="OpenTelemetry Authors">
+// <copyright file="CounterMetric.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,7 +24,7 @@ namespace OpenTelemetry.Metrics
     /// Counter instrument.
     /// </summary>
     /// <typeparam name="T">The type of counter. Only long and double are supported now.</typeparam>
-    public abstract class Counter<T>
+    public abstract class CounterMetric<T>
         where T : struct
     {
         /// <summary>
@@ -64,13 +64,13 @@ public abstract class Counter<T>
         /// </summary>
         /// <param name="labelset">The labelset from which handle should be constructed.</param>
         /// <returns>The handle.</returns>
-        public abstract CounterHandle<T> GetHandle(LabelSet labelset);
+        public abstract CounterMetricHandle<T> GetHandle(LabelSet labelset);
 
         /// <summary>
         /// Gets the handle with given labels.
         /// </summary>
         /// <param name="labels">The labels or dimensions associated with this value.</param>
         /// <returns>The handle.</returns>
-        public abstract CounterHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels);
+        public abstract CounterMetricHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels);
     }
 }
diff --git a/src/OpenTelemetry.Api/Metrics/CounterHandle.cs b/src/OpenTelemetry.Api/Metrics/CounterMetricHandle.cs
similarity index 92%
rename from src/OpenTelemetry.Api/Metrics/CounterHandle.cs
rename to src/OpenTelemetry.Api/Metrics/CounterMetricHandle.cs
index 7a40451e440..c9a5ab43904 100644
--- a/src/OpenTelemetry.Api/Metrics/CounterHandle.cs
+++ b/src/OpenTelemetry.Api/Metrics/CounterMetricHandle.cs
@@ -1,4 +1,4 @@
-// <copyright file="CounterHandle.cs" company="OpenTelemetry Authors">
+// <copyright file="CounterMetricHandle.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -23,7 +23,7 @@ namespace OpenTelemetry.Metrics
     /// Handle to the metrics counter with the defined <see cref="LabelSet"/>.
     /// </summary>
     /// <typeparam name="T">The type of counter. Only long and double are supported now.</typeparam>
-    public abstract class CounterHandle<T>
+    public abstract class CounterMetricHandle<T>
         where T : struct
     {
         /// <summary>
diff --git a/src/OpenTelemetry.Api/Metrics/Measure.cs b/src/OpenTelemetry.Api/Metrics/MeasureMetric.cs
similarity index 91%
rename from src/OpenTelemetry.Api/Metrics/Measure.cs
rename to src/OpenTelemetry.Api/Metrics/MeasureMetric.cs
index c93154dd58b..7215a444ba8 100644
--- a/src/OpenTelemetry.Api/Metrics/Measure.cs
+++ b/src/OpenTelemetry.Api/Metrics/MeasureMetric.cs
@@ -1,4 +1,4 @@
-// <copyright file="Measure.cs" company="OpenTelemetry Authors">
+// <copyright file="MeasureMetric.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,7 +24,7 @@ namespace OpenTelemetry.Metrics
     /// Measure instrument.
     /// </summary>
     /// <typeparam name="T">The type of counter. Only long and double are supported now.</typeparam>
-    public abstract class Measure<T>
+    public abstract class MeasureMetric<T>
         where T : struct
     {
         /// <summary>
@@ -64,13 +64,13 @@ public abstract class Measure<T>
         /// </summary>
         /// <param name="labelset">The labelset from which handle should be constructed.</param>
         /// <returns>The handle.</returns>
-        public abstract MeasureHandle<T> GetHandle(LabelSet labelset);
+        public abstract MeasureMetricHandle<T> GetHandle(LabelSet labelset);
 
         /// <summary>
         /// Gets the handle with given labelset.
         /// </summary>
         /// <param name="labels">The labels or dimensions associated with this value.</param>
         /// <returns>The handle.</returns>
-        public abstract MeasureHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels);
+        public abstract MeasureMetricHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels);
     }
 }
diff --git a/src/OpenTelemetry.Api/Metrics/MeasureHandle.cs b/src/OpenTelemetry.Api/Metrics/MeasureMetricHandle.cs
similarity index 92%
rename from src/OpenTelemetry.Api/Metrics/MeasureHandle.cs
rename to src/OpenTelemetry.Api/Metrics/MeasureMetricHandle.cs
index bd68639e4de..0c27accb103 100644
--- a/src/OpenTelemetry.Api/Metrics/MeasureHandle.cs
+++ b/src/OpenTelemetry.Api/Metrics/MeasureMetricHandle.cs
@@ -1,4 +1,4 @@
-// <copyright file="MeasureHandle.cs" company="OpenTelemetry Authors">
+// <copyright file="MeasureMetricHandle.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -23,7 +23,7 @@ namespace OpenTelemetry.Metrics
     /// Handle to the metrics Measure with the defined <see cref="LabelSet"/>.
     /// </summary>
     /// <typeparam name="T">The type of Measure. Only long and double are supported now.</typeparam>
-    public abstract class MeasureHandle<T>
+    public abstract class MeasureMetricHandle<T>
         where T : struct
     {
         /// <summary>
diff --git a/src/OpenTelemetry.Api/Metrics/Meter.cs b/src/OpenTelemetry.Api/Metrics/Meter.cs
index f7ce4bb89ed..fcd19a33aab 100644
--- a/src/OpenTelemetry.Api/Metrics/Meter.cs
+++ b/src/OpenTelemetry.Api/Metrics/Meter.cs
@@ -29,7 +29,7 @@ public abstract class Meter
         /// <param name="name">The name of the counter.</param>
         /// <param name="monotonic">indicates if only positive values are expected.</param>
         /// <returns>The counter instance.</returns>
-        public abstract Counter<long> CreateInt64Counter(string name, bool monotonic = true);
+        public abstract CounterMetric<long> CreateInt64Counter(string name, bool monotonic = true);
 
         /// <summary>
         /// Creates double counter with given name.
@@ -37,23 +37,7 @@ public abstract class Meter
         /// <param name="name">indicates if only positive values are expected.</param>
         /// <param name="monotonic">The name of the counter.</param>
         /// <returns>The counter instance.</returns>
-        public abstract Counter<double> CreateDoubleCounter(string name, bool monotonic = true);
-
-        /// <summary>
-        /// Creates Int64 Gauge with given name.
-        /// </summary>
-        /// <param name="name">The name of the counter.</param>
-        /// <param name="monotonic">indicates if only positive values are expected.</param>
-        /// <returns>The Gauge instance.</returns>
-        public abstract Gauge<long> CreateInt64Gauge(string name, bool monotonic = false);
-
-        /// <summary>
-        /// Creates double Gauge with given name.
-        /// </summary>
-        /// <param name="name">The name of the counter.</param>
-        /// <param name="monotonic">indicates if only positive values are expected.</param>
-        /// <returns>The Gauge instance.</returns>
-        public abstract Gauge<double> CreateDoubleGauge(string name, bool monotonic = false);
+        public abstract CounterMetric<double> CreateDoubleCounter(string name, bool monotonic = true);
 
         /// <summary>
         /// Creates Int64 Measure with given name.
@@ -61,7 +45,7 @@ public abstract class Meter
         /// <param name="name">The name of the measure.</param>
         /// <param name="absolute">indicates if only positive values are expected.</param>
         /// <returns>The measure instance.</returns>
-        public abstract Measure<long> CreateInt64Measure(string name, bool absolute = true);
+        public abstract MeasureMetric<long> CreateInt64Measure(string name, bool absolute = true);
 
         /// <summary>
         /// Creates double Measure with given name.
@@ -69,7 +53,23 @@ public abstract class Meter
         /// <param name="name">The name of the measure.</param>
         /// <param name="absolute">indicates if only positive values are expected.</param>
         /// <returns>The measure instance.</returns>
-        public abstract Measure<double> CreateDoubleMeasure(string name, bool absolute = true);
+        public abstract MeasureMetric<double> CreateDoubleMeasure(string name, bool absolute = true);
+
+        /// <summary>
+        /// Creates Int64 Observer with given name.
+        /// </summary>
+        /// <param name="name">The name of the observer.</param>
+        /// <param name="absolute">indicates if only positive values are expected.</param>
+        /// <returns>The observer instance.</returns>
+        public abstract ObserverMetric<long> CreateInt64Observer(string name, bool absolute = true);
+
+        /// <summary>
+        /// Creates a double Observer with given name.
+        /// </summary>
+        /// <param name="name">The name of the observer.</param>
+        /// <param name="absolute">indicates if only positive values are expected.</param>
+        /// <returns>The observer instance.</returns>
+        public abstract ObserverMetric<double> CreateDoubleObserver(string name, bool absolute = true);
 
         /// <summary>
         /// Constructs or retrieves the <see cref="LabelSet"/> from the given label key-value pairs.
diff --git a/src/OpenTelemetry.Api/Metrics/NoOpCounter.cs b/src/OpenTelemetry.Api/Metrics/NoOpCounterMetric.cs
similarity index 68%
rename from src/OpenTelemetry.Api/Metrics/NoOpCounter.cs
rename to src/OpenTelemetry.Api/Metrics/NoOpCounterMetric.cs
index 91d48e6dfaa..e208983e4a1 100644
--- a/src/OpenTelemetry.Api/Metrics/NoOpCounter.cs
+++ b/src/OpenTelemetry.Api/Metrics/NoOpCounterMetric.cs
@@ -1,4 +1,4 @@
-// <copyright file="NoOpCounter.cs" company="OpenTelemetry Authors">
+// <copyright file="NoOpCounterMetric.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,24 +24,24 @@ namespace OpenTelemetry.Metrics
     /// A no-op counter instrument.
     /// </summary>
     /// <typeparam name="T">The type of counter. Only long and double are supported now.</typeparam>
-    public sealed class NoOpCounter<T> : Counter<T>
+    public sealed class NoOpCounterMetric<T> : CounterMetric<T>
         where T : struct
     {
         /// <summary>
         /// No op counter instance.
         /// </summary>
-        public static readonly NoOpCounter<T> Instance = new NoOpCounter<T>();
+        public static readonly NoOpCounterMetric<T> Instance = new NoOpCounterMetric<T>();
 
         /// <inheritdoc/>
-        public override CounterHandle<T> GetHandle(LabelSet labelset)
+        public override CounterMetricHandle<T> GetHandle(LabelSet labelset)
         {
-            return NoOpCounterHandle<T>.Instance;
+            return NoOpCounterMetricHandle<T>.Instance;
         }
 
         /// <inheritdoc/>
-        public override CounterHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
+        public override CounterMetricHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
         {
-            return NoOpCounterHandle<T>.Instance;
+            return NoOpCounterMetricHandle<T>.Instance;
         }
     }
 }
diff --git a/src/OpenTelemetry.Api/Metrics/NoOpCounterHandle.cs b/src/OpenTelemetry.Api/Metrics/NoOpCounterMetricHandle.cs
similarity index 82%
rename from src/OpenTelemetry.Api/Metrics/NoOpCounterHandle.cs
rename to src/OpenTelemetry.Api/Metrics/NoOpCounterMetricHandle.cs
index 6e569bad7ea..80adacbb695 100644
--- a/src/OpenTelemetry.Api/Metrics/NoOpCounterHandle.cs
+++ b/src/OpenTelemetry.Api/Metrics/NoOpCounterMetricHandle.cs
@@ -1,4 +1,4 @@
-// <copyright file="NoOpCounterHandle.cs" company="OpenTelemetry Authors">
+// <copyright file="NoOpCounterMetricHandle.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -23,13 +23,13 @@ namespace OpenTelemetry.Metrics
     /// No-Op handle.
     /// </summary>
     /// <typeparam name="T">The type of counter. Only long and double are supported now.</typeparam>
-    public sealed class NoOpCounterHandle<T> : CounterHandle<T>
+    public sealed class NoOpCounterMetricHandle<T> : CounterMetricHandle<T>
         where T : struct
     {
         /// <summary>
         /// No op counter handle instance.
         /// </summary>
-        public static readonly NoOpCounterHandle<T> Instance = new NoOpCounterHandle<T>();
+        public static readonly NoOpCounterMetricHandle<T> Instance = new NoOpCounterMetricHandle<T>();
 
         /// <inheritdoc/>
         public override void Add(in SpanContext context, T value)
diff --git a/src/OpenTelemetry.Api/Metrics/NoOpMeasure.cs b/src/OpenTelemetry.Api/Metrics/NoOpMeasureMetric.cs
similarity index 68%
rename from src/OpenTelemetry.Api/Metrics/NoOpMeasure.cs
rename to src/OpenTelemetry.Api/Metrics/NoOpMeasureMetric.cs
index 11080d48642..7a214819d1c 100644
--- a/src/OpenTelemetry.Api/Metrics/NoOpMeasure.cs
+++ b/src/OpenTelemetry.Api/Metrics/NoOpMeasureMetric.cs
@@ -1,4 +1,4 @@
-// <copyright file="NoOpMeasure.cs" company="OpenTelemetry Authors">
+// <copyright file="NoOpMeasureMetric.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -24,24 +24,24 @@ namespace OpenTelemetry.Metrics
     /// No op measure instrument.
     /// </summary>
     /// <typeparam name="T">The type of counter. Only long and double are supported now.</typeparam>
-    public sealed class NoOpMeasure<T> : Measure<T>
+    public sealed class NoOpMeasureMetric<T> : MeasureMetric<T>
         where T : struct
     {
         /// <summary>
         /// No op measure instance.
         /// </summary>
-        public static readonly NoOpMeasure<T> Instance = new NoOpMeasure<T>();
+        public static readonly NoOpMeasureMetric<T> Instance = new NoOpMeasureMetric<T>();
 
         /// <inheritdoc/>
-        public override MeasureHandle<T> GetHandle(LabelSet labelset)
+        public override MeasureMetricHandle<T> GetHandle(LabelSet labelset)
         {
-            return NoOpMeasureHandle<T>.Instance;
+            return NoOpMeasureMetricHandle<T>.Instance;
         }
 
         /// <inheritdoc/>
-        public override MeasureHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
+        public override MeasureMetricHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
         {
-            return NoOpMeasureHandle<T>.Instance;
+            return NoOpMeasureMetricHandle<T>.Instance;
         }
     }
 }
diff --git a/src/OpenTelemetry.Api/Metrics/NoOpMeasureHandle.cs b/src/OpenTelemetry.Api/Metrics/NoOpMeasureMetricHandle.cs
similarity index 82%
rename from src/OpenTelemetry.Api/Metrics/NoOpMeasureHandle.cs
rename to src/OpenTelemetry.Api/Metrics/NoOpMeasureMetricHandle.cs
index b9477a11256..095acd01d1e 100644
--- a/src/OpenTelemetry.Api/Metrics/NoOpMeasureHandle.cs
+++ b/src/OpenTelemetry.Api/Metrics/NoOpMeasureMetricHandle.cs
@@ -1,4 +1,4 @@
-// <copyright file="NoOpMeasureHandle.cs" company="OpenTelemetry Authors">
+// <copyright file="NoOpMeasureMetricHandle.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -23,13 +23,13 @@ namespace OpenTelemetry.Metrics
     /// No op measure handle.
     /// </summary>
     /// <typeparam name="T">The type of Measure. Only long and double are supported now.</typeparam>
-    public sealed class NoOpMeasureHandle<T> : MeasureHandle<T>
+    public sealed class NoOpMeasureMetricHandle<T> : MeasureMetricHandle<T>
         where T : struct
     {
         /// <summary>
         /// No op measure handle instance.
         /// </summary>
-        public static readonly NoOpMeasureHandle<T> Instance = new NoOpMeasureHandle<T>();
+        public static readonly NoOpMeasureMetricHandle<T> Instance = new NoOpMeasureMetricHandle<T>();
 
         /// <inheritdoc/>
         public override void Record(in SpanContext context, T value)
diff --git a/src/OpenTelemetry.Api/Metrics/NoOpMeter.cs b/src/OpenTelemetry.Api/Metrics/NoOpMeter.cs
index 3b094aa7fa4..eb695ae7721 100644
--- a/src/OpenTelemetry.Api/Metrics/NoOpMeter.cs
+++ b/src/OpenTelemetry.Api/Metrics/NoOpMeter.cs
@@ -24,34 +24,34 @@ public NoOpMeter()
         {
         }
 
-        public override Counter<double> CreateDoubleCounter(string name, bool monotonic = true)
+        public override CounterMetric<double> CreateDoubleCounter(string name, bool monotonic = true)
         {
-            return NoOpCounter<double>.Instance;
+            return NoOpCounterMetric<double>.Instance;
         }
 
-        public override Gauge<double> CreateDoubleGauge(string name, bool monotonic = false)
+        public override MeasureMetric<double> CreateDoubleMeasure(string name, bool absolute = true)
         {
-            return NoOpGauge<double>.Instance;
+            return NoOpMeasureMetric<double>.Instance;
         }
 
-        public override Measure<double> CreateDoubleMeasure(string name, bool absolute = true)
+        public override ObserverMetric<double> CreateDoubleObserver(string name, bool monotonic = true)
         {
-            return NoOpMeasure<double>.Instance;
+            return NoOpObserverMetric<double>.Instance;
         }
 
-        public override Counter<long> CreateInt64Counter(string name, bool monotonic = true)
+        public override CounterMetric<long> CreateInt64Counter(string name, bool monotonic = true)
         {
-            return NoOpCounter<long>.Instance;
+            return NoOpCounterMetric<long>.Instance;
         }
 
-        public override Gauge<long> CreateInt64Gauge(string name, bool monotonic = false)
+        public override MeasureMetric<long> CreateInt64Measure(string name, bool absolute = true)
         {
-            return NoOpGauge<long>.Instance;
+            return NoOpMeasureMetric<long>.Instance;
         }
 
-        public override Measure<long> CreateInt64Measure(string name, bool absolute = true)
+        public override ObserverMetric<long> CreateInt64Observer(string name, bool absolute = true)
         {
-            return NoOpMeasure<long>.Instance;
+            return NoOpObserverMetric<long>.Instance;
         }
 
         public override LabelSet GetLabelSet(IEnumerable<KeyValuePair<string, string>> labels)
diff --git a/src/OpenTelemetry.Api/Metrics/NoOpGauge.cs b/src/OpenTelemetry.Api/Metrics/NoOpObserverMetric.cs
similarity index 57%
rename from src/OpenTelemetry.Api/Metrics/NoOpGauge.cs
rename to src/OpenTelemetry.Api/Metrics/NoOpObserverMetric.cs
index 59317f943b1..109495375a8 100644
--- a/src/OpenTelemetry.Api/Metrics/NoOpGauge.cs
+++ b/src/OpenTelemetry.Api/Metrics/NoOpObserverMetric.cs
@@ -1,4 +1,4 @@
-// <copyright file="NoOpGauge.cs" company="OpenTelemetry Authors">
+// <copyright file="NoOpObserverMetric.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,27 +21,27 @@
 namespace OpenTelemetry.Metrics
 {
     /// <summary>
-    /// A no-op gauge instrument.
+    /// A no-op observer instrument.
     /// </summary>
-    /// <typeparam name="T">The type of gauge. Only long and double are supported now.</typeparam>
-    public sealed class NoOpGauge<T> : Gauge<T>
+    /// <typeparam name="T">The type of observer. Only long and double are supported now.</typeparam>
+    public sealed class NoOpObserverMetric<T> : ObserverMetric<T>
         where T : struct
     {
         /// <summary>
-        /// No op gauge instance.
+        /// No op observer instance.
         /// </summary>
-        public static readonly NoOpGauge<T> Instance = new NoOpGauge<T>();
+        public static readonly NoOpObserverMetric<T> Instance = new NoOpObserverMetric<T>();
 
         /// <inheritdoc/>
-        public override GaugeHandle<T> GetHandle(LabelSet labelset)
+        public override ObserverMetricHandle<T> GetHandle(LabelSet labelset)
         {
-            return NoOpGaugeHandle<T>.Instance;
+            return NoOpObserverMetricHandle<T>.Instance;
         }
 
         /// <inheritdoc/>
-        public override GaugeHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
+        public override ObserverMetricHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
         {
-            return NoOpGaugeHandle<T>.Instance;
+            return NoOpObserverMetricHandle<T>.Instance;
         }
     }
 }
diff --git a/src/OpenTelemetry.Api/Metrics/NoOpGaugeHandle.cs b/src/OpenTelemetry.Api/Metrics/NoOpObserverMetricHandle.cs
similarity index 61%
rename from src/OpenTelemetry.Api/Metrics/NoOpGaugeHandle.cs
rename to src/OpenTelemetry.Api/Metrics/NoOpObserverMetricHandle.cs
index fb9a6745fc9..c6a93ae84b6 100644
--- a/src/OpenTelemetry.Api/Metrics/NoOpGaugeHandle.cs
+++ b/src/OpenTelemetry.Api/Metrics/NoOpObserverMetricHandle.cs
@@ -1,4 +1,4 @@
-// <copyright file="NoOpGaugeHandle.cs" company="OpenTelemetry Authors">
+// <copyright file="NoOpObserverMetricHandle.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,24 +20,24 @@
 namespace OpenTelemetry.Metrics
 {
     /// <summary>
-    /// No-Op handle.
+    /// No-Op observer handle.
     /// </summary>
-    /// <typeparam name="T">The type of gauge. Only long and double are supported now.</typeparam>
-    public sealed class NoOpGaugeHandle<T> : GaugeHandle<T>
+    /// <typeparam name="T">The type of observer. Only long and double are supported now.</typeparam>
+    public sealed class NoOpObserverMetricHandle<T> : ObserverMetricHandle<T>
         where T : struct
     {
         /// <summary>
-        /// No op gauge handle instance.
+        /// No op observer handle instance.
         /// </summary>
-        public static readonly NoOpGaugeHandle<T> Instance = new NoOpGaugeHandle<T>();
+        public static readonly NoOpObserverMetricHandle<T> Instance = new NoOpObserverMetricHandle<T>();
 
         /// <inheritdoc/>
-        public override void Set(in SpanContext context, T value)
+        public override void Observe(in SpanContext context, T value)
         {
         }
 
         /// <inheritdoc/>
-        public override void Set(in DistributedContext context, T value)
+        public override void Observe(in DistributedContext context, T value)
         {
         }
     }
diff --git a/src/OpenTelemetry.Api/Metrics/Gauge.cs b/src/OpenTelemetry.Api/Metrics/ObserverMetric.cs
similarity index 58%
rename from src/OpenTelemetry.Api/Metrics/Gauge.cs
rename to src/OpenTelemetry.Api/Metrics/ObserverMetric.cs
index 8e192ba71a0..99e25fa2645 100644
--- a/src/OpenTelemetry.Api/Metrics/Gauge.cs
+++ b/src/OpenTelemetry.Api/Metrics/ObserverMetric.cs
@@ -1,4 +1,4 @@
-// <copyright file="Gauge.cs" company="OpenTelemetry Authors">
+// <copyright file="ObserverMetric.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,56 +21,56 @@
 namespace OpenTelemetry.Metrics
 {
     /// <summary>
-    /// Gauge instrument.
+    /// Observer instrument.
     /// </summary>
-    /// <typeparam name="T">The type of gauge. Only long and double are supported now.</typeparam>
-    public abstract class Gauge<T>
+    /// <typeparam name="T">The type of observer. Only long and double are supported now.</typeparam>
+    public abstract class ObserverMetric<T>
         where T : struct
     {
         /// <summary>
-        /// Sets the value of the Gauge.
+        /// Observes a value.
         /// </summary>
         /// <param name="context">the associated span context.</param>
-        /// <param name="value">value to which the Gauge should be set.</param>
+        /// <param name="value">value to record.</param>
         /// <param name="labelset">The labelset associated with this value.</param>
-        public void Set(in SpanContext context, T value, LabelSet labelset) => this.GetHandle(labelset).Set(context, value);
+        public void Observe(in SpanContext context, T value, LabelSet labelset) => this.GetHandle(labelset).Observe(context, value);
 
         /// <summary>
-        /// Sets the Gauge.
+        /// Observes a value.
         /// </summary>
         /// <param name="context">the associated span context.</param>
-        /// <param name="value">value to which the Gauge should be set.</param>
+        /// <param name="value">value to record.</param>
         /// <param name="labels">The labels or dimensions associated with this value.</param>
-        public void Set(in SpanContext context, T value, IEnumerable<KeyValuePair<string, string>> labels) => this.GetHandle(labels).Set(context, value);
+        public void Observe(in SpanContext context, T value, IEnumerable<KeyValuePair<string, string>> labels) => this.GetHandle(labels).Observe(context, value);
 
         /// <summary>
-        /// Sets the value of the Gauge.
+        /// Observes a value.
         /// </summary>
         /// <param name="context">the associated distributed context.</param>
-        /// <param name="value">value to which the Gauge should be set.</param>
+        /// <param name="value">value to record.</param>
         /// <param name="labelset">The labelset associated with this value.</param>
-        public void Set(in DistributedContext context, T value, LabelSet labelset) => this.GetHandle(labelset).Set(context, value);
+        public void Observe(in DistributedContext context, T value, LabelSet labelset) => this.GetHandle(labelset).Observe(context, value);
 
         /// <summary>
-        /// Sets the Gauge.
+        /// Observes a value.
         /// </summary>
         /// <param name="context">the associated distributed context.</param>
-        /// <param name="value">value to which the Gauge should be set.</param>
+        /// <param name="value">value to record.</param>
         /// <param name="labels">The labels or dimensions associated with this value.</param>
-        public void Set(in DistributedContext context, T value, IEnumerable<KeyValuePair<string, string>> labels) => this.GetHandle(labels).Set(context, value);
+        public void Observe(in DistributedContext context, T value, IEnumerable<KeyValuePair<string, string>> labels) => this.GetHandle(labels).Observe(context, value);
 
         /// <summary>
         /// Gets the handle with given labelset.
         /// </summary>
         /// <param name="labelset">The labelset from which handle should be constructed.</param>
         /// <returns>The handle.</returns>
-        public abstract GaugeHandle<T> GetHandle(LabelSet labelset);
+        public abstract ObserverMetricHandle<T> GetHandle(LabelSet labelset);
 
         /// <summary>
-        /// Gets the handle with given labels.
+        /// Gets the handle with given labelset.
         /// </summary>
         /// <param name="labels">The labels or dimensions associated with this value.</param>
         /// <returns>The handle.</returns>
-        public abstract GaugeHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels);
+        public abstract ObserverMetricHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels);
     }
 }
diff --git a/src/OpenTelemetry.Api/Metrics/GaugeHandle.cs b/src/OpenTelemetry.Api/Metrics/ObserverMetricHandle.cs
similarity index 57%
rename from src/OpenTelemetry.Api/Metrics/GaugeHandle.cs
rename to src/OpenTelemetry.Api/Metrics/ObserverMetricHandle.cs
index 261d51ff507..b767013ab34 100644
--- a/src/OpenTelemetry.Api/Metrics/GaugeHandle.cs
+++ b/src/OpenTelemetry.Api/Metrics/ObserverMetricHandle.cs
@@ -1,4 +1,4 @@
-// <copyright file="GaugeHandle.cs" company="OpenTelemetry Authors">
+// <copyright file="ObserverMetricHandle.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,24 +20,24 @@
 namespace OpenTelemetry.Metrics
 {
     /// <summary>
-    /// Handle to the metrics gauge with the defined <see cref="LabelSet"/>.
+    /// Handle to the metrics observer with the defined <see cref="LabelSet"/>.
     /// </summary>
-    /// <typeparam name="T">The type of gauge. Only long and double are supported now.</typeparam>
-    public abstract class GaugeHandle<T>
+    /// <typeparam name="T">The type of observer. Only long and double are supported now.</typeparam>
+    public abstract class ObserverMetricHandle<T>
         where T : struct
     {
         /// <summary>
-        /// Sets the value of the guague.
+        /// Sets the value of the observer handle.
         /// </summary>
         /// <param name="context">the associated span context.</param>
-        /// <param name="value">value by which the gauge handle should be set.</param>
-        public abstract void Set(in SpanContext context, T value);
+        /// <param name="value">value by which the observer handle should be Recorded.</param>
+        public abstract void Observe(in SpanContext context, T value);
 
         /// <summary>
-        /// Sets the value of the guague handle.
+        /// Sets the value of the observer handle.
         /// </summary>
         /// <param name="context">the associated distributed context.</param>
-        /// <param name="value">value by which the gauge handle should be set.</param>
-        public abstract void Set(in DistributedContext context, T value);
+        /// <param name="value">value by which the observer handle should be Recorded.</param>
+        public abstract void Observe(in DistributedContext context, T value);
     }
 }
diff --git a/src/OpenTelemetry/Metrics/Aggregators/GaugeAggregator.cs b/src/OpenTelemetry/Metrics/Aggregators/LastValueAggregator.cs
similarity index 68%
rename from src/OpenTelemetry/Metrics/Aggregators/GaugeAggregator.cs
rename to src/OpenTelemetry/Metrics/Aggregators/LastValueAggregator.cs
index a2cdee96412..2d4c4d441dd 100644
--- a/src/OpenTelemetry/Metrics/Aggregators/GaugeAggregator.cs
+++ b/src/OpenTelemetry/Metrics/Aggregators/LastValueAggregator.cs
@@ -1,4 +1,4 @@
-// <copyright file="GaugeAggregator.cs" company="OpenTelemetry Authors">
+// <copyright file="LastValueAggregator.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,24 +14,21 @@
 // limitations under the License.
 // </copyright>
 
-using System;
-
 namespace OpenTelemetry.Metrics.Aggregators
 {
     /// <summary>
-    /// Basic aggregator which keeps the last recorded value and timestamp.
+    /// Simple aggregator that only keeps the last value.
     /// </summary>
-    /// <typeparam name="T">Type of gauge.</typeparam>
-    public class GaugeAggregator<T> : Aggregator<T>
+    /// <typeparam name="T">Type of measure instrument.</typeparam>
+    public class LastValueAggregator<T> : Aggregator<T>
         where T : struct
     {
         private T value;
-        private DateTime timestamp;
-        private Tuple<T, DateTime> checkpoint;
+        private T checkpoint;
 
         public override void Checkpoint()
         {
-            this.checkpoint = new Tuple<T, DateTime>(this.value, this.timestamp);
+            this.checkpoint = this.value;
         }
 
         public override void Update(T value)
@@ -44,11 +41,9 @@ public override void Update(T value)
             {
                 this.value = (T)(object)((long)(object)value);
             }
-
-            this.timestamp = DateTime.UtcNow;
         }
 
-        public Tuple<T, DateTime> ValueFromLastCheckpoint()
+        internal T ValueFromLastCheckpoint()
         {
             return this.checkpoint;
         }
diff --git a/src/OpenTelemetry/Metrics/CounterHandleSdk.cs b/src/OpenTelemetry/Metrics/CounterMetricHandleSdk.cs
similarity index 88%
rename from src/OpenTelemetry/Metrics/CounterHandleSdk.cs
rename to src/OpenTelemetry/Metrics/CounterMetricHandleSdk.cs
index 3445abde1a8..7480de9f989 100644
--- a/src/OpenTelemetry/Metrics/CounterHandleSdk.cs
+++ b/src/OpenTelemetry/Metrics/CounterMetricHandleSdk.cs
@@ -1,4 +1,4 @@
-// <copyright file="CounterHandleSdk.cs" company="OpenTelemetry Authors">
+// <copyright file="CounterMetricHandleSdk.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,12 +21,12 @@
 
 namespace OpenTelemetry.Metrics
 {
-    internal class CounterHandleSdk<T> : CounterHandle<T>
+    internal class CounterMetricHandleSdk<T> : CounterMetricHandle<T>
         where T : struct
     {
         private readonly CounterSumAggregator<T> sumAggregator = new CounterSumAggregator<T>();
 
-        internal CounterHandleSdk()
+        internal CounterMetricHandleSdk()
         {
             if (typeof(T) != typeof(long) && typeof(T) != typeof(double))
             {
diff --git a/src/OpenTelemetry/Metrics/CounterSdk.cs b/src/OpenTelemetry/Metrics/CounterMetricSdk.cs
similarity index 66%
rename from src/OpenTelemetry/Metrics/CounterSdk.cs
rename to src/OpenTelemetry/Metrics/CounterMetricSdk.cs
index ad4b152474b..937ec0c2bc2 100644
--- a/src/OpenTelemetry/Metrics/CounterSdk.cs
+++ b/src/OpenTelemetry/Metrics/CounterMetricSdk.cs
@@ -1,4 +1,4 @@
-// <copyright file="CounterSdk.cs" company="OpenTelemetry Authors">
+// <copyright file="CounterMetricSdk.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,13 +20,13 @@
 
 namespace OpenTelemetry.Metrics
 {
-    internal class CounterSdk<T> : Counter<T>
+    internal class CounterMetricSdk<T> : CounterMetric<T>
         where T : struct
-    {        
-        private readonly IDictionary<LabelSet, CounterHandleSdk<T>> counterHandles = new ConcurrentDictionary<LabelSet, CounterHandleSdk<T>>();
+    {
+        private readonly IDictionary<LabelSet, CounterMetricHandleSdk<T>> counterHandles = new ConcurrentDictionary<LabelSet, CounterMetricHandleSdk<T>>();
         private string metricName;
 
-        public CounterSdk()
+        public CounterMetricSdk()
         {
             if (typeof(T) != typeof(long) && typeof(T) != typeof(double))
             {
@@ -34,16 +34,16 @@ public CounterSdk()
             }
         }
 
-        public CounterSdk(string name) : this()
+        public CounterMetricSdk(string name) : this()
         {
             this.metricName = name;
         }
 
-        public override CounterHandle<T> GetHandle(LabelSet labelset)
+        public override CounterMetricHandle<T> GetHandle(LabelSet labelset)
         {
             if (!this.counterHandles.TryGetValue(labelset, out var handle))
             {
-                handle = new CounterHandleSdk<T>();
+                handle = new CounterMetricHandleSdk<T>();
 
                 this.counterHandles.Add(labelset, handle);
             }
@@ -51,12 +51,12 @@ public override CounterHandle<T> GetHandle(LabelSet labelset)
             return handle;
         }
 
-        public override CounterHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
+        public override CounterMetricHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
         {
             return this.GetHandle(new LabelSetSdk(labels));
         }
 
-        internal IDictionary<LabelSet, CounterHandleSdk<T>> GetAllHandles()
+        internal IDictionary<LabelSet, CounterMetricHandleSdk<T>> GetAllHandles()
         {
             return this.counterHandles;
         }
diff --git a/src/OpenTelemetry/Metrics/Export/MetricProcessor.cs b/src/OpenTelemetry/Metrics/Export/MetricProcessor.cs
index 9c197b20ba8..d3f1cf95838 100644
--- a/src/OpenTelemetry/Metrics/Export/MetricProcessor.cs
+++ b/src/OpenTelemetry/Metrics/Export/MetricProcessor.cs
@@ -39,39 +39,39 @@ public abstract class MetricProcessor
         public abstract void ProcessCounter(string meterName, string metricName, LabelSet labelSet, CounterSumAggregator<double> sumAggregator);
 
         /// <summary>
-        /// Process the gauge metric.
+        /// Process the measure metric.
         /// </summary>
         /// <param name="meterName">the name of the meter, used as a namespace for the metric instruments.</param>
         /// <param name="metricName">the name of the counter.</param>
         /// <param name="labelSet">the labelSet associated with counter value.</param>
-        /// <param name="gaugeAggregator">the aggregator from which current value can be obtained.</param>
-        public abstract void ProcessGauge(string meterName, string metricName, LabelSet labelSet, GaugeAggregator<long> gaugeAggregator);
+        /// <param name="measureAggregator">the aggregator from which raw values can be obtained.</param>
+        public abstract void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<long> measureAggregator);
 
         /// <summary>
-        /// Process the gauge metric.
+        /// Process the measure metric.
         /// </summary>
         /// <param name="meterName">the name of the meter, used as a namespace for the metric instruments.</param>
         /// <param name="metricName">the name of the counter.</param>
         /// <param name="labelSet">the labelSet associated with counter value.</param>
-        /// <param name="gaugeAggregator">the aggregator from which current value can be obtained.</param>
-        public abstract void ProcessGauge(string meterName, string metricName, LabelSet labelSet, GaugeAggregator<double> gaugeAggregator);
+        /// <param name="measureAggregator">the aggregator from which raw values can be obtained.</param>
+        public abstract void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<double> measureAggregator);
 
         /// <summary>
-        /// Process the gauge metric.
+        /// Process the observer metric.
         /// </summary>
         /// <param name="meterName">the name of the meter, used as a namespace for the metric instruments.</param>
-        /// <param name="metricName">the name of the counter.</param>
-        /// <param name="labelSet">the labelSet associated with counter value.</param>
-        /// <param name="measureAggregator">the aggregator from which raw values can be obtained.</param>
-        public abstract void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<long> measureAggregator);
+        /// <param name="metricName">the name of the observer.</param>
+        /// <param name="labelSet">the labelSet associated with observer value.</param>
+        /// <param name="lastValueAggregator">the aggregator from which raw values can be obtained.</param>
+        public abstract void ProcessObserver(string meterName, string metricName, LabelSet labelSet, LastValueAggregator<long> lastValueAggregator);
 
         /// <summary>
-        /// Process the gauge metric.
+        /// Process the observer metric.
         /// </summary>
         /// <param name="meterName">the name of the meter, used as a namespace for the metric instruments.</param>
-        /// <param name="metricName">the name of the counter.</param>
-        /// <param name="labelSet">the labelSet associated with counter value.</param>
-        /// <param name="measureAggregator">the aggregator from which raw values can be obtained.</param>
-        public abstract void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<double> measureAggregator);
+        /// <param name="metricName">the name of the observer.</param>
+        /// <param name="labelSet">the labelSet associated with observer value.</param>
+        /// <param name="lastValueAggregator">the aggregator from which raw values can be obtained.</param>
+        public abstract void ProcessObserver(string meterName, string metricName, LabelSet labelSet, LastValueAggregator<double> lastValueAggregator);
     }
 }
diff --git a/src/OpenTelemetry/Metrics/Export/NoOpMetricProcessor.cs b/src/OpenTelemetry/Metrics/Export/NoOpMetricProcessor.cs
index f8aaccae81b..16c7c786eec 100644
--- a/src/OpenTelemetry/Metrics/Export/NoOpMetricProcessor.cs
+++ b/src/OpenTelemetry/Metrics/Export/NoOpMetricProcessor.cs
@@ -28,19 +28,19 @@ public override void ProcessCounter(string meterName, string metricName, LabelSe
         {
         }
 
-        public override void ProcessGauge(string meterName, string metricName, LabelSet labelSet, GaugeAggregator<long> gaugeAggregator)
+        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<long> measureAggregator)
         {
         }
 
-        public override void ProcessGauge(string meterName, string metricName, LabelSet labelSet, GaugeAggregator<double> gaugeAggregator)
+        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<double> measureAggregator)
         {
         }
 
-        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<long> measureAggregator)
+        public override void ProcessObserver(string meterName, string metricName, LabelSet labelSet, LastValueAggregator<long> lastValueAggregator)
         {
         }
 
-        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<double> measureAggregator)
+        public override void ProcessObserver(string meterName, string metricName, LabelSet labelSet, LastValueAggregator<double> lastValueAggregator)
         {
         }
     }
diff --git a/src/OpenTelemetry/Metrics/Export/UngroupedBatcher.cs b/src/OpenTelemetry/Metrics/Export/UngroupedBatcher.cs
index e4e033f2f07..d3842371324 100644
--- a/src/OpenTelemetry/Metrics/Export/UngroupedBatcher.cs
+++ b/src/OpenTelemetry/Metrics/Export/UngroupedBatcher.cs
@@ -29,7 +29,7 @@ namespace OpenTelemetry.Metrics.Export
     /// </summary>
     public class UngroupedBatcher : MetricProcessor
     {
-        private readonly MetricExporter exporter;        
+        private readonly MetricExporter exporter;
         private readonly Task worker;
         private readonly TimeSpan aggregationInterval;
         private CancellationTokenSource cts;
@@ -70,29 +70,29 @@ public override void ProcessCounter(string meterName, string metricName, LabelSe
             throw new NotImplementedException();
         }
 
-        public override void ProcessGauge(string meterName, string metricName, LabelSet labelSet, GaugeAggregator<long> gaugeAggregator)
+        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<long> measureAggregator)
         {
             throw new NotImplementedException();
         }
 
-        public override void ProcessGauge(string meterName, string metricName, LabelSet labelSet, GaugeAggregator<double> gaugeAggregator)
+        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<double> measureAggregator)
         {
             throw new NotImplementedException();
         }
 
-        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<long> measureAggregator)
+        public override void ProcessObserver(string meterName, string metricName, LabelSet labelSet, LastValueAggregator<long> lastValueAggregator)
         {
             throw new NotImplementedException();
         }
 
-        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<double> measureAggregator)
+        public override void ProcessObserver(string meterName, string metricName, LabelSet labelSet, LastValueAggregator<double> lastValueAggregator)
         {
             throw new NotImplementedException();
         }
 
         private async Task Worker(CancellationToken cancellationToken)
         {
-            try 
+            try
             {
                 await Task.Delay(this.aggregationInterval, cancellationToken).ConfigureAwait(false);
                 while (!cancellationToken.IsCancellationRequested)
diff --git a/src/OpenTelemetry/Metrics/MeasureHandleSdk.cs b/src/OpenTelemetry/Metrics/MeasureMetricHandleSdk.cs
similarity index 88%
rename from src/OpenTelemetry/Metrics/MeasureHandleSdk.cs
rename to src/OpenTelemetry/Metrics/MeasureMetricHandleSdk.cs
index ff225fb881c..5ccef7983b0 100644
--- a/src/OpenTelemetry/Metrics/MeasureHandleSdk.cs
+++ b/src/OpenTelemetry/Metrics/MeasureMetricHandleSdk.cs
@@ -1,4 +1,4 @@
-// <copyright file="MeasureHandleSdk.cs" company="OpenTelemetry Authors">
+// <copyright file="MeasureMetricHandleSdk.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,12 +21,12 @@
 
 namespace OpenTelemetry.Metrics
 {
-    internal class MeasureHandleSdk<T> : MeasureHandle<T>
+    internal class MeasureMetricHandleSdk<T> : MeasureMetricHandle<T>
         where T : struct
     {
         private readonly MeasureExactAggregator<T> measureExactAggregator = new MeasureExactAggregator<T>();
 
-        internal MeasureHandleSdk()
+        internal MeasureMetricHandleSdk()
         {
             if (typeof(T) != typeof(long) && typeof(T) != typeof(double))
             {
diff --git a/src/OpenTelemetry/Metrics/MeasureSdk.cs b/src/OpenTelemetry/Metrics/MeasureMetricSdk.cs
similarity index 66%
rename from src/OpenTelemetry/Metrics/MeasureSdk.cs
rename to src/OpenTelemetry/Metrics/MeasureMetricSdk.cs
index ea296a313ec..a0c0e8573a1 100644
--- a/src/OpenTelemetry/Metrics/MeasureSdk.cs
+++ b/src/OpenTelemetry/Metrics/MeasureMetricSdk.cs
@@ -1,4 +1,4 @@
-// <copyright file="MeasureSdk.cs" company="OpenTelemetry Authors">
+// <copyright file="MeasureMetricSdk.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,13 +20,13 @@
 
 namespace OpenTelemetry.Metrics
 {
-    internal class MeasureSdk<T> : Measure<T>
+    internal class MeasureMetricSdk<T> : MeasureMetric<T>
         where T : struct
-    {        
-        private readonly IDictionary<LabelSet, MeasureHandleSdk<T>> measureHandles = new ConcurrentDictionary<LabelSet, MeasureHandleSdk<T>>();
+    {
+        private readonly IDictionary<LabelSet, MeasureMetricHandleSdk<T>> measureHandles = new ConcurrentDictionary<LabelSet, MeasureMetricHandleSdk<T>>();
         private string metricName;
 
-        public MeasureSdk()
+        public MeasureMetricSdk()
         {
             if (typeof(T) != typeof(long) && typeof(T) != typeof(double))
             {
@@ -34,16 +34,16 @@ public MeasureSdk()
             }
         }
 
-        public MeasureSdk(string name) : this()
+        public MeasureMetricSdk(string name) : this()
         {
             this.metricName = name;
         }
 
-        public override MeasureHandle<T> GetHandle(LabelSet labelset)
+        public override MeasureMetricHandle<T> GetHandle(LabelSet labelset)
         {
             if (!this.measureHandles.TryGetValue(labelset, out var handle))
             {
-                handle = new MeasureHandleSdk<T>();
+                handle = new MeasureMetricHandleSdk<T>();
 
                 this.measureHandles.Add(labelset, handle);
             }
@@ -51,12 +51,12 @@ public override MeasureHandle<T> GetHandle(LabelSet labelset)
             return handle;
         }
 
-        public override MeasureHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
+        public override MeasureMetricHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
         {
             return this.GetHandle(new LabelSetSdk(labels));
         }
 
-        internal IDictionary<LabelSet, MeasureHandleSdk<T>> GetAllHandles()
+        internal IDictionary<LabelSet, MeasureMetricHandleSdk<T>> GetAllHandles()
         {
             return this.measureHandles;
         }
diff --git a/src/OpenTelemetry/Metrics/MeterSdk.cs b/src/OpenTelemetry/Metrics/MeterSdk.cs
index 50ad38e27c8..1f6ba7d14ff 100644
--- a/src/OpenTelemetry/Metrics/MeterSdk.cs
+++ b/src/OpenTelemetry/Metrics/MeterSdk.cs
@@ -25,18 +25,18 @@ public class MeterSdk : Meter
     {
         private readonly string meterName;
         private readonly MetricProcessor metricProcessor;
-        private readonly IDictionary<string, CounterSdk<long>> longCounters = new ConcurrentDictionary<string, CounterSdk<long>>();
-        private readonly IDictionary<string, CounterSdk<double>> doubleCounters = new ConcurrentDictionary<string, CounterSdk<double>>();
-        private readonly IDictionary<string, GaugeSDK<long>> longGauges = new ConcurrentDictionary<string, GaugeSDK<long>>();
-        private readonly IDictionary<string, GaugeSDK<double>> doubleGauges = new ConcurrentDictionary<string, GaugeSDK<double>>();
-        private readonly IDictionary<string, MeasureSdk<long>> longMeasures = new ConcurrentDictionary<string, MeasureSdk<long>>();
-        private readonly IDictionary<string, MeasureSdk<double>> doubleMeasures = new ConcurrentDictionary<string, MeasureSdk<double>>();
+        private readonly IDictionary<string, CounterMetricSdk<long>> longCounters = new ConcurrentDictionary<string, CounterMetricSdk<long>>();
+        private readonly IDictionary<string, CounterMetricSdk<double>> doubleCounters = new ConcurrentDictionary<string, CounterMetricSdk<double>>();
+        private readonly IDictionary<string, MeasureMetricSdk<long>> longMeasures = new ConcurrentDictionary<string, MeasureMetricSdk<long>>();
+        private readonly IDictionary<string, MeasureMetricSdk<double>> doubleMeasures = new ConcurrentDictionary<string, MeasureMetricSdk<double>>();
+        private readonly IDictionary<string, ObserverMetricSdk<long>> longObservers = new ConcurrentDictionary<string, ObserverMetricSdk<long>>();
+        private readonly IDictionary<string, ObserverMetricSdk<double>> doubleObservers = new ConcurrentDictionary<string, ObserverMetricSdk<double>>();
         private readonly object collectLock = new object();
 
         internal MeterSdk(string meterName, MetricProcessor metricProcessor)
         {
             this.meterName = meterName;
-            this.metricProcessor = metricProcessor;            
+            this.metricProcessor = metricProcessor;
         }
 
         public override LabelSet GetLabelSet(IEnumerable<KeyValuePair<string, string>> labels)
@@ -76,65 +76,65 @@ public void Collect()
                     }
                 }
 
-                foreach (var longGauge in this.longGauges)
+                foreach (var longMeasure in this.longMeasures)
                 {
-                    var metricName = longGauge.Key;
-                    var gaugeInstrument = longGauge.Value;
-                    foreach (var handle in gaugeInstrument.GetAllHandles())
+                    var metricName = longMeasure.Key;
+                    var measureInstrument = longMeasure.Value;
+                    foreach (var handle in measureInstrument.GetAllHandles())
                     {
                         var labelSet = handle.Key;
                         var aggregator = handle.Value.GetAggregator();
                         aggregator.Checkpoint();
-                        this.metricProcessor.ProcessGauge(this.meterName, metricName, labelSet, aggregator);
+                        this.metricProcessor.ProcessMeasure(this.meterName, metricName, labelSet, aggregator);
                     }
                 }
 
-                foreach (var doubleGauge in this.doubleGauges)
+                foreach (var doubleMeasure in this.doubleMeasures)
                 {
-                    var metricName = doubleGauge.Key;
-                    var gaugeInstrument = doubleGauge.Value;
-                    foreach (var handle in gaugeInstrument.GetAllHandles())
+                    var metricName = doubleMeasure.Key;
+                    var measureInstrument = doubleMeasure.Value;
+                    foreach (var handle in measureInstrument.GetAllHandles())
                     {
                         var labelSet = handle.Key;
                         var aggregator = handle.Value.GetAggregator();
                         aggregator.Checkpoint();
-                        this.metricProcessor.ProcessGauge(this.meterName, metricName, labelSet, aggregator);
+                        this.metricProcessor.ProcessMeasure(this.meterName, metricName, labelSet, aggregator);
                     }
                 }
 
-                foreach (var longMeasure in this.longMeasures)
+                foreach (var doubleObserver in this.doubleObservers)
                 {
-                    var metricName = longMeasure.Key;
-                    var measureInstrument = longMeasure.Value;
+                    var metricName = doubleObserver.Key;
+                    var measureInstrument = doubleObserver.Value;
                     foreach (var handle in measureInstrument.GetAllHandles())
                     {
                         var labelSet = handle.Key;
                         var aggregator = handle.Value.GetAggregator();
                         aggregator.Checkpoint();
-                        this.metricProcessor.ProcessMeasure(this.meterName, metricName, labelSet, aggregator);
+                        this.metricProcessor.ProcessObserver(this.meterName, metricName, labelSet, aggregator);
                     }
                 }
 
-                foreach (var doubleMeasure in this.doubleMeasures)
+                foreach (var longObserver in this.longObservers)
                 {
-                    var metricName = doubleMeasure.Key;
-                    var measureInstrument = doubleMeasure.Value;
+                    var metricName = longObserver.Key;
+                    var measureInstrument = longObserver.Value;
                     foreach (var handle in measureInstrument.GetAllHandles())
                     {
                         var labelSet = handle.Key;
                         var aggregator = handle.Value.GetAggregator();
                         aggregator.Checkpoint();
-                        this.metricProcessor.ProcessMeasure(this.meterName, metricName, labelSet, aggregator);
+                        this.metricProcessor.ProcessObserver(this.meterName, metricName, labelSet, aggregator);
                     }
                 }
             }
         }
 
-        public override Counter<long> CreateInt64Counter(string name, bool monotonic = true)
+        public override CounterMetric<long> CreateInt64Counter(string name, bool monotonic = true)
         {
             if (!this.longCounters.TryGetValue(name, out var counter))
             {
-                counter = new CounterSdk<long>(name);
+                counter = new CounterMetricSdk<long>(name);
 
                 this.longCounters.Add(name, counter);
             }
@@ -142,63 +142,65 @@ public override Counter<long> CreateInt64Counter(string name, bool monotonic = t
             return counter;
         }
 
-        public override Counter<double> CreateDoubleCounter(string name, bool monotonic = true)
+        public override CounterMetric<double> CreateDoubleCounter(string name, bool monotonic = true)
         {
             if (!this.doubleCounters.TryGetValue(name, out var counter))
             {
-                counter = new CounterSdk<double>(name);
+                counter = new CounterMetricSdk<double>(name);
                 this.doubleCounters.Add(name, counter);
             }
 
             return counter;
         }
 
-        public override Gauge<long> CreateInt64Gauge(string name, bool monotonic = true)
+        public override MeasureMetric<double> CreateDoubleMeasure(string name, bool absolute = true)
         {
-            if (!this.longGauges.TryGetValue(name, out var gauge))
+            if (!this.doubleMeasures.TryGetValue(name, out var measure))
             {
-                gauge = new GaugeSDK<long>(name);
+                measure = new MeasureMetricSdk<double>(name);
 
-                this.longGauges.Add(name, gauge);
+                this.doubleMeasures.Add(name, measure);
             }
 
-            return gauge;
+            return measure;
         }
 
-        public override Gauge<double> CreateDoubleGauge(string name, bool monotonic = true)
+        public override MeasureMetric<long> CreateInt64Measure(string name, bool absolute = true)
         {
-            if (!this.doubleGauges.TryGetValue(name, out var gauge))
+            if (!this.longMeasures.TryGetValue(name, out var measure))
             {
-                gauge = new GaugeSDK<double>(name);
+                measure = new MeasureMetricSdk<long>(name);
 
-                this.doubleGauges.Add(name, gauge);
+                this.longMeasures.Add(name, measure);
             }
 
-            return gauge;
+            return measure;
         }
 
-        public override Measure<double> CreateDoubleMeasure(string name, bool absolute = true)
+        /// <inheritdoc/>
+        public override ObserverMetric<long> CreateInt64Observer(string name, bool absolute = true)
         {
-            if (!this.doubleMeasures.TryGetValue(name, out var measure))
+            if (!this.longObservers.TryGetValue(name, out var observer))
             {
-                measure = new MeasureSdk<double>(name);
+                observer = new ObserverMetricSdk<long>(name);
 
-                this.doubleMeasures.Add(name, measure);
+                this.longObservers.Add(name, observer);
             }
 
-            return measure;
+            return observer;
         }
 
-        public override Measure<long> CreateInt64Measure(string name, bool absolute = true)
+        /// <inheritdoc/>
+        public override ObserverMetric<double> CreateDoubleObserver(string name, bool absolute = true)
         {
-            if (!this.longMeasures.TryGetValue(name, out var measure))
+            if (!this.doubleObservers.TryGetValue(name, out var observer))
             {
-                measure = new MeasureSdk<long>(name);
+                observer = new ObserverMetricSdk<double>(name);
 
-                this.longMeasures.Add(name, measure);
+                this.doubleObservers.Add(name, observer);
             }
 
-            return measure;
+            return observer;
         }
     }
 }
diff --git a/src/OpenTelemetry/Metrics/GaugeHandleSdk.cs b/src/OpenTelemetry/Metrics/ObserverMetricHandleSdk.cs
similarity index 62%
rename from src/OpenTelemetry/Metrics/GaugeHandleSdk.cs
rename to src/OpenTelemetry/Metrics/ObserverMetricHandleSdk.cs
index 7daacfb87db..58ab1d3ab64 100644
--- a/src/OpenTelemetry/Metrics/GaugeHandleSdk.cs
+++ b/src/OpenTelemetry/Metrics/ObserverMetricHandleSdk.cs
@@ -1,4 +1,4 @@
-// <copyright file="GaugeHandleSdk.cs" company="OpenTelemetry Authors">
+// <copyright file="ObserverMetricHandleSdk.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,12 +21,12 @@
 
 namespace OpenTelemetry.Metrics
 {
-    internal class GaugeHandleSdk<T> : GaugeHandle<T>
+    internal class ObserverMetricHandleSdk<T> : ObserverMetricHandle<T>
         where T : struct
     {
-        private readonly GaugeAggregator<T> gaugeAggregator = new GaugeAggregator<T>();
+        private readonly LastValueAggregator<T> aggregator = new LastValueAggregator<T>();
 
-        internal GaugeHandleSdk()
+        internal ObserverMetricHandleSdk()
         {
             if (typeof(T) != typeof(long) && typeof(T) != typeof(double))
             {
@@ -34,19 +34,19 @@ internal GaugeHandleSdk()
             }
         }
 
-        public override void Set(in SpanContext context, T value)
+        public override void Observe(in SpanContext context, T value)
         {
-            this.gaugeAggregator.Update(value);
+            this.aggregator.Update(value);
         }
 
-        public override void Set(in DistributedContext context, T value)
+        public override void Observe(in DistributedContext context, T value)
         {
-            this.gaugeAggregator.Update(value);
+            this.aggregator.Update(value);
         }
 
-        internal GaugeAggregator<T> GetAggregator()
+        internal LastValueAggregator<T> GetAggregator()
         {
-            return this.gaugeAggregator;
+            return this.aggregator;
         }
     }
 }
diff --git a/src/OpenTelemetry/Metrics/GaugeSdk.cs b/src/OpenTelemetry/Metrics/ObserverMetricSdk.cs
similarity index 57%
rename from src/OpenTelemetry/Metrics/GaugeSdk.cs
rename to src/OpenTelemetry/Metrics/ObserverMetricSdk.cs
index b358a4d3126..6d32bff0f96 100644
--- a/src/OpenTelemetry/Metrics/GaugeSdk.cs
+++ b/src/OpenTelemetry/Metrics/ObserverMetricSdk.cs
@@ -1,4 +1,4 @@
-// <copyright file="GaugeSdk.cs" company="OpenTelemetry Authors">
+// <copyright file="ObserverMetricSdk.cs" company="OpenTelemetry Authors">
 // Copyright 2018, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,13 +20,13 @@
 
 namespace OpenTelemetry.Metrics
 {
-    internal class GaugeSDK<T> : Gauge<T>
+    internal class ObserverMetricSdk<T> : ObserverMetric<T>
         where T : struct
-    {        
-        private readonly IDictionary<LabelSet, GaugeHandleSdk<T>> gaugeHandles = new ConcurrentDictionary<LabelSet, GaugeHandleSdk<T>>();
+    {
+        private readonly IDictionary<LabelSet, ObserverMetricHandleSdk<T>> observerHandles = new ConcurrentDictionary<LabelSet, ObserverMetricHandleSdk<T>>();
         private string metricName;
 
-        public GaugeSDK()
+        public ObserverMetricSdk()
         {
             if (typeof(T) != typeof(long) && typeof(T) != typeof(double))
             {
@@ -34,31 +34,31 @@ public GaugeSDK()
             }
         }
 
-        public GaugeSDK(string name) : this()
+        public ObserverMetricSdk(string name) : this()
         {
             this.metricName = name;
         }
 
-        public override GaugeHandle<T> GetHandle(LabelSet labelset)
+        public override ObserverMetricHandle<T> GetHandle(LabelSet labelset)
         {
-            if (!this.gaugeHandles.TryGetValue(labelset, out var handle))
+            if (!this.observerHandles.TryGetValue(labelset, out var handle))
             {
-                handle = new GaugeHandleSdk<T>();
+                handle = new ObserverMetricHandleSdk<T>();
 
-                this.gaugeHandles.Add(labelset, handle);
+                this.observerHandles.Add(labelset, handle);
             }
 
             return handle;
         }
 
-        public override GaugeHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
+        public override ObserverMetricHandle<T> GetHandle(IEnumerable<KeyValuePair<string, string>> labels)
         {
             return this.GetHandle(new LabelSetSdk(labels));
         }
 
-        internal IDictionary<LabelSet, GaugeHandleSdk<T>> GetAllHandles()
+        internal IDictionary<LabelSet, ObserverMetricHandleSdk<T>> GetAllHandles()
         {
-            return this.gaugeHandles;
+            return this.observerHandles;
         }
     }
 }
diff --git a/test/OpenTelemetry.Tests/Impl/Metrics/MetricsTest.cs b/test/OpenTelemetry.Tests/Impl/Metrics/MetricsTest.cs
index 20c668b7560..71c0512b51f 100644
--- a/test/OpenTelemetry.Tests/Impl/Metrics/MetricsTest.cs
+++ b/test/OpenTelemetry.Tests/Impl/Metrics/MetricsTest.cs
@@ -13,9 +13,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // </copyright>
+
+using System.Linq;
 using System.Collections.Generic;
 using OpenTelemetry.Metrics.Configuration;
-using OpenTelemetry.Metrics.Export;
 using OpenTelemetry.Trace;
 using Xunit;
 
@@ -23,13 +24,13 @@ namespace OpenTelemetry.Metrics.Test
 {
     public class MetricsTest
     {
-        [Fact(Skip = "TODO: Make robust tests. These are just basic tests to see metric in action.")]
+        [Fact]
         public void CounterSendsAggregateToRegisteredProcessor()
         {
             var testProcessor = new TestMetricProcessor();
             var meter = MeterFactory.Create(testProcessor).GetMeter("library1") as MeterSdk;
             var testCounter = meter.CreateInt64Counter("testCounter");
-            
+
             var labels1 = new List<KeyValuePair<string, string>>();
             labels1.Add(new KeyValuePair<string, string>("dim1", "value1"));
 
@@ -45,22 +46,21 @@ public void CounterSendsAggregateToRegisteredProcessor()
             meter.Collect();
 
             Assert.Equal(2, testProcessor.counters.Count);
-            Assert.Equal("testCounter", testProcessor.counters[1].Item1);
-            Assert.Equal("testCounter", testProcessor.counters[0].Item1);
+            Assert.Equal(2, testProcessor.counters.Count(kvp => kvp.Item1 == "testCounter"));
 
-            Assert.Equal(meter.GetLabelSet(labels1), testProcessor.counters[1].Item2);
-            Assert.Equal(meter.GetLabelSet(labels2), testProcessor.counters[0].Item2);
+            Assert.Single(testProcessor.counters.Where(kvp => kvp.Item2.Equals(meter.GetLabelSet(labels1))));
+            Assert.Single(testProcessor.counters.Where(kvp => kvp.Item2.Equals(meter.GetLabelSet(labels2))));
 
-            Assert.Equal(110, testProcessor.counters[1].Item3);
-            Assert.Equal(210, testProcessor.counters[0].Item3);
+            Assert.Single(testProcessor.counters.Where(kvp => kvp.Item3 == 110));
+            Assert.Single(testProcessor.counters.Where(kvp => kvp.Item3 == 210));
         }
 
-        [Fact(Skip = "TODO: Make robust tests. These are just basic tests to see metric in action.")]
-        public void GaugeSendsAggregateToRegisteredProcessor()
+        [Fact]
+        public void MeasureSendsAggregateToRegisteredProcessor()
         {
             var testProcessor = new TestMetricProcessor();
             var meter = MeterFactory.Create(testProcessor).GetMeter("library1") as MeterSdk;
-            var testGauge = meter.CreateInt64Gauge("testGauge");
+            var testMeasure = meter.CreateInt64Measure("testMeasure");
 
             var labels1 = new List<KeyValuePair<string, string>>();
             labels1.Add(new KeyValuePair<string, string>("dim1", "value1"));
@@ -69,31 +69,29 @@ public void GaugeSendsAggregateToRegisteredProcessor()
             labels2.Add(new KeyValuePair<string, string>("dim1", "value2"));
 
             var context = default(SpanContext);
-            testGauge.Set(context, 100, meter.GetLabelSet(labels1));
-            testGauge.Set(context, 10, meter.GetLabelSet(labels1));
-            testGauge.Set(context, 200, meter.GetLabelSet(labels2));
-            testGauge.Set(context, 20, meter.GetLabelSet(labels2));
+            testMeasure.Record(context, 100, meter.GetLabelSet(labels1));
+            testMeasure.Record(context, 10, meter.GetLabelSet(labels1));
+            testMeasure.Record(context, 200, meter.GetLabelSet(labels2));
+            testMeasure.Record(context, 20, meter.GetLabelSet(labels2));
 
             meter.Collect();
 
-            Assert.Equal(2, testProcessor.gauges.Count);
-            Assert.Equal("testGauge", testProcessor.gauges[1].Item1);
-            Assert.Equal("testGauge", testProcessor.gauges[0].Item1);
+            Assert.Equal(2, testProcessor.measures.Count);
+            Assert.Equal(2, testProcessor.measures.Count(kvp => kvp.Item1 == "testMeasure"));
 
-            Assert.Equal(meter.GetLabelSet(labels1), testProcessor.gauges[1].Item2);
-            Assert.Equal(meter.GetLabelSet(labels2), testProcessor.gauges[0].Item2);
+            Assert.Single(testProcessor.measures.Where(kvp => kvp.Item2.Equals(meter.GetLabelSet(labels1))));
+            Assert.Single(testProcessor.measures.Where(kvp => kvp.Item2.Equals(meter.GetLabelSet(labels2))));
 
-            Assert.Equal(10, testProcessor.gauges[1].Item3.Item1);
-            Assert.Equal(20, testProcessor.gauges[0].Item3.Item1);
+            Assert.Single(testProcessor.measures.Where(kvp => kvp.Item3.Contains(100) && kvp.Item3.Contains(10)));
+            Assert.Single(testProcessor.measures.Where(kvp => kvp.Item3.Contains(200) && kvp.Item3.Contains(20)));
         }
 
-
-        [Fact(Skip = "TODO: Make robust tests. These are just basic tests to see metric in action.")]
-        public void MeasureSendsAggregateToRegisteredProcessor()
+        [Fact]
+        public void ObserverSendsAggregateToRegisteredProcessor()
         {
             var testProcessor = new TestMetricProcessor();
             var meter = MeterFactory.Create(testProcessor).GetMeter("library1") as MeterSdk;
-            var testMeasure = meter.CreateInt64Measure("testMeasure");
+            var testObserver = meter.CreateInt64Observer("testObserver");
 
             var labels1 = new List<KeyValuePair<string, string>>();
             labels1.Add(new KeyValuePair<string, string>("dim1", "value1"));
@@ -102,26 +100,21 @@ public void MeasureSendsAggregateToRegisteredProcessor()
             labels2.Add(new KeyValuePair<string, string>("dim1", "value2"));
 
             var context = default(SpanContext);
-            testMeasure.Record(context, 100, meter.GetLabelSet(labels1));
-            testMeasure.Record(context, 10, meter.GetLabelSet(labels1));
-            testMeasure.Record(context, 200, meter.GetLabelSet(labels2));
-            testMeasure.Record(context, 20, meter.GetLabelSet(labels2));
+            testObserver.Observe(context, 100, meter.GetLabelSet(labels1));
+            testObserver.Observe(context, 10, meter.GetLabelSet(labels1));
+            testObserver.Observe(context, 200, meter.GetLabelSet(labels2));
+            testObserver.Observe(context, 20, meter.GetLabelSet(labels2));
 
             meter.Collect();
 
-            Assert.Equal(2, testProcessor.measures.Count);
-            Assert.Equal("testMeasure", testProcessor.measures[1].Item1);
-            Assert.Equal("testMeasure", testProcessor.measures[0].Item1);
-
-            Assert.Equal(meter.GetLabelSet(labels1), testProcessor.measures[1].Item2);
-            Assert.Equal(meter.GetLabelSet(labels2), testProcessor.measures[0].Item2);
-
-            Assert.Contains(100, testProcessor.measures[1].Item3);
-            Assert.Contains(10, testProcessor.measures[1].Item3);
+            Assert.Equal(2, testProcessor.observations.Count);
+            Assert.Equal(2, testProcessor.observations.Count(kvp => kvp.Item1 == "testObserver"));
 
+            Assert.Single(testProcessor.observations.Where(kvp => kvp.Item2.Equals(meter.GetLabelSet(labels1))));
+            Assert.Single(testProcessor.observations.Where(kvp => kvp.Item2.Equals(meter.GetLabelSet(labels2))));
 
-            Assert.Contains(200, testProcessor.measures[0].Item3);
-            Assert.Contains(20, testProcessor.measures[0].Item3);
+            Assert.Single(testProcessor.observations.Where(kvp => kvp.Item3 == 10));
+            Assert.Single(testProcessor.observations.Where(kvp => kvp.Item3 == 20));
         }
     }
 }
diff --git a/test/OpenTelemetry.Tests/Impl/Metrics/TestMetricProcessor.cs b/test/OpenTelemetry.Tests/Impl/Metrics/TestMetricProcessor.cs
index 497c9c3997b..5e86d27f996 100644
--- a/test/OpenTelemetry.Tests/Impl/Metrics/TestMetricProcessor.cs
+++ b/test/OpenTelemetry.Tests/Impl/Metrics/TestMetricProcessor.cs
@@ -24,8 +24,8 @@ namespace OpenTelemetry.Metrics.Test
     internal class TestMetricProcessor : MetricProcessor
     {
         public List<Tuple<string, LabelSet, long>> counters = new List<Tuple<string, LabelSet, long>>();
-        public List<Tuple<string, LabelSet, Tuple<long, DateTime>>> gauges = new List<Tuple<string, LabelSet, Tuple<long, DateTime>>>();
         public List<Tuple<string, LabelSet, List<long>>> measures = new List<Tuple<string, LabelSet, List<long>>>();
+        public List<Tuple<string, LabelSet, long>> observations = new List<Tuple<string, LabelSet, long>>();
 
         public override void ProcessCounter(string meterName, string metricName, LabelSet labelSet, CounterSumAggregator<long> sumAggregator)
         {
@@ -36,21 +36,21 @@ public override void ProcessCounter(string meterName, string metricName, LabelSe
         {
         }
 
-        public override void ProcessGauge(string meterName, string metricName, LabelSet labelSet, GaugeAggregator<long> gaugeAggregator)
+        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<long> measureAggregator)
         {
-            gauges.Add(new Tuple<string, LabelSet, Tuple<long, DateTime>>(metricName, labelSet, gaugeAggregator.ValueFromLastCheckpoint()));
+            measures.Add(new Tuple<string, LabelSet, List<long>>(metricName, labelSet, measureAggregator.ValueFromLastCheckpoint()));
         }
 
-        public override void ProcessGauge(string meterName, string metricName, LabelSet labelSet, GaugeAggregator<double> gaugeAggregator)
+        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<double> measureAggregator)
         {
         }
 
-        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<long> measureAggregator)
+        public override void ProcessObserver(string meterName, string metricName, LabelSet labelSet, LastValueAggregator<long> lastValueAggregator)
         {
-            measures.Add(new Tuple<string, LabelSet, List<long>>(metricName, labelSet, measureAggregator.ValueFromLastCheckpoint()));
+            observations.Add(new Tuple<string, LabelSet, long>(metricName, labelSet, lastValueAggregator.ValueFromLastCheckpoint()));
         }
 
-        public override void ProcessMeasure(string meterName, string metricName, LabelSet labelSet, MeasureExactAggregator<double> measureAggregator)
+        public override void ProcessObserver(string meterName, string metricName, LabelSet labelSet, LastValueAggregator<double> lastValueAggregator)
         {
         }
     }
diff --git a/test/OpenTelemetry.Tests/Impl/Trace/Config/MeterFactoryBaseTests.cs b/test/OpenTelemetry.Tests/Impl/Trace/Config/MeterFactoryBaseTests.cs
index a6d0a8bd2d8..61567749413 100644
--- a/test/OpenTelemetry.Tests/Impl/Trace/Config/MeterFactoryBaseTests.cs
+++ b/test/OpenTelemetry.Tests/Impl/Trace/Config/MeterFactoryBaseTests.cs
@@ -36,12 +36,12 @@ public void MeterFactoryBase_Default()
             Assert.Same(defaultMeter, namedMeter);
 
             var counter = defaultMeter.CreateDoubleCounter("somename");
-            Assert.IsType<NoOpCounter<double>>(counter);
+            Assert.IsType<NoOpCounterMetric<double>>(counter);
 
             var labels1 = new List<KeyValuePair<string, string>>();
             labels1.Add(new KeyValuePair<string, string>("dim1", "value1"));
             var counterHandle = counter.GetHandle(labels1);
-            Assert.IsType<NoOpCounterHandle<double>>(counterHandle);
+            Assert.IsType<NoOpCounterMetricHandle<double>>(counterHandle);
         }
     }
 }