[API] Add synchronous gauge

api/include/opentelemetry/metrics/meter.h

@@ -21,6 +21,9 @@ class Histogram;
 template <typename T>
 class UpDownCounter;
 
+template <typename T>
+class Gauge;
+
 class ObservableInstrument;
 
 /**
@@ -91,6 +94,25 @@ class Meter
       nostd::string_view description = "",
       nostd::string_view unit        = "") noexcept = 0;
 
+  /**
+   * Creates a Gauge with the passed characteristics and returns a unique_ptr to that Counter.
+   *
+   * @param name the name of the new Gauge.
+   * @param description a brief description of what the Gauge is used for.
+   * @param unit the unit of metric values following https://unitsofmeasure.org/ucum.html.
+   * @return a unique pointer to the created Gauge.
+   */
+
+  virtual nostd::unique_ptr<Gauge<int64_t>> CreateInt64Gauge(
+      nostd::string_view name,
+      nostd::string_view description = "",
+      nostd::string_view unit        = "") noexcept = 0;
+
+  virtual nostd::unique_ptr<Gauge<double>> CreateDoubleGauge(
+      nostd::string_view name,
+      nostd::string_view description = "",
+      nostd::string_view unit        = "") noexcept = 0;
+
   /**
    * Creates a Asynchronous (Observable) Gauge with the passed characteristics and returns a
    * shared_ptr to that Observable Gauge

api/include/opentelemetry/metrics/noop.h

@@ -71,6 +71,24 @@ class NoopUpDownCounter : public UpDownCounter<T>
   {}
 };
 
+template <class T>
+class NoopGauge : public Gauge<T>
+{
+public:
+  NoopGauge(nostd::string_view /* name */,
+                    nostd::string_view /* description */,
+                    nostd::string_view /* unit */) noexcept
+  {}
+  ~NoopGauge() override = default;
+  void Record(T /* value */) noexcept override {}
+  void Record(T /* value */, const context::Context & /* context */) noexcept override {}
+  void Record(T /* value */, const common::KeyValueIterable & /* attributes */) noexcept override {}
+  void Record(T /* value */,
+           const common::KeyValueIterable & /* attributes */,
+           const context::Context & /* context */) noexcept override
+  {}
+};
+
 class NoopObservableInstrument : public ObservableInstrument
 {
 public:
@@ -140,6 +158,22 @@ class NoopMeter final : public Meter
     return nostd::unique_ptr<Histogram<double>>{new NoopHistogram<double>(name, description, unit)};
   }
 
+  nostd::unique_ptr<Gauge<int64_t>> CreateInt64Gauge(
+      nostd::string_view name,
+      nostd::string_view description = "",
+      nostd::string_view unit        = "") noexcept override
+  {
+    return nostd::unique_ptr<Gauge<int64_t>>{new NoopGauge<int64_t>(name, description, unit)};
+  }
+
+  nostd::unique_ptr<Gauge<double>> CreateDoubleGauge(
+      nostd::string_view name,
+      nostd::string_view description = "",
+      nostd::string_view unit        = "") noexcept override
+  {
+    return nostd::unique_ptr<Gauge<double>>{new NoopGauge<double>(name, description, unit)};
+  }
+
   nostd::shared_ptr<ObservableInstrument> CreateInt64ObservableGauge(
       nostd::string_view name,
       nostd::string_view description = "",

api/include/opentelemetry/metrics/sync_instruments.h

@@ -247,5 +247,80 @@ class UpDownCounter : public SynchronousInstrument
   }
 };
 
+/* A Gauge instrument that records values. */
+template <class T>
+class Gauge : public SynchronousInstrument
+{
+
+public:
+  /**
+   * Record a value
+   *
+   * @param value The measurement value. May be positive, negative or zero.
+   */
+  virtual void Record(T value) noexcept = 0;
+
+  /**
+   * Record a value
+   *
+   * @param value The measurement value. May be positive, negative or zero.
+   * @param context The explicit context to associate with this measurement.
+   */
+  virtual void Record(T value, const context::Context &context) noexcept = 0;
+
+  /**
+   * Record a value with a set of attributes.
+   *
+   * @param value The measurement value. May be positive, negative or zero.
+   * @param attributes A set of attributes to associate with the value.
+   */
+
+  virtual void Record(T value, const common::KeyValueIterable &attributes) noexcept = 0;
+
+  /**
+   * Record a value with a set of attributes.
+   *
+   * @param value The measurement value. May be positive, negative or zero.
+   * @param attributes A set of attributes to associate with the value.
+   * @param context The explicit context to associate with this measurement.
+   */
+  virtual void Record(T value,
+                   const common::KeyValueIterable &attributes,
+                   const context::Context &context) noexcept = 0;
+
+  template <class U,
+            nostd::enable_if_t<common::detail::is_key_value_iterable<U>::value> * = nullptr>
+  void Record(T value, const U &attributes) noexcept
+  {
+    this->Record(value, common::KeyValueIterableView<U>{attributes});
+  }
+
+  template <class U,
+            nostd::enable_if_t<common::detail::is_key_value_iterable<U>::value> * = nullptr>
+  void Record(T value, const U &attributes, const context::Context &context) noexcept
+  {
+    this->Record(value, common::KeyValueIterableView<U>{attributes}, context);
+  }
+
+  void Record(T value,
+           std::initializer_list<std::pair<nostd::string_view, common::AttributeValue>>
+               attributes) noexcept
+  {
+    this->Record(value, nostd::span<const std::pair<nostd::string_view, common::AttributeValue>>{
+                         attributes.begin(), attributes.end()});
+  }
+
+  void Record(T value,
+           std::initializer_list<std::pair<nostd::string_view, common::AttributeValue>> attributes,
+           const context::Context &context) noexcept
+  {
+    this->Record(value,
+              nostd::span<const std::pair<nostd::string_view, common::AttributeValue>>{
+                  attributes.begin(), attributes.end()},
+              context);
+  }
+};
+
+
 }  // namespace metrics
 OPENTELEMETRY_END_NAMESPACE

examples/common/metrics_foo_library/foo_library.cc

@@ -106,4 +106,23 @@ void foo_library::histogram_example(const std::string &name)
     histogram_counter->Record(val, labelkv, context);
     std::this_thread::sleep_for(std::chrono::milliseconds(250));
   }
+
+
+}
+
+void foo_library::gauge_example(const std::string &name)
+{
+  std::string gauge_name = name + "_gauge";
+  auto provider          = metrics_api::Provider::GetMeterProvider();
+  opentelemetry::nostd::shared_ptr<metrics_api::Meter> meter = provider->GetMeter(name, "1.2.0");
+  auto gauge   = meter->CreateInt64Gauge(gauge_name, "des", "unit");
+  auto context = opentelemetry::context::Context{};
+  for (uint32_t i = 0; i < 20; ++i)
+  {
+    int64_t val                                = (rand() % 100) + 100;
+    std::map<std::string, std::string> labels = get_random_attr();
+    auto labelkv = opentelemetry::common::KeyValueIterableView<decltype(labels)>{labels};
+    gauge->Record(val, labelkv, context);
+    std::this_thread::sleep_for(std::chrono::milliseconds(250));
+  }
 }

examples/common/metrics_foo_library/foo_library.h

@@ -11,4 +11,5 @@ class foo_library
   static void counter_example(const std::string &name);
   static void histogram_example(const std::string &name);
   static void observable_counter_example(const std::string &name);
+  static void gauge_example(const std::string &name);
 };

examples/metrics_simple/metrics_ostream.cc

@@ -148,15 +148,21 @@ int main(int argc, char **argv)
   {
     foo_library::histogram_example(name);
   }
+  else if (example_type == "gauge")
+  {
+    foo_library::gauge_example(name);
+  }
   else
   {
     std::thread counter_example{&foo_library::counter_example, name};
     std::thread observable_counter_example{&foo_library::observable_counter_example, name};
     std::thread histogram_example{&foo_library::histogram_example, name};
+    std::thread gauge_example{&foo_library::gauge_example, name};
 
     counter_example.join();
     observable_counter_example.join();
     histogram_example.join();
+    gauge_example.join();
   }
 
   CleanupMetrics();

examples/otlp/file_metric_main.cc

@@ -98,15 +98,21 @@ int main(int argc, char *argv[])
   {
     foo_library::histogram_example(name);
   }
+  else if (example_type == "gauge")
+  {
+    foo_library::gauge_example(name);
+  }
   else
   {
     std::thread counter_example{&foo_library::counter_example, name};
     std::thread observable_counter_example{&foo_library::observable_counter_example, name};
     std::thread histogram_example{&foo_library::histogram_example, name};
+    std::thread gauge_example{&foo_library::gauge_example, name};
 
     counter_example.join();
     observable_counter_example.join();
     histogram_example.join();
+    gauge_example.join();
   }
 
   CleanupMetrics();

examples/otlp/grpc_metric_main.cc

@@ -93,15 +93,21 @@ int main(int argc, char *argv[])
   {
     foo_library::histogram_example(name);
   }
+  else if (example_type == "gauge")
+  {
+    foo_library::gauge_example(name);
+  }
   else
   {
     std::thread counter_example{&foo_library::counter_example, name};
     std::thread observable_counter_example{&foo_library::observable_counter_example, name};
     std::thread histogram_example{&foo_library::histogram_example, name};
+    std::thread gauge_example{&foo_library::gauge_example, name};
 
     counter_example.join();
     observable_counter_example.join();
     histogram_example.join();
+    gauge_example.join();
   }
 
   CleanupMetrics();

examples/otlp/http_metric_main.cc

@@ -133,15 +133,21 @@ int main(int argc, char *argv[])
   {
     foo_library::histogram_example(name);
   }
+  else if (example_type == "gauge")
+  {
+    foo_library::gauge_example(name);
+  }
   else
   {
     std::thread counter_example{&foo_library::counter_example, name};
     std::thread observable_counter_example{&foo_library::observable_counter_example, name};
     std::thread histogram_example{&foo_library::histogram_example, name};
+    std::thread gauge_example{&foo_library::gauge_example, name};
 
     counter_example.join();
     observable_counter_example.join();
     histogram_example.join();
+    gauge_example.join();
   }
 
   CleanupMetrics();

exporters/otlp/src/otlp_metric_utils.cc

@@ -297,6 +297,7 @@ sdk::metrics::AggregationTemporality OtlpMetricUtils::DeltaTemporalitySelector(
     case sdk::metrics::InstrumentType::kObservableCounter:
     case sdk::metrics::InstrumentType::kHistogram:
     case sdk::metrics::InstrumentType::kObservableGauge:
+    case sdk::metrics::InstrumentType::kGauge:
       return sdk::metrics::AggregationTemporality::kDelta;
     case sdk::metrics::InstrumentType::kUpDownCounter:
     case sdk::metrics::InstrumentType::kObservableUpDownCounter:
@@ -320,6 +321,7 @@ sdk::metrics::AggregationTemporality OtlpMetricUtils::LowMemoryTemporalitySelect
     case sdk::metrics::InstrumentType::kHistogram:
       return sdk::metrics::AggregationTemporality::kDelta;
     case sdk::metrics::InstrumentType::kObservableCounter:
+    case sdk::metrics::InstrumentType::kGauge:
     case sdk::metrics::InstrumentType::kObservableGauge:
     case sdk::metrics::InstrumentType::kUpDownCounter:
     case sdk::metrics::InstrumentType::kObservableUpDownCounter:

sdk/include/opentelemetry/sdk/metrics/aggregation/default_aggregation.h

@@ -180,6 +180,7 @@ class DefaultAggregation
         return AggregationType::kSum;
       case InstrumentType::kHistogram:
         return AggregationType::kHistogram;
+      case InstrumentType::kGauge:
       case InstrumentType::kObservableGauge:
         return AggregationType::kLastValue;
       default:

sdk/include/opentelemetry/sdk/metrics/instruments.h

@@ -19,6 +19,7 @@ enum class InstrumentType
   kCounter,
   kHistogram,
   kUpDownCounter,
+  kGauge,
   kObservableCounter,
   kObservableGauge,
   kObservableUpDownCounter

sdk/include/opentelemetry/sdk/metrics/meter.h

@@ -75,6 +75,16 @@ class Meter final : public opentelemetry::metrics::Meter
       nostd::string_view description = "",
       nostd::string_view unit        = "") noexcept override;
 
+  nostd::unique_ptr<opentelemetry::metrics::Gauge<int64_t>> CreateInt64Gauge(
+      nostd::string_view name,
+      nostd::string_view description = "",
+      nostd::string_view unit        = "") noexcept override;
+
+  nostd::unique_ptr<opentelemetry::metrics::Gauge<double>> CreateDoubleGauge(
+      nostd::string_view name,
+      nostd::string_view description = "",
+      nostd::string_view unit        = "") noexcept override;
+
   nostd::shared_ptr<opentelemetry::metrics::ObservableInstrument> CreateInt64ObservableGauge(
       nostd::string_view name,
       nostd::string_view description = "",

sdk/include/opentelemetry/sdk/metrics/sync_instruments.h

@@ -101,6 +101,38 @@ class DoubleUpDownCounter : public Synchronous, public opentelemetry::metrics::U
   void Add(double value, const opentelemetry::context::Context &context) noexcept override;
 };
 
+class LongGauge : public Synchronous, public opentelemetry::metrics::Gauge<int64_t>
+{
+public:
+  LongGauge(const InstrumentDescriptor &instrument_descriptor,
+                    std::unique_ptr<SyncWritableMetricStorage> storage);
+
+  void Record(int64_t value,
+           const opentelemetry::common::KeyValueIterable &attributes) noexcept override;
+  void Record(int64_t value,
+           const opentelemetry::common::KeyValueIterable &attributes,
+           const opentelemetry::context::Context &context) noexcept override;
+
+  void Record(int64_t value) noexcept override;
+  void Record(int64_t value, const opentelemetry::context::Context &context) noexcept override;
+};
+
+class DoubleGauge : public Synchronous, public opentelemetry::metrics::Gauge<double>
+{
+public:
+  DoubleGauge(const InstrumentDescriptor &instrument_descriptor,
+                      std::unique_ptr<SyncWritableMetricStorage> storage);
+
+  void Record(double value,
+           const opentelemetry::common::KeyValueIterable &attributes) noexcept override;
+  void Record(double value,
+           const opentelemetry::common::KeyValueIterable &attributes,
+           const opentelemetry::context::Context &context) noexcept override;
+
+  void Record(double value) noexcept override;
+  void Record(double value, const opentelemetry::context::Context &context) noexcept override;
+};
+
 class LongHistogram : public Synchronous, public opentelemetry::metrics::Histogram<uint64_t>
 {
 public: