mirror of
https://github.com/zerotier/ZeroTierOne.git
synced 2025-09-09 00:03:00 +02:00
861 lines
40 KiB
C++
861 lines
40 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 db
|
|
{
|
|
|
|
/**
|
|
The number of connections that are currently in state described by the @code state @endcode
|
|
attribute <p> updowncounter
|
|
*/
|
|
static constexpr const char *kMetricDbClientConnectionCount = "db.client.connection.count";
|
|
static constexpr const char *descrMetricDbClientConnectionCount =
|
|
"The number of connections that are currently in state described by the `state` attribute";
|
|
static constexpr const char *unitMetricDbClientConnectionCount = "{connection}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionCount,
|
|
descrMetricDbClientConnectionCount,
|
|
unitMetricDbClientConnectionCount);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionCount,
|
|
descrMetricDbClientConnectionCount,
|
|
unitMetricDbClientConnectionCount);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionCount,
|
|
descrMetricDbClientConnectionCount,
|
|
unitMetricDbClientConnectionCount);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionCount,
|
|
descrMetricDbClientConnectionCount,
|
|
unitMetricDbClientConnectionCount);
|
|
}
|
|
|
|
/**
|
|
The time it took to create a new connection
|
|
<p>
|
|
histogram
|
|
*/
|
|
static constexpr const char *kMetricDbClientConnectionCreateTime =
|
|
"db.client.connection.create_time";
|
|
static constexpr const char *descrMetricDbClientConnectionCreateTime =
|
|
"The time it took to create a new connection";
|
|
static constexpr const char *unitMetricDbClientConnectionCreateTime = "s";
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionCreateTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricDbClientConnectionCreateTime,
|
|
descrMetricDbClientConnectionCreateTime,
|
|
unitMetricDbClientConnectionCreateTime);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionCreateTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricDbClientConnectionCreateTime,
|
|
descrMetricDbClientConnectionCreateTime,
|
|
unitMetricDbClientConnectionCreateTime);
|
|
}
|
|
|
|
/**
|
|
The maximum number of idle open connections allowed
|
|
<p>
|
|
updowncounter
|
|
*/
|
|
static constexpr const char *kMetricDbClientConnectionIdleMax = "db.client.connection.idle.max";
|
|
static constexpr const char *descrMetricDbClientConnectionIdleMax =
|
|
"The maximum number of idle open connections allowed";
|
|
static constexpr const char *unitMetricDbClientConnectionIdleMax = "{connection}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionIdleMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionIdleMax,
|
|
descrMetricDbClientConnectionIdleMax,
|
|
unitMetricDbClientConnectionIdleMax);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionIdleMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionIdleMax,
|
|
descrMetricDbClientConnectionIdleMax,
|
|
unitMetricDbClientConnectionIdleMax);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionIdleMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionIdleMax,
|
|
descrMetricDbClientConnectionIdleMax,
|
|
unitMetricDbClientConnectionIdleMax);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionIdleMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionIdleMax,
|
|
descrMetricDbClientConnectionIdleMax,
|
|
unitMetricDbClientConnectionIdleMax);
|
|
}
|
|
|
|
/**
|
|
The minimum number of idle open connections allowed
|
|
<p>
|
|
updowncounter
|
|
*/
|
|
static constexpr const char *kMetricDbClientConnectionIdleMin = "db.client.connection.idle.min";
|
|
static constexpr const char *descrMetricDbClientConnectionIdleMin =
|
|
"The minimum number of idle open connections allowed";
|
|
static constexpr const char *unitMetricDbClientConnectionIdleMin = "{connection}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionIdleMin(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionIdleMin,
|
|
descrMetricDbClientConnectionIdleMin,
|
|
unitMetricDbClientConnectionIdleMin);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionIdleMin(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionIdleMin,
|
|
descrMetricDbClientConnectionIdleMin,
|
|
unitMetricDbClientConnectionIdleMin);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionIdleMin(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionIdleMin,
|
|
descrMetricDbClientConnectionIdleMin,
|
|
unitMetricDbClientConnectionIdleMin);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionIdleMin(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionIdleMin,
|
|
descrMetricDbClientConnectionIdleMin,
|
|
unitMetricDbClientConnectionIdleMin);
|
|
}
|
|
|
|
/**
|
|
The maximum number of open connections allowed
|
|
<p>
|
|
updowncounter
|
|
*/
|
|
static constexpr const char *kMetricDbClientConnectionMax = "db.client.connection.max";
|
|
static constexpr const char *descrMetricDbClientConnectionMax =
|
|
"The maximum number of open connections allowed";
|
|
static constexpr const char *unitMetricDbClientConnectionMax = "{connection}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionMax,
|
|
descrMetricDbClientConnectionMax,
|
|
unitMetricDbClientConnectionMax);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionMax,
|
|
descrMetricDbClientConnectionMax,
|
|
unitMetricDbClientConnectionMax);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionMax,
|
|
descrMetricDbClientConnectionMax,
|
|
unitMetricDbClientConnectionMax);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionMax,
|
|
descrMetricDbClientConnectionMax,
|
|
unitMetricDbClientConnectionMax);
|
|
}
|
|
|
|
/**
|
|
The number of current pending requests for an open connection
|
|
<p>
|
|
updowncounter
|
|
*/
|
|
static constexpr const char *kMetricDbClientConnectionPendingRequests =
|
|
"db.client.connection.pending_requests";
|
|
static constexpr const char *descrMetricDbClientConnectionPendingRequests =
|
|
"The number of current pending requests for an open connection";
|
|
static constexpr const char *unitMetricDbClientConnectionPendingRequests = "{request}";
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionPendingRequests(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionPendingRequests,
|
|
descrMetricDbClientConnectionPendingRequests,
|
|
unitMetricDbClientConnectionPendingRequests);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionPendingRequests(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionPendingRequests,
|
|
descrMetricDbClientConnectionPendingRequests,
|
|
unitMetricDbClientConnectionPendingRequests);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionPendingRequests(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionPendingRequests,
|
|
descrMetricDbClientConnectionPendingRequests,
|
|
unitMetricDbClientConnectionPendingRequests);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionPendingRequests(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionPendingRequests,
|
|
descrMetricDbClientConnectionPendingRequests,
|
|
unitMetricDbClientConnectionPendingRequests);
|
|
}
|
|
|
|
/**
|
|
The number of connection timeouts that have occurred trying to obtain a connection from the pool
|
|
<p>
|
|
counter
|
|
*/
|
|
static constexpr const char *kMetricDbClientConnectionTimeouts = "db.client.connection.timeouts";
|
|
static constexpr const char *descrMetricDbClientConnectionTimeouts =
|
|
"The number of connection timeouts that have occurred trying to obtain a connection from the "
|
|
"pool";
|
|
static constexpr const char *unitMetricDbClientConnectionTimeouts = "{timeout}";
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionTimeouts(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Counter(kMetricDbClientConnectionTimeouts,
|
|
descrMetricDbClientConnectionTimeouts,
|
|
unitMetricDbClientConnectionTimeouts);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Counter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionTimeouts(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleCounter(kMetricDbClientConnectionTimeouts,
|
|
descrMetricDbClientConnectionTimeouts,
|
|
unitMetricDbClientConnectionTimeouts);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionTimeouts(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableCounter(kMetricDbClientConnectionTimeouts,
|
|
descrMetricDbClientConnectionTimeouts,
|
|
unitMetricDbClientConnectionTimeouts);
|
|
}
|
|
|
|
static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionTimeouts(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableCounter(kMetricDbClientConnectionTimeouts,
|
|
descrMetricDbClientConnectionTimeouts,
|
|
unitMetricDbClientConnectionTimeouts);
|
|
}
|
|
|
|
/**
|
|
The time between borrowing a connection and returning it to the pool
|
|
<p>
|
|
histogram
|
|
*/
|
|
static constexpr const char *kMetricDbClientConnectionUseTime = "db.client.connection.use_time";
|
|
static constexpr const char *descrMetricDbClientConnectionUseTime =
|
|
"The time between borrowing a connection and returning it to the pool";
|
|
static constexpr const char *unitMetricDbClientConnectionUseTime = "s";
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionUseTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricDbClientConnectionUseTime,
|
|
descrMetricDbClientConnectionUseTime,
|
|
unitMetricDbClientConnectionUseTime);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionUseTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricDbClientConnectionUseTime,
|
|
descrMetricDbClientConnectionUseTime,
|
|
unitMetricDbClientConnectionUseTime);
|
|
}
|
|
|
|
/**
|
|
The time it took to obtain an open connection from the pool
|
|
<p>
|
|
histogram
|
|
*/
|
|
static constexpr const char *kMetricDbClientConnectionWaitTime = "db.client.connection.wait_time";
|
|
static constexpr const char *descrMetricDbClientConnectionWaitTime =
|
|
"The time it took to obtain an open connection from the pool";
|
|
static constexpr const char *unitMetricDbClientConnectionWaitTime = "s";
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionWaitTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricDbClientConnectionWaitTime,
|
|
descrMetricDbClientConnectionWaitTime,
|
|
unitMetricDbClientConnectionWaitTime);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionWaitTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricDbClientConnectionWaitTime,
|
|
descrMetricDbClientConnectionWaitTime,
|
|
unitMetricDbClientConnectionWaitTime);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code db.client.connection.create_time @endcode instead. Note: the unit also
|
|
changed from @code ms @endcode to @code s @endcode.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code db.client.connection.create_time @endcode with unit @code s
|
|
@endcode.", "reason": "uncategorized"} <p> histogram
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsCreateTime =
|
|
"db.client.connections.create_time";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsCreateTime =
|
|
"Deprecated, use `db.client.connection.create_time` instead. Note: the unit also changed from "
|
|
"`ms` to `s`.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsCreateTime =
|
|
"ms";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionsCreateTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricDbClientConnectionsCreateTime,
|
|
descrMetricDbClientConnectionsCreateTime,
|
|
unitMetricDbClientConnectionsCreateTime);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionsCreateTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricDbClientConnectionsCreateTime,
|
|
descrMetricDbClientConnectionsCreateTime,
|
|
unitMetricDbClientConnectionsCreateTime);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code db.client.connection.idle.max @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code db.client.connection.idle.max @endcode.", "reason": "renamed",
|
|
"renamed_to": "db.client.connection.idle.max"} <p> updowncounter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsIdleMax =
|
|
"db.client.connections.idle.max";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsIdleMax =
|
|
"Deprecated, use `db.client.connection.idle.max` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsIdleMax =
|
|
"{connection}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionsIdleMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionsIdleMax,
|
|
descrMetricDbClientConnectionsIdleMax,
|
|
unitMetricDbClientConnectionsIdleMax);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionsIdleMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionsIdleMax,
|
|
descrMetricDbClientConnectionsIdleMax,
|
|
unitMetricDbClientConnectionsIdleMax);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionsIdleMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionsIdleMax,
|
|
descrMetricDbClientConnectionsIdleMax,
|
|
unitMetricDbClientConnectionsIdleMax);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionsIdleMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionsIdleMax,
|
|
descrMetricDbClientConnectionsIdleMax,
|
|
unitMetricDbClientConnectionsIdleMax);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code db.client.connection.idle.min @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code db.client.connection.idle.min @endcode.", "reason": "renamed",
|
|
"renamed_to": "db.client.connection.idle.min"} <p> updowncounter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsIdleMin =
|
|
"db.client.connections.idle.min";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsIdleMin =
|
|
"Deprecated, use `db.client.connection.idle.min` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsIdleMin =
|
|
"{connection}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionsIdleMin(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionsIdleMin,
|
|
descrMetricDbClientConnectionsIdleMin,
|
|
unitMetricDbClientConnectionsIdleMin);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionsIdleMin(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionsIdleMin,
|
|
descrMetricDbClientConnectionsIdleMin,
|
|
unitMetricDbClientConnectionsIdleMin);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionsIdleMin(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionsIdleMin,
|
|
descrMetricDbClientConnectionsIdleMin,
|
|
unitMetricDbClientConnectionsIdleMin);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionsIdleMin(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionsIdleMin,
|
|
descrMetricDbClientConnectionsIdleMin,
|
|
unitMetricDbClientConnectionsIdleMin);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code db.client.connection.max @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code db.client.connection.max @endcode.", "reason": "renamed",
|
|
"renamed_to": "db.client.connection.max"} <p> updowncounter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsMax =
|
|
"db.client.connections.max";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsMax =
|
|
"Deprecated, use `db.client.connection.max` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsMax =
|
|
"{connection}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionsMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionsMax,
|
|
descrMetricDbClientConnectionsMax,
|
|
unitMetricDbClientConnectionsMax);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionsMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionsMax,
|
|
descrMetricDbClientConnectionsMax,
|
|
unitMetricDbClientConnectionsMax);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionsMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionsMax,
|
|
descrMetricDbClientConnectionsMax,
|
|
unitMetricDbClientConnectionsMax);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionsMax(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionsMax,
|
|
descrMetricDbClientConnectionsMax,
|
|
unitMetricDbClientConnectionsMax);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code db.client.connection.pending_requests @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code db.client.connection.pending_requests @endcode.", "reason": "renamed",
|
|
"renamed_to": "db.client.connection.pending_requests"} <p> updowncounter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsPendingRequests =
|
|
"db.client.connections.pending_requests";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char
|
|
*descrMetricDbClientConnectionsPendingRequests =
|
|
"Deprecated, use `db.client.connection.pending_requests` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsPendingRequests =
|
|
"{request}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionsPendingRequests(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionsPendingRequests,
|
|
descrMetricDbClientConnectionsPendingRequests,
|
|
unitMetricDbClientConnectionsPendingRequests);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionsPendingRequests(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionsPendingRequests,
|
|
descrMetricDbClientConnectionsPendingRequests,
|
|
unitMetricDbClientConnectionsPendingRequests);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionsPendingRequests(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionsPendingRequests,
|
|
descrMetricDbClientConnectionsPendingRequests,
|
|
unitMetricDbClientConnectionsPendingRequests);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionsPendingRequests(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionsPendingRequests,
|
|
descrMetricDbClientConnectionsPendingRequests,
|
|
unitMetricDbClientConnectionsPendingRequests);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code db.client.connection.timeouts @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code db.client.connection.timeouts @endcode.", "reason": "renamed",
|
|
"renamed_to": "db.client.connection.timeouts"} <p> counter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsTimeouts =
|
|
"db.client.connections.timeouts";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsTimeouts =
|
|
"Deprecated, use `db.client.connection.timeouts` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsTimeouts =
|
|
"{timeout}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionsTimeouts(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Counter(kMetricDbClientConnectionsTimeouts,
|
|
descrMetricDbClientConnectionsTimeouts,
|
|
unitMetricDbClientConnectionsTimeouts);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionsTimeouts(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleCounter(kMetricDbClientConnectionsTimeouts,
|
|
descrMetricDbClientConnectionsTimeouts,
|
|
unitMetricDbClientConnectionsTimeouts);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionsTimeouts(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableCounter(kMetricDbClientConnectionsTimeouts,
|
|
descrMetricDbClientConnectionsTimeouts,
|
|
unitMetricDbClientConnectionsTimeouts);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionsTimeouts(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableCounter(kMetricDbClientConnectionsTimeouts,
|
|
descrMetricDbClientConnectionsTimeouts,
|
|
unitMetricDbClientConnectionsTimeouts);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code db.client.connection.count @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code db.client.connection.count @endcode.", "reason": "renamed",
|
|
"renamed_to": "db.client.connection.count"} <p> updowncounter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsUsage =
|
|
"db.client.connections.usage";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsUsage =
|
|
"Deprecated, use `db.client.connection.count` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsUsage =
|
|
"{connection}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionsUsage(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionsUsage,
|
|
descrMetricDbClientConnectionsUsage,
|
|
unitMetricDbClientConnectionsUsage);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionsUsage(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionsUsage,
|
|
descrMetricDbClientConnectionsUsage,
|
|
unitMetricDbClientConnectionsUsage);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientConnectionsUsage(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionsUsage,
|
|
descrMetricDbClientConnectionsUsage,
|
|
unitMetricDbClientConnectionsUsage);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientConnectionsUsage(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionsUsage,
|
|
descrMetricDbClientConnectionsUsage,
|
|
unitMetricDbClientConnectionsUsage);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code db.client.connection.use_time @endcode instead. Note: the unit also changed
|
|
from @code ms @endcode to @code s @endcode.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code db.client.connection.use_time @endcode with unit @code s @endcode.",
|
|
"reason": "uncategorized"} <p> histogram
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsUseTime =
|
|
"db.client.connections.use_time";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsUseTime =
|
|
"Deprecated, use `db.client.connection.use_time` instead. Note: the unit also changed from "
|
|
"`ms` to `s`.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsUseTime = "ms";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionsUseTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricDbClientConnectionsUseTime,
|
|
descrMetricDbClientConnectionsUseTime,
|
|
unitMetricDbClientConnectionsUseTime);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionsUseTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricDbClientConnectionsUseTime,
|
|
descrMetricDbClientConnectionsUseTime,
|
|
unitMetricDbClientConnectionsUseTime);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code db.client.connection.wait_time @endcode instead. Note: the unit also changed
|
|
from @code ms @endcode to @code s @endcode.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code db.client.connection.wait_time @endcode with unit @code s @endcode.",
|
|
"reason": "uncategorized"} <p> histogram
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsWaitTime =
|
|
"db.client.connections.wait_time";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsWaitTime =
|
|
"Deprecated, use `db.client.connection.wait_time` instead. Note: the unit also changed from "
|
|
"`ms` to `s`.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsWaitTime = "ms";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricDbClientConnectionsWaitTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricDbClientConnectionsWaitTime,
|
|
descrMetricDbClientConnectionsWaitTime,
|
|
unitMetricDbClientConnectionsWaitTime);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricDbClientConnectionsWaitTime(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricDbClientConnectionsWaitTime,
|
|
descrMetricDbClientConnectionsWaitTime,
|
|
unitMetricDbClientConnectionsWaitTime);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code azure.cosmosdb.client.active_instance.count @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code azure.cosmosdb.client.active_instance.count @endcode.", "reason":
|
|
"renamed", "renamed_to": "azure.cosmosdb.client.active_instance.count"} <p> updowncounter
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientCosmosdbActiveInstanceCount =
|
|
"db.client.cosmosdb.active_instance.count";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char
|
|
*descrMetricDbClientCosmosdbActiveInstanceCount =
|
|
"Deprecated, use `azure.cosmosdb.client.active_instance.count` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char
|
|
*unitMetricDbClientCosmosdbActiveInstanceCount = "{instance}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
|
|
CreateSyncInt64MetricDbClientCosmosdbActiveInstanceCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64UpDownCounter(kMetricDbClientCosmosdbActiveInstanceCount,
|
|
descrMetricDbClientCosmosdbActiveInstanceCount,
|
|
unitMetricDbClientCosmosdbActiveInstanceCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
|
|
CreateSyncDoubleMetricDbClientCosmosdbActiveInstanceCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleUpDownCounter(kMetricDbClientCosmosdbActiveInstanceCount,
|
|
descrMetricDbClientCosmosdbActiveInstanceCount,
|
|
unitMetricDbClientCosmosdbActiveInstanceCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncInt64MetricDbClientCosmosdbActiveInstanceCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientCosmosdbActiveInstanceCount,
|
|
descrMetricDbClientCosmosdbActiveInstanceCount,
|
|
unitMetricDbClientCosmosdbActiveInstanceCount);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
|
|
CreateAsyncDoubleMetricDbClientCosmosdbActiveInstanceCount(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientCosmosdbActiveInstanceCount,
|
|
descrMetricDbClientCosmosdbActiveInstanceCount,
|
|
unitMetricDbClientCosmosdbActiveInstanceCount);
|
|
}
|
|
|
|
/**
|
|
Deprecated, use @code azure.cosmosdb.client.operation.request_charge @endcode instead.
|
|
|
|
@deprecated
|
|
{"note": "Replaced by @code azure.cosmosdb.client.operation.request_charge @endcode.", "reason":
|
|
"renamed", "renamed_to": "azure.cosmosdb.client.operation.request_charge"} <p> histogram
|
|
*/
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char
|
|
*kMetricDbClientCosmosdbOperationRequestCharge = "db.client.cosmosdb.operation.request_charge";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char
|
|
*descrMetricDbClientCosmosdbOperationRequestCharge =
|
|
"Deprecated, use `azure.cosmosdb.client.operation.request_charge` instead.";
|
|
OPENTELEMETRY_DEPRECATED static constexpr const char
|
|
*unitMetricDbClientCosmosdbOperationRequestCharge = "{request_unit}";
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricDbClientCosmosdbOperationRequestCharge(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricDbClientCosmosdbOperationRequestCharge,
|
|
descrMetricDbClientCosmosdbOperationRequestCharge,
|
|
unitMetricDbClientCosmosdbOperationRequestCharge);
|
|
}
|
|
|
|
OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricDbClientCosmosdbOperationRequestCharge(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricDbClientCosmosdbOperationRequestCharge,
|
|
descrMetricDbClientCosmosdbOperationRequestCharge,
|
|
unitMetricDbClientCosmosdbOperationRequestCharge);
|
|
}
|
|
|
|
/**
|
|
Duration of database client operations.
|
|
<p>
|
|
Batch operations SHOULD be recorded as a single operation.
|
|
<p>
|
|
histogram
|
|
*/
|
|
static constexpr const char *kMetricDbClientOperationDuration = "db.client.operation.duration";
|
|
static constexpr const char *descrMetricDbClientOperationDuration =
|
|
"Duration of database client operations.";
|
|
static constexpr const char *unitMetricDbClientOperationDuration = "s";
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricDbClientOperationDuration(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricDbClientOperationDuration,
|
|
descrMetricDbClientOperationDuration,
|
|
unitMetricDbClientOperationDuration);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricDbClientOperationDuration(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricDbClientOperationDuration,
|
|
descrMetricDbClientOperationDuration,
|
|
unitMetricDbClientOperationDuration);
|
|
}
|
|
|
|
/**
|
|
The actual number of records returned by the database operation.
|
|
<p>
|
|
histogram
|
|
*/
|
|
static constexpr const char *kMetricDbClientResponseReturnedRows =
|
|
"db.client.response.returned_rows";
|
|
static constexpr const char *descrMetricDbClientResponseReturnedRows =
|
|
"The actual number of records returned by the database operation.";
|
|
static constexpr const char *unitMetricDbClientResponseReturnedRows = "{row}";
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
|
|
CreateSyncInt64MetricDbClientResponseReturnedRows(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateUInt64Histogram(kMetricDbClientResponseReturnedRows,
|
|
descrMetricDbClientResponseReturnedRows,
|
|
unitMetricDbClientResponseReturnedRows);
|
|
}
|
|
|
|
static inline nostd::unique_ptr<metrics::Histogram<double>>
|
|
CreateSyncDoubleMetricDbClientResponseReturnedRows(metrics::Meter *meter)
|
|
{
|
|
return meter->CreateDoubleHistogram(kMetricDbClientResponseReturnedRows,
|
|
descrMetricDbClientResponseReturnedRows,
|
|
unitMetricDbClientResponseReturnedRows);
|
|
}
|
|
|
|
} // namespace db
|
|
} // namespace semconv
|
|
OPENTELEMETRY_END_NAMESPACE
|