diff --git a/CHANGELOG.md b/CHANGELOG.md index 208cf2b194..51da906f1c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -32,6 +32,15 @@ Increment the: * [BUILD] Upgrade to opentelemetry-proto 1.8.0 [#3730](https://github.com/open-telemetry/opentelemetry-cpp/pull/3730) +New Features: + +* [CONFIGURATION] Implement declarative configuration (config.yaml) + [#2518](https://github.com/open-telemetry/opentelemetry-cpp/pull/2518) + + * Configuration for opentelemetry-cpp can now be done using a config.yaml + file, instead of using environment variables. + * See [opentelemetry-configuration](https://github.com/open-telemetry/opentelemetry-configuration) + ## [1.23 2025-09-25] * [CodeHealth] Fix clang-tidy warnings part 6 diff --git a/api/include/opentelemetry/semconv/http_attributes.h b/api/include/opentelemetry/semconv/http_attributes.h index 85e5244b08..b815b5d6b8 100644 --- a/api/include/opentelemetry/semconv/http_attributes.h +++ b/api/include/opentelemetry/semconv/http_attributes.h @@ -43,19 +43,23 @@ static constexpr const char *kHttpRequestHeader = "http.request.header";

HTTP request method value SHOULD be "known" to the instrumentation. By default, this convention defines "known" methods as the ones listed in RFC9110 and the PATCH method - defined in RFC5789.

If the HTTP - request method is not known to instrumentation, it MUST set the @code http.request.method @endcode - attribute to @code _OTHER @endcode.

If the HTTP instrumentation could end up converting valid - HTTP request methods to @code _OTHER @endcode, then it MUST provide a way to override the list of - known HTTP methods. If this override is done via environment variable, then the environment - variable MUST be named OTEL_INSTRUMENTATION_HTTP_KNOWN_METHODS and support a comma-separated list - of case-sensitive known HTTP methods (this list MUST be a full override of the default known - method, it is not a list of known methods in addition to the defaults).

HTTP method names are - case-sensitive and @code http.request.method @endcode attribute value MUST match a known HTTP - method name exactly. Instrumentations for specific web frameworks that consider HTTP methods to be - case insensitive, SHOULD populate a canonical equivalent. Tracing instrumentations that do so, - MUST also set @code http.request.method_original @endcode to the original value. + href="https://www.rfc-editor.org/rfc/rfc9110.html#name-methods">RFC9110, the PATCH method + defined in RFC5789 and the QUERY method + defined in httpbis-safe-method-w-body. +

+ If the HTTP request method is not known to instrumentation, it MUST set the @code + http.request.method @endcode attribute to @code _OTHER @endcode.

If the HTTP instrumentation + could end up converting valid HTTP request methods to @code _OTHER @endcode, then it MUST provide + a way to override the list of known HTTP methods. If this override is done via environment + variable, then the environment variable MUST be named OTEL_INSTRUMENTATION_HTTP_KNOWN_METHODS and + support a comma-separated list of case-sensitive known HTTP methods (this list MUST be a full + override of the default known method, it is not a list of known methods in addition to the + defaults).

HTTP method names are case-sensitive and @code http.request.method @endcode + attribute value MUST match a known HTTP method name exactly. Instrumentations for specific web + frameworks that consider HTTP methods to be case insensitive, SHOULD populate a canonical + equivalent. Tracing instrumentations that do so, MUST also set @code http.request.method_original + @endcode to the original value. */ static constexpr const char *kHttpRequestMethod = "http.request.method"; @@ -97,11 +101,19 @@ static constexpr const char *kHttpResponseHeader = "http.response.header"; static constexpr const char *kHttpResponseStatusCode = "http.response.status_code"; /** - The matched route, that is, the path template in the format used by the respective server - framework.

MUST NOT be populated when this is not supported by the HTTP server framework as - the route attribute should have low-cardinality and the URI path can NOT substitute it. SHOULD - include the application root if - there is one. + The matched route template for the request. This MUST be low-cardinality and include all static + path segments, with dynamic path segments represented with placeholders.

MUST NOT be populated + when this is not supported by the HTTP server framework as the route attribute should have + low-cardinality and the URI path can NOT substitute it. SHOULD include the application root if there is one.

+ A static path segment is a part of the route template with a fixed, low-cardinality value. This + includes literal strings like @code /users/ @endcode and placeholders that are constrained to a + finite, predefined set of values, e.g. @code {controller} @endcode or @code {action} @endcode.

+ A dynamic path segment is a placeholder for a value that can have high cardinality and is not + constrained to a predefined list like static path segments.

Instrumentations SHOULD use + routing information provided by the corresponding web framework. They SHOULD pick the most precise + source of routing information and MAY support custom route formatting. Instrumentations SHOULD + document the format and the API used to obtain the route string. */ static constexpr const char *kHttpRoute = "http.route"; diff --git a/api/include/opentelemetry/semconv/incubating/app_attributes.h b/api/include/opentelemetry/semconv/incubating/app_attributes.h index b8477ee3bb..dae548ec11 100644 --- a/api/include/opentelemetry/semconv/incubating/app_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/app_attributes.h @@ -80,6 +80,24 @@ static constexpr const char *kAppScreenCoordinateX = "app.screen.coordinate.x"; */ static constexpr const char *kAppScreenCoordinateY = "app.screen.coordinate.y"; +/** + An identifier that uniquely differentiates this screen from other screens in the same application. +

+ A screen represents only the part of the device display drawn by the app. It typically contains + multiple widgets or UI components and is larger in scope than individual widgets. Multiple screens + can coexist on the same display simultaneously (e.g., split view on tablets). + */ +static constexpr const char *kAppScreenId = "app.screen.id"; + +/** + The name of an application screen. +

+ A screen represents only the part of the device display drawn by the app. It typically contains + multiple widgets or UI components and is larger in scope than individual widgets. Multiple screens + can coexist on the same display simultaneously (e.g., split view on tablets). + */ +static constexpr const char *kAppScreenName = "app.screen.name"; + /** An identifier that uniquely differentiates this widget from other widgets in the same application.

diff --git a/api/include/opentelemetry/semconv/incubating/azure_attributes.h b/api/include/opentelemetry/semconv/incubating/azure_attributes.h index 1618050f9d..b8fa13674f 100644 --- a/api/include/opentelemetry/semconv/incubating/azure_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/azure_attributes.h @@ -39,8 +39,8 @@ static constexpr const char *kAzureCosmosdbConsistencyLevel = "azure.cosmosdb.co List of regions contacted during operation in the order that they were contacted. If there is more than one region listed, it indicates that the operation was performed on multiple regions i.e. cross-regional call.

Region name matches the format of @code displayName @endcode in Azure - Location API + href="https://learn.microsoft.com/rest/api/resources/subscriptions/list-locations">Azure Location + API */ static constexpr const char *kAzureCosmosdbOperationContactedRegions = "azure.cosmosdb.operation.contacted_regions"; diff --git a/api/include/opentelemetry/semconv/incubating/container_attributes.h b/api/include/opentelemetry/semconv/incubating/container_attributes.h index e0678618e2..4d18ce8b30 100644 --- a/api/include/opentelemetry/semconv/incubating/container_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/container_attributes.h @@ -73,7 +73,7 @@ static constexpr const char *kContainerId = "container.id";

Docker defines a sha256 of the image id; @code container.image.id @endcode corresponds to the @code Image @endcode field from the Docker container inspect API + href="https://docs.docker.com/reference/api/engine/version/v1.43/#tag/Container/operation/ContainerInspect">API endpoint. K8s defines a link to the container registry repository with digest @code "imageID": "registry.azurecr.io /namespace/service/dockerfile@sha256:bdeabd40c3a8a492eaf9e8e44d0ebbb84bac7ee25ac0cf8a7159d25f62555625" @@ -91,7 +91,8 @@ static constexpr const char *kContainerImageName = "container.image.name"; /** Repo digests of the container image as provided by the container runtime.

- Docker + Docker and CRI report those under the @code RepoDigests @endcode field. @@ -100,9 +101,9 @@ static constexpr const char *kContainerImageRepoDigests = "container.image.repo_ /** Container image tags. An example can be found in Docker Image - Inspect. Should be only the @code @endcode section of the full name for example from - @code registry.example.com/my-org/my-image: @endcode. + href="https://docs.docker.com/reference/api/engine/version/v1.43/#tag/Image/operation/ImageInspect">Docker + Image Inspect. Should be only the @code @endcode section of the full name for example + from @code registry.example.com/my-org/my-image: @endcode. */ static constexpr const char *kContainerImageTags = "container.image.tags"; diff --git a/api/include/opentelemetry/semconv/incubating/container_metrics.h b/api/include/opentelemetry/semconv/incubating/container_metrics.h index 1b86744224..9455503f91 100644 --- a/api/include/opentelemetry/semconv/incubating/container_metrics.h +++ b/api/include/opentelemetry/semconv/incubating/container_metrics.h @@ -289,6 +289,151 @@ CreateAsyncDoubleMetricContainerFilesystemUsage(metrics::Meter *meter) unitMetricContainerFilesystemUsage); } +/** + Container memory available. +

+ Available memory for use. This is defined as the memory limit - workingSetBytes. If memory limit + is undefined, the available bytes is omitted. In general, this metric can be derived from cadvisor + and by subtracting the @code container_memory_working_set_bytes @endcode metric from the @code + container_spec_memory_limit_bytes @endcode metric. In K8s, this metric is derived from the MemoryStats.AvailableBytes + field of the PodStats.Memory + of the Kubelet's stats API.

updowncounter + */ +static constexpr const char *kMetricContainerMemoryAvailable = "container.memory.available"; +static constexpr const char *descrMetricContainerMemoryAvailable = "Container memory available."; +static constexpr const char *unitMetricContainerMemoryAvailable = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricContainerMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricContainerMemoryAvailable, + descrMetricContainerMemoryAvailable, + unitMetricContainerMemoryAvailable); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricContainerMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricContainerMemoryAvailable, + descrMetricContainerMemoryAvailable, + unitMetricContainerMemoryAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricContainerMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricContainerMemoryAvailable, + descrMetricContainerMemoryAvailable, + unitMetricContainerMemoryAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricContainerMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricContainerMemoryAvailable, + descrMetricContainerMemoryAvailable, + unitMetricContainerMemoryAvailable); +} + +/** + Container memory paging faults. +

+ In general, this metric can be derived from cadvisor + and specifically the @code container_memory_failures_total{failure_type=pgfault, scope=container} + @endcode and @code container_memory_failures_total{failure_type=pgmajfault, scope=container} + @endcodemetric. In K8s, this metric is derived from the MemoryStats.PageFaults + and MemoryStats.MajorPageFaults + field of the PodStats.Memory + of the Kubelet's stats API.

counter + */ +static constexpr const char *kMetricContainerMemoryPagingFaults = "container.memory.paging.faults"; +static constexpr const char *descrMetricContainerMemoryPagingFaults = + "Container memory paging faults."; +static constexpr const char *unitMetricContainerMemoryPagingFaults = "{fault}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricContainerMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricContainerMemoryPagingFaults, + descrMetricContainerMemoryPagingFaults, + unitMetricContainerMemoryPagingFaults); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricContainerMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricContainerMemoryPagingFaults, + descrMetricContainerMemoryPagingFaults, + unitMetricContainerMemoryPagingFaults); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricContainerMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricContainerMemoryPagingFaults, + descrMetricContainerMemoryPagingFaults, + unitMetricContainerMemoryPagingFaults); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricContainerMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricContainerMemoryPagingFaults, + descrMetricContainerMemoryPagingFaults, + unitMetricContainerMemoryPagingFaults); +} + +/** + Container memory RSS. +

+ In general, this metric can be derived from cadvisor + and specifically the @code container_memory_rss @endcode metric. In K8s, this metric is derived + from the MemoryStats.RSSBytes + field of the PodStats.Memory + of the Kubelet's stats API.

updowncounter + */ +static constexpr const char *kMetricContainerMemoryRss = "container.memory.rss"; +static constexpr const char *descrMetricContainerMemoryRss = "Container memory RSS."; +static constexpr const char *unitMetricContainerMemoryRss = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricContainerMemoryRss(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricContainerMemoryRss, descrMetricContainerMemoryRss, + unitMetricContainerMemoryRss); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricContainerMemoryRss(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricContainerMemoryRss, descrMetricContainerMemoryRss, + unitMetricContainerMemoryRss); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricContainerMemoryRss(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricContainerMemoryRss, descrMetricContainerMemoryRss, unitMetricContainerMemoryRss); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricContainerMemoryRss(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricContainerMemoryRss, descrMetricContainerMemoryRss, unitMetricContainerMemoryRss); +} + /** Memory usage of the container.

@@ -328,6 +473,54 @@ CreateAsyncDoubleMetricContainerMemoryUsage(metrics::Meter *meter) kMetricContainerMemoryUsage, descrMetricContainerMemoryUsage, unitMetricContainerMemoryUsage); } +/** + Container memory working set. +

+ In general, this metric can be derived from cadvisor + and specifically the @code container_memory_working_set_bytes @endcode metric. In K8s, this metric + is derived from the MemoryStats.WorkingSetBytes + field of the PodStats.Memory + of the Kubelet's stats API.

updowncounter + */ +static constexpr const char *kMetricContainerMemoryWorkingSet = "container.memory.working_set"; +static constexpr const char *descrMetricContainerMemoryWorkingSet = "Container memory working set."; +static constexpr const char *unitMetricContainerMemoryWorkingSet = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricContainerMemoryWorkingSet(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricContainerMemoryWorkingSet, + descrMetricContainerMemoryWorkingSet, + unitMetricContainerMemoryWorkingSet); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricContainerMemoryWorkingSet(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricContainerMemoryWorkingSet, + descrMetricContainerMemoryWorkingSet, + unitMetricContainerMemoryWorkingSet); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricContainerMemoryWorkingSet(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricContainerMemoryWorkingSet, + descrMetricContainerMemoryWorkingSet, + unitMetricContainerMemoryWorkingSet); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricContainerMemoryWorkingSet(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricContainerMemoryWorkingSet, + descrMetricContainerMemoryWorkingSet, + unitMetricContainerMemoryWorkingSet); +} + /** Network bytes for the container.

diff --git a/api/include/opentelemetry/semconv/incubating/db_attributes.h b/api/include/opentelemetry/semconv/incubating/db_attributes.h index 31b8f2b74e..f6d81cba32 100644 --- a/api/include/opentelemetry/semconv/incubating/db_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/db_attributes.h @@ -229,8 +229,7 @@ OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbRequestContentL Deprecated, use @code db.response.status_code @endcode instead. @deprecated - {"note": "Replaced by @code db.response.status_code @endcode.", "reason": "renamed", "renamed_to": - "db.response.status_code"} + {"note": "Use @code db.response.status_code @endcode instead.", "reason": "uncategorized"} */ OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbStatusCode = "db.cosmosdb.status_code"; @@ -390,15 +389,18 @@ static constexpr const char *kDbOperationParameter = "db.operation.parameter"; @code db.query.parameter. @endcode SHOULD match up with the parameterized placeholders present in @code db.query.text @endcode.

+ It is RECOMMENDED to capture the value as provided by the application + without attempting to do any case normalization. +

@code db.query.parameter. @endcode SHOULD NOT be captured on batch operations.

Examples:

*/ @@ -439,8 +441,7 @@ static constexpr const char *kDbQueryText = "db.query.text"; Deprecated, use @code db.namespace @endcode instead. @deprecated - {"note": "Replaced by @code db.namespace @endcode.", "reason": "renamed", "renamed_to": - "db.namespace"} + {"note": "Uncategorized.", "reason": "uncategorized"} */ OPENTELEMETRY_DEPRECATED static constexpr const char *kDbRedisDatabaseIndex = "db.redis.database_index"; diff --git a/api/include/opentelemetry/semconv/incubating/dns_attributes.h b/api/include/opentelemetry/semconv/incubating/dns_attributes.h index 827d4d51da..39dc7fe570 100644 --- a/api/include/opentelemetry/semconv/incubating/dns_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/dns_attributes.h @@ -27,10 +27,8 @@ static constexpr const char *kDnsAnswers = "dns.answers"; /** The name being queried.

- If the name field contains non-printable characters (below 32 or above 126), those characters - should be represented as escaped base 10 integers (\DDD). Back slashes and quotes should be - escaped. Tabs, carriage returns, and line feeds should be converted to \t, \r, and \n - respectively. + The name represents the queried domain name as it appears in the DNS query without any additional + normalization. */ static constexpr const char *kDnsQuestionName = "dns.question.name"; diff --git a/api/include/opentelemetry/semconv/incubating/enduser_attributes.h b/api/include/opentelemetry/semconv/incubating/enduser_attributes.h index d117dd268e..2487dbe791 100644 --- a/api/include/opentelemetry/semconv/incubating/enduser_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/enduser_attributes.h @@ -40,8 +40,7 @@ static constexpr const char *kEnduserPseudoId = "enduser.pseudo.id"; Deprecated, use @code user.roles @endcode instead. @deprecated - {"note": "Replaced by @code user.roles @endcode.", "reason": "renamed", "renamed_to": - "user.roles"} + {"note": "Use @code user.roles @endcode instead.", "reason": "uncategorized"} */ OPENTELEMETRY_DEPRECATED static constexpr const char *kEnduserRole = "enduser.role"; diff --git a/api/include/opentelemetry/semconv/incubating/event_attributes.h b/api/include/opentelemetry/semconv/incubating/event_attributes.h index de4d30a570..42ecce2c25 100644 --- a/api/include/opentelemetry/semconv/incubating/event_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/event_attributes.h @@ -23,7 +23,8 @@ namespace event Identifies the class / type of event. @deprecated - {"note": "Replaced by EventName top-level field on the LogRecord.\n", "reason": "uncategorized"} + {"note": "The value of this attribute MUST now be set as the value of the EventName field on the + LogRecord to indicate that the LogRecord represents an Event.\n", "reason": "uncategorized"} */ OPENTELEMETRY_DEPRECATED static constexpr const char *kEventName = "event.name"; diff --git a/api/include/opentelemetry/semconv/incubating/faas_attributes.h b/api/include/opentelemetry/semconv/incubating/faas_attributes.h index 9f9690824b..0427a12d57 100644 --- a/api/include/opentelemetry/semconv/incubating/faas_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/faas_attributes.h @@ -142,9 +142,9 @@ static constexpr const char *kFaasTrigger = "faas.trigger"; (Services): The revision (i.e., the function name plus the revision suffix).

  • Google Cloud Functions: The value of the @code - K_REVISION @endcode environment variable.
  • Azure Functions: Not - applicable. Do not set this attribute.
    • + href="https://cloud.google.com/run/docs/container-contract#services-env-vars">@code K_REVISION + @endcode environment variable.
  • Azure Functions: Not applicable. Do + not set this attribute.
    • */ static constexpr const char *kFaasVersion = "faas.version"; diff --git a/api/include/opentelemetry/semconv/incubating/gcp_attributes.h b/api/include/opentelemetry/semconv/incubating/gcp_attributes.h index 7be353eb7e..74ddef337d 100644 --- a/api/include/opentelemetry/semconv/incubating/gcp_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/gcp_attributes.h @@ -80,6 +80,66 @@ static constexpr const char *kGcpApphubWorkloadEnvironmentType = */ static constexpr const char *kGcpApphubWorkloadId = "gcp.apphub.workload.id"; +/** + The container within GCP where the AppHub destination application is defined. + */ +static constexpr const char *kGcpApphubDestinationApplicationContainer = + "gcp.apphub_destination.application.container"; + +/** + The name of the destination application as configured in AppHub. + */ +static constexpr const char *kGcpApphubDestinationApplicationId = + "gcp.apphub_destination.application.id"; + +/** + The GCP zone or region where the destination application is defined. + */ +static constexpr const char *kGcpApphubDestinationApplicationLocation = + "gcp.apphub_destination.application.location"; + +/** + Criticality of a destination workload indicates its importance to the business as specified in AppHub type + enum + */ +static constexpr const char *kGcpApphubDestinationServiceCriticalityType = + "gcp.apphub_destination.service.criticality_type"; + +/** + Software lifecycle stage of a destination service as defined AppHub + environment type + */ +static constexpr const char *kGcpApphubDestinationServiceEnvironmentType = + "gcp.apphub_destination.service.environment_type"; + +/** + The name of the destination service as configured in AppHub. + */ +static constexpr const char *kGcpApphubDestinationServiceId = "gcp.apphub_destination.service.id"; + +/** + Criticality of a destination workload indicates its importance to the business as specified in AppHub type + enum + */ +static constexpr const char *kGcpApphubDestinationWorkloadCriticalityType = + "gcp.apphub_destination.workload.criticality_type"; + +/** + Environment of a destination workload is the stage of a software lifecycle as provided in the AppHub + environment type + */ +static constexpr const char *kGcpApphubDestinationWorkloadEnvironmentType = + "gcp.apphub_destination.workload.environment_type"; + +/** + The name of the destination workload as configured in AppHub. + */ +static constexpr const char *kGcpApphubDestinationWorkloadId = "gcp.apphub_destination.workload.id"; + /** Identifies the Google Cloud service for which the official client library is intended.

    @@ -216,6 +276,102 @@ static constexpr const char *kDevelopment = "DEVELOPMENT"; } // namespace GcpApphubWorkloadEnvironmentTypeValues +namespace GcpApphubDestinationServiceCriticalityTypeValues +{ +/** + Mission critical service. + */ +static constexpr const char *kMissionCritical = "MISSION_CRITICAL"; + +/** + High impact. + */ +static constexpr const char *kHigh = "HIGH"; + +/** + Medium impact. + */ +static constexpr const char *kMedium = "MEDIUM"; + +/** + Low impact. + */ +static constexpr const char *kLow = "LOW"; + +} // namespace GcpApphubDestinationServiceCriticalityTypeValues + +namespace GcpApphubDestinationServiceEnvironmentTypeValues +{ +/** + Production environment. + */ +static constexpr const char *kProduction = "PRODUCTION"; + +/** + Staging environment. + */ +static constexpr const char *kStaging = "STAGING"; + +/** + Test environment. + */ +static constexpr const char *kTest = "TEST"; + +/** + Development environment. + */ +static constexpr const char *kDevelopment = "DEVELOPMENT"; + +} // namespace GcpApphubDestinationServiceEnvironmentTypeValues + +namespace GcpApphubDestinationWorkloadCriticalityTypeValues +{ +/** + Mission critical service. + */ +static constexpr const char *kMissionCritical = "MISSION_CRITICAL"; + +/** + High impact. + */ +static constexpr const char *kHigh = "HIGH"; + +/** + Medium impact. + */ +static constexpr const char *kMedium = "MEDIUM"; + +/** + Low impact. + */ +static constexpr const char *kLow = "LOW"; + +} // namespace GcpApphubDestinationWorkloadCriticalityTypeValues + +namespace GcpApphubDestinationWorkloadEnvironmentTypeValues +{ +/** + Production environment. + */ +static constexpr const char *kProduction = "PRODUCTION"; + +/** + Staging environment. + */ +static constexpr const char *kStaging = "STAGING"; + +/** + Test environment. + */ +static constexpr const char *kTest = "TEST"; + +/** + Development environment. + */ +static constexpr const char *kDevelopment = "DEVELOPMENT"; + +} // namespace GcpApphubDestinationWorkloadEnvironmentTypeValues + } // namespace gcp } // namespace semconv OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/semconv/incubating/gen_ai_attributes.h b/api/include/opentelemetry/semconv/incubating/gen_ai_attributes.h index 50bfff5317..711a8bf380 100644 --- a/api/include/opentelemetry/semconv/incubating/gen_ai_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/gen_ai_attributes.h @@ -61,6 +61,37 @@ static constexpr const char *kGenAiConversationId = "gen_ai.conversation.id"; */ static constexpr const char *kGenAiDataSourceId = "gen_ai.data_source.id"; +/** + The number of dimensions the resulting output embeddings should have. + */ +static constexpr const char *kGenAiEmbeddingsDimensionCount = "gen_ai.embeddings.dimension.count"; + +/** + A free-form explanation for the assigned score provided by the evaluator. + */ +static constexpr const char *kGenAiEvaluationExplanation = "gen_ai.evaluation.explanation"; + +/** + The name of the evaluation metric used for the GenAI response. + */ +static constexpr const char *kGenAiEvaluationName = "gen_ai.evaluation.name"; + +/** + Human readable label for evaluation. +

    + This attribute provides a human-readable interpretation of the evaluation score produced by an + evaluator. For example, a score value of 1 could mean "relevant" in one evaluation system and "not + relevant" in another, depending on the scoring range and evaluator. The label SHOULD have low + cardinality. Possible values depend on the evaluation metric and evaluator used; implementations + SHOULD document the possible values. + */ +static constexpr const char *kGenAiEvaluationScoreLabel = "gen_ai.evaluation.score.label"; + +/** + The evaluation score returned by the evaluator. + */ +static constexpr const char *kGenAiEvaluationScoreValue = "gen_ai.evaluation.score.value"; + /** The chat history provided to the model as an input.

    @@ -313,11 +344,52 @@ static constexpr const char *kGenAiSystemInstructions = "gen_ai.system_instructi */ static constexpr const char *kGenAiTokenType = "gen_ai.token.type"; +/** + Parameters passed to the tool call. +

    + [!WARNING] + This attribute may contain sensitive information.
    +

    + It's expected to be an object - in case a serialized string is available + to the instrumentation, the instrumentation SHOULD do the best effort to + deserialize it to an object. When recorded on spans, it MAY be recorded as a JSON string if + structured format is not supported and SHOULD be recorded in structured form otherwise. + */ +static constexpr const char *kGenAiToolCallArguments = "gen_ai.tool.call.arguments"; + /** The tool call identifier. */ static constexpr const char *kGenAiToolCallId = "gen_ai.tool.call.id"; +/** + The result returned by the tool call (if any and if execution was successful). +

    + [!WARNING] + This attribute may contain sensitive information.
    +

    + It's expected to be an object - in case a serialized string is available + to the instrumentation, the instrumentation SHOULD do the best effort to + deserialize it to an object. When recorded on spans, it MAY be recorded as a JSON string if + structured format is not supported and SHOULD be recorded in structured form otherwise. + */ +static constexpr const char *kGenAiToolCallResult = "gen_ai.tool.call.result"; + +/** + The list of source system tool definitions available to the GenAI agent or model. +

    + The value of this attribute matches source system tool definition format. +

    + It's expected to be an array of objects where each object represents a tool definition. In case a + serialized string is available to the instrumentation, the instrumentation SHOULD do the best + effort to deserialize it to an array. When recorded on spans, it MAY be recorded as a JSON string + if structured format is not supported and SHOULD be recorded in structured form otherwise.

    + Since this attribute could be large, it's NOT RECOMMENDED to populate + it by default. Instrumentations MAY provide a way to enable + populating this attribute. + */ +static constexpr const char *kGenAiToolDefinitions = "gen_ai.tool.definitions"; + /** The tool description. */ @@ -604,13 +676,21 @@ static constexpr const char *kCohere = "cohere"; /** Azure AI Inference + + @deprecated + {"note": "Replaced by @code azure.ai.inference @endcode.", "reason": "renamed", "renamed_to": + "azure.ai.inference"} */ -static constexpr const char *kAzAiInference = "az.ai.inference"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kAzAiInference = "az.ai.inference"; /** Azure OpenAI + + @deprecated + {"note": "Replaced by @code azure.ai.openai @endcode.", "reason": "renamed", "renamed_to": + "azure.ai.openai"} */ -static constexpr const char *kAzAiOpenai = "az.ai.openai"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kAzAiOpenai = "az.ai.openai"; /** Azure AI Inference @@ -639,11 +719,8 @@ static constexpr const char *kPerplexity = "perplexity"; /** xAI - - @deprecated - {"note": "Replaced by @code x_ai @endcode.", "reason": "renamed", "renamed_to": "x_ai"} */ -OPENTELEMETRY_DEPRECATED static constexpr const char *kXai = "xai"; +static constexpr const char *kXai = "xai"; /** DeepSeek diff --git a/api/include/opentelemetry/semconv/incubating/http_attributes.h b/api/include/opentelemetry/semconv/incubating/http_attributes.h index f8cebe1751..1af52bbb62 100644 --- a/api/include/opentelemetry/semconv/incubating/http_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/http_attributes.h @@ -34,11 +34,12 @@ OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpClientIp = "http.clie static constexpr const char *kHttpConnectionState = "http.connection.state"; /** - Deprecated, use @code network.protocol.name @endcode instead. + Deprecated, use @code network.protocol.name @endcode and @code network.protocol.version @endcode + instead. @deprecated - {"note": "Replaced by @code network.protocol.name @endcode.", "reason": "renamed", "renamed_to": - "network.protocol.name"} + {"note": "Split into @code network.protocol.name @endcode and @code network.protocol.version + @endcode", "reason": "uncategorized"} */ OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpFlavor = "http.flavor"; @@ -93,19 +94,23 @@ static constexpr const char *kHttpRequestHeader = "http.request.header";

    HTTP request method value SHOULD be "known" to the instrumentation. By default, this convention defines "known" methods as the ones listed in RFC9110 and the PATCH method - defined in RFC5789.

    If the HTTP - request method is not known to instrumentation, it MUST set the @code http.request.method @endcode - attribute to @code _OTHER @endcode.

    If the HTTP instrumentation could end up converting valid - HTTP request methods to @code _OTHER @endcode, then it MUST provide a way to override the list of - known HTTP methods. If this override is done via environment variable, then the environment - variable MUST be named OTEL_INSTRUMENTATION_HTTP_KNOWN_METHODS and support a comma-separated list - of case-sensitive known HTTP methods (this list MUST be a full override of the default known - method, it is not a list of known methods in addition to the defaults).

    HTTP method names are - case-sensitive and @code http.request.method @endcode attribute value MUST match a known HTTP - method name exactly. Instrumentations for specific web frameworks that consider HTTP methods to be - case insensitive, SHOULD populate a canonical equivalent. Tracing instrumentations that do so, - MUST also set @code http.request.method_original @endcode to the original value. + href="https://www.rfc-editor.org/rfc/rfc9110.html#name-methods">RFC9110, the PATCH method + defined in RFC5789 and the QUERY method + defined in httpbis-safe-method-w-body. +

    + If the HTTP request method is not known to instrumentation, it MUST set the @code + http.request.method @endcode attribute to @code _OTHER @endcode.

    If the HTTP instrumentation + could end up converting valid HTTP request methods to @code _OTHER @endcode, then it MUST provide + a way to override the list of known HTTP methods. If this override is done via environment + variable, then the environment variable MUST be named OTEL_INSTRUMENTATION_HTTP_KNOWN_METHODS and + support a comma-separated list of case-sensitive known HTTP methods (this list MUST be a full + override of the default known method, it is not a list of known methods in addition to the + defaults).

    HTTP method names are case-sensitive and @code http.request.method @endcode + attribute value MUST match a known HTTP method name exactly. Instrumentations for specific web + frameworks that consider HTTP methods to be case insensitive, SHOULD populate a canonical + equivalent. Tracing instrumentations that do so, MUST also set @code http.request.method_original + @endcode to the original value. */ static constexpr const char *kHttpRequestMethod = "http.request.method"; @@ -209,11 +214,19 @@ OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpResponseContentLength "http.response_content_length_uncompressed"; /** - The matched route, that is, the path template in the format used by the respective server - framework.

    MUST NOT be populated when this is not supported by the HTTP server framework as - the route attribute should have low-cardinality and the URI path can NOT substitute it. SHOULD - include the application root if - there is one. + The matched route template for the request. This MUST be low-cardinality and include all static + path segments, with dynamic path segments represented with placeholders.

    MUST NOT be populated + when this is not supported by the HTTP server framework as the route attribute should have + low-cardinality and the URI path can NOT substitute it. SHOULD include the application root if there is one.

    + A static path segment is a part of the route template with a fixed, low-cardinality value. This + includes literal strings like @code /users/ @endcode and placeholders that are constrained to a + finite, predefined set of values, e.g. @code {controller} @endcode or @code {action} @endcode.

    + A dynamic path segment is a placeholder for a value that can have high cardinality and is not + constrained to a predefined list like static path segments.

    Instrumentations SHOULD use + routing information provided by the corresponding web framework. They SHOULD pick the most precise + source of routing information and MAY support custom route formatting. Instrumentations SHOULD + document the format and the API used to obtain the route string. */ static constexpr const char *kHttpRoute = "http.route"; @@ -364,6 +377,11 @@ static constexpr const char *kPut = "PUT"; */ static constexpr const char *kTrace = "TRACE"; +/** + QUERY method. + */ +static constexpr const char *kQuery = "QUERY"; + /** Any HTTP method that the instrumentation has no prior knowledge of. */ diff --git a/api/include/opentelemetry/semconv/incubating/k8s_attributes.h b/api/include/opentelemetry/semconv/incubating/k8s_attributes.h index 80ef2a964b..8f18cfa4fe 100644 --- a/api/include/opentelemetry/semconv/incubating/k8s_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/k8s_attributes.h @@ -391,6 +391,20 @@ OPENTELEMETRY_DEPRECATED static constexpr const char *kK8sPodLabels = "k8s.pod.l */ static constexpr const char *kK8sPodName = "k8s.pod.name"; +/** + The phase for the pod. Corresponds to the @code phase @endcode field of the: K8s + PodStatus + */ +static constexpr const char *kK8sPodStatusPhase = "k8s.pod.status.phase"; + +/** + The reason for the pod state. Corresponds to the @code reason @endcode field of the: K8s + PodStatus + */ +static constexpr const char *kK8sPodStatusReason = "k8s.pod.status.reason"; + /** The UID of the Pod. */ @@ -450,7 +464,7 @@ static constexpr const char *kK8sResourcequotaName = "k8s.resourcequota.name"; string (e.g., count/deployments.apps, count/pods), or, for certain core Kubernetes resources, just the resource name (e.g., pods, services, configmaps). Both forms are supported by Kubernetes for object count quotas. See Kubernetes + href="https://kubernetes.io/docs/concepts/policy/resource-quotas/#quota-on-object-count">Kubernetes Resource Quotas documentation for more details. */ static constexpr const char *kK8sResourcequotaResourceName = "k8s.resourcequota.resource_name"; @@ -633,6 +647,72 @@ static constexpr const char *kNetworkUnavailable = "NetworkUnavailable"; } // namespace K8sNodeConditionTypeValues +namespace K8sPodStatusPhaseValues +{ +/** + The pod has been accepted by the system, but one or more of the containers has not been started. + This includes time before being bound to a node, as well as time spent pulling images onto the + host. + */ +static constexpr const char *kPending = "Pending"; + +/** + The pod has been bound to a node and all of the containers have been started. At least one + container is still running or is in the process of being restarted. + */ +static constexpr const char *kRunning = "Running"; + +/** + All containers in the pod have voluntarily terminated with a container exit code of 0, and the + system is not going to restart any of these containers. + */ +static constexpr const char *kSucceeded = "Succeeded"; + +/** + All containers in the pod have terminated, and at least one container has terminated in a failure + (exited with a non-zero exit code or was stopped by the system). + */ +static constexpr const char *kFailed = "Failed"; + +/** + For some reason the state of the pod could not be obtained, typically due to an error in + communicating with the host of the pod. + */ +static constexpr const char *kUnknown = "Unknown"; + +} // namespace K8sPodStatusPhaseValues + +namespace K8sPodStatusReasonValues +{ +/** + The pod is evicted. + */ +static constexpr const char *kEvicted = "Evicted"; + +/** + The pod is in a status because of its node affinity + */ +static constexpr const char *kNodeAffinity = "NodeAffinity"; + +/** + The reason on a pod when its state cannot be confirmed as kubelet is unresponsive on the node it + is (was) running. + */ +static constexpr const char *kNodeLost = "NodeLost"; + +/** + The node is shutdown + */ +static constexpr const char *kShutdown = "Shutdown"; + +/** + The pod was rejected admission to the node because of an error during admission that could not be + categorized. + */ +static constexpr const char *kUnexpectedAdmissionError = "UnexpectedAdmissionError"; + +} // namespace K8sPodStatusReasonValues + namespace K8sVolumeTypeValues { /** diff --git a/api/include/opentelemetry/semconv/incubating/k8s_metrics.h b/api/include/opentelemetry/semconv/incubating/k8s_metrics.h index 678b24ff85..e925e6a8ff 100644 --- a/api/include/opentelemetry/semconv/incubating/k8s_metrics.h +++ b/api/include/opentelemetry/semconv/incubating/k8s_metrics.h @@ -60,6 +60,53 @@ CreateAsyncDoubleMetricK8sContainerCpuLimit(metrics::Meter *meter) kMetricK8sContainerCpuLimit, descrMetricK8sContainerCpuLimit, unitMetricK8sContainerCpuLimit); } +/** + The ratio of container CPU usage to its CPU limit. +

    + The value range is [0.0,1.0]. A value of 1.0 means the container is using 100% of its CPU limit. + If the CPU limit is not set, this metric SHOULD NOT be emitted for that container.

    gauge + */ +static constexpr const char *kMetricK8sContainerCpuLimitUtilization = + "k8s.container.cpu.limit_utilization"; +static constexpr const char *descrMetricK8sContainerCpuLimitUtilization = + "The ratio of container CPU usage to its CPU limit."; +static constexpr const char *unitMetricK8sContainerCpuLimitUtilization = "1"; + +#if OPENTELEMETRY_ABI_VERSION_NO >= 2 + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sContainerCpuLimitUtilization(metrics::Meter *meter) +{ + return meter->CreateInt64Gauge(kMetricK8sContainerCpuLimitUtilization, + descrMetricK8sContainerCpuLimitUtilization, + unitMetricK8sContainerCpuLimitUtilization); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sContainerCpuLimitUtilization(metrics::Meter *meter) +{ + return meter->CreateDoubleGauge(kMetricK8sContainerCpuLimitUtilization, + descrMetricK8sContainerCpuLimitUtilization, + unitMetricK8sContainerCpuLimitUtilization); +} +#endif /* OPENTELEMETRY_ABI_VERSION_NO */ + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sContainerCpuLimitUtilization(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableGauge(kMetricK8sContainerCpuLimitUtilization, + descrMetricK8sContainerCpuLimitUtilization, + unitMetricK8sContainerCpuLimitUtilization); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sContainerCpuLimitUtilization(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableGauge(kMetricK8sContainerCpuLimitUtilization, + descrMetricK8sContainerCpuLimitUtilization, + unitMetricK8sContainerCpuLimitUtilization); +} + /** CPU resource requested for the container.

    @@ -104,6 +151,52 @@ CreateAsyncDoubleMetricK8sContainerCpuRequest(metrics::Meter *meter) unitMetricK8sContainerCpuRequest); } +/** + The ratio of container CPU usage to its CPU request. +

    + gauge + */ +static constexpr const char *kMetricK8sContainerCpuRequestUtilization = + "k8s.container.cpu.request_utilization"; +static constexpr const char *descrMetricK8sContainerCpuRequestUtilization = + "The ratio of container CPU usage to its CPU request."; +static constexpr const char *unitMetricK8sContainerCpuRequestUtilization = "1"; + +#if OPENTELEMETRY_ABI_VERSION_NO >= 2 + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sContainerCpuRequestUtilization(metrics::Meter *meter) +{ + return meter->CreateInt64Gauge(kMetricK8sContainerCpuRequestUtilization, + descrMetricK8sContainerCpuRequestUtilization, + unitMetricK8sContainerCpuRequestUtilization); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sContainerCpuRequestUtilization(metrics::Meter *meter) +{ + return meter->CreateDoubleGauge(kMetricK8sContainerCpuRequestUtilization, + descrMetricK8sContainerCpuRequestUtilization, + unitMetricK8sContainerCpuRequestUtilization); +} +#endif /* OPENTELEMETRY_ABI_VERSION_NO */ + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sContainerCpuRequestUtilization(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableGauge(kMetricK8sContainerCpuRequestUtilization, + descrMetricK8sContainerCpuRequestUtilization, + unitMetricK8sContainerCpuRequestUtilization); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sContainerCpuRequestUtilization(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableGauge(kMetricK8sContainerCpuRequestUtilization, + descrMetricK8sContainerCpuRequestUtilization, + unitMetricK8sContainerCpuRequestUtilization); +} + /** Maximum ephemeral storage resource limit set for the container.

    @@ -548,40 +641,42 @@ CreateAsyncDoubleMetricK8sContainerStorageRequest(metrics::Meter *meter) } /** - The number of actively running jobs for a cronjob. -

    - This metric aligns with the @code active @endcode field of the - This metric aligns with the @code active @endcode field of the K8s CronJobStatus.

    updowncounter */ -static constexpr const char *kMetricK8sCronjobActiveJobs = "k8s.cronjob.active_jobs"; -static constexpr const char *descrMetricK8sCronjobActiveJobs = - "The number of actively running jobs for a cronjob."; -static constexpr const char *unitMetricK8sCronjobActiveJobs = "{job}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sCronjobActiveJobs = + "k8s.cronjob.active_jobs"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sCronjobActiveJobs = + "Deprecated, use `k8s.cronjob.job.active` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sCronjobActiveJobs = "{job}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sCronjobActiveJobs(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter( kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sCronjobActiveJobs(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter( kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sCronjobActiveJobs(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter( kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sCronjobActiveJobs(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter( @@ -589,21 +684,64 @@ CreateAsyncDoubleMetricK8sCronjobActiveJobs(metrics::Meter *meter) } /** - Number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod. + The number of actively running jobs for a cronjob.

    - This metric aligns with the @code currentNumberScheduled @endcode field of the + This metric aligns with the @code active @endcode field of the K8s + CronJobStatus.

    updowncounter + */ +static constexpr const char *kMetricK8sCronjobJobActive = "k8s.cronjob.job.active"; +static constexpr const char *descrMetricK8sCronjobJobActive = + "The number of actively running jobs for a cronjob."; +static constexpr const char *unitMetricK8sCronjobJobActive = "{job}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sCronjobJobActive(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sCronjobJobActive, descrMetricK8sCronjobJobActive, + unitMetricK8sCronjobJobActive); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sCronjobJobActive(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter( + kMetricK8sCronjobJobActive, descrMetricK8sCronjobJobActive, unitMetricK8sCronjobJobActive); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sCronjobJobActive(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sCronjobJobActive, descrMetricK8sCronjobJobActive, unitMetricK8sCronjobJobActive); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sCronjobJobActive(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sCronjobJobActive, descrMetricK8sCronjobJobActive, unitMetricK8sCronjobJobActive); +} + +/** + Deprecated, use @code k8s.daemonset.node.current_scheduled @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.daemonset.node.current_scheduled @endcode.", "reason": "renamed", + "renamed_to": "k8s.daemonset.node.current_scheduled"}

    This metric aligns with the @code + currentNumberScheduled @endcode field of the K8s DaemonSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sDaemonsetCurrentScheduledNodes = +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sDaemonsetCurrentScheduledNodes = "k8s.daemonset.current_scheduled_nodes"; -static constexpr const char *descrMetricK8sDaemonsetCurrentScheduledNodes = - "Number of nodes that are running at least 1 daemon pod and are supposed to run the daemon " - "pod."; -static constexpr const char *unitMetricK8sDaemonsetCurrentScheduledNodes = "{node}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sDaemonsetCurrentScheduledNodes = + "Deprecated, use `k8s.daemonset.node.current_scheduled` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sDaemonsetCurrentScheduledNodes = + "{node}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes, @@ -611,7 +749,7 @@ CreateSyncInt64MetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter) unitMetricK8sDaemonsetCurrentScheduledNodes); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes, @@ -619,7 +757,7 @@ CreateSyncDoubleMetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter) unitMetricK8sDaemonsetCurrentScheduledNodes); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes, @@ -627,7 +765,7 @@ CreateAsyncInt64MetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter) unitMetricK8sDaemonsetCurrentScheduledNodes); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes, @@ -636,19 +774,23 @@ CreateAsyncDoubleMetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter) } /** - Number of nodes that should be running the daemon pod (including nodes currently running the - daemon pod).

    This metric aligns with the @code desiredNumberScheduled @endcode field of the This metric aligns with the @code + desiredNumberScheduled @endcode field of the K8s DaemonSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sDaemonsetDesiredScheduledNodes = +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sDaemonsetDesiredScheduledNodes = "k8s.daemonset.desired_scheduled_nodes"; -static constexpr const char *descrMetricK8sDaemonsetDesiredScheduledNodes = - "Number of nodes that should be running the daemon pod (including nodes currently running the " - "daemon pod)."; -static constexpr const char *unitMetricK8sDaemonsetDesiredScheduledNodes = "{node}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sDaemonsetDesiredScheduledNodes = + "Deprecated, use `k8s.daemonset.node.desired_scheduled` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sDaemonsetDesiredScheduledNodes = + "{node}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes, @@ -656,7 +798,7 @@ CreateSyncInt64MetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter) unitMetricK8sDaemonsetDesiredScheduledNodes); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes, @@ -664,7 +806,7 @@ CreateSyncDoubleMetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter) unitMetricK8sDaemonsetDesiredScheduledNodes); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes, @@ -672,7 +814,7 @@ CreateAsyncInt64MetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter) unitMetricK8sDaemonsetDesiredScheduledNodes); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes, @@ -681,20 +823,23 @@ CreateAsyncDoubleMetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter) } /** - Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod. -

    - This metric aligns with the @code numberMisscheduled @endcode field of the - This metric aligns with the @code + numberMisscheduled @endcode field of the K8s DaemonSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sDaemonsetMisscheduledNodes = +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sDaemonsetMisscheduledNodes = "k8s.daemonset.misscheduled_nodes"; -static constexpr const char *descrMetricK8sDaemonsetMisscheduledNodes = - "Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod."; -static constexpr const char *unitMetricK8sDaemonsetMisscheduledNodes = "{node}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sDaemonsetMisscheduledNodes = + "Deprecated, use `k8s.daemonset.node.misscheduled` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sDaemonsetMisscheduledNodes = + "{node}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetMisscheduledNodes, @@ -702,7 +847,7 @@ CreateSyncInt64MetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter) unitMetricK8sDaemonsetMisscheduledNodes); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetMisscheduledNodes, @@ -710,7 +855,7 @@ CreateSyncDoubleMetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter) unitMetricK8sDaemonsetMisscheduledNodes); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetMisscheduledNodes, @@ -718,7 +863,7 @@ CreateAsyncInt64MetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter) unitMetricK8sDaemonsetMisscheduledNodes); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetMisscheduledNodes, @@ -727,212 +872,503 @@ CreateAsyncDoubleMetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter) } /** - Number of nodes that should be running the daemon pod and have one or more of the daemon pod - running and ready.

    This metric aligns with the @code numberReady @endcode field of the + This metric aligns with the @code currentNumberScheduled @endcode field of the + K8s DaemonSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sDaemonsetReadyNodes = "k8s.daemonset.ready_nodes"; -static constexpr const char *descrMetricK8sDaemonsetReadyNodes = - "Number of nodes that should be running the daemon pod and have one or more of the daemon pod " - "running and ready."; -static constexpr const char *unitMetricK8sDaemonsetReadyNodes = "{node}"; +static constexpr const char *kMetricK8sDaemonsetNodeCurrentScheduled = + "k8s.daemonset.node.current_scheduled"; +static constexpr const char *descrMetricK8sDaemonsetNodeCurrentScheduled = + "Number of nodes that are running at least 1 daemon pod and are supposed to run the daemon " + "pod."; +static constexpr const char *unitMetricK8sDaemonsetNodeCurrentScheduled = "{node}"; static inline nostd::unique_ptr> -CreateSyncInt64MetricK8sDaemonsetReadyNodes(metrics::Meter *meter) +CreateSyncInt64MetricK8sDaemonsetNodeCurrentScheduled(metrics::Meter *meter) { - return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetReadyNodes, - descrMetricK8sDaemonsetReadyNodes, - unitMetricK8sDaemonsetReadyNodes); + return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetNodeCurrentScheduled, + descrMetricK8sDaemonsetNodeCurrentScheduled, + unitMetricK8sDaemonsetNodeCurrentScheduled); } static inline nostd::unique_ptr> -CreateSyncDoubleMetricK8sDaemonsetReadyNodes(metrics::Meter *meter) +CreateSyncDoubleMetricK8sDaemonsetNodeCurrentScheduled(metrics::Meter *meter) { - return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetReadyNodes, - descrMetricK8sDaemonsetReadyNodes, - unitMetricK8sDaemonsetReadyNodes); + return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetNodeCurrentScheduled, + descrMetricK8sDaemonsetNodeCurrentScheduled, + unitMetricK8sDaemonsetNodeCurrentScheduled); } static inline nostd::shared_ptr -CreateAsyncInt64MetricK8sDaemonsetReadyNodes(metrics::Meter *meter) +CreateAsyncInt64MetricK8sDaemonsetNodeCurrentScheduled(metrics::Meter *meter) { - return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetReadyNodes, - descrMetricK8sDaemonsetReadyNodes, - unitMetricK8sDaemonsetReadyNodes); + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetNodeCurrentScheduled, + descrMetricK8sDaemonsetNodeCurrentScheduled, + unitMetricK8sDaemonsetNodeCurrentScheduled); } static inline nostd::shared_ptr -CreateAsyncDoubleMetricK8sDaemonsetReadyNodes(metrics::Meter *meter) +CreateAsyncDoubleMetricK8sDaemonsetNodeCurrentScheduled(metrics::Meter *meter) { - return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetReadyNodes, - descrMetricK8sDaemonsetReadyNodes, - unitMetricK8sDaemonsetReadyNodes); + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetNodeCurrentScheduled, + descrMetricK8sDaemonsetNodeCurrentScheduled, + unitMetricK8sDaemonsetNodeCurrentScheduled); } /** - Total number of available replica pods (ready for at least minReadySeconds) targeted by this - deployment.

    This metric aligns with the @code availableReplicas @endcode field of the K8s - DeploymentStatus.

    updowncounter + Number of nodes that should be running the daemon pod (including nodes currently running the + daemon pod).

    This metric aligns with the @code desiredNumberScheduled @endcode field of the K8s + DaemonSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sDeploymentAvailablePods = "k8s.deployment.available_pods"; -static constexpr const char *descrMetricK8sDeploymentAvailablePods = - "Total number of available replica pods (ready for at least minReadySeconds) targeted by this " - "deployment."; -static constexpr const char *unitMetricK8sDeploymentAvailablePods = "{pod}"; +static constexpr const char *kMetricK8sDaemonsetNodeDesiredScheduled = + "k8s.daemonset.node.desired_scheduled"; +static constexpr const char *descrMetricK8sDaemonsetNodeDesiredScheduled = + "Number of nodes that should be running the daemon pod (including nodes currently running the " + "daemon pod)."; +static constexpr const char *unitMetricK8sDaemonsetNodeDesiredScheduled = "{node}"; static inline nostd::unique_ptr> -CreateSyncInt64MetricK8sDeploymentAvailablePods(metrics::Meter *meter) +CreateSyncInt64MetricK8sDaemonsetNodeDesiredScheduled(metrics::Meter *meter) { - return meter->CreateInt64UpDownCounter(kMetricK8sDeploymentAvailablePods, - descrMetricK8sDeploymentAvailablePods, - unitMetricK8sDeploymentAvailablePods); + return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetNodeDesiredScheduled, + descrMetricK8sDaemonsetNodeDesiredScheduled, + unitMetricK8sDaemonsetNodeDesiredScheduled); } static inline nostd::unique_ptr> -CreateSyncDoubleMetricK8sDeploymentAvailablePods(metrics::Meter *meter) +CreateSyncDoubleMetricK8sDaemonsetNodeDesiredScheduled(metrics::Meter *meter) { - return meter->CreateDoubleUpDownCounter(kMetricK8sDeploymentAvailablePods, - descrMetricK8sDeploymentAvailablePods, - unitMetricK8sDeploymentAvailablePods); + return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetNodeDesiredScheduled, + descrMetricK8sDaemonsetNodeDesiredScheduled, + unitMetricK8sDaemonsetNodeDesiredScheduled); } static inline nostd::shared_ptr -CreateAsyncInt64MetricK8sDeploymentAvailablePods(metrics::Meter *meter) +CreateAsyncInt64MetricK8sDaemonsetNodeDesiredScheduled(metrics::Meter *meter) { - return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDeploymentAvailablePods, - descrMetricK8sDeploymentAvailablePods, - unitMetricK8sDeploymentAvailablePods); + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetNodeDesiredScheduled, + descrMetricK8sDaemonsetNodeDesiredScheduled, + unitMetricK8sDaemonsetNodeDesiredScheduled); } static inline nostd::shared_ptr -CreateAsyncDoubleMetricK8sDeploymentAvailablePods(metrics::Meter *meter) +CreateAsyncDoubleMetricK8sDaemonsetNodeDesiredScheduled(metrics::Meter *meter) { - return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDeploymentAvailablePods, - descrMetricK8sDeploymentAvailablePods, - unitMetricK8sDeploymentAvailablePods); + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetNodeDesiredScheduled, + descrMetricK8sDaemonsetNodeDesiredScheduled, + unitMetricK8sDaemonsetNodeDesiredScheduled); } /** - Number of desired replica pods in this deployment. + Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod.

    - This metric aligns with the @code replicas @endcode field of the + This metric aligns with the @code numberMisscheduled @endcode field of the K8s - DeploymentSpec.

    updowncounter + href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps">K8s + DaemonSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sDeploymentDesiredPods = "k8s.deployment.desired_pods"; -static constexpr const char *descrMetricK8sDeploymentDesiredPods = - "Number of desired replica pods in this deployment."; -static constexpr const char *unitMetricK8sDeploymentDesiredPods = "{pod}"; +static constexpr const char *kMetricK8sDaemonsetNodeMisscheduled = + "k8s.daemonset.node.misscheduled"; +static constexpr const char *descrMetricK8sDaemonsetNodeMisscheduled = + "Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod."; +static constexpr const char *unitMetricK8sDaemonsetNodeMisscheduled = "{node}"; static inline nostd::unique_ptr> -CreateSyncInt64MetricK8sDeploymentDesiredPods(metrics::Meter *meter) +CreateSyncInt64MetricK8sDaemonsetNodeMisscheduled(metrics::Meter *meter) { - return meter->CreateInt64UpDownCounter(kMetricK8sDeploymentDesiredPods, - descrMetricK8sDeploymentDesiredPods, - unitMetricK8sDeploymentDesiredPods); + return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetNodeMisscheduled, + descrMetricK8sDaemonsetNodeMisscheduled, + unitMetricK8sDaemonsetNodeMisscheduled); } static inline nostd::unique_ptr> -CreateSyncDoubleMetricK8sDeploymentDesiredPods(metrics::Meter *meter) +CreateSyncDoubleMetricK8sDaemonsetNodeMisscheduled(metrics::Meter *meter) { - return meter->CreateDoubleUpDownCounter(kMetricK8sDeploymentDesiredPods, - descrMetricK8sDeploymentDesiredPods, - unitMetricK8sDeploymentDesiredPods); + return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetNodeMisscheduled, + descrMetricK8sDaemonsetNodeMisscheduled, + unitMetricK8sDaemonsetNodeMisscheduled); } static inline nostd::shared_ptr -CreateAsyncInt64MetricK8sDeploymentDesiredPods(metrics::Meter *meter) +CreateAsyncInt64MetricK8sDaemonsetNodeMisscheduled(metrics::Meter *meter) { - return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDeploymentDesiredPods, - descrMetricK8sDeploymentDesiredPods, - unitMetricK8sDeploymentDesiredPods); + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetNodeMisscheduled, + descrMetricK8sDaemonsetNodeMisscheduled, + unitMetricK8sDaemonsetNodeMisscheduled); } static inline nostd::shared_ptr -CreateAsyncDoubleMetricK8sDeploymentDesiredPods(metrics::Meter *meter) +CreateAsyncDoubleMetricK8sDaemonsetNodeMisscheduled(metrics::Meter *meter) { - return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDeploymentDesiredPods, - descrMetricK8sDeploymentDesiredPods, - unitMetricK8sDeploymentDesiredPods); + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetNodeMisscheduled, + descrMetricK8sDaemonsetNodeMisscheduled, + unitMetricK8sDaemonsetNodeMisscheduled); } /** - Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the - autoscaler.

    This metric aligns with the @code currentReplicas @endcode field of the K8s - HorizontalPodAutoscalerStatus

    updowncounter + Number of nodes that should be running the daemon pod and have one or more of the daemon pod + running and ready.

    This metric aligns with the @code numberReady @endcode field of the K8s + DaemonSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sHpaCurrentPods = "k8s.hpa.current_pods"; -static constexpr const char *descrMetricK8sHpaCurrentPods = - "Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the " - "autoscaler."; -static constexpr const char *unitMetricK8sHpaCurrentPods = "{pod}"; +static constexpr const char *kMetricK8sDaemonsetNodeReady = "k8s.daemonset.node.ready"; +static constexpr const char *descrMetricK8sDaemonsetNodeReady = + "Number of nodes that should be running the daemon pod and have one or more of the daemon pod " + "running and ready."; +static constexpr const char *unitMetricK8sDaemonsetNodeReady = "{node}"; static inline nostd::unique_ptr> -CreateSyncInt64MetricK8sHpaCurrentPods(metrics::Meter *meter) +CreateSyncInt64MetricK8sDaemonsetNodeReady(metrics::Meter *meter) { - return meter->CreateInt64UpDownCounter(kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, - unitMetricK8sHpaCurrentPods); + return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetNodeReady, + descrMetricK8sDaemonsetNodeReady, + unitMetricK8sDaemonsetNodeReady); } static inline nostd::unique_ptr> -CreateSyncDoubleMetricK8sHpaCurrentPods(metrics::Meter *meter) +CreateSyncDoubleMetricK8sDaemonsetNodeReady(metrics::Meter *meter) { - return meter->CreateDoubleUpDownCounter(kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, - unitMetricK8sHpaCurrentPods); + return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetNodeReady, + descrMetricK8sDaemonsetNodeReady, + unitMetricK8sDaemonsetNodeReady); } static inline nostd::shared_ptr -CreateAsyncInt64MetricK8sHpaCurrentPods(metrics::Meter *meter) +CreateAsyncInt64MetricK8sDaemonsetNodeReady(metrics::Meter *meter) { - return meter->CreateInt64ObservableUpDownCounter( - kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, unitMetricK8sHpaCurrentPods); + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetNodeReady, + descrMetricK8sDaemonsetNodeReady, + unitMetricK8sDaemonsetNodeReady); } static inline nostd::shared_ptr -CreateAsyncDoubleMetricK8sHpaCurrentPods(metrics::Meter *meter) +CreateAsyncDoubleMetricK8sDaemonsetNodeReady(metrics::Meter *meter) { - return meter->CreateDoubleObservableUpDownCounter( - kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, unitMetricK8sHpaCurrentPods); + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetNodeReady, + descrMetricK8sDaemonsetNodeReady, + unitMetricK8sDaemonsetNodeReady); } /** - Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated by - the autoscaler.

    This metric aligns with the @code desiredReplicas @endcode field of the K8s - HorizontalPodAutoscalerStatus

    updowncounter + Deprecated, use @code k8s.daemonset.node.ready @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.daemonset.node.ready @endcode.", "reason": "renamed", + "renamed_to": "k8s.daemonset.node.ready"}

    This metric aligns with the @code numberReady + @endcode field of the K8s + DaemonSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sHpaDesiredPods = "k8s.hpa.desired_pods"; -static constexpr const char *descrMetricK8sHpaDesiredPods = - "Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated " - "by the autoscaler."; -static constexpr const char *unitMetricK8sHpaDesiredPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sDaemonsetReadyNodes = + "k8s.daemonset.ready_nodes"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sDaemonsetReadyNodes = + "Deprecated, use `k8s.daemonset.node.ready` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sDaemonsetReadyNodes = "{node}"; -static inline nostd::unique_ptr> -CreateSyncInt64MetricK8sHpaDesiredPods(metrics::Meter *meter) +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sDaemonsetReadyNodes(metrics::Meter *meter) { - return meter->CreateInt64UpDownCounter(kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods, - unitMetricK8sHpaDesiredPods); + return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetReadyNodes, + descrMetricK8sDaemonsetReadyNodes, + unitMetricK8sDaemonsetReadyNodes); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sDaemonsetReadyNodes(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetReadyNodes, + descrMetricK8sDaemonsetReadyNodes, + unitMetricK8sDaemonsetReadyNodes); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sDaemonsetReadyNodes(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetReadyNodes, + descrMetricK8sDaemonsetReadyNodes, + unitMetricK8sDaemonsetReadyNodes); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sDaemonsetReadyNodes(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetReadyNodes, + descrMetricK8sDaemonsetReadyNodes, + unitMetricK8sDaemonsetReadyNodes); +} + +/** + Deprecated, use @code k8s.deployment.pod.available @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.deployment.pod.available @endcode.", "reason": "renamed", + "renamed_to": "k8s.deployment.pod.available"}

    This metric aligns with the @code + availableReplicas @endcode field of the K8s + DeploymentStatus.

    updowncounter + */ +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sDeploymentAvailablePods = + "k8s.deployment.available_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sDeploymentAvailablePods = + "Deprecated, use `k8s.deployment.pod.available` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sDeploymentAvailablePods = + "{pod}"; + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sDeploymentAvailablePods(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sDeploymentAvailablePods, + descrMetricK8sDeploymentAvailablePods, + unitMetricK8sDeploymentAvailablePods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sDeploymentAvailablePods(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sDeploymentAvailablePods, + descrMetricK8sDeploymentAvailablePods, + unitMetricK8sDeploymentAvailablePods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sDeploymentAvailablePods(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDeploymentAvailablePods, + descrMetricK8sDeploymentAvailablePods, + unitMetricK8sDeploymentAvailablePods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sDeploymentAvailablePods(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDeploymentAvailablePods, + descrMetricK8sDeploymentAvailablePods, + unitMetricK8sDeploymentAvailablePods); +} + +/** + Deprecated, use @code k8s.deployment.pod.desired @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.deployment.pod.desired @endcode.", "reason": "renamed", + "renamed_to": "k8s.deployment.pod.desired"}

    This metric aligns with the @code replicas + @endcode field of the K8s + DeploymentSpec.

    updowncounter + */ +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sDeploymentDesiredPods = + "k8s.deployment.desired_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sDeploymentDesiredPods = + "Deprecated, use `k8s.deployment.pod.desired` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sDeploymentDesiredPods = "{pod}"; + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sDeploymentDesiredPods(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sDeploymentDesiredPods, + descrMetricK8sDeploymentDesiredPods, + unitMetricK8sDeploymentDesiredPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sDeploymentDesiredPods(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sDeploymentDesiredPods, + descrMetricK8sDeploymentDesiredPods, + unitMetricK8sDeploymentDesiredPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sDeploymentDesiredPods(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDeploymentDesiredPods, + descrMetricK8sDeploymentDesiredPods, + unitMetricK8sDeploymentDesiredPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sDeploymentDesiredPods(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDeploymentDesiredPods, + descrMetricK8sDeploymentDesiredPods, + unitMetricK8sDeploymentDesiredPods); +} + +/** + Total number of available replica pods (ready for at least minReadySeconds) targeted by this + deployment.

    This metric aligns with the @code availableReplicas @endcode field of the K8s + DeploymentStatus.

    updowncounter + */ +static constexpr const char *kMetricK8sDeploymentPodAvailable = "k8s.deployment.pod.available"; +static constexpr const char *descrMetricK8sDeploymentPodAvailable = + "Total number of available replica pods (ready for at least minReadySeconds) targeted by this " + "deployment."; +static constexpr const char *unitMetricK8sDeploymentPodAvailable = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sDeploymentPodAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sDeploymentPodAvailable, + descrMetricK8sDeploymentPodAvailable, + unitMetricK8sDeploymentPodAvailable); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sDeploymentPodAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sDeploymentPodAvailable, + descrMetricK8sDeploymentPodAvailable, + unitMetricK8sDeploymentPodAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sDeploymentPodAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDeploymentPodAvailable, + descrMetricK8sDeploymentPodAvailable, + unitMetricK8sDeploymentPodAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sDeploymentPodAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDeploymentPodAvailable, + descrMetricK8sDeploymentPodAvailable, + unitMetricK8sDeploymentPodAvailable); +} + +/** + Number of desired replica pods in this deployment. +

    + This metric aligns with the @code replicas @endcode field of the + K8s + DeploymentSpec.

    updowncounter + */ +static constexpr const char *kMetricK8sDeploymentPodDesired = "k8s.deployment.pod.desired"; +static constexpr const char *descrMetricK8sDeploymentPodDesired = + "Number of desired replica pods in this deployment."; +static constexpr const char *unitMetricK8sDeploymentPodDesired = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sDeploymentPodDesired(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sDeploymentPodDesired, + descrMetricK8sDeploymentPodDesired, + unitMetricK8sDeploymentPodDesired); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sDeploymentPodDesired(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sDeploymentPodDesired, + descrMetricK8sDeploymentPodDesired, + unitMetricK8sDeploymentPodDesired); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sDeploymentPodDesired(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDeploymentPodDesired, + descrMetricK8sDeploymentPodDesired, + unitMetricK8sDeploymentPodDesired); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sDeploymentPodDesired(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDeploymentPodDesired, + descrMetricK8sDeploymentPodDesired, + unitMetricK8sDeploymentPodDesired); +} + +/** + Deprecated, use @code k8s.hpa.pod.current @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.hpa.pod.current @endcode.", "reason": "renamed", "renamed_to": + "k8s.hpa.pod.current"}

    This metric aligns with the @code currentReplicas @endcode field of the + K8s + HorizontalPodAutoscalerStatus

    updowncounter + */ +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sHpaCurrentPods = + "k8s.hpa.current_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sHpaCurrentPods = + "Deprecated, use `k8s.hpa.pod.current` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sHpaCurrentPods = "{pod}"; + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sHpaCurrentPods(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, + unitMetricK8sHpaCurrentPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sHpaCurrentPods(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, + unitMetricK8sHpaCurrentPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sHpaCurrentPods(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, unitMetricK8sHpaCurrentPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sHpaCurrentPods(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, unitMetricK8sHpaCurrentPods); +} + +/** + Deprecated, use @code k8s.hpa.pod.desired @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.hpa.pod.desired @endcode.", "reason": "renamed", "renamed_to": + "k8s.hpa.pod.desired"}

    This metric aligns with the @code desiredReplicas @endcode field of the + K8s + HorizontalPodAutoscalerStatus

    updowncounter + */ +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sHpaDesiredPods = + "k8s.hpa.desired_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sHpaDesiredPods = + "Deprecated, use `k8s.hpa.pod.desired` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sHpaDesiredPods = "{pod}"; + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sHpaDesiredPods(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods, + unitMetricK8sHpaDesiredPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sHpaDesiredPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods, unitMetricK8sHpaDesiredPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sHpaDesiredPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter( kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods, unitMetricK8sHpaDesiredPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sHpaDesiredPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter( @@ -940,41 +1376,42 @@ CreateAsyncDoubleMetricK8sHpaDesiredPods(metrics::Meter *meter) } /** - The upper limit for the number of replica pods to which the autoscaler can scale up. -

    - This metric aligns with the @code maxReplicas @endcode field of the - This metric aligns with the @code maxReplicas @endcode field of the K8s HorizontalPodAutoscalerSpec

    updowncounter */ -static constexpr const char *kMetricK8sHpaMaxPods = "k8s.hpa.max_pods"; -static constexpr const char *descrMetricK8sHpaMaxPods = - "The upper limit for the number of replica pods to which the autoscaler can scale up."; -static constexpr const char *unitMetricK8sHpaMaxPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sHpaMaxPods = "k8s.hpa.max_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sHpaMaxPods = + "Deprecated, use `k8s.hpa.pod.max` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sHpaMaxPods = "{pod}"; -static inline nostd::unique_ptr> CreateSyncInt64MetricK8sHpaMaxPods( - metrics::Meter *meter) +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sHpaMaxPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods, unitMetricK8sHpaMaxPods); } -static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sHpaMaxPods( - metrics::Meter *meter) +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sHpaMaxPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods, unitMetricK8sHpaMaxPods); } -static inline nostd::shared_ptr CreateAsyncInt64MetricK8sHpaMaxPods( - metrics::Meter *meter) +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sHpaMaxPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods, unitMetricK8sHpaMaxPods); } -static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sHpaMaxPods( - metrics::Meter *meter) +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sHpaMaxPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods, unitMetricK8sHpaMaxPods); @@ -1136,81 +1573,246 @@ CreateAsyncDoubleMetricK8sHpaMetricTargetCpuValue(metrics::Meter *meter) } /** - The lower limit for the number of replica pods to which the autoscaler can scale down. -

    - This metric aligns with the @code minReplicas @endcode field of the - This metric aligns with the @code minReplicas @endcode field of the K8s HorizontalPodAutoscalerSpec

    updowncounter */ -static constexpr const char *kMetricK8sHpaMinPods = "k8s.hpa.min_pods"; -static constexpr const char *descrMetricK8sHpaMinPods = - "The lower limit for the number of replica pods to which the autoscaler can scale down."; -static constexpr const char *unitMetricK8sHpaMinPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sHpaMinPods = "k8s.hpa.min_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sHpaMinPods = + "Deprecated, use `k8s.hpa.pod.min` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sHpaMinPods = "{pod}"; -static inline nostd::unique_ptr> CreateSyncInt64MetricK8sHpaMinPods( - metrics::Meter *meter) +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sHpaMinPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods, unitMetricK8sHpaMinPods); } -static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sHpaMinPods( - metrics::Meter *meter) +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sHpaMinPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods, unitMetricK8sHpaMinPods); } -static inline nostd::shared_ptr CreateAsyncInt64MetricK8sHpaMinPods( - metrics::Meter *meter) +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sHpaMinPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods, unitMetricK8sHpaMinPods); } -static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sHpaMinPods( - metrics::Meter *meter) +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sHpaMinPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods, unitMetricK8sHpaMinPods); } /** - The number of pending and actively running pods for a job. -

    - This metric aligns with the @code active @endcode field of the - K8s - JobStatus.

    updowncounter + Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the + autoscaler.

    This metric aligns with the @code currentReplicas @endcode field of the K8s + HorizontalPodAutoscalerStatus

    updowncounter */ -static constexpr const char *kMetricK8sJobActivePods = "k8s.job.active_pods"; -static constexpr const char *descrMetricK8sJobActivePods = - "The number of pending and actively running pods for a job."; -static constexpr const char *unitMetricK8sJobActivePods = "{pod}"; +static constexpr const char *kMetricK8sHpaPodCurrent = "k8s.hpa.pod.current"; +static constexpr const char *descrMetricK8sHpaPodCurrent = + "Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the " + "autoscaler."; +static constexpr const char *unitMetricK8sHpaPodCurrent = "{pod}"; static inline nostd::unique_ptr> -CreateSyncInt64MetricK8sJobActivePods(metrics::Meter *meter) +CreateSyncInt64MetricK8sHpaPodCurrent(metrics::Meter *meter) { - return meter->CreateInt64UpDownCounter(kMetricK8sJobActivePods, descrMetricK8sJobActivePods, - unitMetricK8sJobActivePods); + return meter->CreateInt64UpDownCounter(kMetricK8sHpaPodCurrent, descrMetricK8sHpaPodCurrent, + unitMetricK8sHpaPodCurrent); } static inline nostd::unique_ptr> -CreateSyncDoubleMetricK8sJobActivePods(metrics::Meter *meter) +CreateSyncDoubleMetricK8sHpaPodCurrent(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sHpaPodCurrent, descrMetricK8sHpaPodCurrent, + unitMetricK8sHpaPodCurrent); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sHpaPodCurrent(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sHpaPodCurrent, descrMetricK8sHpaPodCurrent, unitMetricK8sHpaPodCurrent); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sHpaPodCurrent(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sHpaPodCurrent, descrMetricK8sHpaPodCurrent, unitMetricK8sHpaPodCurrent); +} + +/** + Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated by + the autoscaler.

    This metric aligns with the @code desiredReplicas @endcode field of the K8s + HorizontalPodAutoscalerStatus

    updowncounter + */ +static constexpr const char *kMetricK8sHpaPodDesired = "k8s.hpa.pod.desired"; +static constexpr const char *descrMetricK8sHpaPodDesired = + "Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated " + "by the autoscaler."; +static constexpr const char *unitMetricK8sHpaPodDesired = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sHpaPodDesired(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sHpaPodDesired, descrMetricK8sHpaPodDesired, + unitMetricK8sHpaPodDesired); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sHpaPodDesired(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sHpaPodDesired, descrMetricK8sHpaPodDesired, + unitMetricK8sHpaPodDesired); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sHpaPodDesired(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sHpaPodDesired, descrMetricK8sHpaPodDesired, unitMetricK8sHpaPodDesired); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sHpaPodDesired(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sHpaPodDesired, descrMetricK8sHpaPodDesired, unitMetricK8sHpaPodDesired); +} + +/** + The upper limit for the number of replica pods to which the autoscaler can scale up. +

    + This metric aligns with the @code maxReplicas @endcode field of the + K8s + HorizontalPodAutoscalerSpec

    updowncounter + */ +static constexpr const char *kMetricK8sHpaPodMax = "k8s.hpa.pod.max"; +static constexpr const char *descrMetricK8sHpaPodMax = + "The upper limit for the number of replica pods to which the autoscaler can scale up."; +static constexpr const char *unitMetricK8sHpaPodMax = "{pod}"; + +static inline nostd::unique_ptr> CreateSyncInt64MetricK8sHpaPodMax( + metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sHpaPodMax, descrMetricK8sHpaPodMax, + unitMetricK8sHpaPodMax); +} + +static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sHpaPodMax( + metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sHpaPodMax, descrMetricK8sHpaPodMax, + unitMetricK8sHpaPodMax); +} + +static inline nostd::shared_ptr CreateAsyncInt64MetricK8sHpaPodMax( + metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sHpaPodMax, descrMetricK8sHpaPodMax, + unitMetricK8sHpaPodMax); +} + +static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sHpaPodMax( + metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sHpaPodMax, descrMetricK8sHpaPodMax, + unitMetricK8sHpaPodMax); +} + +/** + The lower limit for the number of replica pods to which the autoscaler can scale down. +

    + This metric aligns with the @code minReplicas @endcode field of the + K8s + HorizontalPodAutoscalerSpec

    updowncounter + */ +static constexpr const char *kMetricK8sHpaPodMin = "k8s.hpa.pod.min"; +static constexpr const char *descrMetricK8sHpaPodMin = + "The lower limit for the number of replica pods to which the autoscaler can scale down."; +static constexpr const char *unitMetricK8sHpaPodMin = "{pod}"; + +static inline nostd::unique_ptr> CreateSyncInt64MetricK8sHpaPodMin( + metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sHpaPodMin, descrMetricK8sHpaPodMin, + unitMetricK8sHpaPodMin); +} + +static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sHpaPodMin( + metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sHpaPodMin, descrMetricK8sHpaPodMin, + unitMetricK8sHpaPodMin); +} + +static inline nostd::shared_ptr CreateAsyncInt64MetricK8sHpaPodMin( + metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sHpaPodMin, descrMetricK8sHpaPodMin, + unitMetricK8sHpaPodMin); +} + +static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sHpaPodMin( + metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sHpaPodMin, descrMetricK8sHpaPodMin, + unitMetricK8sHpaPodMin); +} + +/** + Deprecated, use @code k8s.job.pod.active @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.job.pod.active @endcode.", "reason": "renamed", "renamed_to": + "k8s.job.pod.active"}

    This metric aligns with the @code active @endcode field of the K8s + JobStatus.

    updowncounter + */ +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sJobActivePods = + "k8s.job.active_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sJobActivePods = + "Deprecated, use `k8s.job.pod.active` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sJobActivePods = "{pod}"; + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sJobActivePods(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sJobActivePods, descrMetricK8sJobActivePods, + unitMetricK8sJobActivePods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sJobActivePods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sJobActivePods, descrMetricK8sJobActivePods, unitMetricK8sJobActivePods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sJobActivePods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter( kMetricK8sJobActivePods, descrMetricK8sJobActivePods, unitMetricK8sJobActivePods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sJobActivePods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter( @@ -1218,19 +1820,23 @@ CreateAsyncDoubleMetricK8sJobActivePods(metrics::Meter *meter) } /** - The desired number of successfully finished pods the job should be run with. -

    - This metric aligns with the @code completions @endcode field of the - This metric aligns with the @code completions + @endcode field of the K8s JobSpec..

    updowncounter */ -static constexpr const char *kMetricK8sJobDesiredSuccessfulPods = "k8s.job.desired_successful_pods"; -static constexpr const char *descrMetricK8sJobDesiredSuccessfulPods = - "The desired number of successfully finished pods the job should be run with."; -static constexpr const char *unitMetricK8sJobDesiredSuccessfulPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sJobDesiredSuccessfulPods = + "k8s.job.desired_successful_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sJobDesiredSuccessfulPods = + "Deprecated, use `k8s.job.pod.desired_successful` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sJobDesiredSuccessfulPods = + "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sJobDesiredSuccessfulPods, @@ -1238,7 +1844,7 @@ CreateSyncInt64MetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter) unitMetricK8sJobDesiredSuccessfulPods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sJobDesiredSuccessfulPods, @@ -1246,7 +1852,7 @@ CreateSyncDoubleMetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter) unitMetricK8sJobDesiredSuccessfulPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sJobDesiredSuccessfulPods, @@ -1254,7 +1860,7 @@ CreateAsyncInt64MetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter) unitMetricK8sJobDesiredSuccessfulPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sJobDesiredSuccessfulPods, @@ -1263,46 +1869,223 @@ CreateAsyncDoubleMetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter) } /** - The number of pods which reached phase Failed for a job. -

    - This metric aligns with the @code failed @endcode field of the - This metric aligns with the @code failed @endcode field of the K8s JobStatus.

    updowncounter */ -static constexpr const char *kMetricK8sJobFailedPods = "k8s.job.failed_pods"; -static constexpr const char *descrMetricK8sJobFailedPods = - "The number of pods which reached phase Failed for a job."; -static constexpr const char *unitMetricK8sJobFailedPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sJobFailedPods = + "k8s.job.failed_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sJobFailedPods = + "Deprecated, use `k8s.job.pod.failed` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sJobFailedPods = "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sJobFailedPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods, unitMetricK8sJobFailedPods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sJobFailedPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods, unitMetricK8sJobFailedPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sJobFailedPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter( kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods, unitMetricK8sJobFailedPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sJobFailedPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter( kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods, unitMetricK8sJobFailedPods); } +/** + Deprecated, use @code k8s.job.pod.max_parallel @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.job.pod.max_parallel @endcode.", "reason": "renamed", + "renamed_to": "k8s.job.pod.max_parallel"}

    This metric aligns with the @code parallelism + @endcode field of the K8s + JobSpec.

    updowncounter + */ +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sJobMaxParallelPods = + "k8s.job.max_parallel_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sJobMaxParallelPods = + "Deprecated, use `k8s.job.pod.max_parallel` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sJobMaxParallelPods = "{pod}"; + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sJobMaxParallelPods(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sJobMaxParallelPods, + descrMetricK8sJobMaxParallelPods, + unitMetricK8sJobMaxParallelPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sJobMaxParallelPods(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sJobMaxParallelPods, + descrMetricK8sJobMaxParallelPods, + unitMetricK8sJobMaxParallelPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sJobMaxParallelPods(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sJobMaxParallelPods, + descrMetricK8sJobMaxParallelPods, + unitMetricK8sJobMaxParallelPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sJobMaxParallelPods(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sJobMaxParallelPods, + descrMetricK8sJobMaxParallelPods, + unitMetricK8sJobMaxParallelPods); +} + +/** + The number of pending and actively running pods for a job. +

    + This metric aligns with the @code active @endcode field of the + K8s + JobStatus.

    updowncounter + */ +static constexpr const char *kMetricK8sJobPodActive = "k8s.job.pod.active"; +static constexpr const char *descrMetricK8sJobPodActive = + "The number of pending and actively running pods for a job."; +static constexpr const char *unitMetricK8sJobPodActive = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sJobPodActive(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sJobPodActive, descrMetricK8sJobPodActive, + unitMetricK8sJobPodActive); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sJobPodActive(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sJobPodActive, descrMetricK8sJobPodActive, + unitMetricK8sJobPodActive); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sJobPodActive(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sJobPodActive, descrMetricK8sJobPodActive, unitMetricK8sJobPodActive); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sJobPodActive(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sJobPodActive, descrMetricK8sJobPodActive, unitMetricK8sJobPodActive); +} + +/** + The desired number of successfully finished pods the job should be run with. +

    + This metric aligns with the @code completions @endcode field of the + K8s + JobSpec..

    updowncounter + */ +static constexpr const char *kMetricK8sJobPodDesiredSuccessful = "k8s.job.pod.desired_successful"; +static constexpr const char *descrMetricK8sJobPodDesiredSuccessful = + "The desired number of successfully finished pods the job should be run with."; +static constexpr const char *unitMetricK8sJobPodDesiredSuccessful = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sJobPodDesiredSuccessful(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sJobPodDesiredSuccessful, + descrMetricK8sJobPodDesiredSuccessful, + unitMetricK8sJobPodDesiredSuccessful); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sJobPodDesiredSuccessful(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sJobPodDesiredSuccessful, + descrMetricK8sJobPodDesiredSuccessful, + unitMetricK8sJobPodDesiredSuccessful); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sJobPodDesiredSuccessful(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sJobPodDesiredSuccessful, + descrMetricK8sJobPodDesiredSuccessful, + unitMetricK8sJobPodDesiredSuccessful); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sJobPodDesiredSuccessful(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sJobPodDesiredSuccessful, + descrMetricK8sJobPodDesiredSuccessful, + unitMetricK8sJobPodDesiredSuccessful); +} + +/** + The number of pods which reached phase Failed for a job. +

    + This metric aligns with the @code failed @endcode field of the + K8s + JobStatus.

    updowncounter + */ +static constexpr const char *kMetricK8sJobPodFailed = "k8s.job.pod.failed"; +static constexpr const char *descrMetricK8sJobPodFailed = + "The number of pods which reached phase Failed for a job."; +static constexpr const char *unitMetricK8sJobPodFailed = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sJobPodFailed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sJobPodFailed, descrMetricK8sJobPodFailed, + unitMetricK8sJobPodFailed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sJobPodFailed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sJobPodFailed, descrMetricK8sJobPodFailed, + unitMetricK8sJobPodFailed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sJobPodFailed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sJobPodFailed, descrMetricK8sJobPodFailed, unitMetricK8sJobPodFailed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sJobPodFailed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sJobPodFailed, descrMetricK8sJobPodFailed, unitMetricK8sJobPodFailed); +} + /** The max desired number of pods the job should run at any given time.

    @@ -1311,78 +2094,117 @@ CreateAsyncDoubleMetricK8sJobFailedPods(metrics::Meter *meter) href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch">K8s JobSpec.

    updowncounter */ -static constexpr const char *kMetricK8sJobMaxParallelPods = "k8s.job.max_parallel_pods"; -static constexpr const char *descrMetricK8sJobMaxParallelPods = +static constexpr const char *kMetricK8sJobPodMaxParallel = "k8s.job.pod.max_parallel"; +static constexpr const char *descrMetricK8sJobPodMaxParallel = "The max desired number of pods the job should run at any given time."; -static constexpr const char *unitMetricK8sJobMaxParallelPods = "{pod}"; +static constexpr const char *unitMetricK8sJobPodMaxParallel = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sJobPodMaxParallel(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter( + kMetricK8sJobPodMaxParallel, descrMetricK8sJobPodMaxParallel, unitMetricK8sJobPodMaxParallel); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sJobPodMaxParallel(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter( + kMetricK8sJobPodMaxParallel, descrMetricK8sJobPodMaxParallel, unitMetricK8sJobPodMaxParallel); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sJobPodMaxParallel(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sJobPodMaxParallel, descrMetricK8sJobPodMaxParallel, unitMetricK8sJobPodMaxParallel); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sJobPodMaxParallel(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sJobPodMaxParallel, descrMetricK8sJobPodMaxParallel, unitMetricK8sJobPodMaxParallel); +} + +/** + The number of pods which reached phase Succeeded for a job. +

    + This metric aligns with the @code succeeded @endcode field of the + K8s + JobStatus.

    updowncounter + */ +static constexpr const char *kMetricK8sJobPodSuccessful = "k8s.job.pod.successful"; +static constexpr const char *descrMetricK8sJobPodSuccessful = + "The number of pods which reached phase Succeeded for a job."; +static constexpr const char *unitMetricK8sJobPodSuccessful = "{pod}"; static inline nostd::unique_ptr> -CreateSyncInt64MetricK8sJobMaxParallelPods(metrics::Meter *meter) +CreateSyncInt64MetricK8sJobPodSuccessful(metrics::Meter *meter) { - return meter->CreateInt64UpDownCounter(kMetricK8sJobMaxParallelPods, - descrMetricK8sJobMaxParallelPods, - unitMetricK8sJobMaxParallelPods); + return meter->CreateInt64UpDownCounter(kMetricK8sJobPodSuccessful, descrMetricK8sJobPodSuccessful, + unitMetricK8sJobPodSuccessful); } static inline nostd::unique_ptr> -CreateSyncDoubleMetricK8sJobMaxParallelPods(metrics::Meter *meter) +CreateSyncDoubleMetricK8sJobPodSuccessful(metrics::Meter *meter) { - return meter->CreateDoubleUpDownCounter(kMetricK8sJobMaxParallelPods, - descrMetricK8sJobMaxParallelPods, - unitMetricK8sJobMaxParallelPods); + return meter->CreateDoubleUpDownCounter( + kMetricK8sJobPodSuccessful, descrMetricK8sJobPodSuccessful, unitMetricK8sJobPodSuccessful); } static inline nostd::shared_ptr -CreateAsyncInt64MetricK8sJobMaxParallelPods(metrics::Meter *meter) +CreateAsyncInt64MetricK8sJobPodSuccessful(metrics::Meter *meter) { - return meter->CreateInt64ObservableUpDownCounter(kMetricK8sJobMaxParallelPods, - descrMetricK8sJobMaxParallelPods, - unitMetricK8sJobMaxParallelPods); + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sJobPodSuccessful, descrMetricK8sJobPodSuccessful, unitMetricK8sJobPodSuccessful); } static inline nostd::shared_ptr -CreateAsyncDoubleMetricK8sJobMaxParallelPods(metrics::Meter *meter) +CreateAsyncDoubleMetricK8sJobPodSuccessful(metrics::Meter *meter) { - return meter->CreateDoubleObservableUpDownCounter(kMetricK8sJobMaxParallelPods, - descrMetricK8sJobMaxParallelPods, - unitMetricK8sJobMaxParallelPods); + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sJobPodSuccessful, descrMetricK8sJobPodSuccessful, unitMetricK8sJobPodSuccessful); } /** - The number of pods which reached phase Succeeded for a job. -

    - This metric aligns with the @code succeeded @endcode field of the - This metric aligns with the @code succeeded @endcode field of the K8s JobStatus.

    updowncounter */ -static constexpr const char *kMetricK8sJobSuccessfulPods = "k8s.job.successful_pods"; -static constexpr const char *descrMetricK8sJobSuccessfulPods = - "The number of pods which reached phase Succeeded for a job."; -static constexpr const char *unitMetricK8sJobSuccessfulPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sJobSuccessfulPods = + "k8s.job.successful_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sJobSuccessfulPods = + "Deprecated, use `k8s.job.pod.successful` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sJobSuccessfulPods = "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sJobSuccessfulPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter( kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sJobSuccessfulPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter( kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sJobSuccessfulPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter( kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sJobSuccessfulPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter( @@ -1428,16 +2250,19 @@ CreateAsyncDoubleMetricK8sNamespacePhase(metrics::Meter *meter) } /** - Amount of cpu allocatable on the node. -

    - updowncounter + Deprecated, use @code k8s.node.cpu.allocatable @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.node.cpu.allocatable @endcode.", "reason": "renamed", + "renamed_to": "k8s.node.cpu.allocatable"}

    updowncounter */ -static constexpr const char *kMetricK8sNodeAllocatableCpu = "k8s.node.allocatable.cpu"; -static constexpr const char *descrMetricK8sNodeAllocatableCpu = - "Amount of cpu allocatable on the node."; -static constexpr const char *unitMetricK8sNodeAllocatableCpu = "{cpu}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sNodeAllocatableCpu = + "k8s.node.allocatable.cpu"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sNodeAllocatableCpu = + "Deprecated, use `k8s.node.cpu.allocatable` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sNodeAllocatableCpu = "{cpu}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sNodeAllocatableCpu(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sNodeAllocatableCpu, @@ -1445,7 +2270,7 @@ CreateSyncInt64MetricK8sNodeAllocatableCpu(metrics::Meter *meter) unitMetricK8sNodeAllocatableCpu); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sNodeAllocatableCpu(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sNodeAllocatableCpu, @@ -1453,7 +2278,7 @@ CreateSyncDoubleMetricK8sNodeAllocatableCpu(metrics::Meter *meter) unitMetricK8sNodeAllocatableCpu); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sNodeAllocatableCpu(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sNodeAllocatableCpu, @@ -1461,7 +2286,7 @@ CreateAsyncInt64MetricK8sNodeAllocatableCpu(metrics::Meter *meter) unitMetricK8sNodeAllocatableCpu); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sNodeAllocatableCpu(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sNodeAllocatableCpu, @@ -1470,17 +2295,21 @@ CreateAsyncDoubleMetricK8sNodeAllocatableCpu(metrics::Meter *meter) } /** - Amount of ephemeral-storage allocatable on the node. -

    - updowncounter + Deprecated, use @code k8s.node.ephemeral_storage.allocatable @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.node.ephemeral_storage.allocatable @endcode.", "reason": + "renamed", "renamed_to": "k8s.node.ephemeral_storage.allocatable"}

    updowncounter */ -static constexpr const char *kMetricK8sNodeAllocatableEphemeralStorage = +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sNodeAllocatableEphemeralStorage = "k8s.node.allocatable.ephemeral_storage"; -static constexpr const char *descrMetricK8sNodeAllocatableEphemeralStorage = - "Amount of ephemeral-storage allocatable on the node."; -static constexpr const char *unitMetricK8sNodeAllocatableEphemeralStorage = "By"; +OPENTELEMETRY_DEPRECATED static constexpr const char + *descrMetricK8sNodeAllocatableEphemeralStorage = + "Deprecated, use `k8s.node.ephemeral_storage.allocatable` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sNodeAllocatableEphemeralStorage = + "By"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sNodeAllocatableEphemeralStorage(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sNodeAllocatableEphemeralStorage, @@ -1488,7 +2317,7 @@ CreateSyncInt64MetricK8sNodeAllocatableEphemeralStorage(metrics::Meter *meter) unitMetricK8sNodeAllocatableEphemeralStorage); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sNodeAllocatableEphemeralStorage(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sNodeAllocatableEphemeralStorage, @@ -1496,7 +2325,7 @@ CreateSyncDoubleMetricK8sNodeAllocatableEphemeralStorage(metrics::Meter *meter) unitMetricK8sNodeAllocatableEphemeralStorage); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sNodeAllocatableEphemeralStorage(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sNodeAllocatableEphemeralStorage, @@ -1504,7 +2333,7 @@ CreateAsyncInt64MetricK8sNodeAllocatableEphemeralStorage(metrics::Meter *meter) unitMetricK8sNodeAllocatableEphemeralStorage); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sNodeAllocatableEphemeralStorage(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sNodeAllocatableEphemeralStorage, @@ -1513,16 +2342,19 @@ CreateAsyncDoubleMetricK8sNodeAllocatableEphemeralStorage(metrics::Meter *meter) } /** - Amount of memory allocatable on the node. -

    - updowncounter + Deprecated, use @code k8s.node.memory.allocatable @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.node.memory.allocatable @endcode.", "reason": "renamed", + "renamed_to": "k8s.node.memory.allocatable"}

    updowncounter */ -static constexpr const char *kMetricK8sNodeAllocatableMemory = "k8s.node.allocatable.memory"; -static constexpr const char *descrMetricK8sNodeAllocatableMemory = - "Amount of memory allocatable on the node."; -static constexpr const char *unitMetricK8sNodeAllocatableMemory = "By"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sNodeAllocatableMemory = + "k8s.node.allocatable.memory"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sNodeAllocatableMemory = + "Deprecated, use `k8s.node.memory.allocatable` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sNodeAllocatableMemory = "By"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sNodeAllocatableMemory(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sNodeAllocatableMemory, @@ -1530,7 +2362,7 @@ CreateSyncInt64MetricK8sNodeAllocatableMemory(metrics::Meter *meter) unitMetricK8sNodeAllocatableMemory); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sNodeAllocatableMemory(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sNodeAllocatableMemory, @@ -1538,7 +2370,7 @@ CreateSyncDoubleMetricK8sNodeAllocatableMemory(metrics::Meter *meter) unitMetricK8sNodeAllocatableMemory); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sNodeAllocatableMemory(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sNodeAllocatableMemory, @@ -1546,7 +2378,7 @@ CreateAsyncInt64MetricK8sNodeAllocatableMemory(metrics::Meter *meter) unitMetricK8sNodeAllocatableMemory); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sNodeAllocatableMemory(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sNodeAllocatableMemory, @@ -1555,16 +2387,19 @@ CreateAsyncDoubleMetricK8sNodeAllocatableMemory(metrics::Meter *meter) } /** - Amount of pods allocatable on the node. -

    - updowncounter + Deprecated, use @code k8s.node.pod.allocatable @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.node.pod.allocatable @endcode.", "reason": "renamed", + "renamed_to": "k8s.node.pod.allocatable"}

    updowncounter */ -static constexpr const char *kMetricK8sNodeAllocatablePods = "k8s.node.allocatable.pods"; -static constexpr const char *descrMetricK8sNodeAllocatablePods = - "Amount of pods allocatable on the node."; -static constexpr const char *unitMetricK8sNodeAllocatablePods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sNodeAllocatablePods = + "k8s.node.allocatable.pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sNodeAllocatablePods = + "Deprecated, use `k8s.node.pod.allocatable` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sNodeAllocatablePods = "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sNodeAllocatablePods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sNodeAllocatablePods, @@ -1572,7 +2407,7 @@ CreateSyncInt64MetricK8sNodeAllocatablePods(metrics::Meter *meter) unitMetricK8sNodeAllocatablePods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sNodeAllocatablePods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sNodeAllocatablePods, @@ -1580,7 +2415,7 @@ CreateSyncDoubleMetricK8sNodeAllocatablePods(metrics::Meter *meter) unitMetricK8sNodeAllocatablePods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sNodeAllocatablePods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sNodeAllocatablePods, @@ -1588,7 +2423,7 @@ CreateAsyncInt64MetricK8sNodeAllocatablePods(metrics::Meter *meter) unitMetricK8sNodeAllocatablePods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sNodeAllocatablePods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sNodeAllocatablePods, @@ -1640,6 +2475,48 @@ CreateAsyncDoubleMetricK8sNodeConditionStatus(metrics::Meter *meter) unitMetricK8sNodeConditionStatus); } +/** + Amount of cpu allocatable on the node. +

    + updowncounter + */ +static constexpr const char *kMetricK8sNodeCpuAllocatable = "k8s.node.cpu.allocatable"; +static constexpr const char *descrMetricK8sNodeCpuAllocatable = + "Amount of cpu allocatable on the node."; +static constexpr const char *unitMetricK8sNodeCpuAllocatable = "{cpu}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sNodeCpuAllocatable(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sNodeCpuAllocatable, + descrMetricK8sNodeCpuAllocatable, + unitMetricK8sNodeCpuAllocatable); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sNodeCpuAllocatable(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sNodeCpuAllocatable, + descrMetricK8sNodeCpuAllocatable, + unitMetricK8sNodeCpuAllocatable); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sNodeCpuAllocatable(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sNodeCpuAllocatable, + descrMetricK8sNodeCpuAllocatable, + unitMetricK8sNodeCpuAllocatable); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sNodeCpuAllocatable(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sNodeCpuAllocatable, + descrMetricK8sNodeCpuAllocatable, + unitMetricK8sNodeCpuAllocatable); +} + /** Total CPU time consumed.

    @@ -1722,6 +2599,49 @@ CreateAsyncDoubleMetricK8sNodeCpuUsage(metrics::Meter *meter) unitMetricK8sNodeCpuUsage); } +/** + Amount of ephemeral-storage allocatable on the node. +

    + updowncounter + */ +static constexpr const char *kMetricK8sNodeEphemeralStorageAllocatable = + "k8s.node.ephemeral_storage.allocatable"; +static constexpr const char *descrMetricK8sNodeEphemeralStorageAllocatable = + "Amount of ephemeral-storage allocatable on the node."; +static constexpr const char *unitMetricK8sNodeEphemeralStorageAllocatable = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sNodeEphemeralStorageAllocatable(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sNodeEphemeralStorageAllocatable, + descrMetricK8sNodeEphemeralStorageAllocatable, + unitMetricK8sNodeEphemeralStorageAllocatable); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sNodeEphemeralStorageAllocatable(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sNodeEphemeralStorageAllocatable, + descrMetricK8sNodeEphemeralStorageAllocatable, + unitMetricK8sNodeEphemeralStorageAllocatable); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sNodeEphemeralStorageAllocatable(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sNodeEphemeralStorageAllocatable, + descrMetricK8sNodeEphemeralStorageAllocatable, + unitMetricK8sNodeEphemeralStorageAllocatable); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sNodeEphemeralStorageAllocatable(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sNodeEphemeralStorageAllocatable, + descrMetricK8sNodeEphemeralStorageAllocatable, + unitMetricK8sNodeEphemeralStorageAllocatable); +} + /** Node filesystem available bytes.

    @@ -1869,6 +2789,184 @@ CreateAsyncDoubleMetricK8sNodeFilesystemUsage(metrics::Meter *meter) unitMetricK8sNodeFilesystemUsage); } +/** + Amount of memory allocatable on the node. +

    + updowncounter + */ +static constexpr const char *kMetricK8sNodeMemoryAllocatable = "k8s.node.memory.allocatable"; +static constexpr const char *descrMetricK8sNodeMemoryAllocatable = + "Amount of memory allocatable on the node."; +static constexpr const char *unitMetricK8sNodeMemoryAllocatable = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sNodeMemoryAllocatable(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sNodeMemoryAllocatable, + descrMetricK8sNodeMemoryAllocatable, + unitMetricK8sNodeMemoryAllocatable); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sNodeMemoryAllocatable(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sNodeMemoryAllocatable, + descrMetricK8sNodeMemoryAllocatable, + unitMetricK8sNodeMemoryAllocatable); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sNodeMemoryAllocatable(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sNodeMemoryAllocatable, + descrMetricK8sNodeMemoryAllocatable, + unitMetricK8sNodeMemoryAllocatable); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sNodeMemoryAllocatable(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sNodeMemoryAllocatable, + descrMetricK8sNodeMemoryAllocatable, + unitMetricK8sNodeMemoryAllocatable); +} + +/** + Node memory available. +

    + Available memory for use. This is defined as the memory limit - workingSetBytes. If memory limit + is undefined, the available bytes is omitted. This metric is derived from the MemoryStats.AvailableBytes + field of the NodeStats.Memory + of the Kubelet's stats API.

    updowncounter + */ +static constexpr const char *kMetricK8sNodeMemoryAvailable = "k8s.node.memory.available"; +static constexpr const char *descrMetricK8sNodeMemoryAvailable = "Node memory available."; +static constexpr const char *unitMetricK8sNodeMemoryAvailable = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sNodeMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sNodeMemoryAvailable, + descrMetricK8sNodeMemoryAvailable, + unitMetricK8sNodeMemoryAvailable); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sNodeMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sNodeMemoryAvailable, + descrMetricK8sNodeMemoryAvailable, + unitMetricK8sNodeMemoryAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sNodeMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sNodeMemoryAvailable, + descrMetricK8sNodeMemoryAvailable, + unitMetricK8sNodeMemoryAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sNodeMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sNodeMemoryAvailable, + descrMetricK8sNodeMemoryAvailable, + unitMetricK8sNodeMemoryAvailable); +} + +/** + Node memory paging faults. +

    + Cumulative number of major/minor page faults. + This metric is derived from the MemoryStats.PageFaults + and MemoryStats.MajorPageFaults + fields of the NodeStats.Memory + of the Kubelet's stats API.

    counter + */ +static constexpr const char *kMetricK8sNodeMemoryPagingFaults = "k8s.node.memory.paging.faults"; +static constexpr const char *descrMetricK8sNodeMemoryPagingFaults = "Node memory paging faults."; +static constexpr const char *unitMetricK8sNodeMemoryPagingFaults = "{fault}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sNodeMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricK8sNodeMemoryPagingFaults, + descrMetricK8sNodeMemoryPagingFaults, + unitMetricK8sNodeMemoryPagingFaults); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sNodeMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricK8sNodeMemoryPagingFaults, + descrMetricK8sNodeMemoryPagingFaults, + unitMetricK8sNodeMemoryPagingFaults); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sNodeMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricK8sNodeMemoryPagingFaults, + descrMetricK8sNodeMemoryPagingFaults, + unitMetricK8sNodeMemoryPagingFaults); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sNodeMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricK8sNodeMemoryPagingFaults, + descrMetricK8sNodeMemoryPagingFaults, + unitMetricK8sNodeMemoryPagingFaults); +} + +/** + Node memory RSS. +

    + The amount of anonymous and swap cache memory (includes transparent hugepages). + This metric is derived from the MemoryStats.RSSBytes + field of the NodeStats.Memory + of the Kubelet's stats API.

    updowncounter + */ +static constexpr const char *kMetricK8sNodeMemoryRss = "k8s.node.memory.rss"; +static constexpr const char *descrMetricK8sNodeMemoryRss = "Node memory RSS."; +static constexpr const char *unitMetricK8sNodeMemoryRss = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sNodeMemoryRss(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sNodeMemoryRss, descrMetricK8sNodeMemoryRss, + unitMetricK8sNodeMemoryRss); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sNodeMemoryRss(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sNodeMemoryRss, descrMetricK8sNodeMemoryRss, + unitMetricK8sNodeMemoryRss); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sNodeMemoryRss(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sNodeMemoryRss, descrMetricK8sNodeMemoryRss, unitMetricK8sNodeMemoryRss); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sNodeMemoryRss(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sNodeMemoryRss, descrMetricK8sNodeMemoryRss, unitMetricK8sNodeMemoryRss); +} + /** Memory usage of the Node.

    @@ -1885,30 +2983,76 @@ static constexpr const char *unitMetricK8sNodeMemoryUsage = "By"; static inline nostd::unique_ptr> CreateSyncInt64MetricK8sNodeMemoryUsage( metrics::Meter *meter) { - return meter->CreateInt64Gauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage, - unitMetricK8sNodeMemoryUsage); + return meter->CreateInt64Gauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage, + unitMetricK8sNodeMemoryUsage); +} + +static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sNodeMemoryUsage( + metrics::Meter *meter) +{ + return meter->CreateDoubleGauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage, + unitMetricK8sNodeMemoryUsage); +} +#endif /* OPENTELEMETRY_ABI_VERSION_NO */ + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sNodeMemoryUsage(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableGauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage, + unitMetricK8sNodeMemoryUsage); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sNodeMemoryUsage(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableGauge( + kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage, unitMetricK8sNodeMemoryUsage); +} + +/** + Node memory working set. +

    + The amount of working set memory. This includes recently accessed memory, dirty memory, and kernel + memory. WorkingSetBytes is <= UsageBytes. This metric is derived from the MemoryStats.WorkingSetBytes + field of the NodeStats.Memory + of the Kubelet's stats API.

    updowncounter + */ +static constexpr const char *kMetricK8sNodeMemoryWorkingSet = "k8s.node.memory.working_set"; +static constexpr const char *descrMetricK8sNodeMemoryWorkingSet = "Node memory working set."; +static constexpr const char *unitMetricK8sNodeMemoryWorkingSet = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sNodeMemoryWorkingSet(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sNodeMemoryWorkingSet, + descrMetricK8sNodeMemoryWorkingSet, + unitMetricK8sNodeMemoryWorkingSet); } -static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sNodeMemoryUsage( - metrics::Meter *meter) +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sNodeMemoryWorkingSet(metrics::Meter *meter) { - return meter->CreateDoubleGauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage, - unitMetricK8sNodeMemoryUsage); + return meter->CreateDoubleUpDownCounter(kMetricK8sNodeMemoryWorkingSet, + descrMetricK8sNodeMemoryWorkingSet, + unitMetricK8sNodeMemoryWorkingSet); } -#endif /* OPENTELEMETRY_ABI_VERSION_NO */ static inline nostd::shared_ptr -CreateAsyncInt64MetricK8sNodeMemoryUsage(metrics::Meter *meter) +CreateAsyncInt64MetricK8sNodeMemoryWorkingSet(metrics::Meter *meter) { - return meter->CreateInt64ObservableGauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage, - unitMetricK8sNodeMemoryUsage); + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sNodeMemoryWorkingSet, + descrMetricK8sNodeMemoryWorkingSet, + unitMetricK8sNodeMemoryWorkingSet); } static inline nostd::shared_ptr -CreateAsyncDoubleMetricK8sNodeMemoryUsage(metrics::Meter *meter) +CreateAsyncDoubleMetricK8sNodeMemoryWorkingSet(metrics::Meter *meter) { - return meter->CreateDoubleObservableGauge( - kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage, unitMetricK8sNodeMemoryUsage); + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sNodeMemoryWorkingSet, + descrMetricK8sNodeMemoryWorkingSet, + unitMetricK8sNodeMemoryWorkingSet); } /** @@ -1985,6 +3129,48 @@ CreateAsyncDoubleMetricK8sNodeNetworkIo(metrics::Meter *meter) unitMetricK8sNodeNetworkIo); } +/** + Amount of pods allocatable on the node. +

    + updowncounter + */ +static constexpr const char *kMetricK8sNodePodAllocatable = "k8s.node.pod.allocatable"; +static constexpr const char *descrMetricK8sNodePodAllocatable = + "Amount of pods allocatable on the node."; +static constexpr const char *unitMetricK8sNodePodAllocatable = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sNodePodAllocatable(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sNodePodAllocatable, + descrMetricK8sNodePodAllocatable, + unitMetricK8sNodePodAllocatable); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sNodePodAllocatable(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sNodePodAllocatable, + descrMetricK8sNodePodAllocatable, + unitMetricK8sNodePodAllocatable); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sNodePodAllocatable(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sNodePodAllocatable, + descrMetricK8sNodePodAllocatable, + unitMetricK8sNodePodAllocatable); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sNodePodAllocatable(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sNodePodAllocatable, + descrMetricK8sNodePodAllocatable, + unitMetricK8sNodePodAllocatable); +} + /** The time the Node has been running.

    @@ -2256,6 +3442,142 @@ CreateAsyncDoubleMetricK8sPodFilesystemUsage(metrics::Meter *meter) unitMetricK8sPodFilesystemUsage); } +/** + Pod memory available. +

    + Available memory for use. This is defined as the memory limit - workingSetBytes. If memory limit + is undefined, the available bytes is omitted. This metric is derived from the MemoryStats.AvailableBytes + field of the PodStats.Memory + of the Kubelet's stats API.

    updowncounter + */ +static constexpr const char *kMetricK8sPodMemoryAvailable = "k8s.pod.memory.available"; +static constexpr const char *descrMetricK8sPodMemoryAvailable = "Pod memory available."; +static constexpr const char *unitMetricK8sPodMemoryAvailable = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sPodMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sPodMemoryAvailable, + descrMetricK8sPodMemoryAvailable, + unitMetricK8sPodMemoryAvailable); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sPodMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sPodMemoryAvailable, + descrMetricK8sPodMemoryAvailable, + unitMetricK8sPodMemoryAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sPodMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sPodMemoryAvailable, + descrMetricK8sPodMemoryAvailable, + unitMetricK8sPodMemoryAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sPodMemoryAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sPodMemoryAvailable, + descrMetricK8sPodMemoryAvailable, + unitMetricK8sPodMemoryAvailable); +} + +/** + Pod memory paging faults. +

    + Cumulative number of major/minor page faults. + This metric is derived from the MemoryStats.PageFaults + and MemoryStats.MajorPageFaults + field of the PodStats.Memory + of the Kubelet's stats API.

    counter + */ +static constexpr const char *kMetricK8sPodMemoryPagingFaults = "k8s.pod.memory.paging.faults"; +static constexpr const char *descrMetricK8sPodMemoryPagingFaults = "Pod memory paging faults."; +static constexpr const char *unitMetricK8sPodMemoryPagingFaults = "{fault}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sPodMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricK8sPodMemoryPagingFaults, + descrMetricK8sPodMemoryPagingFaults, + unitMetricK8sPodMemoryPagingFaults); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sPodMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricK8sPodMemoryPagingFaults, + descrMetricK8sPodMemoryPagingFaults, + unitMetricK8sPodMemoryPagingFaults); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sPodMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricK8sPodMemoryPagingFaults, + descrMetricK8sPodMemoryPagingFaults, + unitMetricK8sPodMemoryPagingFaults); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sPodMemoryPagingFaults(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricK8sPodMemoryPagingFaults, + descrMetricK8sPodMemoryPagingFaults, + unitMetricK8sPodMemoryPagingFaults); +} + +/** + Pod memory RSS. +

    + The amount of anonymous and swap cache memory (includes transparent hugepages). + This metric is derived from the MemoryStats.RSSBytes + field of the PodStats.Memory + of the Kubelet's stats API.

    updowncounter + */ +static constexpr const char *kMetricK8sPodMemoryRss = "k8s.pod.memory.rss"; +static constexpr const char *descrMetricK8sPodMemoryRss = "Pod memory RSS."; +static constexpr const char *unitMetricK8sPodMemoryRss = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sPodMemoryRss(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sPodMemoryRss, descrMetricK8sPodMemoryRss, + unitMetricK8sPodMemoryRss); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sPodMemoryRss(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sPodMemoryRss, descrMetricK8sPodMemoryRss, + unitMetricK8sPodMemoryRss); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sPodMemoryRss(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sPodMemoryRss, descrMetricK8sPodMemoryRss, unitMetricK8sPodMemoryRss); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sPodMemoryRss(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sPodMemoryRss, descrMetricK8sPodMemoryRss, unitMetricK8sPodMemoryRss); +} + /** Memory usage of the Pod.

    @@ -2298,6 +3620,52 @@ CreateAsyncDoubleMetricK8sPodMemoryUsage(metrics::Meter *meter) unitMetricK8sPodMemoryUsage); } +/** + Pod memory working set. +

    + The amount of working set memory. This includes recently accessed memory, dirty memory, and kernel + memory. WorkingSetBytes is <= UsageBytes. This metric is derived from the MemoryStats.WorkingSetBytes + field of the PodStats.Memory + of the Kubelet's stats API.

    updowncounter + */ +static constexpr const char *kMetricK8sPodMemoryWorkingSet = "k8s.pod.memory.working_set"; +static constexpr const char *descrMetricK8sPodMemoryWorkingSet = "Pod memory working set."; +static constexpr const char *unitMetricK8sPodMemoryWorkingSet = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sPodMemoryWorkingSet(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sPodMemoryWorkingSet, + descrMetricK8sPodMemoryWorkingSet, + unitMetricK8sPodMemoryWorkingSet); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sPodMemoryWorkingSet(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sPodMemoryWorkingSet, + descrMetricK8sPodMemoryWorkingSet, + unitMetricK8sPodMemoryWorkingSet); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sPodMemoryWorkingSet(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sPodMemoryWorkingSet, + descrMetricK8sPodMemoryWorkingSet, + unitMetricK8sPodMemoryWorkingSet); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sPodMemoryWorkingSet(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sPodMemoryWorkingSet, + descrMetricK8sPodMemoryWorkingSet, + unitMetricK8sPodMemoryWorkingSet); +} + /** Pod network errors.

    @@ -2372,6 +3740,88 @@ CreateAsyncDoubleMetricK8sPodNetworkIo(metrics::Meter *meter) unitMetricK8sPodNetworkIo); } +/** + Describes number of K8s Pods that are currently in a given phase. +

    + All possible pod phases will be reported at each time interval to avoid missing metrics. + Only the value corresponding to the current phase will be non-zero. +

    + updowncounter + */ +static constexpr const char *kMetricK8sPodStatusPhase = "k8s.pod.status.phase"; +static constexpr const char *descrMetricK8sPodStatusPhase = + "Describes number of K8s Pods that are currently in a given phase."; +static constexpr const char *unitMetricK8sPodStatusPhase = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sPodStatusPhase(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sPodStatusPhase, descrMetricK8sPodStatusPhase, + unitMetricK8sPodStatusPhase); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sPodStatusPhase(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sPodStatusPhase, descrMetricK8sPodStatusPhase, + unitMetricK8sPodStatusPhase); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sPodStatusPhase(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sPodStatusPhase, descrMetricK8sPodStatusPhase, unitMetricK8sPodStatusPhase); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sPodStatusPhase(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sPodStatusPhase, descrMetricK8sPodStatusPhase, unitMetricK8sPodStatusPhase); +} + +/** + Describes the number of K8s Pods that are currently in a state for a given reason. +

    + All possible pod status reasons will be reported at each time interval to avoid missing metrics. + Only the value corresponding to the current reason will be non-zero. +

    + updowncounter + */ +static constexpr const char *kMetricK8sPodStatusReason = "k8s.pod.status.reason"; +static constexpr const char *descrMetricK8sPodStatusReason = + "Describes the number of K8s Pods that are currently in a state for a given reason."; +static constexpr const char *unitMetricK8sPodStatusReason = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sPodStatusReason(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sPodStatusReason, descrMetricK8sPodStatusReason, + unitMetricK8sPodStatusReason); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sPodStatusReason(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sPodStatusReason, descrMetricK8sPodStatusReason, + unitMetricK8sPodStatusReason); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sPodStatusReason(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricK8sPodStatusReason, descrMetricK8sPodStatusReason, unitMetricK8sPodStatusReason); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sPodStatusReason(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricK8sPodStatusReason, descrMetricK8sPodStatusReason, unitMetricK8sPodStatusReason); +} + /** The time the Pod has been running.

    @@ -2690,18 +4140,23 @@ CreateAsyncDoubleMetricK8sPodVolumeUsage(metrics::Meter *meter) } /** - Total number of available replica pods (ready for at least minReadySeconds) targeted by this - replicaset.

    This metric aligns with the @code availableReplicas @endcode field of the This metric aligns with the @code + availableReplicas @endcode field of the K8s ReplicaSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sReplicasetAvailablePods = "k8s.replicaset.available_pods"; -static constexpr const char *descrMetricK8sReplicasetAvailablePods = - "Total number of available replica pods (ready for at least minReadySeconds) targeted by this " - "replicaset."; -static constexpr const char *unitMetricK8sReplicasetAvailablePods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicasetAvailablePods = + "k8s.replicaset.available_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sReplicasetAvailablePods = + "Deprecated, use `k8s.replicaset.pod.available` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sReplicasetAvailablePods = + "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sReplicasetAvailablePods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sReplicasetAvailablePods, @@ -2709,7 +4164,7 @@ CreateSyncInt64MetricK8sReplicasetAvailablePods(metrics::Meter *meter) unitMetricK8sReplicasetAvailablePods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sReplicasetAvailablePods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sReplicasetAvailablePods, @@ -2717,7 +4172,7 @@ CreateSyncDoubleMetricK8sReplicasetAvailablePods(metrics::Meter *meter) unitMetricK8sReplicasetAvailablePods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sReplicasetAvailablePods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicasetAvailablePods, @@ -2725,7 +4180,7 @@ CreateAsyncInt64MetricK8sReplicasetAvailablePods(metrics::Meter *meter) unitMetricK8sReplicasetAvailablePods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sReplicasetAvailablePods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicasetAvailablePods, @@ -2734,19 +4189,22 @@ CreateAsyncDoubleMetricK8sReplicasetAvailablePods(metrics::Meter *meter) } /** - Number of desired replica pods in this replicaset. -

    - This metric aligns with the @code replicas @endcode field of the - This metric aligns with the @code replicas + @endcode field of the K8s ReplicaSetSpec.

    updowncounter */ -static constexpr const char *kMetricK8sReplicasetDesiredPods = "k8s.replicaset.desired_pods"; -static constexpr const char *descrMetricK8sReplicasetDesiredPods = - "Number of desired replica pods in this replicaset."; -static constexpr const char *unitMetricK8sReplicasetDesiredPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicasetDesiredPods = + "k8s.replicaset.desired_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sReplicasetDesiredPods = + "Deprecated, use `k8s.replicaset.pod.desired` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sReplicasetDesiredPods = "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sReplicasetDesiredPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sReplicasetDesiredPods, @@ -2754,42 +4212,131 @@ CreateSyncInt64MetricK8sReplicasetDesiredPods(metrics::Meter *meter) unitMetricK8sReplicasetDesiredPods); } +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sReplicasetDesiredPods(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sReplicasetDesiredPods, + descrMetricK8sReplicasetDesiredPods, + unitMetricK8sReplicasetDesiredPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sReplicasetDesiredPods(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicasetDesiredPods, + descrMetricK8sReplicasetDesiredPods, + unitMetricK8sReplicasetDesiredPods); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sReplicasetDesiredPods(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicasetDesiredPods, + descrMetricK8sReplicasetDesiredPods, + unitMetricK8sReplicasetDesiredPods); +} + +/** + Total number of available replica pods (ready for at least minReadySeconds) targeted by this + replicaset.

    This metric aligns with the @code availableReplicas @endcode field of the K8s + ReplicaSetStatus.

    updowncounter + */ +static constexpr const char *kMetricK8sReplicasetPodAvailable = "k8s.replicaset.pod.available"; +static constexpr const char *descrMetricK8sReplicasetPodAvailable = + "Total number of available replica pods (ready for at least minReadySeconds) targeted by this " + "replicaset."; +static constexpr const char *unitMetricK8sReplicasetPodAvailable = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sReplicasetPodAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sReplicasetPodAvailable, + descrMetricK8sReplicasetPodAvailable, + unitMetricK8sReplicasetPodAvailable); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sReplicasetPodAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sReplicasetPodAvailable, + descrMetricK8sReplicasetPodAvailable, + unitMetricK8sReplicasetPodAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sReplicasetPodAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicasetPodAvailable, + descrMetricK8sReplicasetPodAvailable, + unitMetricK8sReplicasetPodAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sReplicasetPodAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicasetPodAvailable, + descrMetricK8sReplicasetPodAvailable, + unitMetricK8sReplicasetPodAvailable); +} + +/** + Number of desired replica pods in this replicaset. +

    + This metric aligns with the @code replicas @endcode field of the + K8s + ReplicaSetSpec.

    updowncounter + */ +static constexpr const char *kMetricK8sReplicasetPodDesired = "k8s.replicaset.pod.desired"; +static constexpr const char *descrMetricK8sReplicasetPodDesired = + "Number of desired replica pods in this replicaset."; +static constexpr const char *unitMetricK8sReplicasetPodDesired = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sReplicasetPodDesired(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sReplicasetPodDesired, + descrMetricK8sReplicasetPodDesired, + unitMetricK8sReplicasetPodDesired); +} + static inline nostd::unique_ptr> -CreateSyncDoubleMetricK8sReplicasetDesiredPods(metrics::Meter *meter) +CreateSyncDoubleMetricK8sReplicasetPodDesired(metrics::Meter *meter) { - return meter->CreateDoubleUpDownCounter(kMetricK8sReplicasetDesiredPods, - descrMetricK8sReplicasetDesiredPods, - unitMetricK8sReplicasetDesiredPods); + return meter->CreateDoubleUpDownCounter(kMetricK8sReplicasetPodDesired, + descrMetricK8sReplicasetPodDesired, + unitMetricK8sReplicasetPodDesired); } static inline nostd::shared_ptr -CreateAsyncInt64MetricK8sReplicasetDesiredPods(metrics::Meter *meter) +CreateAsyncInt64MetricK8sReplicasetPodDesired(metrics::Meter *meter) { - return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicasetDesiredPods, - descrMetricK8sReplicasetDesiredPods, - unitMetricK8sReplicasetDesiredPods); + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicasetPodDesired, + descrMetricK8sReplicasetPodDesired, + unitMetricK8sReplicasetPodDesired); } static inline nostd::shared_ptr -CreateAsyncDoubleMetricK8sReplicasetDesiredPods(metrics::Meter *meter) +CreateAsyncDoubleMetricK8sReplicasetPodDesired(metrics::Meter *meter) { - return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicasetDesiredPods, - descrMetricK8sReplicasetDesiredPods, - unitMetricK8sReplicasetDesiredPods); + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicasetPodDesired, + descrMetricK8sReplicasetPodDesired, + unitMetricK8sReplicasetPodDesired); } /** - Deprecated, use @code k8s.replicationcontroller.available_pods @endcode instead. + Deprecated, use @code k8s.replicationcontroller.pod.available @endcode instead. @deprecated - {"note": "Replaced by @code k8s.replicationcontroller.available_pods @endcode.", "reason": - "renamed", "renamed_to": "k8s.replicationcontroller.available_pods"}

    updowncounter + {"note": "Replaced by @code k8s.replicationcontroller.pod.available @endcode.", "reason": + "renamed", "renamed_to": "k8s.replicationcontroller.pod.available"}

    updowncounter */ OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicationControllerAvailablePods = "k8s.replication_controller.available_pods"; OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sReplicationControllerAvailablePods = - "Deprecated, use `k8s.replicationcontroller.available_pods` instead."; + "Deprecated, use `k8s.replicationcontroller.pod.available` instead."; OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sReplicationControllerAvailablePods = "{pod}"; @@ -2827,17 +4374,17 @@ CreateAsyncDoubleMetricK8sReplicationControllerAvailablePods(metrics::Meter *met } /** - Deprecated, use @code k8s.replicationcontroller.desired_pods @endcode instead. + Deprecated, use @code k8s.replicationcontroller.pod.desired @endcode instead. @deprecated - {"note": "Replaced by @code k8s.replicationcontroller.desired_pods @endcode.", "reason": - "renamed", "renamed_to": "k8s.replicationcontroller.desired_pods"}

    updowncounter + {"note": "Replaced by @code k8s.replicationcontroller.pod.desired @endcode.", "reason": "renamed", + "renamed_to": "k8s.replicationcontroller.pod.desired"}

    updowncounter */ OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicationControllerDesiredPods = "k8s.replication_controller.desired_pods"; OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sReplicationControllerDesiredPods = - "Deprecated, use `k8s.replicationcontroller.desired_pods` instead."; + "Deprecated, use `k8s.replicationcontroller.pod.desired` instead."; OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sReplicationControllerDesiredPods = "{pod}"; @@ -2874,20 +4421,21 @@ CreateAsyncDoubleMetricK8sReplicationControllerDesiredPods(metrics::Meter *meter } /** - Total number of available replica pods (ready for at least minReadySeconds) targeted by this - replication controller.

    This metric aligns with the @code availableReplicas @endcode field of - the K8s - ReplicationControllerStatus

    updowncounter + Deprecated, use @code k8s.replicationcontroller.pod.available @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.replicationcontroller.pod.available @endcode.", "reason": + "renamed", "renamed_to": "k8s.replicationcontroller.pod.available"}

    updowncounter */ -static constexpr const char *kMetricK8sReplicationcontrollerAvailablePods = +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicationcontrollerAvailablePods = "k8s.replicationcontroller.available_pods"; -static constexpr const char *descrMetricK8sReplicationcontrollerAvailablePods = - "Total number of available replica pods (ready for at least minReadySeconds) targeted by this " - "replication controller."; -static constexpr const char *unitMetricK8sReplicationcontrollerAvailablePods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char + *descrMetricK8sReplicationcontrollerAvailablePods = + "Deprecated, use `k8s.replicationcontroller.pod.available` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char + *unitMetricK8sReplicationcontrollerAvailablePods = "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sReplicationcontrollerAvailablePods, @@ -2895,7 +4443,7 @@ CreateSyncInt64MetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter unitMetricK8sReplicationcontrollerAvailablePods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationcontrollerAvailablePods, @@ -2903,7 +4451,7 @@ CreateSyncDoubleMetricK8sReplicationcontrollerAvailablePods(metrics::Meter *mete unitMetricK8sReplicationcontrollerAvailablePods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationcontrollerAvailablePods, @@ -2911,7 +4459,7 @@ CreateAsyncInt64MetricK8sReplicationcontrollerAvailablePods(metrics::Meter *mete unitMetricK8sReplicationcontrollerAvailablePods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter( @@ -2921,20 +4469,21 @@ CreateAsyncDoubleMetricK8sReplicationcontrollerAvailablePods(metrics::Meter *met } /** - Number of desired replica pods in this replication controller. -

    - This metric aligns with the @code replicas @endcode field of the - K8s - ReplicationControllerSpec

    updowncounter + Deprecated, use @code k8s.replicationcontroller.pod.desired @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.replicationcontroller.pod.desired @endcode.", "reason": "renamed", + "renamed_to": "k8s.replicationcontroller.pod.desired"}

    updowncounter */ -static constexpr const char *kMetricK8sReplicationcontrollerDesiredPods = +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicationcontrollerDesiredPods = "k8s.replicationcontroller.desired_pods"; -static constexpr const char *descrMetricK8sReplicationcontrollerDesiredPods = - "Number of desired replica pods in this replication controller."; -static constexpr const char *unitMetricK8sReplicationcontrollerDesiredPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char + *descrMetricK8sReplicationcontrollerDesiredPods = + "Deprecated, use `k8s.replicationcontroller.pod.desired` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char + *unitMetricK8sReplicationcontrollerDesiredPods = "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sReplicationcontrollerDesiredPods, @@ -2942,7 +4491,7 @@ CreateSyncInt64MetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter) unitMetricK8sReplicationcontrollerDesiredPods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods, @@ -2950,7 +4499,7 @@ CreateSyncDoubleMetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter) unitMetricK8sReplicationcontrollerDesiredPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods, @@ -2958,7 +4507,7 @@ CreateAsyncInt64MetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter) unitMetricK8sReplicationcontrollerDesiredPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods, @@ -2966,6 +4515,98 @@ CreateAsyncDoubleMetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter unitMetricK8sReplicationcontrollerDesiredPods); } +/** + Total number of available replica pods (ready for at least minReadySeconds) targeted by this + replication controller.

    This metric aligns with the @code availableReplicas @endcode field of + the K8s + ReplicationControllerStatus

    updowncounter + */ +static constexpr const char *kMetricK8sReplicationcontrollerPodAvailable = + "k8s.replicationcontroller.pod.available"; +static constexpr const char *descrMetricK8sReplicationcontrollerPodAvailable = + "Total number of available replica pods (ready for at least minReadySeconds) targeted by this " + "replication controller."; +static constexpr const char *unitMetricK8sReplicationcontrollerPodAvailable = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sReplicationcontrollerPodAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sReplicationcontrollerPodAvailable, + descrMetricK8sReplicationcontrollerPodAvailable, + unitMetricK8sReplicationcontrollerPodAvailable); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sReplicationcontrollerPodAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationcontrollerPodAvailable, + descrMetricK8sReplicationcontrollerPodAvailable, + unitMetricK8sReplicationcontrollerPodAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sReplicationcontrollerPodAvailable(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationcontrollerPodAvailable, + descrMetricK8sReplicationcontrollerPodAvailable, + unitMetricK8sReplicationcontrollerPodAvailable); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sReplicationcontrollerPodAvailable(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicationcontrollerPodAvailable, + descrMetricK8sReplicationcontrollerPodAvailable, + unitMetricK8sReplicationcontrollerPodAvailable); +} + +/** + Number of desired replica pods in this replication controller. +

    + This metric aligns with the @code replicas @endcode field of the + K8s + ReplicationControllerSpec

    updowncounter + */ +static constexpr const char *kMetricK8sReplicationcontrollerPodDesired = + "k8s.replicationcontroller.pod.desired"; +static constexpr const char *descrMetricK8sReplicationcontrollerPodDesired = + "Number of desired replica pods in this replication controller."; +static constexpr const char *unitMetricK8sReplicationcontrollerPodDesired = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sReplicationcontrollerPodDesired(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sReplicationcontrollerPodDesired, + descrMetricK8sReplicationcontrollerPodDesired, + unitMetricK8sReplicationcontrollerPodDesired); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sReplicationcontrollerPodDesired(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationcontrollerPodDesired, + descrMetricK8sReplicationcontrollerPodDesired, + unitMetricK8sReplicationcontrollerPodDesired); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sReplicationcontrollerPodDesired(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationcontrollerPodDesired, + descrMetricK8sReplicationcontrollerPodDesired, + unitMetricK8sReplicationcontrollerPodDesired); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sReplicationcontrollerPodDesired(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicationcontrollerPodDesired, + descrMetricK8sReplicationcontrollerPodDesired, + unitMetricK8sReplicationcontrollerPodDesired); +} + /** The CPU limits in a specific namespace. The value represents the configured quota limit of the resource in the namespace. @@ -3949,19 +5590,22 @@ CreateAsyncDoubleMetricK8sResourcequotaStorageRequestUsed(metrics::Meter *meter) } /** - The number of replica pods created by the statefulset controller from the statefulset version - indicated by currentRevision.

    This metric aligns with the @code currentReplicas @endcode field - of the This metric aligns with the @code currentReplicas + @endcode field of the K8s StatefulSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sStatefulsetCurrentPods = "k8s.statefulset.current_pods"; -static constexpr const char *descrMetricK8sStatefulsetCurrentPods = - "The number of replica pods created by the statefulset controller from the statefulset version " - "indicated by currentRevision."; -static constexpr const char *unitMetricK8sStatefulsetCurrentPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sStatefulsetCurrentPods = + "k8s.statefulset.current_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sStatefulsetCurrentPods = + "Deprecated, use `k8s.statefulset.pod.current` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sStatefulsetCurrentPods = "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sStatefulsetCurrentPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetCurrentPods, @@ -3969,7 +5613,7 @@ CreateSyncInt64MetricK8sStatefulsetCurrentPods(metrics::Meter *meter) unitMetricK8sStatefulsetCurrentPods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sStatefulsetCurrentPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetCurrentPods, @@ -3977,7 +5621,7 @@ CreateSyncDoubleMetricK8sStatefulsetCurrentPods(metrics::Meter *meter) unitMetricK8sStatefulsetCurrentPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sStatefulsetCurrentPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetCurrentPods, @@ -3985,7 +5629,7 @@ CreateAsyncInt64MetricK8sStatefulsetCurrentPods(metrics::Meter *meter) unitMetricK8sStatefulsetCurrentPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sStatefulsetCurrentPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetCurrentPods, @@ -3994,19 +5638,22 @@ CreateAsyncDoubleMetricK8sStatefulsetCurrentPods(metrics::Meter *meter) } /** - Number of desired replica pods in this statefulset. -

    - This metric aligns with the @code replicas @endcode field of the - This metric aligns with the @code replicas + @endcode field of the K8s StatefulSetSpec.

    updowncounter */ -static constexpr const char *kMetricK8sStatefulsetDesiredPods = "k8s.statefulset.desired_pods"; -static constexpr const char *descrMetricK8sStatefulsetDesiredPods = - "Number of desired replica pods in this statefulset."; -static constexpr const char *unitMetricK8sStatefulsetDesiredPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sStatefulsetDesiredPods = + "k8s.statefulset.desired_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sStatefulsetDesiredPods = + "Deprecated, use `k8s.statefulset.pod.desired` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sStatefulsetDesiredPods = "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sStatefulsetDesiredPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetDesiredPods, @@ -4014,7 +5661,7 @@ CreateSyncInt64MetricK8sStatefulsetDesiredPods(metrics::Meter *meter) unitMetricK8sStatefulsetDesiredPods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sStatefulsetDesiredPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetDesiredPods, @@ -4022,7 +5669,7 @@ CreateSyncDoubleMetricK8sStatefulsetDesiredPods(metrics::Meter *meter) unitMetricK8sStatefulsetDesiredPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sStatefulsetDesiredPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetDesiredPods, @@ -4030,7 +5677,7 @@ CreateAsyncInt64MetricK8sStatefulsetDesiredPods(metrics::Meter *meter) unitMetricK8sStatefulsetDesiredPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sStatefulsetDesiredPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetDesiredPods, @@ -4038,6 +5685,96 @@ CreateAsyncDoubleMetricK8sStatefulsetDesiredPods(metrics::Meter *meter) unitMetricK8sStatefulsetDesiredPods); } +/** + The number of replica pods created by the statefulset controller from the statefulset version + indicated by currentRevision.

    This metric aligns with the @code currentReplicas @endcode field + of the K8s + StatefulSetStatus.

    updowncounter + */ +static constexpr const char *kMetricK8sStatefulsetPodCurrent = "k8s.statefulset.pod.current"; +static constexpr const char *descrMetricK8sStatefulsetPodCurrent = + "The number of replica pods created by the statefulset controller from the statefulset version " + "indicated by currentRevision."; +static constexpr const char *unitMetricK8sStatefulsetPodCurrent = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sStatefulsetPodCurrent(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetPodCurrent, + descrMetricK8sStatefulsetPodCurrent, + unitMetricK8sStatefulsetPodCurrent); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sStatefulsetPodCurrent(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetPodCurrent, + descrMetricK8sStatefulsetPodCurrent, + unitMetricK8sStatefulsetPodCurrent); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sStatefulsetPodCurrent(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetPodCurrent, + descrMetricK8sStatefulsetPodCurrent, + unitMetricK8sStatefulsetPodCurrent); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sStatefulsetPodCurrent(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetPodCurrent, + descrMetricK8sStatefulsetPodCurrent, + unitMetricK8sStatefulsetPodCurrent); +} + +/** + Number of desired replica pods in this statefulset. +

    + This metric aligns with the @code replicas @endcode field of the + K8s + StatefulSetSpec.

    updowncounter + */ +static constexpr const char *kMetricK8sStatefulsetPodDesired = "k8s.statefulset.pod.desired"; +static constexpr const char *descrMetricK8sStatefulsetPodDesired = + "Number of desired replica pods in this statefulset."; +static constexpr const char *unitMetricK8sStatefulsetPodDesired = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sStatefulsetPodDesired(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetPodDesired, + descrMetricK8sStatefulsetPodDesired, + unitMetricK8sStatefulsetPodDesired); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sStatefulsetPodDesired(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetPodDesired, + descrMetricK8sStatefulsetPodDesired, + unitMetricK8sStatefulsetPodDesired); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sStatefulsetPodDesired(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetPodDesired, + descrMetricK8sStatefulsetPodDesired, + unitMetricK8sStatefulsetPodDesired); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sStatefulsetPodDesired(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetPodDesired, + descrMetricK8sStatefulsetPodDesired, + unitMetricK8sStatefulsetPodDesired); +} + /** The number of replica pods created for this statefulset with a Ready Condition.

    @@ -4046,12 +5783,105 @@ CreateAsyncDoubleMetricK8sStatefulsetDesiredPods(metrics::Meter *meter) href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps">K8s StatefulSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sStatefulsetReadyPods = "k8s.statefulset.ready_pods"; -static constexpr const char *descrMetricK8sStatefulsetReadyPods = +static constexpr const char *kMetricK8sStatefulsetPodReady = "k8s.statefulset.pod.ready"; +static constexpr const char *descrMetricK8sStatefulsetPodReady = "The number of replica pods created for this statefulset with a Ready Condition."; -static constexpr const char *unitMetricK8sStatefulsetReadyPods = "{pod}"; +static constexpr const char *unitMetricK8sStatefulsetPodReady = "{pod}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sStatefulsetPodReady(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetPodReady, + descrMetricK8sStatefulsetPodReady, + unitMetricK8sStatefulsetPodReady); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sStatefulsetPodReady(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetPodReady, + descrMetricK8sStatefulsetPodReady, + unitMetricK8sStatefulsetPodReady); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sStatefulsetPodReady(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetPodReady, + descrMetricK8sStatefulsetPodReady, + unitMetricK8sStatefulsetPodReady); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sStatefulsetPodReady(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetPodReady, + descrMetricK8sStatefulsetPodReady, + unitMetricK8sStatefulsetPodReady); +} + +/** + Number of replica pods created by the statefulset controller from the statefulset version + indicated by updateRevision.

    This metric aligns with the @code updatedReplicas @endcode field + of the K8s + StatefulSetStatus.

    updowncounter + */ +static constexpr const char *kMetricK8sStatefulsetPodUpdated = "k8s.statefulset.pod.updated"; +static constexpr const char *descrMetricK8sStatefulsetPodUpdated = + "Number of replica pods created by the statefulset controller from the statefulset version " + "indicated by updateRevision."; +static constexpr const char *unitMetricK8sStatefulsetPodUpdated = "{pod}"; static inline nostd::unique_ptr> +CreateSyncInt64MetricK8sStatefulsetPodUpdated(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetPodUpdated, + descrMetricK8sStatefulsetPodUpdated, + unitMetricK8sStatefulsetPodUpdated); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricK8sStatefulsetPodUpdated(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetPodUpdated, + descrMetricK8sStatefulsetPodUpdated, + unitMetricK8sStatefulsetPodUpdated); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricK8sStatefulsetPodUpdated(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetPodUpdated, + descrMetricK8sStatefulsetPodUpdated, + unitMetricK8sStatefulsetPodUpdated); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricK8sStatefulsetPodUpdated(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetPodUpdated, + descrMetricK8sStatefulsetPodUpdated, + unitMetricK8sStatefulsetPodUpdated); +} + +/** + Deprecated, use @code k8s.statefulset.pod.ready @endcode instead. + + @deprecated + {"note": "Replaced by @code k8s.statefulset.pod.ready @endcode.", "reason": "renamed", + "renamed_to": "k8s.statefulset.pod.ready"}

    This metric aligns with the @code readyReplicas + @endcode field of the K8s + StatefulSetStatus.

    updowncounter + */ +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sStatefulsetReadyPods = + "k8s.statefulset.ready_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sStatefulsetReadyPods = + "Deprecated, use `k8s.statefulset.pod.ready` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sStatefulsetReadyPods = "{pod}"; + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sStatefulsetReadyPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetReadyPods, @@ -4059,7 +5889,7 @@ CreateSyncInt64MetricK8sStatefulsetReadyPods(metrics::Meter *meter) unitMetricK8sStatefulsetReadyPods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sStatefulsetReadyPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetReadyPods, @@ -4067,7 +5897,7 @@ CreateSyncDoubleMetricK8sStatefulsetReadyPods(metrics::Meter *meter) unitMetricK8sStatefulsetReadyPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sStatefulsetReadyPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetReadyPods, @@ -4075,7 +5905,7 @@ CreateAsyncInt64MetricK8sStatefulsetReadyPods(metrics::Meter *meter) unitMetricK8sStatefulsetReadyPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sStatefulsetReadyPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetReadyPods, @@ -4084,19 +5914,22 @@ CreateAsyncDoubleMetricK8sStatefulsetReadyPods(metrics::Meter *meter) } /** - Number of replica pods created by the statefulset controller from the statefulset version - indicated by updateRevision.

    This metric aligns with the @code updatedReplicas @endcode field - of the This metric aligns with the @code updatedReplicas + @endcode field of the K8s StatefulSetStatus.

    updowncounter */ -static constexpr const char *kMetricK8sStatefulsetUpdatedPods = "k8s.statefulset.updated_pods"; -static constexpr const char *descrMetricK8sStatefulsetUpdatedPods = - "Number of replica pods created by the statefulset controller from the statefulset version " - "indicated by updateRevision."; -static constexpr const char *unitMetricK8sStatefulsetUpdatedPods = "{pod}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sStatefulsetUpdatedPods = + "k8s.statefulset.updated_pods"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricK8sStatefulsetUpdatedPods = + "Deprecated, use `k8s.statefulset.pod.updated` instead."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricK8sStatefulsetUpdatedPods = "{pod}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricK8sStatefulsetUpdatedPods(metrics::Meter *meter) { return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetUpdatedPods, @@ -4104,7 +5937,7 @@ CreateSyncInt64MetricK8sStatefulsetUpdatedPods(metrics::Meter *meter) unitMetricK8sStatefulsetUpdatedPods); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricK8sStatefulsetUpdatedPods(metrics::Meter *meter) { return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetUpdatedPods, @@ -4112,7 +5945,7 @@ CreateSyncDoubleMetricK8sStatefulsetUpdatedPods(metrics::Meter *meter) unitMetricK8sStatefulsetUpdatedPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncInt64MetricK8sStatefulsetUpdatedPods(metrics::Meter *meter) { return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetUpdatedPods, @@ -4120,7 +5953,7 @@ CreateAsyncInt64MetricK8sStatefulsetUpdatedPods(metrics::Meter *meter) unitMetricK8sStatefulsetUpdatedPods); } -static inline nostd::shared_ptr +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr CreateAsyncDoubleMetricK8sStatefulsetUpdatedPods(metrics::Meter *meter) { return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetUpdatedPods, diff --git a/api/include/opentelemetry/semconv/incubating/messaging_attributes.h b/api/include/opentelemetry/semconv/incubating/messaging_attributes.h index 4a3e48eac1..6bd5ae8100 100644 --- a/api/include/opentelemetry/semconv/incubating/messaging_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/messaging_attributes.h @@ -164,8 +164,8 @@ OPENTELEMETRY_DEPRECATED static constexpr const char *kMessagingKafkaConsumerGro Deprecated, use @code messaging.destination.partition.id @endcode instead. @deprecated - {"note": "Replaced by @code messaging.destination.partition.id @endcode.", "reason": "renamed", - "renamed_to": "messaging.destination.partition.id"} + {"note": "Record string representation of the partition id in @code + messaging.destination.partition.id @endcode attribute.", "reason": "uncategorized"} */ OPENTELEMETRY_DEPRECATED static constexpr const char *kMessagingKafkaDestinationPartition = "messaging.kafka.destination.partition"; diff --git a/api/include/opentelemetry/semconv/incubating/nfs_attributes.h b/api/include/opentelemetry/semconv/incubating/nfs_attributes.h new file mode 100644 index 0000000000..41aec45907 --- /dev/null +++ b/api/include/opentelemetry/semconv/incubating/nfs_attributes.h @@ -0,0 +1,35 @@ +/* + * 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_attributes-h.j2 + */ + +#pragma once + +#include "opentelemetry/common/macros.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace semconv +{ +namespace nfs +{ + +/** + NFSv4+ operation name. + */ +static constexpr const char *kNfsOperationName = "nfs.operation.name"; + +/** + Linux: one of "hit" (NFSD_STATS_RC_HITS), "miss" (NFSD_STATS_RC_MISSES), or "nocache" + (NFSD_STATS_RC_NOCACHE -- uncacheable) + */ +static constexpr const char *kNfsServerRepcacheStatus = "nfs.server.repcache.status"; + +} // namespace nfs +} // namespace semconv +OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/semconv/incubating/nfs_metrics.h b/api/include/opentelemetry/semconv/incubating/nfs_metrics.h new file mode 100644 index 0000000000..5d08b13bc0 --- /dev/null +++ b/api/include/opentelemetry/semconv/incubating/nfs_metrics.h @@ -0,0 +1,692 @@ +/* + * 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 nfs +{ + +/** + Reports the count of kernel NFS client TCP segments and UDP datagrams handled. +

    + Linux: this metric is taken from the Linux kernel's svc_stat.netudpcnt and svc_stat.nettcpcnt +

    + counter + */ +static constexpr const char *kMetricNfsClientNetCount = "nfs.client.net.count"; +static constexpr const char *descrMetricNfsClientNetCount = + "Reports the count of kernel NFS client TCP segments and UDP datagrams handled."; +static constexpr const char *unitMetricNfsClientNetCount = "{record}"; + +static inline nostd::unique_ptr> CreateSyncInt64MetricNfsClientNetCount( + metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsClientNetCount, descrMetricNfsClientNetCount, + unitMetricNfsClientNetCount); +} + +static inline nostd::unique_ptr> CreateSyncDoubleMetricNfsClientNetCount( + metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsClientNetCount, descrMetricNfsClientNetCount, + unitMetricNfsClientNetCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsClientNetCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsClientNetCount, descrMetricNfsClientNetCount, + unitMetricNfsClientNetCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsClientNetCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter( + kMetricNfsClientNetCount, descrMetricNfsClientNetCount, unitMetricNfsClientNetCount); +} + +/** + Reports the count of kernel NFS client TCP connections accepted. +

    + Linux: this metric is taken from the Linux kernel's svc_stat.nettcpconn +

    + counter + */ +static constexpr const char *kMetricNfsClientNetTcpConnectionAccepted = + "nfs.client.net.tcp.connection.accepted"; +static constexpr const char *descrMetricNfsClientNetTcpConnectionAccepted = + "Reports the count of kernel NFS client TCP connections accepted."; +static constexpr const char *unitMetricNfsClientNetTcpConnectionAccepted = "{connection}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsClientNetTcpConnectionAccepted(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsClientNetTcpConnectionAccepted, + descrMetricNfsClientNetTcpConnectionAccepted, + unitMetricNfsClientNetTcpConnectionAccepted); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsClientNetTcpConnectionAccepted(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsClientNetTcpConnectionAccepted, + descrMetricNfsClientNetTcpConnectionAccepted, + unitMetricNfsClientNetTcpConnectionAccepted); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsClientNetTcpConnectionAccepted(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsClientNetTcpConnectionAccepted, + descrMetricNfsClientNetTcpConnectionAccepted, + unitMetricNfsClientNetTcpConnectionAccepted); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsClientNetTcpConnectionAccepted(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsClientNetTcpConnectionAccepted, + descrMetricNfsClientNetTcpConnectionAccepted, + unitMetricNfsClientNetTcpConnectionAccepted); +} + +/** + Reports the count of kernel NFSv4+ client operations. +

    + counter + */ +static constexpr const char *kMetricNfsClientOperationCount = "nfs.client.operation.count"; +static constexpr const char *descrMetricNfsClientOperationCount = + "Reports the count of kernel NFSv4+ client operations."; +static constexpr const char *unitMetricNfsClientOperationCount = "{operation}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsClientOperationCount(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsClientOperationCount, + descrMetricNfsClientOperationCount, + unitMetricNfsClientOperationCount); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsClientOperationCount(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsClientOperationCount, + descrMetricNfsClientOperationCount, + unitMetricNfsClientOperationCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsClientOperationCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsClientOperationCount, + descrMetricNfsClientOperationCount, + unitMetricNfsClientOperationCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsClientOperationCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsClientOperationCount, + descrMetricNfsClientOperationCount, + unitMetricNfsClientOperationCount); +} + +/** + Reports the count of kernel NFS client procedures. +

    + counter + */ +static constexpr const char *kMetricNfsClientProcedureCount = "nfs.client.procedure.count"; +static constexpr const char *descrMetricNfsClientProcedureCount = + "Reports the count of kernel NFS client procedures."; +static constexpr const char *unitMetricNfsClientProcedureCount = "{procedure}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsClientProcedureCount(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsClientProcedureCount, + descrMetricNfsClientProcedureCount, + unitMetricNfsClientProcedureCount); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsClientProcedureCount(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsClientProcedureCount, + descrMetricNfsClientProcedureCount, + unitMetricNfsClientProcedureCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsClientProcedureCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsClientProcedureCount, + descrMetricNfsClientProcedureCount, + unitMetricNfsClientProcedureCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsClientProcedureCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsClientProcedureCount, + descrMetricNfsClientProcedureCount, + unitMetricNfsClientProcedureCount); +} + +/** + Reports the count of kernel NFS client RPC authentication refreshes. +

    + Linux: this metric is taken from the Linux kernel's svc_stat.rpcauthrefresh +

    + counter + */ +static constexpr const char *kMetricNfsClientRpcAuthrefreshCount = + "nfs.client.rpc.authrefresh.count"; +static constexpr const char *descrMetricNfsClientRpcAuthrefreshCount = + "Reports the count of kernel NFS client RPC authentication refreshes."; +static constexpr const char *unitMetricNfsClientRpcAuthrefreshCount = "{authrefresh}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsClientRpcAuthrefreshCount(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsClientRpcAuthrefreshCount, + descrMetricNfsClientRpcAuthrefreshCount, + unitMetricNfsClientRpcAuthrefreshCount); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsClientRpcAuthrefreshCount(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsClientRpcAuthrefreshCount, + descrMetricNfsClientRpcAuthrefreshCount, + unitMetricNfsClientRpcAuthrefreshCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsClientRpcAuthrefreshCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsClientRpcAuthrefreshCount, + descrMetricNfsClientRpcAuthrefreshCount, + unitMetricNfsClientRpcAuthrefreshCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsClientRpcAuthrefreshCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsClientRpcAuthrefreshCount, + descrMetricNfsClientRpcAuthrefreshCount, + unitMetricNfsClientRpcAuthrefreshCount); +} + +/** + Reports the count of kernel NFS client RPCs sent, regardless of whether they're accepted/rejected + by the server.

    Linux: this metric is taken from the Linux kernel's svc_stat.rpccnt

    counter + */ +static constexpr const char *kMetricNfsClientRpcCount = "nfs.client.rpc.count"; +static constexpr const char *descrMetricNfsClientRpcCount = + "Reports the count of kernel NFS client RPCs sent, regardless of whether they're " + "accepted/rejected by the server."; +static constexpr const char *unitMetricNfsClientRpcCount = "{request}"; + +static inline nostd::unique_ptr> CreateSyncInt64MetricNfsClientRpcCount( + metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsClientRpcCount, descrMetricNfsClientRpcCount, + unitMetricNfsClientRpcCount); +} + +static inline nostd::unique_ptr> CreateSyncDoubleMetricNfsClientRpcCount( + metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsClientRpcCount, descrMetricNfsClientRpcCount, + unitMetricNfsClientRpcCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsClientRpcCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsClientRpcCount, descrMetricNfsClientRpcCount, + unitMetricNfsClientRpcCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsClientRpcCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter( + kMetricNfsClientRpcCount, descrMetricNfsClientRpcCount, unitMetricNfsClientRpcCount); +} + +/** + Reports the count of kernel NFS client RPC retransmits. +

    + Linux: this metric is taken from the Linux kernel's svc_stat.rpcretrans +

    + counter + */ +static constexpr const char *kMetricNfsClientRpcRetransmitCount = "nfs.client.rpc.retransmit.count"; +static constexpr const char *descrMetricNfsClientRpcRetransmitCount = + "Reports the count of kernel NFS client RPC retransmits."; +static constexpr const char *unitMetricNfsClientRpcRetransmitCount = "{retransmit}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsClientRpcRetransmitCount(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsClientRpcRetransmitCount, + descrMetricNfsClientRpcRetransmitCount, + unitMetricNfsClientRpcRetransmitCount); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsClientRpcRetransmitCount(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsClientRpcRetransmitCount, + descrMetricNfsClientRpcRetransmitCount, + unitMetricNfsClientRpcRetransmitCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsClientRpcRetransmitCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsClientRpcRetransmitCount, + descrMetricNfsClientRpcRetransmitCount, + unitMetricNfsClientRpcRetransmitCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsClientRpcRetransmitCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsClientRpcRetransmitCount, + descrMetricNfsClientRpcRetransmitCount, + unitMetricNfsClientRpcRetransmitCount); +} + +/** + Reports the count of kernel NFS server stale file handles. +

    + Linux: this metric is taken from the Linux kernel NFSD_STATS_FH_STALE counter in the nfsd_net + struct

    counter + */ +static constexpr const char *kMetricNfsServerFhStaleCount = "nfs.server.fh.stale.count"; +static constexpr const char *descrMetricNfsServerFhStaleCount = + "Reports the count of kernel NFS server stale file handles."; +static constexpr const char *unitMetricNfsServerFhStaleCount = "{fh}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsServerFhStaleCount(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsServerFhStaleCount, descrMetricNfsServerFhStaleCount, + unitMetricNfsServerFhStaleCount); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsServerFhStaleCount(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsServerFhStaleCount, descrMetricNfsServerFhStaleCount, + unitMetricNfsServerFhStaleCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsServerFhStaleCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsServerFhStaleCount, + descrMetricNfsServerFhStaleCount, + unitMetricNfsServerFhStaleCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsServerFhStaleCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsServerFhStaleCount, + descrMetricNfsServerFhStaleCount, + unitMetricNfsServerFhStaleCount); +} + +/** + Reports the count of kernel NFS server bytes returned to receive and transmit (read and write) + requests.

    Linux: this metric is taken from the Linux kernel NFSD_STATS_IO_READ and + NFSD_STATS_IO_WRITE counters in the nfsd_net struct

    counter + */ +static constexpr const char *kMetricNfsServerIo = "nfs.server.io"; +static constexpr const char *descrMetricNfsServerIo = + "Reports the count of kernel NFS server bytes returned to receive and transmit (read and " + "write) requests."; +static constexpr const char *unitMetricNfsServerIo = "By"; + +static inline nostd::unique_ptr> CreateSyncInt64MetricNfsServerIo( + metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsServerIo, descrMetricNfsServerIo, + unitMetricNfsServerIo); +} + +static inline nostd::unique_ptr> CreateSyncDoubleMetricNfsServerIo( + metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsServerIo, descrMetricNfsServerIo, + unitMetricNfsServerIo); +} + +static inline nostd::shared_ptr CreateAsyncInt64MetricNfsServerIo( + metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsServerIo, descrMetricNfsServerIo, + unitMetricNfsServerIo); +} + +static inline nostd::shared_ptr CreateAsyncDoubleMetricNfsServerIo( + metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsServerIo, descrMetricNfsServerIo, + unitMetricNfsServerIo); +} + +/** + Reports the count of kernel NFS server TCP segments and UDP datagrams handled. +

    + Linux: this metric is taken from the Linux kernel's svc_stat.nettcpcnt and svc_stat.netudpcnt +

    + counter + */ +static constexpr const char *kMetricNfsServerNetCount = "nfs.server.net.count"; +static constexpr const char *descrMetricNfsServerNetCount = + "Reports the count of kernel NFS server TCP segments and UDP datagrams handled."; +static constexpr const char *unitMetricNfsServerNetCount = "{record}"; + +static inline nostd::unique_ptr> CreateSyncInt64MetricNfsServerNetCount( + metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsServerNetCount, descrMetricNfsServerNetCount, + unitMetricNfsServerNetCount); +} + +static inline nostd::unique_ptr> CreateSyncDoubleMetricNfsServerNetCount( + metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsServerNetCount, descrMetricNfsServerNetCount, + unitMetricNfsServerNetCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsServerNetCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsServerNetCount, descrMetricNfsServerNetCount, + unitMetricNfsServerNetCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsServerNetCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter( + kMetricNfsServerNetCount, descrMetricNfsServerNetCount, unitMetricNfsServerNetCount); +} + +/** + Reports the count of kernel NFS server TCP connections accepted. +

    + Linux: this metric is taken from the Linux kernel's svc_stat.nettcpconn +

    + counter + */ +static constexpr const char *kMetricNfsServerNetTcpConnectionAccepted = + "nfs.server.net.tcp.connection.accepted"; +static constexpr const char *descrMetricNfsServerNetTcpConnectionAccepted = + "Reports the count of kernel NFS server TCP connections accepted."; +static constexpr const char *unitMetricNfsServerNetTcpConnectionAccepted = "{connection}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsServerNetTcpConnectionAccepted(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsServerNetTcpConnectionAccepted, + descrMetricNfsServerNetTcpConnectionAccepted, + unitMetricNfsServerNetTcpConnectionAccepted); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsServerNetTcpConnectionAccepted(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsServerNetTcpConnectionAccepted, + descrMetricNfsServerNetTcpConnectionAccepted, + unitMetricNfsServerNetTcpConnectionAccepted); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsServerNetTcpConnectionAccepted(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsServerNetTcpConnectionAccepted, + descrMetricNfsServerNetTcpConnectionAccepted, + unitMetricNfsServerNetTcpConnectionAccepted); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsServerNetTcpConnectionAccepted(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsServerNetTcpConnectionAccepted, + descrMetricNfsServerNetTcpConnectionAccepted, + unitMetricNfsServerNetTcpConnectionAccepted); +} + +/** + Reports the count of kernel NFSv4+ server operations. +

    + counter + */ +static constexpr const char *kMetricNfsServerOperationCount = "nfs.server.operation.count"; +static constexpr const char *descrMetricNfsServerOperationCount = + "Reports the count of kernel NFSv4+ server operations."; +static constexpr const char *unitMetricNfsServerOperationCount = "{operation}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsServerOperationCount(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsServerOperationCount, + descrMetricNfsServerOperationCount, + unitMetricNfsServerOperationCount); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsServerOperationCount(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsServerOperationCount, + descrMetricNfsServerOperationCount, + unitMetricNfsServerOperationCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsServerOperationCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsServerOperationCount, + descrMetricNfsServerOperationCount, + unitMetricNfsServerOperationCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsServerOperationCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsServerOperationCount, + descrMetricNfsServerOperationCount, + unitMetricNfsServerOperationCount); +} + +/** + Reports the count of kernel NFS server procedures. +

    + counter + */ +static constexpr const char *kMetricNfsServerProcedureCount = "nfs.server.procedure.count"; +static constexpr const char *descrMetricNfsServerProcedureCount = + "Reports the count of kernel NFS server procedures."; +static constexpr const char *unitMetricNfsServerProcedureCount = "{procedure}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsServerProcedureCount(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsServerProcedureCount, + descrMetricNfsServerProcedureCount, + unitMetricNfsServerProcedureCount); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsServerProcedureCount(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsServerProcedureCount, + descrMetricNfsServerProcedureCount, + unitMetricNfsServerProcedureCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsServerProcedureCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsServerProcedureCount, + descrMetricNfsServerProcedureCount, + unitMetricNfsServerProcedureCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsServerProcedureCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsServerProcedureCount, + descrMetricNfsServerProcedureCount, + unitMetricNfsServerProcedureCount); +} + +/** + Reports the kernel NFS server reply cache request count by cache hit status. +

    + counter + */ +static constexpr const char *kMetricNfsServerRepcacheRequests = "nfs.server.repcache.requests"; +static constexpr const char *descrMetricNfsServerRepcacheRequests = + "Reports the kernel NFS server reply cache request count by cache hit status."; +static constexpr const char *unitMetricNfsServerRepcacheRequests = "{request}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsServerRepcacheRequests(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsServerRepcacheRequests, + descrMetricNfsServerRepcacheRequests, + unitMetricNfsServerRepcacheRequests); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsServerRepcacheRequests(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsServerRepcacheRequests, + descrMetricNfsServerRepcacheRequests, + unitMetricNfsServerRepcacheRequests); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsServerRepcacheRequests(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsServerRepcacheRequests, + descrMetricNfsServerRepcacheRequests, + unitMetricNfsServerRepcacheRequests); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsServerRepcacheRequests(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter(kMetricNfsServerRepcacheRequests, + descrMetricNfsServerRepcacheRequests, + unitMetricNfsServerRepcacheRequests); +} + +/** + Reports the count of kernel NFS server RPCs handled. +

    + Linux: this metric is taken from the Linux kernel's svc_stat.rpccnt, the count of good RPCs. This + metric can have an error.type of "format", "auth", or "client" for svc_stat.badfmt, + svc_stat.badauth, and svc_stat.badclnt.

    counter + */ +static constexpr const char *kMetricNfsServerRpcCount = "nfs.server.rpc.count"; +static constexpr const char *descrMetricNfsServerRpcCount = + "Reports the count of kernel NFS server RPCs handled."; +static constexpr const char *unitMetricNfsServerRpcCount = "{request}"; + +static inline nostd::unique_ptr> CreateSyncInt64MetricNfsServerRpcCount( + metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricNfsServerRpcCount, descrMetricNfsServerRpcCount, + unitMetricNfsServerRpcCount); +} + +static inline nostd::unique_ptr> CreateSyncDoubleMetricNfsServerRpcCount( + metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricNfsServerRpcCount, descrMetricNfsServerRpcCount, + unitMetricNfsServerRpcCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsServerRpcCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter(kMetricNfsServerRpcCount, descrMetricNfsServerRpcCount, + unitMetricNfsServerRpcCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsServerRpcCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter( + kMetricNfsServerRpcCount, descrMetricNfsServerRpcCount, unitMetricNfsServerRpcCount); +} + +/** + Reports the count of kernel NFS server available threads. +

    + Linux: this metric is taken from the Linux kernel nfsd_th_cnt variable +

    + updowncounter + */ +static constexpr const char *kMetricNfsServerThreadCount = "nfs.server.thread.count"; +static constexpr const char *descrMetricNfsServerThreadCount = + "Reports the count of kernel NFS server available threads."; +static constexpr const char *unitMetricNfsServerThreadCount = "{thread}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricNfsServerThreadCount(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter( + kMetricNfsServerThreadCount, descrMetricNfsServerThreadCount, unitMetricNfsServerThreadCount); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricNfsServerThreadCount(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter( + kMetricNfsServerThreadCount, descrMetricNfsServerThreadCount, unitMetricNfsServerThreadCount); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricNfsServerThreadCount(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricNfsServerThreadCount, descrMetricNfsServerThreadCount, unitMetricNfsServerThreadCount); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricNfsServerThreadCount(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricNfsServerThreadCount, descrMetricNfsServerThreadCount, unitMetricNfsServerThreadCount); +} + +} // namespace nfs +} // namespace semconv +OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/semconv/incubating/onc_rpc_attributes.h b/api/include/opentelemetry/semconv/incubating/onc_rpc_attributes.h new file mode 100644 index 0000000000..afd4487268 --- /dev/null +++ b/api/include/opentelemetry/semconv/incubating/onc_rpc_attributes.h @@ -0,0 +1,44 @@ +/* + * 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_attributes-h.j2 + */ + +#pragma once + +#include "opentelemetry/common/macros.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace semconv +{ +namespace onc_rpc +{ + +/** + ONC/Sun RPC procedure name. + */ +static constexpr const char *kOncRpcProcedureName = "onc_rpc.procedure.name"; + +/** + ONC/Sun RPC procedure number. + */ +static constexpr const char *kOncRpcProcedureNumber = "onc_rpc.procedure.number"; + +/** + ONC/Sun RPC program name. + */ +static constexpr const char *kOncRpcProgramName = "onc_rpc.program.name"; + +/** + ONC/Sun RPC program version. + */ +static constexpr const char *kOncRpcVersion = "onc_rpc.version"; + +} // namespace onc_rpc +} // namespace semconv +OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/semconv/incubating/openshift_attributes.h b/api/include/opentelemetry/semconv/incubating/openshift_attributes.h new file mode 100644 index 0000000000..fe3f5da2c3 --- /dev/null +++ b/api/include/opentelemetry/semconv/incubating/openshift_attributes.h @@ -0,0 +1,34 @@ +/* + * 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_attributes-h.j2 + */ + +#pragma once + +#include "opentelemetry/common/macros.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace semconv +{ +namespace openshift +{ + +/** + The name of the cluster quota. + */ +static constexpr const char *kOpenshiftClusterquotaName = "openshift.clusterquota.name"; + +/** + The UID of the cluster quota. + */ +static constexpr const char *kOpenshiftClusterquotaUid = "openshift.clusterquota.uid"; + +} // namespace openshift +} // namespace semconv +OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/semconv/incubating/openshift_metrics.h b/api/include/opentelemetry/semconv/incubating/openshift_metrics.h new file mode 100644 index 0000000000..f2e7ab2c26 --- /dev/null +++ b/api/include/opentelemetry/semconv/incubating/openshift_metrics.h @@ -0,0 +1,1065 @@ +/* + * 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 openshift +{ + +/** + The enforced hard limit of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Hard @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaCpuLimitHard = + "openshift.clusterquota.cpu.limit.hard"; +static constexpr const char *descrMetricOpenshiftClusterquotaCpuLimitHard = + "The enforced hard limit of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaCpuLimitHard = "{cpu}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaCpuLimitHard(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaCpuLimitHard, + descrMetricOpenshiftClusterquotaCpuLimitHard, + unitMetricOpenshiftClusterquotaCpuLimitHard); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaCpuLimitHard(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaCpuLimitHard, + descrMetricOpenshiftClusterquotaCpuLimitHard, + unitMetricOpenshiftClusterquotaCpuLimitHard); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaCpuLimitHard(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricOpenshiftClusterquotaCpuLimitHard, + descrMetricOpenshiftClusterquotaCpuLimitHard, + unitMetricOpenshiftClusterquotaCpuLimitHard); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaCpuLimitHard(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricOpenshiftClusterquotaCpuLimitHard, + descrMetricOpenshiftClusterquotaCpuLimitHard, + unitMetricOpenshiftClusterquotaCpuLimitHard); +} + +/** + The current observed total usage of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Used @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaCpuLimitUsed = + "openshift.clusterquota.cpu.limit.used"; +static constexpr const char *descrMetricOpenshiftClusterquotaCpuLimitUsed = + "The current observed total usage of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaCpuLimitUsed = "{cpu}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaCpuLimitUsed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaCpuLimitUsed, + descrMetricOpenshiftClusterquotaCpuLimitUsed, + unitMetricOpenshiftClusterquotaCpuLimitUsed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaCpuLimitUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaCpuLimitUsed, + descrMetricOpenshiftClusterquotaCpuLimitUsed, + unitMetricOpenshiftClusterquotaCpuLimitUsed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaCpuLimitUsed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricOpenshiftClusterquotaCpuLimitUsed, + descrMetricOpenshiftClusterquotaCpuLimitUsed, + unitMetricOpenshiftClusterquotaCpuLimitUsed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaCpuLimitUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricOpenshiftClusterquotaCpuLimitUsed, + descrMetricOpenshiftClusterquotaCpuLimitUsed, + unitMetricOpenshiftClusterquotaCpuLimitUsed); +} + +/** + The enforced hard limit of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Hard @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaCpuRequestHard = + "openshift.clusterquota.cpu.request.hard"; +static constexpr const char *descrMetricOpenshiftClusterquotaCpuRequestHard = + "The enforced hard limit of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaCpuRequestHard = "{cpu}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaCpuRequestHard(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaCpuRequestHard, + descrMetricOpenshiftClusterquotaCpuRequestHard, + unitMetricOpenshiftClusterquotaCpuRequestHard); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaCpuRequestHard(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaCpuRequestHard, + descrMetricOpenshiftClusterquotaCpuRequestHard, + unitMetricOpenshiftClusterquotaCpuRequestHard); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaCpuRequestHard(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricOpenshiftClusterquotaCpuRequestHard, + descrMetricOpenshiftClusterquotaCpuRequestHard, + unitMetricOpenshiftClusterquotaCpuRequestHard); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaCpuRequestHard(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricOpenshiftClusterquotaCpuRequestHard, + descrMetricOpenshiftClusterquotaCpuRequestHard, + unitMetricOpenshiftClusterquotaCpuRequestHard); +} + +/** + The current observed total usage of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Used @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaCpuRequestUsed = + "openshift.clusterquota.cpu.request.used"; +static constexpr const char *descrMetricOpenshiftClusterquotaCpuRequestUsed = + "The current observed total usage of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaCpuRequestUsed = "{cpu}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaCpuRequestUsed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaCpuRequestUsed, + descrMetricOpenshiftClusterquotaCpuRequestUsed, + unitMetricOpenshiftClusterquotaCpuRequestUsed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaCpuRequestUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaCpuRequestUsed, + descrMetricOpenshiftClusterquotaCpuRequestUsed, + unitMetricOpenshiftClusterquotaCpuRequestUsed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaCpuRequestUsed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricOpenshiftClusterquotaCpuRequestUsed, + descrMetricOpenshiftClusterquotaCpuRequestUsed, + unitMetricOpenshiftClusterquotaCpuRequestUsed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaCpuRequestUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricOpenshiftClusterquotaCpuRequestUsed, + descrMetricOpenshiftClusterquotaCpuRequestUsed, + unitMetricOpenshiftClusterquotaCpuRequestUsed); +} + +/** + The enforced hard limit of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Hard @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaEphemeralStorageLimitHard = + "openshift.clusterquota.ephemeral_storage.limit.hard"; +static constexpr const char *descrMetricOpenshiftClusterquotaEphemeralStorageLimitHard = + "The enforced hard limit of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaEphemeralStorageLimitHard = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaEphemeralStorageLimitHard(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaEphemeralStorageLimitHard, + descrMetricOpenshiftClusterquotaEphemeralStorageLimitHard, + unitMetricOpenshiftClusterquotaEphemeralStorageLimitHard); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaEphemeralStorageLimitHard(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaEphemeralStorageLimitHard, + descrMetricOpenshiftClusterquotaEphemeralStorageLimitHard, + unitMetricOpenshiftClusterquotaEphemeralStorageLimitHard); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaEphemeralStorageLimitHard(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageLimitHard, + descrMetricOpenshiftClusterquotaEphemeralStorageLimitHard, + unitMetricOpenshiftClusterquotaEphemeralStorageLimitHard); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaEphemeralStorageLimitHard(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageLimitHard, + descrMetricOpenshiftClusterquotaEphemeralStorageLimitHard, + unitMetricOpenshiftClusterquotaEphemeralStorageLimitHard); +} + +/** + The current observed total usage of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Used @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaEphemeralStorageLimitUsed = + "openshift.clusterquota.ephemeral_storage.limit.used"; +static constexpr const char *descrMetricOpenshiftClusterquotaEphemeralStorageLimitUsed = + "The current observed total usage of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaEphemeralStorageLimitUsed = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaEphemeralStorageLimitUsed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaEphemeralStorageLimitUsed, + descrMetricOpenshiftClusterquotaEphemeralStorageLimitUsed, + unitMetricOpenshiftClusterquotaEphemeralStorageLimitUsed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaEphemeralStorageLimitUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaEphemeralStorageLimitUsed, + descrMetricOpenshiftClusterquotaEphemeralStorageLimitUsed, + unitMetricOpenshiftClusterquotaEphemeralStorageLimitUsed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaEphemeralStorageLimitUsed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageLimitUsed, + descrMetricOpenshiftClusterquotaEphemeralStorageLimitUsed, + unitMetricOpenshiftClusterquotaEphemeralStorageLimitUsed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaEphemeralStorageLimitUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageLimitUsed, + descrMetricOpenshiftClusterquotaEphemeralStorageLimitUsed, + unitMetricOpenshiftClusterquotaEphemeralStorageLimitUsed); +} + +/** + The enforced hard limit of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Hard @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaEphemeralStorageRequestHard = + "openshift.clusterquota.ephemeral_storage.request.hard"; +static constexpr const char *descrMetricOpenshiftClusterquotaEphemeralStorageRequestHard = + "The enforced hard limit of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaEphemeralStorageRequestHard = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaEphemeralStorageRequestHard(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageRequestHard, + descrMetricOpenshiftClusterquotaEphemeralStorageRequestHard, + unitMetricOpenshiftClusterquotaEphemeralStorageRequestHard); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaEphemeralStorageRequestHard(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageRequestHard, + descrMetricOpenshiftClusterquotaEphemeralStorageRequestHard, + unitMetricOpenshiftClusterquotaEphemeralStorageRequestHard); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaEphemeralStorageRequestHard(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageRequestHard, + descrMetricOpenshiftClusterquotaEphemeralStorageRequestHard, + unitMetricOpenshiftClusterquotaEphemeralStorageRequestHard); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaEphemeralStorageRequestHard(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageRequestHard, + descrMetricOpenshiftClusterquotaEphemeralStorageRequestHard, + unitMetricOpenshiftClusterquotaEphemeralStorageRequestHard); +} + +/** + The current observed total usage of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Used @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaEphemeralStorageRequestUsed = + "openshift.clusterquota.ephemeral_storage.request.used"; +static constexpr const char *descrMetricOpenshiftClusterquotaEphemeralStorageRequestUsed = + "The current observed total usage of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaEphemeralStorageRequestUsed = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaEphemeralStorageRequestUsed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageRequestUsed, + descrMetricOpenshiftClusterquotaEphemeralStorageRequestUsed, + unitMetricOpenshiftClusterquotaEphemeralStorageRequestUsed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaEphemeralStorageRequestUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageRequestUsed, + descrMetricOpenshiftClusterquotaEphemeralStorageRequestUsed, + unitMetricOpenshiftClusterquotaEphemeralStorageRequestUsed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaEphemeralStorageRequestUsed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageRequestUsed, + descrMetricOpenshiftClusterquotaEphemeralStorageRequestUsed, + unitMetricOpenshiftClusterquotaEphemeralStorageRequestUsed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaEphemeralStorageRequestUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaEphemeralStorageRequestUsed, + descrMetricOpenshiftClusterquotaEphemeralStorageRequestUsed, + unitMetricOpenshiftClusterquotaEphemeralStorageRequestUsed); +} + +/** + The enforced hard limit of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Hard @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaHugepageCountRequestHard = + "openshift.clusterquota.hugepage_count.request.hard"; +static constexpr const char *descrMetricOpenshiftClusterquotaHugepageCountRequestHard = + "The enforced hard limit of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaHugepageCountRequestHard = + "{hugepage}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaHugepageCountRequestHard(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaHugepageCountRequestHard, + descrMetricOpenshiftClusterquotaHugepageCountRequestHard, + unitMetricOpenshiftClusterquotaHugepageCountRequestHard); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaHugepageCountRequestHard(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaHugepageCountRequestHard, + descrMetricOpenshiftClusterquotaHugepageCountRequestHard, + unitMetricOpenshiftClusterquotaHugepageCountRequestHard); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaHugepageCountRequestHard(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaHugepageCountRequestHard, + descrMetricOpenshiftClusterquotaHugepageCountRequestHard, + unitMetricOpenshiftClusterquotaHugepageCountRequestHard); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaHugepageCountRequestHard(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaHugepageCountRequestHard, + descrMetricOpenshiftClusterquotaHugepageCountRequestHard, + unitMetricOpenshiftClusterquotaHugepageCountRequestHard); +} + +/** + The current observed total usage of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Used @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaHugepageCountRequestUsed = + "openshift.clusterquota.hugepage_count.request.used"; +static constexpr const char *descrMetricOpenshiftClusterquotaHugepageCountRequestUsed = + "The current observed total usage of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaHugepageCountRequestUsed = + "{hugepage}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaHugepageCountRequestUsed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaHugepageCountRequestUsed, + descrMetricOpenshiftClusterquotaHugepageCountRequestUsed, + unitMetricOpenshiftClusterquotaHugepageCountRequestUsed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaHugepageCountRequestUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaHugepageCountRequestUsed, + descrMetricOpenshiftClusterquotaHugepageCountRequestUsed, + unitMetricOpenshiftClusterquotaHugepageCountRequestUsed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaHugepageCountRequestUsed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaHugepageCountRequestUsed, + descrMetricOpenshiftClusterquotaHugepageCountRequestUsed, + unitMetricOpenshiftClusterquotaHugepageCountRequestUsed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaHugepageCountRequestUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaHugepageCountRequestUsed, + descrMetricOpenshiftClusterquotaHugepageCountRequestUsed, + unitMetricOpenshiftClusterquotaHugepageCountRequestUsed); +} + +/** + The enforced hard limit of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Hard @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaMemoryLimitHard = + "openshift.clusterquota.memory.limit.hard"; +static constexpr const char *descrMetricOpenshiftClusterquotaMemoryLimitHard = + "The enforced hard limit of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaMemoryLimitHard = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaMemoryLimitHard(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaMemoryLimitHard, + descrMetricOpenshiftClusterquotaMemoryLimitHard, + unitMetricOpenshiftClusterquotaMemoryLimitHard); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaMemoryLimitHard(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaMemoryLimitHard, + descrMetricOpenshiftClusterquotaMemoryLimitHard, + unitMetricOpenshiftClusterquotaMemoryLimitHard); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaMemoryLimitHard(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricOpenshiftClusterquotaMemoryLimitHard, + descrMetricOpenshiftClusterquotaMemoryLimitHard, + unitMetricOpenshiftClusterquotaMemoryLimitHard); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaMemoryLimitHard(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricOpenshiftClusterquotaMemoryLimitHard, + descrMetricOpenshiftClusterquotaMemoryLimitHard, + unitMetricOpenshiftClusterquotaMemoryLimitHard); +} + +/** + The current observed total usage of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Used @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaMemoryLimitUsed = + "openshift.clusterquota.memory.limit.used"; +static constexpr const char *descrMetricOpenshiftClusterquotaMemoryLimitUsed = + "The current observed total usage of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaMemoryLimitUsed = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaMemoryLimitUsed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaMemoryLimitUsed, + descrMetricOpenshiftClusterquotaMemoryLimitUsed, + unitMetricOpenshiftClusterquotaMemoryLimitUsed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaMemoryLimitUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaMemoryLimitUsed, + descrMetricOpenshiftClusterquotaMemoryLimitUsed, + unitMetricOpenshiftClusterquotaMemoryLimitUsed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaMemoryLimitUsed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricOpenshiftClusterquotaMemoryLimitUsed, + descrMetricOpenshiftClusterquotaMemoryLimitUsed, + unitMetricOpenshiftClusterquotaMemoryLimitUsed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaMemoryLimitUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricOpenshiftClusterquotaMemoryLimitUsed, + descrMetricOpenshiftClusterquotaMemoryLimitUsed, + unitMetricOpenshiftClusterquotaMemoryLimitUsed); +} + +/** + The enforced hard limit of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Hard @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaMemoryRequestHard = + "openshift.clusterquota.memory.request.hard"; +static constexpr const char *descrMetricOpenshiftClusterquotaMemoryRequestHard = + "The enforced hard limit of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaMemoryRequestHard = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaMemoryRequestHard(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaMemoryRequestHard, + descrMetricOpenshiftClusterquotaMemoryRequestHard, + unitMetricOpenshiftClusterquotaMemoryRequestHard); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaMemoryRequestHard(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaMemoryRequestHard, + descrMetricOpenshiftClusterquotaMemoryRequestHard, + unitMetricOpenshiftClusterquotaMemoryRequestHard); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaMemoryRequestHard(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaMemoryRequestHard, + descrMetricOpenshiftClusterquotaMemoryRequestHard, + unitMetricOpenshiftClusterquotaMemoryRequestHard); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaMemoryRequestHard(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaMemoryRequestHard, + descrMetricOpenshiftClusterquotaMemoryRequestHard, + unitMetricOpenshiftClusterquotaMemoryRequestHard); +} + +/** + The current observed total usage of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Used @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaMemoryRequestUsed = + "openshift.clusterquota.memory.request.used"; +static constexpr const char *descrMetricOpenshiftClusterquotaMemoryRequestUsed = + "The current observed total usage of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaMemoryRequestUsed = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaMemoryRequestUsed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaMemoryRequestUsed, + descrMetricOpenshiftClusterquotaMemoryRequestUsed, + unitMetricOpenshiftClusterquotaMemoryRequestUsed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaMemoryRequestUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaMemoryRequestUsed, + descrMetricOpenshiftClusterquotaMemoryRequestUsed, + unitMetricOpenshiftClusterquotaMemoryRequestUsed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaMemoryRequestUsed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaMemoryRequestUsed, + descrMetricOpenshiftClusterquotaMemoryRequestUsed, + unitMetricOpenshiftClusterquotaMemoryRequestUsed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaMemoryRequestUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaMemoryRequestUsed, + descrMetricOpenshiftClusterquotaMemoryRequestUsed, + unitMetricOpenshiftClusterquotaMemoryRequestUsed); +} + +/** + The enforced hard limit of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Hard @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaObjectCountHard = + "openshift.clusterquota.object_count.hard"; +static constexpr const char *descrMetricOpenshiftClusterquotaObjectCountHard = + "The enforced hard limit of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaObjectCountHard = "{object}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaObjectCountHard(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaObjectCountHard, + descrMetricOpenshiftClusterquotaObjectCountHard, + unitMetricOpenshiftClusterquotaObjectCountHard); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaObjectCountHard(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaObjectCountHard, + descrMetricOpenshiftClusterquotaObjectCountHard, + unitMetricOpenshiftClusterquotaObjectCountHard); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaObjectCountHard(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricOpenshiftClusterquotaObjectCountHard, + descrMetricOpenshiftClusterquotaObjectCountHard, + unitMetricOpenshiftClusterquotaObjectCountHard); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaObjectCountHard(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricOpenshiftClusterquotaObjectCountHard, + descrMetricOpenshiftClusterquotaObjectCountHard, + unitMetricOpenshiftClusterquotaObjectCountHard); +} + +/** + The current observed total usage of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Used @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaObjectCountUsed = + "openshift.clusterquota.object_count.used"; +static constexpr const char *descrMetricOpenshiftClusterquotaObjectCountUsed = + "The current observed total usage of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaObjectCountUsed = "{object}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaObjectCountUsed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaObjectCountUsed, + descrMetricOpenshiftClusterquotaObjectCountUsed, + unitMetricOpenshiftClusterquotaObjectCountUsed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaObjectCountUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaObjectCountUsed, + descrMetricOpenshiftClusterquotaObjectCountUsed, + unitMetricOpenshiftClusterquotaObjectCountUsed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaObjectCountUsed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter(kMetricOpenshiftClusterquotaObjectCountUsed, + descrMetricOpenshiftClusterquotaObjectCountUsed, + unitMetricOpenshiftClusterquotaObjectCountUsed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaObjectCountUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter(kMetricOpenshiftClusterquotaObjectCountUsed, + descrMetricOpenshiftClusterquotaObjectCountUsed, + unitMetricOpenshiftClusterquotaObjectCountUsed); +} + +/** + The enforced hard limit of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Hard @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + The @code k8s.storageclass.name @endcode should be required when a resource quota is defined for a + specific storage class.

    updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard = + "openshift.clusterquota.persistentvolumeclaim_count.hard"; +static constexpr const char *descrMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard = + "The enforced hard limit of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard = + "{persistentvolumeclaim}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaPersistentvolumeclaimCountHard(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter( + kMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard, + descrMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard, + unitMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter( + kMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard, + descrMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard, + unitMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaPersistentvolumeclaimCountHard(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard, + descrMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard, + unitMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard, + descrMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard, + unitMetricOpenshiftClusterquotaPersistentvolumeclaimCountHard); +} + +/** + The current observed total usage of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Used @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + The @code k8s.storageclass.name @endcode should be required when a resource quota is defined for a + specific storage class.

    updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed = + "openshift.clusterquota.persistentvolumeclaim_count.used"; +static constexpr const char *descrMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed = + "The current observed total usage of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed = + "{persistentvolumeclaim}"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter( + kMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed, + descrMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed, + unitMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter( + kMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed, + descrMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed, + unitMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed, + descrMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed, + unitMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed, + descrMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed, + unitMetricOpenshiftClusterquotaPersistentvolumeclaimCountUsed); +} + +/** + The enforced hard limit of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Hard @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + The @code k8s.storageclass.name @endcode should be required when a resource quota is defined for a + specific storage class.

    updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaStorageRequestHard = + "openshift.clusterquota.storage.request.hard"; +static constexpr const char *descrMetricOpenshiftClusterquotaStorageRequestHard = + "The enforced hard limit of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaStorageRequestHard = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaStorageRequestHard(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaStorageRequestHard, + descrMetricOpenshiftClusterquotaStorageRequestHard, + unitMetricOpenshiftClusterquotaStorageRequestHard); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaStorageRequestHard(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaStorageRequestHard, + descrMetricOpenshiftClusterquotaStorageRequestHard, + unitMetricOpenshiftClusterquotaStorageRequestHard); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaStorageRequestHard(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaStorageRequestHard, + descrMetricOpenshiftClusterquotaStorageRequestHard, + unitMetricOpenshiftClusterquotaStorageRequestHard); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaStorageRequestHard(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaStorageRequestHard, + descrMetricOpenshiftClusterquotaStorageRequestHard, + unitMetricOpenshiftClusterquotaStorageRequestHard); +} + +/** + The current observed total usage of the resource across all projects. +

    + This metric is retrieved from the @code Status.Total.Used @endcode field of the + K8s + ResourceQuotaStatus of the ClusterResourceQuota. +

    + The @code k8s.storageclass.name @endcode should be required when a resource quota is defined for a + specific storage class.

    updowncounter + */ +static constexpr const char *kMetricOpenshiftClusterquotaStorageRequestUsed = + "openshift.clusterquota.storage.request.used"; +static constexpr const char *descrMetricOpenshiftClusterquotaStorageRequestUsed = + "The current observed total usage of the resource across all projects. + "; + static constexpr const char *unitMetricOpenshiftClusterquotaStorageRequestUsed = "By"; + +static inline nostd::unique_ptr> +CreateSyncInt64MetricOpenshiftClusterquotaStorageRequestUsed(metrics::Meter *meter) +{ + return meter->CreateInt64UpDownCounter(kMetricOpenshiftClusterquotaStorageRequestUsed, + descrMetricOpenshiftClusterquotaStorageRequestUsed, + unitMetricOpenshiftClusterquotaStorageRequestUsed); +} + +static inline nostd::unique_ptr> +CreateSyncDoubleMetricOpenshiftClusterquotaStorageRequestUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleUpDownCounter(kMetricOpenshiftClusterquotaStorageRequestUsed, + descrMetricOpenshiftClusterquotaStorageRequestUsed, + unitMetricOpenshiftClusterquotaStorageRequestUsed); +} + +static inline nostd::shared_ptr +CreateAsyncInt64MetricOpenshiftClusterquotaStorageRequestUsed(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableUpDownCounter( + kMetricOpenshiftClusterquotaStorageRequestUsed, + descrMetricOpenshiftClusterquotaStorageRequestUsed, + unitMetricOpenshiftClusterquotaStorageRequestUsed); +} + +static inline nostd::shared_ptr +CreateAsyncDoubleMetricOpenshiftClusterquotaStorageRequestUsed(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableUpDownCounter( + kMetricOpenshiftClusterquotaStorageRequestUsed, + descrMetricOpenshiftClusterquotaStorageRequestUsed, + unitMetricOpenshiftClusterquotaStorageRequestUsed); +} + +} // namespace openshift +} // namespace semconv +OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/semconv/incubating/peer_attributes.h b/api/include/opentelemetry/semconv/incubating/peer_attributes.h index acc6621d24..290258ebed 100644 --- a/api/include/opentelemetry/semconv/incubating/peer_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/peer_attributes.h @@ -22,7 +22,12 @@ namespace peer /** The @code service.name @endcode of the remote service. SHOULD be equal to the actual @code service.name @endcode resource attribute of the - remote service if any. + remote service if any.

    Examples of @code peer.service @endcode that users may specify:

    */ static constexpr const char *kPeerService = "peer.service"; diff --git a/api/include/opentelemetry/semconv/incubating/pprof_attributes.h b/api/include/opentelemetry/semconv/incubating/pprof_attributes.h new file mode 100644 index 0000000000..dc55f9c7e1 --- /dev/null +++ b/api/include/opentelemetry/semconv/incubating/pprof_attributes.h @@ -0,0 +1,58 @@ +/* + * 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_attributes-h.j2 + */ + +#pragma once + +#include "opentelemetry/common/macros.h" +#include "opentelemetry/version.h" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace semconv +{ +namespace pprof +{ + +/** + Provides an indication that multiple symbols map to this location's address, for example due to + identical code folding by the linker. In that case the line information represents one of the + multiple symbols. This field must be recomputed when the symbolization state of the profile + changes. + */ +static constexpr const char *kPprofLocationIsFolded = "pprof.location.is_folded"; + +/** + Indicates that there are filenames related to this mapping. + */ +static constexpr const char *kPprofMappingHasFilenames = "pprof.mapping.has_filenames"; + +/** + Indicates that there are functions related to this mapping. + */ +static constexpr const char *kPprofMappingHasFunctions = "pprof.mapping.has_functions"; + +/** + Indicates that there are inline frames related to this mapping. + */ +static constexpr const char *kPprofMappingHasInlineFrames = "pprof.mapping.has_inline_frames"; + +/** + Indicates that there are line numbers related to this mapping. + */ +static constexpr const char *kPprofMappingHasLineNumbers = "pprof.mapping.has_line_numbers"; + +/** + Free-form text associated with the profile. This field should not be used to store any + machine-readable information, it is only for human-friendly content. + */ +static constexpr const char *kPprofProfileComment = "pprof.profile.comment"; + +} // namespace pprof +} // namespace semconv +OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/semconv/incubating/process_attributes.h b/api/include/opentelemetry/semconv/incubating/process_attributes.h index b6a8bd1d02..8b2f0b986a 100644 --- a/api/include/opentelemetry/semconv/incubating/process_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/process_attributes.h @@ -54,7 +54,7 @@ static constexpr const char *kProcessCommandLine = "process.command_line"; /** Specifies whether the context switches for this data point were voluntary or involuntary. */ -static constexpr const char *kProcessContextSwitchType = "process.context_switch_type"; +static constexpr const char *kProcessContextSwitchType = "process.context_switch.type"; /** Deprecated, use @code cpu.mode @endcode instead. @@ -158,10 +158,14 @@ static constexpr const char *kProcessLinuxCgroup = "process.linux.cgroup"; static constexpr const char *kProcessOwner = "process.owner"; /** - The type of page fault for this data point. Type @code major @endcode is for major/hard page - faults, and @code minor @endcode is for minor/soft page faults. + Deprecated, use @code system.paging.fault.type @endcode instead. + + @deprecated + {"note": "Replaced by @code system.paging.fault.type @endcode.", "reason": "renamed", + "renamed_to": "system.paging.fault.type"} */ -static constexpr const char *kProcessPagingFaultType = "process.paging.fault_type"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kProcessPagingFaultType = + "process.paging.fault_type"; /** Parent Process identifier (PPID). @@ -214,6 +218,13 @@ static constexpr const char *kProcessSavedUserName = "process.saved_user.name"; */ static constexpr const char *kProcessSessionLeaderPid = "process.session_leader.pid"; +/** + The process state, e.g., Linux Process State + Codes + */ +static constexpr const char *kProcessState = "process.state"; + /** Process title (proctitle)

    @@ -274,6 +285,19 @@ static constexpr const char *kMinor = "minor"; } // namespace ProcessPagingFaultTypeValues +namespace ProcessStateValues +{ + +static constexpr const char *kRunning = "running"; + +static constexpr const char *kSleeping = "sleeping"; + +static constexpr const char *kStopped = "stopped"; + +static constexpr const char *kDefunct = "defunct"; + +} // namespace ProcessStateValues + } // namespace process } // namespace semconv OPENTELEMETRY_END_NAMESPACE diff --git a/api/include/opentelemetry/semconv/incubating/rpc_attributes.h b/api/include/opentelemetry/semconv/incubating/rpc_attributes.h index 8a85fe4697..ce5e9072f4 100644 --- a/api/include/opentelemetry/semconv/incubating/rpc_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/rpc_attributes.h @@ -123,22 +123,12 @@ static constexpr const char *kRpcMessageType = "rpc.message.type"; static constexpr const char *kRpcMessageUncompressedSize = "rpc.message.uncompressed_size"; /** - The name of the (logical) method being called, must be equal to the $method part in the span name. -

    - This is the logical name of the method from the RPC interface perspective, which can be different - from the name of any implementing method/function. The @code code.function.name @endcode attribute - may be used to store the latter (e.g., method actually executing the call on the server side, RPC - client stub method on the client side). + This is the logical name of the method from the RPC interface perspective. */ static constexpr const char *kRpcMethod = "rpc.method"; /** The full (logical) name of the service being called, including its package name, if applicable. -

    - This is the logical name of the service from the RPC interface perspective, which can be different - from the name of any implementing class. The @code code.namespace @endcode attribute may be used - to store the latter (despite the attribute name, it may include a class name; e.g., class with - method actually executing the call on the server side, RPC client stub class on the client side). */ static constexpr const char *kRpcService = "rpc.service"; @@ -309,6 +299,16 @@ static constexpr const char *kApacheDubbo = "apache_dubbo"; */ static constexpr const char *kConnectRpc = "connect_rpc"; +/** + ONC RPC (Sun RPC) + */ +static constexpr const char *kOncRpc = "onc_rpc"; + +/** + JSON-RPC + */ +static constexpr const char *kJsonrpc = "jsonrpc"; + } // namespace RpcSystemValues } // namespace rpc diff --git a/api/include/opentelemetry/semconv/incubating/rpc_metrics.h b/api/include/opentelemetry/semconv/incubating/rpc_metrics.h index a337142ef3..2933185e3e 100644 --- a/api/include/opentelemetry/semconv/incubating/rpc_metrics.h +++ b/api/include/opentelemetry/semconv/incubating/rpc_metrics.h @@ -77,6 +77,9 @@ CreateSyncDoubleMetricRpcClientRequestSize(metrics::Meter *meter) /** Measures the number of messages received per RPC. + + @deprecated + {"note": "Removed, no replacement at this time.", "reason": "obsoleted"}

    Should be 1 for all non-streaming RPCs.

    @@ -84,12 +87,13 @@ CreateSyncDoubleMetricRpcClientRequestSize(metrics::Meter *meter)

    histogram */ -static constexpr const char *kMetricRpcClientRequestsPerRpc = "rpc.client.requests_per_rpc"; -static constexpr const char *descrMetricRpcClientRequestsPerRpc = +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricRpcClientRequestsPerRpc = + "rpc.client.requests_per_rpc"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricRpcClientRequestsPerRpc = "Measures the number of messages received per RPC."; -static constexpr const char *unitMetricRpcClientRequestsPerRpc = "{count}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricRpcClientRequestsPerRpc = "{count}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricRpcClientRequestsPerRpc(metrics::Meter *meter) { return meter->CreateUInt64Histogram(kMetricRpcClientRequestsPerRpc, @@ -97,7 +101,7 @@ CreateSyncInt64MetricRpcClientRequestsPerRpc(metrics::Meter *meter) unitMetricRpcClientRequestsPerRpc); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricRpcClientRequestsPerRpc(metrics::Meter *meter) { return meter->CreateDoubleHistogram(kMetricRpcClientRequestsPerRpc, @@ -135,6 +139,9 @@ CreateSyncDoubleMetricRpcClientResponseSize(metrics::Meter *meter) /** Measures the number of messages sent per RPC. + + @deprecated + {"note": "Removed, no replacement at this time.", "reason": "obsoleted"}

    Should be 1 for all non-streaming RPCs.

    @@ -142,12 +149,14 @@ CreateSyncDoubleMetricRpcClientResponseSize(metrics::Meter *meter)

    histogram */ -static constexpr const char *kMetricRpcClientResponsesPerRpc = "rpc.client.responses_per_rpc"; -static constexpr const char *descrMetricRpcClientResponsesPerRpc = +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricRpcClientResponsesPerRpc = + "rpc.client.responses_per_rpc"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricRpcClientResponsesPerRpc = "Measures the number of messages sent per RPC."; -static constexpr const char *unitMetricRpcClientResponsesPerRpc = "{count}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricRpcClientResponsesPerRpc = + "{count}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricRpcClientResponsesPerRpc(metrics::Meter *meter) { return meter->CreateUInt64Histogram(kMetricRpcClientResponsesPerRpc, @@ -155,7 +164,7 @@ CreateSyncInt64MetricRpcClientResponsesPerRpc(metrics::Meter *meter) unitMetricRpcClientResponsesPerRpc); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricRpcClientResponsesPerRpc(metrics::Meter *meter) { return meter->CreateDoubleHistogram(kMetricRpcClientResponsesPerRpc, @@ -219,6 +228,9 @@ CreateSyncDoubleMetricRpcServerRequestSize(metrics::Meter *meter) /** Measures the number of messages received per RPC. + + @deprecated + {"note": "Removed, no replacement at this time.", "reason": "obsoleted"}

    Should be 1 for all non-streaming RPCs.

    @@ -226,12 +238,13 @@ CreateSyncDoubleMetricRpcServerRequestSize(metrics::Meter *meter)

    histogram */ -static constexpr const char *kMetricRpcServerRequestsPerRpc = "rpc.server.requests_per_rpc"; -static constexpr const char *descrMetricRpcServerRequestsPerRpc = +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricRpcServerRequestsPerRpc = + "rpc.server.requests_per_rpc"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricRpcServerRequestsPerRpc = "Measures the number of messages received per RPC."; -static constexpr const char *unitMetricRpcServerRequestsPerRpc = "{count}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricRpcServerRequestsPerRpc = "{count}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricRpcServerRequestsPerRpc(metrics::Meter *meter) { return meter->CreateUInt64Histogram(kMetricRpcServerRequestsPerRpc, @@ -239,7 +252,7 @@ CreateSyncInt64MetricRpcServerRequestsPerRpc(metrics::Meter *meter) unitMetricRpcServerRequestsPerRpc); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricRpcServerRequestsPerRpc(metrics::Meter *meter) { return meter->CreateDoubleHistogram(kMetricRpcServerRequestsPerRpc, @@ -277,6 +290,9 @@ CreateSyncDoubleMetricRpcServerResponseSize(metrics::Meter *meter) /** Measures the number of messages sent per RPC. + + @deprecated + {"note": "Removed, no replacement at this time.", "reason": "obsoleted"}

    Should be 1 for all non-streaming RPCs.

    @@ -284,12 +300,14 @@ CreateSyncDoubleMetricRpcServerResponseSize(metrics::Meter *meter)

    histogram */ -static constexpr const char *kMetricRpcServerResponsesPerRpc = "rpc.server.responses_per_rpc"; -static constexpr const char *descrMetricRpcServerResponsesPerRpc = +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricRpcServerResponsesPerRpc = + "rpc.server.responses_per_rpc"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricRpcServerResponsesPerRpc = "Measures the number of messages sent per RPC."; -static constexpr const char *unitMetricRpcServerResponsesPerRpc = "{count}"; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricRpcServerResponsesPerRpc = + "{count}"; -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncInt64MetricRpcServerResponsesPerRpc(metrics::Meter *meter) { return meter->CreateUInt64Histogram(kMetricRpcServerResponsesPerRpc, @@ -297,7 +315,7 @@ CreateSyncInt64MetricRpcServerResponsesPerRpc(metrics::Meter *meter) unitMetricRpcServerResponsesPerRpc); } -static inline nostd::unique_ptr> +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> CreateSyncDoubleMetricRpcServerResponsesPerRpc(metrics::Meter *meter) { return meter->CreateDoubleHistogram(kMetricRpcServerResponsesPerRpc, diff --git a/api/include/opentelemetry/semconv/incubating/system_attributes.h b/api/include/opentelemetry/semconv/incubating/system_attributes.h index 7000190351..b9ad02de79 100644 --- a/api/include/opentelemetry/semconv/incubating/system_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/system_attributes.h @@ -21,8 +21,13 @@ namespace system /** Deprecated, use @code cpu.logical_number @endcode instead. + + @deprecated + {"note": "Replaced by @code cpu.logical_number @endcode.", "reason": "renamed", "renamed_to": + "cpu.logical_number"} */ -static constexpr const char *kSystemCpuLogicalNumber = "system.cpu.logical_number"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kSystemCpuLogicalNumber = + "system.cpu.logical_number"; /** Deprecated, use @code cpu.mode @endcode instead. @@ -76,29 +81,41 @@ OPENTELEMETRY_DEPRECATED static constexpr const char *kSystemNetworkState = "sys */ static constexpr const char *kSystemPagingDirection = "system.paging.direction"; +/** + The paging fault type + */ +static constexpr const char *kSystemPagingFaultType = "system.paging.fault.type"; + /** The memory paging state */ static constexpr const char *kSystemPagingState = "system.paging.state"; /** - The memory paging type + Deprecated, use @code system.paging.fault.type @endcode instead. + + @deprecated + {"note": "Replaced by @code system.paging.fault.type @endcode.", "reason": "renamed", + "renamed_to": "system.paging.fault.type"} */ -static constexpr const char *kSystemPagingType = "system.paging.type"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kSystemPagingType = "system.paging.type"; /** - The process state, e.g., Linux Process State - Codes + Deprecated, use @code process.state @endcode instead. + + @deprecated + {"note": "Replaced by @code process.state @endcode.", "reason": "renamed", "renamed_to": + "process.state"} */ -static constexpr const char *kSystemProcessStatus = "system.process.status"; +OPENTELEMETRY_DEPRECATED static constexpr const char *kSystemProcessStatus = + "system.process.status"; /** - Deprecated, use @code system.process.status @endcode instead. + Deprecated, use @code process.state @endcode instead. @deprecated - {"note": "Replaced by @code system.process.status @endcode.", "reason": "renamed", "renamed_to": - "system.process.status"} + {"note": "Replaced by @code process.state @endcode.", "reason": "renamed", "renamed_to": + "process.state"} */ OPENTELEMETRY_DEPRECATED static constexpr const char *kSystemProcessesStatus = "system.processes.status"; @@ -210,6 +227,15 @@ static constexpr const char *kOut = "out"; } // namespace SystemPagingDirectionValues +namespace SystemPagingFaultTypeValues +{ + +static constexpr const char *kMajor = "major"; + +static constexpr const char *kMinor = "minor"; + +} // namespace SystemPagingFaultTypeValues + namespace SystemPagingStateValues { diff --git a/api/include/opentelemetry/semconv/incubating/system_metrics.h b/api/include/opentelemetry/semconv/incubating/system_metrics.h index d0767b51a6..63106b053f 100644 --- a/api/include/opentelemetry/semconv/incubating/system_metrics.h +++ b/api/include/opentelemetry/semconv/incubating/system_metrics.h @@ -228,12 +228,12 @@ CreateAsyncDoubleMetricSystemCpuUtilization(metrics::Meter *meter) } /** - TODO. + Disk bytes transferred.

    counter */ static constexpr const char *kMetricSystemDiskIo = "system.disk.io"; -static constexpr const char *descrMetricSystemDiskIo = "TODO."; +static constexpr const char *descrMetricSystemDiskIo = "Disk bytes transferred."; static constexpr const char *unitMetricSystemDiskIo = "By"; static inline nostd::unique_ptr> CreateSyncInt64MetricSystemDiskIo( @@ -348,13 +348,14 @@ CreateAsyncDoubleMetricSystemDiskLimit(metrics::Meter *meter) } /** - TODO. + The number of disk reads/writes merged into single physical disk access operations.

    counter */ -static constexpr const char *kMetricSystemDiskMerged = "system.disk.merged"; -static constexpr const char *descrMetricSystemDiskMerged = "TODO."; -static constexpr const char *unitMetricSystemDiskMerged = "{operation}"; +static constexpr const char *kMetricSystemDiskMerged = "system.disk.merged"; +static constexpr const char *descrMetricSystemDiskMerged = + "The number of disk reads/writes merged into single physical disk access operations."; +static constexpr const char *unitMetricSystemDiskMerged = "{operation}"; static inline nostd::unique_ptr> CreateSyncInt64MetricSystemDiskMerged( metrics::Meter *meter) @@ -434,12 +435,12 @@ CreateAsyncDoubleMetricSystemDiskOperationTime(metrics::Meter *meter) } /** - TODO. + Disk operations count.

    counter */ static constexpr const char *kMetricSystemDiskOperations = "system.disk.operations"; -static constexpr const char *descrMetricSystemDiskOperations = "TODO."; +static constexpr const char *descrMetricSystemDiskOperations = "Disk operations count."; static constexpr const char *unitMetricSystemDiskOperations = "{operation}"; static inline nostd::unique_ptr> @@ -557,13 +558,14 @@ CreateAsyncDoubleMetricSystemFilesystemUsage(metrics::Meter *meter) } /** - TODO. + Fraction of filesystem bytes used.

    gauge */ static constexpr const char *kMetricSystemFilesystemUtilization = "system.filesystem.utilization"; -static constexpr const char *descrMetricSystemFilesystemUtilization = "TODO."; -static constexpr const char *unitMetricSystemFilesystemUtilization = "1"; +static constexpr const char *descrMetricSystemFilesystemUtilization = + "Fraction of filesystem bytes used."; +static constexpr const char *unitMetricSystemFilesystemUtilization = "1"; #if OPENTELEMETRY_ABI_VERSION_NO >= 2 @@ -812,13 +814,14 @@ CreateAsyncDoubleMetricSystemMemoryUsage(metrics::Meter *meter) } /** - TODO. + Percentage of memory bytes in use.

    gauge */ -static constexpr const char *kMetricSystemMemoryUtilization = "system.memory.utilization"; -static constexpr const char *descrMetricSystemMemoryUtilization = "TODO."; -static constexpr const char *unitMetricSystemMemoryUtilization = "1"; +static constexpr const char *kMetricSystemMemoryUtilization = "system.memory.utilization"; +static constexpr const char *descrMetricSystemMemoryUtilization = + "Percentage of memory bytes in use."; +static constexpr const char *unitMetricSystemMemoryUtilization = "1"; #if OPENTELEMETRY_ABI_VERSION_NO >= 2 @@ -855,13 +858,13 @@ CreateAsyncDoubleMetricSystemMemoryUtilization(metrics::Meter *meter) } /** - TODO. + The number of connections.

    updowncounter */ static constexpr const char *kMetricSystemNetworkConnectionCount = "system.network.connection.count"; -static constexpr const char *descrMetricSystemNetworkConnectionCount = "TODO."; +static constexpr const char *descrMetricSystemNetworkConnectionCount = "The number of connections."; static constexpr const char *unitMetricSystemNetworkConnectionCount = "{connection}"; static inline nostd::unique_ptr> @@ -942,6 +945,57 @@ CreateAsyncDoubleMetricSystemNetworkConnections(metrics::Meter *meter) unitMetricSystemNetworkConnections); } +/** + Count of packets that are dropped or discarded even though there was no error. + + @deprecated + {"note": "Replaced by @code system.network.packet.dropped @endcode.", "reason": "renamed", + "renamed_to": "system.network.packet.dropped"}

    Measured as:

    +

    + counter + */ +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricSystemNetworkDropped = + "system.network.dropped"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricSystemNetworkDropped = + "Count of packets that are dropped or discarded even though there was no error."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricSystemNetworkDropped = "{packet}"; + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricSystemNetworkDropped(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricSystemNetworkDropped, descrMetricSystemNetworkDropped, + unitMetricSystemNetworkDropped); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricSystemNetworkDropped(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricSystemNetworkDropped, descrMetricSystemNetworkDropped, + unitMetricSystemNetworkDropped); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncInt64MetricSystemNetworkDropped(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter( + kMetricSystemNetworkDropped, descrMetricSystemNetworkDropped, unitMetricSystemNetworkDropped); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncDoubleMetricSystemNetworkDropped(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter( + kMetricSystemNetworkDropped, descrMetricSystemNetworkDropped, unitMetricSystemNetworkDropped); +} + /** Count of network errors detected.

    @@ -991,13 +1045,14 @@ CreateAsyncDoubleMetricSystemNetworkErrors(metrics::Meter *meter) } /** - TODO. + The number of bytes transmitted and received.

    counter */ -static constexpr const char *kMetricSystemNetworkIo = "system.network.io"; -static constexpr const char *descrMetricSystemNetworkIo = "TODO."; -static constexpr const char *unitMetricSystemNetworkIo = "By"; +static constexpr const char *kMetricSystemNetworkIo = "system.network.io"; +static constexpr const char *descrMetricSystemNetworkIo = + "The number of bytes transmitted and received."; +static constexpr const char *unitMetricSystemNetworkIo = "By"; static inline nostd::unique_ptr> CreateSyncInt64MetricSystemNetworkIo( metrics::Meter *meter) @@ -1028,13 +1083,14 @@ CreateAsyncDoubleMetricSystemNetworkIo(metrics::Meter *meter) } /** - TODO. + The number of packets transferred.

    counter */ -static constexpr const char *kMetricSystemNetworkPacketCount = "system.network.packet.count"; -static constexpr const char *descrMetricSystemNetworkPacketCount = "TODO."; -static constexpr const char *unitMetricSystemNetworkPacketCount = "{packet}"; +static constexpr const char *kMetricSystemNetworkPacketCount = "system.network.packet.count"; +static constexpr const char *descrMetricSystemNetworkPacketCount = + "The number of packets transferred."; +static constexpr const char *unitMetricSystemNetworkPacketCount = "{packet}"; static inline nostd::unique_ptr> CreateSyncInt64MetricSystemNetworkPacketCount(metrics::Meter *meter) @@ -1122,12 +1178,53 @@ CreateAsyncDoubleMetricSystemNetworkPacketDropped(metrics::Meter *meter) } /** - TODO. + The number of packets transferred. + + @deprecated + {"note": "Replaced by @code system.network.packet.count @endcode.", "reason": "renamed", + "renamed_to": "system.network.packet.count"}

    counter + */ +OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricSystemNetworkPackets = + "system.network.packets"; +OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricSystemNetworkPackets = + "The number of packets transferred."; +OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricSystemNetworkPackets = "{packet}"; + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncInt64MetricSystemNetworkPackets(metrics::Meter *meter) +{ + return meter->CreateUInt64Counter(kMetricSystemNetworkPackets, descrMetricSystemNetworkPackets, + unitMetricSystemNetworkPackets); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr> +CreateSyncDoubleMetricSystemNetworkPackets(metrics::Meter *meter) +{ + return meter->CreateDoubleCounter(kMetricSystemNetworkPackets, descrMetricSystemNetworkPackets, + unitMetricSystemNetworkPackets); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncInt64MetricSystemNetworkPackets(metrics::Meter *meter) +{ + return meter->CreateInt64ObservableCounter( + kMetricSystemNetworkPackets, descrMetricSystemNetworkPackets, unitMetricSystemNetworkPackets); +} + +OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr +CreateAsyncDoubleMetricSystemNetworkPackets(metrics::Meter *meter) +{ + return meter->CreateDoubleObservableCounter( + kMetricSystemNetworkPackets, descrMetricSystemNetworkPackets, unitMetricSystemNetworkPackets); +} + +/** + The number of page faults.

    counter */ static constexpr const char *kMetricSystemPagingFaults = "system.paging.faults"; -static constexpr const char *descrMetricSystemPagingFaults = "TODO."; +static constexpr const char *descrMetricSystemPagingFaults = "The number of page faults."; static constexpr const char *unitMetricSystemPagingFaults = "{fault}"; static inline nostd::unique_ptr> CreateSyncInt64MetricSystemPagingFaults( @@ -1159,12 +1256,12 @@ CreateAsyncDoubleMetricSystemPagingFaults(metrics::Meter *meter) } /** - TODO. + The number of paging operations.

    counter */ static constexpr const char *kMetricSystemPagingOperations = "system.paging.operations"; -static constexpr const char *descrMetricSystemPagingOperations = "TODO."; +static constexpr const char *descrMetricSystemPagingOperations = "The number of paging operations."; static constexpr const char *unitMetricSystemPagingOperations = "{operation}"; static inline nostd::unique_ptr> @@ -1237,13 +1334,14 @@ CreateAsyncDoubleMetricSystemPagingUsage(metrics::Meter *meter) } /** - TODO. + Swap (unix) or pagefile (windows) utilization.

    gauge */ -static constexpr const char *kMetricSystemPagingUtilization = "system.paging.utilization"; -static constexpr const char *descrMetricSystemPagingUtilization = "TODO."; -static constexpr const char *unitMetricSystemPagingUtilization = "1"; +static constexpr const char *kMetricSystemPagingUtilization = "system.paging.utilization"; +static constexpr const char *descrMetricSystemPagingUtilization = + "Swap (unix) or pagefile (windows) utilization."; +static constexpr const char *unitMetricSystemPagingUtilization = "1"; #if OPENTELEMETRY_ABI_VERSION_NO >= 2 diff --git a/api/include/opentelemetry/semconv/incubating/thread_attributes.h b/api/include/opentelemetry/semconv/incubating/thread_attributes.h index 2d0c290651..8aefe5667b 100644 --- a/api/include/opentelemetry/semconv/incubating/thread_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/thread_attributes.h @@ -21,11 +21,32 @@ namespace thread /** Current "managed" thread ID (as opposed to OS thread ID). +

    + Examples of where the value can be extracted from: +

    + | Language or platform | Source | + | --- | --- | + | JVM | @code Thread.currentThread().threadId() @endcode | + | .NET | @code Thread.CurrentThread.ManagedThreadId @endcode | + | Python | @code threading.current_thread().ident @endcode | + | Ruby | @code Thread.current.object_id @endcode | + | C++ | @code std::this_thread::get_id() @endcode | + | Erlang | @code erlang:self() @endcode | */ static constexpr const char *kThreadId = "thread.id"; /** Current thread name. +

    + Examples of where the value can be extracted from: +

    + | Language or platform | Source | + | --- | --- | + | JVM | @code Thread.currentThread().getName() @endcode | + | .NET | @code Thread.CurrentThread.Name @endcode | + | Python | @code threading.current_thread().name @endcode | + | Ruby | @code Thread.current.name @endcode | + | Erlang | @code erlang:process_info(self(), registered_name) @endcode | */ static constexpr const char *kThreadName = "thread.name"; diff --git a/api/include/opentelemetry/semconv/incubating/vcs_attributes.h b/api/include/opentelemetry/semconv/incubating/vcs_attributes.h index 16227fe4b4..d30fdd90e9 100644 --- a/api/include/opentelemetry/semconv/incubating/vcs_attributes.h +++ b/api/include/opentelemetry/semconv/incubating/vcs_attributes.h @@ -185,11 +185,10 @@ OPENTELEMETRY_DEPRECATED static constexpr const char *kVcsRepositoryRefType = "vcs.repository.ref.type"; /** - The canonical - URL of the repository providing the complete HTTP(S) address in order to locate and identify - the repository through a browser.

    In Git Version Control Systems, the canonical URL SHOULD NOT - include the @code .git @endcode extension. + The canonical URL of the + repository providing the complete HTTP(S) address in order to locate and identify the repository + through a browser.

    In Git Version Control Systems, the canonical URL SHOULD NOT include the + @code .git @endcode extension. */ static constexpr const char *kVcsRepositoryUrlFull = "vcs.repository.url.full"; diff --git a/api/include/opentelemetry/semconv/schema_url.h b/api/include/opentelemetry/semconv/schema_url.h index 6d5fc0e48d..50beae469f 100644 --- a/api/include/opentelemetry/semconv/schema_url.h +++ b/api/include/opentelemetry/semconv/schema_url.h @@ -19,6 +19,6 @@ namespace semconv /** * The URL of the OpenTelemetry schema for these keys and values. */ -static constexpr const char *kSchemaUrl = "https://opentelemetry.io/schemas/1.37.0"; +static constexpr const char *kSchemaUrl = "https://opentelemetry.io/schemas/1.38.0"; } // namespace semconv OPENTELEMETRY_END_NAMESPACE diff --git a/buildscripts/semantic-convention/generate.sh b/buildscripts/semantic-convention/generate.sh index 2dc8356ccc..6e4499a0f6 100755 --- a/buildscripts/semantic-convention/generate.sh +++ b/buildscripts/semantic-convention/generate.sh @@ -16,10 +16,10 @@ ROOT_DIR="${SCRIPT_DIR}/../../" # freeze the spec & generator tools versions to make the generation reproducible # repository: https://github.com/open-telemetry/semantic-conventions -SEMCONV_VERSION=1.37.0 +SEMCONV_VERSION=1.38.0 # repository: https://github.com/open-telemetry/weaver -WEAVER_VERSION=0.17.1 +WEAVER_VERSION=0.18.0 SEMCONV_VERSION_TAG=v$SEMCONV_VERSION WEAVER_VERSION_TAG=v$WEAVER_VERSION