mirror of
https://github.com/zerotier/ZeroTierOne.git
synced 2025-09-09 08:12:52 +02:00
976 lines
47 KiB
C++
976 lines
47 KiB
C++
/*
|
|
* 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 otel
|
|
{
|
|
|
|
/**
|
|
The number of log records for which the export has finished, either successful or failed
|
|
<p>
|
|
For successful exports, @code error.type @endcode MUST NOT be set. For failed exports, @code
|
|
error.type @endcode MUST contain the failure cause. For exporters with partial success semantics
|
|
(e.g. OTLP with @code rejected_log_records @endcode), rejected log records MUST count as failed
|
|
and only non-rejected log records count as success. If no rejection reason is available, @code
|
|
rejected @endcode SHOULD be used as value for @code error.type @endcode. <p> counter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkExporterLogExported = "otel.sdk.exporter.log.exported";
|
|
static constexpr const char *descrMetricOtelSdkExporterLogExported =
|
|
"The number of log records for which the export has finished, either successful or failed";
|
|
static constexpr const char *unitMetricOtelSdkExporterLogExported = "{log_record}";
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
|
|
CreateSyncInt64MetricOtelSdkExporterLogExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Counter(kMetricOtelSdkExporterLogExported,
|
|
descrMetricOtelSdkExporterLogExported,
|
|
unitMetricOtelSdkExporterLogExported);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<double>>
|
|
CreateSyncDoubleMetricOtelSdkExporterLogExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleCounter(kMetricOtelSdkExporterLogExported,
|
|
descrMetricOtelSdkExporterLogExported,
|
|
unitMetricOtelSdkExporterLogExported);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkExporterLogExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableCounter(kMetricOtelSdkExporterLogExported,
|
|
descrMetricOtelSdkExporterLogExported,
|
|
unitMetricOtelSdkExporterLogExported);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkExporterLogExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableCounter(kMetricOtelSdkExporterLogExported,
|
|
descrMetricOtelSdkExporterLogExported,
|
|
unitMetricOtelSdkExporterLogExported);
|
|
}
|
|
|
|
/**
|
|
The number of log records which were passed to the exporter, but that have not been exported yet
|
|
(neither successful, nor failed) <p> For successful exports, @code error.type @endcode MUST NOT be
|
|
set. For failed exports, @code error.type @endcode MUST contain the failure cause. <p>
|
|
updowncounter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkExporterLogInflight = "otel.sdk.exporter.log.inflight";
|
|
static constexpr const char *descrMetricOtelSdkExporterLogInflight =
|
|
"The number of log records which were passed to the exporter, but that have not been exported "
|
|
"yet (neither successful, nor failed)";
|
|
static constexpr const char *unitMetricOtelSdkExporterLogInflight = "{log_record}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkExporterLogInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkExporterLogInflight,
|
|
descrMetricOtelSdkExporterLogInflight,
|
|
unitMetricOtelSdkExporterLogInflight);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkExporterLogInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkExporterLogInflight,
|
|
descrMetricOtelSdkExporterLogInflight,
|
|
unitMetricOtelSdkExporterLogInflight);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkExporterLogInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkExporterLogInflight,
|
|
descrMetricOtelSdkExporterLogInflight,
|
|
unitMetricOtelSdkExporterLogInflight);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkExporterLogInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkExporterLogInflight,
|
|
descrMetricOtelSdkExporterLogInflight,
|
|
unitMetricOtelSdkExporterLogInflight);
|
|
}
|
|
|
|
/**
|
|
The number of metric data points for which the export has finished, either successful or failed
|
|
<p>
|
|
For successful exports, @code error.type @endcode MUST NOT be set. For failed exports, @code
|
|
error.type @endcode MUST contain the failure cause. For exporters with partial success semantics
|
|
(e.g. OTLP with @code rejected_data_points @endcode), rejected data points MUST count as failed
|
|
and only non-rejected data points count as success. If no rejection reason is available, @code
|
|
rejected @endcode SHOULD be used as value for @code error.type @endcode. <p> counter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkExporterMetricDataPointExported =
|
|
"otel.sdk.exporter.metric_data_point.exported";
|
|
static constexpr const char *descrMetricOtelSdkExporterMetricDataPointExported =
|
|
"The number of metric data points for which the export has finished, either successful or "
|
|
"failed";
|
|
static constexpr const char *unitMetricOtelSdkExporterMetricDataPointExported = "{data_point}";
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
|
|
CreateSyncInt64MetricOtelSdkExporterMetricDataPointExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Counter(kMetricOtelSdkExporterMetricDataPointExported,
|
|
descrMetricOtelSdkExporterMetricDataPointExported,
|
|
unitMetricOtelSdkExporterMetricDataPointExported);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<double>>
|
|
CreateSyncDoubleMetricOtelSdkExporterMetricDataPointExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleCounter(kMetricOtelSdkExporterMetricDataPointExported,
|
|
descrMetricOtelSdkExporterMetricDataPointExported,
|
|
unitMetricOtelSdkExporterMetricDataPointExported);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkExporterMetricDataPointExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableCounter(kMetricOtelSdkExporterMetricDataPointExported,
|
|
descrMetricOtelSdkExporterMetricDataPointExported,
|
|
unitMetricOtelSdkExporterMetricDataPointExported);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkExporterMetricDataPointExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableCounter(kMetricOtelSdkExporterMetricDataPointExported,
|
|
descrMetricOtelSdkExporterMetricDataPointExported,
|
|
unitMetricOtelSdkExporterMetricDataPointExported);
|
|
}
|
|
|
|
/**
|
|
The number of metric data points which were passed to the exporter, but that have not been
|
|
exported yet (neither successful, nor failed) <p> For successful exports, @code error.type
|
|
@endcode MUST NOT be set. For failed exports, @code error.type @endcode MUST contain the failure
|
|
cause. <p> updowncounter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkExporterMetricDataPointInflight =
|
|
"otel.sdk.exporter.metric_data_point.inflight";
|
|
static constexpr const char *descrMetricOtelSdkExporterMetricDataPointInflight =
|
|
"The number of metric data points which were passed to the exporter, but that have not been "
|
|
"exported yet (neither successful, nor failed)";
|
|
static constexpr const char *unitMetricOtelSdkExporterMetricDataPointInflight = "{data_point}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkExporterMetricDataPointInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkExporterMetricDataPointInflight,
|
|
descrMetricOtelSdkExporterMetricDataPointInflight,
|
|
unitMetricOtelSdkExporterMetricDataPointInflight);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkExporterMetricDataPointInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkExporterMetricDataPointInflight,
|
|
descrMetricOtelSdkExporterMetricDataPointInflight,
|
|
unitMetricOtelSdkExporterMetricDataPointInflight);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkExporterMetricDataPointInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(
|
|
kMetricOtelSdkExporterMetricDataPointInflight,
|
|
descrMetricOtelSdkExporterMetricDataPointInflight,
|
|
unitMetricOtelSdkExporterMetricDataPointInflight);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkExporterMetricDataPointInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(
|
|
kMetricOtelSdkExporterMetricDataPointInflight,
|
|
descrMetricOtelSdkExporterMetricDataPointInflight,
|
|
unitMetricOtelSdkExporterMetricDataPointInflight);
|
|
}
|
|
|
|
/**
|
|
The duration of exporting a batch of telemetry records.
|
|
<p>
|
|
This metric defines successful operations using the full success definitions for <a
|
|
href="https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success-1">http</a>
|
|
and <a
|
|
href="https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success">grpc</a>.
|
|
Anything else is defined as an unsuccessful operation. For successful operations, @code error.type
|
|
@endcode MUST NOT be set. For unsuccessful export operations, @code error.type @endcode MUST
|
|
contain a relevant failure cause. <p> histogram
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkExporterOperationDuration =
|
|
"otel.sdk.exporter.operation.duration";
|
|
static constexpr const char *descrMetricOtelSdkExporterOperationDuration =
|
|
"The duration of exporting a batch of telemetry records.";
|
|
static constexpr const char *unitMetricOtelSdkExporterOperationDuration = "s";
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricOtelSdkExporterOperationDuration(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricOtelSdkExporterOperationDuration,
|
|
descrMetricOtelSdkExporterOperationDuration,
|
|
unitMetricOtelSdkExporterOperationDuration);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricOtelSdkExporterOperationDuration(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricOtelSdkExporterOperationDuration,
|
|
descrMetricOtelSdkExporterOperationDuration,
|
|
unitMetricOtelSdkExporterOperationDuration);
|
|
}
|
|
|
|
/**
|
|
The number of spans for which the export has finished, either successful or failed
|
|
<p>
|
|
For successful exports, @code error.type @endcode MUST NOT be set. For failed exports, @code
|
|
error.type @endcode MUST contain the failure cause. For exporters with partial success semantics
|
|
(e.g. OTLP with @code rejected_spans @endcode), rejected spans MUST count as failed and only
|
|
non-rejected spans count as success. If no rejection reason is available, @code rejected @endcode
|
|
SHOULD be used as value for @code error.type @endcode. <p> counter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkExporterSpanExported = "otel.sdk.exporter.span.exported";
|
|
static constexpr const char *descrMetricOtelSdkExporterSpanExported =
|
|
"The number of spans for which the export has finished, either successful or failed";
|
|
static constexpr const char *unitMetricOtelSdkExporterSpanExported = "{span}";
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
|
|
CreateSyncInt64MetricOtelSdkExporterSpanExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Counter(kMetricOtelSdkExporterSpanExported,
|
|
descrMetricOtelSdkExporterSpanExported,
|
|
unitMetricOtelSdkExporterSpanExported);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<double>>
|
|
CreateSyncDoubleMetricOtelSdkExporterSpanExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleCounter(kMetricOtelSdkExporterSpanExported,
|
|
descrMetricOtelSdkExporterSpanExported,
|
|
unitMetricOtelSdkExporterSpanExported);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkExporterSpanExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableCounter(kMetricOtelSdkExporterSpanExported,
|
|
descrMetricOtelSdkExporterSpanExported,
|
|
unitMetricOtelSdkExporterSpanExported);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkExporterSpanExported(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableCounter(kMetricOtelSdkExporterSpanExported,
|
|
descrMetricOtelSdkExporterSpanExported,
|
|
unitMetricOtelSdkExporterSpanExported);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code otel.sdk.exporter.span.exported @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code otel.sdk.exporter.span.exported @endcode.", "reason": "renamed",
|
|
"renamed_to": "otel.sdk.exporter.span.exported"} <p> updowncounter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricOtelSdkExporterSpanExportedCount =
|
|
"otel.sdk.exporter.span.exported.count";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricOtelSdkExporterSpanExportedCount =
|
|
"Deprecated, use `otel.sdk.exporter.span.exported` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricOtelSdkExporterSpanExportedCount =
|
|
"{span}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkExporterSpanExportedCount,
|
|
descrMetricOtelSdkExporterSpanExportedCount,
|
|
unitMetricOtelSdkExporterSpanExportedCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkExporterSpanExportedCount,
|
|
descrMetricOtelSdkExporterSpanExportedCount,
|
|
unitMetricOtelSdkExporterSpanExportedCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkExporterSpanExportedCount,
|
|
descrMetricOtelSdkExporterSpanExportedCount,
|
|
unitMetricOtelSdkExporterSpanExportedCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkExporterSpanExportedCount,
|
|
descrMetricOtelSdkExporterSpanExportedCount,
|
|
unitMetricOtelSdkExporterSpanExportedCount);
|
|
}
|
|
|
|
/**
|
|
The number of spans which were passed to the exporter, but that have not been exported yet
|
|
(neither successful, nor failed) <p> For successful exports, @code error.type @endcode MUST NOT be
|
|
set. For failed exports, @code error.type @endcode MUST contain the failure cause. <p>
|
|
updowncounter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkExporterSpanInflight = "otel.sdk.exporter.span.inflight";
|
|
static constexpr const char *descrMetricOtelSdkExporterSpanInflight =
|
|
"The number of spans which were passed to the exporter, but that have not been exported yet "
|
|
"(neither successful, nor failed)";
|
|
static constexpr const char *unitMetricOtelSdkExporterSpanInflight = "{span}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkExporterSpanInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkExporterSpanInflight,
|
|
descrMetricOtelSdkExporterSpanInflight,
|
|
unitMetricOtelSdkExporterSpanInflight);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkExporterSpanInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkExporterSpanInflight,
|
|
descrMetricOtelSdkExporterSpanInflight,
|
|
unitMetricOtelSdkExporterSpanInflight);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkExporterSpanInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkExporterSpanInflight,
|
|
descrMetricOtelSdkExporterSpanInflight,
|
|
unitMetricOtelSdkExporterSpanInflight);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkExporterSpanInflight(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkExporterSpanInflight,
|
|
descrMetricOtelSdkExporterSpanInflight,
|
|
unitMetricOtelSdkExporterSpanInflight);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code otel.sdk.exporter.span.inflight @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code otel.sdk.exporter.span.inflight @endcode.", "reason": "renamed",
|
|
"renamed_to": "otel.sdk.exporter.span.inflight"} <p> updowncounter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricOtelSdkExporterSpanInflightCount =
|
|
"otel.sdk.exporter.span.inflight.count";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricOtelSdkExporterSpanInflightCount =
|
|
"Deprecated, use `otel.sdk.exporter.span.inflight` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricOtelSdkExporterSpanInflightCount =
|
|
"{span}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
|
|
descrMetricOtelSdkExporterSpanInflightCount,
|
|
unitMetricOtelSdkExporterSpanInflightCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
|
|
descrMetricOtelSdkExporterSpanInflightCount,
|
|
unitMetricOtelSdkExporterSpanInflightCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
|
|
descrMetricOtelSdkExporterSpanInflightCount,
|
|
unitMetricOtelSdkExporterSpanInflightCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
|
|
descrMetricOtelSdkExporterSpanInflightCount,
|
|
unitMetricOtelSdkExporterSpanInflightCount);
|
|
}
|
|
|
|
/**
|
|
The number of logs submitted to enabled SDK Loggers
|
|
<p>
|
|
counter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkLogCreated = "otel.sdk.log.created";
|
|
static constexpr const char *descrMetricOtelSdkLogCreated =
|
|
"The number of logs submitted to enabled SDK Loggers";
|
|
static constexpr const char *unitMetricOtelSdkLogCreated = "{log_record}";
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricOtelSdkLogCreated(
|
|
metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Counter(kMetricOtelSdkLogCreated, descrMetricOtelSdkLogCreated,
|
|
unitMetricOtelSdkLogCreated);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricOtelSdkLogCreated(
|
|
metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleCounter(kMetricOtelSdkLogCreated, descrMetricOtelSdkLogCreated,
|
|
unitMetricOtelSdkLogCreated);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkLogCreated(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableCounter(kMetricOtelSdkLogCreated, descrMetricOtelSdkLogCreated,
|
|
unitMetricOtelSdkLogCreated);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkLogCreated(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableCounter(
|
|
kMetricOtelSdkLogCreated, descrMetricOtelSdkLogCreated, unitMetricOtelSdkLogCreated);
|
|
}
|
|
|
|
/**
|
|
The duration of the collect operation of the metric reader.
|
|
<p>
|
|
For successful collections, @code error.type @endcode MUST NOT be set. For failed collections,
|
|
@code error.type @endcode SHOULD contain the failure cause. It can happen that metrics collection
|
|
is successful for some MetricProducers, while others fail. In that case @code error.type @endcode
|
|
SHOULD be set to any of the failure causes. <p> histogram
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkMetricReaderCollectionDuration =
|
|
"otel.sdk.metric_reader.collection.duration";
|
|
static constexpr const char *descrMetricOtelSdkMetricReaderCollectionDuration =
|
|
"The duration of the collect operation of the metric reader.";
|
|
static constexpr const char *unitMetricOtelSdkMetricReaderCollectionDuration = "s";
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricOtelSdkMetricReaderCollectionDuration(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricOtelSdkMetricReaderCollectionDuration,
|
|
descrMetricOtelSdkMetricReaderCollectionDuration,
|
|
unitMetricOtelSdkMetricReaderCollectionDuration);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricOtelSdkMetricReaderCollectionDuration(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricOtelSdkMetricReaderCollectionDuration,
|
|
descrMetricOtelSdkMetricReaderCollectionDuration,
|
|
unitMetricOtelSdkMetricReaderCollectionDuration);
|
|
}
|
|
|
|
/**
|
|
The number of log records for which the processing has finished, either successful or failed
|
|
<p>
|
|
For successful processing, @code error.type @endcode MUST NOT be set. For failed processing, @code
|
|
error.type @endcode MUST contain the failure cause. For the SDK Simple and Batching Log Record
|
|
Processor a log record is considered to be processed already when it has been submitted to the
|
|
exporter, not when the corresponding export call has finished. <p> counter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkProcessorLogProcessed =
|
|
"otel.sdk.processor.log.processed";
|
|
static constexpr const char *descrMetricOtelSdkProcessorLogProcessed =
|
|
"The number of log records for which the processing has finished, either successful or failed";
|
|
static constexpr const char *unitMetricOtelSdkProcessorLogProcessed = "{log_record}";
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
|
|
CreateSyncInt64MetricOtelSdkProcessorLogProcessed(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Counter(kMetricOtelSdkProcessorLogProcessed,
|
|
descrMetricOtelSdkProcessorLogProcessed,
|
|
unitMetricOtelSdkProcessorLogProcessed);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<double>>
|
|
CreateSyncDoubleMetricOtelSdkProcessorLogProcessed(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleCounter(kMetricOtelSdkProcessorLogProcessed,
|
|
descrMetricOtelSdkProcessorLogProcessed,
|
|
unitMetricOtelSdkProcessorLogProcessed);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkProcessorLogProcessed(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableCounter(kMetricOtelSdkProcessorLogProcessed,
|
|
descrMetricOtelSdkProcessorLogProcessed,
|
|
unitMetricOtelSdkProcessorLogProcessed);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkProcessorLogProcessed(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableCounter(kMetricOtelSdkProcessorLogProcessed,
|
|
descrMetricOtelSdkProcessorLogProcessed,
|
|
unitMetricOtelSdkProcessorLogProcessed);
|
|
}
|
|
|
|
/**
|
|
The maximum number of log records the queue of a given instance of an SDK Log Record processor can
|
|
hold <p> Only applies to Log Record processors which use a queue, e.g. the SDK Batching Log Record
|
|
Processor. <p> updowncounter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkProcessorLogQueueCapacity =
|
|
"otel.sdk.processor.log.queue.capacity";
|
|
static constexpr const char *descrMetricOtelSdkProcessorLogQueueCapacity =
|
|
"The maximum number of log records the queue of a given instance of an SDK Log Record "
|
|
"processor can hold";
|
|
static constexpr const char *unitMetricOtelSdkProcessorLogQueueCapacity = "{log_record}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkProcessorLogQueueCapacity(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkProcessorLogQueueCapacity,
|
|
descrMetricOtelSdkProcessorLogQueueCapacity,
|
|
unitMetricOtelSdkProcessorLogQueueCapacity);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkProcessorLogQueueCapacity(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkProcessorLogQueueCapacity,
|
|
descrMetricOtelSdkProcessorLogQueueCapacity,
|
|
unitMetricOtelSdkProcessorLogQueueCapacity);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkProcessorLogQueueCapacity(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkProcessorLogQueueCapacity,
|
|
descrMetricOtelSdkProcessorLogQueueCapacity,
|
|
unitMetricOtelSdkProcessorLogQueueCapacity);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkProcessorLogQueueCapacity(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkProcessorLogQueueCapacity,
|
|
descrMetricOtelSdkProcessorLogQueueCapacity,
|
|
unitMetricOtelSdkProcessorLogQueueCapacity);
|
|
}
|
|
|
|
/**
|
|
The number of log records in the queue of a given instance of an SDK log processor
|
|
<p>
|
|
Only applies to log record processors which use a queue, e.g. the SDK Batching Log Record
|
|
Processor. <p> updowncounter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkProcessorLogQueueSize =
|
|
"otel.sdk.processor.log.queue.size";
|
|
static constexpr const char *descrMetricOtelSdkProcessorLogQueueSize =
|
|
"The number of log records in the queue of a given instance of an SDK log processor";
|
|
static constexpr const char *unitMetricOtelSdkProcessorLogQueueSize = "{log_record}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkProcessorLogQueueSize(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkProcessorLogQueueSize,
|
|
descrMetricOtelSdkProcessorLogQueueSize,
|
|
unitMetricOtelSdkProcessorLogQueueSize);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkProcessorLogQueueSize(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkProcessorLogQueueSize,
|
|
descrMetricOtelSdkProcessorLogQueueSize,
|
|
unitMetricOtelSdkProcessorLogQueueSize);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkProcessorLogQueueSize(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkProcessorLogQueueSize,
|
|
descrMetricOtelSdkProcessorLogQueueSize,
|
|
unitMetricOtelSdkProcessorLogQueueSize);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkProcessorLogQueueSize(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkProcessorLogQueueSize,
|
|
descrMetricOtelSdkProcessorLogQueueSize,
|
|
unitMetricOtelSdkProcessorLogQueueSize);
|
|
}
|
|
|
|
/**
|
|
The number of spans for which the processing has finished, either successful or failed
|
|
<p>
|
|
For successful processing, @code error.type @endcode MUST NOT be set. For failed processing, @code
|
|
error.type @endcode MUST contain the failure cause. For the SDK Simple and Batching Span Processor
|
|
a span is considered to be processed already when it has been submitted to the exporter, not when
|
|
the corresponding export call has finished. <p> counter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkProcessorSpanProcessed =
|
|
"otel.sdk.processor.span.processed";
|
|
static constexpr const char *descrMetricOtelSdkProcessorSpanProcessed =
|
|
"The number of spans for which the processing has finished, either successful or failed";
|
|
static constexpr const char *unitMetricOtelSdkProcessorSpanProcessed = "{span}";
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
|
|
CreateSyncInt64MetricOtelSdkProcessorSpanProcessed(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Counter(kMetricOtelSdkProcessorSpanProcessed,
|
|
descrMetricOtelSdkProcessorSpanProcessed,
|
|
unitMetricOtelSdkProcessorSpanProcessed);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<double>>
|
|
CreateSyncDoubleMetricOtelSdkProcessorSpanProcessed(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleCounter(kMetricOtelSdkProcessorSpanProcessed,
|
|
descrMetricOtelSdkProcessorSpanProcessed,
|
|
unitMetricOtelSdkProcessorSpanProcessed);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkProcessorSpanProcessed(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableCounter(kMetricOtelSdkProcessorSpanProcessed,
|
|
descrMetricOtelSdkProcessorSpanProcessed,
|
|
unitMetricOtelSdkProcessorSpanProcessed);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkProcessorSpanProcessed(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableCounter(kMetricOtelSdkProcessorSpanProcessed,
|
|
descrMetricOtelSdkProcessorSpanProcessed,
|
|
unitMetricOtelSdkProcessorSpanProcessed);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code otel.sdk.processor.span.processed @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code otel.sdk.processor.span.processed @endcode.", "reason": "renamed",
|
|
"renamed_to": "otel.sdk.processor.span.processed"} <p> updowncounter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricOtelSdkProcessorSpanProcessedCount =
|
|
"otel.sdk.processor.span.processed.count";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char
|
|
*descrMetricOtelSdkProcessorSpanProcessedCount =
|
|
"Deprecated, use `otel.sdk.processor.span.processed` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricOtelSdkProcessorSpanProcessedCount =
|
|
"{span}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkProcessorSpanProcessedCount,
|
|
descrMetricOtelSdkProcessorSpanProcessedCount,
|
|
unitMetricOtelSdkProcessorSpanProcessedCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkProcessorSpanProcessedCount,
|
|
descrMetricOtelSdkProcessorSpanProcessedCount,
|
|
unitMetricOtelSdkProcessorSpanProcessedCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkProcessorSpanProcessedCount,
|
|
descrMetricOtelSdkProcessorSpanProcessedCount,
|
|
unitMetricOtelSdkProcessorSpanProcessedCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkProcessorSpanProcessedCount,
|
|
descrMetricOtelSdkProcessorSpanProcessedCount,
|
|
unitMetricOtelSdkProcessorSpanProcessedCount);
|
|
}
|
|
|
|
/**
|
|
The maximum number of spans the queue of a given instance of an SDK span processor can hold
|
|
<p>
|
|
Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
|
|
<p>
|
|
updowncounter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkProcessorSpanQueueCapacity =
|
|
"otel.sdk.processor.span.queue.capacity";
|
|
static constexpr const char *descrMetricOtelSdkProcessorSpanQueueCapacity =
|
|
"The maximum number of spans the queue of a given instance of an SDK span processor can hold";
|
|
static constexpr const char *unitMetricOtelSdkProcessorSpanQueueCapacity = "{span}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
|
|
descrMetricOtelSdkProcessorSpanQueueCapacity,
|
|
unitMetricOtelSdkProcessorSpanQueueCapacity);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
|
|
descrMetricOtelSdkProcessorSpanQueueCapacity,
|
|
unitMetricOtelSdkProcessorSpanQueueCapacity);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
|
|
descrMetricOtelSdkProcessorSpanQueueCapacity,
|
|
unitMetricOtelSdkProcessorSpanQueueCapacity);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
|
|
descrMetricOtelSdkProcessorSpanQueueCapacity,
|
|
unitMetricOtelSdkProcessorSpanQueueCapacity);
|
|
}
|
|
|
|
/**
|
|
The number of spans in the queue of a given instance of an SDK span processor
|
|
<p>
|
|
Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
|
|
<p>
|
|
updowncounter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkProcessorSpanQueueSize =
|
|
"otel.sdk.processor.span.queue.size";
|
|
static constexpr const char *descrMetricOtelSdkProcessorSpanQueueSize =
|
|
"The number of spans in the queue of a given instance of an SDK span processor";
|
|
static constexpr const char *unitMetricOtelSdkProcessorSpanQueueSize = "{span}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
|
|
descrMetricOtelSdkProcessorSpanQueueSize,
|
|
unitMetricOtelSdkProcessorSpanQueueSize);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
|
|
descrMetricOtelSdkProcessorSpanQueueSize,
|
|
unitMetricOtelSdkProcessorSpanQueueSize);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
|
|
descrMetricOtelSdkProcessorSpanQueueSize,
|
|
unitMetricOtelSdkProcessorSpanQueueSize);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
|
|
descrMetricOtelSdkProcessorSpanQueueSize,
|
|
unitMetricOtelSdkProcessorSpanQueueSize);
|
|
}
|
|
|
|
/**
|
|
The number of created spans for which the end operation was called
|
|
<p>
|
|
For spans with @code recording=true @endcode: Implementations MUST record both @code
|
|
otel.sdk.span.live @endcode and @code otel.sdk.span.ended @endcode. For spans with @code
|
|
recording=false @endcode: If implementations decide to record this metric, they MUST also record
|
|
@code otel.sdk.span.live @endcode. <p> counter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkSpanEnded = "otel.sdk.span.ended";
|
|
static constexpr const char *descrMetricOtelSdkSpanEnded =
|
|
"The number of created spans for which the end operation was called";
|
|
static constexpr const char *unitMetricOtelSdkSpanEnded = "{span}";
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricOtelSdkSpanEnded(
|
|
metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Counter(kMetricOtelSdkSpanEnded, descrMetricOtelSdkSpanEnded,
|
|
unitMetricOtelSdkSpanEnded);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricOtelSdkSpanEnded(
|
|
metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleCounter(kMetricOtelSdkSpanEnded, descrMetricOtelSdkSpanEnded,
|
|
unitMetricOtelSdkSpanEnded);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkSpanEnded(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableCounter(kMetricOtelSdkSpanEnded, descrMetricOtelSdkSpanEnded,
|
|
unitMetricOtelSdkSpanEnded);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkSpanEnded(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableCounter(kMetricOtelSdkSpanEnded, descrMetricOtelSdkSpanEnded,
|
|
unitMetricOtelSdkSpanEnded);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code otel.sdk.span.ended @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code otel.sdk.span.ended @endcode.", "reason": "renamed", "renamed_to":
|
|
"otel.sdk.span.ended"} <p> counter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricOtelSdkSpanEndedCount =
|
|
"otel.sdk.span.ended.count";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricOtelSdkSpanEndedCount =
|
|
"Deprecated, use `otel.sdk.span.ended` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricOtelSdkSpanEndedCount = "{span}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
|
|
CreateSyncInt64MetricOtelSdkSpanEndedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Counter(kMetricOtelSdkSpanEndedCount, descrMetricOtelSdkSpanEndedCount,
|
|
unitMetricOtelSdkSpanEndedCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<double>>
|
|
CreateSyncDoubleMetricOtelSdkSpanEndedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleCounter(kMetricOtelSdkSpanEndedCount, descrMetricOtelSdkSpanEndedCount,
|
|
unitMetricOtelSdkSpanEndedCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkSpanEndedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableCounter(kMetricOtelSdkSpanEndedCount,
|
|
descrMetricOtelSdkSpanEndedCount,
|
|
unitMetricOtelSdkSpanEndedCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkSpanEndedCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableCounter(kMetricOtelSdkSpanEndedCount,
|
|
descrMetricOtelSdkSpanEndedCount,
|
|
unitMetricOtelSdkSpanEndedCount);
|
|
}
|
|
|
|
/**
|
|
The number of created spans for which the end operation has not been called yet
|
|
<p>
|
|
For spans with @code recording=true @endcode: Implementations MUST record both @code
|
|
otel.sdk.span.live @endcode and @code otel.sdk.span.ended @endcode. For spans with @code
|
|
recording=false @endcode: If implementations decide to record this metric, they MUST also record
|
|
@code otel.sdk.span.ended @endcode. <p> updowncounter
|
|
*/
|
|
static constexpr const char *kMetricOtelSdkSpanLive = "otel.sdk.span.live";
|
|
static constexpr const char *descrMetricOtelSdkSpanLive =
|
|
"The number of created spans for which the end operation has not been called yet";
|
|
static constexpr const char *unitMetricOtelSdkSpanLive = "{span}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkSpanLive(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricOtelSdkSpanLive, descrMetricOtelSdkSpanLive,
|
|
unitMetricOtelSdkSpanLive);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkSpanLive(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricOtelSdkSpanLive, descrMetricOtelSdkSpanLive,
|
|
unitMetricOtelSdkSpanLive);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkSpanLive(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(
|
|
kMetricOtelSdkSpanLive, descrMetricOtelSdkSpanLive, unitMetricOtelSdkSpanLive);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkSpanLive(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(
|
|
kMetricOtelSdkSpanLive, descrMetricOtelSdkSpanLive, unitMetricOtelSdkSpanLive);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code otel.sdk.span.live @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code otel.sdk.span.live @endcode.", "reason": "renamed", "renamed_to":
|
|
"otel.sdk.span.live"} <p> updowncounter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricOtelSdkSpanLiveCount =
|
|
"otel.sdk.span.live.count";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricOtelSdkSpanLiveCount =
|
|
"Deprecated, use `otel.sdk.span.live` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricOtelSdkSpanLiveCount = "{span}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricOtelSdkSpanLiveCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(
|
|
kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricOtelSdkSpanLiveCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(
|
|
kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricOtelSdkSpanLiveCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(
|
|
kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricOtelSdkSpanLiveCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(
|
|
kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
|
|
}
|
|
|
|
} // namespace otel
|
|
} // namespace semconv
|
|
OPENTELEMETRY_END_NAMESPACE
|