9.2/includes/opentelemetry/semconv/hw_metrics.h

Go to the documentation of this file.

/*
 * Copyright The OpenTelemetry Authors
 * SPDX-License-Identifier: Apache-2.0
 */
 
/*
 * DO NOT EDIT, this is an Auto-generated file from:
 * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
 */
 
#pragma once
 
#include "opentelemetry/common/macros.h"
#include "opentelemetry/metrics/meter.h"
#include "opentelemetry/version.h"
 
OPENTELEMETRY_BEGIN_NAMESPACE
namespace semconv
{
namespace hw
{
 
static constexpr const char *kMetricHwEnergy     = "hw.energy";
static constexpr const char *descrMetricHwEnergy = "Energy consumed by the component";
static constexpr const char *unitMetricHwEnergy  = "J";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricHwEnergy(
    metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricHwEnergy, descrMetricHwEnergy, unitMetricHwEnergy);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricHwEnergy(
    metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricHwEnergy, descrMetricHwEnergy, unitMetricHwEnergy);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwEnergy(
    metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricHwEnergy, descrMetricHwEnergy,
                                             unitMetricHwEnergy);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwEnergy(
    metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricHwEnergy, descrMetricHwEnergy,
                                              unitMetricHwEnergy);
}
 
static constexpr const char *kMetricHwErrors     = "hw.errors";
static constexpr const char *descrMetricHwErrors = "Number of errors encountered by the component";
static constexpr const char *unitMetricHwErrors  = "{error}";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricHwErrors(
    metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricHwErrors, descrMetricHwErrors, unitMetricHwErrors);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricHwErrors(
    metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricHwErrors, descrMetricHwErrors, unitMetricHwErrors);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwErrors(
    metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricHwErrors, descrMetricHwErrors,
                                             unitMetricHwErrors);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwErrors(
    metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricHwErrors, descrMetricHwErrors,
                                              unitMetricHwErrors);
}
 
static constexpr const char *kMetricHwHostAmbientTemperature = "hw.host.ambient_temperature";
static constexpr const char *descrMetricHwHostAmbientTemperature =
    "Ambient (external) temperature of the physical host";
static constexpr const char *unitMetricHwHostAmbientTemperature = "Cel";
 
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
CreateSyncInt64MetricHwHostAmbientTemperature(metrics::Meter *meter)
{
  return meter->CreateInt64Gauge(kMetricHwHostAmbientTemperature,
                                 descrMetricHwHostAmbientTemperature,
                                 unitMetricHwHostAmbientTemperature);
}
 
static inline nostd::unique_ptr<metrics::Gauge<double>>
CreateSyncDoubleMetricHwHostAmbientTemperature(metrics::Meter *meter)
{
  return meter->CreateDoubleGauge(kMetricHwHostAmbientTemperature,
                                  descrMetricHwHostAmbientTemperature,
                                  unitMetricHwHostAmbientTemperature);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricHwHostAmbientTemperature(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableGauge(kMetricHwHostAmbientTemperature,
                                           descrMetricHwHostAmbientTemperature,
                                           unitMetricHwHostAmbientTemperature);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricHwHostAmbientTemperature(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableGauge(kMetricHwHostAmbientTemperature,
                                            descrMetricHwHostAmbientTemperature,
                                            unitMetricHwHostAmbientTemperature);
}
 
static constexpr const char *kMetricHwHostEnergy = "hw.host.energy";
static constexpr const char *descrMetricHwHostEnergy =
    "Total energy consumed by the entire physical host, in joules";
static constexpr const char *unitMetricHwHostEnergy = "J";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricHwHostEnergy(
    metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
                                    unitMetricHwHostEnergy);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricHwHostEnergy(
    metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
                                    unitMetricHwHostEnergy);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwHostEnergy(
    metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
                                             unitMetricHwHostEnergy);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwHostEnergy(
    metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
                                              unitMetricHwHostEnergy);
}
 
static constexpr const char *kMetricHwHostHeatingMargin = "hw.host.heating_margin";
static constexpr const char *descrMetricHwHostHeatingMargin =
    "By how many degrees Celsius the temperature of the physical host can be increased, before reaching a warning threshold on one of the internal sensors
    ";
    static constexpr const char *unitMetricHwHostHeatingMargin = "Cel";
 
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricHwHostHeatingMargin(
    metrics::Meter *meter)
{
  return meter->CreateInt64Gauge(kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin,
                                 unitMetricHwHostHeatingMargin);
}
 
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricHwHostHeatingMargin(
    metrics::Meter *meter)
{
  return meter->CreateDoubleGauge(kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin,
                                  unitMetricHwHostHeatingMargin);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricHwHostHeatingMargin(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableGauge(
      kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin, unitMetricHwHostHeatingMargin);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricHwHostHeatingMargin(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableGauge(
      kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin, unitMetricHwHostHeatingMargin);
}
 
static constexpr const char *kMetricHwHostPower = "hw.host.power";
static constexpr const char *descrMetricHwHostPower =
    "Instantaneous power consumed by the entire physical host in Watts (`hw.host.energy` is preferred)
    ";
    static constexpr const char *unitMetricHwHostPower = "W";
 
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricHwHostPower(
    metrics::Meter *meter)
{
  return meter->CreateInt64Gauge(kMetricHwHostPower, descrMetricHwHostPower, unitMetricHwHostPower);
}
 
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricHwHostPower(
    metrics::Meter *meter)
{
  return meter->CreateDoubleGauge(kMetricHwHostPower, descrMetricHwHostPower,
                                  unitMetricHwHostPower);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwHostPower(
    metrics::Meter *meter)
{
  return meter->CreateInt64ObservableGauge(kMetricHwHostPower, descrMetricHwHostPower,
                                           unitMetricHwHostPower);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwHostPower(
    metrics::Meter *meter)
{
  return meter->CreateDoubleObservableGauge(kMetricHwHostPower, descrMetricHwHostPower,
                                            unitMetricHwHostPower);
}
 
static constexpr const char *kMetricHwPower     = "hw.power";
static constexpr const char *descrMetricHwPower = "Instantaneous power consumed by the component";
static constexpr const char *unitMetricHwPower  = "W";
 
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricHwPower(
    metrics::Meter *meter)
{
  return meter->CreateInt64Gauge(kMetricHwPower, descrMetricHwPower, unitMetricHwPower);
}
 
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricHwPower(
    metrics::Meter *meter)
{
  return meter->CreateDoubleGauge(kMetricHwPower, descrMetricHwPower, unitMetricHwPower);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwPower(
    metrics::Meter *meter)
{
  return meter->CreateInt64ObservableGauge(kMetricHwPower, descrMetricHwPower, unitMetricHwPower);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwPower(
    metrics::Meter *meter)
{
  return meter->CreateDoubleObservableGauge(kMetricHwPower, descrMetricHwPower, unitMetricHwPower);
}
 
static constexpr const char *kMetricHwStatus = "hw.status";
static constexpr const char *descrMetricHwStatus =
    "Operational status: `1` (true) or `0` (false) for each of the possible states";
static constexpr const char *unitMetricHwStatus = "1";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>> CreateSyncInt64MetricHwStatus(
    metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricHwStatus, descrMetricHwStatus, unitMetricHwStatus);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>> CreateSyncDoubleMetricHwStatus(
    metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricHwStatus, descrMetricHwStatus, unitMetricHwStatus);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwStatus(
    metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(kMetricHwStatus, descrMetricHwStatus,
                                                   unitMetricHwStatus);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwStatus(
    metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(kMetricHwStatus, descrMetricHwStatus,
                                                    unitMetricHwStatus);
}
 
}  // namespace hw
}  // namespace semconv
OPENTELEMETRY_END_NAMESPACE