opentelemetry-cpp/api/include/opentelemetry/semconv/rpc_metrics.h

311 lines
12 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 rpc
{
/**
* Measures the duration of outbound RPC.
* <p>
* While streaming RPCs may record this metric as start-of-batch
* to end-of-batch, it's hard to interpret in practice.
* <p>
* <strong>Streaming</strong>: N/A.
* <p>
* histogram
*/
static constexpr const char *kMetricRpcClientDuration = "rpc.client.duration";
static constexpr const char *descrMetricRpcClientDuration =
"Measures the duration of outbound RPC.";
static constexpr const char *unitMetricRpcClientDuration = "ms";
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
CreateSyncInt64MetricRpcClientDuration(metrics::Meter *meter)
{
return meter->CreateUInt64Histogram(kMetricRpcClientDuration, descrMetricRpcClientDuration,
unitMetricRpcClientDuration);
}
static inline nostd::unique_ptr<metrics::Histogram<double>> CreateSyncDoubleMetricRpcClientDuration(
metrics::Meter *meter)
{
return meter->CreateDoubleHistogram(kMetricRpcClientDuration, descrMetricRpcClientDuration,
unitMetricRpcClientDuration);
}
/**
* Measures the size of RPC request messages (uncompressed).
* <p>
* <strong>Streaming</strong>: Recorded per message in a streaming batch
* <p>
* histogram
*/
static constexpr const char *kMetricRpcClientRequestSize = "rpc.client.request.size";
static constexpr const char *descrMetricRpcClientRequestSize =
"Measures the size of RPC request messages (uncompressed).";
static constexpr const char *unitMetricRpcClientRequestSize = "By";
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
CreateSyncInt64MetricRpcClientRequestSize(metrics::Meter *meter)
{
return meter->CreateUInt64Histogram(kMetricRpcClientRequestSize, descrMetricRpcClientRequestSize,
unitMetricRpcClientRequestSize);
}
static inline nostd::unique_ptr<metrics::Histogram<double>>
CreateSyncDoubleMetricRpcClientRequestSize(metrics::Meter *meter)
{
return meter->CreateDoubleHistogram(kMetricRpcClientRequestSize, descrMetricRpcClientRequestSize,
unitMetricRpcClientRequestSize);
}
/**
* Measures the number of messages received per RPC.
* <p>
* Should be 1 for all non-streaming RPCs.
* <p>
* <strong>Streaming</strong>: This metric is required for server and client streaming RPCs
* <p>
* histogram
*/
static constexpr const char *kMetricRpcClientRequestsPerRpc = "rpc.client.requests_per_rpc";
static constexpr const char *descrMetricRpcClientRequestsPerRpc =
"Measures the number of messages received per RPC.";
static constexpr const char *unitMetricRpcClientRequestsPerRpc = "{count}";
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
CreateSyncInt64MetricRpcClientRequestsPerRpc(metrics::Meter *meter)
{
return meter->CreateUInt64Histogram(kMetricRpcClientRequestsPerRpc,
descrMetricRpcClientRequestsPerRpc,
unitMetricRpcClientRequestsPerRpc);
}
static inline nostd::unique_ptr<metrics::Histogram<double>>
CreateSyncDoubleMetricRpcClientRequestsPerRpc(metrics::Meter *meter)
{
return meter->CreateDoubleHistogram(kMetricRpcClientRequestsPerRpc,
descrMetricRpcClientRequestsPerRpc,
unitMetricRpcClientRequestsPerRpc);
}
/**
* Measures the size of RPC response messages (uncompressed).
* <p>
* <strong>Streaming</strong>: Recorded per response in a streaming batch
* <p>
* histogram
*/
static constexpr const char *kMetricRpcClientResponseSize = "rpc.client.response.size";
static constexpr const char *descrMetricRpcClientResponseSize =
"Measures the size of RPC response messages (uncompressed).";
static constexpr const char *unitMetricRpcClientResponseSize = "By";
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
CreateSyncInt64MetricRpcClientResponseSize(metrics::Meter *meter)
{
return meter->CreateUInt64Histogram(kMetricRpcClientResponseSize,
descrMetricRpcClientResponseSize,
unitMetricRpcClientResponseSize);
}
static inline nostd::unique_ptr<metrics::Histogram<double>>
CreateSyncDoubleMetricRpcClientResponseSize(metrics::Meter *meter)
{
return meter->CreateDoubleHistogram(kMetricRpcClientResponseSize,
descrMetricRpcClientResponseSize,
unitMetricRpcClientResponseSize);
}
/**
* Measures the number of messages sent per RPC.
* <p>
* Should be 1 for all non-streaming RPCs.
* <p>
* <strong>Streaming</strong>: This metric is required for server and client streaming RPCs
* <p>
* histogram
*/
static constexpr const char *kMetricRpcClientResponsesPerRpc = "rpc.client.responses_per_rpc";
static constexpr const char *descrMetricRpcClientResponsesPerRpc =
"Measures the number of messages sent per RPC.";
static constexpr const char *unitMetricRpcClientResponsesPerRpc = "{count}";
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
CreateSyncInt64MetricRpcClientResponsesPerRpc(metrics::Meter *meter)
{
return meter->CreateUInt64Histogram(kMetricRpcClientResponsesPerRpc,
descrMetricRpcClientResponsesPerRpc,
unitMetricRpcClientResponsesPerRpc);
}
static inline nostd::unique_ptr<metrics::Histogram<double>>
CreateSyncDoubleMetricRpcClientResponsesPerRpc(metrics::Meter *meter)
{
return meter->CreateDoubleHistogram(kMetricRpcClientResponsesPerRpc,
descrMetricRpcClientResponsesPerRpc,
unitMetricRpcClientResponsesPerRpc);
}
/**
* Measures the duration of inbound RPC.
* <p>
* While streaming RPCs may record this metric as start-of-batch
* to end-of-batch, it's hard to interpret in practice.
* <p>
* <strong>Streaming</strong>: N/A.
* <p>
* histogram
*/
static constexpr const char *kMetricRpcServerDuration = "rpc.server.duration";
static constexpr const char *descrMetricRpcServerDuration = "Measures the duration of inbound RPC.";
static constexpr const char *unitMetricRpcServerDuration = "ms";
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
CreateSyncInt64MetricRpcServerDuration(metrics::Meter *meter)
{
return meter->CreateUInt64Histogram(kMetricRpcServerDuration, descrMetricRpcServerDuration,
unitMetricRpcServerDuration);
}
static inline nostd::unique_ptr<metrics::Histogram<double>> CreateSyncDoubleMetricRpcServerDuration(
metrics::Meter *meter)
{
return meter->CreateDoubleHistogram(kMetricRpcServerDuration, descrMetricRpcServerDuration,
unitMetricRpcServerDuration);
}
/**
* Measures the size of RPC request messages (uncompressed).
* <p>
* <strong>Streaming</strong>: Recorded per message in a streaming batch
* <p>
* histogram
*/
static constexpr const char *kMetricRpcServerRequestSize = "rpc.server.request.size";
static constexpr const char *descrMetricRpcServerRequestSize =
"Measures the size of RPC request messages (uncompressed).";
static constexpr const char *unitMetricRpcServerRequestSize = "By";
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
CreateSyncInt64MetricRpcServerRequestSize(metrics::Meter *meter)
{
return meter->CreateUInt64Histogram(kMetricRpcServerRequestSize, descrMetricRpcServerRequestSize,
unitMetricRpcServerRequestSize);
}
static inline nostd::unique_ptr<metrics::Histogram<double>>
CreateSyncDoubleMetricRpcServerRequestSize(metrics::Meter *meter)
{
return meter->CreateDoubleHistogram(kMetricRpcServerRequestSize, descrMetricRpcServerRequestSize,
unitMetricRpcServerRequestSize);
}
/**
* Measures the number of messages received per RPC.
* <p>
* Should be 1 for all non-streaming RPCs.
* <p>
* <strong>Streaming</strong> : This metric is required for server and client streaming RPCs
* <p>
* histogram
*/
static constexpr const char *kMetricRpcServerRequestsPerRpc = "rpc.server.requests_per_rpc";
static constexpr const char *descrMetricRpcServerRequestsPerRpc =
"Measures the number of messages received per RPC.";
static constexpr const char *unitMetricRpcServerRequestsPerRpc = "{count}";
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
CreateSyncInt64MetricRpcServerRequestsPerRpc(metrics::Meter *meter)
{
return meter->CreateUInt64Histogram(kMetricRpcServerRequestsPerRpc,
descrMetricRpcServerRequestsPerRpc,
unitMetricRpcServerRequestsPerRpc);
}
static inline nostd::unique_ptr<metrics::Histogram<double>>
CreateSyncDoubleMetricRpcServerRequestsPerRpc(metrics::Meter *meter)
{
return meter->CreateDoubleHistogram(kMetricRpcServerRequestsPerRpc,
descrMetricRpcServerRequestsPerRpc,
unitMetricRpcServerRequestsPerRpc);
}
/**
* Measures the size of RPC response messages (uncompressed).
* <p>
* <strong>Streaming</strong>: Recorded per response in a streaming batch
* <p>
* histogram
*/
static constexpr const char *kMetricRpcServerResponseSize = "rpc.server.response.size";
static constexpr const char *descrMetricRpcServerResponseSize =
"Measures the size of RPC response messages (uncompressed).";
static constexpr const char *unitMetricRpcServerResponseSize = "By";
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
CreateSyncInt64MetricRpcServerResponseSize(metrics::Meter *meter)
{
return meter->CreateUInt64Histogram(kMetricRpcServerResponseSize,
descrMetricRpcServerResponseSize,
unitMetricRpcServerResponseSize);
}
static inline nostd::unique_ptr<metrics::Histogram<double>>
CreateSyncDoubleMetricRpcServerResponseSize(metrics::Meter *meter)
{
return meter->CreateDoubleHistogram(kMetricRpcServerResponseSize,
descrMetricRpcServerResponseSize,
unitMetricRpcServerResponseSize);
}
/**
* Measures the number of messages sent per RPC.
* <p>
* Should be 1 for all non-streaming RPCs.
* <p>
* <strong>Streaming</strong>: This metric is required for server and client streaming RPCs
* <p>
* histogram
*/
static constexpr const char *kMetricRpcServerResponsesPerRpc = "rpc.server.responses_per_rpc";
static constexpr const char *descrMetricRpcServerResponsesPerRpc =
"Measures the number of messages sent per RPC.";
static constexpr const char *unitMetricRpcServerResponsesPerRpc = "{count}";
static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
CreateSyncInt64MetricRpcServerResponsesPerRpc(metrics::Meter *meter)
{
return meter->CreateUInt64Histogram(kMetricRpcServerResponsesPerRpc,
descrMetricRpcServerResponsesPerRpc,
unitMetricRpcServerResponsesPerRpc);
}
static inline nostd::unique_ptr<metrics::Histogram<double>>
CreateSyncDoubleMetricRpcServerResponsesPerRpc(metrics::Meter *meter)
{
return meter->CreateDoubleHistogram(kMetricRpcServerResponsesPerRpc,
descrMetricRpcServerResponsesPerRpc,
unitMetricRpcServerResponsesPerRpc);
}
} // namespace rpc
} // namespace semconv
OPENTELEMETRY_END_NAMESPACE