[SEMANTIC CONVENTIONS] Upgrade semantic conventions to 1.31.0

api/include/opentelemetry/semconv/azure_metrics.h

@@ -0,0 +1,97 @@
+/*
+ * 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 azure
+{
+
+/**
+ * Number of active client instances
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricAzureCosmosdbClientActiveInstanceCount =
+    "azure.cosmosdb.client.active_instance.count";
+static constexpr const char *descrMetricAzureCosmosdbClientActiveInstanceCount =
+    "Number of active client instances";
+static constexpr const char *unitMetricAzureCosmosdbClientActiveInstanceCount = "{instance}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricAzureCosmosdbClientActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricAzureCosmosdbClientActiveInstanceCount,
+                                         descrMetricAzureCosmosdbClientActiveInstanceCount,
+                                         unitMetricAzureCosmosdbClientActiveInstanceCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricAzureCosmosdbClientActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricAzureCosmosdbClientActiveInstanceCount,
+                                          descrMetricAzureCosmosdbClientActiveInstanceCount,
+                                          unitMetricAzureCosmosdbClientActiveInstanceCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricAzureCosmosdbClientActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricAzureCosmosdbClientActiveInstanceCount,
+      descrMetricAzureCosmosdbClientActiveInstanceCount,
+      unitMetricAzureCosmosdbClientActiveInstanceCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricAzureCosmosdbClientActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricAzureCosmosdbClientActiveInstanceCount,
+      descrMetricAzureCosmosdbClientActiveInstanceCount,
+      unitMetricAzureCosmosdbClientActiveInstanceCount);
+}
+
+/**
+ * <a href="https://learn.microsoft.com/azure/cosmos-db/request-units">Request units</a> consumed by
+ * the operation <p> histogram
+ */
+static constexpr const char *kMetricAzureCosmosdbClientOperationRequestCharge =
+    "azure.cosmosdb.client.operation.request_charge";
+static constexpr const char *descrMetricAzureCosmosdbClientOperationRequestCharge =
+    "[Request units](https://learn.microsoft.com/azure/cosmos-db/request-units) consumed by the "
+    "operation";
+static constexpr const char *unitMetricAzureCosmosdbClientOperationRequestCharge = "{request_unit}";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricAzureCosmosdbClientOperationRequestCharge(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricAzureCosmosdbClientOperationRequestCharge,
+                                      descrMetricAzureCosmosdbClientOperationRequestCharge,
+                                      unitMetricAzureCosmosdbClientOperationRequestCharge);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricAzureCosmosdbClientOperationRequestCharge(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricAzureCosmosdbClientOperationRequestCharge,
+                                      descrMetricAzureCosmosdbClientOperationRequestCharge,
+                                      unitMetricAzureCosmosdbClientOperationRequestCharge);
+}
+
+}  // namespace azure
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE

api/include/opentelemetry/semconv/cicd_metrics.h

@@ -0,0 +1,213 @@
+/*
+ * 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 cicd
+{
+
+/**
+ * The number of pipeline runs currently active in the system by state.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricCicdPipelineRunActive = "cicd.pipeline.run.active";
+static constexpr const char *descrMetricCicdPipelineRunActive =
+    "The number of pipeline runs currently active in the system by state.";
+static constexpr const char *unitMetricCicdPipelineRunActive = "{run}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricCicdPipelineRunActive(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricCicdPipelineRunActive,
+                                         descrMetricCicdPipelineRunActive,
+                                         unitMetricCicdPipelineRunActive);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricCicdPipelineRunActive(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricCicdPipelineRunActive,
+                                          descrMetricCicdPipelineRunActive,
+                                          unitMetricCicdPipelineRunActive);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricCicdPipelineRunActive(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricCicdPipelineRunActive,
+                                                   descrMetricCicdPipelineRunActive,
+                                                   unitMetricCicdPipelineRunActive);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricCicdPipelineRunActive(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricCicdPipelineRunActive,
+                                                    descrMetricCicdPipelineRunActive,
+                                                    unitMetricCicdPipelineRunActive);
+}
+
+/**
+ * Duration of a pipeline run grouped by pipeline, state and result.
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricCicdPipelineRunDuration = "cicd.pipeline.run.duration";
+static constexpr const char *descrMetricCicdPipelineRunDuration =
+    "Duration of a pipeline run grouped by pipeline, state and result.";
+static constexpr const char *unitMetricCicdPipelineRunDuration = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricCicdPipelineRunDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricCicdPipelineRunDuration,
+                                      descrMetricCicdPipelineRunDuration,
+                                      unitMetricCicdPipelineRunDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricCicdPipelineRunDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricCicdPipelineRunDuration,
+                                      descrMetricCicdPipelineRunDuration,
+                                      unitMetricCicdPipelineRunDuration);
+}
+
+/**
+ * The number of errors encountered in pipeline runs (eg. compile, test failures).
+ * <p>
+ * There might be errors in a pipeline run that are non fatal (eg. they are suppressed) or in a
+ * parallel stage multiple stages could have a fatal error. This means that this error count might
+ * not be the same as the count of metric @code cicd.pipeline.run.duration @endcode with run result
+ * @code failure @endcode. <p> counter
+ */
+static constexpr const char *kMetricCicdPipelineRunErrors = "cicd.pipeline.run.errors";
+static constexpr const char *descrMetricCicdPipelineRunErrors =
+    "The number of errors encountered in pipeline runs (eg. compile, test failures).";
+static constexpr const char *unitMetricCicdPipelineRunErrors = "{error}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricCicdPipelineRunErrors(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricCicdPipelineRunErrors, descrMetricCicdPipelineRunErrors,
+                                    unitMetricCicdPipelineRunErrors);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricCicdPipelineRunErrors(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricCicdPipelineRunErrors, descrMetricCicdPipelineRunErrors,
+                                    unitMetricCicdPipelineRunErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricCicdPipelineRunErrors(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricCicdPipelineRunErrors,
+                                             descrMetricCicdPipelineRunErrors,
+                                             unitMetricCicdPipelineRunErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricCicdPipelineRunErrors(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricCicdPipelineRunErrors,
+                                              descrMetricCicdPipelineRunErrors,
+                                              unitMetricCicdPipelineRunErrors);
+}
+
+/**
+ * The number of errors in a component of the CICD system (eg. controller, scheduler, agent).
+ * <p>
+ * Errors in pipeline run execution are explicitly excluded. Ie a test failure is not counted in
+ * this metric. <p> counter
+ */
+static constexpr const char *kMetricCicdSystemErrors = "cicd.system.errors";
+static constexpr const char *descrMetricCicdSystemErrors =
+    "The number of errors in a component of the CICD system (eg. controller, scheduler, agent).";
+static constexpr const char *unitMetricCicdSystemErrors = "{error}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricCicdSystemErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricCicdSystemErrors, descrMetricCicdSystemErrors,
+                                    unitMetricCicdSystemErrors);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricCicdSystemErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricCicdSystemErrors, descrMetricCicdSystemErrors,
+                                    unitMetricCicdSystemErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricCicdSystemErrors(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricCicdSystemErrors, descrMetricCicdSystemErrors,
+                                             unitMetricCicdSystemErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricCicdSystemErrors(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricCicdSystemErrors, descrMetricCicdSystemErrors,
+                                              unitMetricCicdSystemErrors);
+}
+
+/**
+ * The number of workers on the CICD system by state.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricCicdWorkerCount = "cicd.worker.count";
+static constexpr const char *descrMetricCicdWorkerCount =
+    "The number of workers on the CICD system by state.";
+static constexpr const char *unitMetricCicdWorkerCount = "{count}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricCicdWorkerCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricCicdWorkerCount, descrMetricCicdWorkerCount,
+                                         unitMetricCicdWorkerCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricCicdWorkerCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricCicdWorkerCount, descrMetricCicdWorkerCount,
+                                          unitMetricCicdWorkerCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricCicdWorkerCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricCicdWorkerCount, descrMetricCicdWorkerCount, unitMetricCicdWorkerCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricCicdWorkerCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricCicdWorkerCount, descrMetricCicdWorkerCount, unitMetricCicdWorkerCount);
+}
+
+}  // namespace cicd
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE