includes/opentelemetry/semconv/incubating/system_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 system
{
 
static constexpr const char *kMetricSystemCpuFrequency = "system.cpu.frequency";
static constexpr const char *descrMetricSystemCpuFrequency =
    "Operating frequency of the logical CPU in Hertz.";
static constexpr const char *unitMetricSystemCpuFrequency = "Hz";
 
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricSystemCpuFrequency(
    metrics::Meter *meter)
{
  return meter->CreateInt64Gauge(kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency,
                                 unitMetricSystemCpuFrequency);
}
 
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricSystemCpuFrequency(
    metrics::Meter *meter)
{
  return meter->CreateDoubleGauge(kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency,
                                  unitMetricSystemCpuFrequency);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemCpuFrequency(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableGauge(kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency,
                                           unitMetricSystemCpuFrequency);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemCpuFrequency(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableGauge(
      kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency, unitMetricSystemCpuFrequency);
}
 
static constexpr const char *kMetricSystemCpuLogicalCount = "system.cpu.logical.count";
static constexpr const char *descrMetricSystemCpuLogicalCount =
    "Reports the number of logical (virtual) processor cores created by the operating system to "
    "manage multitasking.";
static constexpr const char *unitMetricSystemCpuLogicalCount = "{cpu}";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemCpuLogicalCount(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemCpuLogicalCount,
                                         descrMetricSystemCpuLogicalCount,
                                         unitMetricSystemCpuLogicalCount);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemCpuLogicalCount(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemCpuLogicalCount,
                                          descrMetricSystemCpuLogicalCount,
                                          unitMetricSystemCpuLogicalCount);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemCpuLogicalCount(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemCpuLogicalCount,
                                                   descrMetricSystemCpuLogicalCount,
                                                   unitMetricSystemCpuLogicalCount);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemCpuLogicalCount(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemCpuLogicalCount,
                                                    descrMetricSystemCpuLogicalCount,
                                                    unitMetricSystemCpuLogicalCount);
}
 
static constexpr const char *kMetricSystemCpuPhysicalCount = "system.cpu.physical.count";
static constexpr const char *descrMetricSystemCpuPhysicalCount =
    "Reports the number of actual physical processor cores on the hardware.";
static constexpr const char *unitMetricSystemCpuPhysicalCount = "{cpu}";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemCpuPhysicalCount(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemCpuPhysicalCount,
                                         descrMetricSystemCpuPhysicalCount,
                                         unitMetricSystemCpuPhysicalCount);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemCpuPhysicalCount(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemCpuPhysicalCount,
                                          descrMetricSystemCpuPhysicalCount,
                                          unitMetricSystemCpuPhysicalCount);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemCpuPhysicalCount(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemCpuPhysicalCount,
                                                   descrMetricSystemCpuPhysicalCount,
                                                   unitMetricSystemCpuPhysicalCount);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemCpuPhysicalCount(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemCpuPhysicalCount,
                                                    descrMetricSystemCpuPhysicalCount,
                                                    unitMetricSystemCpuPhysicalCount);
}
 
static constexpr const char *kMetricSystemCpuTime = "system.cpu.time";
static constexpr const char *descrMetricSystemCpuTime =
    "Seconds each logical CPU spent on each mode.";
static constexpr const char *unitMetricSystemCpuTime = "s";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemCpuTime(
    metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
                                    unitMetricSystemCpuTime);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemCpuTime(
    metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
                                    unitMetricSystemCpuTime);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricSystemCpuTime(
    metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
                                             unitMetricSystemCpuTime);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricSystemCpuTime(
    metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
                                              unitMetricSystemCpuTime);
}
 
static constexpr const char *kMetricSystemCpuUtilization = "system.cpu.utilization";
static constexpr const char *descrMetricSystemCpuUtilization =
    "For each logical CPU, the utilization is calculated as the change in cumulative CPU time "
    "(cpu.time) over a measurement interval, divided by the elapsed time.";
static constexpr const char *unitMetricSystemCpuUtilization = "1";
 
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricSystemCpuUtilization(
    metrics::Meter *meter)
{
  return meter->CreateInt64Gauge(kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization,
                                 unitMetricSystemCpuUtilization);
}
 
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricSystemCpuUtilization(
    metrics::Meter *meter)
{
  return meter->CreateDoubleGauge(kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization,
                                  unitMetricSystemCpuUtilization);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemCpuUtilization(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableGauge(
      kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization, unitMetricSystemCpuUtilization);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemCpuUtilization(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableGauge(
      kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization, unitMetricSystemCpuUtilization);
}
 
static constexpr const char *kMetricSystemDiskIo     = "system.disk.io";
static constexpr const char *descrMetricSystemDiskIo = "TODO.";
static constexpr const char *unitMetricSystemDiskIo  = "By";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemDiskIo(
    metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemDiskIo, descrMetricSystemDiskIo,
                                    unitMetricSystemDiskIo);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemDiskIo(
    metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemDiskIo, descrMetricSystemDiskIo,
                                    unitMetricSystemDiskIo);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricSystemDiskIo(
    metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricSystemDiskIo, descrMetricSystemDiskIo,
                                             unitMetricSystemDiskIo);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricSystemDiskIo(
    metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricSystemDiskIo, descrMetricSystemDiskIo,
                                              unitMetricSystemDiskIo);
}
 
static constexpr const char *kMetricSystemDiskIoTime     = "system.disk.io_time";
static constexpr const char *descrMetricSystemDiskIoTime = "Time disk spent activated.";
static constexpr const char *unitMetricSystemDiskIoTime  = "s";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemDiskIoTime(
    metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemDiskIoTime, descrMetricSystemDiskIoTime,
                                    unitMetricSystemDiskIoTime);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemDiskIoTime(
    metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemDiskIoTime, descrMetricSystemDiskIoTime,
                                    unitMetricSystemDiskIoTime);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemDiskIoTime(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricSystemDiskIoTime, descrMetricSystemDiskIoTime,
                                             unitMetricSystemDiskIoTime);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemDiskIoTime(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricSystemDiskIoTime, descrMetricSystemDiskIoTime,
                                              unitMetricSystemDiskIoTime);
}
 
static constexpr const char *kMetricSystemDiskLimit     = "system.disk.limit";
static constexpr const char *descrMetricSystemDiskLimit = "The total storage capacity of the disk.";
static constexpr const char *unitMetricSystemDiskLimit  = "By";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemDiskLimit(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemDiskLimit, descrMetricSystemDiskLimit,
                                         unitMetricSystemDiskLimit);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemDiskLimit(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemDiskLimit, descrMetricSystemDiskLimit,
                                          unitMetricSystemDiskLimit);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemDiskLimit(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(
      kMetricSystemDiskLimit, descrMetricSystemDiskLimit, unitMetricSystemDiskLimit);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemDiskLimit(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(
      kMetricSystemDiskLimit, descrMetricSystemDiskLimit, unitMetricSystemDiskLimit);
}
 
static constexpr const char *kMetricSystemDiskMerged     = "system.disk.merged";
static constexpr const char *descrMetricSystemDiskMerged = "TODO.";
static constexpr const char *unitMetricSystemDiskMerged  = "{operation}";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemDiskMerged(
    metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemDiskMerged, descrMetricSystemDiskMerged,
                                    unitMetricSystemDiskMerged);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemDiskMerged(
    metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemDiskMerged, descrMetricSystemDiskMerged,
                                    unitMetricSystemDiskMerged);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemDiskMerged(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricSystemDiskMerged, descrMetricSystemDiskMerged,
                                             unitMetricSystemDiskMerged);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemDiskMerged(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricSystemDiskMerged, descrMetricSystemDiskMerged,
                                              unitMetricSystemDiskMerged);
}
 
static constexpr const char *kMetricSystemDiskOperationTime = "system.disk.operation_time";
static constexpr const char *descrMetricSystemDiskOperationTime =
    "Sum of the time each operation took to complete.";
static constexpr const char *unitMetricSystemDiskOperationTime = "s";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
CreateSyncInt64MetricSystemDiskOperationTime(metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemDiskOperationTime,
                                    descrMetricSystemDiskOperationTime,
                                    unitMetricSystemDiskOperationTime);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>>
CreateSyncDoubleMetricSystemDiskOperationTime(metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemDiskOperationTime,
                                    descrMetricSystemDiskOperationTime,
                                    unitMetricSystemDiskOperationTime);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemDiskOperationTime(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricSystemDiskOperationTime,
                                             descrMetricSystemDiskOperationTime,
                                             unitMetricSystemDiskOperationTime);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemDiskOperationTime(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricSystemDiskOperationTime,
                                              descrMetricSystemDiskOperationTime,
                                              unitMetricSystemDiskOperationTime);
}
 
static constexpr const char *kMetricSystemDiskOperations     = "system.disk.operations";
static constexpr const char *descrMetricSystemDiskOperations = "TODO.";
static constexpr const char *unitMetricSystemDiskOperations  = "{operation}";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
CreateSyncInt64MetricSystemDiskOperations(metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemDiskOperations, descrMetricSystemDiskOperations,
                                    unitMetricSystemDiskOperations);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>>
CreateSyncDoubleMetricSystemDiskOperations(metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemDiskOperations, descrMetricSystemDiskOperations,
                                    unitMetricSystemDiskOperations);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemDiskOperations(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(
      kMetricSystemDiskOperations, descrMetricSystemDiskOperations, unitMetricSystemDiskOperations);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemDiskOperations(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(
      kMetricSystemDiskOperations, descrMetricSystemDiskOperations, unitMetricSystemDiskOperations);
}
 
static constexpr const char *kMetricSystemFilesystemLimit = "system.filesystem.limit";
static constexpr const char *descrMetricSystemFilesystemLimit =
    "The total storage capacity of the filesystem.";
static constexpr const char *unitMetricSystemFilesystemLimit = "By";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemFilesystemLimit(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemFilesystemLimit,
                                         descrMetricSystemFilesystemLimit,
                                         unitMetricSystemFilesystemLimit);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemFilesystemLimit(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemFilesystemLimit,
                                          descrMetricSystemFilesystemLimit,
                                          unitMetricSystemFilesystemLimit);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemFilesystemLimit(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemFilesystemLimit,
                                                   descrMetricSystemFilesystemLimit,
                                                   unitMetricSystemFilesystemLimit);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemFilesystemLimit(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemFilesystemLimit,
                                                    descrMetricSystemFilesystemLimit,
                                                    unitMetricSystemFilesystemLimit);
}
 
static constexpr const char *kMetricSystemFilesystemUsage = "system.filesystem.usage";
static constexpr const char *descrMetricSystemFilesystemUsage =
    "Reports a filesystem's space usage across different states.";
static constexpr const char *unitMetricSystemFilesystemUsage = "By";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemFilesystemUsage(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemFilesystemUsage,
                                         descrMetricSystemFilesystemUsage,
                                         unitMetricSystemFilesystemUsage);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemFilesystemUsage(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemFilesystemUsage,
                                          descrMetricSystemFilesystemUsage,
                                          unitMetricSystemFilesystemUsage);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemFilesystemUsage(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemFilesystemUsage,
                                                   descrMetricSystemFilesystemUsage,
                                                   unitMetricSystemFilesystemUsage);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemFilesystemUsage(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemFilesystemUsage,
                                                    descrMetricSystemFilesystemUsage,
                                                    unitMetricSystemFilesystemUsage);
}
 
static constexpr const char *kMetricSystemFilesystemUtilization = "system.filesystem.utilization";
static constexpr const char *descrMetricSystemFilesystemUtilization = "TODO.";
static constexpr const char *unitMetricSystemFilesystemUtilization  = "1";
 
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
CreateSyncInt64MetricSystemFilesystemUtilization(metrics::Meter *meter)
{
  return meter->CreateInt64Gauge(kMetricSystemFilesystemUtilization,
                                 descrMetricSystemFilesystemUtilization,
                                 unitMetricSystemFilesystemUtilization);
}
 
static inline nostd::unique_ptr<metrics::Gauge<double>>
CreateSyncDoubleMetricSystemFilesystemUtilization(metrics::Meter *meter)
{
  return meter->CreateDoubleGauge(kMetricSystemFilesystemUtilization,
                                  descrMetricSystemFilesystemUtilization,
                                  unitMetricSystemFilesystemUtilization);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemFilesystemUtilization(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableGauge(kMetricSystemFilesystemUtilization,
                                           descrMetricSystemFilesystemUtilization,
                                           unitMetricSystemFilesystemUtilization);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemFilesystemUtilization(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableGauge(kMetricSystemFilesystemUtilization,
                                            descrMetricSystemFilesystemUtilization,
                                            unitMetricSystemFilesystemUtilization);
}
 
static constexpr const char *kMetricSystemLinuxMemoryAvailable = "system.linux.memory.available";
static constexpr const char *descrMetricSystemLinuxMemoryAvailable =
    "An estimate of how much memory is available for starting new applications, without causing "
    "swapping.";
static constexpr const char *unitMetricSystemLinuxMemoryAvailable = "By";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemLinuxMemoryAvailable(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemLinuxMemoryAvailable,
                                         descrMetricSystemLinuxMemoryAvailable,
                                         unitMetricSystemLinuxMemoryAvailable);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemLinuxMemoryAvailable(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemLinuxMemoryAvailable,
                                          descrMetricSystemLinuxMemoryAvailable,
                                          unitMetricSystemLinuxMemoryAvailable);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemLinuxMemoryAvailable(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemLinuxMemoryAvailable,
                                                   descrMetricSystemLinuxMemoryAvailable,
                                                   unitMetricSystemLinuxMemoryAvailable);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemLinuxMemoryAvailable(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemLinuxMemoryAvailable,
                                                    descrMetricSystemLinuxMemoryAvailable,
                                                    unitMetricSystemLinuxMemoryAvailable);
}
 
static constexpr const char *kMetricSystemLinuxMemorySlabUsage = "system.linux.memory.slab.usage";
static constexpr const char *descrMetricSystemLinuxMemorySlabUsage =
    "Reports the memory used by the Linux kernel for managing caches of frequently used objects.";
static constexpr const char *unitMetricSystemLinuxMemorySlabUsage = "By";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemLinuxMemorySlabUsage(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemLinuxMemorySlabUsage,
                                         descrMetricSystemLinuxMemorySlabUsage,
                                         unitMetricSystemLinuxMemorySlabUsage);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemLinuxMemorySlabUsage(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemLinuxMemorySlabUsage,
                                          descrMetricSystemLinuxMemorySlabUsage,
                                          unitMetricSystemLinuxMemorySlabUsage);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemLinuxMemorySlabUsage(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemLinuxMemorySlabUsage,
                                                   descrMetricSystemLinuxMemorySlabUsage,
                                                   unitMetricSystemLinuxMemorySlabUsage);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemLinuxMemorySlabUsage(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemLinuxMemorySlabUsage,
                                                    descrMetricSystemLinuxMemorySlabUsage,
                                                    unitMetricSystemLinuxMemorySlabUsage);
}
 
static constexpr const char *kMetricSystemMemoryLimit = "system.memory.limit";
static constexpr const char *descrMetricSystemMemoryLimit =
    "Total virtual memory available in the system.";
static constexpr const char *unitMetricSystemMemoryLimit = "By";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemMemoryLimit(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemMemoryLimit, descrMetricSystemMemoryLimit,
                                         unitMetricSystemMemoryLimit);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemMemoryLimit(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemMemoryLimit, descrMetricSystemMemoryLimit,
                                          unitMetricSystemMemoryLimit);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemMemoryLimit(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(
      kMetricSystemMemoryLimit, descrMetricSystemMemoryLimit, unitMetricSystemMemoryLimit);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemMemoryLimit(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(
      kMetricSystemMemoryLimit, descrMetricSystemMemoryLimit, unitMetricSystemMemoryLimit);
}
 
static constexpr const char *kMetricSystemMemoryShared = "system.memory.shared";
static constexpr const char *descrMetricSystemMemoryShared =
    "Shared memory used (mostly by tmpfs).";
static constexpr const char *unitMetricSystemMemoryShared = "By";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemMemoryShared(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemMemoryShared, descrMetricSystemMemoryShared,
                                         unitMetricSystemMemoryShared);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemMemoryShared(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemMemoryShared, descrMetricSystemMemoryShared,
                                          unitMetricSystemMemoryShared);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemMemoryShared(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(
      kMetricSystemMemoryShared, descrMetricSystemMemoryShared, unitMetricSystemMemoryShared);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemMemoryShared(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(
      kMetricSystemMemoryShared, descrMetricSystemMemoryShared, unitMetricSystemMemoryShared);
}
 
static constexpr const char *kMetricSystemMemoryUsage     = "system.memory.usage";
static constexpr const char *descrMetricSystemMemoryUsage = "Reports memory in use by state.";
static constexpr const char *unitMetricSystemMemoryUsage  = "By";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemMemoryUsage(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemMemoryUsage, descrMetricSystemMemoryUsage,
                                         unitMetricSystemMemoryUsage);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemMemoryUsage(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemMemoryUsage, descrMetricSystemMemoryUsage,
                                          unitMetricSystemMemoryUsage);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemMemoryUsage(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(
      kMetricSystemMemoryUsage, descrMetricSystemMemoryUsage, unitMetricSystemMemoryUsage);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemMemoryUsage(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(
      kMetricSystemMemoryUsage, descrMetricSystemMemoryUsage, unitMetricSystemMemoryUsage);
}
 
static constexpr const char *kMetricSystemMemoryUtilization     = "system.memory.utilization";
static constexpr const char *descrMetricSystemMemoryUtilization = "TODO.";
static constexpr const char *unitMetricSystemMemoryUtilization  = "1";
 
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
CreateSyncInt64MetricSystemMemoryUtilization(metrics::Meter *meter)
{
  return meter->CreateInt64Gauge(kMetricSystemMemoryUtilization, descrMetricSystemMemoryUtilization,
                                 unitMetricSystemMemoryUtilization);
}
 
static inline nostd::unique_ptr<metrics::Gauge<double>>
CreateSyncDoubleMetricSystemMemoryUtilization(metrics::Meter *meter)
{
  return meter->CreateDoubleGauge(kMetricSystemMemoryUtilization,
                                  descrMetricSystemMemoryUtilization,
                                  unitMetricSystemMemoryUtilization);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemMemoryUtilization(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableGauge(kMetricSystemMemoryUtilization,
                                           descrMetricSystemMemoryUtilization,
                                           unitMetricSystemMemoryUtilization);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemMemoryUtilization(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableGauge(kMetricSystemMemoryUtilization,
                                            descrMetricSystemMemoryUtilization,
                                            unitMetricSystemMemoryUtilization);
}
 
static constexpr const char *kMetricSystemNetworkConnectionCount =
    "system.network.connection.count";
static constexpr const char *descrMetricSystemNetworkConnectionCount = "TODO.";
static constexpr const char *unitMetricSystemNetworkConnectionCount  = "{connection}";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemNetworkConnectionCount(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemNetworkConnectionCount,
                                         descrMetricSystemNetworkConnectionCount,
                                         unitMetricSystemNetworkConnectionCount);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemNetworkConnectionCount(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemNetworkConnectionCount,
                                          descrMetricSystemNetworkConnectionCount,
                                          unitMetricSystemNetworkConnectionCount);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemNetworkConnectionCount(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemNetworkConnectionCount,
                                                   descrMetricSystemNetworkConnectionCount,
                                                   unitMetricSystemNetworkConnectionCount);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemNetworkConnectionCount(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemNetworkConnectionCount,
                                                    descrMetricSystemNetworkConnectionCount,
                                                    unitMetricSystemNetworkConnectionCount);
}
 
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricSystemNetworkConnections =
    "system.network.connections";
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricSystemNetworkConnections =
    "Deprecated, use `system.network.connection.count` instead.";
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricSystemNetworkConnections =
    "{connection}";
 
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemNetworkConnections(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemNetworkConnections,
                                         descrMetricSystemNetworkConnections,
                                         unitMetricSystemNetworkConnections);
}
 
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemNetworkConnections(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemNetworkConnections,
                                          descrMetricSystemNetworkConnections,
                                          unitMetricSystemNetworkConnections);
}
 
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemNetworkConnections(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemNetworkConnections,
                                                   descrMetricSystemNetworkConnections,
                                                   unitMetricSystemNetworkConnections);
}
 
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemNetworkConnections(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemNetworkConnections,
                                                    descrMetricSystemNetworkConnections,
                                                    unitMetricSystemNetworkConnections);
}
 
static constexpr const char *kMetricSystemNetworkErrors     = "system.network.errors";
static constexpr const char *descrMetricSystemNetworkErrors = "Count of network errors detected.";
static constexpr const char *unitMetricSystemNetworkErrors  = "{error}";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
CreateSyncInt64MetricSystemNetworkErrors(metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemNetworkErrors, descrMetricSystemNetworkErrors,
                                    unitMetricSystemNetworkErrors);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemNetworkErrors(
    metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemNetworkErrors, descrMetricSystemNetworkErrors,
                                    unitMetricSystemNetworkErrors);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemNetworkErrors(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(
      kMetricSystemNetworkErrors, descrMetricSystemNetworkErrors, unitMetricSystemNetworkErrors);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemNetworkErrors(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(
      kMetricSystemNetworkErrors, descrMetricSystemNetworkErrors, unitMetricSystemNetworkErrors);
}
 
static constexpr const char *kMetricSystemNetworkIo     = "system.network.io";
static constexpr const char *descrMetricSystemNetworkIo = "TODO.";
static constexpr const char *unitMetricSystemNetworkIo  = "By";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemNetworkIo(
    metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemNetworkIo, descrMetricSystemNetworkIo,
                                    unitMetricSystemNetworkIo);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemNetworkIo(
    metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemNetworkIo, descrMetricSystemNetworkIo,
                                    unitMetricSystemNetworkIo);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemNetworkIo(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricSystemNetworkIo, descrMetricSystemNetworkIo,
                                             unitMetricSystemNetworkIo);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemNetworkIo(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricSystemNetworkIo, descrMetricSystemNetworkIo,
                                              unitMetricSystemNetworkIo);
}
 
static constexpr const char *kMetricSystemNetworkPacketCount     = "system.network.packet.count";
static constexpr const char *descrMetricSystemNetworkPacketCount = "TODO.";
static constexpr const char *unitMetricSystemNetworkPacketCount  = "{packet}";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
CreateSyncInt64MetricSystemNetworkPacketCount(metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemNetworkPacketCount,
                                    descrMetricSystemNetworkPacketCount,
                                    unitMetricSystemNetworkPacketCount);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>>
CreateSyncDoubleMetricSystemNetworkPacketCount(metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemNetworkPacketCount,
                                    descrMetricSystemNetworkPacketCount,
                                    unitMetricSystemNetworkPacketCount);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemNetworkPacketCount(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricSystemNetworkPacketCount,
                                             descrMetricSystemNetworkPacketCount,
                                             unitMetricSystemNetworkPacketCount);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemNetworkPacketCount(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricSystemNetworkPacketCount,
                                              descrMetricSystemNetworkPacketCount,
                                              unitMetricSystemNetworkPacketCount);
}
 
static constexpr const char *kMetricSystemNetworkPacketDropped = "system.network.packet.dropped";
static constexpr const char *descrMetricSystemNetworkPacketDropped =
    "Count of packets that are dropped or discarded even though there was no error.";
static constexpr const char *unitMetricSystemNetworkPacketDropped = "{packet}";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
CreateSyncInt64MetricSystemNetworkPacketDropped(metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemNetworkPacketDropped,
                                    descrMetricSystemNetworkPacketDropped,
                                    unitMetricSystemNetworkPacketDropped);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>>
CreateSyncDoubleMetricSystemNetworkPacketDropped(metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemNetworkPacketDropped,
                                    descrMetricSystemNetworkPacketDropped,
                                    unitMetricSystemNetworkPacketDropped);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemNetworkPacketDropped(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricSystemNetworkPacketDropped,
                                             descrMetricSystemNetworkPacketDropped,
                                             unitMetricSystemNetworkPacketDropped);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemNetworkPacketDropped(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricSystemNetworkPacketDropped,
                                              descrMetricSystemNetworkPacketDropped,
                                              unitMetricSystemNetworkPacketDropped);
}
 
static constexpr const char *kMetricSystemPagingFaults     = "system.paging.faults";
static constexpr const char *descrMetricSystemPagingFaults = "TODO.";
static constexpr const char *unitMetricSystemPagingFaults  = "{fault}";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemPagingFaults(
    metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemPagingFaults, descrMetricSystemPagingFaults,
                                    unitMetricSystemPagingFaults);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemPagingFaults(
    metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemPagingFaults, descrMetricSystemPagingFaults,
                                    unitMetricSystemPagingFaults);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemPagingFaults(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(
      kMetricSystemPagingFaults, descrMetricSystemPagingFaults, unitMetricSystemPagingFaults);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemPagingFaults(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(
      kMetricSystemPagingFaults, descrMetricSystemPagingFaults, unitMetricSystemPagingFaults);
}
 
static constexpr const char *kMetricSystemPagingOperations     = "system.paging.operations";
static constexpr const char *descrMetricSystemPagingOperations = "TODO.";
static constexpr const char *unitMetricSystemPagingOperations  = "{operation}";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
CreateSyncInt64MetricSystemPagingOperations(metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemPagingOperations,
                                    descrMetricSystemPagingOperations,
                                    unitMetricSystemPagingOperations);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>>
CreateSyncDoubleMetricSystemPagingOperations(metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemPagingOperations,
                                    descrMetricSystemPagingOperations,
                                    unitMetricSystemPagingOperations);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemPagingOperations(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(kMetricSystemPagingOperations,
                                             descrMetricSystemPagingOperations,
                                             unitMetricSystemPagingOperations);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemPagingOperations(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(kMetricSystemPagingOperations,
                                              descrMetricSystemPagingOperations,
                                              unitMetricSystemPagingOperations);
}
 
static constexpr const char *kMetricSystemPagingUsage     = "system.paging.usage";
static constexpr const char *descrMetricSystemPagingUsage = "Unix swap or windows pagefile usage.";
static constexpr const char *unitMetricSystemPagingUsage  = "By";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemPagingUsage(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemPagingUsage, descrMetricSystemPagingUsage,
                                         unitMetricSystemPagingUsage);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemPagingUsage(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemPagingUsage, descrMetricSystemPagingUsage,
                                          unitMetricSystemPagingUsage);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemPagingUsage(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(
      kMetricSystemPagingUsage, descrMetricSystemPagingUsage, unitMetricSystemPagingUsage);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemPagingUsage(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(
      kMetricSystemPagingUsage, descrMetricSystemPagingUsage, unitMetricSystemPagingUsage);
}
 
static constexpr const char *kMetricSystemPagingUtilization     = "system.paging.utilization";
static constexpr const char *descrMetricSystemPagingUtilization = "TODO.";
static constexpr const char *unitMetricSystemPagingUtilization  = "1";
 
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
CreateSyncInt64MetricSystemPagingUtilization(metrics::Meter *meter)
{
  return meter->CreateInt64Gauge(kMetricSystemPagingUtilization, descrMetricSystemPagingUtilization,
                                 unitMetricSystemPagingUtilization);
}
 
static inline nostd::unique_ptr<metrics::Gauge<double>>
CreateSyncDoubleMetricSystemPagingUtilization(metrics::Meter *meter)
{
  return meter->CreateDoubleGauge(kMetricSystemPagingUtilization,
                                  descrMetricSystemPagingUtilization,
                                  unitMetricSystemPagingUtilization);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemPagingUtilization(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableGauge(kMetricSystemPagingUtilization,
                                           descrMetricSystemPagingUtilization,
                                           unitMetricSystemPagingUtilization);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemPagingUtilization(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableGauge(kMetricSystemPagingUtilization,
                                            descrMetricSystemPagingUtilization,
                                            unitMetricSystemPagingUtilization);
}
 
static constexpr const char *kMetricSystemProcessCount = "system.process.count";
static constexpr const char *descrMetricSystemProcessCount =
    "Total number of processes in each state.";
static constexpr const char *unitMetricSystemProcessCount = "{process}";
 
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricSystemProcessCount(metrics::Meter *meter)
{
  return meter->CreateInt64UpDownCounter(kMetricSystemProcessCount, descrMetricSystemProcessCount,
                                         unitMetricSystemProcessCount);
}
 
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricSystemProcessCount(metrics::Meter *meter)
{
  return meter->CreateDoubleUpDownCounter(kMetricSystemProcessCount, descrMetricSystemProcessCount,
                                          unitMetricSystemProcessCount);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemProcessCount(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableUpDownCounter(
      kMetricSystemProcessCount, descrMetricSystemProcessCount, unitMetricSystemProcessCount);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemProcessCount(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableUpDownCounter(
      kMetricSystemProcessCount, descrMetricSystemProcessCount, unitMetricSystemProcessCount);
}
 
static constexpr const char *kMetricSystemProcessCreated = "system.process.created";
static constexpr const char *descrMetricSystemProcessCreated =
    "Total number of processes created over uptime of the host.";
static constexpr const char *unitMetricSystemProcessCreated = "{process}";
 
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
CreateSyncInt64MetricSystemProcessCreated(metrics::Meter *meter)
{
  return meter->CreateUInt64Counter(kMetricSystemProcessCreated, descrMetricSystemProcessCreated,
                                    unitMetricSystemProcessCreated);
}
 
static inline nostd::unique_ptr<metrics::Counter<double>>
CreateSyncDoubleMetricSystemProcessCreated(metrics::Meter *meter)
{
  return meter->CreateDoubleCounter(kMetricSystemProcessCreated, descrMetricSystemProcessCreated,
                                    unitMetricSystemProcessCreated);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricSystemProcessCreated(metrics::Meter *meter)
{
  return meter->CreateInt64ObservableCounter(
      kMetricSystemProcessCreated, descrMetricSystemProcessCreated, unitMetricSystemProcessCreated);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricSystemProcessCreated(metrics::Meter *meter)
{
  return meter->CreateDoubleObservableCounter(
      kMetricSystemProcessCreated, descrMetricSystemProcessCreated, unitMetricSystemProcessCreated);
}
 
static constexpr const char *kMetricSystemUptime     = "system.uptime";
static constexpr const char *descrMetricSystemUptime = "The time the system has been running.";
static constexpr const char *unitMetricSystemUptime  = "s";
 
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricSystemUptime(
    metrics::Meter *meter)
{
  return meter->CreateInt64Gauge(kMetricSystemUptime, descrMetricSystemUptime,
                                 unitMetricSystemUptime);
}
 
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricSystemUptime(
    metrics::Meter *meter)
{
  return meter->CreateDoubleGauge(kMetricSystemUptime, descrMetricSystemUptime,
                                  unitMetricSystemUptime);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricSystemUptime(
    metrics::Meter *meter)
{
  return meter->CreateInt64ObservableGauge(kMetricSystemUptime, descrMetricSystemUptime,
                                           unitMetricSystemUptime);
}
 
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricSystemUptime(
    metrics::Meter *meter)
{
  return meter->CreateDoubleObservableGauge(kMetricSystemUptime, descrMetricSystemUptime,
                                            unitMetricSystemUptime);
}
 
}  // namespace system
}  // namespace semconv
OPENTELEMETRY_END_NAMESPACE