From fb8d9f2efb17d38d8f2736d9f7320dffcd2e5314 Mon Sep 17 00:00:00 2001 From: Ben Carr Date: Thu, 1 Feb 2024 23:03:45 -0800 Subject: [PATCH 01/11] Adds some basic constants for metrics utilizing a new jinja template --- Makefile | 3 +- semconv/metric_template.j2 | 48 ++ semconv/v1.24.0/metric.go | 878 +++++++++++++++++++++++++++++++++++++ 3 files changed, 928 insertions(+), 1 deletion(-) create mode 100644 semconv/metric_template.j2 create mode 100644 semconv/v1.24.0/metric.go diff --git a/Makefile b/Makefile index 35fc189961b..5d19223959e 100644 --- a/Makefile +++ b/Makefile @@ -291,6 +291,7 @@ semconv-generate: | $(SEMCONVGEN) $(SEMCONVKIT) $(SEMCONVGEN) -i "$(OTEL_SEMCONV_REPO)/model/." --only=attribute_group -p conventionType=trace -f attribute_group.go -t "$(SEMCONVPKG)/template.j2" -s "$(TAG)" $(SEMCONVGEN) -i "$(OTEL_SEMCONV_REPO)/model/." --only=event -p conventionType=event -f event.go -t "$(SEMCONVPKG)/template.j2" -s "$(TAG)" $(SEMCONVGEN) -i "$(OTEL_SEMCONV_REPO)/model/." --only=resource -p conventionType=resource -f resource.go -t "$(SEMCONVPKG)/template.j2" -s "$(TAG)" + $(SEMCONVGEN) -i "$(OTEL_SEMCONV_REPO)/model/." --only=metric -f metric.go -t "$(SEMCONVPKG)/metric_template.j2" -s "$(TAG)" $(SEMCONVKIT) -output "$(SEMCONVPKG)/$(TAG)" -tag "$(TAG)" .PHONY: gorelease @@ -314,5 +315,5 @@ add-tags: | $(MULTIMOD) $(MULTIMOD) verify && $(MULTIMOD) tag -m ${MODSET} -c ${COMMIT} .PHONY: lint-markdown -lint-markdown: +lint-markdown: docker run -v "$(CURDIR):$(WORKDIR)" docker://avtodev/markdown-lint:v1 -c $(WORKDIR)/.markdownlint.yaml $(WORKDIR)/**/*.md diff --git a/semconv/metric_template.j2 b/semconv/metric_template.j2 new file mode 100644 index 00000000000..a8ad77ff7af --- /dev/null +++ b/semconv/metric_template.j2 @@ -0,0 +1,48 @@ +{%- macro to_go_name(fqn) -%} +{{fqn | replace(".", " ") | replace("_", " ") | title | replace(" ", "")}} +{%- endmacro -%} +{%- macro it_reps(brief) -%} +It represents {% if brief[:2] == "A " or brief[:3] == "An " or brief[:4] == "The " -%} + {{ brief[0]|lower }}{{ brief[1:] }} +{%- else -%} + the {{ brief[0]|lower }}{{ brief[1:] }} +{%- endif -%} +{%- endmacro -%} +{%- macro keydoc(metric) -%} +{%- if metric.stability|string() == "StabilityLevel.DEPRECATED" -%} +{{ to_go_name(metric.metric_name) }} is the attribute Key conforming to the "{{ metric.metric_name}}" semantic conventions. +{%- else -%} +{{ to_go_name(metric.metric_name) }} is the attribute Key conforming to the "{{ metric.metric_name}}" semantic conventions. {{ it_reps(metric.brief) }} +{%- endif %} +{%- endmacro -%} +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated from semantic convention specification. DO NOT EDIT. + +package semconv // import [[IMPORTPATH]] + +import "go.opentelemetry.io/otel/attribute" + +const ( +{% for id in semconvs %} +{%- if semconvs[id].GROUP_TYPE_NAME == 'metric' %}{% set metric = semconvs[id] %} + // {{ keydoc(metric) | wordwrap(76, break_long_words=false, break_on_hyphens=false, wrapstring="\n// ") }} + // Instrument: {{ metric.instrument }} + // Unit: {{ metric.unit }} + // Stability: {{ metric.stability }} + {{to_go_name(metric.metric_name)}} = attribute.Key("{{metric.metric_name}}") +{%- endif %} +{% endfor %} +) diff --git a/semconv/v1.24.0/metric.go b/semconv/v1.24.0/metric.go new file mode 100644 index 00000000000..c8591a6dcb7 --- /dev/null +++ b/semconv/v1.24.0/metric.go @@ -0,0 +1,878 @@ +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated from semantic convention specification. DO NOT EDIT. + +package semconv // import "go.opentelemetry.io/otel/semconv/v1.24.0" + +import "go.opentelemetry.io/otel/attribute" + +const ( + + // DBClientConnectionsUsage is the attribute Key conforming to the + // "db.client.connections.usage" semantic conventions. It represents the number + // of connections that are currently in state described by the `state` + // attribute + // Instrument: updowncounter + // Unit: {connection} + // Stability: None + DBClientConnectionsUsage = attribute.Key("db.client.connections.usage") + + // DBClientConnectionsIdleMax is the attribute Key conforming to the + // "db.client.connections.idle.max" semantic conventions. It represents the + // maximum number of idle open connections allowed + // Instrument: updowncounter + // Unit: {connection} + // Stability: None + DBClientConnectionsIdleMax = attribute.Key("db.client.connections.idle.max") + + // DBClientConnectionsIdleMin is the attribute Key conforming to the + // "db.client.connections.idle.min" semantic conventions. It represents the + // minimum number of idle open connections allowed + // Instrument: updowncounter + // Unit: {connection} + // Stability: None + DBClientConnectionsIdleMin = attribute.Key("db.client.connections.idle.min") + + // DBClientConnectionsMax is the attribute Key conforming to the + // "db.client.connections.max" semantic conventions. It represents the maximum + // number of open connections allowed + // Instrument: updowncounter + // Unit: {connection} + // Stability: None + DBClientConnectionsMax = attribute.Key("db.client.connections.max") + + // DBClientConnectionsPendingRequests is the attribute Key conforming to the + // "db.client.connections.pending_requests" semantic conventions. It represents + // the number of pending requests for an open connection, cumulative for the + // entire pool + // Instrument: updowncounter + // Unit: {request} + // Stability: None + DBClientConnectionsPendingRequests = attribute.Key("db.client.connections.pending_requests") + + // DBClientConnectionsTimeouts is the attribute Key conforming to the + // "db.client.connections.timeouts" semantic conventions. It represents the + // number of connection timeouts that have occurred trying to obtain a + // connection from the pool + // Instrument: counter + // Unit: {timeout} + // Stability: None + DBClientConnectionsTimeouts = attribute.Key("db.client.connections.timeouts") + + // DBClientConnectionsCreateTime is the attribute Key conforming to the + // "db.client.connections.create_time" semantic conventions. It represents the + // time it took to create a new connection + // Instrument: histogram + // Unit: ms + // Stability: None + DBClientConnectionsCreateTime = attribute.Key("db.client.connections.create_time") + + // DBClientConnectionsWaitTime is the attribute Key conforming to the + // "db.client.connections.wait_time" semantic conventions. It represents the + // time it took to obtain an open connection from the pool + // Instrument: histogram + // Unit: ms + // Stability: None + DBClientConnectionsWaitTime = attribute.Key("db.client.connections.wait_time") + + // DBClientConnectionsUseTime is the attribute Key conforming to the + // "db.client.connections.use_time" semantic conventions. It represents the + // time between borrowing a connection and returning it to the pool + // Instrument: histogram + // Unit: ms + // Stability: None + DBClientConnectionsUseTime = attribute.Key("db.client.connections.use_time") + + // AspnetcoreRoutingMatchAttempts is the attribute Key conforming to the + // "aspnetcore.routing.match_attempts" semantic conventions. It represents the + // number of requests that were attempted to be matched to an endpoint. + // Instrument: counter + // Unit: {match_attempt} + // Stability: None + AspnetcoreRoutingMatchAttempts = attribute.Key("aspnetcore.routing.match_attempts") + + // AspnetcoreDiagnosticsExceptions is the attribute Key conforming to the + // "aspnetcore.diagnostics.exceptions" semantic conventions. It represents the + // number of exceptions caught by exception handling middleware. + // Instrument: counter + // Unit: {exception} + // Stability: None + AspnetcoreDiagnosticsExceptions = attribute.Key("aspnetcore.diagnostics.exceptions") + + // AspnetcoreRateLimitingActiveRequestLeases is the attribute Key conforming to + // the "aspnetcore.rate_limiting.active_request_leases" semantic conventions. + // It represents the number of requests that are currently active on the server + // that hold a rate limiting lease. + // Instrument: updowncounter + // Unit: {request} + // Stability: None + AspnetcoreRateLimitingActiveRequestLeases = attribute.Key("aspnetcore.rate_limiting.active_request_leases") + + // AspnetcoreRateLimitingRequestLeaseDuration is the attribute Key conforming + // to the "aspnetcore.rate_limiting.request_lease.duration" semantic + // conventions. It represents the duration of rate limiting lease held by + // requests on the server. + // Instrument: histogram + // Unit: s + // Stability: None + AspnetcoreRateLimitingRequestLeaseDuration = attribute.Key("aspnetcore.rate_limiting.request_lease.duration") + + // AspnetcoreRateLimitingRequestTimeInQueue is the attribute Key conforming to + // the "aspnetcore.rate_limiting.request.time_in_queue" semantic conventions. + // It represents the time the request spent in a queue waiting to acquire a + // rate limiting lease. + // Instrument: histogram + // Unit: s + // Stability: None + AspnetcoreRateLimitingRequestTimeInQueue = attribute.Key("aspnetcore.rate_limiting.request.time_in_queue") + + // AspnetcoreRateLimitingQueuedRequests is the attribute Key conforming to the + // "aspnetcore.rate_limiting.queued_requests" semantic conventions. It + // represents the number of requests that are currently queued, waiting to + // acquire a rate limiting lease. + // Instrument: updowncounter + // Unit: {request} + // Stability: None + AspnetcoreRateLimitingQueuedRequests = attribute.Key("aspnetcore.rate_limiting.queued_requests") + + // AspnetcoreRateLimitingRequests is the attribute Key conforming to the + // "aspnetcore.rate_limiting.requests" semantic conventions. It represents the + // number of requests that tried to acquire a rate limiting lease. + // Instrument: counter + // Unit: {request} + // Stability: None + AspnetcoreRateLimitingRequests = attribute.Key("aspnetcore.rate_limiting.requests") + + // DNSLookupDuration is the attribute Key conforming to the + // "dns.lookup.duration" semantic conventions. It represents the measures the + // time taken to perform a DNS lookup. + // Instrument: histogram + // Unit: s + // Stability: None + DNSLookupDuration = attribute.Key("dns.lookup.duration") + + // HTTPClientOpenConnections is the attribute Key conforming to the + // "http.client.open_connections" semantic conventions. It represents the + // number of outbound HTTP connections that are currently active or idle on the + // client. + // Instrument: updowncounter + // Unit: {connection} + // Stability: None + HTTPClientOpenConnections = attribute.Key("http.client.open_connections") + + // HTTPClientConnectionDuration is the attribute Key conforming to the + // "http.client.connection.duration" semantic conventions. It represents the + // duration of the successfully established outbound HTTP connections. + // Instrument: histogram + // Unit: s + // Stability: None + HTTPClientConnectionDuration = attribute.Key("http.client.connection.duration") + + // HTTPClientActiveRequests is the attribute Key conforming to the + // "http.client.active_requests" semantic conventions. It represents the number + // of active HTTP requests. + // Instrument: updowncounter + // Unit: {request} + // Stability: None + HTTPClientActiveRequests = attribute.Key("http.client.active_requests") + + // HTTPClientRequestTimeInQueue is the attribute Key conforming to the + // "http.client.request.time_in_queue" semantic conventions. It represents the + // amount of time requests spent on a queue waiting for an available + // connection. + // Instrument: histogram + // Unit: s + // Stability: None + HTTPClientRequestTimeInQueue = attribute.Key("http.client.request.time_in_queue") + + // KestrelActiveConnections is the attribute Key conforming to the + // "kestrel.active_connections" semantic conventions. It represents the number + // of connections that are currently active on the server. + // Instrument: updowncounter + // Unit: {connection} + // Stability: None + KestrelActiveConnections = attribute.Key("kestrel.active_connections") + + // KestrelConnectionDuration is the attribute Key conforming to the + // "kestrel.connection.duration" semantic conventions. It represents the + // duration of connections on the server. + // Instrument: histogram + // Unit: s + // Stability: None + KestrelConnectionDuration = attribute.Key("kestrel.connection.duration") + + // KestrelRejectedConnections is the attribute Key conforming to the + // "kestrel.rejected_connections" semantic conventions. It represents the + // number of connections rejected by the server. + // Instrument: counter + // Unit: {connection} + // Stability: None + KestrelRejectedConnections = attribute.Key("kestrel.rejected_connections") + + // KestrelQueuedConnections is the attribute Key conforming to the + // "kestrel.queued_connections" semantic conventions. It represents the number + // of connections that are currently queued and are waiting to start. + // Instrument: updowncounter + // Unit: {connection} + // Stability: None + KestrelQueuedConnections = attribute.Key("kestrel.queued_connections") + + // KestrelQueuedRequests is the attribute Key conforming to the + // "kestrel.queued_requests" semantic conventions. It represents the number of + // HTTP requests on multiplexed connections (HTTP/2 and HTTP/3) that are + // currently queued and are waiting to start. + // Instrument: updowncounter + // Unit: {request} + // Stability: None + KestrelQueuedRequests = attribute.Key("kestrel.queued_requests") + + // KestrelUpgradedConnections is the attribute Key conforming to the + // "kestrel.upgraded_connections" semantic conventions. It represents the + // number of connections that are currently upgraded (WebSockets). . + // Instrument: updowncounter + // Unit: {connection} + // Stability: None + KestrelUpgradedConnections = attribute.Key("kestrel.upgraded_connections") + + // KestrelTLSHandshakeDuration is the attribute Key conforming to the + // "kestrel.tls_handshake.duration" semantic conventions. It represents the + // duration of TLS handshakes on the server. + // Instrument: histogram + // Unit: s + // Stability: None + KestrelTLSHandshakeDuration = attribute.Key("kestrel.tls_handshake.duration") + + // KestrelActiveTLSHandshakes is the attribute Key conforming to the + // "kestrel.active_tls_handshakes" semantic conventions. It represents the + // number of TLS handshakes that are currently in progress on the server. + // Instrument: updowncounter + // Unit: {handshake} + // Stability: None + KestrelActiveTLSHandshakes = attribute.Key("kestrel.active_tls_handshakes") + + // SignalrServerConnectionDuration is the attribute Key conforming to the + // "signalr.server.connection.duration" semantic conventions. It represents the + // duration of connections on the server. + // Instrument: histogram + // Unit: s + // Stability: None + SignalrServerConnectionDuration = attribute.Key("signalr.server.connection.duration") + + // SignalrServerActiveConnections is the attribute Key conforming to the + // "signalr.server.active_connections" semantic conventions. It represents the + // number of connections that are currently active on the server. + // Instrument: updowncounter + // Unit: {connection} + // Stability: None + SignalrServerActiveConnections = attribute.Key("signalr.server.active_connections") + + // FaaSInvokeDuration is the attribute Key conforming to the + // "faas.invoke_duration" semantic conventions. It represents the measures the + // duration of the function's logic execution + // Instrument: histogram + // Unit: s + // Stability: None + FaaSInvokeDuration = attribute.Key("faas.invoke_duration") + + // FaaSInitDuration is the attribute Key conforming to the "faas.init_duration" + // semantic conventions. It represents the measures the duration of the + // function's initialization, such as a cold start + // Instrument: histogram + // Unit: s + // Stability: None + FaaSInitDuration = attribute.Key("faas.init_duration") + + // FaaSColdstarts is the attribute Key conforming to the "faas.coldstarts" + // semantic conventions. It represents the number of invocation cold starts + // Instrument: counter + // Unit: {coldstart} + // Stability: None + FaaSColdstarts = attribute.Key("faas.coldstarts") + + // FaaSErrors is the attribute Key conforming to the "faas.errors" semantic + // conventions. It represents the number of invocation errors + // Instrument: counter + // Unit: {error} + // Stability: None + FaaSErrors = attribute.Key("faas.errors") + + // FaaSInvocations is the attribute Key conforming to the "faas.invocations" + // semantic conventions. It represents the number of successful invocations + // Instrument: counter + // Unit: {invocation} + // Stability: None + FaaSInvocations = attribute.Key("faas.invocations") + + // FaaSTimeouts is the attribute Key conforming to the "faas.timeouts" semantic + // conventions. It represents the number of invocation timeouts + // Instrument: counter + // Unit: {timeout} + // Stability: None + FaaSTimeouts = attribute.Key("faas.timeouts") + + // FaaSMemUsage is the attribute Key conforming to the "faas.mem_usage" + // semantic conventions. It represents the distribution of max memory usage per + // invocation + // Instrument: histogram + // Unit: By + // Stability: None + FaaSMemUsage = attribute.Key("faas.mem_usage") + + // FaaSCPUUsage is the attribute Key conforming to the "faas.cpu_usage" + // semantic conventions. It represents the distribution of CPU usage per + // invocation + // Instrument: histogram + // Unit: s + // Stability: None + FaaSCPUUsage = attribute.Key("faas.cpu_usage") + + // FaaSNetIo is the attribute Key conforming to the "faas.net_io" semantic + // conventions. It represents the distribution of net I/O usage per invocation + // Instrument: histogram + // Unit: By + // Stability: None + FaaSNetIo = attribute.Key("faas.net_io") + + // HTTPServerRequestDuration is the attribute Key conforming to the + // "http.server.request.duration" semantic conventions. It represents the + // duration of HTTP server requests. + // Instrument: histogram + // Unit: s + // Stability: StabilityLevel.STABLE + HTTPServerRequestDuration = attribute.Key("http.server.request.duration") + + // HTTPServerActiveRequests is the attribute Key conforming to the + // "http.server.active_requests" semantic conventions. It represents the number + // of active HTTP server requests. + // Instrument: updowncounter + // Unit: {request} + // Stability: None + HTTPServerActiveRequests = attribute.Key("http.server.active_requests") + + // HTTPServerRequestBodySize is the attribute Key conforming to the + // "http.server.request.body.size" semantic conventions. It represents the size + // of HTTP server request bodies. + // Instrument: histogram + // Unit: By + // Stability: None + HTTPServerRequestBodySize = attribute.Key("http.server.request.body.size") + + // HTTPServerResponseBodySize is the attribute Key conforming to the + // "http.server.response.body.size" semantic conventions. It represents the + // size of HTTP server response bodies. + // Instrument: histogram + // Unit: By + // Stability: None + HTTPServerResponseBodySize = attribute.Key("http.server.response.body.size") + + // HTTPClientRequestDuration is the attribute Key conforming to the + // "http.client.request.duration" semantic conventions. It represents the + // duration of HTTP client requests. + // Instrument: histogram + // Unit: s + // Stability: StabilityLevel.STABLE + HTTPClientRequestDuration = attribute.Key("http.client.request.duration") + + // HTTPClientRequestBodySize is the attribute Key conforming to the + // "http.client.request.body.size" semantic conventions. It represents the size + // of HTTP client request bodies. + // Instrument: histogram + // Unit: By + // Stability: None + HTTPClientRequestBodySize = attribute.Key("http.client.request.body.size") + + // HTTPClientResponseBodySize is the attribute Key conforming to the + // "http.client.response.body.size" semantic conventions. It represents the + // size of HTTP client response bodies. + // Instrument: histogram + // Unit: By + // Stability: None + HTTPClientResponseBodySize = attribute.Key("http.client.response.body.size") + + // JvmMemoryInit is the attribute Key conforming to the "jvm.memory.init" + // semantic conventions. It represents the measure of initial memory requested. + // Instrument: updowncounter + // Unit: By + // Stability: None + JvmMemoryInit = attribute.Key("jvm.memory.init") + + // JvmSystemCPUUtilization is the attribute Key conforming to the + // "jvm.system.cpu.utilization" semantic conventions. It represents the recent + // CPU utilization for the whole system as reported by the JVM. + // Instrument: gauge + // Unit: 1 + // Stability: None + JvmSystemCPUUtilization = attribute.Key("jvm.system.cpu.utilization") + + // JvmSystemCPULoad1m is the attribute Key conforming to the + // "jvm.system.cpu.load_1m" semantic conventions. It represents the average CPU + // load of the whole system for the last minute as reported by the JVM. + // Instrument: gauge + // Unit: {run_queue_item} + // Stability: None + JvmSystemCPULoad1m = attribute.Key("jvm.system.cpu.load_1m") + + // JvmBufferMemoryUsage is the attribute Key conforming to the + // "jvm.buffer.memory.usage" semantic conventions. It represents the measure of + // memory used by buffers. + // Instrument: updowncounter + // Unit: By + // Stability: None + JvmBufferMemoryUsage = attribute.Key("jvm.buffer.memory.usage") + + // JvmBufferMemoryLimit is the attribute Key conforming to the + // "jvm.buffer.memory.limit" semantic conventions. It represents the measure of + // total memory capacity of buffers. + // Instrument: updowncounter + // Unit: By + // Stability: None + JvmBufferMemoryLimit = attribute.Key("jvm.buffer.memory.limit") + + // JvmBufferCount is the attribute Key conforming to the "jvm.buffer.count" + // semantic conventions. It represents the number of buffers in the pool. + // Instrument: updowncounter + // Unit: {buffer} + // Stability: None + JvmBufferCount = attribute.Key("jvm.buffer.count") + + // JvmMemoryUsed is the attribute Key conforming to the "jvm.memory.used" + // semantic conventions. It represents the measure of memory used. + // Instrument: updowncounter + // Unit: By + // Stability: StabilityLevel.STABLE + JvmMemoryUsed = attribute.Key("jvm.memory.used") + + // JvmMemoryCommitted is the attribute Key conforming to the + // "jvm.memory.committed" semantic conventions. It represents the measure of + // memory committed. + // Instrument: updowncounter + // Unit: By + // Stability: StabilityLevel.STABLE + JvmMemoryCommitted = attribute.Key("jvm.memory.committed") + + // JvmMemoryLimit is the attribute Key conforming to the "jvm.memory.limit" + // semantic conventions. It represents the measure of max obtainable memory. + // Instrument: updowncounter + // Unit: By + // Stability: StabilityLevel.STABLE + JvmMemoryLimit = attribute.Key("jvm.memory.limit") + + // JvmMemoryUsedAfterLastGc is the attribute Key conforming to the + // "jvm.memory.used_after_last_gc" semantic conventions. It represents the + // measure of memory used, as measured after the most recent garbage collection + // event on this pool. + // Instrument: updowncounter + // Unit: By + // Stability: StabilityLevel.STABLE + JvmMemoryUsedAfterLastGc = attribute.Key("jvm.memory.used_after_last_gc") + + // JvmGcDuration is the attribute Key conforming to the "jvm.gc.duration" + // semantic conventions. It represents the duration of JVM garbage collection + // actions. + // Instrument: histogram + // Unit: s + // Stability: StabilityLevel.STABLE + JvmGcDuration = attribute.Key("jvm.gc.duration") + + // JvmThreadCount is the attribute Key conforming to the "jvm.thread.count" + // semantic conventions. It represents the number of executing platform + // threads. + // Instrument: updowncounter + // Unit: {thread} + // Stability: StabilityLevel.STABLE + JvmThreadCount = attribute.Key("jvm.thread.count") + + // JvmClassLoaded is the attribute Key conforming to the "jvm.class.loaded" + // semantic conventions. It represents the number of classes loaded since JVM + // start. + // Instrument: counter + // Unit: {class} + // Stability: StabilityLevel.STABLE + JvmClassLoaded = attribute.Key("jvm.class.loaded") + + // JvmClassUnloaded is the attribute Key conforming to the "jvm.class.unloaded" + // semantic conventions. It represents the number of classes unloaded since JVM + // start. + // Instrument: counter + // Unit: {class} + // Stability: StabilityLevel.STABLE + JvmClassUnloaded = attribute.Key("jvm.class.unloaded") + + // JvmClassCount is the attribute Key conforming to the "jvm.class.count" + // semantic conventions. It represents the number of classes currently loaded. + // Instrument: updowncounter + // Unit: {class} + // Stability: StabilityLevel.STABLE + JvmClassCount = attribute.Key("jvm.class.count") + + // JvmCPUCount is the attribute Key conforming to the "jvm.cpu.count" semantic + // conventions. It represents the number of processors available to the Java + // virtual machine. + // Instrument: updowncounter + // Unit: {cpu} + // Stability: StabilityLevel.STABLE + JvmCPUCount = attribute.Key("jvm.cpu.count") + + // JvmCPUTime is the attribute Key conforming to the "jvm.cpu.time" semantic + // conventions. It represents the cPU time used by the process as reported by + // the JVM. + // Instrument: counter + // Unit: s + // Stability: StabilityLevel.STABLE + JvmCPUTime = attribute.Key("jvm.cpu.time") + + // JvmCPURecentUtilization is the attribute Key conforming to the + // "jvm.cpu.recent_utilization" semantic conventions. It represents the recent + // CPU utilization for the process as reported by the JVM. + // Instrument: gauge + // Unit: 1 + // Stability: StabilityLevel.STABLE + JvmCPURecentUtilization = attribute.Key("jvm.cpu.recent_utilization") + + // MessagingPublishDuration is the attribute Key conforming to the + // "messaging.publish.duration" semantic conventions. It represents the + // measures the duration of publish operation. + // Instrument: histogram + // Unit: s + // Stability: None + MessagingPublishDuration = attribute.Key("messaging.publish.duration") + + // MessagingReceiveDuration is the attribute Key conforming to the + // "messaging.receive.duration" semantic conventions. It represents the + // measures the duration of receive operation. + // Instrument: histogram + // Unit: s + // Stability: None + MessagingReceiveDuration = attribute.Key("messaging.receive.duration") + + // MessagingDeliverDuration is the attribute Key conforming to the + // "messaging.deliver.duration" semantic conventions. It represents the + // measures the duration of deliver operation. + // Instrument: histogram + // Unit: s + // Stability: None + MessagingDeliverDuration = attribute.Key("messaging.deliver.duration") + + // MessagingPublishMessages is the attribute Key conforming to the + // "messaging.publish.messages" semantic conventions. It represents the + // measures the number of published messages. + // Instrument: counter + // Unit: {message} + // Stability: None + MessagingPublishMessages = attribute.Key("messaging.publish.messages") + + // MessagingReceiveMessages is the attribute Key conforming to the + // "messaging.receive.messages" semantic conventions. It represents the + // measures the number of received messages. + // Instrument: counter + // Unit: {message} + // Stability: None + MessagingReceiveMessages = attribute.Key("messaging.receive.messages") + + // MessagingDeliverMessages is the attribute Key conforming to the + // "messaging.deliver.messages" semantic conventions. It represents the + // measures the number of delivered messages. + // Instrument: counter + // Unit: {message} + // Stability: None + MessagingDeliverMessages = attribute.Key("messaging.deliver.messages") + + // RPCServerDuration is the attribute Key conforming to the + // "rpc.server.duration" semantic conventions. It represents the measures the + // duration of inbound RPC. + // Instrument: histogram + // Unit: ms + // Stability: None + RPCServerDuration = attribute.Key("rpc.server.duration") + + // RPCServerRequestSize is the attribute Key conforming to the + // "rpc.server.request.size" semantic conventions. It represents the measures + // the size of RPC request messages (uncompressed). + // Instrument: histogram + // Unit: By + // Stability: None + RPCServerRequestSize = attribute.Key("rpc.server.request.size") + + // RPCServerResponseSize is the attribute Key conforming to the + // "rpc.server.response.size" semantic conventions. It represents the measures + // the size of RPC response messages (uncompressed). + // Instrument: histogram + // Unit: By + // Stability: None + RPCServerResponseSize = attribute.Key("rpc.server.response.size") + + // RPCServerRequestsPerRPC is the attribute Key conforming to the + // "rpc.server.requests_per_rpc" semantic conventions. It represents the + // measures the number of messages received per RPC. + // Instrument: histogram + // Unit: {count} + // Stability: None + RPCServerRequestsPerRPC = attribute.Key("rpc.server.requests_per_rpc") + + // RPCServerResponsesPerRPC is the attribute Key conforming to the + // "rpc.server.responses_per_rpc" semantic conventions. It represents the + // measures the number of messages sent per RPC. + // Instrument: histogram + // Unit: {count} + // Stability: None + RPCServerResponsesPerRPC = attribute.Key("rpc.server.responses_per_rpc") + + // RPCClientDuration is the attribute Key conforming to the + // "rpc.client.duration" semantic conventions. It represents the measures the + // duration of outbound RPC. + // Instrument: histogram + // Unit: ms + // Stability: None + RPCClientDuration = attribute.Key("rpc.client.duration") + + // RPCClientRequestSize is the attribute Key conforming to the + // "rpc.client.request.size" semantic conventions. It represents the measures + // the size of RPC request messages (uncompressed). + // Instrument: histogram + // Unit: By + // Stability: None + RPCClientRequestSize = attribute.Key("rpc.client.request.size") + + // RPCClientResponseSize is the attribute Key conforming to the + // "rpc.client.response.size" semantic conventions. It represents the measures + // the size of RPC response messages (uncompressed). + // Instrument: histogram + // Unit: By + // Stability: None + RPCClientResponseSize = attribute.Key("rpc.client.response.size") + + // RPCClientRequestsPerRPC is the attribute Key conforming to the + // "rpc.client.requests_per_rpc" semantic conventions. It represents the + // measures the number of messages received per RPC. + // Instrument: histogram + // Unit: {count} + // Stability: None + RPCClientRequestsPerRPC = attribute.Key("rpc.client.requests_per_rpc") + + // RPCClientResponsesPerRPC is the attribute Key conforming to the + // "rpc.client.responses_per_rpc" semantic conventions. It represents the + // measures the number of messages sent per RPC. + // Instrument: histogram + // Unit: {count} + // Stability: None + RPCClientResponsesPerRPC = attribute.Key("rpc.client.responses_per_rpc") + + // SystemCPUTime is the attribute Key conforming to the "system.cpu.time" + // semantic conventions. It represents the seconds each logical CPU spent on + // each mode + // Instrument: counter + // Unit: s + // Stability: None + SystemCPUTime = attribute.Key("system.cpu.time") + + // SystemCPUUtilization is the attribute Key conforming to the + // "system.cpu.utilization" semantic conventions. It represents the difference + // in system.cpu.time since the last measurement, divided by the elapsed time + // and number of logical CPUs + // Instrument: gauge + // Unit: 1 + // Stability: None + SystemCPUUtilization = attribute.Key("system.cpu.utilization") + + // SystemCPUFrequency is the attribute Key conforming to the + // "system.cpu.frequency" semantic conventions. It represents the reports the + // current frequency of the CPU in Hz + // Instrument: gauge + // Unit: {Hz} + // Stability: None + SystemCPUFrequency = attribute.Key("system.cpu.frequency") + + // SystemCPUPhysicalCount is the attribute Key conforming to the + // "system.cpu.physical.count" semantic conventions. It represents the reports + // the number of actual physical processor cores on the hardware + // Instrument: updowncounter + // Unit: {cpu} + // Stability: None + SystemCPUPhysicalCount = attribute.Key("system.cpu.physical.count") + + // SystemCPULogicalCount is the attribute Key conforming to the + // "system.cpu.logical.count" semantic conventions. It represents the reports + // the number of logical (virtual) processor cores created by the operating + // system to manage multitasking + // Instrument: updowncounter + // Unit: {cpu} + // Stability: None + SystemCPULogicalCount = attribute.Key("system.cpu.logical.count") + + // SystemMemoryUsage is the attribute Key conforming to the + // "system.memory.usage" semantic conventions. It represents the reports memory + // in use by state. + // Instrument: updowncounter + // Unit: By + // Stability: None + SystemMemoryUsage = attribute.Key("system.memory.usage") + + // SystemMemoryLimit is the attribute Key conforming to the + // "system.memory.limit" semantic conventions. It represents the total memory + // available in the system. + // Instrument: updowncounter + // Unit: By + // Stability: None + SystemMemoryLimit = attribute.Key("system.memory.limit") + + // SystemMemoryUtilization is the attribute Key conforming to the + // "system.memory.utilization" semantic conventions. It represents the + // Instrument: gauge + // Unit: 1 + // Stability: None + SystemMemoryUtilization = attribute.Key("system.memory.utilization") + + // SystemPagingUsage is the attribute Key conforming to the + // "system.paging.usage" semantic conventions. It represents the unix swap or + // windows pagefile usage + // Instrument: updowncounter + // Unit: By + // Stability: None + SystemPagingUsage = attribute.Key("system.paging.usage") + + // SystemPagingUtilization is the attribute Key conforming to the + // "system.paging.utilization" semantic conventions. It represents the + // Instrument: gauge + // Unit: 1 + // Stability: None + SystemPagingUtilization = attribute.Key("system.paging.utilization") + + // SystemPagingFaults is the attribute Key conforming to the + // "system.paging.faults" semantic conventions. It represents the + // Instrument: counter + // Unit: {fault} + // Stability: None + SystemPagingFaults = attribute.Key("system.paging.faults") + + // SystemPagingOperations is the attribute Key conforming to the + // "system.paging.operations" semantic conventions. It represents the + // Instrument: counter + // Unit: {operation} + // Stability: None + SystemPagingOperations = attribute.Key("system.paging.operations") + + // SystemDiskIo is the attribute Key conforming to the "system.disk.io" + // semantic conventions. It represents the + // Instrument: counter + // Unit: By + // Stability: None + SystemDiskIo = attribute.Key("system.disk.io") + + // SystemDiskOperations is the attribute Key conforming to the + // "system.disk.operations" semantic conventions. It represents the + // Instrument: counter + // Unit: {operation} + // Stability: None + SystemDiskOperations = attribute.Key("system.disk.operations") + + // SystemDiskIoTime is the attribute Key conforming to the + // "system.disk.io_time" semantic conventions. It represents the time disk + // spent activated + // Instrument: counter + // Unit: s + // Stability: None + SystemDiskIoTime = attribute.Key("system.disk.io_time") + + // SystemDiskOperationTime is the attribute Key conforming to the + // "system.disk.operation_time" semantic conventions. It represents the sum of + // the time each operation took to complete + // Instrument: counter + // Unit: s + // Stability: None + SystemDiskOperationTime = attribute.Key("system.disk.operation_time") + + // SystemDiskMerged is the attribute Key conforming to the "system.disk.merged" + // semantic conventions. It represents the + // Instrument: counter + // Unit: {operation} + // Stability: None + SystemDiskMerged = attribute.Key("system.disk.merged") + + // SystemFilesystemUsage is the attribute Key conforming to the + // "system.filesystem.usage" semantic conventions. It represents the + // Instrument: updowncounter + // Unit: By + // Stability: None + SystemFilesystemUsage = attribute.Key("system.filesystem.usage") + + // SystemFilesystemUtilization is the attribute Key conforming to the + // "system.filesystem.utilization" semantic conventions. It represents the + // Instrument: gauge + // Unit: 1 + // Stability: None + SystemFilesystemUtilization = attribute.Key("system.filesystem.utilization") + + // SystemNetworkDropped is the attribute Key conforming to the + // "system.network.dropped" semantic conventions. It represents the count of + // packets that are dropped or discarded even though there was no error + // Instrument: counter + // Unit: {packet} + // Stability: None + SystemNetworkDropped = attribute.Key("system.network.dropped") + + // SystemNetworkPackets is the attribute Key conforming to the + // "system.network.packets" semantic conventions. It represents the + // Instrument: counter + // Unit: {packet} + // Stability: None + SystemNetworkPackets = attribute.Key("system.network.packets") + + // SystemNetworkErrors is the attribute Key conforming to the + // "system.network.errors" semantic conventions. It represents the count of + // network errors detected + // Instrument: counter + // Unit: {error} + // Stability: None + SystemNetworkErrors = attribute.Key("system.network.errors") + + // SystemNetworkIo is the attribute Key conforming to the "system.network.io" + // semantic conventions. It represents the + // Instrument: counter + // Unit: By + // Stability: None + SystemNetworkIo = attribute.Key("system.network.io") + + // SystemNetworkConnections is the attribute Key conforming to the + // "system.network.connections" semantic conventions. It represents the + // Instrument: updowncounter + // Unit: {connection} + // Stability: None + SystemNetworkConnections = attribute.Key("system.network.connections") + + // SystemProcessesCount is the attribute Key conforming to the + // "system.processes.count" semantic conventions. It represents the total + // number of processes in each state + // Instrument: updowncounter + // Unit: {process} + // Stability: None + SystemProcessesCount = attribute.Key("system.processes.count") + + // SystemProcessesCreated is the attribute Key conforming to the + // "system.processes.created" semantic conventions. It represents the total + // number of processes created over uptime of the host + // Instrument: counter + // Unit: {process} + // Stability: None + SystemProcessesCreated = attribute.Key("system.processes.created") + + // SystemLinuxMemoryAvailable is the attribute Key conforming to the + // "system.linux.memory.available" semantic conventions. It represents an + // estimate of how much memory is available for starting new applications, + // without causing swapping + // Instrument: updowncounter + // Unit: By + // Stability: None + SystemLinuxMemoryAvailable = attribute.Key("system.linux.memory.available") +) From bd60b70c32d3af917c624254540b560ca9301116 Mon Sep 17 00:00:00 2001 From: Ben Carr Date: Tue, 6 Feb 2024 15:20:22 -0800 Subject: [PATCH 02/11] Updates generated comments with more explicit nomenclature; Adds Unit and Description consts for each metric; append 'Name' to metric const instead of 'Key' --- semconv/metric_template.j2 | 8 +- semconv/v1.24.0/metric.go | 744 +++++++++++++++++++++++-------------- 2 files changed, 480 insertions(+), 272 deletions(-) diff --git a/semconv/metric_template.j2 b/semconv/metric_template.j2 index a8ad77ff7af..4e6cf7a6eec 100644 --- a/semconv/metric_template.j2 +++ b/semconv/metric_template.j2 @@ -10,9 +10,9 @@ It represents {% if brief[:2] == "A " or brief[:3] == "An " or brief[:4] == "The {%- endmacro -%} {%- macro keydoc(metric) -%} {%- if metric.stability|string() == "StabilityLevel.DEPRECATED" -%} -{{ to_go_name(metric.metric_name) }} is the attribute Key conforming to the "{{ metric.metric_name}}" semantic conventions. +{{ to_go_name(metric.metric_name) }} is the metric conforming to the "{{ metric.metric_name}}" semantic conventions. {%- else -%} -{{ to_go_name(metric.metric_name) }} is the attribute Key conforming to the "{{ metric.metric_name}}" semantic conventions. {{ it_reps(metric.brief) }} +{{ to_go_name(metric.metric_name) }} is the metric conforming to the "{{ metric.metric_name}}" semantic conventions. {{ it_reps(metric.brief) }} {%- endif %} {%- endmacro -%} // Copyright The OpenTelemetry Authors @@ -42,7 +42,9 @@ const ( // Instrument: {{ metric.instrument }} // Unit: {{ metric.unit }} // Stability: {{ metric.stability }} - {{to_go_name(metric.metric_name)}} = attribute.Key("{{metric.metric_name}}") + {{to_go_name(metric.metric_name)}}Name = attribute.Key("{{metric.metric_name}}") + {{to_go_name(metric.metric_name)}}Unit = attribute.Key("{{metric.unit}}") + {{to_go_name(metric.metric_name)}}Description = attribute.Key("{{metric.brief}}") {%- endif %} {% endfor %} ) diff --git a/semconv/v1.24.0/metric.go b/semconv/v1.24.0/metric.go index c8591a6dcb7..1023910ee17 100644 --- a/semconv/v1.24.0/metric.go +++ b/semconv/v1.24.0/metric.go @@ -20,859 +20,1065 @@ import "go.opentelemetry.io/otel/attribute" const ( - // DBClientConnectionsUsage is the attribute Key conforming to the + // DBClientConnectionsUsage is the metric conforming to the // "db.client.connections.usage" semantic conventions. It represents the number // of connections that are currently in state described by the `state` // attribute // Instrument: updowncounter // Unit: {connection} // Stability: None - DBClientConnectionsUsage = attribute.Key("db.client.connections.usage") + DBClientConnectionsUsageName = attribute.Key("db.client.connections.usage") + DBClientConnectionsUsageUnit = attribute.Key("{connection}") + DBClientConnectionsUsageDescription = attribute.Key("The number of connections that are currently in state described by the `state` attribute") - // DBClientConnectionsIdleMax is the attribute Key conforming to the + // DBClientConnectionsIdleMax is the metric conforming to the // "db.client.connections.idle.max" semantic conventions. It represents the // maximum number of idle open connections allowed // Instrument: updowncounter // Unit: {connection} // Stability: None - DBClientConnectionsIdleMax = attribute.Key("db.client.connections.idle.max") + DBClientConnectionsIdleMaxName = attribute.Key("db.client.connections.idle.max") + DBClientConnectionsIdleMaxUnit = attribute.Key("{connection}") + DBClientConnectionsIdleMaxDescription = attribute.Key("The maximum number of idle open connections allowed") - // DBClientConnectionsIdleMin is the attribute Key conforming to the + // DBClientConnectionsIdleMin is the metric conforming to the // "db.client.connections.idle.min" semantic conventions. It represents the // minimum number of idle open connections allowed // Instrument: updowncounter // Unit: {connection} // Stability: None - DBClientConnectionsIdleMin = attribute.Key("db.client.connections.idle.min") + DBClientConnectionsIdleMinName = attribute.Key("db.client.connections.idle.min") + DBClientConnectionsIdleMinUnit = attribute.Key("{connection}") + DBClientConnectionsIdleMinDescription = attribute.Key("The minimum number of idle open connections allowed") - // DBClientConnectionsMax is the attribute Key conforming to the + // DBClientConnectionsMax is the metric conforming to the // "db.client.connections.max" semantic conventions. It represents the maximum // number of open connections allowed // Instrument: updowncounter // Unit: {connection} // Stability: None - DBClientConnectionsMax = attribute.Key("db.client.connections.max") + DBClientConnectionsMaxName = attribute.Key("db.client.connections.max") + DBClientConnectionsMaxUnit = attribute.Key("{connection}") + DBClientConnectionsMaxDescription = attribute.Key("The maximum number of open connections allowed") - // DBClientConnectionsPendingRequests is the attribute Key conforming to the + // DBClientConnectionsPendingRequests is the metric conforming to the // "db.client.connections.pending_requests" semantic conventions. It represents // the number of pending requests for an open connection, cumulative for the // entire pool // Instrument: updowncounter // Unit: {request} // Stability: None - DBClientConnectionsPendingRequests = attribute.Key("db.client.connections.pending_requests") + DBClientConnectionsPendingRequestsName = attribute.Key("db.client.connections.pending_requests") + DBClientConnectionsPendingRequestsUnit = attribute.Key("{request}") + DBClientConnectionsPendingRequestsDescription = attribute.Key("The number of pending requests for an open connection, cumulative for the entire pool") - // DBClientConnectionsTimeouts is the attribute Key conforming to the + // DBClientConnectionsTimeouts is the metric conforming to the // "db.client.connections.timeouts" semantic conventions. It represents the // number of connection timeouts that have occurred trying to obtain a // connection from the pool // Instrument: counter // Unit: {timeout} // Stability: None - DBClientConnectionsTimeouts = attribute.Key("db.client.connections.timeouts") + DBClientConnectionsTimeoutsName = attribute.Key("db.client.connections.timeouts") + DBClientConnectionsTimeoutsUnit = attribute.Key("{timeout}") + DBClientConnectionsTimeoutsDescription = attribute.Key("The number of connection timeouts that have occurred trying to obtain a connection from the pool") - // DBClientConnectionsCreateTime is the attribute Key conforming to the + // DBClientConnectionsCreateTime is the metric conforming to the // "db.client.connections.create_time" semantic conventions. It represents the // time it took to create a new connection // Instrument: histogram // Unit: ms // Stability: None - DBClientConnectionsCreateTime = attribute.Key("db.client.connections.create_time") + DBClientConnectionsCreateTimeName = attribute.Key("db.client.connections.create_time") + DBClientConnectionsCreateTimeUnit = attribute.Key("ms") + DBClientConnectionsCreateTimeDescription = attribute.Key("The time it took to create a new connection") - // DBClientConnectionsWaitTime is the attribute Key conforming to the + // DBClientConnectionsWaitTime is the metric conforming to the // "db.client.connections.wait_time" semantic conventions. It represents the // time it took to obtain an open connection from the pool // Instrument: histogram // Unit: ms // Stability: None - DBClientConnectionsWaitTime = attribute.Key("db.client.connections.wait_time") + DBClientConnectionsWaitTimeName = attribute.Key("db.client.connections.wait_time") + DBClientConnectionsWaitTimeUnit = attribute.Key("ms") + DBClientConnectionsWaitTimeDescription = attribute.Key("The time it took to obtain an open connection from the pool") - // DBClientConnectionsUseTime is the attribute Key conforming to the + // DBClientConnectionsUseTime is the metric conforming to the // "db.client.connections.use_time" semantic conventions. It represents the // time between borrowing a connection and returning it to the pool // Instrument: histogram // Unit: ms // Stability: None - DBClientConnectionsUseTime = attribute.Key("db.client.connections.use_time") + DBClientConnectionsUseTimeName = attribute.Key("db.client.connections.use_time") + DBClientConnectionsUseTimeUnit = attribute.Key("ms") + DBClientConnectionsUseTimeDescription = attribute.Key("The time between borrowing a connection and returning it to the pool") - // AspnetcoreRoutingMatchAttempts is the attribute Key conforming to the + // AspnetcoreRoutingMatchAttempts is the metric conforming to the // "aspnetcore.routing.match_attempts" semantic conventions. It represents the // number of requests that were attempted to be matched to an endpoint. // Instrument: counter // Unit: {match_attempt} // Stability: None - AspnetcoreRoutingMatchAttempts = attribute.Key("aspnetcore.routing.match_attempts") + AspnetcoreRoutingMatchAttemptsName = attribute.Key("aspnetcore.routing.match_attempts") + AspnetcoreRoutingMatchAttemptsUnit = attribute.Key("{match_attempt}") + AspnetcoreRoutingMatchAttemptsDescription = attribute.Key("Number of requests that were attempted to be matched to an endpoint.") - // AspnetcoreDiagnosticsExceptions is the attribute Key conforming to the + // AspnetcoreDiagnosticsExceptions is the metric conforming to the // "aspnetcore.diagnostics.exceptions" semantic conventions. It represents the // number of exceptions caught by exception handling middleware. // Instrument: counter // Unit: {exception} // Stability: None - AspnetcoreDiagnosticsExceptions = attribute.Key("aspnetcore.diagnostics.exceptions") + AspnetcoreDiagnosticsExceptionsName = attribute.Key("aspnetcore.diagnostics.exceptions") + AspnetcoreDiagnosticsExceptionsUnit = attribute.Key("{exception}") + AspnetcoreDiagnosticsExceptionsDescription = attribute.Key("Number of exceptions caught by exception handling middleware.") - // AspnetcoreRateLimitingActiveRequestLeases is the attribute Key conforming to - // the "aspnetcore.rate_limiting.active_request_leases" semantic conventions. - // It represents the number of requests that are currently active on the server + // AspnetcoreRateLimitingActiveRequestLeases is the metric conforming to the + // "aspnetcore.rate_limiting.active_request_leases" semantic conventions. It + // represents the number of requests that are currently active on the server // that hold a rate limiting lease. // Instrument: updowncounter // Unit: {request} // Stability: None - AspnetcoreRateLimitingActiveRequestLeases = attribute.Key("aspnetcore.rate_limiting.active_request_leases") + AspnetcoreRateLimitingActiveRequestLeasesName = attribute.Key("aspnetcore.rate_limiting.active_request_leases") + AspnetcoreRateLimitingActiveRequestLeasesUnit = attribute.Key("{request}") + AspnetcoreRateLimitingActiveRequestLeasesDescription = attribute.Key("Number of requests that are currently active on the server that hold a rate limiting lease.") - // AspnetcoreRateLimitingRequestLeaseDuration is the attribute Key conforming - // to the "aspnetcore.rate_limiting.request_lease.duration" semantic - // conventions. It represents the duration of rate limiting lease held by - // requests on the server. + // AspnetcoreRateLimitingRequestLeaseDuration is the metric conforming to the + // "aspnetcore.rate_limiting.request_lease.duration" semantic conventions. It + // represents the duration of rate limiting lease held by requests on the + // server. // Instrument: histogram // Unit: s // Stability: None - AspnetcoreRateLimitingRequestLeaseDuration = attribute.Key("aspnetcore.rate_limiting.request_lease.duration") + AspnetcoreRateLimitingRequestLeaseDurationName = attribute.Key("aspnetcore.rate_limiting.request_lease.duration") + AspnetcoreRateLimitingRequestLeaseDurationUnit = attribute.Key("s") + AspnetcoreRateLimitingRequestLeaseDurationDescription = attribute.Key("The duration of rate limiting lease held by requests on the server.") - // AspnetcoreRateLimitingRequestTimeInQueue is the attribute Key conforming to - // the "aspnetcore.rate_limiting.request.time_in_queue" semantic conventions. - // It represents the time the request spent in a queue waiting to acquire a - // rate limiting lease. + // AspnetcoreRateLimitingRequestTimeInQueue is the metric conforming to the + // "aspnetcore.rate_limiting.request.time_in_queue" semantic conventions. It + // represents the time the request spent in a queue waiting to acquire a rate + // limiting lease. // Instrument: histogram // Unit: s // Stability: None - AspnetcoreRateLimitingRequestTimeInQueue = attribute.Key("aspnetcore.rate_limiting.request.time_in_queue") + AspnetcoreRateLimitingRequestTimeInQueueName = attribute.Key("aspnetcore.rate_limiting.request.time_in_queue") + AspnetcoreRateLimitingRequestTimeInQueueUnit = attribute.Key("s") + AspnetcoreRateLimitingRequestTimeInQueueDescription = attribute.Key("The time the request spent in a queue waiting to acquire a rate limiting lease.") - // AspnetcoreRateLimitingQueuedRequests is the attribute Key conforming to the + // AspnetcoreRateLimitingQueuedRequests is the metric conforming to the // "aspnetcore.rate_limiting.queued_requests" semantic conventions. It // represents the number of requests that are currently queued, waiting to // acquire a rate limiting lease. // Instrument: updowncounter // Unit: {request} // Stability: None - AspnetcoreRateLimitingQueuedRequests = attribute.Key("aspnetcore.rate_limiting.queued_requests") + AspnetcoreRateLimitingQueuedRequestsName = attribute.Key("aspnetcore.rate_limiting.queued_requests") + AspnetcoreRateLimitingQueuedRequestsUnit = attribute.Key("{request}") + AspnetcoreRateLimitingQueuedRequestsDescription = attribute.Key("Number of requests that are currently queued, waiting to acquire a rate limiting lease.") - // AspnetcoreRateLimitingRequests is the attribute Key conforming to the + // AspnetcoreRateLimitingRequests is the metric conforming to the // "aspnetcore.rate_limiting.requests" semantic conventions. It represents the // number of requests that tried to acquire a rate limiting lease. // Instrument: counter // Unit: {request} // Stability: None - AspnetcoreRateLimitingRequests = attribute.Key("aspnetcore.rate_limiting.requests") + AspnetcoreRateLimitingRequestsName = attribute.Key("aspnetcore.rate_limiting.requests") + AspnetcoreRateLimitingRequestsUnit = attribute.Key("{request}") + AspnetcoreRateLimitingRequestsDescription = attribute.Key("Number of requests that tried to acquire a rate limiting lease.") - // DNSLookupDuration is the attribute Key conforming to the - // "dns.lookup.duration" semantic conventions. It represents the measures the - // time taken to perform a DNS lookup. + // DNSLookupDuration is the metric conforming to the "dns.lookup.duration" + // semantic conventions. It represents the measures the time taken to perform a + // DNS lookup. // Instrument: histogram // Unit: s // Stability: None - DNSLookupDuration = attribute.Key("dns.lookup.duration") + DNSLookupDurationName = attribute.Key("dns.lookup.duration") + DNSLookupDurationUnit = attribute.Key("s") + DNSLookupDurationDescription = attribute.Key("Measures the time taken to perform a DNS lookup.") - // HTTPClientOpenConnections is the attribute Key conforming to the + // HTTPClientOpenConnections is the metric conforming to the // "http.client.open_connections" semantic conventions. It represents the // number of outbound HTTP connections that are currently active or idle on the // client. // Instrument: updowncounter // Unit: {connection} // Stability: None - HTTPClientOpenConnections = attribute.Key("http.client.open_connections") + HTTPClientOpenConnectionsName = attribute.Key("http.client.open_connections") + HTTPClientOpenConnectionsUnit = attribute.Key("{connection}") + HTTPClientOpenConnectionsDescription = attribute.Key("Number of outbound HTTP connections that are currently active or idle on the client.") - // HTTPClientConnectionDuration is the attribute Key conforming to the + // HTTPClientConnectionDuration is the metric conforming to the // "http.client.connection.duration" semantic conventions. It represents the // duration of the successfully established outbound HTTP connections. // Instrument: histogram // Unit: s // Stability: None - HTTPClientConnectionDuration = attribute.Key("http.client.connection.duration") + HTTPClientConnectionDurationName = attribute.Key("http.client.connection.duration") + HTTPClientConnectionDurationUnit = attribute.Key("s") + HTTPClientConnectionDurationDescription = attribute.Key("The duration of the successfully established outbound HTTP connections.") - // HTTPClientActiveRequests is the attribute Key conforming to the + // HTTPClientActiveRequests is the metric conforming to the // "http.client.active_requests" semantic conventions. It represents the number // of active HTTP requests. // Instrument: updowncounter // Unit: {request} // Stability: None - HTTPClientActiveRequests = attribute.Key("http.client.active_requests") + HTTPClientActiveRequestsName = attribute.Key("http.client.active_requests") + HTTPClientActiveRequestsUnit = attribute.Key("{request}") + HTTPClientActiveRequestsDescription = attribute.Key("Number of active HTTP requests.") - // HTTPClientRequestTimeInQueue is the attribute Key conforming to the + // HTTPClientRequestTimeInQueue is the metric conforming to the // "http.client.request.time_in_queue" semantic conventions. It represents the // amount of time requests spent on a queue waiting for an available // connection. // Instrument: histogram // Unit: s // Stability: None - HTTPClientRequestTimeInQueue = attribute.Key("http.client.request.time_in_queue") + HTTPClientRequestTimeInQueueName = attribute.Key("http.client.request.time_in_queue") + HTTPClientRequestTimeInQueueUnit = attribute.Key("s") + HTTPClientRequestTimeInQueueDescription = attribute.Key("The amount of time requests spent on a queue waiting for an available connection.") - // KestrelActiveConnections is the attribute Key conforming to the + // KestrelActiveConnections is the metric conforming to the // "kestrel.active_connections" semantic conventions. It represents the number // of connections that are currently active on the server. // Instrument: updowncounter // Unit: {connection} // Stability: None - KestrelActiveConnections = attribute.Key("kestrel.active_connections") + KestrelActiveConnectionsName = attribute.Key("kestrel.active_connections") + KestrelActiveConnectionsUnit = attribute.Key("{connection}") + KestrelActiveConnectionsDescription = attribute.Key("Number of connections that are currently active on the server.") - // KestrelConnectionDuration is the attribute Key conforming to the + // KestrelConnectionDuration is the metric conforming to the // "kestrel.connection.duration" semantic conventions. It represents the // duration of connections on the server. // Instrument: histogram // Unit: s // Stability: None - KestrelConnectionDuration = attribute.Key("kestrel.connection.duration") + KestrelConnectionDurationName = attribute.Key("kestrel.connection.duration") + KestrelConnectionDurationUnit = attribute.Key("s") + KestrelConnectionDurationDescription = attribute.Key("The duration of connections on the server.") - // KestrelRejectedConnections is the attribute Key conforming to the + // KestrelRejectedConnections is the metric conforming to the // "kestrel.rejected_connections" semantic conventions. It represents the // number of connections rejected by the server. // Instrument: counter // Unit: {connection} // Stability: None - KestrelRejectedConnections = attribute.Key("kestrel.rejected_connections") + KestrelRejectedConnectionsName = attribute.Key("kestrel.rejected_connections") + KestrelRejectedConnectionsUnit = attribute.Key("{connection}") + KestrelRejectedConnectionsDescription = attribute.Key("Number of connections rejected by the server.") - // KestrelQueuedConnections is the attribute Key conforming to the + // KestrelQueuedConnections is the metric conforming to the // "kestrel.queued_connections" semantic conventions. It represents the number // of connections that are currently queued and are waiting to start. // Instrument: updowncounter // Unit: {connection} // Stability: None - KestrelQueuedConnections = attribute.Key("kestrel.queued_connections") + KestrelQueuedConnectionsName = attribute.Key("kestrel.queued_connections") + KestrelQueuedConnectionsUnit = attribute.Key("{connection}") + KestrelQueuedConnectionsDescription = attribute.Key("Number of connections that are currently queued and are waiting to start.") - // KestrelQueuedRequests is the attribute Key conforming to the + // KestrelQueuedRequests is the metric conforming to the // "kestrel.queued_requests" semantic conventions. It represents the number of // HTTP requests on multiplexed connections (HTTP/2 and HTTP/3) that are // currently queued and are waiting to start. // Instrument: updowncounter // Unit: {request} // Stability: None - KestrelQueuedRequests = attribute.Key("kestrel.queued_requests") + KestrelQueuedRequestsName = attribute.Key("kestrel.queued_requests") + KestrelQueuedRequestsUnit = attribute.Key("{request}") + KestrelQueuedRequestsDescription = attribute.Key("Number of HTTP requests on multiplexed connections (HTTP/2 and HTTP/3) that are currently queued and are waiting to start.") - // KestrelUpgradedConnections is the attribute Key conforming to the + // KestrelUpgradedConnections is the metric conforming to the // "kestrel.upgraded_connections" semantic conventions. It represents the // number of connections that are currently upgraded (WebSockets). . // Instrument: updowncounter // Unit: {connection} // Stability: None - KestrelUpgradedConnections = attribute.Key("kestrel.upgraded_connections") + KestrelUpgradedConnectionsName = attribute.Key("kestrel.upgraded_connections") + KestrelUpgradedConnectionsUnit = attribute.Key("{connection}") + KestrelUpgradedConnectionsDescription = attribute.Key("Number of connections that are currently upgraded (WebSockets). .") - // KestrelTLSHandshakeDuration is the attribute Key conforming to the + // KestrelTLSHandshakeDuration is the metric conforming to the // "kestrel.tls_handshake.duration" semantic conventions. It represents the // duration of TLS handshakes on the server. // Instrument: histogram // Unit: s // Stability: None - KestrelTLSHandshakeDuration = attribute.Key("kestrel.tls_handshake.duration") + KestrelTLSHandshakeDurationName = attribute.Key("kestrel.tls_handshake.duration") + KestrelTLSHandshakeDurationUnit = attribute.Key("s") + KestrelTLSHandshakeDurationDescription = attribute.Key("The duration of TLS handshakes on the server.") - // KestrelActiveTLSHandshakes is the attribute Key conforming to the + // KestrelActiveTLSHandshakes is the metric conforming to the // "kestrel.active_tls_handshakes" semantic conventions. It represents the // number of TLS handshakes that are currently in progress on the server. // Instrument: updowncounter // Unit: {handshake} // Stability: None - KestrelActiveTLSHandshakes = attribute.Key("kestrel.active_tls_handshakes") + KestrelActiveTLSHandshakesName = attribute.Key("kestrel.active_tls_handshakes") + KestrelActiveTLSHandshakesUnit = attribute.Key("{handshake}") + KestrelActiveTLSHandshakesDescription = attribute.Key("Number of TLS handshakes that are currently in progress on the server.") - // SignalrServerConnectionDuration is the attribute Key conforming to the + // SignalrServerConnectionDuration is the metric conforming to the // "signalr.server.connection.duration" semantic conventions. It represents the // duration of connections on the server. // Instrument: histogram // Unit: s // Stability: None - SignalrServerConnectionDuration = attribute.Key("signalr.server.connection.duration") + SignalrServerConnectionDurationName = attribute.Key("signalr.server.connection.duration") + SignalrServerConnectionDurationUnit = attribute.Key("s") + SignalrServerConnectionDurationDescription = attribute.Key("The duration of connections on the server.") - // SignalrServerActiveConnections is the attribute Key conforming to the + // SignalrServerActiveConnections is the metric conforming to the // "signalr.server.active_connections" semantic conventions. It represents the // number of connections that are currently active on the server. // Instrument: updowncounter // Unit: {connection} // Stability: None - SignalrServerActiveConnections = attribute.Key("signalr.server.active_connections") + SignalrServerActiveConnectionsName = attribute.Key("signalr.server.active_connections") + SignalrServerActiveConnectionsUnit = attribute.Key("{connection}") + SignalrServerActiveConnectionsDescription = attribute.Key("Number of connections that are currently active on the server.") - // FaaSInvokeDuration is the attribute Key conforming to the - // "faas.invoke_duration" semantic conventions. It represents the measures the - // duration of the function's logic execution + // FaaSInvokeDuration is the metric conforming to the "faas.invoke_duration" + // semantic conventions. It represents the measures the duration of the + // function's logic execution // Instrument: histogram // Unit: s // Stability: None - FaaSInvokeDuration = attribute.Key("faas.invoke_duration") + FaaSInvokeDurationName = attribute.Key("faas.invoke_duration") + FaaSInvokeDurationUnit = attribute.Key("s") + FaaSInvokeDurationDescription = attribute.Key("Measures the duration of the function's logic execution") - // FaaSInitDuration is the attribute Key conforming to the "faas.init_duration" + // FaaSInitDuration is the metric conforming to the "faas.init_duration" // semantic conventions. It represents the measures the duration of the // function's initialization, such as a cold start // Instrument: histogram // Unit: s // Stability: None - FaaSInitDuration = attribute.Key("faas.init_duration") + FaaSInitDurationName = attribute.Key("faas.init_duration") + FaaSInitDurationUnit = attribute.Key("s") + FaaSInitDurationDescription = attribute.Key("Measures the duration of the function's initialization, such as a cold start") - // FaaSColdstarts is the attribute Key conforming to the "faas.coldstarts" - // semantic conventions. It represents the number of invocation cold starts + // FaaSColdstarts is the metric conforming to the "faas.coldstarts" semantic + // conventions. It represents the number of invocation cold starts // Instrument: counter // Unit: {coldstart} // Stability: None - FaaSColdstarts = attribute.Key("faas.coldstarts") + FaaSColdstartsName = attribute.Key("faas.coldstarts") + FaaSColdstartsUnit = attribute.Key("{coldstart}") + FaaSColdstartsDescription = attribute.Key("Number of invocation cold starts") - // FaaSErrors is the attribute Key conforming to the "faas.errors" semantic + // FaaSErrors is the metric conforming to the "faas.errors" semantic // conventions. It represents the number of invocation errors // Instrument: counter // Unit: {error} // Stability: None - FaaSErrors = attribute.Key("faas.errors") + FaaSErrorsName = attribute.Key("faas.errors") + FaaSErrorsUnit = attribute.Key("{error}") + FaaSErrorsDescription = attribute.Key("Number of invocation errors") - // FaaSInvocations is the attribute Key conforming to the "faas.invocations" - // semantic conventions. It represents the number of successful invocations + // FaaSInvocations is the metric conforming to the "faas.invocations" semantic + // conventions. It represents the number of successful invocations // Instrument: counter // Unit: {invocation} // Stability: None - FaaSInvocations = attribute.Key("faas.invocations") + FaaSInvocationsName = attribute.Key("faas.invocations") + FaaSInvocationsUnit = attribute.Key("{invocation}") + FaaSInvocationsDescription = attribute.Key("Number of successful invocations") - // FaaSTimeouts is the attribute Key conforming to the "faas.timeouts" semantic + // FaaSTimeouts is the metric conforming to the "faas.timeouts" semantic // conventions. It represents the number of invocation timeouts // Instrument: counter // Unit: {timeout} // Stability: None - FaaSTimeouts = attribute.Key("faas.timeouts") + FaaSTimeoutsName = attribute.Key("faas.timeouts") + FaaSTimeoutsUnit = attribute.Key("{timeout}") + FaaSTimeoutsDescription = attribute.Key("Number of invocation timeouts") - // FaaSMemUsage is the attribute Key conforming to the "faas.mem_usage" - // semantic conventions. It represents the distribution of max memory usage per + // FaaSMemUsage is the metric conforming to the "faas.mem_usage" semantic + // conventions. It represents the distribution of max memory usage per // invocation // Instrument: histogram // Unit: By // Stability: None - FaaSMemUsage = attribute.Key("faas.mem_usage") + FaaSMemUsageName = attribute.Key("faas.mem_usage") + FaaSMemUsageUnit = attribute.Key("By") + FaaSMemUsageDescription = attribute.Key("Distribution of max memory usage per invocation") - // FaaSCPUUsage is the attribute Key conforming to the "faas.cpu_usage" - // semantic conventions. It represents the distribution of CPU usage per - // invocation + // FaaSCPUUsage is the metric conforming to the "faas.cpu_usage" semantic + // conventions. It represents the distribution of CPU usage per invocation // Instrument: histogram // Unit: s // Stability: None - FaaSCPUUsage = attribute.Key("faas.cpu_usage") + FaaSCPUUsageName = attribute.Key("faas.cpu_usage") + FaaSCPUUsageUnit = attribute.Key("s") + FaaSCPUUsageDescription = attribute.Key("Distribution of CPU usage per invocation") - // FaaSNetIo is the attribute Key conforming to the "faas.net_io" semantic + // FaaSNetIo is the metric conforming to the "faas.net_io" semantic // conventions. It represents the distribution of net I/O usage per invocation // Instrument: histogram // Unit: By // Stability: None - FaaSNetIo = attribute.Key("faas.net_io") + FaaSNetIoName = attribute.Key("faas.net_io") + FaaSNetIoUnit = attribute.Key("By") + FaaSNetIoDescription = attribute.Key("Distribution of net I/O usage per invocation") - // HTTPServerRequestDuration is the attribute Key conforming to the + // HTTPServerRequestDuration is the metric conforming to the // "http.server.request.duration" semantic conventions. It represents the // duration of HTTP server requests. // Instrument: histogram // Unit: s // Stability: StabilityLevel.STABLE - HTTPServerRequestDuration = attribute.Key("http.server.request.duration") + HTTPServerRequestDurationName = attribute.Key("http.server.request.duration") + HTTPServerRequestDurationUnit = attribute.Key("s") + HTTPServerRequestDurationDescription = attribute.Key("Duration of HTTP server requests.") - // HTTPServerActiveRequests is the attribute Key conforming to the + // HTTPServerActiveRequests is the metric conforming to the // "http.server.active_requests" semantic conventions. It represents the number // of active HTTP server requests. // Instrument: updowncounter // Unit: {request} // Stability: None - HTTPServerActiveRequests = attribute.Key("http.server.active_requests") + HTTPServerActiveRequestsName = attribute.Key("http.server.active_requests") + HTTPServerActiveRequestsUnit = attribute.Key("{request}") + HTTPServerActiveRequestsDescription = attribute.Key("Number of active HTTP server requests.") - // HTTPServerRequestBodySize is the attribute Key conforming to the + // HTTPServerRequestBodySize is the metric conforming to the // "http.server.request.body.size" semantic conventions. It represents the size // of HTTP server request bodies. // Instrument: histogram // Unit: By // Stability: None - HTTPServerRequestBodySize = attribute.Key("http.server.request.body.size") + HTTPServerRequestBodySizeName = attribute.Key("http.server.request.body.size") + HTTPServerRequestBodySizeUnit = attribute.Key("By") + HTTPServerRequestBodySizeDescription = attribute.Key("Size of HTTP server request bodies.") - // HTTPServerResponseBodySize is the attribute Key conforming to the + // HTTPServerResponseBodySize is the metric conforming to the // "http.server.response.body.size" semantic conventions. It represents the // size of HTTP server response bodies. // Instrument: histogram // Unit: By // Stability: None - HTTPServerResponseBodySize = attribute.Key("http.server.response.body.size") + HTTPServerResponseBodySizeName = attribute.Key("http.server.response.body.size") + HTTPServerResponseBodySizeUnit = attribute.Key("By") + HTTPServerResponseBodySizeDescription = attribute.Key("Size of HTTP server response bodies.") - // HTTPClientRequestDuration is the attribute Key conforming to the + // HTTPClientRequestDuration is the metric conforming to the // "http.client.request.duration" semantic conventions. It represents the // duration of HTTP client requests. // Instrument: histogram // Unit: s // Stability: StabilityLevel.STABLE - HTTPClientRequestDuration = attribute.Key("http.client.request.duration") + HTTPClientRequestDurationName = attribute.Key("http.client.request.duration") + HTTPClientRequestDurationUnit = attribute.Key("s") + HTTPClientRequestDurationDescription = attribute.Key("Duration of HTTP client requests.") - // HTTPClientRequestBodySize is the attribute Key conforming to the + // HTTPClientRequestBodySize is the metric conforming to the // "http.client.request.body.size" semantic conventions. It represents the size // of HTTP client request bodies. // Instrument: histogram // Unit: By // Stability: None - HTTPClientRequestBodySize = attribute.Key("http.client.request.body.size") + HTTPClientRequestBodySizeName = attribute.Key("http.client.request.body.size") + HTTPClientRequestBodySizeUnit = attribute.Key("By") + HTTPClientRequestBodySizeDescription = attribute.Key("Size of HTTP client request bodies.") - // HTTPClientResponseBodySize is the attribute Key conforming to the + // HTTPClientResponseBodySize is the metric conforming to the // "http.client.response.body.size" semantic conventions. It represents the // size of HTTP client response bodies. // Instrument: histogram // Unit: By // Stability: None - HTTPClientResponseBodySize = attribute.Key("http.client.response.body.size") + HTTPClientResponseBodySizeName = attribute.Key("http.client.response.body.size") + HTTPClientResponseBodySizeUnit = attribute.Key("By") + HTTPClientResponseBodySizeDescription = attribute.Key("Size of HTTP client response bodies.") - // JvmMemoryInit is the attribute Key conforming to the "jvm.memory.init" - // semantic conventions. It represents the measure of initial memory requested. + // JvmMemoryInit is the metric conforming to the "jvm.memory.init" semantic + // conventions. It represents the measure of initial memory requested. // Instrument: updowncounter // Unit: By // Stability: None - JvmMemoryInit = attribute.Key("jvm.memory.init") + JvmMemoryInitName = attribute.Key("jvm.memory.init") + JvmMemoryInitUnit = attribute.Key("By") + JvmMemoryInitDescription = attribute.Key("Measure of initial memory requested.") - // JvmSystemCPUUtilization is the attribute Key conforming to the + // JvmSystemCPUUtilization is the metric conforming to the // "jvm.system.cpu.utilization" semantic conventions. It represents the recent // CPU utilization for the whole system as reported by the JVM. // Instrument: gauge // Unit: 1 // Stability: None - JvmSystemCPUUtilization = attribute.Key("jvm.system.cpu.utilization") + JvmSystemCPUUtilizationName = attribute.Key("jvm.system.cpu.utilization") + JvmSystemCPUUtilizationUnit = attribute.Key("1") + JvmSystemCPUUtilizationDescription = attribute.Key("Recent CPU utilization for the whole system as reported by the JVM.") - // JvmSystemCPULoad1m is the attribute Key conforming to the - // "jvm.system.cpu.load_1m" semantic conventions. It represents the average CPU - // load of the whole system for the last minute as reported by the JVM. + // JvmSystemCPULoad1m is the metric conforming to the "jvm.system.cpu.load_1m" + // semantic conventions. It represents the average CPU load of the whole system + // for the last minute as reported by the JVM. // Instrument: gauge // Unit: {run_queue_item} // Stability: None - JvmSystemCPULoad1m = attribute.Key("jvm.system.cpu.load_1m") + JvmSystemCPULoad1mName = attribute.Key("jvm.system.cpu.load_1m") + JvmSystemCPULoad1mUnit = attribute.Key("{run_queue_item}") + JvmSystemCPULoad1mDescription = attribute.Key("Average CPU load of the whole system for the last minute as reported by the JVM.") - // JvmBufferMemoryUsage is the attribute Key conforming to the + // JvmBufferMemoryUsage is the metric conforming to the // "jvm.buffer.memory.usage" semantic conventions. It represents the measure of // memory used by buffers. // Instrument: updowncounter // Unit: By // Stability: None - JvmBufferMemoryUsage = attribute.Key("jvm.buffer.memory.usage") + JvmBufferMemoryUsageName = attribute.Key("jvm.buffer.memory.usage") + JvmBufferMemoryUsageUnit = attribute.Key("By") + JvmBufferMemoryUsageDescription = attribute.Key("Measure of memory used by buffers.") - // JvmBufferMemoryLimit is the attribute Key conforming to the + // JvmBufferMemoryLimit is the metric conforming to the // "jvm.buffer.memory.limit" semantic conventions. It represents the measure of // total memory capacity of buffers. // Instrument: updowncounter // Unit: By // Stability: None - JvmBufferMemoryLimit = attribute.Key("jvm.buffer.memory.limit") + JvmBufferMemoryLimitName = attribute.Key("jvm.buffer.memory.limit") + JvmBufferMemoryLimitUnit = attribute.Key("By") + JvmBufferMemoryLimitDescription = attribute.Key("Measure of total memory capacity of buffers.") - // JvmBufferCount is the attribute Key conforming to the "jvm.buffer.count" - // semantic conventions. It represents the number of buffers in the pool. + // JvmBufferCount is the metric conforming to the "jvm.buffer.count" semantic + // conventions. It represents the number of buffers in the pool. // Instrument: updowncounter // Unit: {buffer} // Stability: None - JvmBufferCount = attribute.Key("jvm.buffer.count") + JvmBufferCountName = attribute.Key("jvm.buffer.count") + JvmBufferCountUnit = attribute.Key("{buffer}") + JvmBufferCountDescription = attribute.Key("Number of buffers in the pool.") - // JvmMemoryUsed is the attribute Key conforming to the "jvm.memory.used" - // semantic conventions. It represents the measure of memory used. + // JvmMemoryUsed is the metric conforming to the "jvm.memory.used" semantic + // conventions. It represents the measure of memory used. // Instrument: updowncounter // Unit: By // Stability: StabilityLevel.STABLE - JvmMemoryUsed = attribute.Key("jvm.memory.used") + JvmMemoryUsedName = attribute.Key("jvm.memory.used") + JvmMemoryUsedUnit = attribute.Key("By") + JvmMemoryUsedDescription = attribute.Key("Measure of memory used.") - // JvmMemoryCommitted is the attribute Key conforming to the - // "jvm.memory.committed" semantic conventions. It represents the measure of - // memory committed. + // JvmMemoryCommitted is the metric conforming to the "jvm.memory.committed" + // semantic conventions. It represents the measure of memory committed. // Instrument: updowncounter // Unit: By // Stability: StabilityLevel.STABLE - JvmMemoryCommitted = attribute.Key("jvm.memory.committed") + JvmMemoryCommittedName = attribute.Key("jvm.memory.committed") + JvmMemoryCommittedUnit = attribute.Key("By") + JvmMemoryCommittedDescription = attribute.Key("Measure of memory committed.") - // JvmMemoryLimit is the attribute Key conforming to the "jvm.memory.limit" - // semantic conventions. It represents the measure of max obtainable memory. + // JvmMemoryLimit is the metric conforming to the "jvm.memory.limit" semantic + // conventions. It represents the measure of max obtainable memory. // Instrument: updowncounter // Unit: By // Stability: StabilityLevel.STABLE - JvmMemoryLimit = attribute.Key("jvm.memory.limit") + JvmMemoryLimitName = attribute.Key("jvm.memory.limit") + JvmMemoryLimitUnit = attribute.Key("By") + JvmMemoryLimitDescription = attribute.Key("Measure of max obtainable memory.") - // JvmMemoryUsedAfterLastGc is the attribute Key conforming to the + // JvmMemoryUsedAfterLastGc is the metric conforming to the // "jvm.memory.used_after_last_gc" semantic conventions. It represents the // measure of memory used, as measured after the most recent garbage collection // event on this pool. // Instrument: updowncounter // Unit: By // Stability: StabilityLevel.STABLE - JvmMemoryUsedAfterLastGc = attribute.Key("jvm.memory.used_after_last_gc") + JvmMemoryUsedAfterLastGcName = attribute.Key("jvm.memory.used_after_last_gc") + JvmMemoryUsedAfterLastGcUnit = attribute.Key("By") + JvmMemoryUsedAfterLastGcDescription = attribute.Key("Measure of memory used, as measured after the most recent garbage collection event on this pool.") - // JvmGcDuration is the attribute Key conforming to the "jvm.gc.duration" - // semantic conventions. It represents the duration of JVM garbage collection - // actions. + // JvmGcDuration is the metric conforming to the "jvm.gc.duration" semantic + // conventions. It represents the duration of JVM garbage collection actions. // Instrument: histogram // Unit: s // Stability: StabilityLevel.STABLE - JvmGcDuration = attribute.Key("jvm.gc.duration") + JvmGcDurationName = attribute.Key("jvm.gc.duration") + JvmGcDurationUnit = attribute.Key("s") + JvmGcDurationDescription = attribute.Key("Duration of JVM garbage collection actions.") - // JvmThreadCount is the attribute Key conforming to the "jvm.thread.count" - // semantic conventions. It represents the number of executing platform - // threads. + // JvmThreadCount is the metric conforming to the "jvm.thread.count" semantic + // conventions. It represents the number of executing platform threads. // Instrument: updowncounter // Unit: {thread} // Stability: StabilityLevel.STABLE - JvmThreadCount = attribute.Key("jvm.thread.count") + JvmThreadCountName = attribute.Key("jvm.thread.count") + JvmThreadCountUnit = attribute.Key("{thread}") + JvmThreadCountDescription = attribute.Key("Number of executing platform threads.") - // JvmClassLoaded is the attribute Key conforming to the "jvm.class.loaded" - // semantic conventions. It represents the number of classes loaded since JVM - // start. + // JvmClassLoaded is the metric conforming to the "jvm.class.loaded" semantic + // conventions. It represents the number of classes loaded since JVM start. // Instrument: counter // Unit: {class} // Stability: StabilityLevel.STABLE - JvmClassLoaded = attribute.Key("jvm.class.loaded") + JvmClassLoadedName = attribute.Key("jvm.class.loaded") + JvmClassLoadedUnit = attribute.Key("{class}") + JvmClassLoadedDescription = attribute.Key("Number of classes loaded since JVM start.") - // JvmClassUnloaded is the attribute Key conforming to the "jvm.class.unloaded" + // JvmClassUnloaded is the metric conforming to the "jvm.class.unloaded" // semantic conventions. It represents the number of classes unloaded since JVM // start. // Instrument: counter // Unit: {class} // Stability: StabilityLevel.STABLE - JvmClassUnloaded = attribute.Key("jvm.class.unloaded") + JvmClassUnloadedName = attribute.Key("jvm.class.unloaded") + JvmClassUnloadedUnit = attribute.Key("{class}") + JvmClassUnloadedDescription = attribute.Key("Number of classes unloaded since JVM start.") - // JvmClassCount is the attribute Key conforming to the "jvm.class.count" - // semantic conventions. It represents the number of classes currently loaded. + // JvmClassCount is the metric conforming to the "jvm.class.count" semantic + // conventions. It represents the number of classes currently loaded. // Instrument: updowncounter // Unit: {class} // Stability: StabilityLevel.STABLE - JvmClassCount = attribute.Key("jvm.class.count") + JvmClassCountName = attribute.Key("jvm.class.count") + JvmClassCountUnit = attribute.Key("{class}") + JvmClassCountDescription = attribute.Key("Number of classes currently loaded.") - // JvmCPUCount is the attribute Key conforming to the "jvm.cpu.count" semantic + // JvmCPUCount is the metric conforming to the "jvm.cpu.count" semantic // conventions. It represents the number of processors available to the Java // virtual machine. // Instrument: updowncounter // Unit: {cpu} // Stability: StabilityLevel.STABLE - JvmCPUCount = attribute.Key("jvm.cpu.count") + JvmCPUCountName = attribute.Key("jvm.cpu.count") + JvmCPUCountUnit = attribute.Key("{cpu}") + JvmCPUCountDescription = attribute.Key("Number of processors available to the Java virtual machine.") - // JvmCPUTime is the attribute Key conforming to the "jvm.cpu.time" semantic + // JvmCPUTime is the metric conforming to the "jvm.cpu.time" semantic // conventions. It represents the cPU time used by the process as reported by // the JVM. // Instrument: counter // Unit: s // Stability: StabilityLevel.STABLE - JvmCPUTime = attribute.Key("jvm.cpu.time") + JvmCPUTimeName = attribute.Key("jvm.cpu.time") + JvmCPUTimeUnit = attribute.Key("s") + JvmCPUTimeDescription = attribute.Key("CPU time used by the process as reported by the JVM.") - // JvmCPURecentUtilization is the attribute Key conforming to the + // JvmCPURecentUtilization is the metric conforming to the // "jvm.cpu.recent_utilization" semantic conventions. It represents the recent // CPU utilization for the process as reported by the JVM. // Instrument: gauge // Unit: 1 // Stability: StabilityLevel.STABLE - JvmCPURecentUtilization = attribute.Key("jvm.cpu.recent_utilization") + JvmCPURecentUtilizationName = attribute.Key("jvm.cpu.recent_utilization") + JvmCPURecentUtilizationUnit = attribute.Key("1") + JvmCPURecentUtilizationDescription = attribute.Key("Recent CPU utilization for the process as reported by the JVM.") - // MessagingPublishDuration is the attribute Key conforming to the + // MessagingPublishDuration is the metric conforming to the // "messaging.publish.duration" semantic conventions. It represents the // measures the duration of publish operation. // Instrument: histogram // Unit: s // Stability: None - MessagingPublishDuration = attribute.Key("messaging.publish.duration") + MessagingPublishDurationName = attribute.Key("messaging.publish.duration") + MessagingPublishDurationUnit = attribute.Key("s") + MessagingPublishDurationDescription = attribute.Key("Measures the duration of publish operation.") - // MessagingReceiveDuration is the attribute Key conforming to the + // MessagingReceiveDuration is the metric conforming to the // "messaging.receive.duration" semantic conventions. It represents the // measures the duration of receive operation. // Instrument: histogram // Unit: s // Stability: None - MessagingReceiveDuration = attribute.Key("messaging.receive.duration") + MessagingReceiveDurationName = attribute.Key("messaging.receive.duration") + MessagingReceiveDurationUnit = attribute.Key("s") + MessagingReceiveDurationDescription = attribute.Key("Measures the duration of receive operation.") - // MessagingDeliverDuration is the attribute Key conforming to the + // MessagingDeliverDuration is the metric conforming to the // "messaging.deliver.duration" semantic conventions. It represents the // measures the duration of deliver operation. // Instrument: histogram // Unit: s // Stability: None - MessagingDeliverDuration = attribute.Key("messaging.deliver.duration") + MessagingDeliverDurationName = attribute.Key("messaging.deliver.duration") + MessagingDeliverDurationUnit = attribute.Key("s") + MessagingDeliverDurationDescription = attribute.Key("Measures the duration of deliver operation.") - // MessagingPublishMessages is the attribute Key conforming to the + // MessagingPublishMessages is the metric conforming to the // "messaging.publish.messages" semantic conventions. It represents the // measures the number of published messages. // Instrument: counter // Unit: {message} // Stability: None - MessagingPublishMessages = attribute.Key("messaging.publish.messages") + MessagingPublishMessagesName = attribute.Key("messaging.publish.messages") + MessagingPublishMessagesUnit = attribute.Key("{message}") + MessagingPublishMessagesDescription = attribute.Key("Measures the number of published messages.") - // MessagingReceiveMessages is the attribute Key conforming to the + // MessagingReceiveMessages is the metric conforming to the // "messaging.receive.messages" semantic conventions. It represents the // measures the number of received messages. // Instrument: counter // Unit: {message} // Stability: None - MessagingReceiveMessages = attribute.Key("messaging.receive.messages") + MessagingReceiveMessagesName = attribute.Key("messaging.receive.messages") + MessagingReceiveMessagesUnit = attribute.Key("{message}") + MessagingReceiveMessagesDescription = attribute.Key("Measures the number of received messages.") - // MessagingDeliverMessages is the attribute Key conforming to the + // MessagingDeliverMessages is the metric conforming to the // "messaging.deliver.messages" semantic conventions. It represents the // measures the number of delivered messages. // Instrument: counter // Unit: {message} // Stability: None - MessagingDeliverMessages = attribute.Key("messaging.deliver.messages") + MessagingDeliverMessagesName = attribute.Key("messaging.deliver.messages") + MessagingDeliverMessagesUnit = attribute.Key("{message}") + MessagingDeliverMessagesDescription = attribute.Key("Measures the number of delivered messages.") - // RPCServerDuration is the attribute Key conforming to the - // "rpc.server.duration" semantic conventions. It represents the measures the - // duration of inbound RPC. + // RPCServerDuration is the metric conforming to the "rpc.server.duration" + // semantic conventions. It represents the measures the duration of inbound + // RPC. // Instrument: histogram // Unit: ms // Stability: None - RPCServerDuration = attribute.Key("rpc.server.duration") + RPCServerDurationName = attribute.Key("rpc.server.duration") + RPCServerDurationUnit = attribute.Key("ms") + RPCServerDurationDescription = attribute.Key("Measures the duration of inbound RPC.") - // RPCServerRequestSize is the attribute Key conforming to the + // RPCServerRequestSize is the metric conforming to the // "rpc.server.request.size" semantic conventions. It represents the measures // the size of RPC request messages (uncompressed). // Instrument: histogram // Unit: By // Stability: None - RPCServerRequestSize = attribute.Key("rpc.server.request.size") + RPCServerRequestSizeName = attribute.Key("rpc.server.request.size") + RPCServerRequestSizeUnit = attribute.Key("By") + RPCServerRequestSizeDescription = attribute.Key("Measures the size of RPC request messages (uncompressed).") - // RPCServerResponseSize is the attribute Key conforming to the + // RPCServerResponseSize is the metric conforming to the // "rpc.server.response.size" semantic conventions. It represents the measures // the size of RPC response messages (uncompressed). // Instrument: histogram // Unit: By // Stability: None - RPCServerResponseSize = attribute.Key("rpc.server.response.size") + RPCServerResponseSizeName = attribute.Key("rpc.server.response.size") + RPCServerResponseSizeUnit = attribute.Key("By") + RPCServerResponseSizeDescription = attribute.Key("Measures the size of RPC response messages (uncompressed).") - // RPCServerRequestsPerRPC is the attribute Key conforming to the + // RPCServerRequestsPerRPC is the metric conforming to the // "rpc.server.requests_per_rpc" semantic conventions. It represents the // measures the number of messages received per RPC. // Instrument: histogram // Unit: {count} // Stability: None - RPCServerRequestsPerRPC = attribute.Key("rpc.server.requests_per_rpc") + RPCServerRequestsPerRPCName = attribute.Key("rpc.server.requests_per_rpc") + RPCServerRequestsPerRPCUnit = attribute.Key("{count}") + RPCServerRequestsPerRPCDescription = attribute.Key("Measures the number of messages received per RPC.") - // RPCServerResponsesPerRPC is the attribute Key conforming to the + // RPCServerResponsesPerRPC is the metric conforming to the // "rpc.server.responses_per_rpc" semantic conventions. It represents the // measures the number of messages sent per RPC. // Instrument: histogram // Unit: {count} // Stability: None - RPCServerResponsesPerRPC = attribute.Key("rpc.server.responses_per_rpc") + RPCServerResponsesPerRPCName = attribute.Key("rpc.server.responses_per_rpc") + RPCServerResponsesPerRPCUnit = attribute.Key("{count}") + RPCServerResponsesPerRPCDescription = attribute.Key("Measures the number of messages sent per RPC.") - // RPCClientDuration is the attribute Key conforming to the - // "rpc.client.duration" semantic conventions. It represents the measures the - // duration of outbound RPC. + // RPCClientDuration is the metric conforming to the "rpc.client.duration" + // semantic conventions. It represents the measures the duration of outbound + // RPC. // Instrument: histogram // Unit: ms // Stability: None - RPCClientDuration = attribute.Key("rpc.client.duration") + RPCClientDurationName = attribute.Key("rpc.client.duration") + RPCClientDurationUnit = attribute.Key("ms") + RPCClientDurationDescription = attribute.Key("Measures the duration of outbound RPC.") - // RPCClientRequestSize is the attribute Key conforming to the + // RPCClientRequestSize is the metric conforming to the // "rpc.client.request.size" semantic conventions. It represents the measures // the size of RPC request messages (uncompressed). // Instrument: histogram // Unit: By // Stability: None - RPCClientRequestSize = attribute.Key("rpc.client.request.size") + RPCClientRequestSizeName = attribute.Key("rpc.client.request.size") + RPCClientRequestSizeUnit = attribute.Key("By") + RPCClientRequestSizeDescription = attribute.Key("Measures the size of RPC request messages (uncompressed).") - // RPCClientResponseSize is the attribute Key conforming to the + // RPCClientResponseSize is the metric conforming to the // "rpc.client.response.size" semantic conventions. It represents the measures // the size of RPC response messages (uncompressed). // Instrument: histogram // Unit: By // Stability: None - RPCClientResponseSize = attribute.Key("rpc.client.response.size") + RPCClientResponseSizeName = attribute.Key("rpc.client.response.size") + RPCClientResponseSizeUnit = attribute.Key("By") + RPCClientResponseSizeDescription = attribute.Key("Measures the size of RPC response messages (uncompressed).") - // RPCClientRequestsPerRPC is the attribute Key conforming to the + // RPCClientRequestsPerRPC is the metric conforming to the // "rpc.client.requests_per_rpc" semantic conventions. It represents the // measures the number of messages received per RPC. // Instrument: histogram // Unit: {count} // Stability: None - RPCClientRequestsPerRPC = attribute.Key("rpc.client.requests_per_rpc") + RPCClientRequestsPerRPCName = attribute.Key("rpc.client.requests_per_rpc") + RPCClientRequestsPerRPCUnit = attribute.Key("{count}") + RPCClientRequestsPerRPCDescription = attribute.Key("Measures the number of messages received per RPC.") - // RPCClientResponsesPerRPC is the attribute Key conforming to the + // RPCClientResponsesPerRPC is the metric conforming to the // "rpc.client.responses_per_rpc" semantic conventions. It represents the // measures the number of messages sent per RPC. // Instrument: histogram // Unit: {count} // Stability: None - RPCClientResponsesPerRPC = attribute.Key("rpc.client.responses_per_rpc") + RPCClientResponsesPerRPCName = attribute.Key("rpc.client.responses_per_rpc") + RPCClientResponsesPerRPCUnit = attribute.Key("{count}") + RPCClientResponsesPerRPCDescription = attribute.Key("Measures the number of messages sent per RPC.") - // SystemCPUTime is the attribute Key conforming to the "system.cpu.time" - // semantic conventions. It represents the seconds each logical CPU spent on - // each mode + // SystemCPUTime is the metric conforming to the "system.cpu.time" semantic + // conventions. It represents the seconds each logical CPU spent on each mode // Instrument: counter // Unit: s // Stability: None - SystemCPUTime = attribute.Key("system.cpu.time") + SystemCPUTimeName = attribute.Key("system.cpu.time") + SystemCPUTimeUnit = attribute.Key("s") + SystemCPUTimeDescription = attribute.Key("Seconds each logical CPU spent on each mode") - // SystemCPUUtilization is the attribute Key conforming to the + // SystemCPUUtilization is the metric conforming to the // "system.cpu.utilization" semantic conventions. It represents the difference // in system.cpu.time since the last measurement, divided by the elapsed time // and number of logical CPUs // Instrument: gauge // Unit: 1 // Stability: None - SystemCPUUtilization = attribute.Key("system.cpu.utilization") + SystemCPUUtilizationName = attribute.Key("system.cpu.utilization") + SystemCPUUtilizationUnit = attribute.Key("1") + SystemCPUUtilizationDescription = attribute.Key("Difference in system.cpu.time since the last measurement, divided by the elapsed time and number of logical CPUs") - // SystemCPUFrequency is the attribute Key conforming to the - // "system.cpu.frequency" semantic conventions. It represents the reports the - // current frequency of the CPU in Hz + // SystemCPUFrequency is the metric conforming to the "system.cpu.frequency" + // semantic conventions. It represents the reports the current frequency of the + // CPU in Hz // Instrument: gauge // Unit: {Hz} // Stability: None - SystemCPUFrequency = attribute.Key("system.cpu.frequency") + SystemCPUFrequencyName = attribute.Key("system.cpu.frequency") + SystemCPUFrequencyUnit = attribute.Key("{Hz}") + SystemCPUFrequencyDescription = attribute.Key("Reports the current frequency of the CPU in Hz") - // SystemCPUPhysicalCount is the attribute Key conforming to the + // SystemCPUPhysicalCount is the metric conforming to the // "system.cpu.physical.count" semantic conventions. It represents the reports // the number of actual physical processor cores on the hardware // Instrument: updowncounter // Unit: {cpu} // Stability: None - SystemCPUPhysicalCount = attribute.Key("system.cpu.physical.count") + SystemCPUPhysicalCountName = attribute.Key("system.cpu.physical.count") + SystemCPUPhysicalCountUnit = attribute.Key("{cpu}") + SystemCPUPhysicalCountDescription = attribute.Key("Reports the number of actual physical processor cores on the hardware") - // SystemCPULogicalCount is the attribute Key conforming to the + // SystemCPULogicalCount is the metric conforming to the // "system.cpu.logical.count" semantic conventions. It represents the reports // the number of logical (virtual) processor cores created by the operating // system to manage multitasking // Instrument: updowncounter // Unit: {cpu} // Stability: None - SystemCPULogicalCount = attribute.Key("system.cpu.logical.count") + SystemCPULogicalCountName = attribute.Key("system.cpu.logical.count") + SystemCPULogicalCountUnit = attribute.Key("{cpu}") + SystemCPULogicalCountDescription = attribute.Key("Reports the number of logical (virtual) processor cores created by the operating system to manage multitasking") - // SystemMemoryUsage is the attribute Key conforming to the - // "system.memory.usage" semantic conventions. It represents the reports memory - // in use by state. + // SystemMemoryUsage is the metric conforming to the "system.memory.usage" + // semantic conventions. It represents the reports memory in use by state. // Instrument: updowncounter // Unit: By // Stability: None - SystemMemoryUsage = attribute.Key("system.memory.usage") + SystemMemoryUsageName = attribute.Key("system.memory.usage") + SystemMemoryUsageUnit = attribute.Key("By") + SystemMemoryUsageDescription = attribute.Key("Reports memory in use by state.") - // SystemMemoryLimit is the attribute Key conforming to the - // "system.memory.limit" semantic conventions. It represents the total memory - // available in the system. + // SystemMemoryLimit is the metric conforming to the "system.memory.limit" + // semantic conventions. It represents the total memory available in the + // system. // Instrument: updowncounter // Unit: By // Stability: None - SystemMemoryLimit = attribute.Key("system.memory.limit") + SystemMemoryLimitName = attribute.Key("system.memory.limit") + SystemMemoryLimitUnit = attribute.Key("By") + SystemMemoryLimitDescription = attribute.Key("Total memory available in the system.") - // SystemMemoryUtilization is the attribute Key conforming to the + // SystemMemoryUtilization is the metric conforming to the // "system.memory.utilization" semantic conventions. It represents the // Instrument: gauge // Unit: 1 // Stability: None - SystemMemoryUtilization = attribute.Key("system.memory.utilization") + SystemMemoryUtilizationName = attribute.Key("system.memory.utilization") + SystemMemoryUtilizationUnit = attribute.Key("1") + SystemMemoryUtilizationDescription = attribute.Key("") - // SystemPagingUsage is the attribute Key conforming to the - // "system.paging.usage" semantic conventions. It represents the unix swap or - // windows pagefile usage + // SystemPagingUsage is the metric conforming to the "system.paging.usage" + // semantic conventions. It represents the unix swap or windows pagefile usage // Instrument: updowncounter // Unit: By // Stability: None - SystemPagingUsage = attribute.Key("system.paging.usage") + SystemPagingUsageName = attribute.Key("system.paging.usage") + SystemPagingUsageUnit = attribute.Key("By") + SystemPagingUsageDescription = attribute.Key("Unix swap or windows pagefile usage") - // SystemPagingUtilization is the attribute Key conforming to the + // SystemPagingUtilization is the metric conforming to the // "system.paging.utilization" semantic conventions. It represents the // Instrument: gauge // Unit: 1 // Stability: None - SystemPagingUtilization = attribute.Key("system.paging.utilization") + SystemPagingUtilizationName = attribute.Key("system.paging.utilization") + SystemPagingUtilizationUnit = attribute.Key("1") + SystemPagingUtilizationDescription = attribute.Key("") - // SystemPagingFaults is the attribute Key conforming to the - // "system.paging.faults" semantic conventions. It represents the + // SystemPagingFaults is the metric conforming to the "system.paging.faults" + // semantic conventions. It represents the // Instrument: counter // Unit: {fault} // Stability: None - SystemPagingFaults = attribute.Key("system.paging.faults") + SystemPagingFaultsName = attribute.Key("system.paging.faults") + SystemPagingFaultsUnit = attribute.Key("{fault}") + SystemPagingFaultsDescription = attribute.Key("") - // SystemPagingOperations is the attribute Key conforming to the + // SystemPagingOperations is the metric conforming to the // "system.paging.operations" semantic conventions. It represents the // Instrument: counter // Unit: {operation} // Stability: None - SystemPagingOperations = attribute.Key("system.paging.operations") + SystemPagingOperationsName = attribute.Key("system.paging.operations") + SystemPagingOperationsUnit = attribute.Key("{operation}") + SystemPagingOperationsDescription = attribute.Key("") - // SystemDiskIo is the attribute Key conforming to the "system.disk.io" - // semantic conventions. It represents the + // SystemDiskIo is the metric conforming to the "system.disk.io" semantic + // conventions. It represents the // Instrument: counter // Unit: By // Stability: None - SystemDiskIo = attribute.Key("system.disk.io") + SystemDiskIoName = attribute.Key("system.disk.io") + SystemDiskIoUnit = attribute.Key("By") + SystemDiskIoDescription = attribute.Key("") - // SystemDiskOperations is the attribute Key conforming to the + // SystemDiskOperations is the metric conforming to the // "system.disk.operations" semantic conventions. It represents the // Instrument: counter // Unit: {operation} // Stability: None - SystemDiskOperations = attribute.Key("system.disk.operations") + SystemDiskOperationsName = attribute.Key("system.disk.operations") + SystemDiskOperationsUnit = attribute.Key("{operation}") + SystemDiskOperationsDescription = attribute.Key("") - // SystemDiskIoTime is the attribute Key conforming to the - // "system.disk.io_time" semantic conventions. It represents the time disk - // spent activated + // SystemDiskIoTime is the metric conforming to the "system.disk.io_time" + // semantic conventions. It represents the time disk spent activated // Instrument: counter // Unit: s // Stability: None - SystemDiskIoTime = attribute.Key("system.disk.io_time") + SystemDiskIoTimeName = attribute.Key("system.disk.io_time") + SystemDiskIoTimeUnit = attribute.Key("s") + SystemDiskIoTimeDescription = attribute.Key("Time disk spent activated") - // SystemDiskOperationTime is the attribute Key conforming to the + // SystemDiskOperationTime is the metric conforming to the // "system.disk.operation_time" semantic conventions. It represents the sum of // the time each operation took to complete // Instrument: counter // Unit: s // Stability: None - SystemDiskOperationTime = attribute.Key("system.disk.operation_time") + SystemDiskOperationTimeName = attribute.Key("system.disk.operation_time") + SystemDiskOperationTimeUnit = attribute.Key("s") + SystemDiskOperationTimeDescription = attribute.Key("Sum of the time each operation took to complete") - // SystemDiskMerged is the attribute Key conforming to the "system.disk.merged" + // SystemDiskMerged is the metric conforming to the "system.disk.merged" // semantic conventions. It represents the // Instrument: counter // Unit: {operation} // Stability: None - SystemDiskMerged = attribute.Key("system.disk.merged") + SystemDiskMergedName = attribute.Key("system.disk.merged") + SystemDiskMergedUnit = attribute.Key("{operation}") + SystemDiskMergedDescription = attribute.Key("") - // SystemFilesystemUsage is the attribute Key conforming to the + // SystemFilesystemUsage is the metric conforming to the // "system.filesystem.usage" semantic conventions. It represents the // Instrument: updowncounter // Unit: By // Stability: None - SystemFilesystemUsage = attribute.Key("system.filesystem.usage") + SystemFilesystemUsageName = attribute.Key("system.filesystem.usage") + SystemFilesystemUsageUnit = attribute.Key("By") + SystemFilesystemUsageDescription = attribute.Key("") - // SystemFilesystemUtilization is the attribute Key conforming to the + // SystemFilesystemUtilization is the metric conforming to the // "system.filesystem.utilization" semantic conventions. It represents the // Instrument: gauge // Unit: 1 // Stability: None - SystemFilesystemUtilization = attribute.Key("system.filesystem.utilization") + SystemFilesystemUtilizationName = attribute.Key("system.filesystem.utilization") + SystemFilesystemUtilizationUnit = attribute.Key("1") + SystemFilesystemUtilizationDescription = attribute.Key("") - // SystemNetworkDropped is the attribute Key conforming to the + // SystemNetworkDropped is the metric conforming to the // "system.network.dropped" semantic conventions. It represents the count of // packets that are dropped or discarded even though there was no error // Instrument: counter // Unit: {packet} // Stability: None - SystemNetworkDropped = attribute.Key("system.network.dropped") + SystemNetworkDroppedName = attribute.Key("system.network.dropped") + SystemNetworkDroppedUnit = attribute.Key("{packet}") + SystemNetworkDroppedDescription = attribute.Key("Count of packets that are dropped or discarded even though there was no error") - // SystemNetworkPackets is the attribute Key conforming to the + // SystemNetworkPackets is the metric conforming to the // "system.network.packets" semantic conventions. It represents the // Instrument: counter // Unit: {packet} // Stability: None - SystemNetworkPackets = attribute.Key("system.network.packets") + SystemNetworkPacketsName = attribute.Key("system.network.packets") + SystemNetworkPacketsUnit = attribute.Key("{packet}") + SystemNetworkPacketsDescription = attribute.Key("") - // SystemNetworkErrors is the attribute Key conforming to the - // "system.network.errors" semantic conventions. It represents the count of - // network errors detected + // SystemNetworkErrors is the metric conforming to the "system.network.errors" + // semantic conventions. It represents the count of network errors detected // Instrument: counter // Unit: {error} // Stability: None - SystemNetworkErrors = attribute.Key("system.network.errors") + SystemNetworkErrorsName = attribute.Key("system.network.errors") + SystemNetworkErrorsUnit = attribute.Key("{error}") + SystemNetworkErrorsDescription = attribute.Key("Count of network errors detected") - // SystemNetworkIo is the attribute Key conforming to the "system.network.io" - // semantic conventions. It represents the + // SystemNetworkIo is the metric conforming to the "system.network.io" semantic + // conventions. It represents the // Instrument: counter // Unit: By // Stability: None - SystemNetworkIo = attribute.Key("system.network.io") + SystemNetworkIoName = attribute.Key("system.network.io") + SystemNetworkIoUnit = attribute.Key("By") + SystemNetworkIoDescription = attribute.Key("") - // SystemNetworkConnections is the attribute Key conforming to the + // SystemNetworkConnections is the metric conforming to the // "system.network.connections" semantic conventions. It represents the // Instrument: updowncounter // Unit: {connection} // Stability: None - SystemNetworkConnections = attribute.Key("system.network.connections") + SystemNetworkConnectionsName = attribute.Key("system.network.connections") + SystemNetworkConnectionsUnit = attribute.Key("{connection}") + SystemNetworkConnectionsDescription = attribute.Key("") - // SystemProcessesCount is the attribute Key conforming to the + // SystemProcessesCount is the metric conforming to the // "system.processes.count" semantic conventions. It represents the total // number of processes in each state // Instrument: updowncounter // Unit: {process} // Stability: None - SystemProcessesCount = attribute.Key("system.processes.count") + SystemProcessesCountName = attribute.Key("system.processes.count") + SystemProcessesCountUnit = attribute.Key("{process}") + SystemProcessesCountDescription = attribute.Key("Total number of processes in each state") - // SystemProcessesCreated is the attribute Key conforming to the + // SystemProcessesCreated is the metric conforming to the // "system.processes.created" semantic conventions. It represents the total // number of processes created over uptime of the host // Instrument: counter // Unit: {process} // Stability: None - SystemProcessesCreated = attribute.Key("system.processes.created") + SystemProcessesCreatedName = attribute.Key("system.processes.created") + SystemProcessesCreatedUnit = attribute.Key("{process}") + SystemProcessesCreatedDescription = attribute.Key("Total number of processes created over uptime of the host") - // SystemLinuxMemoryAvailable is the attribute Key conforming to the + // SystemLinuxMemoryAvailable is the metric conforming to the // "system.linux.memory.available" semantic conventions. It represents an // estimate of how much memory is available for starting new applications, // without causing swapping // Instrument: updowncounter // Unit: By // Stability: None - SystemLinuxMemoryAvailable = attribute.Key("system.linux.memory.available") + SystemLinuxMemoryAvailableName = attribute.Key("system.linux.memory.available") + SystemLinuxMemoryAvailableUnit = attribute.Key("By") + SystemLinuxMemoryAvailableDescription = attribute.Key("An estimate of how much memory is available for starting new applications, without causing swapping") ) From d77868738de576991c54e6a4304bdaf4b3d54df5 Mon Sep 17 00:00:00 2001 From: Ben Carr Date: Tue, 6 Feb 2024 16:33:15 -0800 Subject: [PATCH 03/11] Update CHANGELOG --- CHANGELOG.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index ea1f723e264..38828f116e4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,10 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm ## [Unreleased] +### Added + +- Adds a new template to generate metric semantic conventions, as well as adding it to the Makefile `semconv-generate` script to add the metric.go file to the v1.24.0 directory. (#4528) + ## [1.23.0] 2024-02-06 This release contains the first stable, `v1`, release of the following modules: From 58ff3f0577868cc7bf299245a28991a5b6f2663f Mon Sep 17 00:00:00 2001 From: Ben Carr Date: Tue, 20 Feb 2024 13:45:37 -0800 Subject: [PATCH 04/11] fix overlooked merge conflict --- Makefile | 5 ----- 1 file changed, 5 deletions(-) diff --git a/Makefile b/Makefile index e6a860d4860..5df3b1a62b6 100644 --- a/Makefile +++ b/Makefile @@ -315,10 +315,5 @@ add-tags: | $(MULTIMOD) $(MULTIMOD) verify && $(MULTIMOD) tag -m ${MODSET} -c ${COMMIT} .PHONY: lint-markdown -<<<<<<< HEAD lint-markdown: - docker run -v "$(CURDIR):$(WORKDIR)" docker://avtodev/markdown-lint:v1 -c $(WORKDIR)/.markdownlint.yaml $(WORKDIR)/**/*.md -======= -lint-markdown: docker run -v "$(CURDIR):$(WORKDIR)" avtodev/markdown-lint:v1 -c $(WORKDIR)/.markdownlint.yaml $(WORKDIR)/**/*.md ->>>>>>> main From 35d60771827afa8f141edc4ddcfcbd448fd5bd86 Mon Sep 17 00:00:00 2001 From: Ben Carr Date: Thu, 22 Feb 2024 13:42:53 -0800 Subject: [PATCH 05/11] change the types of generated consts to string; format generation to handle empty stability and descriptions --- semconv/metric_template.j2 | 26 +- semconv/v1.24.0/metric.go | 1082 ++++++++++++++++++------------------ 2 files changed, 558 insertions(+), 550 deletions(-) diff --git a/semconv/metric_template.j2 b/semconv/metric_template.j2 index 4e6cf7a6eec..9ac84be15aa 100644 --- a/semconv/metric_template.j2 +++ b/semconv/metric_template.j2 @@ -9,10 +9,17 @@ It represents {% if brief[:2] == "A " or brief[:3] == "An " or brief[:4] == "The {%- endif -%} {%- endmacro -%} {%- macro keydoc(metric) -%} -{%- if metric.stability|string() == "StabilityLevel.DEPRECATED" -%} +{%- if metric.stability|string() == "StabilityLevel.DEPRECATED" or not metric.brief-%} {{ to_go_name(metric.metric_name) }} is the metric conforming to the "{{ metric.metric_name}}" semantic conventions. {%- else -%} -{{ to_go_name(metric.metric_name) }} is the metric conforming to the "{{ metric.metric_name}}" semantic conventions. {{ it_reps(metric.brief) }} +{{ to_go_name(metric.metric_name) }} is the metric conforming to the "{{ metric.metric_name}}" semantic conventions. {{ it_reps(metric.brief) }}. +{%- endif %} +{%- endmacro -%} +{%- macro format_stability(stability) -%} +{%- if not stability -%} +Experimental +{%- else -%} +{{ stability|replace("StabilityLevel.", "")|capitalize() }} {%- endif %} {%- endmacro -%} // Copyright The OpenTelemetry Authors @@ -33,18 +40,21 @@ It represents {% if brief[:2] == "A " or brief[:3] == "An " or brief[:4] == "The package semconv // import [[IMPORTPATH]] -import "go.opentelemetry.io/otel/attribute" - const ( {% for id in semconvs %} {%- if semconvs[id].GROUP_TYPE_NAME == 'metric' %}{% set metric = semconvs[id] %} // {{ keydoc(metric) | wordwrap(76, break_long_words=false, break_on_hyphens=false, wrapstring="\n// ") }} // Instrument: {{ metric.instrument }} // Unit: {{ metric.unit }} - // Stability: {{ metric.stability }} - {{to_go_name(metric.metric_name)}}Name = attribute.Key("{{metric.metric_name}}") - {{to_go_name(metric.metric_name)}}Unit = attribute.Key("{{metric.unit}}") - {{to_go_name(metric.metric_name)}}Description = attribute.Key("{{metric.brief}}") + // Stability: {{ format_stability(metric.stability) }} +{%- if not metric.brief %} + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. +{%- endif %} + {{to_go_name(metric.metric_name)}}Name = "{{metric.metric_name}}" + {{to_go_name(metric.metric_name)}}Unit = "{{metric.unit}}" +{%- if metric.brief %} + {{to_go_name(metric.metric_name)}}Description = "{{metric.brief}}" +{%- endif %} {%- endif %} {% endfor %} ) diff --git a/semconv/v1.24.0/metric.go b/semconv/v1.24.0/metric.go index 1023910ee17..8609d4ad9d0 100644 --- a/semconv/v1.24.0/metric.go +++ b/semconv/v1.24.0/metric.go @@ -16,1069 +16,1067 @@ package semconv // import "go.opentelemetry.io/otel/semconv/v1.24.0" -import "go.opentelemetry.io/otel/attribute" - const ( // DBClientConnectionsUsage is the metric conforming to the // "db.client.connections.usage" semantic conventions. It represents the number // of connections that are currently in state described by the `state` - // attribute + // attribute. // Instrument: updowncounter // Unit: {connection} - // Stability: None - DBClientConnectionsUsageName = attribute.Key("db.client.connections.usage") - DBClientConnectionsUsageUnit = attribute.Key("{connection}") - DBClientConnectionsUsageDescription = attribute.Key("The number of connections that are currently in state described by the `state` attribute") + // Stability: Experimental + DBClientConnectionsUsageName = "db.client.connections.usage" + DBClientConnectionsUsageUnit = "{connection}" + DBClientConnectionsUsageDescription = "The number of connections that are currently in state described by the `state` attribute" // DBClientConnectionsIdleMax is the metric conforming to the // "db.client.connections.idle.max" semantic conventions. It represents the - // maximum number of idle open connections allowed + // maximum number of idle open connections allowed. // Instrument: updowncounter // Unit: {connection} - // Stability: None - DBClientConnectionsIdleMaxName = attribute.Key("db.client.connections.idle.max") - DBClientConnectionsIdleMaxUnit = attribute.Key("{connection}") - DBClientConnectionsIdleMaxDescription = attribute.Key("The maximum number of idle open connections allowed") + // Stability: Experimental + DBClientConnectionsIdleMaxName = "db.client.connections.idle.max" + DBClientConnectionsIdleMaxUnit = "{connection}" + DBClientConnectionsIdleMaxDescription = "The maximum number of idle open connections allowed" // DBClientConnectionsIdleMin is the metric conforming to the // "db.client.connections.idle.min" semantic conventions. It represents the - // minimum number of idle open connections allowed + // minimum number of idle open connections allowed. // Instrument: updowncounter // Unit: {connection} - // Stability: None - DBClientConnectionsIdleMinName = attribute.Key("db.client.connections.idle.min") - DBClientConnectionsIdleMinUnit = attribute.Key("{connection}") - DBClientConnectionsIdleMinDescription = attribute.Key("The minimum number of idle open connections allowed") + // Stability: Experimental + DBClientConnectionsIdleMinName = "db.client.connections.idle.min" + DBClientConnectionsIdleMinUnit = "{connection}" + DBClientConnectionsIdleMinDescription = "The minimum number of idle open connections allowed" // DBClientConnectionsMax is the metric conforming to the // "db.client.connections.max" semantic conventions. It represents the maximum - // number of open connections allowed + // number of open connections allowed. // Instrument: updowncounter // Unit: {connection} - // Stability: None - DBClientConnectionsMaxName = attribute.Key("db.client.connections.max") - DBClientConnectionsMaxUnit = attribute.Key("{connection}") - DBClientConnectionsMaxDescription = attribute.Key("The maximum number of open connections allowed") + // Stability: Experimental + DBClientConnectionsMaxName = "db.client.connections.max" + DBClientConnectionsMaxUnit = "{connection}" + DBClientConnectionsMaxDescription = "The maximum number of open connections allowed" // DBClientConnectionsPendingRequests is the metric conforming to the // "db.client.connections.pending_requests" semantic conventions. It represents // the number of pending requests for an open connection, cumulative for the - // entire pool + // entire pool. // Instrument: updowncounter // Unit: {request} - // Stability: None - DBClientConnectionsPendingRequestsName = attribute.Key("db.client.connections.pending_requests") - DBClientConnectionsPendingRequestsUnit = attribute.Key("{request}") - DBClientConnectionsPendingRequestsDescription = attribute.Key("The number of pending requests for an open connection, cumulative for the entire pool") + // Stability: Experimental + DBClientConnectionsPendingRequestsName = "db.client.connections.pending_requests" + DBClientConnectionsPendingRequestsUnit = "{request}" + DBClientConnectionsPendingRequestsDescription = "The number of pending requests for an open connection, cumulative for the entire pool" // DBClientConnectionsTimeouts is the metric conforming to the // "db.client.connections.timeouts" semantic conventions. It represents the // number of connection timeouts that have occurred trying to obtain a - // connection from the pool + // connection from the pool. // Instrument: counter // Unit: {timeout} - // Stability: None - DBClientConnectionsTimeoutsName = attribute.Key("db.client.connections.timeouts") - DBClientConnectionsTimeoutsUnit = attribute.Key("{timeout}") - DBClientConnectionsTimeoutsDescription = attribute.Key("The number of connection timeouts that have occurred trying to obtain a connection from the pool") + // Stability: Experimental + DBClientConnectionsTimeoutsName = "db.client.connections.timeouts" + DBClientConnectionsTimeoutsUnit = "{timeout}" + DBClientConnectionsTimeoutsDescription = "The number of connection timeouts that have occurred trying to obtain a connection from the pool" // DBClientConnectionsCreateTime is the metric conforming to the // "db.client.connections.create_time" semantic conventions. It represents the - // time it took to create a new connection + // time it took to create a new connection. // Instrument: histogram // Unit: ms - // Stability: None - DBClientConnectionsCreateTimeName = attribute.Key("db.client.connections.create_time") - DBClientConnectionsCreateTimeUnit = attribute.Key("ms") - DBClientConnectionsCreateTimeDescription = attribute.Key("The time it took to create a new connection") + // Stability: Experimental + DBClientConnectionsCreateTimeName = "db.client.connections.create_time" + DBClientConnectionsCreateTimeUnit = "ms" + DBClientConnectionsCreateTimeDescription = "The time it took to create a new connection" // DBClientConnectionsWaitTime is the metric conforming to the // "db.client.connections.wait_time" semantic conventions. It represents the - // time it took to obtain an open connection from the pool + // time it took to obtain an open connection from the pool. // Instrument: histogram // Unit: ms - // Stability: None - DBClientConnectionsWaitTimeName = attribute.Key("db.client.connections.wait_time") - DBClientConnectionsWaitTimeUnit = attribute.Key("ms") - DBClientConnectionsWaitTimeDescription = attribute.Key("The time it took to obtain an open connection from the pool") + // Stability: Experimental + DBClientConnectionsWaitTimeName = "db.client.connections.wait_time" + DBClientConnectionsWaitTimeUnit = "ms" + DBClientConnectionsWaitTimeDescription = "The time it took to obtain an open connection from the pool" // DBClientConnectionsUseTime is the metric conforming to the // "db.client.connections.use_time" semantic conventions. It represents the - // time between borrowing a connection and returning it to the pool + // time between borrowing a connection and returning it to the pool. // Instrument: histogram // Unit: ms - // Stability: None - DBClientConnectionsUseTimeName = attribute.Key("db.client.connections.use_time") - DBClientConnectionsUseTimeUnit = attribute.Key("ms") - DBClientConnectionsUseTimeDescription = attribute.Key("The time between borrowing a connection and returning it to the pool") + // Stability: Experimental + DBClientConnectionsUseTimeName = "db.client.connections.use_time" + DBClientConnectionsUseTimeUnit = "ms" + DBClientConnectionsUseTimeDescription = "The time between borrowing a connection and returning it to the pool" // AspnetcoreRoutingMatchAttempts is the metric conforming to the // "aspnetcore.routing.match_attempts" semantic conventions. It represents the - // number of requests that were attempted to be matched to an endpoint. + // number of requests that were attempted to be matched to an endpoint.. // Instrument: counter // Unit: {match_attempt} - // Stability: None - AspnetcoreRoutingMatchAttemptsName = attribute.Key("aspnetcore.routing.match_attempts") - AspnetcoreRoutingMatchAttemptsUnit = attribute.Key("{match_attempt}") - AspnetcoreRoutingMatchAttemptsDescription = attribute.Key("Number of requests that were attempted to be matched to an endpoint.") + // Stability: Experimental + AspnetcoreRoutingMatchAttemptsName = "aspnetcore.routing.match_attempts" + AspnetcoreRoutingMatchAttemptsUnit = "{match_attempt}" + AspnetcoreRoutingMatchAttemptsDescription = "Number of requests that were attempted to be matched to an endpoint." // AspnetcoreDiagnosticsExceptions is the metric conforming to the // "aspnetcore.diagnostics.exceptions" semantic conventions. It represents the - // number of exceptions caught by exception handling middleware. + // number of exceptions caught by exception handling middleware.. // Instrument: counter // Unit: {exception} - // Stability: None - AspnetcoreDiagnosticsExceptionsName = attribute.Key("aspnetcore.diagnostics.exceptions") - AspnetcoreDiagnosticsExceptionsUnit = attribute.Key("{exception}") - AspnetcoreDiagnosticsExceptionsDescription = attribute.Key("Number of exceptions caught by exception handling middleware.") + // Stability: Experimental + AspnetcoreDiagnosticsExceptionsName = "aspnetcore.diagnostics.exceptions" + AspnetcoreDiagnosticsExceptionsUnit = "{exception}" + AspnetcoreDiagnosticsExceptionsDescription = "Number of exceptions caught by exception handling middleware." // AspnetcoreRateLimitingActiveRequestLeases is the metric conforming to the // "aspnetcore.rate_limiting.active_request_leases" semantic conventions. It // represents the number of requests that are currently active on the server - // that hold a rate limiting lease. + // that hold a rate limiting lease.. // Instrument: updowncounter // Unit: {request} - // Stability: None - AspnetcoreRateLimitingActiveRequestLeasesName = attribute.Key("aspnetcore.rate_limiting.active_request_leases") - AspnetcoreRateLimitingActiveRequestLeasesUnit = attribute.Key("{request}") - AspnetcoreRateLimitingActiveRequestLeasesDescription = attribute.Key("Number of requests that are currently active on the server that hold a rate limiting lease.") + // Stability: Experimental + AspnetcoreRateLimitingActiveRequestLeasesName = "aspnetcore.rate_limiting.active_request_leases" + AspnetcoreRateLimitingActiveRequestLeasesUnit = "{request}" + AspnetcoreRateLimitingActiveRequestLeasesDescription = "Number of requests that are currently active on the server that hold a rate limiting lease." // AspnetcoreRateLimitingRequestLeaseDuration is the metric conforming to the // "aspnetcore.rate_limiting.request_lease.duration" semantic conventions. It // represents the duration of rate limiting lease held by requests on the - // server. + // server.. // Instrument: histogram // Unit: s - // Stability: None - AspnetcoreRateLimitingRequestLeaseDurationName = attribute.Key("aspnetcore.rate_limiting.request_lease.duration") - AspnetcoreRateLimitingRequestLeaseDurationUnit = attribute.Key("s") - AspnetcoreRateLimitingRequestLeaseDurationDescription = attribute.Key("The duration of rate limiting lease held by requests on the server.") + // Stability: Experimental + AspnetcoreRateLimitingRequestLeaseDurationName = "aspnetcore.rate_limiting.request_lease.duration" + AspnetcoreRateLimitingRequestLeaseDurationUnit = "s" + AspnetcoreRateLimitingRequestLeaseDurationDescription = "The duration of rate limiting lease held by requests on the server." // AspnetcoreRateLimitingRequestTimeInQueue is the metric conforming to the // "aspnetcore.rate_limiting.request.time_in_queue" semantic conventions. It // represents the time the request spent in a queue waiting to acquire a rate - // limiting lease. + // limiting lease.. // Instrument: histogram // Unit: s - // Stability: None - AspnetcoreRateLimitingRequestTimeInQueueName = attribute.Key("aspnetcore.rate_limiting.request.time_in_queue") - AspnetcoreRateLimitingRequestTimeInQueueUnit = attribute.Key("s") - AspnetcoreRateLimitingRequestTimeInQueueDescription = attribute.Key("The time the request spent in a queue waiting to acquire a rate limiting lease.") + // Stability: Experimental + AspnetcoreRateLimitingRequestTimeInQueueName = "aspnetcore.rate_limiting.request.time_in_queue" + AspnetcoreRateLimitingRequestTimeInQueueUnit = "s" + AspnetcoreRateLimitingRequestTimeInQueueDescription = "The time the request spent in a queue waiting to acquire a rate limiting lease." // AspnetcoreRateLimitingQueuedRequests is the metric conforming to the // "aspnetcore.rate_limiting.queued_requests" semantic conventions. It // represents the number of requests that are currently queued, waiting to - // acquire a rate limiting lease. + // acquire a rate limiting lease.. // Instrument: updowncounter // Unit: {request} - // Stability: None - AspnetcoreRateLimitingQueuedRequestsName = attribute.Key("aspnetcore.rate_limiting.queued_requests") - AspnetcoreRateLimitingQueuedRequestsUnit = attribute.Key("{request}") - AspnetcoreRateLimitingQueuedRequestsDescription = attribute.Key("Number of requests that are currently queued, waiting to acquire a rate limiting lease.") + // Stability: Experimental + AspnetcoreRateLimitingQueuedRequestsName = "aspnetcore.rate_limiting.queued_requests" + AspnetcoreRateLimitingQueuedRequestsUnit = "{request}" + AspnetcoreRateLimitingQueuedRequestsDescription = "Number of requests that are currently queued, waiting to acquire a rate limiting lease." // AspnetcoreRateLimitingRequests is the metric conforming to the // "aspnetcore.rate_limiting.requests" semantic conventions. It represents the - // number of requests that tried to acquire a rate limiting lease. + // number of requests that tried to acquire a rate limiting lease.. // Instrument: counter // Unit: {request} - // Stability: None - AspnetcoreRateLimitingRequestsName = attribute.Key("aspnetcore.rate_limiting.requests") - AspnetcoreRateLimitingRequestsUnit = attribute.Key("{request}") - AspnetcoreRateLimitingRequestsDescription = attribute.Key("Number of requests that tried to acquire a rate limiting lease.") + // Stability: Experimental + AspnetcoreRateLimitingRequestsName = "aspnetcore.rate_limiting.requests" + AspnetcoreRateLimitingRequestsUnit = "{request}" + AspnetcoreRateLimitingRequestsDescription = "Number of requests that tried to acquire a rate limiting lease." // DNSLookupDuration is the metric conforming to the "dns.lookup.duration" // semantic conventions. It represents the measures the time taken to perform a - // DNS lookup. + // DNS lookup.. // Instrument: histogram // Unit: s - // Stability: None - DNSLookupDurationName = attribute.Key("dns.lookup.duration") - DNSLookupDurationUnit = attribute.Key("s") - DNSLookupDurationDescription = attribute.Key("Measures the time taken to perform a DNS lookup.") + // Stability: Experimental + DNSLookupDurationName = "dns.lookup.duration" + DNSLookupDurationUnit = "s" + DNSLookupDurationDescription = "Measures the time taken to perform a DNS lookup." // HTTPClientOpenConnections is the metric conforming to the // "http.client.open_connections" semantic conventions. It represents the // number of outbound HTTP connections that are currently active or idle on the - // client. + // client.. // Instrument: updowncounter // Unit: {connection} - // Stability: None - HTTPClientOpenConnectionsName = attribute.Key("http.client.open_connections") - HTTPClientOpenConnectionsUnit = attribute.Key("{connection}") - HTTPClientOpenConnectionsDescription = attribute.Key("Number of outbound HTTP connections that are currently active or idle on the client.") + // Stability: Experimental + HTTPClientOpenConnectionsName = "http.client.open_connections" + HTTPClientOpenConnectionsUnit = "{connection}" + HTTPClientOpenConnectionsDescription = "Number of outbound HTTP connections that are currently active or idle on the client." // HTTPClientConnectionDuration is the metric conforming to the // "http.client.connection.duration" semantic conventions. It represents the - // duration of the successfully established outbound HTTP connections. + // duration of the successfully established outbound HTTP connections.. // Instrument: histogram // Unit: s - // Stability: None - HTTPClientConnectionDurationName = attribute.Key("http.client.connection.duration") - HTTPClientConnectionDurationUnit = attribute.Key("s") - HTTPClientConnectionDurationDescription = attribute.Key("The duration of the successfully established outbound HTTP connections.") + // Stability: Experimental + HTTPClientConnectionDurationName = "http.client.connection.duration" + HTTPClientConnectionDurationUnit = "s" + HTTPClientConnectionDurationDescription = "The duration of the successfully established outbound HTTP connections." // HTTPClientActiveRequests is the metric conforming to the // "http.client.active_requests" semantic conventions. It represents the number - // of active HTTP requests. + // of active HTTP requests.. // Instrument: updowncounter // Unit: {request} - // Stability: None - HTTPClientActiveRequestsName = attribute.Key("http.client.active_requests") - HTTPClientActiveRequestsUnit = attribute.Key("{request}") - HTTPClientActiveRequestsDescription = attribute.Key("Number of active HTTP requests.") + // Stability: Experimental + HTTPClientActiveRequestsName = "http.client.active_requests" + HTTPClientActiveRequestsUnit = "{request}" + HTTPClientActiveRequestsDescription = "Number of active HTTP requests." // HTTPClientRequestTimeInQueue is the metric conforming to the // "http.client.request.time_in_queue" semantic conventions. It represents the // amount of time requests spent on a queue waiting for an available - // connection. + // connection.. // Instrument: histogram // Unit: s - // Stability: None - HTTPClientRequestTimeInQueueName = attribute.Key("http.client.request.time_in_queue") - HTTPClientRequestTimeInQueueUnit = attribute.Key("s") - HTTPClientRequestTimeInQueueDescription = attribute.Key("The amount of time requests spent on a queue waiting for an available connection.") + // Stability: Experimental + HTTPClientRequestTimeInQueueName = "http.client.request.time_in_queue" + HTTPClientRequestTimeInQueueUnit = "s" + HTTPClientRequestTimeInQueueDescription = "The amount of time requests spent on a queue waiting for an available connection." // KestrelActiveConnections is the metric conforming to the // "kestrel.active_connections" semantic conventions. It represents the number - // of connections that are currently active on the server. + // of connections that are currently active on the server.. // Instrument: updowncounter // Unit: {connection} - // Stability: None - KestrelActiveConnectionsName = attribute.Key("kestrel.active_connections") - KestrelActiveConnectionsUnit = attribute.Key("{connection}") - KestrelActiveConnectionsDescription = attribute.Key("Number of connections that are currently active on the server.") + // Stability: Experimental + KestrelActiveConnectionsName = "kestrel.active_connections" + KestrelActiveConnectionsUnit = "{connection}" + KestrelActiveConnectionsDescription = "Number of connections that are currently active on the server." // KestrelConnectionDuration is the metric conforming to the // "kestrel.connection.duration" semantic conventions. It represents the - // duration of connections on the server. + // duration of connections on the server.. // Instrument: histogram // Unit: s - // Stability: None - KestrelConnectionDurationName = attribute.Key("kestrel.connection.duration") - KestrelConnectionDurationUnit = attribute.Key("s") - KestrelConnectionDurationDescription = attribute.Key("The duration of connections on the server.") + // Stability: Experimental + KestrelConnectionDurationName = "kestrel.connection.duration" + KestrelConnectionDurationUnit = "s" + KestrelConnectionDurationDescription = "The duration of connections on the server." // KestrelRejectedConnections is the metric conforming to the // "kestrel.rejected_connections" semantic conventions. It represents the - // number of connections rejected by the server. + // number of connections rejected by the server.. // Instrument: counter // Unit: {connection} - // Stability: None - KestrelRejectedConnectionsName = attribute.Key("kestrel.rejected_connections") - KestrelRejectedConnectionsUnit = attribute.Key("{connection}") - KestrelRejectedConnectionsDescription = attribute.Key("Number of connections rejected by the server.") + // Stability: Experimental + KestrelRejectedConnectionsName = "kestrel.rejected_connections" + KestrelRejectedConnectionsUnit = "{connection}" + KestrelRejectedConnectionsDescription = "Number of connections rejected by the server." // KestrelQueuedConnections is the metric conforming to the // "kestrel.queued_connections" semantic conventions. It represents the number - // of connections that are currently queued and are waiting to start. + // of connections that are currently queued and are waiting to start.. // Instrument: updowncounter // Unit: {connection} - // Stability: None - KestrelQueuedConnectionsName = attribute.Key("kestrel.queued_connections") - KestrelQueuedConnectionsUnit = attribute.Key("{connection}") - KestrelQueuedConnectionsDescription = attribute.Key("Number of connections that are currently queued and are waiting to start.") + // Stability: Experimental + KestrelQueuedConnectionsName = "kestrel.queued_connections" + KestrelQueuedConnectionsUnit = "{connection}" + KestrelQueuedConnectionsDescription = "Number of connections that are currently queued and are waiting to start." // KestrelQueuedRequests is the metric conforming to the // "kestrel.queued_requests" semantic conventions. It represents the number of // HTTP requests on multiplexed connections (HTTP/2 and HTTP/3) that are - // currently queued and are waiting to start. + // currently queued and are waiting to start.. // Instrument: updowncounter // Unit: {request} - // Stability: None - KestrelQueuedRequestsName = attribute.Key("kestrel.queued_requests") - KestrelQueuedRequestsUnit = attribute.Key("{request}") - KestrelQueuedRequestsDescription = attribute.Key("Number of HTTP requests on multiplexed connections (HTTP/2 and HTTP/3) that are currently queued and are waiting to start.") + // Stability: Experimental + KestrelQueuedRequestsName = "kestrel.queued_requests" + KestrelQueuedRequestsUnit = "{request}" + KestrelQueuedRequestsDescription = "Number of HTTP requests on multiplexed connections (HTTP/2 and HTTP/3) that are currently queued and are waiting to start." // KestrelUpgradedConnections is the metric conforming to the // "kestrel.upgraded_connections" semantic conventions. It represents the - // number of connections that are currently upgraded (WebSockets). . + // number of connections that are currently upgraded (WebSockets). .. // Instrument: updowncounter // Unit: {connection} - // Stability: None - KestrelUpgradedConnectionsName = attribute.Key("kestrel.upgraded_connections") - KestrelUpgradedConnectionsUnit = attribute.Key("{connection}") - KestrelUpgradedConnectionsDescription = attribute.Key("Number of connections that are currently upgraded (WebSockets). .") + // Stability: Experimental + KestrelUpgradedConnectionsName = "kestrel.upgraded_connections" + KestrelUpgradedConnectionsUnit = "{connection}" + KestrelUpgradedConnectionsDescription = "Number of connections that are currently upgraded (WebSockets). ." // KestrelTLSHandshakeDuration is the metric conforming to the // "kestrel.tls_handshake.duration" semantic conventions. It represents the - // duration of TLS handshakes on the server. + // duration of TLS handshakes on the server.. // Instrument: histogram // Unit: s - // Stability: None - KestrelTLSHandshakeDurationName = attribute.Key("kestrel.tls_handshake.duration") - KestrelTLSHandshakeDurationUnit = attribute.Key("s") - KestrelTLSHandshakeDurationDescription = attribute.Key("The duration of TLS handshakes on the server.") + // Stability: Experimental + KestrelTLSHandshakeDurationName = "kestrel.tls_handshake.duration" + KestrelTLSHandshakeDurationUnit = "s" + KestrelTLSHandshakeDurationDescription = "The duration of TLS handshakes on the server." // KestrelActiveTLSHandshakes is the metric conforming to the // "kestrel.active_tls_handshakes" semantic conventions. It represents the - // number of TLS handshakes that are currently in progress on the server. + // number of TLS handshakes that are currently in progress on the server.. // Instrument: updowncounter // Unit: {handshake} - // Stability: None - KestrelActiveTLSHandshakesName = attribute.Key("kestrel.active_tls_handshakes") - KestrelActiveTLSHandshakesUnit = attribute.Key("{handshake}") - KestrelActiveTLSHandshakesDescription = attribute.Key("Number of TLS handshakes that are currently in progress on the server.") + // Stability: Experimental + KestrelActiveTLSHandshakesName = "kestrel.active_tls_handshakes" + KestrelActiveTLSHandshakesUnit = "{handshake}" + KestrelActiveTLSHandshakesDescription = "Number of TLS handshakes that are currently in progress on the server." // SignalrServerConnectionDuration is the metric conforming to the // "signalr.server.connection.duration" semantic conventions. It represents the - // duration of connections on the server. + // duration of connections on the server.. // Instrument: histogram // Unit: s - // Stability: None - SignalrServerConnectionDurationName = attribute.Key("signalr.server.connection.duration") - SignalrServerConnectionDurationUnit = attribute.Key("s") - SignalrServerConnectionDurationDescription = attribute.Key("The duration of connections on the server.") + // Stability: Experimental + SignalrServerConnectionDurationName = "signalr.server.connection.duration" + SignalrServerConnectionDurationUnit = "s" + SignalrServerConnectionDurationDescription = "The duration of connections on the server." // SignalrServerActiveConnections is the metric conforming to the // "signalr.server.active_connections" semantic conventions. It represents the - // number of connections that are currently active on the server. + // number of connections that are currently active on the server.. // Instrument: updowncounter // Unit: {connection} - // Stability: None - SignalrServerActiveConnectionsName = attribute.Key("signalr.server.active_connections") - SignalrServerActiveConnectionsUnit = attribute.Key("{connection}") - SignalrServerActiveConnectionsDescription = attribute.Key("Number of connections that are currently active on the server.") + // Stability: Experimental + SignalrServerActiveConnectionsName = "signalr.server.active_connections" + SignalrServerActiveConnectionsUnit = "{connection}" + SignalrServerActiveConnectionsDescription = "Number of connections that are currently active on the server." // FaaSInvokeDuration is the metric conforming to the "faas.invoke_duration" // semantic conventions. It represents the measures the duration of the - // function's logic execution + // function's logic execution. // Instrument: histogram // Unit: s - // Stability: None - FaaSInvokeDurationName = attribute.Key("faas.invoke_duration") - FaaSInvokeDurationUnit = attribute.Key("s") - FaaSInvokeDurationDescription = attribute.Key("Measures the duration of the function's logic execution") + // Stability: Experimental + FaaSInvokeDurationName = "faas.invoke_duration" + FaaSInvokeDurationUnit = "s" + FaaSInvokeDurationDescription = "Measures the duration of the function's logic execution" // FaaSInitDuration is the metric conforming to the "faas.init_duration" // semantic conventions. It represents the measures the duration of the - // function's initialization, such as a cold start + // function's initialization, such as a cold start. // Instrument: histogram // Unit: s - // Stability: None - FaaSInitDurationName = attribute.Key("faas.init_duration") - FaaSInitDurationUnit = attribute.Key("s") - FaaSInitDurationDescription = attribute.Key("Measures the duration of the function's initialization, such as a cold start") + // Stability: Experimental + FaaSInitDurationName = "faas.init_duration" + FaaSInitDurationUnit = "s" + FaaSInitDurationDescription = "Measures the duration of the function's initialization, such as a cold start" // FaaSColdstarts is the metric conforming to the "faas.coldstarts" semantic - // conventions. It represents the number of invocation cold starts + // conventions. It represents the number of invocation cold starts. // Instrument: counter // Unit: {coldstart} - // Stability: None - FaaSColdstartsName = attribute.Key("faas.coldstarts") - FaaSColdstartsUnit = attribute.Key("{coldstart}") - FaaSColdstartsDescription = attribute.Key("Number of invocation cold starts") + // Stability: Experimental + FaaSColdstartsName = "faas.coldstarts" + FaaSColdstartsUnit = "{coldstart}" + FaaSColdstartsDescription = "Number of invocation cold starts" // FaaSErrors is the metric conforming to the "faas.errors" semantic - // conventions. It represents the number of invocation errors + // conventions. It represents the number of invocation errors. // Instrument: counter // Unit: {error} - // Stability: None - FaaSErrorsName = attribute.Key("faas.errors") - FaaSErrorsUnit = attribute.Key("{error}") - FaaSErrorsDescription = attribute.Key("Number of invocation errors") + // Stability: Experimental + FaaSErrorsName = "faas.errors" + FaaSErrorsUnit = "{error}" + FaaSErrorsDescription = "Number of invocation errors" // FaaSInvocations is the metric conforming to the "faas.invocations" semantic - // conventions. It represents the number of successful invocations + // conventions. It represents the number of successful invocations. // Instrument: counter // Unit: {invocation} - // Stability: None - FaaSInvocationsName = attribute.Key("faas.invocations") - FaaSInvocationsUnit = attribute.Key("{invocation}") - FaaSInvocationsDescription = attribute.Key("Number of successful invocations") + // Stability: Experimental + FaaSInvocationsName = "faas.invocations" + FaaSInvocationsUnit = "{invocation}" + FaaSInvocationsDescription = "Number of successful invocations" // FaaSTimeouts is the metric conforming to the "faas.timeouts" semantic - // conventions. It represents the number of invocation timeouts + // conventions. It represents the number of invocation timeouts. // Instrument: counter // Unit: {timeout} - // Stability: None - FaaSTimeoutsName = attribute.Key("faas.timeouts") - FaaSTimeoutsUnit = attribute.Key("{timeout}") - FaaSTimeoutsDescription = attribute.Key("Number of invocation timeouts") + // Stability: Experimental + FaaSTimeoutsName = "faas.timeouts" + FaaSTimeoutsUnit = "{timeout}" + FaaSTimeoutsDescription = "Number of invocation timeouts" // FaaSMemUsage is the metric conforming to the "faas.mem_usage" semantic // conventions. It represents the distribution of max memory usage per - // invocation + // invocation. // Instrument: histogram // Unit: By - // Stability: None - FaaSMemUsageName = attribute.Key("faas.mem_usage") - FaaSMemUsageUnit = attribute.Key("By") - FaaSMemUsageDescription = attribute.Key("Distribution of max memory usage per invocation") + // Stability: Experimental + FaaSMemUsageName = "faas.mem_usage" + FaaSMemUsageUnit = "By" + FaaSMemUsageDescription = "Distribution of max memory usage per invocation" // FaaSCPUUsage is the metric conforming to the "faas.cpu_usage" semantic - // conventions. It represents the distribution of CPU usage per invocation + // conventions. It represents the distribution of CPU usage per invocation. // Instrument: histogram // Unit: s - // Stability: None - FaaSCPUUsageName = attribute.Key("faas.cpu_usage") - FaaSCPUUsageUnit = attribute.Key("s") - FaaSCPUUsageDescription = attribute.Key("Distribution of CPU usage per invocation") + // Stability: Experimental + FaaSCPUUsageName = "faas.cpu_usage" + FaaSCPUUsageUnit = "s" + FaaSCPUUsageDescription = "Distribution of CPU usage per invocation" // FaaSNetIo is the metric conforming to the "faas.net_io" semantic - // conventions. It represents the distribution of net I/O usage per invocation + // conventions. It represents the distribution of net I/O usage per invocation. // Instrument: histogram // Unit: By - // Stability: None - FaaSNetIoName = attribute.Key("faas.net_io") - FaaSNetIoUnit = attribute.Key("By") - FaaSNetIoDescription = attribute.Key("Distribution of net I/O usage per invocation") + // Stability: Experimental + FaaSNetIoName = "faas.net_io" + FaaSNetIoUnit = "By" + FaaSNetIoDescription = "Distribution of net I/O usage per invocation" // HTTPServerRequestDuration is the metric conforming to the // "http.server.request.duration" semantic conventions. It represents the - // duration of HTTP server requests. + // duration of HTTP server requests.. // Instrument: histogram // Unit: s - // Stability: StabilityLevel.STABLE - HTTPServerRequestDurationName = attribute.Key("http.server.request.duration") - HTTPServerRequestDurationUnit = attribute.Key("s") - HTTPServerRequestDurationDescription = attribute.Key("Duration of HTTP server requests.") + // Stability: Stable + HTTPServerRequestDurationName = "http.server.request.duration" + HTTPServerRequestDurationUnit = "s" + HTTPServerRequestDurationDescription = "Duration of HTTP server requests." // HTTPServerActiveRequests is the metric conforming to the // "http.server.active_requests" semantic conventions. It represents the number - // of active HTTP server requests. + // of active HTTP server requests.. // Instrument: updowncounter // Unit: {request} - // Stability: None - HTTPServerActiveRequestsName = attribute.Key("http.server.active_requests") - HTTPServerActiveRequestsUnit = attribute.Key("{request}") - HTTPServerActiveRequestsDescription = attribute.Key("Number of active HTTP server requests.") + // Stability: Experimental + HTTPServerActiveRequestsName = "http.server.active_requests" + HTTPServerActiveRequestsUnit = "{request}" + HTTPServerActiveRequestsDescription = "Number of active HTTP server requests." // HTTPServerRequestBodySize is the metric conforming to the // "http.server.request.body.size" semantic conventions. It represents the size - // of HTTP server request bodies. + // of HTTP server request bodies.. // Instrument: histogram // Unit: By - // Stability: None - HTTPServerRequestBodySizeName = attribute.Key("http.server.request.body.size") - HTTPServerRequestBodySizeUnit = attribute.Key("By") - HTTPServerRequestBodySizeDescription = attribute.Key("Size of HTTP server request bodies.") + // Stability: Experimental + HTTPServerRequestBodySizeName = "http.server.request.body.size" + HTTPServerRequestBodySizeUnit = "By" + HTTPServerRequestBodySizeDescription = "Size of HTTP server request bodies." // HTTPServerResponseBodySize is the metric conforming to the // "http.server.response.body.size" semantic conventions. It represents the - // size of HTTP server response bodies. + // size of HTTP server response bodies.. // Instrument: histogram // Unit: By - // Stability: None - HTTPServerResponseBodySizeName = attribute.Key("http.server.response.body.size") - HTTPServerResponseBodySizeUnit = attribute.Key("By") - HTTPServerResponseBodySizeDescription = attribute.Key("Size of HTTP server response bodies.") + // Stability: Experimental + HTTPServerResponseBodySizeName = "http.server.response.body.size" + HTTPServerResponseBodySizeUnit = "By" + HTTPServerResponseBodySizeDescription = "Size of HTTP server response bodies." // HTTPClientRequestDuration is the metric conforming to the // "http.client.request.duration" semantic conventions. It represents the - // duration of HTTP client requests. + // duration of HTTP client requests.. // Instrument: histogram // Unit: s - // Stability: StabilityLevel.STABLE - HTTPClientRequestDurationName = attribute.Key("http.client.request.duration") - HTTPClientRequestDurationUnit = attribute.Key("s") - HTTPClientRequestDurationDescription = attribute.Key("Duration of HTTP client requests.") + // Stability: Stable + HTTPClientRequestDurationName = "http.client.request.duration" + HTTPClientRequestDurationUnit = "s" + HTTPClientRequestDurationDescription = "Duration of HTTP client requests." // HTTPClientRequestBodySize is the metric conforming to the // "http.client.request.body.size" semantic conventions. It represents the size - // of HTTP client request bodies. + // of HTTP client request bodies.. // Instrument: histogram // Unit: By - // Stability: None - HTTPClientRequestBodySizeName = attribute.Key("http.client.request.body.size") - HTTPClientRequestBodySizeUnit = attribute.Key("By") - HTTPClientRequestBodySizeDescription = attribute.Key("Size of HTTP client request bodies.") + // Stability: Experimental + HTTPClientRequestBodySizeName = "http.client.request.body.size" + HTTPClientRequestBodySizeUnit = "By" + HTTPClientRequestBodySizeDescription = "Size of HTTP client request bodies." // HTTPClientResponseBodySize is the metric conforming to the // "http.client.response.body.size" semantic conventions. It represents the - // size of HTTP client response bodies. + // size of HTTP client response bodies.. // Instrument: histogram // Unit: By - // Stability: None - HTTPClientResponseBodySizeName = attribute.Key("http.client.response.body.size") - HTTPClientResponseBodySizeUnit = attribute.Key("By") - HTTPClientResponseBodySizeDescription = attribute.Key("Size of HTTP client response bodies.") + // Stability: Experimental + HTTPClientResponseBodySizeName = "http.client.response.body.size" + HTTPClientResponseBodySizeUnit = "By" + HTTPClientResponseBodySizeDescription = "Size of HTTP client response bodies." // JvmMemoryInit is the metric conforming to the "jvm.memory.init" semantic - // conventions. It represents the measure of initial memory requested. + // conventions. It represents the measure of initial memory requested.. // Instrument: updowncounter // Unit: By - // Stability: None - JvmMemoryInitName = attribute.Key("jvm.memory.init") - JvmMemoryInitUnit = attribute.Key("By") - JvmMemoryInitDescription = attribute.Key("Measure of initial memory requested.") + // Stability: Experimental + JvmMemoryInitName = "jvm.memory.init" + JvmMemoryInitUnit = "By" + JvmMemoryInitDescription = "Measure of initial memory requested." // JvmSystemCPUUtilization is the metric conforming to the // "jvm.system.cpu.utilization" semantic conventions. It represents the recent - // CPU utilization for the whole system as reported by the JVM. + // CPU utilization for the whole system as reported by the JVM.. // Instrument: gauge // Unit: 1 - // Stability: None - JvmSystemCPUUtilizationName = attribute.Key("jvm.system.cpu.utilization") - JvmSystemCPUUtilizationUnit = attribute.Key("1") - JvmSystemCPUUtilizationDescription = attribute.Key("Recent CPU utilization for the whole system as reported by the JVM.") + // Stability: Experimental + JvmSystemCPUUtilizationName = "jvm.system.cpu.utilization" + JvmSystemCPUUtilizationUnit = "1" + JvmSystemCPUUtilizationDescription = "Recent CPU utilization for the whole system as reported by the JVM." // JvmSystemCPULoad1m is the metric conforming to the "jvm.system.cpu.load_1m" // semantic conventions. It represents the average CPU load of the whole system - // for the last minute as reported by the JVM. + // for the last minute as reported by the JVM.. // Instrument: gauge // Unit: {run_queue_item} - // Stability: None - JvmSystemCPULoad1mName = attribute.Key("jvm.system.cpu.load_1m") - JvmSystemCPULoad1mUnit = attribute.Key("{run_queue_item}") - JvmSystemCPULoad1mDescription = attribute.Key("Average CPU load of the whole system for the last minute as reported by the JVM.") + // Stability: Experimental + JvmSystemCPULoad1mName = "jvm.system.cpu.load_1m" + JvmSystemCPULoad1mUnit = "{run_queue_item}" + JvmSystemCPULoad1mDescription = "Average CPU load of the whole system for the last minute as reported by the JVM." // JvmBufferMemoryUsage is the metric conforming to the // "jvm.buffer.memory.usage" semantic conventions. It represents the measure of - // memory used by buffers. + // memory used by buffers.. // Instrument: updowncounter // Unit: By - // Stability: None - JvmBufferMemoryUsageName = attribute.Key("jvm.buffer.memory.usage") - JvmBufferMemoryUsageUnit = attribute.Key("By") - JvmBufferMemoryUsageDescription = attribute.Key("Measure of memory used by buffers.") + // Stability: Experimental + JvmBufferMemoryUsageName = "jvm.buffer.memory.usage" + JvmBufferMemoryUsageUnit = "By" + JvmBufferMemoryUsageDescription = "Measure of memory used by buffers." // JvmBufferMemoryLimit is the metric conforming to the // "jvm.buffer.memory.limit" semantic conventions. It represents the measure of - // total memory capacity of buffers. + // total memory capacity of buffers.. // Instrument: updowncounter // Unit: By - // Stability: None - JvmBufferMemoryLimitName = attribute.Key("jvm.buffer.memory.limit") - JvmBufferMemoryLimitUnit = attribute.Key("By") - JvmBufferMemoryLimitDescription = attribute.Key("Measure of total memory capacity of buffers.") + // Stability: Experimental + JvmBufferMemoryLimitName = "jvm.buffer.memory.limit" + JvmBufferMemoryLimitUnit = "By" + JvmBufferMemoryLimitDescription = "Measure of total memory capacity of buffers." // JvmBufferCount is the metric conforming to the "jvm.buffer.count" semantic - // conventions. It represents the number of buffers in the pool. + // conventions. It represents the number of buffers in the pool.. // Instrument: updowncounter // Unit: {buffer} - // Stability: None - JvmBufferCountName = attribute.Key("jvm.buffer.count") - JvmBufferCountUnit = attribute.Key("{buffer}") - JvmBufferCountDescription = attribute.Key("Number of buffers in the pool.") + // Stability: Experimental + JvmBufferCountName = "jvm.buffer.count" + JvmBufferCountUnit = "{buffer}" + JvmBufferCountDescription = "Number of buffers in the pool." // JvmMemoryUsed is the metric conforming to the "jvm.memory.used" semantic - // conventions. It represents the measure of memory used. + // conventions. It represents the measure of memory used.. // Instrument: updowncounter // Unit: By - // Stability: StabilityLevel.STABLE - JvmMemoryUsedName = attribute.Key("jvm.memory.used") - JvmMemoryUsedUnit = attribute.Key("By") - JvmMemoryUsedDescription = attribute.Key("Measure of memory used.") + // Stability: Stable + JvmMemoryUsedName = "jvm.memory.used" + JvmMemoryUsedUnit = "By" + JvmMemoryUsedDescription = "Measure of memory used." // JvmMemoryCommitted is the metric conforming to the "jvm.memory.committed" - // semantic conventions. It represents the measure of memory committed. + // semantic conventions. It represents the measure of memory committed.. // Instrument: updowncounter // Unit: By - // Stability: StabilityLevel.STABLE - JvmMemoryCommittedName = attribute.Key("jvm.memory.committed") - JvmMemoryCommittedUnit = attribute.Key("By") - JvmMemoryCommittedDescription = attribute.Key("Measure of memory committed.") + // Stability: Stable + JvmMemoryCommittedName = "jvm.memory.committed" + JvmMemoryCommittedUnit = "By" + JvmMemoryCommittedDescription = "Measure of memory committed." // JvmMemoryLimit is the metric conforming to the "jvm.memory.limit" semantic - // conventions. It represents the measure of max obtainable memory. + // conventions. It represents the measure of max obtainable memory.. // Instrument: updowncounter // Unit: By - // Stability: StabilityLevel.STABLE - JvmMemoryLimitName = attribute.Key("jvm.memory.limit") - JvmMemoryLimitUnit = attribute.Key("By") - JvmMemoryLimitDescription = attribute.Key("Measure of max obtainable memory.") + // Stability: Stable + JvmMemoryLimitName = "jvm.memory.limit" + JvmMemoryLimitUnit = "By" + JvmMemoryLimitDescription = "Measure of max obtainable memory." // JvmMemoryUsedAfterLastGc is the metric conforming to the // "jvm.memory.used_after_last_gc" semantic conventions. It represents the // measure of memory used, as measured after the most recent garbage collection - // event on this pool. + // event on this pool.. // Instrument: updowncounter // Unit: By - // Stability: StabilityLevel.STABLE - JvmMemoryUsedAfterLastGcName = attribute.Key("jvm.memory.used_after_last_gc") - JvmMemoryUsedAfterLastGcUnit = attribute.Key("By") - JvmMemoryUsedAfterLastGcDescription = attribute.Key("Measure of memory used, as measured after the most recent garbage collection event on this pool.") + // Stability: Stable + JvmMemoryUsedAfterLastGcName = "jvm.memory.used_after_last_gc" + JvmMemoryUsedAfterLastGcUnit = "By" + JvmMemoryUsedAfterLastGcDescription = "Measure of memory used, as measured after the most recent garbage collection event on this pool." // JvmGcDuration is the metric conforming to the "jvm.gc.duration" semantic - // conventions. It represents the duration of JVM garbage collection actions. + // conventions. It represents the duration of JVM garbage collection actions.. // Instrument: histogram // Unit: s - // Stability: StabilityLevel.STABLE - JvmGcDurationName = attribute.Key("jvm.gc.duration") - JvmGcDurationUnit = attribute.Key("s") - JvmGcDurationDescription = attribute.Key("Duration of JVM garbage collection actions.") + // Stability: Stable + JvmGcDurationName = "jvm.gc.duration" + JvmGcDurationUnit = "s" + JvmGcDurationDescription = "Duration of JVM garbage collection actions." // JvmThreadCount is the metric conforming to the "jvm.thread.count" semantic - // conventions. It represents the number of executing platform threads. + // conventions. It represents the number of executing platform threads.. // Instrument: updowncounter // Unit: {thread} - // Stability: StabilityLevel.STABLE - JvmThreadCountName = attribute.Key("jvm.thread.count") - JvmThreadCountUnit = attribute.Key("{thread}") - JvmThreadCountDescription = attribute.Key("Number of executing platform threads.") + // Stability: Stable + JvmThreadCountName = "jvm.thread.count" + JvmThreadCountUnit = "{thread}" + JvmThreadCountDescription = "Number of executing platform threads." // JvmClassLoaded is the metric conforming to the "jvm.class.loaded" semantic - // conventions. It represents the number of classes loaded since JVM start. + // conventions. It represents the number of classes loaded since JVM start.. // Instrument: counter // Unit: {class} - // Stability: StabilityLevel.STABLE - JvmClassLoadedName = attribute.Key("jvm.class.loaded") - JvmClassLoadedUnit = attribute.Key("{class}") - JvmClassLoadedDescription = attribute.Key("Number of classes loaded since JVM start.") + // Stability: Stable + JvmClassLoadedName = "jvm.class.loaded" + JvmClassLoadedUnit = "{class}" + JvmClassLoadedDescription = "Number of classes loaded since JVM start." // JvmClassUnloaded is the metric conforming to the "jvm.class.unloaded" // semantic conventions. It represents the number of classes unloaded since JVM - // start. + // start.. // Instrument: counter // Unit: {class} - // Stability: StabilityLevel.STABLE - JvmClassUnloadedName = attribute.Key("jvm.class.unloaded") - JvmClassUnloadedUnit = attribute.Key("{class}") - JvmClassUnloadedDescription = attribute.Key("Number of classes unloaded since JVM start.") + // Stability: Stable + JvmClassUnloadedName = "jvm.class.unloaded" + JvmClassUnloadedUnit = "{class}" + JvmClassUnloadedDescription = "Number of classes unloaded since JVM start." // JvmClassCount is the metric conforming to the "jvm.class.count" semantic - // conventions. It represents the number of classes currently loaded. + // conventions. It represents the number of classes currently loaded.. // Instrument: updowncounter // Unit: {class} - // Stability: StabilityLevel.STABLE - JvmClassCountName = attribute.Key("jvm.class.count") - JvmClassCountUnit = attribute.Key("{class}") - JvmClassCountDescription = attribute.Key("Number of classes currently loaded.") + // Stability: Stable + JvmClassCountName = "jvm.class.count" + JvmClassCountUnit = "{class}" + JvmClassCountDescription = "Number of classes currently loaded." // JvmCPUCount is the metric conforming to the "jvm.cpu.count" semantic // conventions. It represents the number of processors available to the Java - // virtual machine. + // virtual machine.. // Instrument: updowncounter // Unit: {cpu} - // Stability: StabilityLevel.STABLE - JvmCPUCountName = attribute.Key("jvm.cpu.count") - JvmCPUCountUnit = attribute.Key("{cpu}") - JvmCPUCountDescription = attribute.Key("Number of processors available to the Java virtual machine.") + // Stability: Stable + JvmCPUCountName = "jvm.cpu.count" + JvmCPUCountUnit = "{cpu}" + JvmCPUCountDescription = "Number of processors available to the Java virtual machine." // JvmCPUTime is the metric conforming to the "jvm.cpu.time" semantic // conventions. It represents the cPU time used by the process as reported by - // the JVM. + // the JVM.. // Instrument: counter // Unit: s - // Stability: StabilityLevel.STABLE - JvmCPUTimeName = attribute.Key("jvm.cpu.time") - JvmCPUTimeUnit = attribute.Key("s") - JvmCPUTimeDescription = attribute.Key("CPU time used by the process as reported by the JVM.") + // Stability: Stable + JvmCPUTimeName = "jvm.cpu.time" + JvmCPUTimeUnit = "s" + JvmCPUTimeDescription = "CPU time used by the process as reported by the JVM." // JvmCPURecentUtilization is the metric conforming to the // "jvm.cpu.recent_utilization" semantic conventions. It represents the recent - // CPU utilization for the process as reported by the JVM. + // CPU utilization for the process as reported by the JVM.. // Instrument: gauge // Unit: 1 - // Stability: StabilityLevel.STABLE - JvmCPURecentUtilizationName = attribute.Key("jvm.cpu.recent_utilization") - JvmCPURecentUtilizationUnit = attribute.Key("1") - JvmCPURecentUtilizationDescription = attribute.Key("Recent CPU utilization for the process as reported by the JVM.") + // Stability: Stable + JvmCPURecentUtilizationName = "jvm.cpu.recent_utilization" + JvmCPURecentUtilizationUnit = "1" + JvmCPURecentUtilizationDescription = "Recent CPU utilization for the process as reported by the JVM." // MessagingPublishDuration is the metric conforming to the // "messaging.publish.duration" semantic conventions. It represents the - // measures the duration of publish operation. + // measures the duration of publish operation.. // Instrument: histogram // Unit: s - // Stability: None - MessagingPublishDurationName = attribute.Key("messaging.publish.duration") - MessagingPublishDurationUnit = attribute.Key("s") - MessagingPublishDurationDescription = attribute.Key("Measures the duration of publish operation.") + // Stability: Experimental + MessagingPublishDurationName = "messaging.publish.duration" + MessagingPublishDurationUnit = "s" + MessagingPublishDurationDescription = "Measures the duration of publish operation." // MessagingReceiveDuration is the metric conforming to the // "messaging.receive.duration" semantic conventions. It represents the - // measures the duration of receive operation. + // measures the duration of receive operation.. // Instrument: histogram // Unit: s - // Stability: None - MessagingReceiveDurationName = attribute.Key("messaging.receive.duration") - MessagingReceiveDurationUnit = attribute.Key("s") - MessagingReceiveDurationDescription = attribute.Key("Measures the duration of receive operation.") + // Stability: Experimental + MessagingReceiveDurationName = "messaging.receive.duration" + MessagingReceiveDurationUnit = "s" + MessagingReceiveDurationDescription = "Measures the duration of receive operation." // MessagingDeliverDuration is the metric conforming to the // "messaging.deliver.duration" semantic conventions. It represents the - // measures the duration of deliver operation. + // measures the duration of deliver operation.. // Instrument: histogram // Unit: s - // Stability: None - MessagingDeliverDurationName = attribute.Key("messaging.deliver.duration") - MessagingDeliverDurationUnit = attribute.Key("s") - MessagingDeliverDurationDescription = attribute.Key("Measures the duration of deliver operation.") + // Stability: Experimental + MessagingDeliverDurationName = "messaging.deliver.duration" + MessagingDeliverDurationUnit = "s" + MessagingDeliverDurationDescription = "Measures the duration of deliver operation." // MessagingPublishMessages is the metric conforming to the // "messaging.publish.messages" semantic conventions. It represents the - // measures the number of published messages. + // measures the number of published messages.. // Instrument: counter // Unit: {message} - // Stability: None - MessagingPublishMessagesName = attribute.Key("messaging.publish.messages") - MessagingPublishMessagesUnit = attribute.Key("{message}") - MessagingPublishMessagesDescription = attribute.Key("Measures the number of published messages.") + // Stability: Experimental + MessagingPublishMessagesName = "messaging.publish.messages" + MessagingPublishMessagesUnit = "{message}" + MessagingPublishMessagesDescription = "Measures the number of published messages." // MessagingReceiveMessages is the metric conforming to the // "messaging.receive.messages" semantic conventions. It represents the - // measures the number of received messages. + // measures the number of received messages.. // Instrument: counter // Unit: {message} - // Stability: None - MessagingReceiveMessagesName = attribute.Key("messaging.receive.messages") - MessagingReceiveMessagesUnit = attribute.Key("{message}") - MessagingReceiveMessagesDescription = attribute.Key("Measures the number of received messages.") + // Stability: Experimental + MessagingReceiveMessagesName = "messaging.receive.messages" + MessagingReceiveMessagesUnit = "{message}" + MessagingReceiveMessagesDescription = "Measures the number of received messages." // MessagingDeliverMessages is the metric conforming to the // "messaging.deliver.messages" semantic conventions. It represents the - // measures the number of delivered messages. + // measures the number of delivered messages.. // Instrument: counter // Unit: {message} - // Stability: None - MessagingDeliverMessagesName = attribute.Key("messaging.deliver.messages") - MessagingDeliverMessagesUnit = attribute.Key("{message}") - MessagingDeliverMessagesDescription = attribute.Key("Measures the number of delivered messages.") + // Stability: Experimental + MessagingDeliverMessagesName = "messaging.deliver.messages" + MessagingDeliverMessagesUnit = "{message}" + MessagingDeliverMessagesDescription = "Measures the number of delivered messages." // RPCServerDuration is the metric conforming to the "rpc.server.duration" // semantic conventions. It represents the measures the duration of inbound - // RPC. + // RPC.. // Instrument: histogram // Unit: ms - // Stability: None - RPCServerDurationName = attribute.Key("rpc.server.duration") - RPCServerDurationUnit = attribute.Key("ms") - RPCServerDurationDescription = attribute.Key("Measures the duration of inbound RPC.") + // Stability: Experimental + RPCServerDurationName = "rpc.server.duration" + RPCServerDurationUnit = "ms" + RPCServerDurationDescription = "Measures the duration of inbound RPC." // RPCServerRequestSize is the metric conforming to the // "rpc.server.request.size" semantic conventions. It represents the measures - // the size of RPC request messages (uncompressed). + // the size of RPC request messages (uncompressed).. // Instrument: histogram // Unit: By - // Stability: None - RPCServerRequestSizeName = attribute.Key("rpc.server.request.size") - RPCServerRequestSizeUnit = attribute.Key("By") - RPCServerRequestSizeDescription = attribute.Key("Measures the size of RPC request messages (uncompressed).") + // Stability: Experimental + RPCServerRequestSizeName = "rpc.server.request.size" + RPCServerRequestSizeUnit = "By" + RPCServerRequestSizeDescription = "Measures the size of RPC request messages (uncompressed)." // RPCServerResponseSize is the metric conforming to the // "rpc.server.response.size" semantic conventions. It represents the measures - // the size of RPC response messages (uncompressed). + // the size of RPC response messages (uncompressed).. // Instrument: histogram // Unit: By - // Stability: None - RPCServerResponseSizeName = attribute.Key("rpc.server.response.size") - RPCServerResponseSizeUnit = attribute.Key("By") - RPCServerResponseSizeDescription = attribute.Key("Measures the size of RPC response messages (uncompressed).") + // Stability: Experimental + RPCServerResponseSizeName = "rpc.server.response.size" + RPCServerResponseSizeUnit = "By" + RPCServerResponseSizeDescription = "Measures the size of RPC response messages (uncompressed)." // RPCServerRequestsPerRPC is the metric conforming to the // "rpc.server.requests_per_rpc" semantic conventions. It represents the - // measures the number of messages received per RPC. + // measures the number of messages received per RPC.. // Instrument: histogram // Unit: {count} - // Stability: None - RPCServerRequestsPerRPCName = attribute.Key("rpc.server.requests_per_rpc") - RPCServerRequestsPerRPCUnit = attribute.Key("{count}") - RPCServerRequestsPerRPCDescription = attribute.Key("Measures the number of messages received per RPC.") + // Stability: Experimental + RPCServerRequestsPerRPCName = "rpc.server.requests_per_rpc" + RPCServerRequestsPerRPCUnit = "{count}" + RPCServerRequestsPerRPCDescription = "Measures the number of messages received per RPC." // RPCServerResponsesPerRPC is the metric conforming to the // "rpc.server.responses_per_rpc" semantic conventions. It represents the - // measures the number of messages sent per RPC. + // measures the number of messages sent per RPC.. // Instrument: histogram // Unit: {count} - // Stability: None - RPCServerResponsesPerRPCName = attribute.Key("rpc.server.responses_per_rpc") - RPCServerResponsesPerRPCUnit = attribute.Key("{count}") - RPCServerResponsesPerRPCDescription = attribute.Key("Measures the number of messages sent per RPC.") + // Stability: Experimental + RPCServerResponsesPerRPCName = "rpc.server.responses_per_rpc" + RPCServerResponsesPerRPCUnit = "{count}" + RPCServerResponsesPerRPCDescription = "Measures the number of messages sent per RPC." // RPCClientDuration is the metric conforming to the "rpc.client.duration" // semantic conventions. It represents the measures the duration of outbound - // RPC. + // RPC.. // Instrument: histogram // Unit: ms - // Stability: None - RPCClientDurationName = attribute.Key("rpc.client.duration") - RPCClientDurationUnit = attribute.Key("ms") - RPCClientDurationDescription = attribute.Key("Measures the duration of outbound RPC.") + // Stability: Experimental + RPCClientDurationName = "rpc.client.duration" + RPCClientDurationUnit = "ms" + RPCClientDurationDescription = "Measures the duration of outbound RPC." // RPCClientRequestSize is the metric conforming to the // "rpc.client.request.size" semantic conventions. It represents the measures - // the size of RPC request messages (uncompressed). + // the size of RPC request messages (uncompressed).. // Instrument: histogram // Unit: By - // Stability: None - RPCClientRequestSizeName = attribute.Key("rpc.client.request.size") - RPCClientRequestSizeUnit = attribute.Key("By") - RPCClientRequestSizeDescription = attribute.Key("Measures the size of RPC request messages (uncompressed).") + // Stability: Experimental + RPCClientRequestSizeName = "rpc.client.request.size" + RPCClientRequestSizeUnit = "By" + RPCClientRequestSizeDescription = "Measures the size of RPC request messages (uncompressed)." // RPCClientResponseSize is the metric conforming to the // "rpc.client.response.size" semantic conventions. It represents the measures - // the size of RPC response messages (uncompressed). + // the size of RPC response messages (uncompressed).. // Instrument: histogram // Unit: By - // Stability: None - RPCClientResponseSizeName = attribute.Key("rpc.client.response.size") - RPCClientResponseSizeUnit = attribute.Key("By") - RPCClientResponseSizeDescription = attribute.Key("Measures the size of RPC response messages (uncompressed).") + // Stability: Experimental + RPCClientResponseSizeName = "rpc.client.response.size" + RPCClientResponseSizeUnit = "By" + RPCClientResponseSizeDescription = "Measures the size of RPC response messages (uncompressed)." // RPCClientRequestsPerRPC is the metric conforming to the // "rpc.client.requests_per_rpc" semantic conventions. It represents the - // measures the number of messages received per RPC. + // measures the number of messages received per RPC.. // Instrument: histogram // Unit: {count} - // Stability: None - RPCClientRequestsPerRPCName = attribute.Key("rpc.client.requests_per_rpc") - RPCClientRequestsPerRPCUnit = attribute.Key("{count}") - RPCClientRequestsPerRPCDescription = attribute.Key("Measures the number of messages received per RPC.") + // Stability: Experimental + RPCClientRequestsPerRPCName = "rpc.client.requests_per_rpc" + RPCClientRequestsPerRPCUnit = "{count}" + RPCClientRequestsPerRPCDescription = "Measures the number of messages received per RPC." // RPCClientResponsesPerRPC is the metric conforming to the // "rpc.client.responses_per_rpc" semantic conventions. It represents the - // measures the number of messages sent per RPC. + // measures the number of messages sent per RPC.. // Instrument: histogram // Unit: {count} - // Stability: None - RPCClientResponsesPerRPCName = attribute.Key("rpc.client.responses_per_rpc") - RPCClientResponsesPerRPCUnit = attribute.Key("{count}") - RPCClientResponsesPerRPCDescription = attribute.Key("Measures the number of messages sent per RPC.") + // Stability: Experimental + RPCClientResponsesPerRPCName = "rpc.client.responses_per_rpc" + RPCClientResponsesPerRPCUnit = "{count}" + RPCClientResponsesPerRPCDescription = "Measures the number of messages sent per RPC." // SystemCPUTime is the metric conforming to the "system.cpu.time" semantic - // conventions. It represents the seconds each logical CPU spent on each mode + // conventions. It represents the seconds each logical CPU spent on each mode. // Instrument: counter // Unit: s - // Stability: None - SystemCPUTimeName = attribute.Key("system.cpu.time") - SystemCPUTimeUnit = attribute.Key("s") - SystemCPUTimeDescription = attribute.Key("Seconds each logical CPU spent on each mode") + // Stability: Experimental + SystemCPUTimeName = "system.cpu.time" + SystemCPUTimeUnit = "s" + SystemCPUTimeDescription = "Seconds each logical CPU spent on each mode" // SystemCPUUtilization is the metric conforming to the // "system.cpu.utilization" semantic conventions. It represents the difference // in system.cpu.time since the last measurement, divided by the elapsed time - // and number of logical CPUs + // and number of logical CPUs. // Instrument: gauge // Unit: 1 - // Stability: None - SystemCPUUtilizationName = attribute.Key("system.cpu.utilization") - SystemCPUUtilizationUnit = attribute.Key("1") - SystemCPUUtilizationDescription = attribute.Key("Difference in system.cpu.time since the last measurement, divided by the elapsed time and number of logical CPUs") + // Stability: Experimental + SystemCPUUtilizationName = "system.cpu.utilization" + SystemCPUUtilizationUnit = "1" + SystemCPUUtilizationDescription = "Difference in system.cpu.time since the last measurement, divided by the elapsed time and number of logical CPUs" // SystemCPUFrequency is the metric conforming to the "system.cpu.frequency" // semantic conventions. It represents the reports the current frequency of the - // CPU in Hz + // CPU in Hz. // Instrument: gauge // Unit: {Hz} - // Stability: None - SystemCPUFrequencyName = attribute.Key("system.cpu.frequency") - SystemCPUFrequencyUnit = attribute.Key("{Hz}") - SystemCPUFrequencyDescription = attribute.Key("Reports the current frequency of the CPU in Hz") + // Stability: Experimental + SystemCPUFrequencyName = "system.cpu.frequency" + SystemCPUFrequencyUnit = "{Hz}" + SystemCPUFrequencyDescription = "Reports the current frequency of the CPU in Hz" // SystemCPUPhysicalCount is the metric conforming to the // "system.cpu.physical.count" semantic conventions. It represents the reports - // the number of actual physical processor cores on the hardware + // the number of actual physical processor cores on the hardware. // Instrument: updowncounter // Unit: {cpu} - // Stability: None - SystemCPUPhysicalCountName = attribute.Key("system.cpu.physical.count") - SystemCPUPhysicalCountUnit = attribute.Key("{cpu}") - SystemCPUPhysicalCountDescription = attribute.Key("Reports the number of actual physical processor cores on the hardware") + // Stability: Experimental + SystemCPUPhysicalCountName = "system.cpu.physical.count" + SystemCPUPhysicalCountUnit = "{cpu}" + SystemCPUPhysicalCountDescription = "Reports the number of actual physical processor cores on the hardware" // SystemCPULogicalCount is the metric conforming to the // "system.cpu.logical.count" semantic conventions. It represents the reports // the number of logical (virtual) processor cores created by the operating - // system to manage multitasking + // system to manage multitasking. // Instrument: updowncounter // Unit: {cpu} - // Stability: None - SystemCPULogicalCountName = attribute.Key("system.cpu.logical.count") - SystemCPULogicalCountUnit = attribute.Key("{cpu}") - SystemCPULogicalCountDescription = attribute.Key("Reports the number of logical (virtual) processor cores created by the operating system to manage multitasking") + // Stability: Experimental + SystemCPULogicalCountName = "system.cpu.logical.count" + SystemCPULogicalCountUnit = "{cpu}" + SystemCPULogicalCountDescription = "Reports the number of logical (virtual) processor cores created by the operating system to manage multitasking" // SystemMemoryUsage is the metric conforming to the "system.memory.usage" - // semantic conventions. It represents the reports memory in use by state. + // semantic conventions. It represents the reports memory in use by state.. // Instrument: updowncounter // Unit: By - // Stability: None - SystemMemoryUsageName = attribute.Key("system.memory.usage") - SystemMemoryUsageUnit = attribute.Key("By") - SystemMemoryUsageDescription = attribute.Key("Reports memory in use by state.") + // Stability: Experimental + SystemMemoryUsageName = "system.memory.usage" + SystemMemoryUsageUnit = "By" + SystemMemoryUsageDescription = "Reports memory in use by state." // SystemMemoryLimit is the metric conforming to the "system.memory.limit" // semantic conventions. It represents the total memory available in the - // system. + // system.. // Instrument: updowncounter // Unit: By - // Stability: None - SystemMemoryLimitName = attribute.Key("system.memory.limit") - SystemMemoryLimitUnit = attribute.Key("By") - SystemMemoryLimitDescription = attribute.Key("Total memory available in the system.") + // Stability: Experimental + SystemMemoryLimitName = "system.memory.limit" + SystemMemoryLimitUnit = "By" + SystemMemoryLimitDescription = "Total memory available in the system." // SystemMemoryUtilization is the metric conforming to the - // "system.memory.utilization" semantic conventions. It represents the + // "system.memory.utilization" semantic conventions. // Instrument: gauge // Unit: 1 - // Stability: None - SystemMemoryUtilizationName = attribute.Key("system.memory.utilization") - SystemMemoryUtilizationUnit = attribute.Key("1") - SystemMemoryUtilizationDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemMemoryUtilizationName = "system.memory.utilization" + SystemMemoryUtilizationUnit = "1" // SystemPagingUsage is the metric conforming to the "system.paging.usage" - // semantic conventions. It represents the unix swap or windows pagefile usage + // semantic conventions. It represents the unix swap or windows pagefile usage. // Instrument: updowncounter // Unit: By - // Stability: None - SystemPagingUsageName = attribute.Key("system.paging.usage") - SystemPagingUsageUnit = attribute.Key("By") - SystemPagingUsageDescription = attribute.Key("Unix swap or windows pagefile usage") + // Stability: Experimental + SystemPagingUsageName = "system.paging.usage" + SystemPagingUsageUnit = "By" + SystemPagingUsageDescription = "Unix swap or windows pagefile usage" // SystemPagingUtilization is the metric conforming to the - // "system.paging.utilization" semantic conventions. It represents the + // "system.paging.utilization" semantic conventions. // Instrument: gauge // Unit: 1 - // Stability: None - SystemPagingUtilizationName = attribute.Key("system.paging.utilization") - SystemPagingUtilizationUnit = attribute.Key("1") - SystemPagingUtilizationDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemPagingUtilizationName = "system.paging.utilization" + SystemPagingUtilizationUnit = "1" // SystemPagingFaults is the metric conforming to the "system.paging.faults" - // semantic conventions. It represents the + // semantic conventions. // Instrument: counter // Unit: {fault} - // Stability: None - SystemPagingFaultsName = attribute.Key("system.paging.faults") - SystemPagingFaultsUnit = attribute.Key("{fault}") - SystemPagingFaultsDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemPagingFaultsName = "system.paging.faults" + SystemPagingFaultsUnit = "{fault}" // SystemPagingOperations is the metric conforming to the - // "system.paging.operations" semantic conventions. It represents the + // "system.paging.operations" semantic conventions. // Instrument: counter // Unit: {operation} - // Stability: None - SystemPagingOperationsName = attribute.Key("system.paging.operations") - SystemPagingOperationsUnit = attribute.Key("{operation}") - SystemPagingOperationsDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemPagingOperationsName = "system.paging.operations" + SystemPagingOperationsUnit = "{operation}" // SystemDiskIo is the metric conforming to the "system.disk.io" semantic - // conventions. It represents the + // conventions. // Instrument: counter // Unit: By - // Stability: None - SystemDiskIoName = attribute.Key("system.disk.io") - SystemDiskIoUnit = attribute.Key("By") - SystemDiskIoDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemDiskIoName = "system.disk.io" + SystemDiskIoUnit = "By" // SystemDiskOperations is the metric conforming to the - // "system.disk.operations" semantic conventions. It represents the + // "system.disk.operations" semantic conventions. // Instrument: counter // Unit: {operation} - // Stability: None - SystemDiskOperationsName = attribute.Key("system.disk.operations") - SystemDiskOperationsUnit = attribute.Key("{operation}") - SystemDiskOperationsDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemDiskOperationsName = "system.disk.operations" + SystemDiskOperationsUnit = "{operation}" // SystemDiskIoTime is the metric conforming to the "system.disk.io_time" - // semantic conventions. It represents the time disk spent activated + // semantic conventions. It represents the time disk spent activated. // Instrument: counter // Unit: s - // Stability: None - SystemDiskIoTimeName = attribute.Key("system.disk.io_time") - SystemDiskIoTimeUnit = attribute.Key("s") - SystemDiskIoTimeDescription = attribute.Key("Time disk spent activated") + // Stability: Experimental + SystemDiskIoTimeName = "system.disk.io_time" + SystemDiskIoTimeUnit = "s" + SystemDiskIoTimeDescription = "Time disk spent activated" // SystemDiskOperationTime is the metric conforming to the // "system.disk.operation_time" semantic conventions. It represents the sum of - // the time each operation took to complete + // the time each operation took to complete. // Instrument: counter // Unit: s - // Stability: None - SystemDiskOperationTimeName = attribute.Key("system.disk.operation_time") - SystemDiskOperationTimeUnit = attribute.Key("s") - SystemDiskOperationTimeDescription = attribute.Key("Sum of the time each operation took to complete") + // Stability: Experimental + SystemDiskOperationTimeName = "system.disk.operation_time" + SystemDiskOperationTimeUnit = "s" + SystemDiskOperationTimeDescription = "Sum of the time each operation took to complete" // SystemDiskMerged is the metric conforming to the "system.disk.merged" - // semantic conventions. It represents the + // semantic conventions. // Instrument: counter // Unit: {operation} - // Stability: None - SystemDiskMergedName = attribute.Key("system.disk.merged") - SystemDiskMergedUnit = attribute.Key("{operation}") - SystemDiskMergedDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemDiskMergedName = "system.disk.merged" + SystemDiskMergedUnit = "{operation}" // SystemFilesystemUsage is the metric conforming to the - // "system.filesystem.usage" semantic conventions. It represents the + // "system.filesystem.usage" semantic conventions. // Instrument: updowncounter // Unit: By - // Stability: None - SystemFilesystemUsageName = attribute.Key("system.filesystem.usage") - SystemFilesystemUsageUnit = attribute.Key("By") - SystemFilesystemUsageDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemFilesystemUsageName = "system.filesystem.usage" + SystemFilesystemUsageUnit = "By" // SystemFilesystemUtilization is the metric conforming to the - // "system.filesystem.utilization" semantic conventions. It represents the + // "system.filesystem.utilization" semantic conventions. // Instrument: gauge // Unit: 1 - // Stability: None - SystemFilesystemUtilizationName = attribute.Key("system.filesystem.utilization") - SystemFilesystemUtilizationUnit = attribute.Key("1") - SystemFilesystemUtilizationDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemFilesystemUtilizationName = "system.filesystem.utilization" + SystemFilesystemUtilizationUnit = "1" // SystemNetworkDropped is the metric conforming to the // "system.network.dropped" semantic conventions. It represents the count of - // packets that are dropped or discarded even though there was no error + // packets that are dropped or discarded even though there was no error. // Instrument: counter // Unit: {packet} - // Stability: None - SystemNetworkDroppedName = attribute.Key("system.network.dropped") - SystemNetworkDroppedUnit = attribute.Key("{packet}") - SystemNetworkDroppedDescription = attribute.Key("Count of packets that are dropped or discarded even though there was no error") + // Stability: Experimental + SystemNetworkDroppedName = "system.network.dropped" + SystemNetworkDroppedUnit = "{packet}" + SystemNetworkDroppedDescription = "Count of packets that are dropped or discarded even though there was no error" // SystemNetworkPackets is the metric conforming to the - // "system.network.packets" semantic conventions. It represents the + // "system.network.packets" semantic conventions. // Instrument: counter // Unit: {packet} - // Stability: None - SystemNetworkPacketsName = attribute.Key("system.network.packets") - SystemNetworkPacketsUnit = attribute.Key("{packet}") - SystemNetworkPacketsDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemNetworkPacketsName = "system.network.packets" + SystemNetworkPacketsUnit = "{packet}" // SystemNetworkErrors is the metric conforming to the "system.network.errors" - // semantic conventions. It represents the count of network errors detected + // semantic conventions. It represents the count of network errors detected. // Instrument: counter // Unit: {error} - // Stability: None - SystemNetworkErrorsName = attribute.Key("system.network.errors") - SystemNetworkErrorsUnit = attribute.Key("{error}") - SystemNetworkErrorsDescription = attribute.Key("Count of network errors detected") + // Stability: Experimental + SystemNetworkErrorsName = "system.network.errors" + SystemNetworkErrorsUnit = "{error}" + SystemNetworkErrorsDescription = "Count of network errors detected" // SystemNetworkIo is the metric conforming to the "system.network.io" semantic - // conventions. It represents the + // conventions. // Instrument: counter // Unit: By - // Stability: None - SystemNetworkIoName = attribute.Key("system.network.io") - SystemNetworkIoUnit = attribute.Key("By") - SystemNetworkIoDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemNetworkIoName = "system.network.io" + SystemNetworkIoUnit = "By" // SystemNetworkConnections is the metric conforming to the - // "system.network.connections" semantic conventions. It represents the + // "system.network.connections" semantic conventions. // Instrument: updowncounter // Unit: {connection} - // Stability: None - SystemNetworkConnectionsName = attribute.Key("system.network.connections") - SystemNetworkConnectionsUnit = attribute.Key("{connection}") - SystemNetworkConnectionsDescription = attribute.Key("") + // Stability: Experimental + // NOTE: The description (brief) for this metric is not defined in the semantic-conventions repository. + SystemNetworkConnectionsName = "system.network.connections" + SystemNetworkConnectionsUnit = "{connection}" // SystemProcessesCount is the metric conforming to the // "system.processes.count" semantic conventions. It represents the total - // number of processes in each state + // number of processes in each state. // Instrument: updowncounter // Unit: {process} - // Stability: None - SystemProcessesCountName = attribute.Key("system.processes.count") - SystemProcessesCountUnit = attribute.Key("{process}") - SystemProcessesCountDescription = attribute.Key("Total number of processes in each state") + // Stability: Experimental + SystemProcessesCountName = "system.processes.count" + SystemProcessesCountUnit = "{process}" + SystemProcessesCountDescription = "Total number of processes in each state" // SystemProcessesCreated is the metric conforming to the // "system.processes.created" semantic conventions. It represents the total - // number of processes created over uptime of the host + // number of processes created over uptime of the host. // Instrument: counter // Unit: {process} - // Stability: None - SystemProcessesCreatedName = attribute.Key("system.processes.created") - SystemProcessesCreatedUnit = attribute.Key("{process}") - SystemProcessesCreatedDescription = attribute.Key("Total number of processes created over uptime of the host") + // Stability: Experimental + SystemProcessesCreatedName = "system.processes.created" + SystemProcessesCreatedUnit = "{process}" + SystemProcessesCreatedDescription = "Total number of processes created over uptime of the host" // SystemLinuxMemoryAvailable is the metric conforming to the // "system.linux.memory.available" semantic conventions. It represents an // estimate of how much memory is available for starting new applications, - // without causing swapping + // without causing swapping. // Instrument: updowncounter // Unit: By - // Stability: None - SystemLinuxMemoryAvailableName = attribute.Key("system.linux.memory.available") - SystemLinuxMemoryAvailableUnit = attribute.Key("By") - SystemLinuxMemoryAvailableDescription = attribute.Key("An estimate of how much memory is available for starting new applications, without causing swapping") + // Stability: Experimental + SystemLinuxMemoryAvailableName = "system.linux.memory.available" + SystemLinuxMemoryAvailableUnit = "By" + SystemLinuxMemoryAvailableDescription = "An estimate of how much memory is available for starting new applications, without causing swapping" ) From e396ef9626eb6946e3a93405c888f3d73615f0c2 Mon Sep 17 00:00:00 2001 From: Ben Carr Date: Thu, 22 Feb 2024 13:59:54 -0800 Subject: [PATCH 06/11] trim trailing (repeated) periods in the description --- semconv/metric_template.j2 | 2 +- semconv/v1.24.0/metric.go | 130 ++++++++++++++++++------------------- 2 files changed, 66 insertions(+), 66 deletions(-) diff --git a/semconv/metric_template.j2 b/semconv/metric_template.j2 index 9ac84be15aa..250bef9585c 100644 --- a/semconv/metric_template.j2 +++ b/semconv/metric_template.j2 @@ -12,7 +12,7 @@ It represents {% if brief[:2] == "A " or brief[:3] == "An " or brief[:4] == "The {%- if metric.stability|string() == "StabilityLevel.DEPRECATED" or not metric.brief-%} {{ to_go_name(metric.metric_name) }} is the metric conforming to the "{{ metric.metric_name}}" semantic conventions. {%- else -%} -{{ to_go_name(metric.metric_name) }} is the metric conforming to the "{{ metric.metric_name}}" semantic conventions. {{ it_reps(metric.brief) }}. +{{ to_go_name(metric.metric_name) }} is the metric conforming to the "{{ metric.metric_name}}" semantic conventions. {{ it_reps(metric.brief)|trim(".") }}. {%- endif %} {%- endmacro -%} {%- macro format_stability(stability) -%} diff --git a/semconv/v1.24.0/metric.go b/semconv/v1.24.0/metric.go index 8609d4ad9d0..825f66f1c77 100644 --- a/semconv/v1.24.0/metric.go +++ b/semconv/v1.24.0/metric.go @@ -113,7 +113,7 @@ const ( // AspnetcoreRoutingMatchAttempts is the metric conforming to the // "aspnetcore.routing.match_attempts" semantic conventions. It represents the - // number of requests that were attempted to be matched to an endpoint.. + // number of requests that were attempted to be matched to an endpoint. // Instrument: counter // Unit: {match_attempt} // Stability: Experimental @@ -123,7 +123,7 @@ const ( // AspnetcoreDiagnosticsExceptions is the metric conforming to the // "aspnetcore.diagnostics.exceptions" semantic conventions. It represents the - // number of exceptions caught by exception handling middleware.. + // number of exceptions caught by exception handling middleware. // Instrument: counter // Unit: {exception} // Stability: Experimental @@ -134,7 +134,7 @@ const ( // AspnetcoreRateLimitingActiveRequestLeases is the metric conforming to the // "aspnetcore.rate_limiting.active_request_leases" semantic conventions. It // represents the number of requests that are currently active on the server - // that hold a rate limiting lease.. + // that hold a rate limiting lease. // Instrument: updowncounter // Unit: {request} // Stability: Experimental @@ -145,7 +145,7 @@ const ( // AspnetcoreRateLimitingRequestLeaseDuration is the metric conforming to the // "aspnetcore.rate_limiting.request_lease.duration" semantic conventions. It // represents the duration of rate limiting lease held by requests on the - // server.. + // server. // Instrument: histogram // Unit: s // Stability: Experimental @@ -156,7 +156,7 @@ const ( // AspnetcoreRateLimitingRequestTimeInQueue is the metric conforming to the // "aspnetcore.rate_limiting.request.time_in_queue" semantic conventions. It // represents the time the request spent in a queue waiting to acquire a rate - // limiting lease.. + // limiting lease. // Instrument: histogram // Unit: s // Stability: Experimental @@ -167,7 +167,7 @@ const ( // AspnetcoreRateLimitingQueuedRequests is the metric conforming to the // "aspnetcore.rate_limiting.queued_requests" semantic conventions. It // represents the number of requests that are currently queued, waiting to - // acquire a rate limiting lease.. + // acquire a rate limiting lease. // Instrument: updowncounter // Unit: {request} // Stability: Experimental @@ -177,7 +177,7 @@ const ( // AspnetcoreRateLimitingRequests is the metric conforming to the // "aspnetcore.rate_limiting.requests" semantic conventions. It represents the - // number of requests that tried to acquire a rate limiting lease.. + // number of requests that tried to acquire a rate limiting lease. // Instrument: counter // Unit: {request} // Stability: Experimental @@ -187,7 +187,7 @@ const ( // DNSLookupDuration is the metric conforming to the "dns.lookup.duration" // semantic conventions. It represents the measures the time taken to perform a - // DNS lookup.. + // DNS lookup. // Instrument: histogram // Unit: s // Stability: Experimental @@ -198,7 +198,7 @@ const ( // HTTPClientOpenConnections is the metric conforming to the // "http.client.open_connections" semantic conventions. It represents the // number of outbound HTTP connections that are currently active or idle on the - // client.. + // client. // Instrument: updowncounter // Unit: {connection} // Stability: Experimental @@ -208,7 +208,7 @@ const ( // HTTPClientConnectionDuration is the metric conforming to the // "http.client.connection.duration" semantic conventions. It represents the - // duration of the successfully established outbound HTTP connections.. + // duration of the successfully established outbound HTTP connections. // Instrument: histogram // Unit: s // Stability: Experimental @@ -218,7 +218,7 @@ const ( // HTTPClientActiveRequests is the metric conforming to the // "http.client.active_requests" semantic conventions. It represents the number - // of active HTTP requests.. + // of active HTTP requests. // Instrument: updowncounter // Unit: {request} // Stability: Experimental @@ -229,7 +229,7 @@ const ( // HTTPClientRequestTimeInQueue is the metric conforming to the // "http.client.request.time_in_queue" semantic conventions. It represents the // amount of time requests spent on a queue waiting for an available - // connection.. + // connection. // Instrument: histogram // Unit: s // Stability: Experimental @@ -239,7 +239,7 @@ const ( // KestrelActiveConnections is the metric conforming to the // "kestrel.active_connections" semantic conventions. It represents the number - // of connections that are currently active on the server.. + // of connections that are currently active on the server. // Instrument: updowncounter // Unit: {connection} // Stability: Experimental @@ -249,7 +249,7 @@ const ( // KestrelConnectionDuration is the metric conforming to the // "kestrel.connection.duration" semantic conventions. It represents the - // duration of connections on the server.. + // duration of connections on the server. // Instrument: histogram // Unit: s // Stability: Experimental @@ -259,7 +259,7 @@ const ( // KestrelRejectedConnections is the metric conforming to the // "kestrel.rejected_connections" semantic conventions. It represents the - // number of connections rejected by the server.. + // number of connections rejected by the server. // Instrument: counter // Unit: {connection} // Stability: Experimental @@ -269,7 +269,7 @@ const ( // KestrelQueuedConnections is the metric conforming to the // "kestrel.queued_connections" semantic conventions. It represents the number - // of connections that are currently queued and are waiting to start.. + // of connections that are currently queued and are waiting to start. // Instrument: updowncounter // Unit: {connection} // Stability: Experimental @@ -280,7 +280,7 @@ const ( // KestrelQueuedRequests is the metric conforming to the // "kestrel.queued_requests" semantic conventions. It represents the number of // HTTP requests on multiplexed connections (HTTP/2 and HTTP/3) that are - // currently queued and are waiting to start.. + // currently queued and are waiting to start. // Instrument: updowncounter // Unit: {request} // Stability: Experimental @@ -290,7 +290,7 @@ const ( // KestrelUpgradedConnections is the metric conforming to the // "kestrel.upgraded_connections" semantic conventions. It represents the - // number of connections that are currently upgraded (WebSockets). .. + // number of connections that are currently upgraded (WebSockets). . // Instrument: updowncounter // Unit: {connection} // Stability: Experimental @@ -300,7 +300,7 @@ const ( // KestrelTLSHandshakeDuration is the metric conforming to the // "kestrel.tls_handshake.duration" semantic conventions. It represents the - // duration of TLS handshakes on the server.. + // duration of TLS handshakes on the server. // Instrument: histogram // Unit: s // Stability: Experimental @@ -310,7 +310,7 @@ const ( // KestrelActiveTLSHandshakes is the metric conforming to the // "kestrel.active_tls_handshakes" semantic conventions. It represents the - // number of TLS handshakes that are currently in progress on the server.. + // number of TLS handshakes that are currently in progress on the server. // Instrument: updowncounter // Unit: {handshake} // Stability: Experimental @@ -320,7 +320,7 @@ const ( // SignalrServerConnectionDuration is the metric conforming to the // "signalr.server.connection.duration" semantic conventions. It represents the - // duration of connections on the server.. + // duration of connections on the server. // Instrument: histogram // Unit: s // Stability: Experimental @@ -330,7 +330,7 @@ const ( // SignalrServerActiveConnections is the metric conforming to the // "signalr.server.active_connections" semantic conventions. It represents the - // number of connections that are currently active on the server.. + // number of connections that are currently active on the server. // Instrument: updowncounter // Unit: {connection} // Stability: Experimental @@ -424,7 +424,7 @@ const ( // HTTPServerRequestDuration is the metric conforming to the // "http.server.request.duration" semantic conventions. It represents the - // duration of HTTP server requests.. + // duration of HTTP server requests. // Instrument: histogram // Unit: s // Stability: Stable @@ -434,7 +434,7 @@ const ( // HTTPServerActiveRequests is the metric conforming to the // "http.server.active_requests" semantic conventions. It represents the number - // of active HTTP server requests.. + // of active HTTP server requests. // Instrument: updowncounter // Unit: {request} // Stability: Experimental @@ -444,7 +444,7 @@ const ( // HTTPServerRequestBodySize is the metric conforming to the // "http.server.request.body.size" semantic conventions. It represents the size - // of HTTP server request bodies.. + // of HTTP server request bodies. // Instrument: histogram // Unit: By // Stability: Experimental @@ -454,7 +454,7 @@ const ( // HTTPServerResponseBodySize is the metric conforming to the // "http.server.response.body.size" semantic conventions. It represents the - // size of HTTP server response bodies.. + // size of HTTP server response bodies. // Instrument: histogram // Unit: By // Stability: Experimental @@ -464,7 +464,7 @@ const ( // HTTPClientRequestDuration is the metric conforming to the // "http.client.request.duration" semantic conventions. It represents the - // duration of HTTP client requests.. + // duration of HTTP client requests. // Instrument: histogram // Unit: s // Stability: Stable @@ -474,7 +474,7 @@ const ( // HTTPClientRequestBodySize is the metric conforming to the // "http.client.request.body.size" semantic conventions. It represents the size - // of HTTP client request bodies.. + // of HTTP client request bodies. // Instrument: histogram // Unit: By // Stability: Experimental @@ -484,7 +484,7 @@ const ( // HTTPClientResponseBodySize is the metric conforming to the // "http.client.response.body.size" semantic conventions. It represents the - // size of HTTP client response bodies.. + // size of HTTP client response bodies. // Instrument: histogram // Unit: By // Stability: Experimental @@ -493,7 +493,7 @@ const ( HTTPClientResponseBodySizeDescription = "Size of HTTP client response bodies." // JvmMemoryInit is the metric conforming to the "jvm.memory.init" semantic - // conventions. It represents the measure of initial memory requested.. + // conventions. It represents the measure of initial memory requested. // Instrument: updowncounter // Unit: By // Stability: Experimental @@ -503,7 +503,7 @@ const ( // JvmSystemCPUUtilization is the metric conforming to the // "jvm.system.cpu.utilization" semantic conventions. It represents the recent - // CPU utilization for the whole system as reported by the JVM.. + // CPU utilization for the whole system as reported by the JVM. // Instrument: gauge // Unit: 1 // Stability: Experimental @@ -513,7 +513,7 @@ const ( // JvmSystemCPULoad1m is the metric conforming to the "jvm.system.cpu.load_1m" // semantic conventions. It represents the average CPU load of the whole system - // for the last minute as reported by the JVM.. + // for the last minute as reported by the JVM. // Instrument: gauge // Unit: {run_queue_item} // Stability: Experimental @@ -523,7 +523,7 @@ const ( // JvmBufferMemoryUsage is the metric conforming to the // "jvm.buffer.memory.usage" semantic conventions. It represents the measure of - // memory used by buffers.. + // memory used by buffers. // Instrument: updowncounter // Unit: By // Stability: Experimental @@ -533,7 +533,7 @@ const ( // JvmBufferMemoryLimit is the metric conforming to the // "jvm.buffer.memory.limit" semantic conventions. It represents the measure of - // total memory capacity of buffers.. + // total memory capacity of buffers. // Instrument: updowncounter // Unit: By // Stability: Experimental @@ -542,7 +542,7 @@ const ( JvmBufferMemoryLimitDescription = "Measure of total memory capacity of buffers." // JvmBufferCount is the metric conforming to the "jvm.buffer.count" semantic - // conventions. It represents the number of buffers in the pool.. + // conventions. It represents the number of buffers in the pool. // Instrument: updowncounter // Unit: {buffer} // Stability: Experimental @@ -551,7 +551,7 @@ const ( JvmBufferCountDescription = "Number of buffers in the pool." // JvmMemoryUsed is the metric conforming to the "jvm.memory.used" semantic - // conventions. It represents the measure of memory used.. + // conventions. It represents the measure of memory used. // Instrument: updowncounter // Unit: By // Stability: Stable @@ -560,7 +560,7 @@ const ( JvmMemoryUsedDescription = "Measure of memory used." // JvmMemoryCommitted is the metric conforming to the "jvm.memory.committed" - // semantic conventions. It represents the measure of memory committed.. + // semantic conventions. It represents the measure of memory committed. // Instrument: updowncounter // Unit: By // Stability: Stable @@ -569,7 +569,7 @@ const ( JvmMemoryCommittedDescription = "Measure of memory committed." // JvmMemoryLimit is the metric conforming to the "jvm.memory.limit" semantic - // conventions. It represents the measure of max obtainable memory.. + // conventions. It represents the measure of max obtainable memory. // Instrument: updowncounter // Unit: By // Stability: Stable @@ -580,7 +580,7 @@ const ( // JvmMemoryUsedAfterLastGc is the metric conforming to the // "jvm.memory.used_after_last_gc" semantic conventions. It represents the // measure of memory used, as measured after the most recent garbage collection - // event on this pool.. + // event on this pool. // Instrument: updowncounter // Unit: By // Stability: Stable @@ -589,7 +589,7 @@ const ( JvmMemoryUsedAfterLastGcDescription = "Measure of memory used, as measured after the most recent garbage collection event on this pool." // JvmGcDuration is the metric conforming to the "jvm.gc.duration" semantic - // conventions. It represents the duration of JVM garbage collection actions.. + // conventions. It represents the duration of JVM garbage collection actions. // Instrument: histogram // Unit: s // Stability: Stable @@ -598,7 +598,7 @@ const ( JvmGcDurationDescription = "Duration of JVM garbage collection actions." // JvmThreadCount is the metric conforming to the "jvm.thread.count" semantic - // conventions. It represents the number of executing platform threads.. + // conventions. It represents the number of executing platform threads. // Instrument: updowncounter // Unit: {thread} // Stability: Stable @@ -607,7 +607,7 @@ const ( JvmThreadCountDescription = "Number of executing platform threads." // JvmClassLoaded is the metric conforming to the "jvm.class.loaded" semantic - // conventions. It represents the number of classes loaded since JVM start.. + // conventions. It represents the number of classes loaded since JVM start. // Instrument: counter // Unit: {class} // Stability: Stable @@ -617,7 +617,7 @@ const ( // JvmClassUnloaded is the metric conforming to the "jvm.class.unloaded" // semantic conventions. It represents the number of classes unloaded since JVM - // start.. + // start. // Instrument: counter // Unit: {class} // Stability: Stable @@ -626,7 +626,7 @@ const ( JvmClassUnloadedDescription = "Number of classes unloaded since JVM start." // JvmClassCount is the metric conforming to the "jvm.class.count" semantic - // conventions. It represents the number of classes currently loaded.. + // conventions. It represents the number of classes currently loaded. // Instrument: updowncounter // Unit: {class} // Stability: Stable @@ -636,7 +636,7 @@ const ( // JvmCPUCount is the metric conforming to the "jvm.cpu.count" semantic // conventions. It represents the number of processors available to the Java - // virtual machine.. + // virtual machine. // Instrument: updowncounter // Unit: {cpu} // Stability: Stable @@ -646,7 +646,7 @@ const ( // JvmCPUTime is the metric conforming to the "jvm.cpu.time" semantic // conventions. It represents the cPU time used by the process as reported by - // the JVM.. + // the JVM. // Instrument: counter // Unit: s // Stability: Stable @@ -656,7 +656,7 @@ const ( // JvmCPURecentUtilization is the metric conforming to the // "jvm.cpu.recent_utilization" semantic conventions. It represents the recent - // CPU utilization for the process as reported by the JVM.. + // CPU utilization for the process as reported by the JVM. // Instrument: gauge // Unit: 1 // Stability: Stable @@ -666,7 +666,7 @@ const ( // MessagingPublishDuration is the metric conforming to the // "messaging.publish.duration" semantic conventions. It represents the - // measures the duration of publish operation.. + // measures the duration of publish operation. // Instrument: histogram // Unit: s // Stability: Experimental @@ -676,7 +676,7 @@ const ( // MessagingReceiveDuration is the metric conforming to the // "messaging.receive.duration" semantic conventions. It represents the - // measures the duration of receive operation.. + // measures the duration of receive operation. // Instrument: histogram // Unit: s // Stability: Experimental @@ -686,7 +686,7 @@ const ( // MessagingDeliverDuration is the metric conforming to the // "messaging.deliver.duration" semantic conventions. It represents the - // measures the duration of deliver operation.. + // measures the duration of deliver operation. // Instrument: histogram // Unit: s // Stability: Experimental @@ -696,7 +696,7 @@ const ( // MessagingPublishMessages is the metric conforming to the // "messaging.publish.messages" semantic conventions. It represents the - // measures the number of published messages.. + // measures the number of published messages. // Instrument: counter // Unit: {message} // Stability: Experimental @@ -706,7 +706,7 @@ const ( // MessagingReceiveMessages is the metric conforming to the // "messaging.receive.messages" semantic conventions. It represents the - // measures the number of received messages.. + // measures the number of received messages. // Instrument: counter // Unit: {message} // Stability: Experimental @@ -716,7 +716,7 @@ const ( // MessagingDeliverMessages is the metric conforming to the // "messaging.deliver.messages" semantic conventions. It represents the - // measures the number of delivered messages.. + // measures the number of delivered messages. // Instrument: counter // Unit: {message} // Stability: Experimental @@ -726,7 +726,7 @@ const ( // RPCServerDuration is the metric conforming to the "rpc.server.duration" // semantic conventions. It represents the measures the duration of inbound - // RPC.. + // RPC. // Instrument: histogram // Unit: ms // Stability: Experimental @@ -736,7 +736,7 @@ const ( // RPCServerRequestSize is the metric conforming to the // "rpc.server.request.size" semantic conventions. It represents the measures - // the size of RPC request messages (uncompressed).. + // the size of RPC request messages (uncompressed). // Instrument: histogram // Unit: By // Stability: Experimental @@ -746,7 +746,7 @@ const ( // RPCServerResponseSize is the metric conforming to the // "rpc.server.response.size" semantic conventions. It represents the measures - // the size of RPC response messages (uncompressed).. + // the size of RPC response messages (uncompressed). // Instrument: histogram // Unit: By // Stability: Experimental @@ -756,7 +756,7 @@ const ( // RPCServerRequestsPerRPC is the metric conforming to the // "rpc.server.requests_per_rpc" semantic conventions. It represents the - // measures the number of messages received per RPC.. + // measures the number of messages received per RPC. // Instrument: histogram // Unit: {count} // Stability: Experimental @@ -766,7 +766,7 @@ const ( // RPCServerResponsesPerRPC is the metric conforming to the // "rpc.server.responses_per_rpc" semantic conventions. It represents the - // measures the number of messages sent per RPC.. + // measures the number of messages sent per RPC. // Instrument: histogram // Unit: {count} // Stability: Experimental @@ -776,7 +776,7 @@ const ( // RPCClientDuration is the metric conforming to the "rpc.client.duration" // semantic conventions. It represents the measures the duration of outbound - // RPC.. + // RPC. // Instrument: histogram // Unit: ms // Stability: Experimental @@ -786,7 +786,7 @@ const ( // RPCClientRequestSize is the metric conforming to the // "rpc.client.request.size" semantic conventions. It represents the measures - // the size of RPC request messages (uncompressed).. + // the size of RPC request messages (uncompressed). // Instrument: histogram // Unit: By // Stability: Experimental @@ -796,7 +796,7 @@ const ( // RPCClientResponseSize is the metric conforming to the // "rpc.client.response.size" semantic conventions. It represents the measures - // the size of RPC response messages (uncompressed).. + // the size of RPC response messages (uncompressed). // Instrument: histogram // Unit: By // Stability: Experimental @@ -806,7 +806,7 @@ const ( // RPCClientRequestsPerRPC is the metric conforming to the // "rpc.client.requests_per_rpc" semantic conventions. It represents the - // measures the number of messages received per RPC.. + // measures the number of messages received per RPC. // Instrument: histogram // Unit: {count} // Stability: Experimental @@ -816,7 +816,7 @@ const ( // RPCClientResponsesPerRPC is the metric conforming to the // "rpc.client.responses_per_rpc" semantic conventions. It represents the - // measures the number of messages sent per RPC.. + // measures the number of messages sent per RPC. // Instrument: histogram // Unit: {count} // Stability: Experimental @@ -876,7 +876,7 @@ const ( SystemCPULogicalCountDescription = "Reports the number of logical (virtual) processor cores created by the operating system to manage multitasking" // SystemMemoryUsage is the metric conforming to the "system.memory.usage" - // semantic conventions. It represents the reports memory in use by state.. + // semantic conventions. It represents the reports memory in use by state. // Instrument: updowncounter // Unit: By // Stability: Experimental @@ -886,7 +886,7 @@ const ( // SystemMemoryLimit is the metric conforming to the "system.memory.limit" // semantic conventions. It represents the total memory available in the - // system.. + // system. // Instrument: updowncounter // Unit: By // Stability: Experimental From 14b878ea4e4f367671e5cb11feae614ed5c987d7 Mon Sep 17 00:00:00 2001 From: Ben Carr Date: Wed, 13 Mar 2024 14:01:10 -0700 Subject: [PATCH 07/11] manual formatting of some proper nouns; simplify the license header --- semconv/metric_template.j2 | 25 ++--- semconv/v1.24.0/metric.go | 200 ++++++++++++++++++------------------- 2 files changed, 110 insertions(+), 115 deletions(-) diff --git a/semconv/metric_template.j2 b/semconv/metric_template.j2 index 250bef9585c..20dcaca0a84 100644 --- a/semconv/metric_template.j2 +++ b/semconv/metric_template.j2 @@ -1,6 +1,12 @@ -{%- macro to_go_name(fqn) -%} -{{fqn | replace(".", " ") | replace("_", " ") | title | replace(" ", "")}} -{%- endmacro -%} +{% macro to_go_name(name) -%} + {%- if name.startswith('aspnetcore.') -%} + ASPNETCore{{ name[11:] | replace(".", " ") | replace("_", " ") | title | replace(" ", "") }} + {%- elif name.startswith('jvm.') -%} + JVM{{ name[4:] | replace(".", " ") | replace("_", " ") | title | replace(" ", "") }} + {%- else -%} + {{ name | replace(".", " ") | replace("_", " ") | title | replace(" ", "") }} + {%- endif -%} +{%- endmacro %} {%- macro it_reps(brief) -%} It represents {% if brief[:2] == "A " or brief[:3] == "An " or brief[:4] == "The " -%} {{ brief[0]|lower }}{{ brief[1:] }} @@ -23,18 +29,7 @@ Experimental {%- endif %} {%- endmacro -%} // Copyright The OpenTelemetry Authors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// SPDX-License-Identifier: Apache-2.0 // Code generated from semantic convention specification. DO NOT EDIT. diff --git a/semconv/v1.24.0/metric.go b/semconv/v1.24.0/metric.go index 825f66f1c77..b9292df916f 100644 --- a/semconv/v1.24.0/metric.go +++ b/semconv/v1.24.0/metric.go @@ -111,79 +111,79 @@ const ( DBClientConnectionsUseTimeUnit = "ms" DBClientConnectionsUseTimeDescription = "The time between borrowing a connection and returning it to the pool" - // AspnetcoreRoutingMatchAttempts is the metric conforming to the + // ASPNETCoreRoutingMatchAttempts is the metric conforming to the // "aspnetcore.routing.match_attempts" semantic conventions. It represents the // number of requests that were attempted to be matched to an endpoint. // Instrument: counter // Unit: {match_attempt} // Stability: Experimental - AspnetcoreRoutingMatchAttemptsName = "aspnetcore.routing.match_attempts" - AspnetcoreRoutingMatchAttemptsUnit = "{match_attempt}" - AspnetcoreRoutingMatchAttemptsDescription = "Number of requests that were attempted to be matched to an endpoint." + ASPNETCoreRoutingMatchAttemptsName = "aspnetcore.routing.match_attempts" + ASPNETCoreRoutingMatchAttemptsUnit = "{match_attempt}" + ASPNETCoreRoutingMatchAttemptsDescription = "Number of requests that were attempted to be matched to an endpoint." - // AspnetcoreDiagnosticsExceptions is the metric conforming to the + // ASPNETCoreDiagnosticsExceptions is the metric conforming to the // "aspnetcore.diagnostics.exceptions" semantic conventions. It represents the // number of exceptions caught by exception handling middleware. // Instrument: counter // Unit: {exception} // Stability: Experimental - AspnetcoreDiagnosticsExceptionsName = "aspnetcore.diagnostics.exceptions" - AspnetcoreDiagnosticsExceptionsUnit = "{exception}" - AspnetcoreDiagnosticsExceptionsDescription = "Number of exceptions caught by exception handling middleware." + ASPNETCoreDiagnosticsExceptionsName = "aspnetcore.diagnostics.exceptions" + ASPNETCoreDiagnosticsExceptionsUnit = "{exception}" + ASPNETCoreDiagnosticsExceptionsDescription = "Number of exceptions caught by exception handling middleware." - // AspnetcoreRateLimitingActiveRequestLeases is the metric conforming to the + // ASPNETCoreRateLimitingActiveRequestLeases is the metric conforming to the // "aspnetcore.rate_limiting.active_request_leases" semantic conventions. It // represents the number of requests that are currently active on the server // that hold a rate limiting lease. // Instrument: updowncounter // Unit: {request} // Stability: Experimental - AspnetcoreRateLimitingActiveRequestLeasesName = "aspnetcore.rate_limiting.active_request_leases" - AspnetcoreRateLimitingActiveRequestLeasesUnit = "{request}" - AspnetcoreRateLimitingActiveRequestLeasesDescription = "Number of requests that are currently active on the server that hold a rate limiting lease." + ASPNETCoreRateLimitingActiveRequestLeasesName = "aspnetcore.rate_limiting.active_request_leases" + ASPNETCoreRateLimitingActiveRequestLeasesUnit = "{request}" + ASPNETCoreRateLimitingActiveRequestLeasesDescription = "Number of requests that are currently active on the server that hold a rate limiting lease." - // AspnetcoreRateLimitingRequestLeaseDuration is the metric conforming to the + // ASPNETCoreRateLimitingRequestLeaseDuration is the metric conforming to the // "aspnetcore.rate_limiting.request_lease.duration" semantic conventions. It // represents the duration of rate limiting lease held by requests on the // server. // Instrument: histogram // Unit: s // Stability: Experimental - AspnetcoreRateLimitingRequestLeaseDurationName = "aspnetcore.rate_limiting.request_lease.duration" - AspnetcoreRateLimitingRequestLeaseDurationUnit = "s" - AspnetcoreRateLimitingRequestLeaseDurationDescription = "The duration of rate limiting lease held by requests on the server." + ASPNETCoreRateLimitingRequestLeaseDurationName = "aspnetcore.rate_limiting.request_lease.duration" + ASPNETCoreRateLimitingRequestLeaseDurationUnit = "s" + ASPNETCoreRateLimitingRequestLeaseDurationDescription = "The duration of rate limiting lease held by requests on the server." - // AspnetcoreRateLimitingRequestTimeInQueue is the metric conforming to the + // ASPNETCoreRateLimitingRequestTimeInQueue is the metric conforming to the // "aspnetcore.rate_limiting.request.time_in_queue" semantic conventions. It // represents the time the request spent in a queue waiting to acquire a rate // limiting lease. // Instrument: histogram // Unit: s // Stability: Experimental - AspnetcoreRateLimitingRequestTimeInQueueName = "aspnetcore.rate_limiting.request.time_in_queue" - AspnetcoreRateLimitingRequestTimeInQueueUnit = "s" - AspnetcoreRateLimitingRequestTimeInQueueDescription = "The time the request spent in a queue waiting to acquire a rate limiting lease." + ASPNETCoreRateLimitingRequestTimeInQueueName = "aspnetcore.rate_limiting.request.time_in_queue" + ASPNETCoreRateLimitingRequestTimeInQueueUnit = "s" + ASPNETCoreRateLimitingRequestTimeInQueueDescription = "The time the request spent in a queue waiting to acquire a rate limiting lease." - // AspnetcoreRateLimitingQueuedRequests is the metric conforming to the + // ASPNETCoreRateLimitingQueuedRequests is the metric conforming to the // "aspnetcore.rate_limiting.queued_requests" semantic conventions. It // represents the number of requests that are currently queued, waiting to // acquire a rate limiting lease. // Instrument: updowncounter // Unit: {request} // Stability: Experimental - AspnetcoreRateLimitingQueuedRequestsName = "aspnetcore.rate_limiting.queued_requests" - AspnetcoreRateLimitingQueuedRequestsUnit = "{request}" - AspnetcoreRateLimitingQueuedRequestsDescription = "Number of requests that are currently queued, waiting to acquire a rate limiting lease." + ASPNETCoreRateLimitingQueuedRequestsName = "aspnetcore.rate_limiting.queued_requests" + ASPNETCoreRateLimitingQueuedRequestsUnit = "{request}" + ASPNETCoreRateLimitingQueuedRequestsDescription = "Number of requests that are currently queued, waiting to acquire a rate limiting lease." - // AspnetcoreRateLimitingRequests is the metric conforming to the + // ASPNETCoreRateLimitingRequests is the metric conforming to the // "aspnetcore.rate_limiting.requests" semantic conventions. It represents the // number of requests that tried to acquire a rate limiting lease. // Instrument: counter // Unit: {request} // Stability: Experimental - AspnetcoreRateLimitingRequestsName = "aspnetcore.rate_limiting.requests" - AspnetcoreRateLimitingRequestsUnit = "{request}" - AspnetcoreRateLimitingRequestsDescription = "Number of requests that tried to acquire a rate limiting lease." + ASPNETCoreRateLimitingRequestsName = "aspnetcore.rate_limiting.requests" + ASPNETCoreRateLimitingRequestsUnit = "{request}" + ASPNETCoreRateLimitingRequestsDescription = "Number of requests that tried to acquire a rate limiting lease." // DNSLookupDuration is the metric conforming to the "dns.lookup.duration" // semantic conventions. It represents the measures the time taken to perform a @@ -492,177 +492,177 @@ const ( HTTPClientResponseBodySizeUnit = "By" HTTPClientResponseBodySizeDescription = "Size of HTTP client response bodies." - // JvmMemoryInit is the metric conforming to the "jvm.memory.init" semantic + // JVMMemoryInit is the metric conforming to the "jvm.memory.init" semantic // conventions. It represents the measure of initial memory requested. // Instrument: updowncounter // Unit: By // Stability: Experimental - JvmMemoryInitName = "jvm.memory.init" - JvmMemoryInitUnit = "By" - JvmMemoryInitDescription = "Measure of initial memory requested." + JVMMemoryInitName = "jvm.memory.init" + JVMMemoryInitUnit = "By" + JVMMemoryInitDescription = "Measure of initial memory requested." - // JvmSystemCPUUtilization is the metric conforming to the + // JVMSystemCPUUtilization is the metric conforming to the // "jvm.system.cpu.utilization" semantic conventions. It represents the recent // CPU utilization for the whole system as reported by the JVM. // Instrument: gauge // Unit: 1 // Stability: Experimental - JvmSystemCPUUtilizationName = "jvm.system.cpu.utilization" - JvmSystemCPUUtilizationUnit = "1" - JvmSystemCPUUtilizationDescription = "Recent CPU utilization for the whole system as reported by the JVM." + JVMSystemCPUUtilizationName = "jvm.system.cpu.utilization" + JVMSystemCPUUtilizationUnit = "1" + JVMSystemCPUUtilizationDescription = "Recent CPU utilization for the whole system as reported by the JVM." - // JvmSystemCPULoad1m is the metric conforming to the "jvm.system.cpu.load_1m" + // JVMSystemCPULoad1m is the metric conforming to the "jvm.system.cpu.load_1m" // semantic conventions. It represents the average CPU load of the whole system // for the last minute as reported by the JVM. // Instrument: gauge // Unit: {run_queue_item} // Stability: Experimental - JvmSystemCPULoad1mName = "jvm.system.cpu.load_1m" - JvmSystemCPULoad1mUnit = "{run_queue_item}" - JvmSystemCPULoad1mDescription = "Average CPU load of the whole system for the last minute as reported by the JVM." + JVMSystemCPULoad1mName = "jvm.system.cpu.load_1m" + JVMSystemCPULoad1mUnit = "{run_queue_item}" + JVMSystemCPULoad1mDescription = "Average CPU load of the whole system for the last minute as reported by the JVM." - // JvmBufferMemoryUsage is the metric conforming to the + // JVMBufferMemoryUsage is the metric conforming to the // "jvm.buffer.memory.usage" semantic conventions. It represents the measure of // memory used by buffers. // Instrument: updowncounter // Unit: By // Stability: Experimental - JvmBufferMemoryUsageName = "jvm.buffer.memory.usage" - JvmBufferMemoryUsageUnit = "By" - JvmBufferMemoryUsageDescription = "Measure of memory used by buffers." + JVMBufferMemoryUsageName = "jvm.buffer.memory.usage" + JVMBufferMemoryUsageUnit = "By" + JVMBufferMemoryUsageDescription = "Measure of memory used by buffers." - // JvmBufferMemoryLimit is the metric conforming to the + // JVMBufferMemoryLimit is the metric conforming to the // "jvm.buffer.memory.limit" semantic conventions. It represents the measure of // total memory capacity of buffers. // Instrument: updowncounter // Unit: By // Stability: Experimental - JvmBufferMemoryLimitName = "jvm.buffer.memory.limit" - JvmBufferMemoryLimitUnit = "By" - JvmBufferMemoryLimitDescription = "Measure of total memory capacity of buffers." + JVMBufferMemoryLimitName = "jvm.buffer.memory.limit" + JVMBufferMemoryLimitUnit = "By" + JVMBufferMemoryLimitDescription = "Measure of total memory capacity of buffers." - // JvmBufferCount is the metric conforming to the "jvm.buffer.count" semantic + // JVMBufferCount is the metric conforming to the "jvm.buffer.count" semantic // conventions. It represents the number of buffers in the pool. // Instrument: updowncounter // Unit: {buffer} // Stability: Experimental - JvmBufferCountName = "jvm.buffer.count" - JvmBufferCountUnit = "{buffer}" - JvmBufferCountDescription = "Number of buffers in the pool." + JVMBufferCountName = "jvm.buffer.count" + JVMBufferCountUnit = "{buffer}" + JVMBufferCountDescription = "Number of buffers in the pool." - // JvmMemoryUsed is the metric conforming to the "jvm.memory.used" semantic + // JVMMemoryUsed is the metric conforming to the "jvm.memory.used" semantic // conventions. It represents the measure of memory used. // Instrument: updowncounter // Unit: By // Stability: Stable - JvmMemoryUsedName = "jvm.memory.used" - JvmMemoryUsedUnit = "By" - JvmMemoryUsedDescription = "Measure of memory used." + JVMMemoryUsedName = "jvm.memory.used" + JVMMemoryUsedUnit = "By" + JVMMemoryUsedDescription = "Measure of memory used." - // JvmMemoryCommitted is the metric conforming to the "jvm.memory.committed" + // JVMMemoryCommitted is the metric conforming to the "jvm.memory.committed" // semantic conventions. It represents the measure of memory committed. // Instrument: updowncounter // Unit: By // Stability: Stable - JvmMemoryCommittedName = "jvm.memory.committed" - JvmMemoryCommittedUnit = "By" - JvmMemoryCommittedDescription = "Measure of memory committed." + JVMMemoryCommittedName = "jvm.memory.committed" + JVMMemoryCommittedUnit = "By" + JVMMemoryCommittedDescription = "Measure of memory committed." - // JvmMemoryLimit is the metric conforming to the "jvm.memory.limit" semantic + // JVMMemoryLimit is the metric conforming to the "jvm.memory.limit" semantic // conventions. It represents the measure of max obtainable memory. // Instrument: updowncounter // Unit: By // Stability: Stable - JvmMemoryLimitName = "jvm.memory.limit" - JvmMemoryLimitUnit = "By" - JvmMemoryLimitDescription = "Measure of max obtainable memory." + JVMMemoryLimitName = "jvm.memory.limit" + JVMMemoryLimitUnit = "By" + JVMMemoryLimitDescription = "Measure of max obtainable memory." - // JvmMemoryUsedAfterLastGc is the metric conforming to the + // JVMMemoryUsedAfterLastGc is the metric conforming to the // "jvm.memory.used_after_last_gc" semantic conventions. It represents the // measure of memory used, as measured after the most recent garbage collection // event on this pool. // Instrument: updowncounter // Unit: By // Stability: Stable - JvmMemoryUsedAfterLastGcName = "jvm.memory.used_after_last_gc" - JvmMemoryUsedAfterLastGcUnit = "By" - JvmMemoryUsedAfterLastGcDescription = "Measure of memory used, as measured after the most recent garbage collection event on this pool." + JVMMemoryUsedAfterLastGcName = "jvm.memory.used_after_last_gc" + JVMMemoryUsedAfterLastGcUnit = "By" + JVMMemoryUsedAfterLastGcDescription = "Measure of memory used, as measured after the most recent garbage collection event on this pool." - // JvmGcDuration is the metric conforming to the "jvm.gc.duration" semantic + // JVMGcDuration is the metric conforming to the "jvm.gc.duration" semantic // conventions. It represents the duration of JVM garbage collection actions. // Instrument: histogram // Unit: s // Stability: Stable - JvmGcDurationName = "jvm.gc.duration" - JvmGcDurationUnit = "s" - JvmGcDurationDescription = "Duration of JVM garbage collection actions." + JVMGcDurationName = "jvm.gc.duration" + JVMGcDurationUnit = "s" + JVMGcDurationDescription = "Duration of JVM garbage collection actions." - // JvmThreadCount is the metric conforming to the "jvm.thread.count" semantic + // JVMThreadCount is the metric conforming to the "jvm.thread.count" semantic // conventions. It represents the number of executing platform threads. // Instrument: updowncounter // Unit: {thread} // Stability: Stable - JvmThreadCountName = "jvm.thread.count" - JvmThreadCountUnit = "{thread}" - JvmThreadCountDescription = "Number of executing platform threads." + JVMThreadCountName = "jvm.thread.count" + JVMThreadCountUnit = "{thread}" + JVMThreadCountDescription = "Number of executing platform threads." - // JvmClassLoaded is the metric conforming to the "jvm.class.loaded" semantic + // JVMClassLoaded is the metric conforming to the "jvm.class.loaded" semantic // conventions. It represents the number of classes loaded since JVM start. // Instrument: counter // Unit: {class} // Stability: Stable - JvmClassLoadedName = "jvm.class.loaded" - JvmClassLoadedUnit = "{class}" - JvmClassLoadedDescription = "Number of classes loaded since JVM start." + JVMClassLoadedName = "jvm.class.loaded" + JVMClassLoadedUnit = "{class}" + JVMClassLoadedDescription = "Number of classes loaded since JVM start." - // JvmClassUnloaded is the metric conforming to the "jvm.class.unloaded" + // JVMClassUnloaded is the metric conforming to the "jvm.class.unloaded" // semantic conventions. It represents the number of classes unloaded since JVM // start. // Instrument: counter // Unit: {class} // Stability: Stable - JvmClassUnloadedName = "jvm.class.unloaded" - JvmClassUnloadedUnit = "{class}" - JvmClassUnloadedDescription = "Number of classes unloaded since JVM start." + JVMClassUnloadedName = "jvm.class.unloaded" + JVMClassUnloadedUnit = "{class}" + JVMClassUnloadedDescription = "Number of classes unloaded since JVM start." - // JvmClassCount is the metric conforming to the "jvm.class.count" semantic + // JVMClassCount is the metric conforming to the "jvm.class.count" semantic // conventions. It represents the number of classes currently loaded. // Instrument: updowncounter // Unit: {class} // Stability: Stable - JvmClassCountName = "jvm.class.count" - JvmClassCountUnit = "{class}" - JvmClassCountDescription = "Number of classes currently loaded." + JVMClassCountName = "jvm.class.count" + JVMClassCountUnit = "{class}" + JVMClassCountDescription = "Number of classes currently loaded." - // JvmCPUCount is the metric conforming to the "jvm.cpu.count" semantic + // JVMCPUCount is the metric conforming to the "jvm.cpu.count" semantic // conventions. It represents the number of processors available to the Java // virtual machine. // Instrument: updowncounter // Unit: {cpu} // Stability: Stable - JvmCPUCountName = "jvm.cpu.count" - JvmCPUCountUnit = "{cpu}" - JvmCPUCountDescription = "Number of processors available to the Java virtual machine." + JVMCPUCountName = "jvm.cpu.count" + JVMCPUCountUnit = "{cpu}" + JVMCPUCountDescription = "Number of processors available to the Java virtual machine." - // JvmCPUTime is the metric conforming to the "jvm.cpu.time" semantic + // JVMCPUTime is the metric conforming to the "jvm.cpu.time" semantic // conventions. It represents the cPU time used by the process as reported by // the JVM. // Instrument: counter // Unit: s // Stability: Stable - JvmCPUTimeName = "jvm.cpu.time" - JvmCPUTimeUnit = "s" - JvmCPUTimeDescription = "CPU time used by the process as reported by the JVM." + JVMCPUTimeName = "jvm.cpu.time" + JVMCPUTimeUnit = "s" + JVMCPUTimeDescription = "CPU time used by the process as reported by the JVM." - // JvmCPURecentUtilization is the metric conforming to the + // JVMCPURecentUtilization is the metric conforming to the // "jvm.cpu.recent_utilization" semantic conventions. It represents the recent // CPU utilization for the process as reported by the JVM. // Instrument: gauge // Unit: 1 // Stability: Stable - JvmCPURecentUtilizationName = "jvm.cpu.recent_utilization" - JvmCPURecentUtilizationUnit = "1" - JvmCPURecentUtilizationDescription = "Recent CPU utilization for the process as reported by the JVM." + JVMCPURecentUtilizationName = "jvm.cpu.recent_utilization" + JVMCPURecentUtilizationUnit = "1" + JVMCPURecentUtilizationDescription = "Recent CPU utilization for the process as reported by the JVM." // MessagingPublishDuration is the metric conforming to the // "messaging.publish.duration" semantic conventions. It represents the From dccb44d4f293998fc25d0e966c42b165bbf0cde7 Mon Sep 17 00:00:00 2001 From: Ben Carr Date: Wed, 13 Mar 2024 17:35:12 -0700 Subject: [PATCH 08/11] update metrics file with concise generated license header --- semconv/v1.24.0/metric.go | 13 +------------ 1 file changed, 1 insertion(+), 12 deletions(-) diff --git a/semconv/v1.24.0/metric.go b/semconv/v1.24.0/metric.go index b9292df916f..c98ee845e09 100644 --- a/semconv/v1.24.0/metric.go +++ b/semconv/v1.24.0/metric.go @@ -1,16 +1,5 @@ // Copyright The OpenTelemetry Authors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// SPDX-License-Identifier: Apache-2.0 // Code generated from semantic convention specification. DO NOT EDIT. From 21773166b0afc4d97924b4115b46386c1fedab2c Mon Sep 17 00:00:00 2001 From: Ben Carr Date: Fri, 15 Mar 2024 14:26:09 -0700 Subject: [PATCH 09/11] revert special formatting logic for JVM and ASPNETCore --- semconv/metric_template.j2 | 12 +-- semconv/v1.24.0/metric.go | 200 ++++++++++++++++++------------------- 2 files changed, 103 insertions(+), 109 deletions(-) diff --git a/semconv/metric_template.j2 b/semconv/metric_template.j2 index 20dcaca0a84..144d280a875 100644 --- a/semconv/metric_template.j2 +++ b/semconv/metric_template.j2 @@ -1,12 +1,6 @@ -{% macro to_go_name(name) -%} - {%- if name.startswith('aspnetcore.') -%} - ASPNETCore{{ name[11:] | replace(".", " ") | replace("_", " ") | title | replace(" ", "") }} - {%- elif name.startswith('jvm.') -%} - JVM{{ name[4:] | replace(".", " ") | replace("_", " ") | title | replace(" ", "") }} - {%- else -%} - {{ name | replace(".", " ") | replace("_", " ") | title | replace(" ", "") }} - {%- endif -%} -{%- endmacro %} +{%- macro to_go_name(fqn) -%} +{{fqn | replace(".", " ") | replace("_", " ") | title | replace(" ", "")}} +{%- endmacro -%} {%- macro it_reps(brief) -%} It represents {% if brief[:2] == "A " or brief[:3] == "An " or brief[:4] == "The " -%} {{ brief[0]|lower }}{{ brief[1:] }} diff --git a/semconv/v1.24.0/metric.go b/semconv/v1.24.0/metric.go index c98ee845e09..a6b953f625e 100644 --- a/semconv/v1.24.0/metric.go +++ b/semconv/v1.24.0/metric.go @@ -100,79 +100,79 @@ const ( DBClientConnectionsUseTimeUnit = "ms" DBClientConnectionsUseTimeDescription = "The time between borrowing a connection and returning it to the pool" - // ASPNETCoreRoutingMatchAttempts is the metric conforming to the + // AspnetcoreRoutingMatchAttempts is the metric conforming to the // "aspnetcore.routing.match_attempts" semantic conventions. It represents the // number of requests that were attempted to be matched to an endpoint. // Instrument: counter // Unit: {match_attempt} // Stability: Experimental - ASPNETCoreRoutingMatchAttemptsName = "aspnetcore.routing.match_attempts" - ASPNETCoreRoutingMatchAttemptsUnit = "{match_attempt}" - ASPNETCoreRoutingMatchAttemptsDescription = "Number of requests that were attempted to be matched to an endpoint." + AspnetcoreRoutingMatchAttemptsName = "aspnetcore.routing.match_attempts" + AspnetcoreRoutingMatchAttemptsUnit = "{match_attempt}" + AspnetcoreRoutingMatchAttemptsDescription = "Number of requests that were attempted to be matched to an endpoint." - // ASPNETCoreDiagnosticsExceptions is the metric conforming to the + // AspnetcoreDiagnosticsExceptions is the metric conforming to the // "aspnetcore.diagnostics.exceptions" semantic conventions. It represents the // number of exceptions caught by exception handling middleware. // Instrument: counter // Unit: {exception} // Stability: Experimental - ASPNETCoreDiagnosticsExceptionsName = "aspnetcore.diagnostics.exceptions" - ASPNETCoreDiagnosticsExceptionsUnit = "{exception}" - ASPNETCoreDiagnosticsExceptionsDescription = "Number of exceptions caught by exception handling middleware." + AspnetcoreDiagnosticsExceptionsName = "aspnetcore.diagnostics.exceptions" + AspnetcoreDiagnosticsExceptionsUnit = "{exception}" + AspnetcoreDiagnosticsExceptionsDescription = "Number of exceptions caught by exception handling middleware." - // ASPNETCoreRateLimitingActiveRequestLeases is the metric conforming to the + // AspnetcoreRateLimitingActiveRequestLeases is the metric conforming to the // "aspnetcore.rate_limiting.active_request_leases" semantic conventions. It // represents the number of requests that are currently active on the server // that hold a rate limiting lease. // Instrument: updowncounter // Unit: {request} // Stability: Experimental - ASPNETCoreRateLimitingActiveRequestLeasesName = "aspnetcore.rate_limiting.active_request_leases" - ASPNETCoreRateLimitingActiveRequestLeasesUnit = "{request}" - ASPNETCoreRateLimitingActiveRequestLeasesDescription = "Number of requests that are currently active on the server that hold a rate limiting lease." + AspnetcoreRateLimitingActiveRequestLeasesName = "aspnetcore.rate_limiting.active_request_leases" + AspnetcoreRateLimitingActiveRequestLeasesUnit = "{request}" + AspnetcoreRateLimitingActiveRequestLeasesDescription = "Number of requests that are currently active on the server that hold a rate limiting lease." - // ASPNETCoreRateLimitingRequestLeaseDuration is the metric conforming to the + // AspnetcoreRateLimitingRequestLeaseDuration is the metric conforming to the // "aspnetcore.rate_limiting.request_lease.duration" semantic conventions. It // represents the duration of rate limiting lease held by requests on the // server. // Instrument: histogram // Unit: s // Stability: Experimental - ASPNETCoreRateLimitingRequestLeaseDurationName = "aspnetcore.rate_limiting.request_lease.duration" - ASPNETCoreRateLimitingRequestLeaseDurationUnit = "s" - ASPNETCoreRateLimitingRequestLeaseDurationDescription = "The duration of rate limiting lease held by requests on the server." + AspnetcoreRateLimitingRequestLeaseDurationName = "aspnetcore.rate_limiting.request_lease.duration" + AspnetcoreRateLimitingRequestLeaseDurationUnit = "s" + AspnetcoreRateLimitingRequestLeaseDurationDescription = "The duration of rate limiting lease held by requests on the server." - // ASPNETCoreRateLimitingRequestTimeInQueue is the metric conforming to the + // AspnetcoreRateLimitingRequestTimeInQueue is the metric conforming to the // "aspnetcore.rate_limiting.request.time_in_queue" semantic conventions. It // represents the time the request spent in a queue waiting to acquire a rate // limiting lease. // Instrument: histogram // Unit: s // Stability: Experimental - ASPNETCoreRateLimitingRequestTimeInQueueName = "aspnetcore.rate_limiting.request.time_in_queue" - ASPNETCoreRateLimitingRequestTimeInQueueUnit = "s" - ASPNETCoreRateLimitingRequestTimeInQueueDescription = "The time the request spent in a queue waiting to acquire a rate limiting lease." + AspnetcoreRateLimitingRequestTimeInQueueName = "aspnetcore.rate_limiting.request.time_in_queue" + AspnetcoreRateLimitingRequestTimeInQueueUnit = "s" + AspnetcoreRateLimitingRequestTimeInQueueDescription = "The time the request spent in a queue waiting to acquire a rate limiting lease." - // ASPNETCoreRateLimitingQueuedRequests is the metric conforming to the + // AspnetcoreRateLimitingQueuedRequests is the metric conforming to the // "aspnetcore.rate_limiting.queued_requests" semantic conventions. It // represents the number of requests that are currently queued, waiting to // acquire a rate limiting lease. // Instrument: updowncounter // Unit: {request} // Stability: Experimental - ASPNETCoreRateLimitingQueuedRequestsName = "aspnetcore.rate_limiting.queued_requests" - ASPNETCoreRateLimitingQueuedRequestsUnit = "{request}" - ASPNETCoreRateLimitingQueuedRequestsDescription = "Number of requests that are currently queued, waiting to acquire a rate limiting lease." + AspnetcoreRateLimitingQueuedRequestsName = "aspnetcore.rate_limiting.queued_requests" + AspnetcoreRateLimitingQueuedRequestsUnit = "{request}" + AspnetcoreRateLimitingQueuedRequestsDescription = "Number of requests that are currently queued, waiting to acquire a rate limiting lease." - // ASPNETCoreRateLimitingRequests is the metric conforming to the + // AspnetcoreRateLimitingRequests is the metric conforming to the // "aspnetcore.rate_limiting.requests" semantic conventions. It represents the // number of requests that tried to acquire a rate limiting lease. // Instrument: counter // Unit: {request} // Stability: Experimental - ASPNETCoreRateLimitingRequestsName = "aspnetcore.rate_limiting.requests" - ASPNETCoreRateLimitingRequestsUnit = "{request}" - ASPNETCoreRateLimitingRequestsDescription = "Number of requests that tried to acquire a rate limiting lease." + AspnetcoreRateLimitingRequestsName = "aspnetcore.rate_limiting.requests" + AspnetcoreRateLimitingRequestsUnit = "{request}" + AspnetcoreRateLimitingRequestsDescription = "Number of requests that tried to acquire a rate limiting lease." // DNSLookupDuration is the metric conforming to the "dns.lookup.duration" // semantic conventions. It represents the measures the time taken to perform a @@ -481,177 +481,177 @@ const ( HTTPClientResponseBodySizeUnit = "By" HTTPClientResponseBodySizeDescription = "Size of HTTP client response bodies." - // JVMMemoryInit is the metric conforming to the "jvm.memory.init" semantic + // JvmMemoryInit is the metric conforming to the "jvm.memory.init" semantic // conventions. It represents the measure of initial memory requested. // Instrument: updowncounter // Unit: By // Stability: Experimental - JVMMemoryInitName = "jvm.memory.init" - JVMMemoryInitUnit = "By" - JVMMemoryInitDescription = "Measure of initial memory requested." + JvmMemoryInitName = "jvm.memory.init" + JvmMemoryInitUnit = "By" + JvmMemoryInitDescription = "Measure of initial memory requested." - // JVMSystemCPUUtilization is the metric conforming to the + // JvmSystemCPUUtilization is the metric conforming to the // "jvm.system.cpu.utilization" semantic conventions. It represents the recent // CPU utilization for the whole system as reported by the JVM. // Instrument: gauge // Unit: 1 // Stability: Experimental - JVMSystemCPUUtilizationName = "jvm.system.cpu.utilization" - JVMSystemCPUUtilizationUnit = "1" - JVMSystemCPUUtilizationDescription = "Recent CPU utilization for the whole system as reported by the JVM." + JvmSystemCPUUtilizationName = "jvm.system.cpu.utilization" + JvmSystemCPUUtilizationUnit = "1" + JvmSystemCPUUtilizationDescription = "Recent CPU utilization for the whole system as reported by the JVM." - // JVMSystemCPULoad1m is the metric conforming to the "jvm.system.cpu.load_1m" + // JvmSystemCPULoad1m is the metric conforming to the "jvm.system.cpu.load_1m" // semantic conventions. It represents the average CPU load of the whole system // for the last minute as reported by the JVM. // Instrument: gauge // Unit: {run_queue_item} // Stability: Experimental - JVMSystemCPULoad1mName = "jvm.system.cpu.load_1m" - JVMSystemCPULoad1mUnit = "{run_queue_item}" - JVMSystemCPULoad1mDescription = "Average CPU load of the whole system for the last minute as reported by the JVM." + JvmSystemCPULoad1mName = "jvm.system.cpu.load_1m" + JvmSystemCPULoad1mUnit = "{run_queue_item}" + JvmSystemCPULoad1mDescription = "Average CPU load of the whole system for the last minute as reported by the JVM." - // JVMBufferMemoryUsage is the metric conforming to the + // JvmBufferMemoryUsage is the metric conforming to the // "jvm.buffer.memory.usage" semantic conventions. It represents the measure of // memory used by buffers. // Instrument: updowncounter // Unit: By // Stability: Experimental - JVMBufferMemoryUsageName = "jvm.buffer.memory.usage" - JVMBufferMemoryUsageUnit = "By" - JVMBufferMemoryUsageDescription = "Measure of memory used by buffers." + JvmBufferMemoryUsageName = "jvm.buffer.memory.usage" + JvmBufferMemoryUsageUnit = "By" + JvmBufferMemoryUsageDescription = "Measure of memory used by buffers." - // JVMBufferMemoryLimit is the metric conforming to the + // JvmBufferMemoryLimit is the metric conforming to the // "jvm.buffer.memory.limit" semantic conventions. It represents the measure of // total memory capacity of buffers. // Instrument: updowncounter // Unit: By // Stability: Experimental - JVMBufferMemoryLimitName = "jvm.buffer.memory.limit" - JVMBufferMemoryLimitUnit = "By" - JVMBufferMemoryLimitDescription = "Measure of total memory capacity of buffers." + JvmBufferMemoryLimitName = "jvm.buffer.memory.limit" + JvmBufferMemoryLimitUnit = "By" + JvmBufferMemoryLimitDescription = "Measure of total memory capacity of buffers." - // JVMBufferCount is the metric conforming to the "jvm.buffer.count" semantic + // JvmBufferCount is the metric conforming to the "jvm.buffer.count" semantic // conventions. It represents the number of buffers in the pool. // Instrument: updowncounter // Unit: {buffer} // Stability: Experimental - JVMBufferCountName = "jvm.buffer.count" - JVMBufferCountUnit = "{buffer}" - JVMBufferCountDescription = "Number of buffers in the pool." + JvmBufferCountName = "jvm.buffer.count" + JvmBufferCountUnit = "{buffer}" + JvmBufferCountDescription = "Number of buffers in the pool." - // JVMMemoryUsed is the metric conforming to the "jvm.memory.used" semantic + // JvmMemoryUsed is the metric conforming to the "jvm.memory.used" semantic // conventions. It represents the measure of memory used. // Instrument: updowncounter // Unit: By // Stability: Stable - JVMMemoryUsedName = "jvm.memory.used" - JVMMemoryUsedUnit = "By" - JVMMemoryUsedDescription = "Measure of memory used." + JvmMemoryUsedName = "jvm.memory.used" + JvmMemoryUsedUnit = "By" + JvmMemoryUsedDescription = "Measure of memory used." - // JVMMemoryCommitted is the metric conforming to the "jvm.memory.committed" + // JvmMemoryCommitted is the metric conforming to the "jvm.memory.committed" // semantic conventions. It represents the measure of memory committed. // Instrument: updowncounter // Unit: By // Stability: Stable - JVMMemoryCommittedName = "jvm.memory.committed" - JVMMemoryCommittedUnit = "By" - JVMMemoryCommittedDescription = "Measure of memory committed." + JvmMemoryCommittedName = "jvm.memory.committed" + JvmMemoryCommittedUnit = "By" + JvmMemoryCommittedDescription = "Measure of memory committed." - // JVMMemoryLimit is the metric conforming to the "jvm.memory.limit" semantic + // JvmMemoryLimit is the metric conforming to the "jvm.memory.limit" semantic // conventions. It represents the measure of max obtainable memory. // Instrument: updowncounter // Unit: By // Stability: Stable - JVMMemoryLimitName = "jvm.memory.limit" - JVMMemoryLimitUnit = "By" - JVMMemoryLimitDescription = "Measure of max obtainable memory." + JvmMemoryLimitName = "jvm.memory.limit" + JvmMemoryLimitUnit = "By" + JvmMemoryLimitDescription = "Measure of max obtainable memory." - // JVMMemoryUsedAfterLastGc is the metric conforming to the + // JvmMemoryUsedAfterLastGc is the metric conforming to the // "jvm.memory.used_after_last_gc" semantic conventions. It represents the // measure of memory used, as measured after the most recent garbage collection // event on this pool. // Instrument: updowncounter // Unit: By // Stability: Stable - JVMMemoryUsedAfterLastGcName = "jvm.memory.used_after_last_gc" - JVMMemoryUsedAfterLastGcUnit = "By" - JVMMemoryUsedAfterLastGcDescription = "Measure of memory used, as measured after the most recent garbage collection event on this pool." + JvmMemoryUsedAfterLastGcName = "jvm.memory.used_after_last_gc" + JvmMemoryUsedAfterLastGcUnit = "By" + JvmMemoryUsedAfterLastGcDescription = "Measure of memory used, as measured after the most recent garbage collection event on this pool." - // JVMGcDuration is the metric conforming to the "jvm.gc.duration" semantic + // JvmGcDuration is the metric conforming to the "jvm.gc.duration" semantic // conventions. It represents the duration of JVM garbage collection actions. // Instrument: histogram // Unit: s // Stability: Stable - JVMGcDurationName = "jvm.gc.duration" - JVMGcDurationUnit = "s" - JVMGcDurationDescription = "Duration of JVM garbage collection actions." + JvmGcDurationName = "jvm.gc.duration" + JvmGcDurationUnit = "s" + JvmGcDurationDescription = "Duration of JVM garbage collection actions." - // JVMThreadCount is the metric conforming to the "jvm.thread.count" semantic + // JvmThreadCount is the metric conforming to the "jvm.thread.count" semantic // conventions. It represents the number of executing platform threads. // Instrument: updowncounter // Unit: {thread} // Stability: Stable - JVMThreadCountName = "jvm.thread.count" - JVMThreadCountUnit = "{thread}" - JVMThreadCountDescription = "Number of executing platform threads." + JvmThreadCountName = "jvm.thread.count" + JvmThreadCountUnit = "{thread}" + JvmThreadCountDescription = "Number of executing platform threads." - // JVMClassLoaded is the metric conforming to the "jvm.class.loaded" semantic + // JvmClassLoaded is the metric conforming to the "jvm.class.loaded" semantic // conventions. It represents the number of classes loaded since JVM start. // Instrument: counter // Unit: {class} // Stability: Stable - JVMClassLoadedName = "jvm.class.loaded" - JVMClassLoadedUnit = "{class}" - JVMClassLoadedDescription = "Number of classes loaded since JVM start." + JvmClassLoadedName = "jvm.class.loaded" + JvmClassLoadedUnit = "{class}" + JvmClassLoadedDescription = "Number of classes loaded since JVM start." - // JVMClassUnloaded is the metric conforming to the "jvm.class.unloaded" + // JvmClassUnloaded is the metric conforming to the "jvm.class.unloaded" // semantic conventions. It represents the number of classes unloaded since JVM // start. // Instrument: counter // Unit: {class} // Stability: Stable - JVMClassUnloadedName = "jvm.class.unloaded" - JVMClassUnloadedUnit = "{class}" - JVMClassUnloadedDescription = "Number of classes unloaded since JVM start." + JvmClassUnloadedName = "jvm.class.unloaded" + JvmClassUnloadedUnit = "{class}" + JvmClassUnloadedDescription = "Number of classes unloaded since JVM start." - // JVMClassCount is the metric conforming to the "jvm.class.count" semantic + // JvmClassCount is the metric conforming to the "jvm.class.count" semantic // conventions. It represents the number of classes currently loaded. // Instrument: updowncounter // Unit: {class} // Stability: Stable - JVMClassCountName = "jvm.class.count" - JVMClassCountUnit = "{class}" - JVMClassCountDescription = "Number of classes currently loaded." + JvmClassCountName = "jvm.class.count" + JvmClassCountUnit = "{class}" + JvmClassCountDescription = "Number of classes currently loaded." - // JVMCPUCount is the metric conforming to the "jvm.cpu.count" semantic + // JvmCPUCount is the metric conforming to the "jvm.cpu.count" semantic // conventions. It represents the number of processors available to the Java // virtual machine. // Instrument: updowncounter // Unit: {cpu} // Stability: Stable - JVMCPUCountName = "jvm.cpu.count" - JVMCPUCountUnit = "{cpu}" - JVMCPUCountDescription = "Number of processors available to the Java virtual machine." + JvmCPUCountName = "jvm.cpu.count" + JvmCPUCountUnit = "{cpu}" + JvmCPUCountDescription = "Number of processors available to the Java virtual machine." - // JVMCPUTime is the metric conforming to the "jvm.cpu.time" semantic + // JvmCPUTime is the metric conforming to the "jvm.cpu.time" semantic // conventions. It represents the cPU time used by the process as reported by // the JVM. // Instrument: counter // Unit: s // Stability: Stable - JVMCPUTimeName = "jvm.cpu.time" - JVMCPUTimeUnit = "s" - JVMCPUTimeDescription = "CPU time used by the process as reported by the JVM." + JvmCPUTimeName = "jvm.cpu.time" + JvmCPUTimeUnit = "s" + JvmCPUTimeDescription = "CPU time used by the process as reported by the JVM." - // JVMCPURecentUtilization is the metric conforming to the + // JvmCPURecentUtilization is the metric conforming to the // "jvm.cpu.recent_utilization" semantic conventions. It represents the recent // CPU utilization for the process as reported by the JVM. // Instrument: gauge // Unit: 1 // Stability: Stable - JVMCPURecentUtilizationName = "jvm.cpu.recent_utilization" - JVMCPURecentUtilizationUnit = "1" - JVMCPURecentUtilizationDescription = "Recent CPU utilization for the process as reported by the JVM." + JvmCPURecentUtilizationName = "jvm.cpu.recent_utilization" + JvmCPURecentUtilizationUnit = "1" + JvmCPURecentUtilizationDescription = "Recent CPU utilization for the process as reported by the JVM." // MessagingPublishDuration is the metric conforming to the // "messaging.publish.duration" semantic conventions. It represents the From 2a5c71224aa61029e61bad9661f4496649e64d76 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Robert=20Paj=C4=85k?= Date: Fri, 15 Mar 2024 23:01:43 +0100 Subject: [PATCH 10/11] Update CHANGELOG.md --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 43073ad2f3f..ed8b58eb907 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm - Add `SeverityUndefined` `const` to `go.opentelemetry.io/otel/log`. This value represents an unset severity level. (#5072) - Add `Empty` function in `go.opentelemetry.io/otel/log` to return a `KeyValue` for an empty value. (#5076) -- Adds a new template to generate metric semantic conventions, as well as adding it to the Makefile `semconv-generate` script to add the metric.go file to the v1.24.0 directory. (#4528) +- Add metric semantic conventions to `go.opentelemetry.io/otel/semconv/v1.24.0`. Future `semconv` packages will include metric semantic conventions as well. (#4528) ### Changed From 296624e4f49529113d064a0eb3e8f77bd13f1162 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Robert=20Paj=C4=85k?= Date: Thu, 4 Apr 2024 10:50:52 +0200 Subject: [PATCH 11/11] Update CHANGELOG.md Co-authored-by: Damien Mathieu <42@dmathieu.com> --- CHANGELOG.md | 1 - 1 file changed, 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9f161e2e0f3..dfad8986c49 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2975,4 +2975,3 @@ It contains api and sdk for trace and meter. [metric API]:https://pkg.go.dev/go.opentelemetry.io/otel/metric [metric SDK]:https://pkg.go.dev/go.opentelemetry.io/otel/sdk/metric [trace API]:https://pkg.go.dev/go.opentelemetry.io/otel/trace -