includes/opentelemetry/semconv/incubating/db_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 db
{
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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);
}
 
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