mirror
/
devilutionX-ZeroTierOne
mirror of https://github.com/diasurgical/ZeroTierOne.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6607 Commits
2 Branches
0 Tags
159 MiB
 
 
 
 
 
 
Tree: 4f2717c244
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '4f2717c244'
${ noResults }
devilutionX-ZeroTierOne/ext/opentelemetry-cpp-api-only/include/opentelemetry/semconv/k8s_metrics.h

1735 lines
79 KiB
Raw Blame History

/*
* 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 k8s
{
/**
* The number of actively running jobs for a cronjob
* <p>
* This metric aligns with the @code active @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#cronjobstatus-v1-batch">K8s
* CronJobStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#cronjob">@code k8s.cronjob @endcode</a> resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sCronjobActiveJobs = "k8s.cronjob.active_jobs";
static constexpr const char *descrMetricK8sCronjobActiveJobs =
"The number of actively running jobs for a cronjob";
static constexpr const char *unitMetricK8sCronjobActiveJobs = "{job}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sCronjobActiveJobs(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(
kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sCronjobActiveJobs(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(
kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sCronjobActiveJobs(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(
kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sCronjobActiveJobs(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(
kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs);
}
/**
* Number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod
* <p>
* This metric aligns with the @code currentNumberScheduled @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps">K8s
* DaemonSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#daemonset">@code k8s.daemonset @endcode</a> resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sDaemonsetCurrentScheduledNodes =
"k8s.daemonset.current_scheduled_nodes";
static constexpr const char *descrMetricK8sDaemonsetCurrentScheduledNodes =
"Number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod";
static constexpr const char *unitMetricK8sDaemonsetCurrentScheduledNodes = "{node}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes,
descrMetricK8sDaemonsetCurrentScheduledNodes,
unitMetricK8sDaemonsetCurrentScheduledNodes);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes,
descrMetricK8sDaemonsetCurrentScheduledNodes,
unitMetricK8sDaemonsetCurrentScheduledNodes);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes,
descrMetricK8sDaemonsetCurrentScheduledNodes,
unitMetricK8sDaemonsetCurrentScheduledNodes);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes,
descrMetricK8sDaemonsetCurrentScheduledNodes,
unitMetricK8sDaemonsetCurrentScheduledNodes);
}
/**
* Number of nodes that should be running the daemon pod (including nodes currently running the
* daemon pod) <p> This metric aligns with the @code desiredNumberScheduled @endcode field of the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps">K8s
* DaemonSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#daemonset">@code k8s.daemonset @endcode</a> resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sDaemonsetDesiredScheduledNodes =
"k8s.daemonset.desired_scheduled_nodes";
static constexpr const char *descrMetricK8sDaemonsetDesiredScheduledNodes =
"Number of nodes that should be running the daemon pod (including nodes currently running the "
"daemon pod)";
static constexpr const char *unitMetricK8sDaemonsetDesiredScheduledNodes = "{node}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes,
descrMetricK8sDaemonsetDesiredScheduledNodes,
unitMetricK8sDaemonsetDesiredScheduledNodes);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes,
descrMetricK8sDaemonsetDesiredScheduledNodes,
unitMetricK8sDaemonsetDesiredScheduledNodes);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes,
descrMetricK8sDaemonsetDesiredScheduledNodes,
unitMetricK8sDaemonsetDesiredScheduledNodes);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes,
descrMetricK8sDaemonsetDesiredScheduledNodes,
unitMetricK8sDaemonsetDesiredScheduledNodes);
}
/**
* Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod
* <p>
* This metric aligns with the @code numberMisscheduled @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps">K8s
* DaemonSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#daemonset">@code k8s.daemonset @endcode</a> resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sDaemonsetMisscheduledNodes =
"k8s.daemonset.misscheduled_nodes";
static constexpr const char *descrMetricK8sDaemonsetMisscheduledNodes =
"Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod";
static constexpr const char *unitMetricK8sDaemonsetMisscheduledNodes = "{node}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetMisscheduledNodes,
descrMetricK8sDaemonsetMisscheduledNodes,
unitMetricK8sDaemonsetMisscheduledNodes);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetMisscheduledNodes,
descrMetricK8sDaemonsetMisscheduledNodes,
unitMetricK8sDaemonsetMisscheduledNodes);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetMisscheduledNodes,
descrMetricK8sDaemonsetMisscheduledNodes,
unitMetricK8sDaemonsetMisscheduledNodes);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetMisscheduledNodes,
descrMetricK8sDaemonsetMisscheduledNodes,
unitMetricK8sDaemonsetMisscheduledNodes);
}
/**
* Number of nodes that should be running the daemon pod and have one or more of the daemon pod
* running and ready <p> This metric aligns with the @code numberReady @endcode field of the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps">K8s
* DaemonSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#daemonset">@code k8s.daemonset @endcode</a> resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sDaemonsetReadyNodes = "k8s.daemonset.ready_nodes";
static constexpr const char *descrMetricK8sDaemonsetReadyNodes =
"Number of nodes that should be running the daemon pod and have one or more of the daemon pod "
"running and ready";
static constexpr const char *unitMetricK8sDaemonsetReadyNodes = "{node}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sDaemonsetReadyNodes(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetReadyNodes,
descrMetricK8sDaemonsetReadyNodes,
unitMetricK8sDaemonsetReadyNodes);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sDaemonsetReadyNodes(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetReadyNodes,
descrMetricK8sDaemonsetReadyNodes,
unitMetricK8sDaemonsetReadyNodes);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sDaemonsetReadyNodes(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetReadyNodes,
descrMetricK8sDaemonsetReadyNodes,
unitMetricK8sDaemonsetReadyNodes);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sDaemonsetReadyNodes(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetReadyNodes,
descrMetricK8sDaemonsetReadyNodes,
unitMetricK8sDaemonsetReadyNodes);
}
/**
* Total number of available replica pods (ready for at least minReadySeconds) targeted by this
* deployment <p> This metric aligns with the @code availableReplicas @endcode field of the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#deploymentstatus-v1-apps">K8s
* DeploymentStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#deployment">@code k8s.deployment @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sDeploymentAvailablePods = "k8s.deployment.available_pods";
static constexpr const char *descrMetricK8sDeploymentAvailablePods =
"Total number of available replica pods (ready for at least minReadySeconds) targeted by this "
"deployment";
static constexpr const char *unitMetricK8sDeploymentAvailablePods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sDeploymentAvailablePods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sDeploymentAvailablePods,
descrMetricK8sDeploymentAvailablePods,
unitMetricK8sDeploymentAvailablePods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sDeploymentAvailablePods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sDeploymentAvailablePods,
descrMetricK8sDeploymentAvailablePods,
unitMetricK8sDeploymentAvailablePods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sDeploymentAvailablePods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDeploymentAvailablePods,
descrMetricK8sDeploymentAvailablePods,
unitMetricK8sDeploymentAvailablePods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sDeploymentAvailablePods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDeploymentAvailablePods,
descrMetricK8sDeploymentAvailablePods,
unitMetricK8sDeploymentAvailablePods);
}
/**
* Number of desired replica pods in this deployment
* <p>
* This metric aligns with the @code replicas @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#deploymentspec-v1-apps">K8s
* DeploymentSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#deployment">@code k8s.deployment @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sDeploymentDesiredPods = "k8s.deployment.desired_pods";
static constexpr const char *descrMetricK8sDeploymentDesiredPods =
"Number of desired replica pods in this deployment";
static constexpr const char *unitMetricK8sDeploymentDesiredPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sDeploymentDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sDeploymentDesiredPods,
descrMetricK8sDeploymentDesiredPods,
unitMetricK8sDeploymentDesiredPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sDeploymentDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sDeploymentDesiredPods,
descrMetricK8sDeploymentDesiredPods,
unitMetricK8sDeploymentDesiredPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sDeploymentDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDeploymentDesiredPods,
descrMetricK8sDeploymentDesiredPods,
unitMetricK8sDeploymentDesiredPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sDeploymentDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDeploymentDesiredPods,
descrMetricK8sDeploymentDesiredPods,
unitMetricK8sDeploymentDesiredPods);
}
/**
* Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the
* autoscaler <p> This metric aligns with the @code currentReplicas @endcode field of the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerstatus-v2-autoscaling">K8s
* HorizontalPodAutoscalerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sHpaCurrentPods = "k8s.hpa.current_pods";
static constexpr const char *descrMetricK8sHpaCurrentPods =
"Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the "
"autoscaler";
static constexpr const char *unitMetricK8sHpaCurrentPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sHpaCurrentPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods,
unitMetricK8sHpaCurrentPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sHpaCurrentPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods,
unitMetricK8sHpaCurrentPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sHpaCurrentPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(
kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, unitMetricK8sHpaCurrentPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sHpaCurrentPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(
kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, unitMetricK8sHpaCurrentPods);
}
/**
* Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated by
* the autoscaler <p> This metric aligns with the @code desiredReplicas @endcode field of the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerstatus-v2-autoscaling">K8s
* HorizontalPodAutoscalerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sHpaDesiredPods = "k8s.hpa.desired_pods";
static constexpr const char *descrMetricK8sHpaDesiredPods =
"Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated "
"by the autoscaler";
static constexpr const char *unitMetricK8sHpaDesiredPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sHpaDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods,
unitMetricK8sHpaDesiredPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sHpaDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods,
unitMetricK8sHpaDesiredPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sHpaDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(
kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods, unitMetricK8sHpaDesiredPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sHpaDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(
kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods, unitMetricK8sHpaDesiredPods);
}
/**
* The upper limit for the number of replica pods to which the autoscaler can scale up
* <p>
* This metric aligns with the @code maxReplicas @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerspec-v2-autoscaling">K8s
* HorizontalPodAutoscalerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sHpaMaxPods = "k8s.hpa.max_pods";
static constexpr const char *descrMetricK8sHpaMaxPods =
"The upper limit for the number of replica pods to which the autoscaler can scale up";
static constexpr const char *unitMetricK8sHpaMaxPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>> CreateSyncInt64MetricK8sHpaMaxPods(
metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods,
unitMetricK8sHpaMaxPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>> CreateSyncDoubleMetricK8sHpaMaxPods(
metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods,
unitMetricK8sHpaMaxPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sHpaMaxPods(
metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods,
unitMetricK8sHpaMaxPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricK8sHpaMaxPods(
metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods,
unitMetricK8sHpaMaxPods);
}
/**
* The lower limit for the number of replica pods to which the autoscaler can scale down
* <p>
* This metric aligns with the @code minReplicas @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerspec-v2-autoscaling">K8s
* HorizontalPodAutoscalerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sHpaMinPods = "k8s.hpa.min_pods";
static constexpr const char *descrMetricK8sHpaMinPods =
"The lower limit for the number of replica pods to which the autoscaler can scale down";
static constexpr const char *unitMetricK8sHpaMinPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>> CreateSyncInt64MetricK8sHpaMinPods(
metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods,
unitMetricK8sHpaMinPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>> CreateSyncDoubleMetricK8sHpaMinPods(
metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods,
unitMetricK8sHpaMinPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sHpaMinPods(
metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods,
unitMetricK8sHpaMinPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricK8sHpaMinPods(
metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods,
unitMetricK8sHpaMinPods);
}
/**
* The number of pending and actively running pods for a job
* <p>
* This metric aligns with the @code active @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch">K8s
* JobStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sJobActivePods = "k8s.job.active_pods";
static constexpr const char *descrMetricK8sJobActivePods =
"The number of pending and actively running pods for a job";
static constexpr const char *unitMetricK8sJobActivePods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sJobActivePods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sJobActivePods, descrMetricK8sJobActivePods,
unitMetricK8sJobActivePods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sJobActivePods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sJobActivePods, descrMetricK8sJobActivePods,
unitMetricK8sJobActivePods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sJobActivePods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(
kMetricK8sJobActivePods, descrMetricK8sJobActivePods, unitMetricK8sJobActivePods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sJobActivePods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(
kMetricK8sJobActivePods, descrMetricK8sJobActivePods, unitMetricK8sJobActivePods);
}
/**
* The desired number of successfully finished pods the job should be run with
* <p>
* This metric aligns with the @code completions @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch">K8s
* JobSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sJobDesiredSuccessfulPods = "k8s.job.desired_successful_pods";
static constexpr const char *descrMetricK8sJobDesiredSuccessfulPods =
"The desired number of successfully finished pods the job should be run with";
static constexpr const char *unitMetricK8sJobDesiredSuccessfulPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sJobDesiredSuccessfulPods,
descrMetricK8sJobDesiredSuccessfulPods,
unitMetricK8sJobDesiredSuccessfulPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sJobDesiredSuccessfulPods,
descrMetricK8sJobDesiredSuccessfulPods,
unitMetricK8sJobDesiredSuccessfulPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sJobDesiredSuccessfulPods,
descrMetricK8sJobDesiredSuccessfulPods,
unitMetricK8sJobDesiredSuccessfulPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sJobDesiredSuccessfulPods,
descrMetricK8sJobDesiredSuccessfulPods,
unitMetricK8sJobDesiredSuccessfulPods);
}
/**
* The number of pods which reached phase Failed for a job
* <p>
* This metric aligns with the @code failed @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch">K8s
* JobStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sJobFailedPods = "k8s.job.failed_pods";
static constexpr const char *descrMetricK8sJobFailedPods =
"The number of pods which reached phase Failed for a job";
static constexpr const char *unitMetricK8sJobFailedPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sJobFailedPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods,
unitMetricK8sJobFailedPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sJobFailedPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods,
unitMetricK8sJobFailedPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sJobFailedPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(
kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods, unitMetricK8sJobFailedPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sJobFailedPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(
kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods, unitMetricK8sJobFailedPods);
}
/**
* The max desired number of pods the job should run at any given time
* <p>
* This metric aligns with the @code parallelism @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch">K8s
* JobSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sJobMaxParallelPods = "k8s.job.max_parallel_pods";
static constexpr const char *descrMetricK8sJobMaxParallelPods =
"The max desired number of pods the job should run at any given time";
static constexpr const char *unitMetricK8sJobMaxParallelPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sJobMaxParallelPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sJobMaxParallelPods,
descrMetricK8sJobMaxParallelPods,
unitMetricK8sJobMaxParallelPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sJobMaxParallelPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sJobMaxParallelPods,
descrMetricK8sJobMaxParallelPods,
unitMetricK8sJobMaxParallelPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sJobMaxParallelPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sJobMaxParallelPods,
descrMetricK8sJobMaxParallelPods,
unitMetricK8sJobMaxParallelPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sJobMaxParallelPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sJobMaxParallelPods,
descrMetricK8sJobMaxParallelPods,
unitMetricK8sJobMaxParallelPods);
}
/**
* The number of pods which reached phase Succeeded for a job
* <p>
* This metric aligns with the @code succeeded @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch">K8s
* JobStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sJobSuccessfulPods = "k8s.job.successful_pods";
static constexpr const char *descrMetricK8sJobSuccessfulPods =
"The number of pods which reached phase Succeeded for a job";
static constexpr const char *unitMetricK8sJobSuccessfulPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sJobSuccessfulPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(
kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sJobSuccessfulPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(
kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sJobSuccessfulPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(
kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sJobSuccessfulPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(
kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods);
}
/**
* Describes number of K8s namespaces that are currently in a given phase.
* <p>
* This metric SHOULD, at a minimum, be reported against a
* <a href="../resource/k8s.md#namespace">@code k8s.namespace @endcode</a> resource.
* <p>
* updowncounter
*/
static constexpr const char *kMetricK8sNamespacePhase = "k8s.namespace.phase";
static constexpr const char *descrMetricK8sNamespacePhase =
"Describes number of K8s namespaces that are currently in a given phase.";
static constexpr const char *unitMetricK8sNamespacePhase = "{namespace}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sNamespacePhase(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sNamespacePhase, descrMetricK8sNamespacePhase,
unitMetricK8sNamespacePhase);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sNamespacePhase(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sNamespacePhase, descrMetricK8sNamespacePhase,
unitMetricK8sNamespacePhase);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sNamespacePhase(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(
kMetricK8sNamespacePhase, descrMetricK8sNamespacePhase, unitMetricK8sNamespacePhase);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sNamespacePhase(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(
kMetricK8sNamespacePhase, descrMetricK8sNamespacePhase, unitMetricK8sNamespacePhase);
}
/**
* Total CPU time consumed
* <p>
* Total CPU time consumed by the specific Node on all available CPU cores
* <p>
* counter
*/
static constexpr const char *kMetricK8sNodeCpuTime = "k8s.node.cpu.time";
static constexpr const char *descrMetricK8sNodeCpuTime = "Total CPU time consumed";
static constexpr const char *unitMetricK8sNodeCpuTime = "s";
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricK8sNodeCpuTime(
metrics::Meter *meter)
{
return meter->CreateUInt64Counter(kMetricK8sNodeCpuTime, descrMetricK8sNodeCpuTime,
unitMetricK8sNodeCpuTime);
}
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricK8sNodeCpuTime(
metrics::Meter *meter)
{
return meter->CreateDoubleCounter(kMetricK8sNodeCpuTime, descrMetricK8sNodeCpuTime,
unitMetricK8sNodeCpuTime);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sNodeCpuTime(
metrics::Meter *meter)
{
return meter->CreateInt64ObservableCounter(kMetricK8sNodeCpuTime, descrMetricK8sNodeCpuTime,
unitMetricK8sNodeCpuTime);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sNodeCpuTime(metrics::Meter *meter)
{
return meter->CreateDoubleObservableCounter(kMetricK8sNodeCpuTime, descrMetricK8sNodeCpuTime,
unitMetricK8sNodeCpuTime);
}
/**
* Node's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs
* <p>
* CPU usage of the specific Node on all available CPU cores, averaged over the sample window
* <p>
* gauge
*/
static constexpr const char *kMetricK8sNodeCpuUsage = "k8s.node.cpu.usage";
static constexpr const char *descrMetricK8sNodeCpuUsage =
"Node's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs";
static constexpr const char *unitMetricK8sNodeCpuUsage = "{cpu}";
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sNodeCpuUsage(
metrics::Meter *meter)
{
return meter->CreateInt64Gauge(kMetricK8sNodeCpuUsage, descrMetricK8sNodeCpuUsage,
unitMetricK8sNodeCpuUsage);
}
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sNodeCpuUsage(
metrics::Meter *meter)
{
return meter->CreateDoubleGauge(kMetricK8sNodeCpuUsage, descrMetricK8sNodeCpuUsage,
unitMetricK8sNodeCpuUsage);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sNodeCpuUsage(metrics::Meter *meter)
{
return meter->CreateInt64ObservableGauge(kMetricK8sNodeCpuUsage, descrMetricK8sNodeCpuUsage,
unitMetricK8sNodeCpuUsage);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sNodeCpuUsage(metrics::Meter *meter)
{
return meter->CreateDoubleObservableGauge(kMetricK8sNodeCpuUsage, descrMetricK8sNodeCpuUsage,
unitMetricK8sNodeCpuUsage);
}
/**
* Memory usage of the Node
* <p>
* Total memory usage of the Node
* <p>
* gauge
*/
static constexpr const char *kMetricK8sNodeMemoryUsage = "k8s.node.memory.usage";
static constexpr const char *descrMetricK8sNodeMemoryUsage = "Memory usage of the Node";
static constexpr const char *unitMetricK8sNodeMemoryUsage = "By";
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sNodeMemoryUsage(
metrics::Meter *meter)
{
return meter->CreateInt64Gauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage,
unitMetricK8sNodeMemoryUsage);
}
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sNodeMemoryUsage(
metrics::Meter *meter)
{
return meter->CreateDoubleGauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage,
unitMetricK8sNodeMemoryUsage);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sNodeMemoryUsage(metrics::Meter *meter)
{
return meter->CreateInt64ObservableGauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage,
unitMetricK8sNodeMemoryUsage);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sNodeMemoryUsage(metrics::Meter *meter)
{
return meter->CreateDoubleObservableGauge(
kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage, unitMetricK8sNodeMemoryUsage);
}
/**
* Node network errors
* <p>
* counter
*/
static constexpr const char *kMetricK8sNodeNetworkErrors = "k8s.node.network.errors";
static constexpr const char *descrMetricK8sNodeNetworkErrors = "Node network errors";
static constexpr const char *unitMetricK8sNodeNetworkErrors = "{error}";
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
CreateSyncInt64MetricK8sNodeNetworkErrors(metrics::Meter *meter)
{
return meter->CreateUInt64Counter(kMetricK8sNodeNetworkErrors, descrMetricK8sNodeNetworkErrors,
unitMetricK8sNodeNetworkErrors);
}
static inline nostd::unique_ptr<metrics::Counter<double>>
CreateSyncDoubleMetricK8sNodeNetworkErrors(metrics::Meter *meter)
{
return meter->CreateDoubleCounter(kMetricK8sNodeNetworkErrors, descrMetricK8sNodeNetworkErrors,
unitMetricK8sNodeNetworkErrors);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sNodeNetworkErrors(metrics::Meter *meter)
{
return meter->CreateInt64ObservableCounter(
kMetricK8sNodeNetworkErrors, descrMetricK8sNodeNetworkErrors, unitMetricK8sNodeNetworkErrors);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sNodeNetworkErrors(metrics::Meter *meter)
{
return meter->CreateDoubleObservableCounter(
kMetricK8sNodeNetworkErrors, descrMetricK8sNodeNetworkErrors, unitMetricK8sNodeNetworkErrors);
}
/**
* Network bytes for the Node
* <p>
* counter
*/
static constexpr const char *kMetricK8sNodeNetworkIo = "k8s.node.network.io";
static constexpr const char *descrMetricK8sNodeNetworkIo = "Network bytes for the Node";
static constexpr const char *unitMetricK8sNodeNetworkIo = "By";
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricK8sNodeNetworkIo(
metrics::Meter *meter)
{
return meter->CreateUInt64Counter(kMetricK8sNodeNetworkIo, descrMetricK8sNodeNetworkIo,
unitMetricK8sNodeNetworkIo);
}
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricK8sNodeNetworkIo(
metrics::Meter *meter)
{
return meter->CreateDoubleCounter(kMetricK8sNodeNetworkIo, descrMetricK8sNodeNetworkIo,
unitMetricK8sNodeNetworkIo);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sNodeNetworkIo(metrics::Meter *meter)
{
return meter->CreateInt64ObservableCounter(kMetricK8sNodeNetworkIo, descrMetricK8sNodeNetworkIo,
unitMetricK8sNodeNetworkIo);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sNodeNetworkIo(metrics::Meter *meter)
{
return meter->CreateDoubleObservableCounter(kMetricK8sNodeNetworkIo, descrMetricK8sNodeNetworkIo,
unitMetricK8sNodeNetworkIo);
}
/**
* The time the Node has been running
* <p>
* Instrumentations SHOULD use a gauge with type @code double @endcode and measure uptime in seconds
* as a floating point number with the highest precision available. The actual accuracy would depend
* on the instrumentation and operating system. <p> gauge
*/
static constexpr const char *kMetricK8sNodeUptime = "k8s.node.uptime";
static constexpr const char *descrMetricK8sNodeUptime = "The time the Node has been running";
static constexpr const char *unitMetricK8sNodeUptime = "s";
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sNodeUptime(
metrics::Meter *meter)
{
return meter->CreateInt64Gauge(kMetricK8sNodeUptime, descrMetricK8sNodeUptime,
unitMetricK8sNodeUptime);
}
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sNodeUptime(
metrics::Meter *meter)
{
return meter->CreateDoubleGauge(kMetricK8sNodeUptime, descrMetricK8sNodeUptime,
unitMetricK8sNodeUptime);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sNodeUptime(
metrics::Meter *meter)
{
return meter->CreateInt64ObservableGauge(kMetricK8sNodeUptime, descrMetricK8sNodeUptime,
unitMetricK8sNodeUptime);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricK8sNodeUptime(
metrics::Meter *meter)
{
return meter->CreateDoubleObservableGauge(kMetricK8sNodeUptime, descrMetricK8sNodeUptime,
unitMetricK8sNodeUptime);
}
/**
* Total CPU time consumed
* <p>
* Total CPU time consumed by the specific Pod on all available CPU cores
* <p>
* counter
*/
static constexpr const char *kMetricK8sPodCpuTime = "k8s.pod.cpu.time";
static constexpr const char *descrMetricK8sPodCpuTime = "Total CPU time consumed";
static constexpr const char *unitMetricK8sPodCpuTime = "s";
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricK8sPodCpuTime(
metrics::Meter *meter)
{
return meter->CreateUInt64Counter(kMetricK8sPodCpuTime, descrMetricK8sPodCpuTime,
unitMetricK8sPodCpuTime);
}
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricK8sPodCpuTime(
metrics::Meter *meter)
{
return meter->CreateDoubleCounter(kMetricK8sPodCpuTime, descrMetricK8sPodCpuTime,
unitMetricK8sPodCpuTime);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sPodCpuTime(
metrics::Meter *meter)
{
return meter->CreateInt64ObservableCounter(kMetricK8sPodCpuTime, descrMetricK8sPodCpuTime,
unitMetricK8sPodCpuTime);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricK8sPodCpuTime(
metrics::Meter *meter)
{
return meter->CreateDoubleObservableCounter(kMetricK8sPodCpuTime, descrMetricK8sPodCpuTime,
unitMetricK8sPodCpuTime);
}
/**
* Pod's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs
* <p>
* CPU usage of the specific Pod on all available CPU cores, averaged over the sample window
* <p>
* gauge
*/
static constexpr const char *kMetricK8sPodCpuUsage = "k8s.pod.cpu.usage";
static constexpr const char *descrMetricK8sPodCpuUsage =
"Pod's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs";
static constexpr const char *unitMetricK8sPodCpuUsage = "{cpu}";
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sPodCpuUsage(
metrics::Meter *meter)
{
return meter->CreateInt64Gauge(kMetricK8sPodCpuUsage, descrMetricK8sPodCpuUsage,
unitMetricK8sPodCpuUsage);
}
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sPodCpuUsage(
metrics::Meter *meter)
{
return meter->CreateDoubleGauge(kMetricK8sPodCpuUsage, descrMetricK8sPodCpuUsage,
unitMetricK8sPodCpuUsage);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sPodCpuUsage(
metrics::Meter *meter)
{
return meter->CreateInt64ObservableGauge(kMetricK8sPodCpuUsage, descrMetricK8sPodCpuUsage,
unitMetricK8sPodCpuUsage);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sPodCpuUsage(metrics::Meter *meter)
{
return meter->CreateDoubleObservableGauge(kMetricK8sPodCpuUsage, descrMetricK8sPodCpuUsage,
unitMetricK8sPodCpuUsage);
}
/**
* Memory usage of the Pod
* <p>
* Total memory usage of the Pod
* <p>
* gauge
*/
static constexpr const char *kMetricK8sPodMemoryUsage = "k8s.pod.memory.usage";
static constexpr const char *descrMetricK8sPodMemoryUsage = "Memory usage of the Pod";
static constexpr const char *unitMetricK8sPodMemoryUsage = "By";
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sPodMemoryUsage(
metrics::Meter *meter)
{
return meter->CreateInt64Gauge(kMetricK8sPodMemoryUsage, descrMetricK8sPodMemoryUsage,
unitMetricK8sPodMemoryUsage);
}
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sPodMemoryUsage(
metrics::Meter *meter)
{
return meter->CreateDoubleGauge(kMetricK8sPodMemoryUsage, descrMetricK8sPodMemoryUsage,
unitMetricK8sPodMemoryUsage);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sPodMemoryUsage(metrics::Meter *meter)
{
return meter->CreateInt64ObservableGauge(kMetricK8sPodMemoryUsage, descrMetricK8sPodMemoryUsage,
unitMetricK8sPodMemoryUsage);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sPodMemoryUsage(metrics::Meter *meter)
{
return meter->CreateDoubleObservableGauge(kMetricK8sPodMemoryUsage, descrMetricK8sPodMemoryUsage,
unitMetricK8sPodMemoryUsage);
}
/**
* Pod network errors
* <p>
* counter
*/
static constexpr const char *kMetricK8sPodNetworkErrors = "k8s.pod.network.errors";
static constexpr const char *descrMetricK8sPodNetworkErrors = "Pod network errors";
static constexpr const char *unitMetricK8sPodNetworkErrors = "{error}";
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
CreateSyncInt64MetricK8sPodNetworkErrors(metrics::Meter *meter)
{
return meter->CreateUInt64Counter(kMetricK8sPodNetworkErrors, descrMetricK8sPodNetworkErrors,
unitMetricK8sPodNetworkErrors);
}
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricK8sPodNetworkErrors(
metrics::Meter *meter)
{
return meter->CreateDoubleCounter(kMetricK8sPodNetworkErrors, descrMetricK8sPodNetworkErrors,
unitMetricK8sPodNetworkErrors);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sPodNetworkErrors(metrics::Meter *meter)
{
return meter->CreateInt64ObservableCounter(
kMetricK8sPodNetworkErrors, descrMetricK8sPodNetworkErrors, unitMetricK8sPodNetworkErrors);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sPodNetworkErrors(metrics::Meter *meter)
{
return meter->CreateDoubleObservableCounter(
kMetricK8sPodNetworkErrors, descrMetricK8sPodNetworkErrors, unitMetricK8sPodNetworkErrors);
}
/**
* Network bytes for the Pod
* <p>
* counter
*/
static constexpr const char *kMetricK8sPodNetworkIo = "k8s.pod.network.io";
static constexpr const char *descrMetricK8sPodNetworkIo = "Network bytes for the Pod";
static constexpr const char *unitMetricK8sPodNetworkIo = "By";
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricK8sPodNetworkIo(
metrics::Meter *meter)
{
return meter->CreateUInt64Counter(kMetricK8sPodNetworkIo, descrMetricK8sPodNetworkIo,
unitMetricK8sPodNetworkIo);
}
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricK8sPodNetworkIo(
metrics::Meter *meter)
{
return meter->CreateDoubleCounter(kMetricK8sPodNetworkIo, descrMetricK8sPodNetworkIo,
unitMetricK8sPodNetworkIo);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sPodNetworkIo(metrics::Meter *meter)
{
return meter->CreateInt64ObservableCounter(kMetricK8sPodNetworkIo, descrMetricK8sPodNetworkIo,
unitMetricK8sPodNetworkIo);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sPodNetworkIo(metrics::Meter *meter)
{
return meter->CreateDoubleObservableCounter(kMetricK8sPodNetworkIo, descrMetricK8sPodNetworkIo,
unitMetricK8sPodNetworkIo);
}
/**
* The time the Pod has been running
* <p>
* Instrumentations SHOULD use a gauge with type @code double @endcode and measure uptime in seconds
* as a floating point number with the highest precision available. The actual accuracy would depend
* on the instrumentation and operating system. <p> gauge
*/
static constexpr const char *kMetricK8sPodUptime = "k8s.pod.uptime";
static constexpr const char *descrMetricK8sPodUptime = "The time the Pod has been running";
static constexpr const char *unitMetricK8sPodUptime = "s";
#if OPENTELEMETRY_ABI_VERSION_NO >= 2
static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sPodUptime(
metrics::Meter *meter)
{
return meter->CreateInt64Gauge(kMetricK8sPodUptime, descrMetricK8sPodUptime,
unitMetricK8sPodUptime);
}
static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sPodUptime(
metrics::Meter *meter)
{
return meter->CreateDoubleGauge(kMetricK8sPodUptime, descrMetricK8sPodUptime,
unitMetricK8sPodUptime);
}
#endif /* OPENTELEMETRY_ABI_VERSION_NO */
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sPodUptime(
metrics::Meter *meter)
{
return meter->CreateInt64ObservableGauge(kMetricK8sPodUptime, descrMetricK8sPodUptime,
unitMetricK8sPodUptime);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricK8sPodUptime(
metrics::Meter *meter)
{
return meter->CreateDoubleObservableGauge(kMetricK8sPodUptime, descrMetricK8sPodUptime,
unitMetricK8sPodUptime);
}
/**
* Total number of available replica pods (ready for at least minReadySeconds) targeted by this
* replicaset <p> This metric aligns with the @code availableReplicas @endcode field of the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicasetstatus-v1-apps">K8s
* ReplicaSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#replicaset">@code k8s.replicaset @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sReplicasetAvailablePods = "k8s.replicaset.available_pods";
static constexpr const char *descrMetricK8sReplicasetAvailablePods =
"Total number of available replica pods (ready for at least minReadySeconds) targeted by this "
"replicaset";
static constexpr const char *unitMetricK8sReplicasetAvailablePods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sReplicasetAvailablePods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sReplicasetAvailablePods,
descrMetricK8sReplicasetAvailablePods,
unitMetricK8sReplicasetAvailablePods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sReplicasetAvailablePods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sReplicasetAvailablePods,
descrMetricK8sReplicasetAvailablePods,
unitMetricK8sReplicasetAvailablePods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sReplicasetAvailablePods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicasetAvailablePods,
descrMetricK8sReplicasetAvailablePods,
unitMetricK8sReplicasetAvailablePods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sReplicasetAvailablePods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicasetAvailablePods,
descrMetricK8sReplicasetAvailablePods,
unitMetricK8sReplicasetAvailablePods);
}
/**
* Number of desired replica pods in this replicaset
* <p>
* This metric aligns with the @code replicas @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicasetspec-v1-apps">K8s
* ReplicaSetSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#replicaset">@code k8s.replicaset @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sReplicasetDesiredPods = "k8s.replicaset.desired_pods";
static constexpr const char *descrMetricK8sReplicasetDesiredPods =
"Number of desired replica pods in this replicaset";
static constexpr const char *unitMetricK8sReplicasetDesiredPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sReplicasetDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sReplicasetDesiredPods,
descrMetricK8sReplicasetDesiredPods,
unitMetricK8sReplicasetDesiredPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sReplicasetDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sReplicasetDesiredPods,
descrMetricK8sReplicasetDesiredPods,
unitMetricK8sReplicasetDesiredPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sReplicasetDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicasetDesiredPods,
descrMetricK8sReplicasetDesiredPods,
unitMetricK8sReplicasetDesiredPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sReplicasetDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicasetDesiredPods,
descrMetricK8sReplicasetDesiredPods,
unitMetricK8sReplicasetDesiredPods);
}
/**
* Deprecated, use @code k8s.replicationcontroller.available_pods @endcode instead.
*
* @deprecated
* {"note": "Replaced by @code k8s.replicationcontroller.available_pods @endcode.", "reason":
* "uncategorized"} <p> This metric aligns with the @code availableReplicas @endcode field of the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerstatus-v1-core">K8s
* ReplicationControllerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
* resource. <p> updowncounter
*/
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicationControllerAvailablePods =
"k8s.replication_controller.available_pods";
OPENTELEMETRY_DEPRECATED static constexpr const char
*descrMetricK8sReplicationControllerAvailablePods =
"Deprecated, use `k8s.replicationcontroller.available_pods` instead.";
OPENTELEMETRY_DEPRECATED static constexpr const char
*unitMetricK8sReplicationControllerAvailablePods = "{pod}";
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sReplicationControllerAvailablePods,
descrMetricK8sReplicationControllerAvailablePods,
unitMetricK8sReplicationControllerAvailablePods);
}
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationControllerAvailablePods,
descrMetricK8sReplicationControllerAvailablePods,
unitMetricK8sReplicationControllerAvailablePods);
}
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationControllerAvailablePods,
descrMetricK8sReplicationControllerAvailablePods,
unitMetricK8sReplicationControllerAvailablePods);
}
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(
kMetricK8sReplicationControllerAvailablePods,
descrMetricK8sReplicationControllerAvailablePods,
unitMetricK8sReplicationControllerAvailablePods);
}
/**
* Deprecated, use @code k8s.replicationcontroller.desired_pods @endcode instead.
*
* @deprecated
* {"note": "Replaced by @code k8s.replicationcontroller.desired_pods @endcode.", "reason":
* "uncategorized"} <p> This metric aligns with the @code replicas @endcode field of the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerspec-v1-core">K8s
* ReplicationControllerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
* resource. <p> updowncounter
*/
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicationControllerDesiredPods =
"k8s.replication_controller.desired_pods";
OPENTELEMETRY_DEPRECATED static constexpr const char
*descrMetricK8sReplicationControllerDesiredPods =
"Deprecated, use `k8s.replicationcontroller.desired_pods` instead.";
OPENTELEMETRY_DEPRECATED static constexpr const char
*unitMetricK8sReplicationControllerDesiredPods = "{pod}";
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sReplicationControllerDesiredPods,
descrMetricK8sReplicationControllerDesiredPods,
unitMetricK8sReplicationControllerDesiredPods);
}
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationControllerDesiredPods,
descrMetricK8sReplicationControllerDesiredPods,
unitMetricK8sReplicationControllerDesiredPods);
}
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationControllerDesiredPods,
descrMetricK8sReplicationControllerDesiredPods,
unitMetricK8sReplicationControllerDesiredPods);
}
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicationControllerDesiredPods,
descrMetricK8sReplicationControllerDesiredPods,
unitMetricK8sReplicationControllerDesiredPods);
}
/**
* Total number of available replica pods (ready for at least minReadySeconds) targeted by this
* replication controller <p> This metric aligns with the @code availableReplicas @endcode field of
* the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerstatus-v1-core">K8s
* ReplicationControllerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
* resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sReplicationcontrollerAvailablePods =
"k8s.replicationcontroller.available_pods";
static constexpr const char *descrMetricK8sReplicationcontrollerAvailablePods =
"Total number of available replica pods (ready for at least minReadySeconds) targeted by this "
"replication controller";
static constexpr const char *unitMetricK8sReplicationcontrollerAvailablePods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sReplicationcontrollerAvailablePods,
descrMetricK8sReplicationcontrollerAvailablePods,
unitMetricK8sReplicationcontrollerAvailablePods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationcontrollerAvailablePods,
descrMetricK8sReplicationcontrollerAvailablePods,
unitMetricK8sReplicationcontrollerAvailablePods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationcontrollerAvailablePods,
descrMetricK8sReplicationcontrollerAvailablePods,
unitMetricK8sReplicationcontrollerAvailablePods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(
kMetricK8sReplicationcontrollerAvailablePods,
descrMetricK8sReplicationcontrollerAvailablePods,
unitMetricK8sReplicationcontrollerAvailablePods);
}
/**
* Number of desired replica pods in this replication controller
* <p>
* This metric aligns with the @code replicas @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerspec-v1-core">K8s
* ReplicationControllerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
* resource. <p> updowncounter
*/
static constexpr const char *kMetricK8sReplicationcontrollerDesiredPods =
"k8s.replicationcontroller.desired_pods";
static constexpr const char *descrMetricK8sReplicationcontrollerDesiredPods =
"Number of desired replica pods in this replication controller";
static constexpr const char *unitMetricK8sReplicationcontrollerDesiredPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
descrMetricK8sReplicationcontrollerDesiredPods,
unitMetricK8sReplicationcontrollerDesiredPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
descrMetricK8sReplicationcontrollerDesiredPods,
unitMetricK8sReplicationcontrollerDesiredPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
descrMetricK8sReplicationcontrollerDesiredPods,
unitMetricK8sReplicationcontrollerDesiredPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
descrMetricK8sReplicationcontrollerDesiredPods,
unitMetricK8sReplicationcontrollerDesiredPods);
}
/**
* The number of replica pods created by the statefulset controller from the statefulset version
* indicated by currentRevision <p> This metric aligns with the @code currentReplicas @endcode field
* of the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps">K8s
* StatefulSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#statefulset">@code k8s.statefulset @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sStatefulsetCurrentPods = "k8s.statefulset.current_pods";
static constexpr const char *descrMetricK8sStatefulsetCurrentPods =
"The number of replica pods created by the statefulset controller from the statefulset version "
"indicated by currentRevision";
static constexpr const char *unitMetricK8sStatefulsetCurrentPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sStatefulsetCurrentPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetCurrentPods,
descrMetricK8sStatefulsetCurrentPods,
unitMetricK8sStatefulsetCurrentPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sStatefulsetCurrentPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetCurrentPods,
descrMetricK8sStatefulsetCurrentPods,
unitMetricK8sStatefulsetCurrentPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sStatefulsetCurrentPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetCurrentPods,
descrMetricK8sStatefulsetCurrentPods,
unitMetricK8sStatefulsetCurrentPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sStatefulsetCurrentPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetCurrentPods,
descrMetricK8sStatefulsetCurrentPods,
unitMetricK8sStatefulsetCurrentPods);
}
/**
* Number of desired replica pods in this statefulset
* <p>
* This metric aligns with the @code replicas @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetspec-v1-apps">K8s
* StatefulSetSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#statefulset">@code k8s.statefulset @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sStatefulsetDesiredPods = "k8s.statefulset.desired_pods";
static constexpr const char *descrMetricK8sStatefulsetDesiredPods =
"Number of desired replica pods in this statefulset";
static constexpr const char *unitMetricK8sStatefulsetDesiredPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sStatefulsetDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetDesiredPods,
descrMetricK8sStatefulsetDesiredPods,
unitMetricK8sStatefulsetDesiredPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sStatefulsetDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetDesiredPods,
descrMetricK8sStatefulsetDesiredPods,
unitMetricK8sStatefulsetDesiredPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sStatefulsetDesiredPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetDesiredPods,
descrMetricK8sStatefulsetDesiredPods,
unitMetricK8sStatefulsetDesiredPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sStatefulsetDesiredPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetDesiredPods,
descrMetricK8sStatefulsetDesiredPods,
unitMetricK8sStatefulsetDesiredPods);
}
/**
* The number of replica pods created for this statefulset with a Ready Condition
* <p>
* This metric aligns with the @code readyReplicas @endcode field of the
* <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps">K8s
* StatefulSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#statefulset">@code k8s.statefulset @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sStatefulsetReadyPods = "k8s.statefulset.ready_pods";
static constexpr const char *descrMetricK8sStatefulsetReadyPods =
"The number of replica pods created for this statefulset with a Ready Condition";
static constexpr const char *unitMetricK8sStatefulsetReadyPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sStatefulsetReadyPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetReadyPods,
descrMetricK8sStatefulsetReadyPods,
unitMetricK8sStatefulsetReadyPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sStatefulsetReadyPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetReadyPods,
descrMetricK8sStatefulsetReadyPods,
unitMetricK8sStatefulsetReadyPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sStatefulsetReadyPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetReadyPods,
descrMetricK8sStatefulsetReadyPods,
unitMetricK8sStatefulsetReadyPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sStatefulsetReadyPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetReadyPods,
descrMetricK8sStatefulsetReadyPods,
unitMetricK8sStatefulsetReadyPods);
}
/**
* Number of replica pods created by the statefulset controller from the statefulset version
* indicated by updateRevision <p> This metric aligns with the @code updatedReplicas @endcode field
* of the <a
* href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps">K8s
* StatefulSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
* href="../resource/k8s.md#statefulset">@code k8s.statefulset @endcode</a> resource. <p>
* updowncounter
*/
static constexpr const char *kMetricK8sStatefulsetUpdatedPods = "k8s.statefulset.updated_pods";
static constexpr const char *descrMetricK8sStatefulsetUpdatedPods =
"Number of replica pods created by the statefulset controller from the statefulset version "
"indicated by updateRevision";
static constexpr const char *unitMetricK8sStatefulsetUpdatedPods = "{pod}";
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
CreateSyncInt64MetricK8sStatefulsetUpdatedPods(metrics::Meter *meter)
{
return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetUpdatedPods,
descrMetricK8sStatefulsetUpdatedPods,
unitMetricK8sStatefulsetUpdatedPods);
}
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
CreateSyncDoubleMetricK8sStatefulsetUpdatedPods(metrics::Meter *meter)
{
return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetUpdatedPods,
descrMetricK8sStatefulsetUpdatedPods,
unitMetricK8sStatefulsetUpdatedPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncInt64MetricK8sStatefulsetUpdatedPods(metrics::Meter *meter)
{
return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetUpdatedPods,
descrMetricK8sStatefulsetUpdatedPods,
unitMetricK8sStatefulsetUpdatedPods);
}
static inline nostd::shared_ptr<metrics::ObservableInstrument>
CreateAsyncDoubleMetricK8sStatefulsetUpdatedPods(metrics::Meter *meter)
{
return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetUpdatedPods,
descrMetricK8sStatefulsetUpdatedPods,
unitMetricK8sStatefulsetUpdatedPods);
}
} // namespace k8s
} // namespace semconv
OPENTELEMETRY_END_NAMESPACE