9.2/includes/opentelemetry/semconv/incubating/cicd_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 cicd
{
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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