diff --git a/api/include/opentelemetry/semconv/azure_metrics.h b/api/include/opentelemetry/semconv/azure_metrics.h
new file mode 100644
index 0000000000..63f4556b0b
--- /dev/null
+++ b/api/include/opentelemetry/semconv/azure_metrics.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace azure
+{
+
+/**
+ * Number of active client instances
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricAzureCosmosdbClientActiveInstanceCount =
+    "azure.cosmosdb.client.active_instance.count";
+static constexpr const char *descrMetricAzureCosmosdbClientActiveInstanceCount =
+    "Number of active client instances";
+static constexpr const char *unitMetricAzureCosmosdbClientActiveInstanceCount = "{instance}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricAzureCosmosdbClientActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricAzureCosmosdbClientActiveInstanceCount,
+                                         descrMetricAzureCosmosdbClientActiveInstanceCount,
+                                         unitMetricAzureCosmosdbClientActiveInstanceCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricAzureCosmosdbClientActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricAzureCosmosdbClientActiveInstanceCount,
+                                          descrMetricAzureCosmosdbClientActiveInstanceCount,
+                                          unitMetricAzureCosmosdbClientActiveInstanceCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricAzureCosmosdbClientActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricAzureCosmosdbClientActiveInstanceCount,
+      descrMetricAzureCosmosdbClientActiveInstanceCount,
+      unitMetricAzureCosmosdbClientActiveInstanceCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricAzureCosmosdbClientActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricAzureCosmosdbClientActiveInstanceCount,
+      descrMetricAzureCosmosdbClientActiveInstanceCount,
+      unitMetricAzureCosmosdbClientActiveInstanceCount);
+}
+
+/**
+ * <a href="https://learn.microsoft.com/azure/cosmos-db/request-units">Request units</a> consumed by
+ * the operation <p> histogram
+ */
+static constexpr const char *kMetricAzureCosmosdbClientOperationRequestCharge =
+    "azure.cosmosdb.client.operation.request_charge";
+static constexpr const char *descrMetricAzureCosmosdbClientOperationRequestCharge =
+    "[Request units](https://learn.microsoft.com/azure/cosmos-db/request-units) consumed by the "
+    "operation";
+static constexpr const char *unitMetricAzureCosmosdbClientOperationRequestCharge = "{request_unit}";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricAzureCosmosdbClientOperationRequestCharge(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricAzureCosmosdbClientOperationRequestCharge,
+                                      descrMetricAzureCosmosdbClientOperationRequestCharge,
+                                      unitMetricAzureCosmosdbClientOperationRequestCharge);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricAzureCosmosdbClientOperationRequestCharge(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricAzureCosmosdbClientOperationRequestCharge,
+                                      descrMetricAzureCosmosdbClientOperationRequestCharge,
+                                      unitMetricAzureCosmosdbClientOperationRequestCharge);
+}
+
+}  // namespace azure
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/cicd_metrics.h b/api/include/opentelemetry/semconv/cicd_metrics.h
new file mode 100644
index 0000000000..993c2636f4
--- /dev/null
+++ b/api/include/opentelemetry/semconv/cicd_metrics.h
@@ -0,0 +1,213 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace cicd
+{
+
+/**
+ * The number of pipeline runs currently active in the system by state.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricCicdPipelineRunActive = "cicd.pipeline.run.active";
+static constexpr const char *descrMetricCicdPipelineRunActive =
+    "The number of pipeline runs currently active in the system by state.";
+static constexpr const char *unitMetricCicdPipelineRunActive = "{run}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricCicdPipelineRunActive(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricCicdPipelineRunActive,
+                                         descrMetricCicdPipelineRunActive,
+                                         unitMetricCicdPipelineRunActive);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricCicdPipelineRunActive(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricCicdPipelineRunActive,
+                                          descrMetricCicdPipelineRunActive,
+                                          unitMetricCicdPipelineRunActive);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricCicdPipelineRunActive(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricCicdPipelineRunActive,
+                                                   descrMetricCicdPipelineRunActive,
+                                                   unitMetricCicdPipelineRunActive);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricCicdPipelineRunActive(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricCicdPipelineRunActive,
+                                                    descrMetricCicdPipelineRunActive,
+                                                    unitMetricCicdPipelineRunActive);
+}
+
+/**
+ * Duration of a pipeline run grouped by pipeline, state and result.
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricCicdPipelineRunDuration = "cicd.pipeline.run.duration";
+static constexpr const char *descrMetricCicdPipelineRunDuration =
+    "Duration of a pipeline run grouped by pipeline, state and result.";
+static constexpr const char *unitMetricCicdPipelineRunDuration = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricCicdPipelineRunDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricCicdPipelineRunDuration,
+                                      descrMetricCicdPipelineRunDuration,
+                                      unitMetricCicdPipelineRunDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricCicdPipelineRunDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricCicdPipelineRunDuration,
+                                      descrMetricCicdPipelineRunDuration,
+                                      unitMetricCicdPipelineRunDuration);
+}
+
+/**
+ * The number of errors encountered in pipeline runs (eg. compile, test failures).
+ * <p>
+ * There might be errors in a pipeline run that are non fatal (eg. they are suppressed) or in a
+ * parallel stage multiple stages could have a fatal error. This means that this error count might
+ * not be the same as the count of metric @code cicd.pipeline.run.duration @endcode with run result
+ * @code failure @endcode. <p> counter
+ */
+static constexpr const char *kMetricCicdPipelineRunErrors = "cicd.pipeline.run.errors";
+static constexpr const char *descrMetricCicdPipelineRunErrors =
+    "The number of errors encountered in pipeline runs (eg. compile, test failures).";
+static constexpr const char *unitMetricCicdPipelineRunErrors = "{error}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricCicdPipelineRunErrors(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricCicdPipelineRunErrors, descrMetricCicdPipelineRunErrors,
+                                    unitMetricCicdPipelineRunErrors);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricCicdPipelineRunErrors(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricCicdPipelineRunErrors, descrMetricCicdPipelineRunErrors,
+                                    unitMetricCicdPipelineRunErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricCicdPipelineRunErrors(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricCicdPipelineRunErrors,
+                                             descrMetricCicdPipelineRunErrors,
+                                             unitMetricCicdPipelineRunErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricCicdPipelineRunErrors(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricCicdPipelineRunErrors,
+                                              descrMetricCicdPipelineRunErrors,
+                                              unitMetricCicdPipelineRunErrors);
+}
+
+/**
+ * The number of errors in a component of the CICD system (eg. controller, scheduler, agent).
+ * <p>
+ * Errors in pipeline run execution are explicitly excluded. Ie a test failure is not counted in
+ * this metric. <p> counter
+ */
+static constexpr const char *kMetricCicdSystemErrors = "cicd.system.errors";
+static constexpr const char *descrMetricCicdSystemErrors =
+    "The number of errors in a component of the CICD system (eg. controller, scheduler, agent).";
+static constexpr const char *unitMetricCicdSystemErrors = "{error}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricCicdSystemErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricCicdSystemErrors, descrMetricCicdSystemErrors,
+                                    unitMetricCicdSystemErrors);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricCicdSystemErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricCicdSystemErrors, descrMetricCicdSystemErrors,
+                                    unitMetricCicdSystemErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricCicdSystemErrors(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricCicdSystemErrors, descrMetricCicdSystemErrors,
+                                             unitMetricCicdSystemErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricCicdSystemErrors(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricCicdSystemErrors, descrMetricCicdSystemErrors,
+                                              unitMetricCicdSystemErrors);
+}
+
+/**
+ * The number of workers on the CICD system by state.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricCicdWorkerCount = "cicd.worker.count";
+static constexpr const char *descrMetricCicdWorkerCount =
+    "The number of workers on the CICD system by state.";
+static constexpr const char *unitMetricCicdWorkerCount = "{count}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricCicdWorkerCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricCicdWorkerCount, descrMetricCicdWorkerCount,
+                                         unitMetricCicdWorkerCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricCicdWorkerCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricCicdWorkerCount, descrMetricCicdWorkerCount,
+                                          unitMetricCicdWorkerCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricCicdWorkerCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricCicdWorkerCount, descrMetricCicdWorkerCount, unitMetricCicdWorkerCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricCicdWorkerCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricCicdWorkerCount, descrMetricCicdWorkerCount, unitMetricCicdWorkerCount);
+}
+
+}  // namespace cicd
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/container_metrics.h b/api/include/opentelemetry/semconv/container_metrics.h
new file mode 100644
index 0000000000..d3fef8b91b
--- /dev/null
+++ b/api/include/opentelemetry/semconv/container_metrics.h
@@ -0,0 +1,266 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace container
+{
+
+/**
+ * Total CPU time consumed
+ * <p>
+ * Total CPU time consumed by the specific container on all available CPU cores
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricContainerCpuTime     = "container.cpu.time";
+static constexpr const char *descrMetricContainerCpuTime = "Total CPU time consumed";
+static constexpr const char *unitMetricContainerCpuTime  = "s";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricContainerCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricContainerCpuTime, descrMetricContainerCpuTime,
+                                    unitMetricContainerCpuTime);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricContainerCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricContainerCpuTime, descrMetricContainerCpuTime,
+                                    unitMetricContainerCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricContainerCpuTime(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricContainerCpuTime, descrMetricContainerCpuTime,
+                                             unitMetricContainerCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricContainerCpuTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricContainerCpuTime, descrMetricContainerCpuTime,
+                                              unitMetricContainerCpuTime);
+}
+
+/**
+ * Container's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs
+ * <p>
+ * CPU usage of the specific container on all available CPU cores, averaged over the sample window
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricContainerCpuUsage = "container.cpu.usage";
+static constexpr const char *descrMetricContainerCpuUsage =
+    "Container's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs";
+static constexpr const char *unitMetricContainerCpuUsage = "{cpu}";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricContainerCpuUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricContainerCpuUsage, descrMetricContainerCpuUsage,
+                                 unitMetricContainerCpuUsage);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricContainerCpuUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricContainerCpuUsage, descrMetricContainerCpuUsage,
+                                  unitMetricContainerCpuUsage);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricContainerCpuUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricContainerCpuUsage, descrMetricContainerCpuUsage,
+                                           unitMetricContainerCpuUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricContainerCpuUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricContainerCpuUsage, descrMetricContainerCpuUsage,
+                                            unitMetricContainerCpuUsage);
+}
+
+/**
+ * Disk bytes for the container.
+ * <p>
+ * The total number of bytes read/written successfully (aggregated from all disks).
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricContainerDiskIo     = "container.disk.io";
+static constexpr const char *descrMetricContainerDiskIo = "Disk bytes for the container.";
+static constexpr const char *unitMetricContainerDiskIo  = "By";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricContainerDiskIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricContainerDiskIo, descrMetricContainerDiskIo,
+                                    unitMetricContainerDiskIo);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricContainerDiskIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricContainerDiskIo, descrMetricContainerDiskIo,
+                                    unitMetricContainerDiskIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricContainerDiskIo(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricContainerDiskIo, descrMetricContainerDiskIo,
+                                             unitMetricContainerDiskIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricContainerDiskIo(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricContainerDiskIo, descrMetricContainerDiskIo,
+                                              unitMetricContainerDiskIo);
+}
+
+/**
+ * Memory usage of the container.
+ * <p>
+ * Memory usage of the container.
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricContainerMemoryUsage     = "container.memory.usage";
+static constexpr const char *descrMetricContainerMemoryUsage = "Memory usage of the container.";
+static constexpr const char *unitMetricContainerMemoryUsage  = "By";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricContainerMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricContainerMemoryUsage, descrMetricContainerMemoryUsage,
+                                    unitMetricContainerMemoryUsage);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricContainerMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricContainerMemoryUsage, descrMetricContainerMemoryUsage,
+                                    unitMetricContainerMemoryUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricContainerMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricContainerMemoryUsage, descrMetricContainerMemoryUsage, unitMetricContainerMemoryUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricContainerMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricContainerMemoryUsage, descrMetricContainerMemoryUsage, unitMetricContainerMemoryUsage);
+}
+
+/**
+ * Network bytes for the container.
+ * <p>
+ * The number of bytes sent/received on all network interfaces by the container.
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricContainerNetworkIo     = "container.network.io";
+static constexpr const char *descrMetricContainerNetworkIo = "Network bytes for the container.";
+static constexpr const char *unitMetricContainerNetworkIo  = "By";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricContainerNetworkIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricContainerNetworkIo, descrMetricContainerNetworkIo,
+                                    unitMetricContainerNetworkIo);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricContainerNetworkIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricContainerNetworkIo, descrMetricContainerNetworkIo,
+                                    unitMetricContainerNetworkIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricContainerNetworkIo(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricContainerNetworkIo, descrMetricContainerNetworkIo, unitMetricContainerNetworkIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricContainerNetworkIo(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricContainerNetworkIo, descrMetricContainerNetworkIo, unitMetricContainerNetworkIo);
+}
+
+/**
+ * The time the container has been running
+ * <p>
+ * Instrumentations SHOULD use a gauge with type @code double @endcode and measure uptime in seconds
+ * as a floating point number with the highest precision available. The actual accuracy would depend
+ * on the instrumentation and operating system. <p> gauge
+ */
+static constexpr const char *kMetricContainerUptime     = "container.uptime";
+static constexpr const char *descrMetricContainerUptime = "The time the container has been running";
+static constexpr const char *unitMetricContainerUptime  = "s";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricContainerUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricContainerUptime, descrMetricContainerUptime,
+                                 unitMetricContainerUptime);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricContainerUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricContainerUptime, descrMetricContainerUptime,
+                                  unitMetricContainerUptime);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricContainerUptime(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricContainerUptime, descrMetricContainerUptime,
+                                           unitMetricContainerUptime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricContainerUptime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricContainerUptime, descrMetricContainerUptime,
+                                            unitMetricContainerUptime);
+}
+
+}  // namespace container
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/cpu_metrics.h b/api/include/opentelemetry/semconv/cpu_metrics.h
new file mode 100644
index 0000000000..f9e6de5eb2
--- /dev/null
+++ b/api/include/opentelemetry/semconv/cpu_metrics.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace cpu
+{
+
+/**
+ * Operating frequency of the logical CPU in Hertz.
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricCpuFrequency = "cpu.frequency";
+static constexpr const char *descrMetricCpuFrequency =
+    "Operating frequency of the logical CPU in Hertz.";
+static constexpr const char *unitMetricCpuFrequency = "Hz";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricCpuFrequency(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricCpuFrequency, descrMetricCpuFrequency,
+                                 unitMetricCpuFrequency);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricCpuFrequency(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricCpuFrequency, descrMetricCpuFrequency,
+                                  unitMetricCpuFrequency);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricCpuFrequency(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricCpuFrequency, descrMetricCpuFrequency,
+                                           unitMetricCpuFrequency);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricCpuFrequency(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricCpuFrequency, descrMetricCpuFrequency,
+                                            unitMetricCpuFrequency);
+}
+
+/**
+ * Seconds each logical CPU spent on each mode
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricCpuTime     = "cpu.time";
+static constexpr const char *descrMetricCpuTime = "Seconds each logical CPU spent on each mode";
+static constexpr const char *unitMetricCpuTime  = "s";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricCpuTime, descrMetricCpuTime, unitMetricCpuTime);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricCpuTime, descrMetricCpuTime, unitMetricCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricCpuTime, descrMetricCpuTime, unitMetricCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricCpuTime, descrMetricCpuTime,
+                                              unitMetricCpuTime);
+}
+
+/**
+ * For each logical CPU, the utilization is calculated as the change in cumulative CPU time
+ * (cpu.time) over a measurement interval, divided by the elapsed time. <p> gauge
+ */
+static constexpr const char *kMetricCpuUtilization = "cpu.utilization";
+static constexpr const char *descrMetricCpuUtilization =
+    "For each logical CPU, the utilization is calculated as the change in cumulative CPU time "
+    "(cpu.time) over a measurement interval, divided by the elapsed time.";
+static constexpr const char *unitMetricCpuUtilization = "1";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricCpuUtilization(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricCpuUtilization, descrMetricCpuUtilization,
+                                 unitMetricCpuUtilization);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricCpuUtilization(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricCpuUtilization, descrMetricCpuUtilization,
+                                  unitMetricCpuUtilization);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricCpuUtilization(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricCpuUtilization, descrMetricCpuUtilization,
+                                           unitMetricCpuUtilization);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricCpuUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricCpuUtilization, descrMetricCpuUtilization,
+                                            unitMetricCpuUtilization);
+}
+
+}  // namespace cpu
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/db_metrics.h b/api/include/opentelemetry/semconv/db_metrics.h
new file mode 100644
index 0000000000..a444adf5f9
--- /dev/null
+++ b/api/include/opentelemetry/semconv/db_metrics.h
@@ -0,0 +1,866 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace db
+{
+
+/**
+ * The number of connections that are currently in state described by the @code state @endcode
+ * attribute <p> updowncounter
+ */
+static constexpr const char *kMetricDbClientConnectionCount = "db.client.connection.count";
+static constexpr const char *descrMetricDbClientConnectionCount =
+    "The number of connections that are currently in state described by the `state` attribute";
+static constexpr const char *unitMetricDbClientConnectionCount = "{connection}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientConnectionCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionCount,
+                                         descrMetricDbClientConnectionCount,
+                                         unitMetricDbClientConnectionCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientConnectionCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionCount,
+                                          descrMetricDbClientConnectionCount,
+                                          unitMetricDbClientConnectionCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionCount,
+                                                   descrMetricDbClientConnectionCount,
+                                                   unitMetricDbClientConnectionCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionCount,
+                                                    descrMetricDbClientConnectionCount,
+                                                    unitMetricDbClientConnectionCount);
+}
+
+/**
+ * The time it took to create a new connection
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricDbClientConnectionCreateTime =
+    "db.client.connection.create_time";
+static constexpr const char *descrMetricDbClientConnectionCreateTime =
+    "The time it took to create a new connection";
+static constexpr const char *unitMetricDbClientConnectionCreateTime = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricDbClientConnectionCreateTime(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricDbClientConnectionCreateTime,
+                                      descrMetricDbClientConnectionCreateTime,
+                                      unitMetricDbClientConnectionCreateTime);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricDbClientConnectionCreateTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricDbClientConnectionCreateTime,
+                                      descrMetricDbClientConnectionCreateTime,
+                                      unitMetricDbClientConnectionCreateTime);
+}
+
+/**
+ * The maximum number of idle open connections allowed
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricDbClientConnectionIdleMax = "db.client.connection.idle.max";
+static constexpr const char *descrMetricDbClientConnectionIdleMax =
+    "The maximum number of idle open connections allowed";
+static constexpr const char *unitMetricDbClientConnectionIdleMax = "{connection}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientConnectionIdleMax(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionIdleMax,
+                                         descrMetricDbClientConnectionIdleMax,
+                                         unitMetricDbClientConnectionIdleMax);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientConnectionIdleMax(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionIdleMax,
+                                          descrMetricDbClientConnectionIdleMax,
+                                          unitMetricDbClientConnectionIdleMax);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionIdleMax(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionIdleMax,
+                                                   descrMetricDbClientConnectionIdleMax,
+                                                   unitMetricDbClientConnectionIdleMax);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionIdleMax(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionIdleMax,
+                                                    descrMetricDbClientConnectionIdleMax,
+                                                    unitMetricDbClientConnectionIdleMax);
+}
+
+/**
+ * The minimum number of idle open connections allowed
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricDbClientConnectionIdleMin = "db.client.connection.idle.min";
+static constexpr const char *descrMetricDbClientConnectionIdleMin =
+    "The minimum number of idle open connections allowed";
+static constexpr const char *unitMetricDbClientConnectionIdleMin = "{connection}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientConnectionIdleMin(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionIdleMin,
+                                         descrMetricDbClientConnectionIdleMin,
+                                         unitMetricDbClientConnectionIdleMin);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientConnectionIdleMin(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionIdleMin,
+                                          descrMetricDbClientConnectionIdleMin,
+                                          unitMetricDbClientConnectionIdleMin);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionIdleMin(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionIdleMin,
+                                                   descrMetricDbClientConnectionIdleMin,
+                                                   unitMetricDbClientConnectionIdleMin);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionIdleMin(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionIdleMin,
+                                                    descrMetricDbClientConnectionIdleMin,
+                                                    unitMetricDbClientConnectionIdleMin);
+}
+
+/**
+ * The maximum number of open connections allowed
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricDbClientConnectionMax = "db.client.connection.max";
+static constexpr const char *descrMetricDbClientConnectionMax =
+    "The maximum number of open connections allowed";
+static constexpr const char *unitMetricDbClientConnectionMax = "{connection}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientConnectionMax(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionMax,
+                                         descrMetricDbClientConnectionMax,
+                                         unitMetricDbClientConnectionMax);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientConnectionMax(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionMax,
+                                          descrMetricDbClientConnectionMax,
+                                          unitMetricDbClientConnectionMax);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionMax(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionMax,
+                                                   descrMetricDbClientConnectionMax,
+                                                   unitMetricDbClientConnectionMax);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionMax(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionMax,
+                                                    descrMetricDbClientConnectionMax,
+                                                    unitMetricDbClientConnectionMax);
+}
+
+/**
+ * The number of current pending requests for an open connection
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricDbClientConnectionPendingRequests =
+    "db.client.connection.pending_requests";
+static constexpr const char *descrMetricDbClientConnectionPendingRequests =
+    "The number of current pending requests for an open connection";
+static constexpr const char *unitMetricDbClientConnectionPendingRequests = "{request}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientConnectionPendingRequests(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionPendingRequests,
+                                         descrMetricDbClientConnectionPendingRequests,
+                                         unitMetricDbClientConnectionPendingRequests);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientConnectionPendingRequests(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionPendingRequests,
+                                          descrMetricDbClientConnectionPendingRequests,
+                                          unitMetricDbClientConnectionPendingRequests);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionPendingRequests(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionPendingRequests,
+                                                   descrMetricDbClientConnectionPendingRequests,
+                                                   unitMetricDbClientConnectionPendingRequests);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionPendingRequests(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionPendingRequests,
+                                                    descrMetricDbClientConnectionPendingRequests,
+                                                    unitMetricDbClientConnectionPendingRequests);
+}
+
+/**
+ * The number of connection timeouts that have occurred trying to obtain a connection from the pool
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricDbClientConnectionTimeouts = "db.client.connection.timeouts";
+static constexpr const char *descrMetricDbClientConnectionTimeouts =
+    "The number of connection timeouts that have occurred trying to obtain a connection from the "
+    "pool";
+static constexpr const char *unitMetricDbClientConnectionTimeouts = "{timeout}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricDbClientConnectionTimeouts(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricDbClientConnectionTimeouts,
+                                    descrMetricDbClientConnectionTimeouts,
+                                    unitMetricDbClientConnectionTimeouts);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricDbClientConnectionTimeouts(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricDbClientConnectionTimeouts,
+                                    descrMetricDbClientConnectionTimeouts,
+                                    unitMetricDbClientConnectionTimeouts);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionTimeouts(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricDbClientConnectionTimeouts,
+                                             descrMetricDbClientConnectionTimeouts,
+                                             unitMetricDbClientConnectionTimeouts);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionTimeouts(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricDbClientConnectionTimeouts,
+                                              descrMetricDbClientConnectionTimeouts,
+                                              unitMetricDbClientConnectionTimeouts);
+}
+
+/**
+ * The time between borrowing a connection and returning it to the pool
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricDbClientConnectionUseTime = "db.client.connection.use_time";
+static constexpr const char *descrMetricDbClientConnectionUseTime =
+    "The time between borrowing a connection and returning it to the pool";
+static constexpr const char *unitMetricDbClientConnectionUseTime = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricDbClientConnectionUseTime(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricDbClientConnectionUseTime,
+                                      descrMetricDbClientConnectionUseTime,
+                                      unitMetricDbClientConnectionUseTime);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricDbClientConnectionUseTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricDbClientConnectionUseTime,
+                                      descrMetricDbClientConnectionUseTime,
+                                      unitMetricDbClientConnectionUseTime);
+}
+
+/**
+ * The time it took to obtain an open connection from the pool
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricDbClientConnectionWaitTime = "db.client.connection.wait_time";
+static constexpr const char *descrMetricDbClientConnectionWaitTime =
+    "The time it took to obtain an open connection from the pool";
+static constexpr const char *unitMetricDbClientConnectionWaitTime = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricDbClientConnectionWaitTime(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricDbClientConnectionWaitTime,
+                                      descrMetricDbClientConnectionWaitTime,
+                                      unitMetricDbClientConnectionWaitTime);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricDbClientConnectionWaitTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricDbClientConnectionWaitTime,
+                                      descrMetricDbClientConnectionWaitTime,
+                                      unitMetricDbClientConnectionWaitTime);
+}
+
+/**
+ * Deprecated, use @code db.client.connection.create_time @endcode instead. Note: the unit also
+ * changed from @code ms @endcode to @code s @endcode.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code db.client.connection.create_time @endcode. Note: the unit also
+ * changed from @code ms @endcode to @code s @endcode.", "reason": "uncategorized"} <p> histogram
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsCreateTime =
+    "db.client.connections.create_time";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsCreateTime =
+    "Deprecated, use `db.client.connection.create_time` instead. Note: the unit also changed from "
+    "`ms` to `s`.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsCreateTime =
+    "ms";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricDbClientConnectionsCreateTime(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricDbClientConnectionsCreateTime,
+                                      descrMetricDbClientConnectionsCreateTime,
+                                      unitMetricDbClientConnectionsCreateTime);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricDbClientConnectionsCreateTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricDbClientConnectionsCreateTime,
+                                      descrMetricDbClientConnectionsCreateTime,
+                                      unitMetricDbClientConnectionsCreateTime);
+}
+
+/**
+ * Deprecated, use @code db.client.connection.idle.max @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code db.client.connection.idle.max @endcode.", "reason": "uncategorized"}
+ * <p>
+ * updowncounter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsIdleMax =
+    "db.client.connections.idle.max";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsIdleMax =
+    "Deprecated, use `db.client.connection.idle.max` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsIdleMax =
+    "{connection}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientConnectionsIdleMax(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionsIdleMax,
+                                         descrMetricDbClientConnectionsIdleMax,
+                                         unitMetricDbClientConnectionsIdleMax);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientConnectionsIdleMax(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionsIdleMax,
+                                          descrMetricDbClientConnectionsIdleMax,
+                                          unitMetricDbClientConnectionsIdleMax);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionsIdleMax(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionsIdleMax,
+                                                   descrMetricDbClientConnectionsIdleMax,
+                                                   unitMetricDbClientConnectionsIdleMax);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionsIdleMax(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionsIdleMax,
+                                                    descrMetricDbClientConnectionsIdleMax,
+                                                    unitMetricDbClientConnectionsIdleMax);
+}
+
+/**
+ * Deprecated, use @code db.client.connection.idle.min @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code db.client.connection.idle.min @endcode.", "reason": "uncategorized"}
+ * <p>
+ * updowncounter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsIdleMin =
+    "db.client.connections.idle.min";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsIdleMin =
+    "Deprecated, use `db.client.connection.idle.min` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsIdleMin =
+    "{connection}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientConnectionsIdleMin(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionsIdleMin,
+                                         descrMetricDbClientConnectionsIdleMin,
+                                         unitMetricDbClientConnectionsIdleMin);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientConnectionsIdleMin(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionsIdleMin,
+                                          descrMetricDbClientConnectionsIdleMin,
+                                          unitMetricDbClientConnectionsIdleMin);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionsIdleMin(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionsIdleMin,
+                                                   descrMetricDbClientConnectionsIdleMin,
+                                                   unitMetricDbClientConnectionsIdleMin);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionsIdleMin(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionsIdleMin,
+                                                    descrMetricDbClientConnectionsIdleMin,
+                                                    unitMetricDbClientConnectionsIdleMin);
+}
+
+/**
+ * Deprecated, use @code db.client.connection.max @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code db.client.connection.max @endcode.", "reason": "uncategorized"}
+ * <p>
+ * updowncounter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsMax =
+    "db.client.connections.max";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsMax =
+    "Deprecated, use `db.client.connection.max` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsMax =
+    "{connection}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientConnectionsMax(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionsMax,
+                                         descrMetricDbClientConnectionsMax,
+                                         unitMetricDbClientConnectionsMax);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientConnectionsMax(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionsMax,
+                                          descrMetricDbClientConnectionsMax,
+                                          unitMetricDbClientConnectionsMax);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionsMax(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionsMax,
+                                                   descrMetricDbClientConnectionsMax,
+                                                   unitMetricDbClientConnectionsMax);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionsMax(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionsMax,
+                                                    descrMetricDbClientConnectionsMax,
+                                                    unitMetricDbClientConnectionsMax);
+}
+
+/**
+ * Deprecated, use @code db.client.connection.pending_requests @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code db.client.connection.pending_requests @endcode.", "reason":
+ * "uncategorized"} <p> updowncounter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsPendingRequests =
+    "db.client.connections.pending_requests";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *descrMetricDbClientConnectionsPendingRequests =
+        "Deprecated, use `db.client.connection.pending_requests` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsPendingRequests =
+    "{request}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientConnectionsPendingRequests(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionsPendingRequests,
+                                         descrMetricDbClientConnectionsPendingRequests,
+                                         unitMetricDbClientConnectionsPendingRequests);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientConnectionsPendingRequests(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionsPendingRequests,
+                                          descrMetricDbClientConnectionsPendingRequests,
+                                          unitMetricDbClientConnectionsPendingRequests);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionsPendingRequests(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionsPendingRequests,
+                                                   descrMetricDbClientConnectionsPendingRequests,
+                                                   unitMetricDbClientConnectionsPendingRequests);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionsPendingRequests(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionsPendingRequests,
+                                                    descrMetricDbClientConnectionsPendingRequests,
+                                                    unitMetricDbClientConnectionsPendingRequests);
+}
+
+/**
+ * Deprecated, use @code db.client.connection.timeouts @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code db.client.connection.timeouts @endcode.", "reason": "uncategorized"}
+ * <p>
+ * counter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsTimeouts =
+    "db.client.connections.timeouts";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsTimeouts =
+    "Deprecated, use `db.client.connection.timeouts` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsTimeouts =
+    "{timeout}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricDbClientConnectionsTimeouts(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricDbClientConnectionsTimeouts,
+                                    descrMetricDbClientConnectionsTimeouts,
+                                    unitMetricDbClientConnectionsTimeouts);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricDbClientConnectionsTimeouts(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricDbClientConnectionsTimeouts,
+                                    descrMetricDbClientConnectionsTimeouts,
+                                    unitMetricDbClientConnectionsTimeouts);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionsTimeouts(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricDbClientConnectionsTimeouts,
+                                             descrMetricDbClientConnectionsTimeouts,
+                                             unitMetricDbClientConnectionsTimeouts);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionsTimeouts(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricDbClientConnectionsTimeouts,
+                                              descrMetricDbClientConnectionsTimeouts,
+                                              unitMetricDbClientConnectionsTimeouts);
+}
+
+/**
+ * Deprecated, use @code db.client.connection.count @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code db.client.connection.count @endcode.", "reason": "uncategorized"}
+ * <p>
+ * updowncounter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsUsage =
+    "db.client.connections.usage";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsUsage =
+    "Deprecated, use `db.client.connection.count` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsUsage =
+    "{connection}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientConnectionsUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientConnectionsUsage,
+                                         descrMetricDbClientConnectionsUsage,
+                                         unitMetricDbClientConnectionsUsage);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientConnectionsUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientConnectionsUsage,
+                                          descrMetricDbClientConnectionsUsage,
+                                          unitMetricDbClientConnectionsUsage);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientConnectionsUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientConnectionsUsage,
+                                                   descrMetricDbClientConnectionsUsage,
+                                                   unitMetricDbClientConnectionsUsage);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientConnectionsUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientConnectionsUsage,
+                                                    descrMetricDbClientConnectionsUsage,
+                                                    unitMetricDbClientConnectionsUsage);
+}
+
+/**
+ * Deprecated, use @code db.client.connection.use_time @endcode instead. Note: the unit also changed
+ * from @code ms @endcode to @code s @endcode.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code db.client.connection.use_time @endcode. Note: the unit also changed
+ * from @code ms @endcode to @code s @endcode.", "reason": "uncategorized"} <p> histogram
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsUseTime =
+    "db.client.connections.use_time";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsUseTime =
+    "Deprecated, use `db.client.connection.use_time` instead. Note: the unit also changed from "
+    "`ms` to `s`.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsUseTime = "ms";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricDbClientConnectionsUseTime(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricDbClientConnectionsUseTime,
+                                      descrMetricDbClientConnectionsUseTime,
+                                      unitMetricDbClientConnectionsUseTime);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricDbClientConnectionsUseTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricDbClientConnectionsUseTime,
+                                      descrMetricDbClientConnectionsUseTime,
+                                      unitMetricDbClientConnectionsUseTime);
+}
+
+/**
+ * Deprecated, use @code db.client.connection.wait_time @endcode instead. Note: the unit also
+ * changed from @code ms @endcode to @code s @endcode.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code db.client.connection.wait_time @endcode. Note: the unit also changed
+ * from @code ms @endcode to @code s @endcode.", "reason": "uncategorized"} <p> histogram
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsWaitTime =
+    "db.client.connections.wait_time";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricDbClientConnectionsWaitTime =
+    "Deprecated, use `db.client.connection.wait_time` instead. Note: the unit also changed from "
+    "`ms` to `s`.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricDbClientConnectionsWaitTime = "ms";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricDbClientConnectionsWaitTime(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricDbClientConnectionsWaitTime,
+                                      descrMetricDbClientConnectionsWaitTime,
+                                      unitMetricDbClientConnectionsWaitTime);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricDbClientConnectionsWaitTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricDbClientConnectionsWaitTime,
+                                      descrMetricDbClientConnectionsWaitTime,
+                                      unitMetricDbClientConnectionsWaitTime);
+}
+
+/**
+ * Deprecated, use @code azure.cosmosdb.client.active_instance.count @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code azure.cosmosdb.client.active_instance.count @endcode.", "reason":
+ * "uncategorized"} <p> updowncounter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientCosmosdbActiveInstanceCount =
+    "db.client.cosmosdb.active_instance.count";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *descrMetricDbClientCosmosdbActiveInstanceCount =
+        "Deprecated, use `azure.cosmosdb.client.active_instance.count` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *unitMetricDbClientCosmosdbActiveInstanceCount = "{instance}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricDbClientCosmosdbActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricDbClientCosmosdbActiveInstanceCount,
+                                         descrMetricDbClientCosmosdbActiveInstanceCount,
+                                         unitMetricDbClientCosmosdbActiveInstanceCount);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricDbClientCosmosdbActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricDbClientCosmosdbActiveInstanceCount,
+                                          descrMetricDbClientCosmosdbActiveInstanceCount,
+                                          unitMetricDbClientCosmosdbActiveInstanceCount);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricDbClientCosmosdbActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricDbClientCosmosdbActiveInstanceCount,
+                                                   descrMetricDbClientCosmosdbActiveInstanceCount,
+                                                   unitMetricDbClientCosmosdbActiveInstanceCount);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricDbClientCosmosdbActiveInstanceCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricDbClientCosmosdbActiveInstanceCount,
+                                                    descrMetricDbClientCosmosdbActiveInstanceCount,
+                                                    unitMetricDbClientCosmosdbActiveInstanceCount);
+}
+
+/**
+ * Deprecated, use @code azure.cosmosdb.client.operation.request_charge @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code azure.cosmosdb.client.operation.request_charge @endcode.", "reason":
+ * "uncategorized"} <p> histogram
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *kMetricDbClientCosmosdbOperationRequestCharge = "db.client.cosmosdb.operation.request_charge";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *descrMetricDbClientCosmosdbOperationRequestCharge =
+        "Deprecated, use `azure.cosmosdb.client.operation.request_charge` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *unitMetricDbClientCosmosdbOperationRequestCharge = "{request_unit}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricDbClientCosmosdbOperationRequestCharge(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricDbClientCosmosdbOperationRequestCharge,
+                                      descrMetricDbClientCosmosdbOperationRequestCharge,
+                                      unitMetricDbClientCosmosdbOperationRequestCharge);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricDbClientCosmosdbOperationRequestCharge(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricDbClientCosmosdbOperationRequestCharge,
+                                      descrMetricDbClientCosmosdbOperationRequestCharge,
+                                      unitMetricDbClientCosmosdbOperationRequestCharge);
+}
+
+/**
+ * Duration of database client operations.
+ * <p>
+ * Batch operations SHOULD be recorded as a single operation.
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricDbClientOperationDuration = "db.client.operation.duration";
+static constexpr const char *descrMetricDbClientOperationDuration =
+    "Duration of database client operations.";
+static constexpr const char *unitMetricDbClientOperationDuration = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricDbClientOperationDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricDbClientOperationDuration,
+                                      descrMetricDbClientOperationDuration,
+                                      unitMetricDbClientOperationDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricDbClientOperationDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricDbClientOperationDuration,
+                                      descrMetricDbClientOperationDuration,
+                                      unitMetricDbClientOperationDuration);
+}
+
+/**
+ * The actual number of records returned by the database operation.
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricDbClientResponseReturnedRows =
+    "db.client.response.returned_rows";
+static constexpr const char *descrMetricDbClientResponseReturnedRows =
+    "The actual number of records returned by the database operation.";
+static constexpr const char *unitMetricDbClientResponseReturnedRows = "{row}";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricDbClientResponseReturnedRows(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricDbClientResponseReturnedRows,
+                                      descrMetricDbClientResponseReturnedRows,
+                                      unitMetricDbClientResponseReturnedRows);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricDbClientResponseReturnedRows(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricDbClientResponseReturnedRows,
+                                      descrMetricDbClientResponseReturnedRows,
+                                      unitMetricDbClientResponseReturnedRows);
+}
+
+}  // namespace db
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/dns_metrics.h b/api/include/opentelemetry/semconv/dns_metrics.h
new file mode 100644
index 0000000000..019fea6742
--- /dev/null
+++ b/api/include/opentelemetry/semconv/dns_metrics.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace dns
+{
+
+/**
+ * Measures the time taken to perform a DNS lookup.
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricDnsLookupDuration = "dns.lookup.duration";
+static constexpr const char *descrMetricDnsLookupDuration =
+    "Measures the time taken to perform a DNS lookup.";
+static constexpr const char *unitMetricDnsLookupDuration = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricDnsLookupDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricDnsLookupDuration, descrMetricDnsLookupDuration,
+                                      unitMetricDnsLookupDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>> CreateSyncDoubleMetricDnsLookupDuration(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricDnsLookupDuration, descrMetricDnsLookupDuration,
+                                      unitMetricDnsLookupDuration);
+}
+
+}  // namespace dns
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/exception_attributes.h b/api/include/opentelemetry/semconv/exception_attributes.h
index 980e4525f9..61e94d955b 100644
--- a/api/include/opentelemetry/semconv/exception_attributes.h
+++ b/api/include/opentelemetry/semconv/exception_attributes.h
@@ -21,10 +21,10 @@ namespace exception
 
 /**
  * Indicates that the exception is escaping the scope of the span.
- * <p>
+ *
  * @deprecated
- * It's no longer recommended to record exceptions that are handled and do not escape the scope of a
- * span.
+ * {"note": "It's no longer recommended to record exceptions that are handled and do not escape the
+ * scope of a span.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kExceptionEscaped = "exception.escaped";
 
diff --git a/api/include/opentelemetry/semconv/faas_metrics.h b/api/include/opentelemetry/semconv/faas_metrics.h
new file mode 100644
index 0000000000..72109d887a
--- /dev/null
+++ b/api/include/opentelemetry/semconv/faas_metrics.h
@@ -0,0 +1,287 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace faas
+{
+
+/**
+ * Number of invocation cold starts
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricFaasColdstarts     = "faas.coldstarts";
+static constexpr const char *descrMetricFaasColdstarts = "Number of invocation cold starts";
+static constexpr const char *unitMetricFaasColdstarts  = "{coldstart}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricFaasColdstarts(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricFaasColdstarts, descrMetricFaasColdstarts,
+                                    unitMetricFaasColdstarts);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricFaasColdstarts(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricFaasColdstarts, descrMetricFaasColdstarts,
+                                    unitMetricFaasColdstarts);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricFaasColdstarts(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricFaasColdstarts, descrMetricFaasColdstarts,
+                                             unitMetricFaasColdstarts);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricFaasColdstarts(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricFaasColdstarts, descrMetricFaasColdstarts,
+                                              unitMetricFaasColdstarts);
+}
+
+/**
+ * Distribution of CPU usage per invocation
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricFaasCpuUsage     = "faas.cpu_usage";
+static constexpr const char *descrMetricFaasCpuUsage = "Distribution of CPU usage per invocation";
+static constexpr const char *unitMetricFaasCpuUsage  = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>> CreateSyncInt64MetricFaasCpuUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricFaasCpuUsage, descrMetricFaasCpuUsage,
+                                      unitMetricFaasCpuUsage);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>> CreateSyncDoubleMetricFaasCpuUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricFaasCpuUsage, descrMetricFaasCpuUsage,
+                                      unitMetricFaasCpuUsage);
+}
+
+/**
+ * Number of invocation errors
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricFaasErrors     = "faas.errors";
+static constexpr const char *descrMetricFaasErrors = "Number of invocation errors";
+static constexpr const char *unitMetricFaasErrors  = "{error}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricFaasErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricFaasErrors, descrMetricFaasErrors, unitMetricFaasErrors);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricFaasErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricFaasErrors, descrMetricFaasErrors, unitMetricFaasErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricFaasErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricFaasErrors, descrMetricFaasErrors,
+                                             unitMetricFaasErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricFaasErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricFaasErrors, descrMetricFaasErrors,
+                                              unitMetricFaasErrors);
+}
+
+/**
+ * Measures the duration of the function's initialization, such as a cold start
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricFaasInitDuration = "faas.init_duration";
+static constexpr const char *descrMetricFaasInitDuration =
+    "Measures the duration of the function's initialization, such as a cold start";
+static constexpr const char *unitMetricFaasInitDuration = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>> CreateSyncInt64MetricFaasInitDuration(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricFaasInitDuration, descrMetricFaasInitDuration,
+                                      unitMetricFaasInitDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>> CreateSyncDoubleMetricFaasInitDuration(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricFaasInitDuration, descrMetricFaasInitDuration,
+                                      unitMetricFaasInitDuration);
+}
+
+/**
+ * Number of successful invocations
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricFaasInvocations     = "faas.invocations";
+static constexpr const char *descrMetricFaasInvocations = "Number of successful invocations";
+static constexpr const char *unitMetricFaasInvocations  = "{invocation}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricFaasInvocations(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricFaasInvocations, descrMetricFaasInvocations,
+                                    unitMetricFaasInvocations);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricFaasInvocations(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricFaasInvocations, descrMetricFaasInvocations,
+                                    unitMetricFaasInvocations);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricFaasInvocations(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricFaasInvocations, descrMetricFaasInvocations,
+                                             unitMetricFaasInvocations);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricFaasInvocations(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricFaasInvocations, descrMetricFaasInvocations,
+                                              unitMetricFaasInvocations);
+}
+
+/**
+ * Measures the duration of the function's logic execution
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricFaasInvokeDuration = "faas.invoke_duration";
+static constexpr const char *descrMetricFaasInvokeDuration =
+    "Measures the duration of the function's logic execution";
+static constexpr const char *unitMetricFaasInvokeDuration = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricFaasInvokeDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricFaasInvokeDuration, descrMetricFaasInvokeDuration,
+                                      unitMetricFaasInvokeDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricFaasInvokeDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricFaasInvokeDuration, descrMetricFaasInvokeDuration,
+                                      unitMetricFaasInvokeDuration);
+}
+
+/**
+ * Distribution of max memory usage per invocation
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricFaasMemUsage = "faas.mem_usage";
+static constexpr const char *descrMetricFaasMemUsage =
+    "Distribution of max memory usage per invocation";
+static constexpr const char *unitMetricFaasMemUsage = "By";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>> CreateSyncInt64MetricFaasMemUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricFaasMemUsage, descrMetricFaasMemUsage,
+                                      unitMetricFaasMemUsage);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>> CreateSyncDoubleMetricFaasMemUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricFaasMemUsage, descrMetricFaasMemUsage,
+                                      unitMetricFaasMemUsage);
+}
+
+/**
+ * Distribution of net I/O usage per invocation
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricFaasNetIo     = "faas.net_io";
+static constexpr const char *descrMetricFaasNetIo = "Distribution of net I/O usage per invocation";
+static constexpr const char *unitMetricFaasNetIo  = "By";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>> CreateSyncInt64MetricFaasNetIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricFaasNetIo, descrMetricFaasNetIo, unitMetricFaasNetIo);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>> CreateSyncDoubleMetricFaasNetIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricFaasNetIo, descrMetricFaasNetIo, unitMetricFaasNetIo);
+}
+
+/**
+ * Number of invocation timeouts
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricFaasTimeouts     = "faas.timeouts";
+static constexpr const char *descrMetricFaasTimeouts = "Number of invocation timeouts";
+static constexpr const char *unitMetricFaasTimeouts  = "{timeout}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricFaasTimeouts(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricFaasTimeouts, descrMetricFaasTimeouts,
+                                    unitMetricFaasTimeouts);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricFaasTimeouts(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricFaasTimeouts, descrMetricFaasTimeouts,
+                                    unitMetricFaasTimeouts);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricFaasTimeouts(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricFaasTimeouts, descrMetricFaasTimeouts,
+                                             unitMetricFaasTimeouts);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricFaasTimeouts(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricFaasTimeouts, descrMetricFaasTimeouts,
+                                              unitMetricFaasTimeouts);
+}
+
+}  // namespace faas
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/gen_ai_metrics.h b/api/include/opentelemetry/semconv/gen_ai_metrics.h
new file mode 100644
index 0000000000..437ba4af4a
--- /dev/null
+++ b/api/include/opentelemetry/semconv/gen_ai_metrics.h
@@ -0,0 +1,157 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace gen_ai
+{
+
+/**
+ * GenAI operation duration
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricGenAiClientOperationDuration =
+    "gen_ai.client.operation.duration";
+static constexpr const char *descrMetricGenAiClientOperationDuration = "GenAI operation duration";
+static constexpr const char *unitMetricGenAiClientOperationDuration  = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricGenAiClientOperationDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricGenAiClientOperationDuration,
+                                      descrMetricGenAiClientOperationDuration,
+                                      unitMetricGenAiClientOperationDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricGenAiClientOperationDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricGenAiClientOperationDuration,
+                                      descrMetricGenAiClientOperationDuration,
+                                      unitMetricGenAiClientOperationDuration);
+}
+
+/**
+ * Measures number of input and output tokens used
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricGenAiClientTokenUsage = "gen_ai.client.token.usage";
+static constexpr const char *descrMetricGenAiClientTokenUsage =
+    "Measures number of input and output tokens used";
+static constexpr const char *unitMetricGenAiClientTokenUsage = "{token}";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricGenAiClientTokenUsage(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricGenAiClientTokenUsage,
+                                      descrMetricGenAiClientTokenUsage,
+                                      unitMetricGenAiClientTokenUsage);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricGenAiClientTokenUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricGenAiClientTokenUsage,
+                                      descrMetricGenAiClientTokenUsage,
+                                      unitMetricGenAiClientTokenUsage);
+}
+
+/**
+ * Generative AI server request duration such as time-to-last byte or last output token
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricGenAiServerRequestDuration = "gen_ai.server.request.duration";
+static constexpr const char *descrMetricGenAiServerRequestDuration =
+    "Generative AI server request duration such as time-to-last byte or last output token";
+static constexpr const char *unitMetricGenAiServerRequestDuration = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricGenAiServerRequestDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricGenAiServerRequestDuration,
+                                      descrMetricGenAiServerRequestDuration,
+                                      unitMetricGenAiServerRequestDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricGenAiServerRequestDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricGenAiServerRequestDuration,
+                                      descrMetricGenAiServerRequestDuration,
+                                      unitMetricGenAiServerRequestDuration);
+}
+
+/**
+ * Time per output token generated after the first token for successful responses
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricGenAiServerTimePerOutputToken =
+    "gen_ai.server.time_per_output_token";
+static constexpr const char *descrMetricGenAiServerTimePerOutputToken =
+    "Time per output token generated after the first token for successful responses";
+static constexpr const char *unitMetricGenAiServerTimePerOutputToken = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricGenAiServerTimePerOutputToken(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricGenAiServerTimePerOutputToken,
+                                      descrMetricGenAiServerTimePerOutputToken,
+                                      unitMetricGenAiServerTimePerOutputToken);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricGenAiServerTimePerOutputToken(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricGenAiServerTimePerOutputToken,
+                                      descrMetricGenAiServerTimePerOutputToken,
+                                      unitMetricGenAiServerTimePerOutputToken);
+}
+
+/**
+ * Time to generate first token for successful responses
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricGenAiServerTimeToFirstToken =
+    "gen_ai.server.time_to_first_token";
+static constexpr const char *descrMetricGenAiServerTimeToFirstToken =
+    "Time to generate first token for successful responses";
+static constexpr const char *unitMetricGenAiServerTimeToFirstToken = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricGenAiServerTimeToFirstToken(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricGenAiServerTimeToFirstToken,
+                                      descrMetricGenAiServerTimeToFirstToken,
+                                      unitMetricGenAiServerTimeToFirstToken);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricGenAiServerTimeToFirstToken(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricGenAiServerTimeToFirstToken,
+                                      descrMetricGenAiServerTimeToFirstToken,
+                                      unitMetricGenAiServerTimeToFirstToken);
+}
+
+}  // namespace gen_ai
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/hw_metrics.h b/api/include/opentelemetry/semconv/hw_metrics.h
new file mode 100644
index 0000000000..225b939e8c
--- /dev/null
+++ b/api/include/opentelemetry/semconv/hw_metrics.h
@@ -0,0 +1,344 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace hw
+{
+
+/**
+ * Energy consumed by the component
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricHwEnergy     = "hw.energy";
+static constexpr const char *descrMetricHwEnergy = "Energy consumed by the component";
+static constexpr const char *unitMetricHwEnergy  = "J";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricHwEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricHwEnergy, descrMetricHwEnergy, unitMetricHwEnergy);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricHwEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricHwEnergy, descrMetricHwEnergy, unitMetricHwEnergy);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricHwEnergy, descrMetricHwEnergy,
+                                             unitMetricHwEnergy);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricHwEnergy, descrMetricHwEnergy,
+                                              unitMetricHwEnergy);
+}
+
+/**
+ * Number of errors encountered by the component
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricHwErrors     = "hw.errors";
+static constexpr const char *descrMetricHwErrors = "Number of errors encountered by the component";
+static constexpr const char *unitMetricHwErrors  = "{error}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricHwErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricHwErrors, descrMetricHwErrors, unitMetricHwErrors);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricHwErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricHwErrors, descrMetricHwErrors, unitMetricHwErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricHwErrors, descrMetricHwErrors,
+                                             unitMetricHwErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricHwErrors, descrMetricHwErrors,
+                                              unitMetricHwErrors);
+}
+
+/**
+ * Ambient (external) temperature of the physical host
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricHwHostAmbientTemperature = "hw.host.ambient_temperature";
+static constexpr const char *descrMetricHwHostAmbientTemperature =
+    "Ambient (external) temperature of the physical host";
+static constexpr const char *unitMetricHwHostAmbientTemperature = "Cel";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
+CreateSyncInt64MetricHwHostAmbientTemperature(metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricHwHostAmbientTemperature,
+                                 descrMetricHwHostAmbientTemperature,
+                                 unitMetricHwHostAmbientTemperature);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>>
+CreateSyncDoubleMetricHwHostAmbientTemperature(metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricHwHostAmbientTemperature,
+                                  descrMetricHwHostAmbientTemperature,
+                                  unitMetricHwHostAmbientTemperature);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricHwHostAmbientTemperature(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricHwHostAmbientTemperature,
+                                           descrMetricHwHostAmbientTemperature,
+                                           unitMetricHwHostAmbientTemperature);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricHwHostAmbientTemperature(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricHwHostAmbientTemperature,
+                                            descrMetricHwHostAmbientTemperature,
+                                            unitMetricHwHostAmbientTemperature);
+}
+
+/**
+ * Total energy consumed by the entire physical host, in joules
+ * <p>
+ * The overall energy usage of a host MUST be reported using the specific @code hw.host.energy
+ * @endcode and @code hw.host.power @endcode metrics <strong>only</strong>, instead of the generic
+ * @code hw.energy @endcode and @code hw.power @endcode described in the previous section, to
+ * prevent summing up overlapping values. <p> counter
+ */
+static constexpr const char *kMetricHwHostEnergy = "hw.host.energy";
+static constexpr const char *descrMetricHwHostEnergy =
+    "Total energy consumed by the entire physical host, in joules";
+static constexpr const char *unitMetricHwHostEnergy = "J";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricHwHostEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
+                                    unitMetricHwHostEnergy);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricHwHostEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
+                                    unitMetricHwHostEnergy);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwHostEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
+                                             unitMetricHwHostEnergy);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwHostEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
+                                              unitMetricHwHostEnergy);
+}
+
+/**
+ * By how many degrees Celsius the temperature of the physical host can be increased, before
+ * reaching a warning threshold on one of the internal sensors <p> gauge
+ */
+static constexpr const char *kMetricHwHostHeatingMargin = "hw.host.heating_margin";
+static constexpr const char *descrMetricHwHostHeatingMargin =
+    "By how many degrees Celsius the temperature of the physical host can be increased, before reaching a warning threshold on one of the internal sensors
+    ";
+    static constexpr const char *unitMetricHwHostHeatingMargin = "Cel";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricHwHostHeatingMargin(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin,
+                                 unitMetricHwHostHeatingMargin);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricHwHostHeatingMargin(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin,
+                                  unitMetricHwHostHeatingMargin);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricHwHostHeatingMargin(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(
+      kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin, unitMetricHwHostHeatingMargin);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricHwHostHeatingMargin(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(
+      kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin, unitMetricHwHostHeatingMargin);
+}
+
+/**
+ * Instantaneous power consumed by the entire physical host in Watts (@code hw.host.energy @endcode
+ * is preferred) <p> The overall energy usage of a host MUST be reported using the specific @code
+ * hw.host.energy @endcode and @code hw.host.power @endcode metrics <strong>only</strong>, instead
+ * of the generic @code hw.energy @endcode and @code hw.power @endcode described in the previous
+ * section, to prevent summing up overlapping values. <p> gauge
+ */
+static constexpr const char *kMetricHwHostPower = "hw.host.power";
+static constexpr const char *descrMetricHwHostPower =
+    "Instantaneous power consumed by the entire physical host in Watts (`hw.host.energy` is preferred)
+    ";
+    static constexpr const char *unitMetricHwHostPower = "W";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricHwHostPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricHwHostPower, descrMetricHwHostPower, unitMetricHwHostPower);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricHwHostPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricHwHostPower, descrMetricHwHostPower,
+                                  unitMetricHwHostPower);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwHostPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricHwHostPower, descrMetricHwHostPower,
+                                           unitMetricHwHostPower);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwHostPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricHwHostPower, descrMetricHwHostPower,
+                                            unitMetricHwHostPower);
+}
+
+/**
+ * Instantaneous power consumed by the component
+ * <p>
+ * It is recommended to report @code hw.energy @endcode instead of @code hw.power @endcode when
+ * possible. <p> gauge
+ */
+static constexpr const char *kMetricHwPower     = "hw.power";
+static constexpr const char *descrMetricHwPower = "Instantaneous power consumed by the component";
+static constexpr const char *unitMetricHwPower  = "W";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricHwPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricHwPower, descrMetricHwPower, unitMetricHwPower);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricHwPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricHwPower, descrMetricHwPower, unitMetricHwPower);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricHwPower, descrMetricHwPower, unitMetricHwPower);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricHwPower, descrMetricHwPower, unitMetricHwPower);
+}
+
+/**
+ * Operational status: @code 1 @endcode (true) or @code 0 @endcode (false) for each of the possible
+ * states <p>
+ * @code hw.status @endcode is currently specified as an <em>UpDownCounter</em> but would ideally be
+ * represented using a <a
+ * href="https://github.com/prometheus/OpenMetrics/blob/v1.0.0/specification/OpenMetrics.md#stateset"><em>StateSet</em>
+ * as defined in OpenMetrics</a>. This semantic convention will be updated once <em>StateSet</em> is
+ * specified in OpenTelemetry. This planned change is not expected to have any consequence on the
+ * way users query their timeseries backend to retrieve the values of @code hw.status @endcode over
+ * time. <p> updowncounter
+ */
+static constexpr const char *kMetricHwStatus = "hw.status";
+static constexpr const char *descrMetricHwStatus =
+    "Operational status: `1` (true) or `0` (false) for each of the possible states";
+static constexpr const char *unitMetricHwStatus = "1";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>> CreateSyncInt64MetricHwStatus(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricHwStatus, descrMetricHwStatus, unitMetricHwStatus);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>> CreateSyncDoubleMetricHwStatus(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricHwStatus, descrMetricHwStatus, unitMetricHwStatus);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwStatus(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricHwStatus, descrMetricHwStatus,
+                                                   unitMetricHwStatus);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwStatus(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricHwStatus, descrMetricHwStatus,
+                                                    unitMetricHwStatus);
+}
+
+}  // namespace hw
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/incubating/cicd_attributes.h b/api/include/opentelemetry/semconv/incubating/cicd_attributes.h
index d6c3ee6aba..7014d45980 100644
--- a/api/include/opentelemetry/semconv/incubating/cicd_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/cicd_attributes.h
@@ -39,6 +39,12 @@ static constexpr const char *kCicdPipelineRunId = "cicd.pipeline.run.id";
  */
 static constexpr const char *kCicdPipelineRunState = "cicd.pipeline.run.state";
 
+/**
+ * The <a href="https://wikipedia.org/wiki/URL">URL</a> of the pipeline run, providing the complete
+ * address in order to locate and identify the pipeline run.
+ */
+static constexpr const char *kCicdPipelineRunUrlFull = "cicd.pipeline.run.url.full";
+
 /**
  * The human readable name of a task within a pipeline. Task here most closely aligns with a <a
  * href="https://wikipedia.org/wiki/Pipeline_(computing)">computing process</a> in a pipeline. Other
@@ -52,8 +58,8 @@ static constexpr const char *kCicdPipelineTaskName = "cicd.pipeline.task.name";
 static constexpr const char *kCicdPipelineTaskRunId = "cicd.pipeline.task.run.id";
 
 /**
- * The <a href="https://wikipedia.org/wiki/URL">URL</a> of the pipeline run providing the complete
- * address in order to locate and identify the pipeline run.
+ * The <a href="https://wikipedia.org/wiki/URL">URL</a> of the pipeline task run, providing the
+ * complete address in order to locate and identify the pipeline task run.
  */
 static constexpr const char *kCicdPipelineTaskRunUrlFull = "cicd.pipeline.task.run.url.full";
 
diff --git a/api/include/opentelemetry/semconv/incubating/cloud_attributes.h b/api/include/opentelemetry/semconv/incubating/cloud_attributes.h
index 00f58969d6..f0b4d6da07 100644
--- a/api/include/opentelemetry/semconv/incubating/cloud_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/cloud_attributes.h
@@ -59,13 +59,12 @@ static constexpr const char *kCloudRegion = "cloud.region";
  * Cloud provider-specific native identifier of the monitored cloud resource (e.g. an <a
  * href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">ARN</a> on AWS,
  * a <a href="https://learn.microsoft.com/rest/api/resources/resources/get-by-id">fully qualified
- * resource ID</a> on Azure, a <a
- * href="https://cloud.google.com/apis/design/resource_names#full_resource_name">full resource
- * name</a> on GCP) <p> On some cloud providers, it may not be possible to determine the full ID at
- * startup, so it may be necessary to set @code cloud.resource_id @endcode as a span attribute
- * instead. <p> The exact value to use for @code cloud.resource_id @endcode depends on the cloud
- * provider. The following well-known definitions MUST be used if you set this attribute and they
- * apply: <ul> <li><strong>AWS Lambda:</strong> The function <a
+ * resource ID</a> on Azure, a <a href="https://google.aip.dev/122#full-resource-names">full
+ * resource name</a> on GCP) <p> On some cloud providers, it may not be possible to determine the
+ * full ID at startup, so it may be necessary to set @code cloud.resource_id @endcode as a span
+ * attribute instead. <p> The exact value to use for @code cloud.resource_id @endcode depends on the
+ * cloud provider. The following well-known definitions MUST be used if you set this attribute and
+ * they apply: <ul> <li><strong>AWS Lambda:</strong> The function <a
  * href="https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html">ARN</a>. Take
  * care not to use the "invoked ARN" directly but replace any <a
  * href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html">alias suffix</a>
diff --git a/api/include/opentelemetry/semconv/incubating/code_attributes.h b/api/include/opentelemetry/semconv/incubating/code_attributes.h
index 100b81b8a1..c0bcbc628e 100644
--- a/api/include/opentelemetry/semconv/incubating/code_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/code_attributes.h
@@ -21,9 +21,9 @@ namespace code
 
 /**
  * Deprecated, use @code code.column.number @endcode
- * <p>
+ *
  * @deprecated
- * Replaced by @code code.column.number @endcode
+ * {"note": "Replaced by @code code.column.number @endcode", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kCodeColumn = "code.column";
 
@@ -41,19 +41,38 @@ static constexpr const char *kCodeFilePath = "code.file.path";
 
 /**
  * Deprecated, use @code code.file.path @endcode instead
+ *
+ * @deprecated
+ * {"note": "Replaced by @code code.file.path @endcode", "reason": "uncategorized"}
  */
-static constexpr const char *kCodeFilepath = "code.filepath";
+OPENTELEMETRY_DEPRECATED static constexpr const char *kCodeFilepath = "code.filepath";
 
 /**
  * Deprecated, use @code code.function.name @endcode instead
- * <p>
+ *
  * @deprecated
- * Replaced by @code code.function.name @endcode
+ * {"note": "Replaced by @code code.function.name @endcode", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kCodeFunction = "code.function";
 
 /**
- * The method or function name, or equivalent (usually rightmost part of the code unit's name).
+ * The method or function fully-qualified name without arguments. The value should fit the natural
+ * representation of the language runtime, which is also likely the same used within @code
+ * code.stacktrace @endcode attribute value. <p> Values and format depends on each language runtime,
+ * thus it is impossible to provide an exhaustive list of examples. The values are usually the same
+ * (or prefixes of) the ones found in native stack trace representation stored in
+ * @code code.stacktrace @endcode without information on arguments.
+ * <p>
+ * Examples:
+ * <ul>
+ *   <li>Java method: @code com.example.MyHttpService.serveRequest @endcode</li>
+ *   <li>Java anonymous class method: @code com.mycompany.Main$1.myMethod @endcode</li>
+ *   <li>Java lambda method: @code com.mycompany.Main$$Lambda/0x0000748ae4149c00.myMethod
+ * @endcode</li> <li>PHP function: `GuzzleHttp\Client::transfer</li> <li>Go function: @code
+ * github.com/my/repo/pkg.foo.func5 @endcode</li> <li>Elixir: @code OpenTelemetry.Ctx.new
+ * @endcode</li> <li>Erlang: @code opentelemetry_ctx:new @endcode</li> <li>Rust: @code
+ * playground::my_module::my_cool_func @endcode</li> <li>C function: @code fopen @endcode</li>
+ * </ul>
  */
 static constexpr const char *kCodeFunctionName = "code.function.name";
 
@@ -65,22 +84,26 @@ static constexpr const char *kCodeLineNumber = "code.line.number";
 
 /**
  * Deprecated, use @code code.line.number @endcode instead
- * <p>
+ *
  * @deprecated
- * Replaced by @code code.line.number @endcode
+ * {"note": "Replaced by @code code.line.number @endcode", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kCodeLineno = "code.lineno";
 
 /**
- * The "namespace" within which @code code.function.name @endcode is defined. Usually the qualified
- * class or module name, such that @code code.namespace @endcode + some separator + @code
- * code.function.name @endcode form a unique identifier for the code unit.
+ * Deprecated, namespace is now included into @code code.function.name @endcode
+ *
+ * @deprecated
+ * {"note": "Value should be included in @code code.function.name @endcode which is expected to be a
+ * fully-qualified name.", "reason": "uncategorized"}
  */
-static constexpr const char *kCodeNamespace = "code.namespace";
+OPENTELEMETRY_DEPRECATED static constexpr const char *kCodeNamespace = "code.namespace";
 
 /**
  * A stacktrace as a string in the natural representation for the language runtime. The
- * representation is to be determined and documented by each language SIG.
+ * representation is identical to <a
+ * href="/docs/exceptions/exceptions-spans.md#stacktrace-representation">@code exception.stacktrace
+ * @endcode</a>.
  */
 static constexpr const char *kCodeStacktrace = "code.stacktrace";
 
diff --git a/api/include/opentelemetry/semconv/incubating/container_attributes.h b/api/include/opentelemetry/semconv/incubating/container_attributes.h
index ecb8c7cd2c..87b5150f91 100644
--- a/api/include/opentelemetry/semconv/incubating/container_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/container_attributes.h
@@ -39,9 +39,9 @@ static constexpr const char *kContainerCommandLine = "container.command_line";
 
 /**
  * Deprecated, use @code cpu.mode @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code cpu.mode @endcode
+ * {"note": "Replaced by @code cpu.mode @endcode", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kContainerCpuState = "container.cpu.state";
 
@@ -113,9 +113,9 @@ static constexpr const char *kContainerLabel = "container.label";
 
 /**
  * Deprecated, use @code container.label @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code container.label @endcode.
+ * {"note": "Replaced by @code container.label @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kContainerLabels = "container.labels";
 
diff --git a/api/include/opentelemetry/semconv/incubating/cpu_attributes.h b/api/include/opentelemetry/semconv/incubating/cpu_attributes.h
index b5ca637e31..cd9dd5cf71 100644
--- a/api/include/opentelemetry/semconv/incubating/cpu_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/cpu_attributes.h
@@ -19,6 +19,11 @@ namespace semconv
 namespace cpu
 {
 
+/**
+ * The logical CPU number [0..n-1]
+ */
+static constexpr const char *kCpuLogicalNumber = "cpu.logical_number";
+
 /**
  * The mode of the CPU
  */
diff --git a/api/include/opentelemetry/semconv/incubating/cpu_metrics.h b/api/include/opentelemetry/semconv/incubating/cpu_metrics.h
new file mode 100644
index 0000000000..f9e6de5eb2
--- /dev/null
+++ b/api/include/opentelemetry/semconv/incubating/cpu_metrics.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace cpu
+{
+
+/**
+ * Operating frequency of the logical CPU in Hertz.
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricCpuFrequency = "cpu.frequency";
+static constexpr const char *descrMetricCpuFrequency =
+    "Operating frequency of the logical CPU in Hertz.";
+static constexpr const char *unitMetricCpuFrequency = "Hz";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricCpuFrequency(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricCpuFrequency, descrMetricCpuFrequency,
+                                 unitMetricCpuFrequency);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricCpuFrequency(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricCpuFrequency, descrMetricCpuFrequency,
+                                  unitMetricCpuFrequency);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricCpuFrequency(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricCpuFrequency, descrMetricCpuFrequency,
+                                           unitMetricCpuFrequency);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricCpuFrequency(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricCpuFrequency, descrMetricCpuFrequency,
+                                            unitMetricCpuFrequency);
+}
+
+/**
+ * Seconds each logical CPU spent on each mode
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricCpuTime     = "cpu.time";
+static constexpr const char *descrMetricCpuTime = "Seconds each logical CPU spent on each mode";
+static constexpr const char *unitMetricCpuTime  = "s";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricCpuTime, descrMetricCpuTime, unitMetricCpuTime);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricCpuTime, descrMetricCpuTime, unitMetricCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricCpuTime, descrMetricCpuTime, unitMetricCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricCpuTime, descrMetricCpuTime,
+                                              unitMetricCpuTime);
+}
+
+/**
+ * For each logical CPU, the utilization is calculated as the change in cumulative CPU time
+ * (cpu.time) over a measurement interval, divided by the elapsed time. <p> gauge
+ */
+static constexpr const char *kMetricCpuUtilization = "cpu.utilization";
+static constexpr const char *descrMetricCpuUtilization =
+    "For each logical CPU, the utilization is calculated as the change in cumulative CPU time "
+    "(cpu.time) over a measurement interval, divided by the elapsed time.";
+static constexpr const char *unitMetricCpuUtilization = "1";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricCpuUtilization(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricCpuUtilization, descrMetricCpuUtilization,
+                                 unitMetricCpuUtilization);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricCpuUtilization(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricCpuUtilization, descrMetricCpuUtilization,
+                                  unitMetricCpuUtilization);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricCpuUtilization(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricCpuUtilization, descrMetricCpuUtilization,
+                                           unitMetricCpuUtilization);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricCpuUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricCpuUtilization, descrMetricCpuUtilization,
+                                            unitMetricCpuUtilization);
+}
+
+}  // namespace cpu
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/incubating/db_attributes.h b/api/include/opentelemetry/semconv/incubating/db_attributes.h
index 719d53900a..ee74981969 100644
--- a/api/include/opentelemetry/semconv/incubating/db_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/db_attributes.h
@@ -21,63 +21,64 @@ namespace db
 
 /**
  * Deprecated, use @code cassandra.consistency.level @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code cassandra.consistency.level @endcode.
+ * {"note": "Replaced by @code cassandra.consistency.level @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCassandraConsistencyLevel =
     "db.cassandra.consistency_level";
 
 /**
  * Deprecated, use @code cassandra.coordinator.dc @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code cassandra.coordinator.dc @endcode.
+ * {"note": "Replaced by @code cassandra.coordinator.dc @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCassandraCoordinatorDc =
     "db.cassandra.coordinator.dc";
 
 /**
  * Deprecated, use @code cassandra.coordinator.id @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code cassandra.coordinator.id @endcode.
+ * {"note": "Replaced by @code cassandra.coordinator.id @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCassandraCoordinatorId =
     "db.cassandra.coordinator.id";
 
 /**
  * Deprecated, use @code cassandra.query.idempotent @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code cassandra.query.idempotent @endcode.
+ * {"note": "Replaced by @code cassandra.query.idempotent @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCassandraIdempotence =
     "db.cassandra.idempotence";
 
 /**
  * Deprecated, use @code cassandra.page.size @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code cassandra.page.size @endcode.
+ * {"note": "Replaced by @code cassandra.page.size @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCassandraPageSize =
     "db.cassandra.page_size";
 
 /**
  * Deprecated, use @code cassandra.speculative_execution.count @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code cassandra.speculative_execution.count @endcode.
+ * {"note": "Replaced by @code cassandra.speculative_execution.count @endcode.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCassandraSpeculativeExecutionCount =
     "db.cassandra.speculative_execution_count";
 
 /**
  * Deprecated, use @code db.collection.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.collection.name @endcode.
+ * {"note": "Replaced by @code db.collection.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCassandraTable = "db.cassandra.table";
 
@@ -98,18 +99,18 @@ static constexpr const char *kDbClientConnectionState = "db.client.connection.st
 
 /**
  * Deprecated, use @code db.client.connection.pool.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.client.connection.pool.name @endcode.
+ * {"note": "Replaced by @code db.client.connection.pool.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbClientConnectionsPoolName =
     "db.client.connections.pool.name";
 
 /**
  * Deprecated, use @code db.client.connection.state @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.client.connection.state @endcode.
+ * {"note": "Replaced by @code db.client.connection.state @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbClientConnectionsState =
     "db.client.connections.state";
@@ -117,180 +118,190 @@ OPENTELEMETRY_DEPRECATED static constexpr const char *kDbClientConnectionsState
 /**
  * The name of a collection (table, container) within the database.
  * <p>
- * It is RECOMMENDED to capture the value as provided by the application without attempting to do
- * any case normalization. <p> The collection name SHOULD NOT be extracted from @code db.query.text
- * @endcode, unless the query format is known to only ever have a single collection name present.
+ * It is RECOMMENDED to capture the value as provided by the application
+ * without attempting to do any case normalization.
+ * <p>
+ * The collection name SHOULD NOT be extracted from @code db.query.text @endcode,
+ * when the database system supports cross-table queries in non-batch operations.
  * <p>
- * For batch operations, if the individual operations are known to have the same collection name
- * then that collection name SHOULD be used.
+ * For batch operations, if the individual operations are known to have the same
+ * collection name then that collection name SHOULD be used.
  */
 static constexpr const char *kDbCollectionName = "db.collection.name";
 
 /**
  * Deprecated, use @code server.address @endcode, @code server.port @endcode attributes instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code server.address @endcode and @code server.port @endcode.
+ * {"note": "Replaced by @code server.address @endcode and @code server.port @endcode.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbConnectionString = "db.connection_string";
 
 /**
  * Deprecated, use @code azure.client.id @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code azure.client.id @endcode.
+ * {"note": "Replaced by @code azure.client.id @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbClientId = "db.cosmosdb.client_id";
 
 /**
  * Deprecated, use @code azure.cosmosdb.connection.mode @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code azure.cosmosdb.connection.mode @endcode.
+ * {"note": "Replaced by @code azure.cosmosdb.connection.mode @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbConnectionMode =
     "db.cosmosdb.connection_mode";
 
 /**
  * Deprecated, use @code cosmosdb.consistency.level @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code azure.cosmosdb.consistency.level @endcode.
+ * {"note": "Replaced by @code azure.cosmosdb.consistency.level @endcode.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbConsistencyLevel =
     "db.cosmosdb.consistency_level";
 
 /**
  * Deprecated, use @code db.collection.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.collection.name @endcode.
+ * {"note": "Replaced by @code db.collection.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbContainer =
     "db.cosmosdb.container";
 
 /**
  * Deprecated, no replacement at this time.
- * <p>
+ *
  * @deprecated
- * No replacement at this time.
+ * {"note": "No replacement at this time.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbOperationType =
     "db.cosmosdb.operation_type";
 
 /**
  * Deprecated, use @code azure.cosmosdb.operation.contacted_regions @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code azure.cosmosdb.operation.contacted_regions @endcode.
+ * {"note": "Replaced by @code azure.cosmosdb.operation.contacted_regions @endcode.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbRegionsContacted =
     "db.cosmosdb.regions_contacted";
 
 /**
  * Deprecated, use @code azure.cosmosdb.operation.request_charge @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code azure.cosmosdb.operation.request_charge @endcode.
+ * {"note": "Replaced by @code azure.cosmosdb.operation.request_charge @endcode.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbRequestCharge =
     "db.cosmosdb.request_charge";
 
 /**
  * Deprecated, use @code azure.cosmosdb.request.body.size @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code azure.cosmosdb.request.body.size @endcode.
+ * {"note": "Replaced by @code azure.cosmosdb.request.body.size @endcode.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbRequestContentLength =
     "db.cosmosdb.request_content_length";
 
 /**
  * Deprecated, use @code db.response.status_code @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.response.status_code @endcode.
+ * {"note": "Replaced by @code db.response.status_code @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbStatusCode =
     "db.cosmosdb.status_code";
 
 /**
  * Deprecated, use @code azure.cosmosdb.response.sub_status_code @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code azure.cosmosdb.response.sub_status_code @endcode.
+ * {"note": "Replaced by @code azure.cosmosdb.response.sub_status_code @endcode.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbCosmosdbSubStatusCode =
     "db.cosmosdb.sub_status_code";
 
 /**
  * Deprecated, use @code db.namespace @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.namespace @endcode.
+ * {"note": "Replaced by @code db.namespace @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbElasticsearchClusterName =
     "db.elasticsearch.cluster.name";
 
 /**
  * Deprecated, use @code elasticsearch.node.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code elasticsearch.node.name @endcode.
+ * {"note": "Replaced by @code elasticsearch.node.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbElasticsearchNodeName =
     "db.elasticsearch.node.name";
 
 /**
  * Deprecated, use @code db.operation.parameter @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.operation.parameter @endcode.
+ * {"note": "Replaced by @code db.operation.parameter @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbElasticsearchPathParts =
     "db.elasticsearch.path_parts";
 
 /**
- * Deprecated, no general replacement at this time. For Elasticsearch, use @code
- * db.elasticsearch.node.name @endcode instead. <p>
- * @deprecated
  * Deprecated, no general replacement at this time. For Elasticsearch, use @code
  * db.elasticsearch.node.name @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Deprecated, no general replacement at this time. For Elasticsearch, use @code
+ * db.elasticsearch.node.name @endcode instead.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbInstanceId = "db.instance.id";
 
 /**
  * Removed, no replacement at this time.
- * <p>
+ *
  * @deprecated
- * Removed as not used.
+ * {"note": "Removed as not used.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbJdbcDriverClassname =
     "db.jdbc.driver_classname";
 
 /**
  * Deprecated, use @code db.collection.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.collection.name @endcode.
+ * {"note": "Replaced by @code db.collection.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbMongodbCollection =
     "db.mongodb.collection";
 
 /**
  * Deprecated, SQL Server instance is now populated as a part of @code db.namespace @endcode
- * attribute. <p>
+ * attribute.
+ *
  * @deprecated
- * Deprecated, no replacement at this time.
+ * {"note": "Deprecated, no replacement at this time.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbMssqlInstanceName =
     "db.mssql.instance_name";
 
 /**
  * Deprecated, use @code db.namespace @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.namespace @endcode.
+ * {"note": "Replaced by @code db.namespace @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbName = "db.name";
 
@@ -309,9 +320,9 @@ static constexpr const char *kDbNamespace = "db.namespace";
 
 /**
  * Deprecated, use @code db.operation.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.operation.name @endcode.
+ * {"note": "Replaced by @code db.operation.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbOperation = "db.operation";
 
@@ -330,7 +341,7 @@ static constexpr const char *kDbOperationBatchSize = "db.operation.batch.size";
  * without attempting to do any case normalization.
  * <p>
  * The operation name SHOULD NOT be extracted from @code db.query.text @endcode,
- * unless the query format is known to only ever have a single operation name present.
+ * when the database system supports cross-table queries in non-batch operations.
  * <p>
  * For batch operations, if the individual operations are known to have the same operation name
  * then that operation name SHOULD be used prepended by @code BATCH  @endcode,
@@ -351,9 +362,10 @@ static constexpr const char *kDbOperationParameter = "db.operation.parameter";
 
 /**
  * A query parameter used in @code db.query.text @endcode, with @code <key> @endcode being the
- * parameter name, and the attribute value being a string representation of the parameter value. <p>
+ * parameter name, and the attribute value being a string representation of the parameter value.
+ *
  * @deprecated
- * Replaced by @code db.operation.parameter @endcode.
+ * {"note": "Replaced by @code db.operation.parameter @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbQueryParameter = "db.query.parameter";
 
@@ -365,8 +377,8 @@ OPENTELEMETRY_DEPRECATED static constexpr const char *kDbQueryParameter = "db.qu
  * database calls involving complex queries. Summary may be available to the instrumentation through
  * instrumentation hooks or other means. If it is not available, instrumentations that support query
  * parsing SHOULD generate a summary following <a
- * href="../../docs/database/database-spans.md#generating-a-summary-of-the-query-text">Generating
- * query summary</a> section.
+ * href="../database/database-spans.md#generating-a-summary-of-the-query-text">Generating query
+ * summary</a> section.
  */
 static constexpr const char *kDbQuerySummary = "db.query.summary";
 
@@ -374,7 +386,7 @@ static constexpr const char *kDbQuerySummary = "db.query.summary";
  * The database query being executed.
  * <p>
  * For sanitization see <a
- * href="../../docs/database/database-spans.md#sanitization-of-dbquerytext">Sanitization of @code
+ * href="../database/database-spans.md#sanitization-of-dbquerytext">Sanitization of @code
  * db.query.text @endcode</a>. For batch operations, if the individual operations are known to have
  * the same query text then that query text SHOULD be used, otherwise all of the individual query
  * texts SHOULD be concatenated with separator @code ;  @endcode or some other database system
@@ -387,9 +399,9 @@ static constexpr const char *kDbQueryText = "db.query.text";
 
 /**
  * Deprecated, use @code db.namespace @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.namespace @endcode.
+ * {"note": "Replaced by @code db.namespace @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbRedisDatabaseIndex =
     "db.redis.database_index";
@@ -411,25 +423,25 @@ static constexpr const char *kDbResponseStatusCode = "db.response.status_code";
 
 /**
  * Deprecated, use @code db.collection.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.collection.name @endcode.
+ * {"note": "Replaced by @code db.collection.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbSqlTable = "db.sql.table";
 
 /**
  * The database statement being executed.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.query.text @endcode.
+ * {"note": "Replaced by @code db.query.text @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbStatement = "db.statement";
 
 /**
  * Deprecated, use @code db.system.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.system.name @endcode.
+ * {"note": "Replaced by @code db.system.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbSystem = "db.system";
 
@@ -444,9 +456,9 @@ static constexpr const char *kDbSystemName = "db.system.name";
 
 /**
  * Deprecated, no replacement at this time.
- * <p>
+ *
  * @deprecated
- * No replacement at this time.
+ * {"note": "No replacement at this time.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDbUser = "db.user";
 
@@ -673,11 +685,8 @@ static constexpr const char *kAdabas = "adabas";
 
 /**
  * Deprecated, use @code intersystems_cache @endcode instead.
- * <p>
- * @deprecated
- * Replaced by @code intersystems_cache @endcode.
  */
-OPENTELEMETRY_DEPRECATED static constexpr const char *kCache = "cache";
+static constexpr const char *kCache = "cache";
 
 /**
  * InterSystems Caché
@@ -696,11 +705,8 @@ static constexpr const char *kClickhouse = "clickhouse";
 
 /**
  * Deprecated, use @code other_sql @endcode instead.
- * <p>
- * @deprecated
- * Replaced by @code other_sql @endcode.
  */
-OPENTELEMETRY_DEPRECATED static constexpr const char *kCloudscape = "cloudscape";
+static constexpr const char *kCloudscape = "cloudscape";
 
 /**
  * CockroachDB
@@ -709,11 +715,8 @@ static constexpr const char *kCockroachdb = "cockroachdb";
 
 /**
  * Deprecated, no replacement at this time.
- * <p>
- * @deprecated
- * Removed.
  */
-OPENTELEMETRY_DEPRECATED static constexpr const char *kColdfusion = "coldfusion";
+static constexpr const char *kColdfusion = "coldfusion";
 
 /**
  * Microsoft Azure Cosmos DB
@@ -767,11 +770,8 @@ static constexpr const char *kFirebird = "firebird";
 
 /**
  * Deprecated, use @code other_sql @endcode instead.
- * <p>
- * @deprecated
- * Replaced by @code other_sql @endcode.
  */
-OPENTELEMETRY_DEPRECATED static constexpr const char *kFirstsql = "firstsql";
+static constexpr const char *kFirstsql = "firstsql";
 
 /**
  * Apache Geode
@@ -855,11 +855,8 @@ static constexpr const char *kMssql = "mssql";
 
 /**
  * Deprecated, Microsoft SQL Server Compact is discontinued.
- * <p>
- * @deprecated
- * Removed, use @code other_sql @endcode instead.
  */
-OPENTELEMETRY_DEPRECATED static constexpr const char *kMssqlcompact = "mssqlcompact";
+static constexpr const char *kMssqlcompact = "mssqlcompact";
 
 /**
  * MySQL (This value has stability level RELEASE CANDIDATE)
diff --git a/api/include/opentelemetry/semconv/incubating/db_metrics.h b/api/include/opentelemetry/semconv/incubating/db_metrics.h
index d26662fcc7..a444adf5f9 100644
--- a/api/include/opentelemetry/semconv/incubating/db_metrics.h
+++ b/api/include/opentelemetry/semconv/incubating/db_metrics.h
@@ -354,10 +354,11 @@ CreateSyncDoubleMetricDbClientConnectionWaitTime(metrics::Meter *meter)
 
 /**
  * Deprecated, use @code db.client.connection.create_time @endcode instead. Note: the unit also
- * changed from @code ms @endcode to @code s @endcode. <p>
+ * changed from @code ms @endcode to @code s @endcode.
+ *
  * @deprecated
- * Replaced by @code db.client.connection.create_time @endcode. Note: the unit also changed from
- * @code ms @endcode to @code s @endcode. <p> histogram
+ * {"note": "Replaced by @code db.client.connection.create_time @endcode. Note: the unit also
+ * changed from @code ms @endcode to @code s @endcode.", "reason": "uncategorized"} <p> histogram
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsCreateTime =
     "db.client.connections.create_time";
@@ -385,9 +386,9 @@ CreateSyncDoubleMetricDbClientConnectionsCreateTime(metrics::Meter *meter)
 
 /**
  * Deprecated, use @code db.client.connection.idle.max @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.client.connection.idle.max @endcode.
+ * {"note": "Replaced by @code db.client.connection.idle.max @endcode.", "reason": "uncategorized"}
  * <p>
  * updowncounter
  */
@@ -432,9 +433,9 @@ CreateAsyncDoubleMetricDbClientConnectionsIdleMax(metrics::Meter *meter)
 
 /**
  * Deprecated, use @code db.client.connection.idle.min @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.client.connection.idle.min @endcode.
+ * {"note": "Replaced by @code db.client.connection.idle.min @endcode.", "reason": "uncategorized"}
  * <p>
  * updowncounter
  */
@@ -479,9 +480,9 @@ CreateAsyncDoubleMetricDbClientConnectionsIdleMin(metrics::Meter *meter)
 
 /**
  * Deprecated, use @code db.client.connection.max @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.client.connection.max @endcode.
+ * {"note": "Replaced by @code db.client.connection.max @endcode.", "reason": "uncategorized"}
  * <p>
  * updowncounter
  */
@@ -526,11 +527,10 @@ CreateAsyncDoubleMetricDbClientConnectionsMax(metrics::Meter *meter)
 
 /**
  * Deprecated, use @code db.client.connection.pending_requests @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.client.connection.pending_requests @endcode.
- * <p>
- * updowncounter
+ * {"note": "Replaced by @code db.client.connection.pending_requests @endcode.", "reason":
+ * "uncategorized"} <p> updowncounter
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsPendingRequests =
     "db.client.connections.pending_requests";
@@ -574,9 +574,9 @@ CreateAsyncDoubleMetricDbClientConnectionsPendingRequests(metrics::Meter *meter)
 
 /**
  * Deprecated, use @code db.client.connection.timeouts @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.client.connection.timeouts @endcode.
+ * {"note": "Replaced by @code db.client.connection.timeouts @endcode.", "reason": "uncategorized"}
  * <p>
  * counter
  */
@@ -621,9 +621,9 @@ CreateAsyncDoubleMetricDbClientConnectionsTimeouts(metrics::Meter *meter)
 
 /**
  * Deprecated, use @code db.client.connection.count @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.client.connection.count @endcode.
+ * {"note": "Replaced by @code db.client.connection.count @endcode.", "reason": "uncategorized"}
  * <p>
  * updowncounter
  */
@@ -668,10 +668,11 @@ CreateAsyncDoubleMetricDbClientConnectionsUsage(metrics::Meter *meter)
 
 /**
  * Deprecated, use @code db.client.connection.use_time @endcode instead. Note: the unit also changed
- * from @code ms @endcode to @code s @endcode. <p>
+ * from @code ms @endcode to @code s @endcode.
+ *
  * @deprecated
- * Replaced by @code db.client.connection.use_time @endcode. Note: the unit also changed from @code
- * ms @endcode to @code s @endcode. <p> histogram
+ * {"note": "Replaced by @code db.client.connection.use_time @endcode. Note: the unit also changed
+ * from @code ms @endcode to @code s @endcode.", "reason": "uncategorized"} <p> histogram
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsUseTime =
     "db.client.connections.use_time";
@@ -698,10 +699,11 @@ CreateSyncDoubleMetricDbClientConnectionsUseTime(metrics::Meter *meter)
 
 /**
  * Deprecated, use @code db.client.connection.wait_time @endcode instead. Note: the unit also
- * changed from @code ms @endcode to @code s @endcode. <p>
+ * changed from @code ms @endcode to @code s @endcode.
+ *
  * @deprecated
- * Replaced by @code db.client.connection.wait_time @endcode. Note: the unit also changed from @code
- * ms @endcode to @code s @endcode. <p> histogram
+ * {"note": "Replaced by @code db.client.connection.wait_time @endcode. Note: the unit also changed
+ * from @code ms @endcode to @code s @endcode.", "reason": "uncategorized"} <p> histogram
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientConnectionsWaitTime =
     "db.client.connections.wait_time";
@@ -728,11 +730,10 @@ CreateSyncDoubleMetricDbClientConnectionsWaitTime(metrics::Meter *meter)
 
 /**
  * Deprecated, use @code azure.cosmosdb.client.active_instance.count @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code azure.cosmosdb.client.active_instance.count @endcode.
- * <p>
- * updowncounter
+ * {"note": "Replaced by @code azure.cosmosdb.client.active_instance.count @endcode.", "reason":
+ * "uncategorized"} <p> updowncounter
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricDbClientCosmosdbActiveInstanceCount =
     "db.client.cosmosdb.active_instance.count";
@@ -776,11 +777,10 @@ CreateAsyncDoubleMetricDbClientCosmosdbActiveInstanceCount(metrics::Meter *meter
 
 /**
  * Deprecated, use @code azure.cosmosdb.client.operation.request_charge @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code azure.cosmosdb.client.operation.request_charge @endcode.
- * <p>
- * histogram
+ * {"note": "Replaced by @code azure.cosmosdb.client.operation.request_charge @endcode.", "reason":
+ * "uncategorized"} <p> histogram
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char
     *kMetricDbClientCosmosdbOperationRequestCharge = "db.client.cosmosdb.operation.request_charge";
diff --git a/api/include/opentelemetry/semconv/incubating/deployment_attributes.h b/api/include/opentelemetry/semconv/incubating/deployment_attributes.h
index 534608bb65..fc2aeb1c3d 100644
--- a/api/include/opentelemetry/semconv/incubating/deployment_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/deployment_attributes.h
@@ -21,9 +21,10 @@ namespace deployment
 
 /**
  * 'Deprecated, use @code deployment.environment.name @endcode instead.'
- * <p>
+ *
  * @deprecated
- * Deprecated, use @code deployment.environment.name @endcode instead.
+ * {"note": "Deprecated, use @code deployment.environment.name @endcode instead.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kDeploymentEnvironment =
     "deployment.environment";
diff --git a/api/include/opentelemetry/semconv/incubating/enduser_attributes.h b/api/include/opentelemetry/semconv/incubating/enduser_attributes.h
index 922ff9c803..af9fe393a8 100644
--- a/api/include/opentelemetry/semconv/incubating/enduser_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/enduser_attributes.h
@@ -20,26 +20,35 @@ namespace enduser
 {
 
 /**
- * Deprecated, use @code user.id @endcode instead.
- * <p>
- * @deprecated
- * Replaced by @code user.id @endcode attribute.
+ * Unique identifier of an end user in the system. It maybe a username, email address, or other
+ * identifier. <p> Unique identifier of an end user in the system. <blockquote>
+ * [!Warning]
+ * This field contains sensitive (PII) information.</blockquote>
+ */
+static constexpr const char *kEnduserId = "enduser.id";
+
+/**
+ * Pseudonymous identifier of an end user. This identifier should be a random value that is not
+ * directly linked or associated with the end user's actual identity. <p> Pseudonymous identifier of
+ * an end user. <blockquote>
+ * [!Warning]
+ * This field contains sensitive (linkable PII) information.</blockquote>
  */
-OPENTELEMETRY_DEPRECATED static constexpr const char *kEnduserId = "enduser.id";
+static constexpr const char *kEnduserPseudoId = "enduser.pseudo.id";
 
 /**
  * Deprecated, use @code user.roles @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code user.roles @endcode attribute.
+ * {"note": "Replaced by @code user.roles @endcode attribute.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kEnduserRole = "enduser.role";
 
 /**
  * Deprecated, no replacement at this time.
- * <p>
+ *
  * @deprecated
- * Removed.
+ * {"note": "Removed.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kEnduserScope = "enduser.scope";
 
diff --git a/api/include/opentelemetry/semconv/incubating/event_attributes.h b/api/include/opentelemetry/semconv/incubating/event_attributes.h
index 4342757540..c1b39247d5 100644
--- a/api/include/opentelemetry/semconv/incubating/event_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/event_attributes.h
@@ -21,9 +21,9 @@ namespace event
 
 /**
  * Identifies the class / type of event.
- * <p>
+ *
  * @deprecated
- * Replaced by EventName top-level field on the LogRecord
+ * {"note": "Replaced by EventName top-level field on the LogRecord", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kEventName = "event.name";
 
diff --git a/api/include/opentelemetry/semconv/incubating/exception_attributes.h b/api/include/opentelemetry/semconv/incubating/exception_attributes.h
index 980e4525f9..61e94d955b 100644
--- a/api/include/opentelemetry/semconv/incubating/exception_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/exception_attributes.h
@@ -21,10 +21,10 @@ namespace exception
 
 /**
  * Indicates that the exception is escaping the scope of the span.
- * <p>
+ *
  * @deprecated
- * It's no longer recommended to record exceptions that are handled and do not escape the scope of a
- * span.
+ * {"note": "It's no longer recommended to record exceptions that are handled and do not escape the
+ * scope of a span.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kExceptionEscaped = "exception.escaped";
 
diff --git a/api/include/opentelemetry/semconv/incubating/gen_ai_attributes.h b/api/include/opentelemetry/semconv/incubating/gen_ai_attributes.h
index cab6f8034f..a2acf23845 100644
--- a/api/include/opentelemetry/semconv/incubating/gen_ai_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/gen_ai_attributes.h
@@ -19,25 +19,43 @@ namespace semconv
 namespace gen_ai
 {
 
+/**
+ * Free-form description of the GenAI agent provided by the application.
+ */
+static constexpr const char *kGenAiAgentDescription = "gen_ai.agent.description";
+
+/**
+ * The unique identifier of the GenAI agent.
+ */
+static constexpr const char *kGenAiAgentId = "gen_ai.agent.id";
+
+/**
+ * Human-readable name of the GenAI agent provided by the application.
+ */
+static constexpr const char *kGenAiAgentName = "gen_ai.agent.name";
+
 /**
  * Deprecated, use Event API to report completions contents.
- * <p>
+ *
  * @deprecated
- * Removed, no replacement at this time.
+ * {"note": "Removed, no replacement at this time.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kGenAiCompletion = "gen_ai.completion";
 
 /**
- * The response format that is requested.
+ * Deprecated, use @code gen_ai.output.type @endcode.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code gen_ai.output.type @endcode.", "reason": "uncategorized"}
  */
-static constexpr const char *kGenAiOpenaiRequestResponseFormat =
+OPENTELEMETRY_DEPRECATED static constexpr const char *kGenAiOpenaiRequestResponseFormat =
     "gen_ai.openai.request.response_format";
 
 /**
  * Deprecated, use @code gen_ai.request.seed @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code gen_ai.request.seed @endcode attribute.
+ * {"note": "Replaced by @code gen_ai.request.seed @endcode attribute.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kGenAiOpenaiRequestSeed =
     "gen_ai.openai.request.seed";
@@ -70,13 +88,29 @@ static constexpr const char *kGenAiOpenaiResponseSystemFingerprint =
 static constexpr const char *kGenAiOperationName = "gen_ai.operation.name";
 
 /**
- * Deprecated, use Event API to report prompt contents.
+ * Represents the content type requested by the client.
  * <p>
+ * This attribute SHOULD be used when the client requests output of a specific type. The model may
+ * return zero or more outputs of this type. This attribute specifies the output modality and not
+ * the actual output format. For example, if an image is requested, the actual output could be a URL
+ * pointing to an image file. Additional output format details may be recorded in the future in the
+ * @code gen_ai.output.{type}.* @endcode attributes.
+ */
+static constexpr const char *kGenAiOutputType = "gen_ai.output.type";
+
+/**
+ * Deprecated, use Event API to report prompt contents.
+ *
  * @deprecated
- * Removed, no replacement at this time.
+ * {"note": "Removed, no replacement at this time.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kGenAiPrompt = "gen_ai.prompt";
 
+/**
+ * The target number of candidate completions to return.
+ */
+static constexpr const char *kGenAiRequestChoiceCount = "gen_ai.request.choice.count";
+
 /**
  * The encoding formats requested in an embeddings operation, if specified.
  * <p>
@@ -166,10 +200,34 @@ static constexpr const char *kGenAiSystem = "gen_ai.system";
 static constexpr const char *kGenAiTokenType = "gen_ai.token.type";
 
 /**
- * Deprecated, use @code gen_ai.usage.output_tokens @endcode instead.
+ * The tool call identifier.
+ */
+static constexpr const char *kGenAiToolCallId = "gen_ai.tool.call.id";
+
+/**
+ * Name of the tool utilized by the agent.
+ */
+static constexpr const char *kGenAiToolName = "gen_ai.tool.name";
+
+/**
+ * Type of the tool utilized by the agent
  * <p>
+ * Extension: A tool executed on the agent-side to directly call external APIs, bridging the gap
+ * between the agent and real-world systems. Agent-side operations involve actions that are
+ * performed by the agent on the server or within the agent's controlled environment. Function: A
+ * tool executed on the client-side, where the agent generates parameters for a predefined function,
+ * and the client executes the logic. Client-side operations are actions taken on the user's end or
+ * within the client application. Datastore: A tool used by the agent to access and query structured
+ * or unstructured external data for retrieval-augmented tasks or knowledge updates.
+ */
+static constexpr const char *kGenAiToolType = "gen_ai.tool.type";
+
+/**
+ * Deprecated, use @code gen_ai.usage.output_tokens @endcode instead.
+ *
  * @deprecated
- * Replaced by @code gen_ai.usage.output_tokens @endcode attribute.
+ * {"note": "Replaced by @code gen_ai.usage.output_tokens @endcode attribute.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kGenAiUsageCompletionTokens =
     "gen_ai.usage.completion_tokens";
@@ -186,9 +244,10 @@ static constexpr const char *kGenAiUsageOutputTokens = "gen_ai.usage.output_toke
 
 /**
  * Deprecated, use @code gen_ai.usage.input_tokens @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code gen_ai.usage.input_tokens @endcode attribute.
+ * {"note": "Replaced by @code gen_ai.usage.input_tokens @endcode attribute.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kGenAiUsagePromptTokens =
     "gen_ai.usage.prompt_tokens";
@@ -248,8 +307,42 @@ static constexpr const char *kTextCompletion = "text_completion";
  */
 static constexpr const char *kEmbeddings = "embeddings";
 
+/**
+ * Create GenAI agent
+ */
+static constexpr const char *kCreateAgent = "create_agent";
+
+/**
+ * Execute a tool
+ */
+static constexpr const char *kExecuteTool = "execute_tool";
+
 }  // namespace GenAiOperationNameValues
 
+namespace GenAiOutputTypeValues
+{
+/**
+ * Plain text
+ */
+static constexpr const char *kText = "text";
+
+/**
+ * JSON object with known or unknown schema
+ */
+static constexpr const char *kJson = "json";
+
+/**
+ * Image
+ */
+static constexpr const char *kImage = "image";
+
+/**
+ * Speech
+ */
+static constexpr const char *kSpeech = "speech";
+
+}  // namespace GenAiOutputTypeValues
+
 namespace GenAiSystemValues
 {
 /**
@@ -336,6 +429,11 @@ static constexpr const char *kInput = "input";
  */
 static constexpr const char *kCompletion = "output";
 
+/**
+ * Output tokens (completion, response, etc.)
+ */
+static constexpr const char *kOutput = "output";
+
 }  // namespace GenAiTokenTypeValues
 
 }  // namespace gen_ai
diff --git a/api/include/opentelemetry/semconv/incubating/http_attributes.h b/api/include/opentelemetry/semconv/incubating/http_attributes.h
index 0bf4c65ff7..b83ebf12ed 100644
--- a/api/include/opentelemetry/semconv/incubating/http_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/http_attributes.h
@@ -21,9 +21,9 @@ namespace http
 
 /**
  * Deprecated, use @code client.address @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code client.address @endcode.
+ * {"note": "Replaced by @code client.address @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpClientIp = "http.client_ip";
 
@@ -34,26 +34,27 @@ static constexpr const char *kHttpConnectionState = "http.connection.state";
 
 /**
  * Deprecated, use @code network.protocol.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code network.protocol.name @endcode.
+ * {"note": "Replaced by @code network.protocol.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpFlavor = "http.flavor";
 
 /**
  * Deprecated, use one of @code server.address @endcode, @code client.address @endcode or @code
- * http.request.header.host @endcode instead, depending on the usage. <p>
+ * http.request.header.host @endcode instead, depending on the usage.
+ *
  * @deprecated
- * Replaced by one of @code server.address @endcode, @code client.address @endcode or @code
- * http.request.header.host @endcode, depending on the usage.
+ * {"note": "Replaced by one of @code server.address @endcode, @code client.address @endcode or
+ * @code http.request.header.host @endcode, depending on the usage.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpHost = "http.host";
 
 /**
  * Deprecated, use @code http.request.method @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code http.request.method @endcode.
+ * {"note": "Replaced by @code http.request.method @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpMethod = "http.method";
 
@@ -123,18 +124,18 @@ static constexpr const char *kHttpRequestSize = "http.request.size";
 
 /**
  * Deprecated, use @code http.request.header.<key> @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code http.request.header.<key> @endcode.
+ * {"note": "Replaced by @code http.request.header.<key> @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpRequestContentLength =
     "http.request_content_length";
 
 /**
  * Deprecated, use @code http.request.body.size @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code http.request.body.size @endcode.
+ * {"note": "Replaced by @code http.request.body.size @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpRequestContentLengthUncompressed =
     "http.request_content_length_uncompressed";
@@ -173,18 +174,18 @@ static constexpr const char *kHttpResponseStatusCode = "http.response.status_cod
 
 /**
  * Deprecated, use @code http.response.header.<key> @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code http.response.header.<key> @endcode.
+ * {"note": "Replaced by @code http.response.header.<key> @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpResponseContentLength =
     "http.response_content_length";
 
 /**
  * Deprecated, use @code http.response.body.size @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replace by @code http.response.body.size @endcode.
+ * {"note": "Replace by @code http.response.body.size @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpResponseContentLengthUncompressed =
     "http.response_content_length_uncompressed";
@@ -200,49 +201,49 @@ static constexpr const char *kHttpRoute = "http.route";
 
 /**
  * Deprecated, use @code url.scheme @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code url.scheme @endcode instead.
+ * {"note": "Replaced by @code url.scheme @endcode instead.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpScheme = "http.scheme";
 
 /**
  * Deprecated, use @code server.address @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code server.address @endcode.
+ * {"note": "Replaced by @code server.address @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpServerName = "http.server_name";
 
 /**
  * Deprecated, use @code http.response.status_code @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code http.response.status_code @endcode.
+ * {"note": "Replaced by @code http.response.status_code @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpStatusCode = "http.status_code";
 
 /**
  * Deprecated, use @code url.path @endcode and @code url.query @endcode instead.
- * <p>
+ *
  * @deprecated
- * Split to @code url.path @endcode and `url.query.
+ * {"note": "Split to @code url.path @endcode and `url.query.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpTarget = "http.target";
 
 /**
  * Deprecated, use @code url.full @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code url.full @endcode.
+ * {"note": "Replaced by @code url.full @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpUrl = "http.url";
 
 /**
  * Deprecated, use @code user_agent.original @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code user_agent.original @endcode.
+ * {"note": "Replaced by @code user_agent.original @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kHttpUserAgent = "http.user_agent";
 
diff --git a/api/include/opentelemetry/semconv/incubating/hw_metrics.h b/api/include/opentelemetry/semconv/incubating/hw_metrics.h
index a8c4446361..225b939e8c 100644
--- a/api/include/opentelemetry/semconv/incubating/hw_metrics.h
+++ b/api/include/opentelemetry/semconv/incubating/hw_metrics.h
@@ -90,6 +90,176 @@ static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDouble
                                               unitMetricHwErrors);
 }
 
+/**
+ * Ambient (external) temperature of the physical host
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricHwHostAmbientTemperature = "hw.host.ambient_temperature";
+static constexpr const char *descrMetricHwHostAmbientTemperature =
+    "Ambient (external) temperature of the physical host";
+static constexpr const char *unitMetricHwHostAmbientTemperature = "Cel";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
+CreateSyncInt64MetricHwHostAmbientTemperature(metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricHwHostAmbientTemperature,
+                                 descrMetricHwHostAmbientTemperature,
+                                 unitMetricHwHostAmbientTemperature);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>>
+CreateSyncDoubleMetricHwHostAmbientTemperature(metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricHwHostAmbientTemperature,
+                                  descrMetricHwHostAmbientTemperature,
+                                  unitMetricHwHostAmbientTemperature);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricHwHostAmbientTemperature(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricHwHostAmbientTemperature,
+                                           descrMetricHwHostAmbientTemperature,
+                                           unitMetricHwHostAmbientTemperature);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricHwHostAmbientTemperature(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricHwHostAmbientTemperature,
+                                            descrMetricHwHostAmbientTemperature,
+                                            unitMetricHwHostAmbientTemperature);
+}
+
+/**
+ * Total energy consumed by the entire physical host, in joules
+ * <p>
+ * The overall energy usage of a host MUST be reported using the specific @code hw.host.energy
+ * @endcode and @code hw.host.power @endcode metrics <strong>only</strong>, instead of the generic
+ * @code hw.energy @endcode and @code hw.power @endcode described in the previous section, to
+ * prevent summing up overlapping values. <p> counter
+ */
+static constexpr const char *kMetricHwHostEnergy = "hw.host.energy";
+static constexpr const char *descrMetricHwHostEnergy =
+    "Total energy consumed by the entire physical host, in joules";
+static constexpr const char *unitMetricHwHostEnergy = "J";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricHwHostEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
+                                    unitMetricHwHostEnergy);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricHwHostEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
+                                    unitMetricHwHostEnergy);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwHostEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
+                                             unitMetricHwHostEnergy);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwHostEnergy(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricHwHostEnergy, descrMetricHwHostEnergy,
+                                              unitMetricHwHostEnergy);
+}
+
+/**
+ * By how many degrees Celsius the temperature of the physical host can be increased, before
+ * reaching a warning threshold on one of the internal sensors <p> gauge
+ */
+static constexpr const char *kMetricHwHostHeatingMargin = "hw.host.heating_margin";
+static constexpr const char *descrMetricHwHostHeatingMargin =
+    "By how many degrees Celsius the temperature of the physical host can be increased, before reaching a warning threshold on one of the internal sensors
+    ";
+    static constexpr const char *unitMetricHwHostHeatingMargin = "Cel";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricHwHostHeatingMargin(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin,
+                                 unitMetricHwHostHeatingMargin);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricHwHostHeatingMargin(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin,
+                                  unitMetricHwHostHeatingMargin);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricHwHostHeatingMargin(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(
+      kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin, unitMetricHwHostHeatingMargin);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricHwHostHeatingMargin(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(
+      kMetricHwHostHeatingMargin, descrMetricHwHostHeatingMargin, unitMetricHwHostHeatingMargin);
+}
+
+/**
+ * Instantaneous power consumed by the entire physical host in Watts (@code hw.host.energy @endcode
+ * is preferred) <p> The overall energy usage of a host MUST be reported using the specific @code
+ * hw.host.energy @endcode and @code hw.host.power @endcode metrics <strong>only</strong>, instead
+ * of the generic @code hw.energy @endcode and @code hw.power @endcode described in the previous
+ * section, to prevent summing up overlapping values. <p> gauge
+ */
+static constexpr const char *kMetricHwHostPower = "hw.host.power";
+static constexpr const char *descrMetricHwHostPower =
+    "Instantaneous power consumed by the entire physical host in Watts (`hw.host.energy` is preferred)
+    ";
+    static constexpr const char *unitMetricHwHostPower = "W";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricHwHostPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricHwHostPower, descrMetricHwHostPower, unitMetricHwHostPower);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricHwHostPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricHwHostPower, descrMetricHwHostPower,
+                                  unitMetricHwHostPower);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricHwHostPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricHwHostPower, descrMetricHwHostPower,
+                                           unitMetricHwHostPower);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricHwHostPower(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricHwHostPower, descrMetricHwHostPower,
+                                            unitMetricHwHostPower);
+}
+
 /**
  * Instantaneous power consumed by the component
  * <p>
diff --git a/api/include/opentelemetry/semconv/incubating/k8s_attributes.h b/api/include/opentelemetry/semconv/incubating/k8s_attributes.h
index 849dc24655..54f5a2a182 100644
--- a/api/include/opentelemetry/semconv/incubating/k8s_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/k8s_attributes.h
@@ -96,6 +96,16 @@ static constexpr const char *kK8sDeploymentName = "k8s.deployment.name";
  */
 static constexpr const char *kK8sDeploymentUid = "k8s.deployment.uid";
 
+/**
+ * The name of the horizontal pod autoscaler.
+ */
+static constexpr const char *kK8sHpaName = "k8s.hpa.name";
+
+/**
+ * The UID of the horizontal pod autoscaler.
+ */
+static constexpr const char *kK8sHpaUid = "k8s.hpa.uid";
+
 /**
  * The name of the Job.
  */
@@ -145,9 +155,9 @@ static constexpr const char *kK8sPodLabel = "k8s.pod.label";
 
 /**
  * Deprecated, use @code k8s.pod.label @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code k8s.pod.label @endcode.
+ * {"note": "Replaced by @code k8s.pod.label @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kK8sPodLabels = "k8s.pod.labels";
 
@@ -171,6 +181,26 @@ static constexpr const char *kK8sReplicasetName = "k8s.replicaset.name";
  */
 static constexpr const char *kK8sReplicasetUid = "k8s.replicaset.uid";
 
+/**
+ * The name of the replication controller.
+ */
+static constexpr const char *kK8sReplicationcontrollerName = "k8s.replicationcontroller.name";
+
+/**
+ * The UID of the replication controller.
+ */
+static constexpr const char *kK8sReplicationcontrollerUid = "k8s.replicationcontroller.uid";
+
+/**
+ * The name of the resource quota.
+ */
+static constexpr const char *kK8sResourcequotaName = "k8s.resourcequota.name";
+
+/**
+ * The UID of the resource quota.
+ */
+static constexpr const char *kK8sResourcequotaUid = "k8s.resourcequota.uid";
+
 /**
  * The name of the StatefulSet.
  */
diff --git a/api/include/opentelemetry/semconv/incubating/k8s_metrics.h b/api/include/opentelemetry/semconv/incubating/k8s_metrics.h
index 05f9a5126b..0c2a18ea20 100644
--- a/api/include/opentelemetry/semconv/incubating/k8s_metrics.h
+++ b/api/include/opentelemetry/semconv/incubating/k8s_metrics.h
@@ -344,7 +344,9 @@ CreateAsyncDoubleMetricK8sDeploymentDesiredPods(metrics::Meter *meter)
  * Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the
  * autoscaler <p> This metric aligns with the @code currentReplicas @endcode field of the <a
  * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerstatus-v2-autoscaling">K8s
- * HorizontalPodAutoscalerStatus</a> <p> updowncounter
+ * HorizontalPodAutoscalerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
+ * updowncounter
  */
 static constexpr const char *kMetricK8sHpaCurrentPods = "k8s.hpa.current_pods";
 static constexpr const char *descrMetricK8sHpaCurrentPods =
@@ -384,7 +386,9 @@ CreateAsyncDoubleMetricK8sHpaCurrentPods(metrics::Meter *meter)
  * Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated by
  * the autoscaler <p> This metric aligns with the @code desiredReplicas @endcode field of the <a
  * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerstatus-v2-autoscaling">K8s
- * HorizontalPodAutoscalerStatus</a> <p> updowncounter
+ * HorizontalPodAutoscalerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
+ * updowncounter
  */
 static constexpr const char *kMetricK8sHpaDesiredPods = "k8s.hpa.desired_pods";
 static constexpr const char *descrMetricK8sHpaDesiredPods =
@@ -426,7 +430,9 @@ CreateAsyncDoubleMetricK8sHpaDesiredPods(metrics::Meter *meter)
  * This metric aligns with the @code maxReplicas @endcode field of the
  * <a
  * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerspec-v2-autoscaling">K8s
- * HorizontalPodAutoscalerSpec</a> <p> updowncounter
+ * HorizontalPodAutoscalerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
+ * updowncounter
  */
 static constexpr const char *kMetricK8sHpaMaxPods = "k8s.hpa.max_pods";
 static constexpr const char *descrMetricK8sHpaMaxPods =
@@ -467,7 +473,9 @@ static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDouble
  * This metric aligns with the @code minReplicas @endcode field of the
  * <a
  * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerspec-v2-autoscaling">K8s
- * HorizontalPodAutoscalerSpec</a> <p> updowncounter
+ * HorizontalPodAutoscalerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
+ * updowncounter
  */
 static constexpr const char *kMetricK8sHpaMinPods = "k8s.hpa.min_pods";
 static constexpr const char *descrMetricK8sHpaMinPods =
@@ -636,13 +644,10 @@ CreateAsyncDoubleMetricK8sJobFailedPods(metrics::Meter *meter)
  * The max desired number of pods the job should run at any given time
  * <p>
  * This metric aligns with the @code parallelism @endcode field of the
- * [K8s
- * JobSpec](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch.
- * <p>
- * This metric SHOULD, at a minimum, be reported against a
- * <a href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource.
- * <p>
- * updowncounter
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch">K8s
+ * JobSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
  */
 static constexpr const char *kMetricK8sJobMaxParallelPods = "k8s.job.max_parallel_pods";
 static constexpr const char *descrMetricK8sJobMaxParallelPods =
@@ -1338,20 +1343,25 @@ CreateAsyncDoubleMetricK8sReplicasetDesiredPods(metrics::Meter *meter)
 }
 
 /**
- * Total number of available replica pods (ready for at least minReadySeconds) targeted by this
- * replication controller <p> This metric aligns with the @code availableReplicas @endcode field of
- * the <a
+ * Deprecated, use @code k8s.replicationcontroller.available_pods @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code k8s.replicationcontroller.available_pods @endcode.", "reason":
+ * "uncategorized"} <p> This metric aligns with the @code availableReplicas @endcode field of the <a
  * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerstatus-v1-core">K8s
- * ReplicationControllerStatus</a> <p> updowncounter
+ * ReplicationControllerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
+ * resource. <p> updowncounter
  */
-static constexpr const char *kMetricK8sReplicationControllerAvailablePods =
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicationControllerAvailablePods =
     "k8s.replication_controller.available_pods";
-static constexpr const char *descrMetricK8sReplicationControllerAvailablePods =
-    "Total number of available replica pods (ready for at least minReadySeconds) targeted by this "
-    "replication controller";
-static constexpr const char *unitMetricK8sReplicationControllerAvailablePods = "{pod}";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *descrMetricK8sReplicationControllerAvailablePods =
+        "Deprecated, use `k8s.replicationcontroller.available_pods` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *unitMetricK8sReplicationControllerAvailablePods = "{pod}";
 
-static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
 CreateSyncInt64MetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
 {
   return meter->CreateInt64UpDownCounter(kMetricK8sReplicationControllerAvailablePods,
@@ -1359,7 +1369,7 @@ CreateSyncInt64MetricK8sReplicationControllerAvailablePods(metrics::Meter *meter
                                          unitMetricK8sReplicationControllerAvailablePods);
 }
 
-static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
 CreateSyncDoubleMetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
 {
   return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationControllerAvailablePods,
@@ -1367,7 +1377,7 @@ CreateSyncDoubleMetricK8sReplicationControllerAvailablePods(metrics::Meter *mete
                                           unitMetricK8sReplicationControllerAvailablePods);
 }
 
-static inline nostd::shared_ptr<metrics::ObservableInstrument>
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
 CreateAsyncInt64MetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
 {
   return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationControllerAvailablePods,
@@ -1375,7 +1385,7 @@ CreateAsyncInt64MetricK8sReplicationControllerAvailablePods(metrics::Meter *mete
                                                    unitMetricK8sReplicationControllerAvailablePods);
 }
 
-static inline nostd::shared_ptr<metrics::ObservableInstrument>
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
 CreateAsyncDoubleMetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
 {
   return meter->CreateDoubleObservableUpDownCounter(
@@ -1385,20 +1395,25 @@ CreateAsyncDoubleMetricK8sReplicationControllerAvailablePods(metrics::Meter *met
 }
 
 /**
- * Number of desired replica pods in this replication controller
- * <p>
- * This metric aligns with the @code replicas @endcode field of the
- * <a
+ * Deprecated, use @code k8s.replicationcontroller.desired_pods @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code k8s.replicationcontroller.desired_pods @endcode.", "reason":
+ * "uncategorized"} <p> This metric aligns with the @code replicas @endcode field of the <a
  * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerspec-v1-core">K8s
- * ReplicationControllerSpec</a> <p> updowncounter
+ * ReplicationControllerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
+ * resource. <p> updowncounter
  */
-static constexpr const char *kMetricK8sReplicationControllerDesiredPods =
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicationControllerDesiredPods =
     "k8s.replication_controller.desired_pods";
-static constexpr const char *descrMetricK8sReplicationControllerDesiredPods =
-    "Number of desired replica pods in this replication controller";
-static constexpr const char *unitMetricK8sReplicationControllerDesiredPods = "{pod}";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *descrMetricK8sReplicationControllerDesiredPods =
+        "Deprecated, use `k8s.replicationcontroller.desired_pods` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *unitMetricK8sReplicationControllerDesiredPods = "{pod}";
 
-static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
 CreateSyncInt64MetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
 {
   return meter->CreateInt64UpDownCounter(kMetricK8sReplicationControllerDesiredPods,
@@ -1406,7 +1421,7 @@ CreateSyncInt64MetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
                                          unitMetricK8sReplicationControllerDesiredPods);
 }
 
-static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
 CreateSyncDoubleMetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
 {
   return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationControllerDesiredPods,
@@ -1414,7 +1429,7 @@ CreateSyncDoubleMetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
                                           unitMetricK8sReplicationControllerDesiredPods);
 }
 
-static inline nostd::shared_ptr<metrics::ObservableInstrument>
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
 CreateAsyncInt64MetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
 {
   return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationControllerDesiredPods,
@@ -1422,7 +1437,7 @@ CreateAsyncInt64MetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
                                                    unitMetricK8sReplicationControllerDesiredPods);
 }
 
-static inline nostd::shared_ptr<metrics::ObservableInstrument>
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
 CreateAsyncDoubleMetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
 {
   return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicationControllerDesiredPods,
@@ -1430,6 +1445,103 @@ CreateAsyncDoubleMetricK8sReplicationControllerDesiredPods(metrics::Meter *meter
                                                     unitMetricK8sReplicationControllerDesiredPods);
 }
 
+/**
+ * Total number of available replica pods (ready for at least minReadySeconds) targeted by this
+ * replication controller <p> This metric aligns with the @code availableReplicas @endcode field of
+ * the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerstatus-v1-core">K8s
+ * ReplicationControllerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
+ * resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sReplicationcontrollerAvailablePods =
+    "k8s.replicationcontroller.available_pods";
+static constexpr const char *descrMetricK8sReplicationcontrollerAvailablePods =
+    "Total number of available replica pods (ready for at least minReadySeconds) targeted by this "
+    "replication controller";
+static constexpr const char *unitMetricK8sReplicationcontrollerAvailablePods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sReplicationcontrollerAvailablePods,
+                                         descrMetricK8sReplicationcontrollerAvailablePods,
+                                         unitMetricK8sReplicationcontrollerAvailablePods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationcontrollerAvailablePods,
+                                          descrMetricK8sReplicationcontrollerAvailablePods,
+                                          unitMetricK8sReplicationcontrollerAvailablePods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationcontrollerAvailablePods,
+                                                   descrMetricK8sReplicationcontrollerAvailablePods,
+                                                   unitMetricK8sReplicationcontrollerAvailablePods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricK8sReplicationcontrollerAvailablePods,
+      descrMetricK8sReplicationcontrollerAvailablePods,
+      unitMetricK8sReplicationcontrollerAvailablePods);
+}
+
+/**
+ * Number of desired replica pods in this replication controller
+ * <p>
+ * This metric aligns with the @code replicas @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerspec-v1-core">K8s
+ * ReplicationControllerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
+ * resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sReplicationcontrollerDesiredPods =
+    "k8s.replicationcontroller.desired_pods";
+static constexpr const char *descrMetricK8sReplicationcontrollerDesiredPods =
+    "Number of desired replica pods in this replication controller";
+static constexpr const char *unitMetricK8sReplicationcontrollerDesiredPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
+                                         descrMetricK8sReplicationcontrollerDesiredPods,
+                                         unitMetricK8sReplicationcontrollerDesiredPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
+                                          descrMetricK8sReplicationcontrollerDesiredPods,
+                                          unitMetricK8sReplicationcontrollerDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
+                                                   descrMetricK8sReplicationcontrollerDesiredPods,
+                                                   unitMetricK8sReplicationcontrollerDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
+                                                    descrMetricK8sReplicationcontrollerDesiredPods,
+                                                    unitMetricK8sReplicationcontrollerDesiredPods);
+}
+
 /**
  * The number of replica pods created by the statefulset controller from the statefulset version
  * indicated by currentRevision <p> This metric aligns with the @code currentReplicas @endcode field
diff --git a/api/include/opentelemetry/semconv/incubating/message_attributes.h b/api/include/opentelemetry/semconv/incubating/message_attributes.h
index 431af91f1e..19e2e3f8c0 100644
--- a/api/include/opentelemetry/semconv/incubating/message_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/message_attributes.h
@@ -21,34 +21,34 @@ namespace message
 
 /**
  * Deprecated, use @code rpc.message.compressed_size @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code rpc.message.compressed_size @endcode.
+ * {"note": "Replaced by @code rpc.message.compressed_size @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessageCompressedSize =
     "message.compressed_size";
 
 /**
  * Deprecated, use @code rpc.message.id @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code rpc.message.id @endcode.
+ * {"note": "Replaced by @code rpc.message.id @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessageId = "message.id";
 
 /**
  * Deprecated, use @code rpc.message.type @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code rpc.message.type @endcode.
+ * {"note": "Replaced by @code rpc.message.type @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessageType = "message.type";
 
 /**
  * Deprecated, use @code rpc.message.uncompressed_size @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code rpc.message.uncompressed_size @endcode.
+ * {"note": "Replaced by @code rpc.message.uncompressed_size @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessageUncompressedSize =
     "message.uncompressed_size";
diff --git a/api/include/opentelemetry/semconv/incubating/messaging_attributes.h b/api/include/opentelemetry/semconv/incubating/messaging_attributes.h
index cc06578c3d..486f4d42b5 100644
--- a/api/include/opentelemetry/semconv/incubating/messaging_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/messaging_attributes.h
@@ -39,9 +39,9 @@ static constexpr const char *kMessagingClientId = "messaging.client.id";
 // Excluded attribute:
 /**
  * Deprecated, use @code messaging.client.id @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.client.id @endcode.
+ * {"note": "Replaced by @code messaging.client.id @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED
 static constexpr const char *kMessagingClientId
@@ -107,27 +107,27 @@ static constexpr const char *kMessagingDestinationTemporary = "messaging.destina
 
 /**
  * Deprecated, no replacement at this time.
- * <p>
+ *
  * @deprecated
- * No replacement at this time.
+ * {"note": "No replacement at this time.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessagingDestinationPublishAnonymous =
     "messaging.destination_publish.anonymous";
 
 /**
  * Deprecated, no replacement at this time.
- * <p>
+ *
  * @deprecated
- * No replacement at this time.
+ * {"note": "No replacement at this time.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessagingDestinationPublishName =
     "messaging.destination_publish.name";
 
 /**
  * Deprecated, use @code messaging.consumer.group.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.consumer.group.name @endcode.
+ * {"note": "Replaced by @code messaging.consumer.group.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessagingEventhubsConsumerGroup =
     "messaging.eventhubs.consumer.group";
@@ -165,18 +165,19 @@ static constexpr const char *kMessagingGcpPubsubMessageOrderingKey =
 
 /**
  * Deprecated, use @code messaging.consumer.group.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.consumer.group.name @endcode.
+ * {"note": "Replaced by @code messaging.consumer.group.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessagingKafkaConsumerGroup =
     "messaging.kafka.consumer.group";
 
 /**
  * Deprecated, use @code messaging.destination.partition.id @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.destination.partition.id @endcode.
+ * {"note": "Replaced by @code messaging.destination.partition.id @endcode.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessagingKafkaDestinationPartition =
     "messaging.kafka.destination.partition";
@@ -192,9 +193,9 @@ static constexpr const char *kMessagingKafkaMessageKey = "messaging.kafka.messag
 
 /**
  * Deprecated, use @code messaging.kafka.offset @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.kafka.offset @endcode.
+ * {"note": "Replaced by @code messaging.kafka.offset @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessagingKafkaMessageOffset =
     "messaging.kafka.message.offset";
@@ -238,9 +239,9 @@ static constexpr const char *kMessagingMessageId = "messaging.message.id";
 
 /**
  * Deprecated, use @code messaging.operation.type @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.operation.type @endcode.
+ * {"note": "Replaced by @code messaging.operation.type @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessagingOperation = "messaging.operation";
 
@@ -270,10 +271,10 @@ static constexpr const char *kMessagingRabbitmqMessageDeliveryTag =
 
 /**
  * Deprecated, use @code messaging.consumer.group.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.consumer.group.name @endcode on the consumer spans. No replacement
- * for producer spans.
+ * {"note": "Replaced by @code messaging.consumer.group.name @endcode on the consumer spans. No
+ * replacement for producer spans.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMessagingRocketmqClientGroup =
     "messaging.rocketmq.client_group";
@@ -324,9 +325,10 @@ static constexpr const char *kMessagingRocketmqNamespace = "messaging.rocketmq.n
 
 /**
  * Deprecated, use @code messaging.destination.subscription.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.destination.subscription.name @endcode.
+ * {"note": "Replaced by @code messaging.destination.subscription.name @endcode.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char
     *kMessagingServicebusDestinationSubscriptionName =
@@ -394,19 +396,13 @@ static constexpr const char *kSettle = "settle";
 
 /**
  * Deprecated. Use @code process @endcode instead.
- * <p>
- * @deprecated
- * Replaced by @code process @endcode.
  */
-OPENTELEMETRY_DEPRECATED static constexpr const char *kDeliver = "deliver";
+static constexpr const char *kDeliver = "deliver";
 
 /**
  * Deprecated. Use @code send @endcode instead.
- * <p>
- * @deprecated
- * Replaced by @code send @endcode.
  */
-OPENTELEMETRY_DEPRECATED static constexpr const char *kPublish = "publish";
+static constexpr const char *kPublish = "publish";
 
 }  // namespace MessagingOperationTypeValues
 
diff --git a/api/include/opentelemetry/semconv/incubating/messaging_metrics.h b/api/include/opentelemetry/semconv/incubating/messaging_metrics.h
index 77cb7012c9..91cb19f726 100644
--- a/api/include/opentelemetry/semconv/incubating/messaging_metrics.h
+++ b/api/include/opentelemetry/semconv/incubating/messaging_metrics.h
@@ -97,9 +97,9 @@ CreateSyncDoubleMetricMessagingClientOperationDuration(metrics::Meter *meter)
 
 /**
  * Deprecated. Use @code messaging.client.sent.messages @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.client.sent.messages @endcode.
+ * {"note": "Replaced by @code messaging.client.sent.messages @endcode.", "reason": "uncategorized"}
  * <p>
  * counter
  */
@@ -215,11 +215,10 @@ CreateSyncDoubleMetricMessagingProcessDuration(metrics::Meter *meter)
 
 /**
  * Deprecated. Use @code messaging.client.consumed.messages @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.client.consumed.messages @endcode.
- * <p>
- * counter
+ * {"note": "Replaced by @code messaging.client.consumed.messages @endcode.", "reason":
+ * "uncategorized"} <p> counter
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingProcessMessages =
     "messaging.process.messages";
@@ -262,11 +261,10 @@ CreateAsyncDoubleMetricMessagingProcessMessages(metrics::Meter *meter)
 
 /**
  * Deprecated. Use @code messaging.client.operation.duration @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.client.operation.duration @endcode.
- * <p>
- * histogram
+ * {"note": "Replaced by @code messaging.client.operation.duration @endcode.", "reason":
+ * "uncategorized"} <p> histogram
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingPublishDuration =
     "messaging.publish.duration";
@@ -292,11 +290,10 @@ CreateSyncDoubleMetricMessagingPublishDuration(metrics::Meter *meter)
 
 /**
  * Deprecated. Use @code messaging.client.produced.messages @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.client.produced.messages @endcode.
- * <p>
- * counter
+ * {"note": "Replaced by @code messaging.client.produced.messages @endcode.", "reason":
+ * "uncategorized"} <p> counter
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingPublishMessages =
     "messaging.publish.messages";
@@ -339,11 +336,10 @@ CreateAsyncDoubleMetricMessagingPublishMessages(metrics::Meter *meter)
 
 /**
  * Deprecated. Use @code messaging.client.operation.duration @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.client.operation.duration @endcode.
- * <p>
- * histogram
+ * {"note": "Replaced by @code messaging.client.operation.duration @endcode.", "reason":
+ * "uncategorized"} <p> histogram
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingReceiveDuration =
     "messaging.receive.duration";
@@ -369,11 +365,10 @@ CreateSyncDoubleMetricMessagingReceiveDuration(metrics::Meter *meter)
 
 /**
  * Deprecated. Use @code messaging.client.consumed.messages @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code messaging.client.consumed.messages @endcode.
- * <p>
- * counter
+ * {"note": "Replaced by @code messaging.client.consumed.messages @endcode.", "reason":
+ * "uncategorized"} <p> counter
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingReceiveMessages =
     "messaging.receive.messages";
diff --git a/api/include/opentelemetry/semconv/incubating/net_attributes.h b/api/include/opentelemetry/semconv/incubating/net_attributes.h
index b87a66cd51..ba35616314 100644
--- a/api/include/opentelemetry/semconv/incubating/net_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/net_attributes.h
@@ -21,123 +21,126 @@ namespace net
 
 /**
  * Deprecated, use @code network.local.address @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code network.local.address @endcode.
+ * {"note": "Replaced by @code network.local.address @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetHostIp = "net.host.ip";
 
 /**
  * Deprecated, use @code server.address @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code server.address @endcode.
+ * {"note": "Replaced by @code server.address @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetHostName = "net.host.name";
 
 /**
  * Deprecated, use @code server.port @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code server.port @endcode.
+ * {"note": "Replaced by @code server.port @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetHostPort = "net.host.port";
 
 /**
  * Deprecated, use @code network.peer.address @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code network.peer.address @endcode.
+ * {"note": "Replaced by @code network.peer.address @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetPeerIp = "net.peer.ip";
 
 /**
  * Deprecated, use @code server.address @endcode on client spans and @code client.address @endcode
- * on server spans. <p>
+ * on server spans.
+ *
  * @deprecated
- * Replaced by @code server.address @endcode on client spans and @code client.address @endcode on
- * server spans.
+ * {"note": "Replaced by @code server.address @endcode on client spans and @code client.address
+ * @endcode on server spans.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetPeerName = "net.peer.name";
 
 /**
  * Deprecated, use @code server.port @endcode on client spans and @code client.port @endcode on
- * server spans. <p>
+ * server spans.
+ *
  * @deprecated
- * Replaced by @code server.port @endcode on client spans and @code client.port @endcode on server
- * spans.
+ * {"note": "Replaced by @code server.port @endcode on client spans and @code client.port @endcode
+ * on server spans.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetPeerPort = "net.peer.port";
 
 /**
  * Deprecated, use @code network.protocol.name @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code network.protocol.name @endcode.
+ * {"note": "Replaced by @code network.protocol.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetProtocolName = "net.protocol.name";
 
 /**
  * Deprecated, use @code network.protocol.version @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code network.protocol.version @endcode.
+ * {"note": "Replaced by @code network.protocol.version @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetProtocolVersion = "net.protocol.version";
 
 /**
  * Deprecated, use @code network.transport @endcode and @code network.type @endcode.
- * <p>
+ *
  * @deprecated
- * Split to @code network.transport @endcode and @code network.type @endcode.
+ * {"note": "Split to @code network.transport @endcode and @code network.type @endcode.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetSockFamily = "net.sock.family";
 
 /**
  * Deprecated, use @code network.local.address @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code network.local.address @endcode.
+ * {"note": "Replaced by @code network.local.address @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetSockHostAddr = "net.sock.host.addr";
 
 /**
  * Deprecated, use @code network.local.port @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code network.local.port @endcode.
+ * {"note": "Replaced by @code network.local.port @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetSockHostPort = "net.sock.host.port";
 
 /**
  * Deprecated, use @code network.peer.address @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code network.peer.address @endcode.
+ * {"note": "Replaced by @code network.peer.address @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetSockPeerAddr = "net.sock.peer.addr";
 
 /**
  * Deprecated, no replacement at this time.
- * <p>
+ *
  * @deprecated
- * Removed.
+ * {"note": "Removed.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetSockPeerName = "net.sock.peer.name";
 
 /**
  * Deprecated, use @code network.peer.port @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code network.peer.port @endcode.
+ * {"note": "Replaced by @code network.peer.port @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetSockPeerPort = "net.sock.peer.port";
 
 /**
  * Deprecated, use @code network.transport @endcode.
- * <p>
+ *
  * @deprecated
- * Replaced by @code network.transport @endcode.
+ * {"note": "Replaced by @code network.transport @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kNetTransport = "net.transport";
 
diff --git a/api/include/opentelemetry/semconv/incubating/oci_attributes.h b/api/include/opentelemetry/semconv/incubating/oci_attributes.h
index ade92d35c8..96c87d9dd1 100644
--- a/api/include/opentelemetry/semconv/incubating/oci_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/oci_attributes.h
@@ -26,8 +26,8 @@ namespace oci
  * Specification</a>, and specifically the <a
  * href="https://github.com/opencontainers/image-spec/blob/main/descriptor.md#digests">Digest
  * property</a>. An example can be found in <a
- * href="https://docs.docker.com/registry/spec/manifest-v2-2/#example-image-manifest">Example Image
- * Manifest</a>.
+ * href="https://github.com/opencontainers/image-spec/blob/main/manifest.md#example-image-manifest">Example
+ * Image Manifest</a>.
  */
 static constexpr const char *kOciManifestDigest = "oci.manifest.digest";
 
diff --git a/api/include/opentelemetry/semconv/incubating/otel_attributes.h b/api/include/opentelemetry/semconv/incubating/otel_attributes.h
index a6cf9f50de..8299c2190e 100644
--- a/api/include/opentelemetry/semconv/incubating/otel_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/otel_attributes.h
@@ -20,18 +20,44 @@ namespace otel
 {
 
 /**
- * Deprecated. Use the @code otel.scope.name @endcode attribute
+ * A name uniquely identifying the instance of the OpenTelemetry component within its containing SDK
+ * instance. <p> Implementations SHOULD ensure a low cardinality for this attribute, even across
+ * application or SDK restarts. E.g. implementations MUST NOT use UUIDs as values for this
+ * attribute. <p> Implementations MAY achieve these goals by following a @code
+ * <otel.component.type>/<instance-counter> @endcode pattern, e.g. @code batching_span_processor/0
+ * @endcode. Hereby @code otel.component.type @endcode refers to the corresponding attribute value
+ * of the component. <p> The value of @code instance-counter @endcode MAY be automatically assigned
+ * by the component and uniqueness within the enclosing SDK instance MUST be guaranteed. For
+ * example, @code <instance-counter> @endcode MAY be implemented by using a monotonically increasing
+ * counter (starting with @code 0 @endcode), which is incremented every time an instance of the
+ * given component type is started. <p> With this implementation, for example the first Batching
+ * Span Processor would have @code batching_span_processor/0 @endcode as @code otel.component.name
+ * @endcode, the second one @code batching_span_processor/1 @endcode and so on. These values will
+ * therefore be reused in the case of an application restart.
+ */
+static constexpr const char *kOtelComponentName = "otel.component.name";
+
+/**
+ * A name identifying the type of the OpenTelemetry component.
  * <p>
+ * If none of the standardized values apply, implementations SHOULD use the language-defined name of
+ * the type. E.g. for Java the fully qualified classname SHOULD be used in this case.
+ */
+static constexpr const char *kOtelComponentType = "otel.component.type";
+
+/**
+ * Deprecated. Use the @code otel.scope.name @endcode attribute
+ *
  * @deprecated
- * Use the @code otel.scope.name @endcode attribute.
+ * {"note": "Use the @code otel.scope.name @endcode attribute.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kOtelLibraryName = "otel.library.name";
 
 /**
  * Deprecated. Use the @code otel.scope.version @endcode attribute.
- * <p>
+ *
  * @deprecated
- * Use the @code otel.scope.version @endcode attribute.
+ * {"note": "Use the @code otel.scope.version @endcode attribute.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kOtelLibraryVersion = "otel.library.version";
 
@@ -45,6 +71,11 @@ static constexpr const char *kOtelScopeName = "otel.scope.name";
  */
 static constexpr const char *kOtelScopeVersion = "otel.scope.version";
 
+/**
+ * The result value of the sampler for this span
+ */
+static constexpr const char *kOtelSpanSamplingResult = "otel.span.sampling_result";
+
 /**
  * Name of the code, either "OK" or "ERROR". MUST NOT be set if the status code is UNSET.
  */
@@ -55,6 +86,54 @@ static constexpr const char *kOtelStatusCode = "otel.status_code";
  */
 static constexpr const char *kOtelStatusDescription = "otel.status_description";
 
+namespace OtelComponentTypeValues
+{
+/**
+ * The builtin SDK Batching Span Processor
+ */
+static constexpr const char *kBatchingSpanProcessor = "batching_span_processor";
+
+/**
+ * The builtin SDK Simple Span Processor
+ */
+static constexpr const char *kSimpleSpanProcessor = "simple_span_processor";
+
+/**
+ * OTLP span exporter over gRPC with protobuf serialization
+ */
+static constexpr const char *kOtlpGrpcSpanExporter = "otlp_grpc_span_exporter";
+
+/**
+ * OTLP span exporter over HTTP with protobuf serialization
+ */
+static constexpr const char *kOtlpHttpSpanExporter = "otlp_http_span_exporter";
+
+/**
+ * OTLP span exporter over HTTP with JSON serialization
+ */
+static constexpr const char *kOtlpHttpJsonSpanExporter = "otlp_http_json_span_exporter";
+
+}  // namespace OtelComponentTypeValues
+
+namespace OtelSpanSamplingResultValues
+{
+/**
+ * The span is not sampled and not recording
+ */
+static constexpr const char *kDrop = "DROP";
+
+/**
+ * The span is not sampled, but recording
+ */
+static constexpr const char *kRecordOnly = "RECORD_ONLY";
+
+/**
+ * The span is sampled and recording
+ */
+static constexpr const char *kRecordAndSample = "RECORD_AND_SAMPLE";
+
+}  // namespace OtelSpanSamplingResultValues
+
 namespace OtelStatusCodeValues
 {
 /**
diff --git a/api/include/opentelemetry/semconv/incubating/otel_metrics.h b/api/include/opentelemetry/semconv/incubating/otel_metrics.h
new file mode 100644
index 0000000000..0308a324b0
--- /dev/null
+++ b/api/include/opentelemetry/semconv/incubating/otel_metrics.h
@@ -0,0 +1,337 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace otel
+{
+
+/**
+ * The number of spans for which the export has finished, either successful or failed
+ * <p>
+ * For successful exports, @code error.type @endcode MUST NOT be set. For failed exports, @code
+ * error.type @endcode must contain the failure cause. For exporters with partial success semantics
+ * (e.g. OTLP with @code rejected_spans @endcode), rejected spans must count as failed and only
+ * non-rejected spans count as success. If no rejection reason is available, @code rejected @endcode
+ * SHOULD be used as value for @code error.type @endcode. <p> counter
+ */
+static constexpr const char *kMetricOtelSdkExporterSpanExportedCount =
+    "otel.sdk.exporter.span.exported.count";
+static constexpr const char *descrMetricOtelSdkExporterSpanExportedCount =
+    "The number of spans for which the export has finished, either successful or failed";
+static constexpr const char *unitMetricOtelSdkExporterSpanExportedCount = "{span}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricOtelSdkExporterSpanExportedCount,
+                                    descrMetricOtelSdkExporterSpanExportedCount,
+                                    unitMetricOtelSdkExporterSpanExportedCount);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricOtelSdkExporterSpanExportedCount,
+                                    descrMetricOtelSdkExporterSpanExportedCount,
+                                    unitMetricOtelSdkExporterSpanExportedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricOtelSdkExporterSpanExportedCount,
+                                             descrMetricOtelSdkExporterSpanExportedCount,
+                                             unitMetricOtelSdkExporterSpanExportedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricOtelSdkExporterSpanExportedCount,
+                                              descrMetricOtelSdkExporterSpanExportedCount,
+                                              unitMetricOtelSdkExporterSpanExportedCount);
+}
+
+/**
+ * The number of spans which were passed to the exporter, but that have not been exported yet
+ * (neither successful, nor failed) <p> For successful exports, @code error.type @endcode MUST NOT
+ * be set. For failed exports, @code error.type @endcode must contain the failure cause. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricOtelSdkExporterSpanInflightCount =
+    "otel.sdk.exporter.span.inflight.count";
+static constexpr const char *descrMetricOtelSdkExporterSpanInflightCount =
+    "The number of spans which were passed to the exporter, but that have not been exported yet "
+    "(neither successful, nor failed)";
+static constexpr const char *unitMetricOtelSdkExporterSpanInflightCount = "{span}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
+                                         descrMetricOtelSdkExporterSpanInflightCount,
+                                         unitMetricOtelSdkExporterSpanInflightCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
+                                          descrMetricOtelSdkExporterSpanInflightCount,
+                                          unitMetricOtelSdkExporterSpanInflightCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
+                                                   descrMetricOtelSdkExporterSpanInflightCount,
+                                                   unitMetricOtelSdkExporterSpanInflightCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
+                                                    descrMetricOtelSdkExporterSpanInflightCount,
+                                                    unitMetricOtelSdkExporterSpanInflightCount);
+}
+
+/**
+ * The number of spans for which the processing has finished, either successful or failed
+ * <p>
+ * For successful processing, @code error.type @endcode MUST NOT be set. For failed processing,
+ * @code error.type @endcode must contain the failure cause. For the SDK Simple and Batching Span
+ * Processor a span is considered to be processed already when it has been submitted to the
+ * exporter, not when the corresponding export call has finished. <p> counter
+ */
+static constexpr const char *kMetricOtelSdkProcessorSpanProcessedCount =
+    "otel.sdk.processor.span.processed.count";
+static constexpr const char *descrMetricOtelSdkProcessorSpanProcessedCount =
+    "The number of spans for which the processing has finished, either successful or failed";
+static constexpr const char *unitMetricOtelSdkProcessorSpanProcessedCount = "{span}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricOtelSdkProcessorSpanProcessedCount,
+                                    descrMetricOtelSdkProcessorSpanProcessedCount,
+                                    unitMetricOtelSdkProcessorSpanProcessedCount);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricOtelSdkProcessorSpanProcessedCount,
+                                    descrMetricOtelSdkProcessorSpanProcessedCount,
+                                    unitMetricOtelSdkProcessorSpanProcessedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricOtelSdkProcessorSpanProcessedCount,
+                                             descrMetricOtelSdkProcessorSpanProcessedCount,
+                                             unitMetricOtelSdkProcessorSpanProcessedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricOtelSdkProcessorSpanProcessedCount,
+                                              descrMetricOtelSdkProcessorSpanProcessedCount,
+                                              unitMetricOtelSdkProcessorSpanProcessedCount);
+}
+
+/**
+ * The maximum number of spans the queue of a given instance of an SDK span processor can hold
+ * <p>
+ * Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricOtelSdkProcessorSpanQueueCapacity =
+    "otel.sdk.processor.span.queue.capacity";
+static constexpr const char *descrMetricOtelSdkProcessorSpanQueueCapacity =
+    "The maximum number of spans the queue of a given instance of an SDK span processor can hold";
+static constexpr const char *unitMetricOtelSdkProcessorSpanQueueCapacity = "{span}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
+                                         descrMetricOtelSdkProcessorSpanQueueCapacity,
+                                         unitMetricOtelSdkProcessorSpanQueueCapacity);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
+                                          descrMetricOtelSdkProcessorSpanQueueCapacity,
+                                          unitMetricOtelSdkProcessorSpanQueueCapacity);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
+                                                   descrMetricOtelSdkProcessorSpanQueueCapacity,
+                                                   unitMetricOtelSdkProcessorSpanQueueCapacity);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
+                                                    descrMetricOtelSdkProcessorSpanQueueCapacity,
+                                                    unitMetricOtelSdkProcessorSpanQueueCapacity);
+}
+
+/**
+ * The number of spans in the queue of a given instance of an SDK span processor
+ * <p>
+ * Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricOtelSdkProcessorSpanQueueSize =
+    "otel.sdk.processor.span.queue.size";
+static constexpr const char *descrMetricOtelSdkProcessorSpanQueueSize =
+    "The number of spans in the queue of a given instance of an SDK span processor";
+static constexpr const char *unitMetricOtelSdkProcessorSpanQueueSize = "{span}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
+                                         descrMetricOtelSdkProcessorSpanQueueSize,
+                                         unitMetricOtelSdkProcessorSpanQueueSize);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
+                                          descrMetricOtelSdkProcessorSpanQueueSize,
+                                          unitMetricOtelSdkProcessorSpanQueueSize);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
+                                                   descrMetricOtelSdkProcessorSpanQueueSize,
+                                                   unitMetricOtelSdkProcessorSpanQueueSize);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
+                                                    descrMetricOtelSdkProcessorSpanQueueSize,
+                                                    unitMetricOtelSdkProcessorSpanQueueSize);
+}
+
+/**
+ * The number of created spans for which the end operation was called
+ * <p>
+ * For spans with @code recording=true @endcode: Implementations MUST record both @code
+ * otel.sdk.span.live.count @endcode and @code otel.sdk.span.ended.count @endcode. For spans with
+ * @code recording=false @endcode: If implementations decide to record this metric, they MUST also
+ * record @code otel.sdk.span.live.count @endcode. <p> counter
+ */
+static constexpr const char *kMetricOtelSdkSpanEndedCount = "otel.sdk.span.ended.count";
+static constexpr const char *descrMetricOtelSdkSpanEndedCount =
+    "The number of created spans for which the end operation was called";
+static constexpr const char *unitMetricOtelSdkSpanEndedCount = "{span}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricOtelSdkSpanEndedCount(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricOtelSdkSpanEndedCount, descrMetricOtelSdkSpanEndedCount,
+                                    unitMetricOtelSdkSpanEndedCount);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricOtelSdkSpanEndedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricOtelSdkSpanEndedCount, descrMetricOtelSdkSpanEndedCount,
+                                    unitMetricOtelSdkSpanEndedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkSpanEndedCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricOtelSdkSpanEndedCount,
+                                             descrMetricOtelSdkSpanEndedCount,
+                                             unitMetricOtelSdkSpanEndedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkSpanEndedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricOtelSdkSpanEndedCount,
+                                              descrMetricOtelSdkSpanEndedCount,
+                                              unitMetricOtelSdkSpanEndedCount);
+}
+
+/**
+ * The number of created spans for which the end operation has not been called yet
+ * <p>
+ * For spans with @code recording=true @endcode: Implementations MUST record both @code
+ * otel.sdk.span.live.count @endcode and @code otel.sdk.span.ended.count @endcode. For spans with
+ * @code recording=false @endcode: If implementations decide to record this metric, they MUST also
+ * record @code otel.sdk.span.ended.count @endcode. <p> updowncounter
+ */
+static constexpr const char *kMetricOtelSdkSpanLiveCount = "otel.sdk.span.live.count";
+static constexpr const char *descrMetricOtelSdkSpanLiveCount =
+    "The number of created spans for which the end operation has not been called yet";
+static constexpr const char *unitMetricOtelSdkSpanLiveCount = "{span}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricOtelSdkSpanLiveCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(
+      kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricOtelSdkSpanLiveCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(
+      kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkSpanLiveCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkSpanLiveCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
+}
+
+}  // namespace otel
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/incubating/other_attributes.h b/api/include/opentelemetry/semconv/incubating/other_attributes.h
index 0587c0a6d6..1a757f7eda 100644
--- a/api/include/opentelemetry/semconv/incubating/other_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/other_attributes.h
@@ -21,9 +21,9 @@ namespace other
 
 /**
  * Deprecated, use @code db.client.connection.state @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.client.connection.state @endcode.
+ * {"note": "Replaced by @code db.client.connection.state @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kState = "state";
 
diff --git a/api/include/opentelemetry/semconv/incubating/pool_attributes.h b/api/include/opentelemetry/semconv/incubating/pool_attributes.h
index 3554e600b9..fecd19fd8e 100644
--- a/api/include/opentelemetry/semconv/incubating/pool_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/pool_attributes.h
@@ -21,9 +21,9 @@ namespace pool
 
 /**
  * Deprecated, use @code db.client.connection.pool.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code db.client.connection.pool.name @endcode.
+ * {"note": "Replaced by @code db.client.connection.pool.name @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kPoolName = "pool.name";
 
diff --git a/api/include/opentelemetry/semconv/incubating/process_attributes.h b/api/include/opentelemetry/semconv/incubating/process_attributes.h
index 09bbacbd3d..8cad737f78 100644
--- a/api/include/opentelemetry/semconv/incubating/process_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/process_attributes.h
@@ -56,9 +56,9 @@ static constexpr const char *kProcessContextSwitchType = "process.context_switch
 
 /**
  * Deprecated, use @code cpu.mode @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code cpu.mode @endcode
+ * {"note": "Replaced by @code cpu.mode @endcode", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kProcessCpuState = "process.cpu.state";
 
@@ -86,17 +86,18 @@ static constexpr const char *kProcessExecutableBuildIdHtlhash =
 
 /**
  * "Deprecated, use @code process.executable.build_id.htlhash @endcode instead."
- * <p>
+ *
  * @deprecated
- * Replaced by @code process.executable.build_id.htlhash @endcode
+ * {"note": "Replaced by @code process.executable.build_id.htlhash @endcode", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kProcessExecutableBuildIdProfiling =
     "process.executable.build_id.profiling";
 
 /**
- * The name of the process executable. On Linux based systems, can be set to the @code Name @endcode
- * in @code proc/[pid]/status @endcode. On Windows, can be set to the base name of @code
- * GetProcessImageFileNameW @endcode.
+ * The name of the process executable. On Linux based systems, this SHOULD be set to the base name
+ * of the target of @code /proc/[pid]/exe @endcode. On Windows, this SHOULD be set to the base name
+ * of @code GetProcessImageFileNameW @endcode.
  */
 static constexpr const char *kProcessExecutableName = "process.executable.name";
 
diff --git a/api/include/opentelemetry/semconv/incubating/process_metrics.h b/api/include/opentelemetry/semconv/incubating/process_metrics.h
index f9502779a0..d76db55c9e 100644
--- a/api/include/opentelemetry/semconv/incubating/process_metrics.h
+++ b/api/include/opentelemetry/semconv/incubating/process_metrics.h
@@ -28,7 +28,7 @@ namespace process
 static constexpr const char *kMetricProcessContextSwitches = "process.context_switches";
 static constexpr const char *descrMetricProcessContextSwitches =
     "Number of times the process has been context switched.";
-static constexpr const char *unitMetricProcessContextSwitches = "{count}";
+static constexpr const char *unitMetricProcessContextSwitches = "{context_switch}";
 
 static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
 CreateSyncInt64MetricProcessContextSwitches(metrics::Meter *meter)
@@ -302,7 +302,7 @@ static constexpr const char *kMetricProcessOpenFileDescriptorCount =
     "process.open_file_descriptor.count";
 static constexpr const char *descrMetricProcessOpenFileDescriptorCount =
     "Number of file descriptors in use by the process.";
-static constexpr const char *unitMetricProcessOpenFileDescriptorCount = "{count}";
+static constexpr const char *unitMetricProcessOpenFileDescriptorCount = "{file_descriptor}";
 
 static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
 CreateSyncInt64MetricProcessOpenFileDescriptorCount(metrics::Meter *meter)
diff --git a/api/include/opentelemetry/semconv/incubating/rpc_attributes.h b/api/include/opentelemetry/semconv/incubating/rpc_attributes.h
index 784ab70ce6..ca3a80e3e0 100644
--- a/api/include/opentelemetry/semconv/incubating/rpc_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/rpc_attributes.h
@@ -20,7 +20,7 @@ namespace rpc
 {
 
 /**
- * The <a href="https://connect.build/docs/protocol/#error-codes">error codes</a> of the Connect
+ * The <a href="https://connectrpc.com//docs/protocol/#error-codes">error codes</a> of the Connect
  * request. Error codes are always string values.
  */
 static constexpr const char *kRpcConnectRpcErrorCode = "rpc.connect_rpc.error_code";
diff --git a/api/include/opentelemetry/semconv/incubating/system_attributes.h b/api/include/opentelemetry/semconv/incubating/system_attributes.h
index ae468ac201..d005ffb3b6 100644
--- a/api/include/opentelemetry/semconv/incubating/system_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/system_attributes.h
@@ -20,15 +20,15 @@ namespace system
 {
 
 /**
- * The logical CPU number [0..n-1]
+ * Deprecated, use @code cpu.logical_number @endcode instead.
  */
 static constexpr const char *kSystemCpuLogicalNumber = "system.cpu.logical_number";
 
 /**
  * Deprecated, use @code cpu.mode @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code cpu.mode @endcode
+ * {"note": "Replaced by @code cpu.mode @endcode", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kSystemCpuState = "system.cpu.state";
 
@@ -64,9 +64,10 @@ static constexpr const char *kSystemMemoryState = "system.memory.state";
 
 /**
  * Deprecated, use @code network.connection.state @endcode instead.
- * <p>
+ *
  * @deprecated
- * Removed, report network connection state with @code network.connection.state @endcode attribute
+ * {"note": "Removed, report network connection state with @code network.connection.state @endcode
+ * attribute", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kSystemNetworkState = "system.network.state";
 
@@ -94,9 +95,9 @@ static constexpr const char *kSystemProcessStatus = "system.process.status";
 
 /**
  * Deprecated, use @code system.process.status @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code system.process.status @endcode.
+ * {"note": "Replaced by @code system.process.status @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kSystemProcessesStatus =
     "system.processes.status";
@@ -207,11 +208,8 @@ static constexpr const char *kFree = "free";
 
 /**
  * none
- * <p>
- * @deprecated
- * Removed, report shared memory usage with @code metric.system.memory.shared @endcode metric
  */
-OPENTELEMETRY_DEPRECATED static constexpr const char *kShared = "shared";
+static constexpr const char *kShared = "shared";
 
 /**
  * none
diff --git a/api/include/opentelemetry/semconv/incubating/system_metrics.h b/api/include/opentelemetry/semconv/incubating/system_metrics.h
index ba787a86d0..a985dac901 100644
--- a/api/include/opentelemetry/semconv/incubating/system_metrics.h
+++ b/api/include/opentelemetry/semconv/incubating/system_metrics.h
@@ -21,40 +21,44 @@ namespace system
 {
 
 /**
- * Reports the current frequency of the CPU in Hz
+ * Deprecated. Use @code cpu.frequency @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code cpu.frequency @endcode.", "reason": "uncategorized"}
  * <p>
  * gauge
  */
-static constexpr const char *kMetricSystemCpuFrequency = "system.cpu.frequency";
-static constexpr const char *descrMetricSystemCpuFrequency =
-    "Reports the current frequency of the CPU in Hz";
-static constexpr const char *unitMetricSystemCpuFrequency = "{Hz}";
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricSystemCpuFrequency =
+    "system.cpu.frequency";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricSystemCpuFrequency =
+    "Deprecated. Use `cpu.frequency` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricSystemCpuFrequency = "{Hz}";
 
 #if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
-static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricSystemCpuFrequency(
-    metrics::Meter *meter)
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
+CreateSyncInt64MetricSystemCpuFrequency(metrics::Meter *meter)
 {
   return meter->CreateInt64Gauge(kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency,
                                  unitMetricSystemCpuFrequency);
 }
 
-static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricSystemCpuFrequency(
-    metrics::Meter *meter)
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Gauge<double>>
+CreateSyncDoubleMetricSystemCpuFrequency(metrics::Meter *meter)
 {
   return meter->CreateDoubleGauge(kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency,
                                   unitMetricSystemCpuFrequency);
 }
 #endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
-static inline nostd::shared_ptr<metrics::ObservableInstrument>
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
 CreateAsyncInt64MetricSystemCpuFrequency(metrics::Meter *meter)
 {
   return meter->CreateInt64ObservableGauge(kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency,
                                            unitMetricSystemCpuFrequency);
 }
 
-static inline nostd::shared_ptr<metrics::ObservableInstrument>
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
 CreateAsyncDoubleMetricSystemCpuFrequency(metrics::Meter *meter)
 {
   return meter->CreateDoubleObservableGauge(
@@ -149,78 +153,85 @@ CreateAsyncDoubleMetricSystemCpuPhysicalCount(metrics::Meter *meter)
 }
 
 /**
- * Seconds each logical CPU spent on each mode
+ * Deprecated. Use @code cpu.time @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code cpu.time @endcode.", "reason": "uncategorized"}
  * <p>
  * counter
  */
-static constexpr const char *kMetricSystemCpuTime = "system.cpu.time";
-static constexpr const char *descrMetricSystemCpuTime =
-    "Seconds each logical CPU spent on each mode";
-static constexpr const char *unitMetricSystemCpuTime = "s";
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricSystemCpuTime = "system.cpu.time";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricSystemCpuTime =
+    "Deprecated. Use `cpu.time` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricSystemCpuTime = "s";
 
-static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemCpuTime(
-    metrics::Meter *meter)
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricSystemCpuTime(metrics::Meter *meter)
 {
   return meter->CreateUInt64Counter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
                                     unitMetricSystemCpuTime);
 }
 
-static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemCpuTime(
-    metrics::Meter *meter)
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricSystemCpuTime(metrics::Meter *meter)
 {
   return meter->CreateDoubleCounter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
                                     unitMetricSystemCpuTime);
 }
 
-static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricSystemCpuTime(
-    metrics::Meter *meter)
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemCpuTime(metrics::Meter *meter)
 {
   return meter->CreateInt64ObservableCounter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
                                              unitMetricSystemCpuTime);
 }
 
-static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricSystemCpuTime(
-    metrics::Meter *meter)
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemCpuTime(metrics::Meter *meter)
 {
   return meter->CreateDoubleObservableCounter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
                                               unitMetricSystemCpuTime);
 }
 
 /**
- * Difference in system.cpu.time since the last measurement, divided by the elapsed time and number
- * of logical CPUs <p> gauge
+ * Deprecated. Use @code cpu.utilization @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code cpu.utilization @endcode.", "reason": "uncategorized"}
+ * <p>
+ * gauge
  */
-static constexpr const char *kMetricSystemCpuUtilization = "system.cpu.utilization";
-static constexpr const char *descrMetricSystemCpuUtilization =
-    "Difference in system.cpu.time since the last measurement, divided by the elapsed time and "
-    "number of logical CPUs";
-static constexpr const char *unitMetricSystemCpuUtilization = "1";
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricSystemCpuUtilization =
+    "system.cpu.utilization";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricSystemCpuUtilization =
+    "Deprecated. Use `cpu.utilization` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricSystemCpuUtilization = "1";
 
 #if OPENTELEMETRY_ABI_VERSION_NO >= 2
 
-static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricSystemCpuUtilization(
-    metrics::Meter *meter)
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
+CreateSyncInt64MetricSystemCpuUtilization(metrics::Meter *meter)
 {
   return meter->CreateInt64Gauge(kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization,
                                  unitMetricSystemCpuUtilization);
 }
 
-static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricSystemCpuUtilization(
-    metrics::Meter *meter)
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Gauge<double>>
+CreateSyncDoubleMetricSystemCpuUtilization(metrics::Meter *meter)
 {
   return meter->CreateDoubleGauge(kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization,
                                   unitMetricSystemCpuUtilization);
 }
 #endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
-static inline nostd::shared_ptr<metrics::ObservableInstrument>
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
 CreateAsyncInt64MetricSystemCpuUtilization(metrics::Meter *meter)
 {
   return meter->CreateInt64ObservableGauge(
       kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization, unitMetricSystemCpuUtilization);
 }
 
-static inline nostd::shared_ptr<metrics::ObservableInstrument>
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
 CreateAsyncDoubleMetricSystemCpuUtilization(metrics::Meter *meter)
 {
   return meter->CreateDoubleObservableGauge(
diff --git a/api/include/opentelemetry/semconv/incubating/tls_attributes.h b/api/include/opentelemetry/semconv/incubating/tls_attributes.h
index d399f56ef2..da7ed78b99 100644
--- a/api/include/opentelemetry/semconv/incubating/tls_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/tls_attributes.h
@@ -87,9 +87,9 @@ static constexpr const char *kTlsClientNotBefore = "tls.client.not_before";
 
 /**
  * Deprecated, use @code server.address @endcode instead.
- * <p>
+ *
  * @deprecated
- * Replaced by @code server.address @endcode.
+ * {"note": "Replaced by @code server.address @endcode.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kTlsClientServerName =
     "tls.client.server_name";
@@ -124,15 +124,15 @@ static constexpr const char *kTlsNextProtocol = "tls.next_protocol";
 
 /**
  * Normalized lowercase protocol name parsed from original string of the negotiated <a
- * href="https://www.openssl.org/docs/man1.1.1/man3/SSL_get_version.html#RETURN-VALUES">SSL/TLS
- * protocol version</a>
+ * href="https://docs.openssl.org/1.1.1/man3/SSL_get_version/#return-values">SSL/TLS protocol
+ * version</a>
  */
 static constexpr const char *kTlsProtocolName = "tls.protocol.name";
 
 /**
  * Numeric part of the version parsed from the original string of the negotiated <a
- * href="https://www.openssl.org/docs/man1.1.1/man3/SSL_get_version.html#RETURN-VALUES">SSL/TLS
- * protocol version</a>
+ * href="https://docs.openssl.org/1.1.1/man3/SSL_get_version/#return-values">SSL/TLS protocol
+ * version</a>
  */
 static constexpr const char *kTlsProtocolVersion = "tls.protocol.version";
 
diff --git a/api/include/opentelemetry/semconv/incubating/url_attributes.h b/api/include/opentelemetry/semconv/incubating/url_attributes.h
index 96ea78cfe9..2646de430d 100644
--- a/api/include/opentelemetry/semconv/incubating/url_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/url_attributes.h
@@ -131,7 +131,7 @@ static constexpr const char *kUrlQuery = "url.query";
 /**
  * The highest registered url domain, stripped of the subdomain.
  * <p>
- * This value can be determined precisely with the <a href="http://publicsuffix.org">public suffix
+ * This value can be determined precisely with the <a href="https://publicsuffix.org/">public suffix
  * list</a>. For example, the registered domain for @code foo.example.com @endcode is @code
  * example.com @endcode. Trying to approximate this by simply taking the last two labels will not
  * work well for TLDs such as @code co.uk @endcode.
@@ -163,7 +163,7 @@ static constexpr const char *kUrlTemplate = "url.template";
 /**
  * The effective top level domain (eTLD), also known as the domain suffix, is the last part of the
  * domain name. For example, the top level domain for example.com is @code com @endcode. <p> This
- * value can be determined precisely with the <a href="http://publicsuffix.org">public suffix
+ * value can be determined precisely with the <a href="https://publicsuffix.org/">public suffix
  * list</a>.
  */
 static constexpr const char *kUrlTopLevelDomain = "url.top_level_domain";
diff --git a/api/include/opentelemetry/semconv/incubating/user_agent_attributes.h b/api/include/opentelemetry/semconv/incubating/user_agent_attributes.h
index 1ebffd13ec..2eb01ffc6b 100644
--- a/api/include/opentelemetry/semconv/incubating/user_agent_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/user_agent_attributes.h
@@ -35,6 +35,22 @@ static constexpr const char *kUserAgentName = "user_agent.name";
  */
 static constexpr const char *kUserAgentOriginal = "user_agent.original";
 
+/**
+ * Human readable operating system name.
+ * <p>
+ * For mapping user agent strings to OS names, libraries such as <a
+ * href="https://github.com/ua-parser">ua-parser</a> can be utilized.
+ */
+static constexpr const char *kUserAgentOsName = "user_agent.os.name";
+
+/**
+ * The version string of the operating system as defined in <a
+ * href="/docs/resource/README.md#version-attributes">Version Attributes</a>. <p> For mapping user
+ * agent strings to OS versions, libraries such as <a
+ * href="https://github.com/ua-parser">ua-parser</a> can be utilized.
+ */
+static constexpr const char *kUserAgentOsVersion = "user_agent.os.version";
+
 /**
  * Specifies the category of synthetic traffic, such as tests or bots.
  * <p>
diff --git a/api/include/opentelemetry/semconv/incubating/vcs_attributes.h b/api/include/opentelemetry/semconv/incubating/vcs_attributes.h
index 6906fec5e3..858479931a 100644
--- a/api/include/opentelemetry/semconv/incubating/vcs_attributes.h
+++ b/api/include/opentelemetry/semconv/incubating/vcs_attributes.h
@@ -120,18 +120,18 @@ static constexpr const char *kVcsRefType = "vcs.ref.type";
 
 /**
  * Deprecated, use @code vcs.change.id @endcode instead.
- * <p>
+ *
  * @deprecated
- * Deprecated, use @code vcs.change.id @endcode instead.
+ * {"note": "Deprecated, use @code vcs.change.id @endcode instead.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kVcsRepositoryChangeId =
     "vcs.repository.change.id";
 
 /**
  * Deprecated, use @code vcs.change.title @endcode instead.
- * <p>
+ *
  * @deprecated
- * Deprecated, use @code vcs.change.title @endcode instead.
+ * {"note": "Deprecated, use @code vcs.change.title @endcode instead.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kVcsRepositoryChangeTitle =
     "vcs.repository.change.title";
@@ -146,27 +146,28 @@ static constexpr const char *kVcsRepositoryName = "vcs.repository.name";
 
 /**
  * Deprecated, use @code vcs.ref.head.name @endcode instead.
- * <p>
+ *
  * @deprecated
- * Deprecated, use @code vcs.ref.head.name @endcode instead.
+ * {"note": "Deprecated, use @code vcs.ref.head.name @endcode instead.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kVcsRepositoryRefName =
     "vcs.repository.ref.name";
 
 /**
  * Deprecated, use @code vcs.ref.head.revision @endcode instead.
- * <p>
+ *
  * @deprecated
- * Deprecated, use @code vcs.ref.head.revision @endcode instead.
+ * {"note": "Deprecated, use @code vcs.ref.head.revision @endcode instead.", "reason":
+ * "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kVcsRepositoryRefRevision =
     "vcs.repository.ref.revision";
 
 /**
  * Deprecated, use @code vcs.ref.head.type @endcode instead.
- * <p>
+ *
  * @deprecated
- * Deprecated, use @code vcs.ref.head.type @endcode instead.
+ * {"note": "Deprecated, use @code vcs.ref.head.type @endcode instead.", "reason": "uncategorized"}
  */
 OPENTELEMETRY_DEPRECATED static constexpr const char *kVcsRepositoryRefType =
     "vcs.repository.ref.type";
diff --git a/api/include/opentelemetry/semconv/k8s_metrics.h b/api/include/opentelemetry/semconv/k8s_metrics.h
new file mode 100644
index 0000000000..0c2a18ea20
--- /dev/null
+++ b/api/include/opentelemetry/semconv/k8s_metrics.h
@@ -0,0 +1,1735 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace k8s
+{
+
+/**
+ * The number of actively running jobs for a cronjob
+ * <p>
+ * This metric aligns with the @code active @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#cronjobstatus-v1-batch">K8s
+ * CronJobStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#cronjob">@code k8s.cronjob @endcode</a> resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sCronjobActiveJobs = "k8s.cronjob.active_jobs";
+static constexpr const char *descrMetricK8sCronjobActiveJobs =
+    "The number of actively running jobs for a cronjob";
+static constexpr const char *unitMetricK8sCronjobActiveJobs = "{job}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sCronjobActiveJobs(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(
+      kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sCronjobActiveJobs(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(
+      kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sCronjobActiveJobs(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sCronjobActiveJobs(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricK8sCronjobActiveJobs, descrMetricK8sCronjobActiveJobs, unitMetricK8sCronjobActiveJobs);
+}
+
+/**
+ * Number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod
+ * <p>
+ * This metric aligns with the @code currentNumberScheduled @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps">K8s
+ * DaemonSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#daemonset">@code k8s.daemonset @endcode</a> resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sDaemonsetCurrentScheduledNodes =
+    "k8s.daemonset.current_scheduled_nodes";
+static constexpr const char *descrMetricK8sDaemonsetCurrentScheduledNodes =
+    "Number of nodes that are running at least 1 daemon pod and are supposed to run the daemon pod";
+static constexpr const char *unitMetricK8sDaemonsetCurrentScheduledNodes = "{node}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes,
+                                         descrMetricK8sDaemonsetCurrentScheduledNodes,
+                                         unitMetricK8sDaemonsetCurrentScheduledNodes);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes,
+                                          descrMetricK8sDaemonsetCurrentScheduledNodes,
+                                          unitMetricK8sDaemonsetCurrentScheduledNodes);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes,
+                                                   descrMetricK8sDaemonsetCurrentScheduledNodes,
+                                                   unitMetricK8sDaemonsetCurrentScheduledNodes);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sDaemonsetCurrentScheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetCurrentScheduledNodes,
+                                                    descrMetricK8sDaemonsetCurrentScheduledNodes,
+                                                    unitMetricK8sDaemonsetCurrentScheduledNodes);
+}
+
+/**
+ * Number of nodes that should be running the daemon pod (including nodes currently running the
+ * daemon pod) <p> This metric aligns with the @code desiredNumberScheduled @endcode field of the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps">K8s
+ * DaemonSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#daemonset">@code k8s.daemonset @endcode</a> resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sDaemonsetDesiredScheduledNodes =
+    "k8s.daemonset.desired_scheduled_nodes";
+static constexpr const char *descrMetricK8sDaemonsetDesiredScheduledNodes =
+    "Number of nodes that should be running the daemon pod (including nodes currently running the "
+    "daemon pod)";
+static constexpr const char *unitMetricK8sDaemonsetDesiredScheduledNodes = "{node}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes,
+                                         descrMetricK8sDaemonsetDesiredScheduledNodes,
+                                         unitMetricK8sDaemonsetDesiredScheduledNodes);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes,
+                                          descrMetricK8sDaemonsetDesiredScheduledNodes,
+                                          unitMetricK8sDaemonsetDesiredScheduledNodes);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes,
+                                                   descrMetricK8sDaemonsetDesiredScheduledNodes,
+                                                   unitMetricK8sDaemonsetDesiredScheduledNodes);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sDaemonsetDesiredScheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetDesiredScheduledNodes,
+                                                    descrMetricK8sDaemonsetDesiredScheduledNodes,
+                                                    unitMetricK8sDaemonsetDesiredScheduledNodes);
+}
+
+/**
+ * Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod
+ * <p>
+ * This metric aligns with the @code numberMisscheduled @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps">K8s
+ * DaemonSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#daemonset">@code k8s.daemonset @endcode</a> resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sDaemonsetMisscheduledNodes =
+    "k8s.daemonset.misscheduled_nodes";
+static constexpr const char *descrMetricK8sDaemonsetMisscheduledNodes =
+    "Number of nodes that are running the daemon pod, but are not supposed to run the daemon pod";
+static constexpr const char *unitMetricK8sDaemonsetMisscheduledNodes = "{node}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetMisscheduledNodes,
+                                         descrMetricK8sDaemonsetMisscheduledNodes,
+                                         unitMetricK8sDaemonsetMisscheduledNodes);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetMisscheduledNodes,
+                                          descrMetricK8sDaemonsetMisscheduledNodes,
+                                          unitMetricK8sDaemonsetMisscheduledNodes);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetMisscheduledNodes,
+                                                   descrMetricK8sDaemonsetMisscheduledNodes,
+                                                   unitMetricK8sDaemonsetMisscheduledNodes);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sDaemonsetMisscheduledNodes(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetMisscheduledNodes,
+                                                    descrMetricK8sDaemonsetMisscheduledNodes,
+                                                    unitMetricK8sDaemonsetMisscheduledNodes);
+}
+
+/**
+ * Number of nodes that should be running the daemon pod and have one or more of the daemon pod
+ * running and ready <p> This metric aligns with the @code numberReady @endcode field of the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#daemonsetstatus-v1-apps">K8s
+ * DaemonSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#daemonset">@code k8s.daemonset @endcode</a> resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sDaemonsetReadyNodes = "k8s.daemonset.ready_nodes";
+static constexpr const char *descrMetricK8sDaemonsetReadyNodes =
+    "Number of nodes that should be running the daemon pod and have one or more of the daemon pod "
+    "running and ready";
+static constexpr const char *unitMetricK8sDaemonsetReadyNodes = "{node}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sDaemonsetReadyNodes(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sDaemonsetReadyNodes,
+                                         descrMetricK8sDaemonsetReadyNodes,
+                                         unitMetricK8sDaemonsetReadyNodes);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sDaemonsetReadyNodes(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sDaemonsetReadyNodes,
+                                          descrMetricK8sDaemonsetReadyNodes,
+                                          unitMetricK8sDaemonsetReadyNodes);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sDaemonsetReadyNodes(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDaemonsetReadyNodes,
+                                                   descrMetricK8sDaemonsetReadyNodes,
+                                                   unitMetricK8sDaemonsetReadyNodes);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sDaemonsetReadyNodes(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDaemonsetReadyNodes,
+                                                    descrMetricK8sDaemonsetReadyNodes,
+                                                    unitMetricK8sDaemonsetReadyNodes);
+}
+
+/**
+ * Total number of available replica pods (ready for at least minReadySeconds) targeted by this
+ * deployment <p> This metric aligns with the @code availableReplicas @endcode field of the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#deploymentstatus-v1-apps">K8s
+ * DeploymentStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#deployment">@code k8s.deployment @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sDeploymentAvailablePods = "k8s.deployment.available_pods";
+static constexpr const char *descrMetricK8sDeploymentAvailablePods =
+    "Total number of available replica pods (ready for at least minReadySeconds) targeted by this "
+    "deployment";
+static constexpr const char *unitMetricK8sDeploymentAvailablePods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sDeploymentAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sDeploymentAvailablePods,
+                                         descrMetricK8sDeploymentAvailablePods,
+                                         unitMetricK8sDeploymentAvailablePods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sDeploymentAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sDeploymentAvailablePods,
+                                          descrMetricK8sDeploymentAvailablePods,
+                                          unitMetricK8sDeploymentAvailablePods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sDeploymentAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDeploymentAvailablePods,
+                                                   descrMetricK8sDeploymentAvailablePods,
+                                                   unitMetricK8sDeploymentAvailablePods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sDeploymentAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDeploymentAvailablePods,
+                                                    descrMetricK8sDeploymentAvailablePods,
+                                                    unitMetricK8sDeploymentAvailablePods);
+}
+
+/**
+ * Number of desired replica pods in this deployment
+ * <p>
+ * This metric aligns with the @code replicas @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#deploymentspec-v1-apps">K8s
+ * DeploymentSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#deployment">@code k8s.deployment @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sDeploymentDesiredPods = "k8s.deployment.desired_pods";
+static constexpr const char *descrMetricK8sDeploymentDesiredPods =
+    "Number of desired replica pods in this deployment";
+static constexpr const char *unitMetricK8sDeploymentDesiredPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sDeploymentDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sDeploymentDesiredPods,
+                                         descrMetricK8sDeploymentDesiredPods,
+                                         unitMetricK8sDeploymentDesiredPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sDeploymentDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sDeploymentDesiredPods,
+                                          descrMetricK8sDeploymentDesiredPods,
+                                          unitMetricK8sDeploymentDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sDeploymentDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sDeploymentDesiredPods,
+                                                   descrMetricK8sDeploymentDesiredPods,
+                                                   unitMetricK8sDeploymentDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sDeploymentDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sDeploymentDesiredPods,
+                                                    descrMetricK8sDeploymentDesiredPods,
+                                                    unitMetricK8sDeploymentDesiredPods);
+}
+
+/**
+ * Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the
+ * autoscaler <p> This metric aligns with the @code currentReplicas @endcode field of the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerstatus-v2-autoscaling">K8s
+ * HorizontalPodAutoscalerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sHpaCurrentPods = "k8s.hpa.current_pods";
+static constexpr const char *descrMetricK8sHpaCurrentPods =
+    "Current number of replica pods managed by this horizontal pod autoscaler, as last seen by the "
+    "autoscaler";
+static constexpr const char *unitMetricK8sHpaCurrentPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sHpaCurrentPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods,
+                                         unitMetricK8sHpaCurrentPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sHpaCurrentPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods,
+                                          unitMetricK8sHpaCurrentPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sHpaCurrentPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, unitMetricK8sHpaCurrentPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sHpaCurrentPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricK8sHpaCurrentPods, descrMetricK8sHpaCurrentPods, unitMetricK8sHpaCurrentPods);
+}
+
+/**
+ * Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated by
+ * the autoscaler <p> This metric aligns with the @code desiredReplicas @endcode field of the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerstatus-v2-autoscaling">K8s
+ * HorizontalPodAutoscalerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sHpaDesiredPods = "k8s.hpa.desired_pods";
+static constexpr const char *descrMetricK8sHpaDesiredPods =
+    "Desired number of replica pods managed by this horizontal pod autoscaler, as last calculated "
+    "by the autoscaler";
+static constexpr const char *unitMetricK8sHpaDesiredPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sHpaDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods,
+                                         unitMetricK8sHpaDesiredPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sHpaDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods,
+                                          unitMetricK8sHpaDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sHpaDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods, unitMetricK8sHpaDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sHpaDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricK8sHpaDesiredPods, descrMetricK8sHpaDesiredPods, unitMetricK8sHpaDesiredPods);
+}
+
+/**
+ * The upper limit for the number of replica pods to which the autoscaler can scale up
+ * <p>
+ * This metric aligns with the @code maxReplicas @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerspec-v2-autoscaling">K8s
+ * HorizontalPodAutoscalerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sHpaMaxPods = "k8s.hpa.max_pods";
+static constexpr const char *descrMetricK8sHpaMaxPods =
+    "The upper limit for the number of replica pods to which the autoscaler can scale up";
+static constexpr const char *unitMetricK8sHpaMaxPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>> CreateSyncInt64MetricK8sHpaMaxPods(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods,
+                                         unitMetricK8sHpaMaxPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>> CreateSyncDoubleMetricK8sHpaMaxPods(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods,
+                                          unitMetricK8sHpaMaxPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sHpaMaxPods(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods,
+                                                   unitMetricK8sHpaMaxPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricK8sHpaMaxPods(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sHpaMaxPods, descrMetricK8sHpaMaxPods,
+                                                    unitMetricK8sHpaMaxPods);
+}
+
+/**
+ * The lower limit for the number of replica pods to which the autoscaler can scale down
+ * <p>
+ * This metric aligns with the @code minReplicas @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#horizontalpodautoscalerspec-v2-autoscaling">K8s
+ * HorizontalPodAutoscalerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#horizontalpodautoscaler">@code k8s.hpa @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sHpaMinPods = "k8s.hpa.min_pods";
+static constexpr const char *descrMetricK8sHpaMinPods =
+    "The lower limit for the number of replica pods to which the autoscaler can scale down";
+static constexpr const char *unitMetricK8sHpaMinPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>> CreateSyncInt64MetricK8sHpaMinPods(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods,
+                                         unitMetricK8sHpaMinPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>> CreateSyncDoubleMetricK8sHpaMinPods(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods,
+                                          unitMetricK8sHpaMinPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sHpaMinPods(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods,
+                                                   unitMetricK8sHpaMinPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricK8sHpaMinPods(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sHpaMinPods, descrMetricK8sHpaMinPods,
+                                                    unitMetricK8sHpaMinPods);
+}
+
+/**
+ * The number of pending and actively running pods for a job
+ * <p>
+ * This metric aligns with the @code active @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch">K8s
+ * JobStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sJobActivePods = "k8s.job.active_pods";
+static constexpr const char *descrMetricK8sJobActivePods =
+    "The number of pending and actively running pods for a job";
+static constexpr const char *unitMetricK8sJobActivePods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sJobActivePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sJobActivePods, descrMetricK8sJobActivePods,
+                                         unitMetricK8sJobActivePods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sJobActivePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sJobActivePods, descrMetricK8sJobActivePods,
+                                          unitMetricK8sJobActivePods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sJobActivePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricK8sJobActivePods, descrMetricK8sJobActivePods, unitMetricK8sJobActivePods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sJobActivePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricK8sJobActivePods, descrMetricK8sJobActivePods, unitMetricK8sJobActivePods);
+}
+
+/**
+ * The desired number of successfully finished pods the job should be run with
+ * <p>
+ * This metric aligns with the @code completions @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch">K8s
+ * JobSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sJobDesiredSuccessfulPods = "k8s.job.desired_successful_pods";
+static constexpr const char *descrMetricK8sJobDesiredSuccessfulPods =
+    "The desired number of successfully finished pods the job should be run with";
+static constexpr const char *unitMetricK8sJobDesiredSuccessfulPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sJobDesiredSuccessfulPods,
+                                         descrMetricK8sJobDesiredSuccessfulPods,
+                                         unitMetricK8sJobDesiredSuccessfulPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sJobDesiredSuccessfulPods,
+                                          descrMetricK8sJobDesiredSuccessfulPods,
+                                          unitMetricK8sJobDesiredSuccessfulPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sJobDesiredSuccessfulPods,
+                                                   descrMetricK8sJobDesiredSuccessfulPods,
+                                                   unitMetricK8sJobDesiredSuccessfulPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sJobDesiredSuccessfulPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sJobDesiredSuccessfulPods,
+                                                    descrMetricK8sJobDesiredSuccessfulPods,
+                                                    unitMetricK8sJobDesiredSuccessfulPods);
+}
+
+/**
+ * The number of pods which reached phase Failed for a job
+ * <p>
+ * This metric aligns with the @code failed @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch">K8s
+ * JobStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sJobFailedPods = "k8s.job.failed_pods";
+static constexpr const char *descrMetricK8sJobFailedPods =
+    "The number of pods which reached phase Failed for a job";
+static constexpr const char *unitMetricK8sJobFailedPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sJobFailedPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods,
+                                         unitMetricK8sJobFailedPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sJobFailedPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods,
+                                          unitMetricK8sJobFailedPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sJobFailedPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods, unitMetricK8sJobFailedPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sJobFailedPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricK8sJobFailedPods, descrMetricK8sJobFailedPods, unitMetricK8sJobFailedPods);
+}
+
+/**
+ * The max desired number of pods the job should run at any given time
+ * <p>
+ * This metric aligns with the @code parallelism @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobspec-v1-batch">K8s
+ * JobSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sJobMaxParallelPods = "k8s.job.max_parallel_pods";
+static constexpr const char *descrMetricK8sJobMaxParallelPods =
+    "The max desired number of pods the job should run at any given time";
+static constexpr const char *unitMetricK8sJobMaxParallelPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sJobMaxParallelPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sJobMaxParallelPods,
+                                         descrMetricK8sJobMaxParallelPods,
+                                         unitMetricK8sJobMaxParallelPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sJobMaxParallelPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sJobMaxParallelPods,
+                                          descrMetricK8sJobMaxParallelPods,
+                                          unitMetricK8sJobMaxParallelPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sJobMaxParallelPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sJobMaxParallelPods,
+                                                   descrMetricK8sJobMaxParallelPods,
+                                                   unitMetricK8sJobMaxParallelPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sJobMaxParallelPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sJobMaxParallelPods,
+                                                    descrMetricK8sJobMaxParallelPods,
+                                                    unitMetricK8sJobMaxParallelPods);
+}
+
+/**
+ * The number of pods which reached phase Succeeded for a job
+ * <p>
+ * This metric aligns with the @code succeeded @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#jobstatus-v1-batch">K8s
+ * JobStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#job">@code k8s.job @endcode</a> resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sJobSuccessfulPods = "k8s.job.successful_pods";
+static constexpr const char *descrMetricK8sJobSuccessfulPods =
+    "The number of pods which reached phase Succeeded for a job";
+static constexpr const char *unitMetricK8sJobSuccessfulPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sJobSuccessfulPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(
+      kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sJobSuccessfulPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(
+      kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sJobSuccessfulPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sJobSuccessfulPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricK8sJobSuccessfulPods, descrMetricK8sJobSuccessfulPods, unitMetricK8sJobSuccessfulPods);
+}
+
+/**
+ * Describes number of K8s namespaces that are currently in a given phase.
+ * <p>
+ * This metric SHOULD, at a minimum, be reported against a
+ * <a href="../resource/k8s.md#namespace">@code k8s.namespace @endcode</a> resource.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sNamespacePhase = "k8s.namespace.phase";
+static constexpr const char *descrMetricK8sNamespacePhase =
+    "Describes number of K8s namespaces that are currently in a given phase.";
+static constexpr const char *unitMetricK8sNamespacePhase = "{namespace}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sNamespacePhase(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sNamespacePhase, descrMetricK8sNamespacePhase,
+                                         unitMetricK8sNamespacePhase);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sNamespacePhase(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sNamespacePhase, descrMetricK8sNamespacePhase,
+                                          unitMetricK8sNamespacePhase);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sNamespacePhase(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricK8sNamespacePhase, descrMetricK8sNamespacePhase, unitMetricK8sNamespacePhase);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sNamespacePhase(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricK8sNamespacePhase, descrMetricK8sNamespacePhase, unitMetricK8sNamespacePhase);
+}
+
+/**
+ * Total CPU time consumed
+ * <p>
+ * Total CPU time consumed by the specific Node on all available CPU cores
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricK8sNodeCpuTime     = "k8s.node.cpu.time";
+static constexpr const char *descrMetricK8sNodeCpuTime = "Total CPU time consumed";
+static constexpr const char *unitMetricK8sNodeCpuTime  = "s";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricK8sNodeCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricK8sNodeCpuTime, descrMetricK8sNodeCpuTime,
+                                    unitMetricK8sNodeCpuTime);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricK8sNodeCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricK8sNodeCpuTime, descrMetricK8sNodeCpuTime,
+                                    unitMetricK8sNodeCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sNodeCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricK8sNodeCpuTime, descrMetricK8sNodeCpuTime,
+                                             unitMetricK8sNodeCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sNodeCpuTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricK8sNodeCpuTime, descrMetricK8sNodeCpuTime,
+                                              unitMetricK8sNodeCpuTime);
+}
+
+/**
+ * Node's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs
+ * <p>
+ * CPU usage of the specific Node on all available CPU cores, averaged over the sample window
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricK8sNodeCpuUsage = "k8s.node.cpu.usage";
+static constexpr const char *descrMetricK8sNodeCpuUsage =
+    "Node's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs";
+static constexpr const char *unitMetricK8sNodeCpuUsage = "{cpu}";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sNodeCpuUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricK8sNodeCpuUsage, descrMetricK8sNodeCpuUsage,
+                                 unitMetricK8sNodeCpuUsage);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sNodeCpuUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricK8sNodeCpuUsage, descrMetricK8sNodeCpuUsage,
+                                  unitMetricK8sNodeCpuUsage);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sNodeCpuUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricK8sNodeCpuUsage, descrMetricK8sNodeCpuUsage,
+                                           unitMetricK8sNodeCpuUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sNodeCpuUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricK8sNodeCpuUsage, descrMetricK8sNodeCpuUsage,
+                                            unitMetricK8sNodeCpuUsage);
+}
+
+/**
+ * Memory usage of the Node
+ * <p>
+ * Total memory usage of the Node
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricK8sNodeMemoryUsage     = "k8s.node.memory.usage";
+static constexpr const char *descrMetricK8sNodeMemoryUsage = "Memory usage of the Node";
+static constexpr const char *unitMetricK8sNodeMemoryUsage  = "By";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sNodeMemoryUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage,
+                                 unitMetricK8sNodeMemoryUsage);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sNodeMemoryUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage,
+                                  unitMetricK8sNodeMemoryUsage);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sNodeMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage,
+                                           unitMetricK8sNodeMemoryUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sNodeMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(
+      kMetricK8sNodeMemoryUsage, descrMetricK8sNodeMemoryUsage, unitMetricK8sNodeMemoryUsage);
+}
+
+/**
+ * Node network errors
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricK8sNodeNetworkErrors     = "k8s.node.network.errors";
+static constexpr const char *descrMetricK8sNodeNetworkErrors = "Node network errors";
+static constexpr const char *unitMetricK8sNodeNetworkErrors  = "{error}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricK8sNodeNetworkErrors(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricK8sNodeNetworkErrors, descrMetricK8sNodeNetworkErrors,
+                                    unitMetricK8sNodeNetworkErrors);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricK8sNodeNetworkErrors(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricK8sNodeNetworkErrors, descrMetricK8sNodeNetworkErrors,
+                                    unitMetricK8sNodeNetworkErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sNodeNetworkErrors(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricK8sNodeNetworkErrors, descrMetricK8sNodeNetworkErrors, unitMetricK8sNodeNetworkErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sNodeNetworkErrors(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricK8sNodeNetworkErrors, descrMetricK8sNodeNetworkErrors, unitMetricK8sNodeNetworkErrors);
+}
+
+/**
+ * Network bytes for the Node
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricK8sNodeNetworkIo     = "k8s.node.network.io";
+static constexpr const char *descrMetricK8sNodeNetworkIo = "Network bytes for the Node";
+static constexpr const char *unitMetricK8sNodeNetworkIo  = "By";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricK8sNodeNetworkIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricK8sNodeNetworkIo, descrMetricK8sNodeNetworkIo,
+                                    unitMetricK8sNodeNetworkIo);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricK8sNodeNetworkIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricK8sNodeNetworkIo, descrMetricK8sNodeNetworkIo,
+                                    unitMetricK8sNodeNetworkIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sNodeNetworkIo(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricK8sNodeNetworkIo, descrMetricK8sNodeNetworkIo,
+                                             unitMetricK8sNodeNetworkIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sNodeNetworkIo(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricK8sNodeNetworkIo, descrMetricK8sNodeNetworkIo,
+                                              unitMetricK8sNodeNetworkIo);
+}
+
+/**
+ * The time the Node has been running
+ * <p>
+ * Instrumentations SHOULD use a gauge with type @code double @endcode and measure uptime in seconds
+ * as a floating point number with the highest precision available. The actual accuracy would depend
+ * on the instrumentation and operating system. <p> gauge
+ */
+static constexpr const char *kMetricK8sNodeUptime     = "k8s.node.uptime";
+static constexpr const char *descrMetricK8sNodeUptime = "The time the Node has been running";
+static constexpr const char *unitMetricK8sNodeUptime  = "s";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sNodeUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricK8sNodeUptime, descrMetricK8sNodeUptime,
+                                 unitMetricK8sNodeUptime);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sNodeUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricK8sNodeUptime, descrMetricK8sNodeUptime,
+                                  unitMetricK8sNodeUptime);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sNodeUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricK8sNodeUptime, descrMetricK8sNodeUptime,
+                                           unitMetricK8sNodeUptime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricK8sNodeUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricK8sNodeUptime, descrMetricK8sNodeUptime,
+                                            unitMetricK8sNodeUptime);
+}
+
+/**
+ * Total CPU time consumed
+ * <p>
+ * Total CPU time consumed by the specific Pod on all available CPU cores
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricK8sPodCpuTime     = "k8s.pod.cpu.time";
+static constexpr const char *descrMetricK8sPodCpuTime = "Total CPU time consumed";
+static constexpr const char *unitMetricK8sPodCpuTime  = "s";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricK8sPodCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricK8sPodCpuTime, descrMetricK8sPodCpuTime,
+                                    unitMetricK8sPodCpuTime);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricK8sPodCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricK8sPodCpuTime, descrMetricK8sPodCpuTime,
+                                    unitMetricK8sPodCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sPodCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricK8sPodCpuTime, descrMetricK8sPodCpuTime,
+                                             unitMetricK8sPodCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricK8sPodCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricK8sPodCpuTime, descrMetricK8sPodCpuTime,
+                                              unitMetricK8sPodCpuTime);
+}
+
+/**
+ * Pod's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs
+ * <p>
+ * CPU usage of the specific Pod on all available CPU cores, averaged over the sample window
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricK8sPodCpuUsage = "k8s.pod.cpu.usage";
+static constexpr const char *descrMetricK8sPodCpuUsage =
+    "Pod's CPU usage, measured in cpus. Range from 0 to the number of allocatable CPUs";
+static constexpr const char *unitMetricK8sPodCpuUsage = "{cpu}";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sPodCpuUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricK8sPodCpuUsage, descrMetricK8sPodCpuUsage,
+                                 unitMetricK8sPodCpuUsage);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sPodCpuUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricK8sPodCpuUsage, descrMetricK8sPodCpuUsage,
+                                  unitMetricK8sPodCpuUsage);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sPodCpuUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricK8sPodCpuUsage, descrMetricK8sPodCpuUsage,
+                                           unitMetricK8sPodCpuUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sPodCpuUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricK8sPodCpuUsage, descrMetricK8sPodCpuUsage,
+                                            unitMetricK8sPodCpuUsage);
+}
+
+/**
+ * Memory usage of the Pod
+ * <p>
+ * Total memory usage of the Pod
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricK8sPodMemoryUsage     = "k8s.pod.memory.usage";
+static constexpr const char *descrMetricK8sPodMemoryUsage = "Memory usage of the Pod";
+static constexpr const char *unitMetricK8sPodMemoryUsage  = "By";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sPodMemoryUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricK8sPodMemoryUsage, descrMetricK8sPodMemoryUsage,
+                                 unitMetricK8sPodMemoryUsage);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sPodMemoryUsage(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricK8sPodMemoryUsage, descrMetricK8sPodMemoryUsage,
+                                  unitMetricK8sPodMemoryUsage);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sPodMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricK8sPodMemoryUsage, descrMetricK8sPodMemoryUsage,
+                                           unitMetricK8sPodMemoryUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sPodMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricK8sPodMemoryUsage, descrMetricK8sPodMemoryUsage,
+                                            unitMetricK8sPodMemoryUsage);
+}
+
+/**
+ * Pod network errors
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricK8sPodNetworkErrors     = "k8s.pod.network.errors";
+static constexpr const char *descrMetricK8sPodNetworkErrors = "Pod network errors";
+static constexpr const char *unitMetricK8sPodNetworkErrors  = "{error}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricK8sPodNetworkErrors(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricK8sPodNetworkErrors, descrMetricK8sPodNetworkErrors,
+                                    unitMetricK8sPodNetworkErrors);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricK8sPodNetworkErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricK8sPodNetworkErrors, descrMetricK8sPodNetworkErrors,
+                                    unitMetricK8sPodNetworkErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sPodNetworkErrors(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricK8sPodNetworkErrors, descrMetricK8sPodNetworkErrors, unitMetricK8sPodNetworkErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sPodNetworkErrors(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricK8sPodNetworkErrors, descrMetricK8sPodNetworkErrors, unitMetricK8sPodNetworkErrors);
+}
+
+/**
+ * Network bytes for the Pod
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricK8sPodNetworkIo     = "k8s.pod.network.io";
+static constexpr const char *descrMetricK8sPodNetworkIo = "Network bytes for the Pod";
+static constexpr const char *unitMetricK8sPodNetworkIo  = "By";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricK8sPodNetworkIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricK8sPodNetworkIo, descrMetricK8sPodNetworkIo,
+                                    unitMetricK8sPodNetworkIo);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricK8sPodNetworkIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricK8sPodNetworkIo, descrMetricK8sPodNetworkIo,
+                                    unitMetricK8sPodNetworkIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sPodNetworkIo(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricK8sPodNetworkIo, descrMetricK8sPodNetworkIo,
+                                             unitMetricK8sPodNetworkIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sPodNetworkIo(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricK8sPodNetworkIo, descrMetricK8sPodNetworkIo,
+                                              unitMetricK8sPodNetworkIo);
+}
+
+/**
+ * The time the Pod has been running
+ * <p>
+ * Instrumentations SHOULD use a gauge with type @code double @endcode and measure uptime in seconds
+ * as a floating point number with the highest precision available. The actual accuracy would depend
+ * on the instrumentation and operating system. <p> gauge
+ */
+static constexpr const char *kMetricK8sPodUptime     = "k8s.pod.uptime";
+static constexpr const char *descrMetricK8sPodUptime = "The time the Pod has been running";
+static constexpr const char *unitMetricK8sPodUptime  = "s";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricK8sPodUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricK8sPodUptime, descrMetricK8sPodUptime,
+                                 unitMetricK8sPodUptime);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricK8sPodUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricK8sPodUptime, descrMetricK8sPodUptime,
+                                  unitMetricK8sPodUptime);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricK8sPodUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricK8sPodUptime, descrMetricK8sPodUptime,
+                                           unitMetricK8sPodUptime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricK8sPodUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricK8sPodUptime, descrMetricK8sPodUptime,
+                                            unitMetricK8sPodUptime);
+}
+
+/**
+ * Total number of available replica pods (ready for at least minReadySeconds) targeted by this
+ * replicaset <p> This metric aligns with the @code availableReplicas @endcode field of the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicasetstatus-v1-apps">K8s
+ * ReplicaSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#replicaset">@code k8s.replicaset @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sReplicasetAvailablePods = "k8s.replicaset.available_pods";
+static constexpr const char *descrMetricK8sReplicasetAvailablePods =
+    "Total number of available replica pods (ready for at least minReadySeconds) targeted by this "
+    "replicaset";
+static constexpr const char *unitMetricK8sReplicasetAvailablePods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sReplicasetAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sReplicasetAvailablePods,
+                                         descrMetricK8sReplicasetAvailablePods,
+                                         unitMetricK8sReplicasetAvailablePods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sReplicasetAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sReplicasetAvailablePods,
+                                          descrMetricK8sReplicasetAvailablePods,
+                                          unitMetricK8sReplicasetAvailablePods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sReplicasetAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicasetAvailablePods,
+                                                   descrMetricK8sReplicasetAvailablePods,
+                                                   unitMetricK8sReplicasetAvailablePods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sReplicasetAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicasetAvailablePods,
+                                                    descrMetricK8sReplicasetAvailablePods,
+                                                    unitMetricK8sReplicasetAvailablePods);
+}
+
+/**
+ * Number of desired replica pods in this replicaset
+ * <p>
+ * This metric aligns with the @code replicas @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicasetspec-v1-apps">K8s
+ * ReplicaSetSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#replicaset">@code k8s.replicaset @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sReplicasetDesiredPods = "k8s.replicaset.desired_pods";
+static constexpr const char *descrMetricK8sReplicasetDesiredPods =
+    "Number of desired replica pods in this replicaset";
+static constexpr const char *unitMetricK8sReplicasetDesiredPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sReplicasetDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sReplicasetDesiredPods,
+                                         descrMetricK8sReplicasetDesiredPods,
+                                         unitMetricK8sReplicasetDesiredPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sReplicasetDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sReplicasetDesiredPods,
+                                          descrMetricK8sReplicasetDesiredPods,
+                                          unitMetricK8sReplicasetDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sReplicasetDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicasetDesiredPods,
+                                                   descrMetricK8sReplicasetDesiredPods,
+                                                   unitMetricK8sReplicasetDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sReplicasetDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicasetDesiredPods,
+                                                    descrMetricK8sReplicasetDesiredPods,
+                                                    unitMetricK8sReplicasetDesiredPods);
+}
+
+/**
+ * Deprecated, use @code k8s.replicationcontroller.available_pods @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code k8s.replicationcontroller.available_pods @endcode.", "reason":
+ * "uncategorized"} <p> This metric aligns with the @code availableReplicas @endcode field of the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerstatus-v1-core">K8s
+ * ReplicationControllerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
+ * resource. <p> updowncounter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicationControllerAvailablePods =
+    "k8s.replication_controller.available_pods";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *descrMetricK8sReplicationControllerAvailablePods =
+        "Deprecated, use `k8s.replicationcontroller.available_pods` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *unitMetricK8sReplicationControllerAvailablePods = "{pod}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sReplicationControllerAvailablePods,
+                                         descrMetricK8sReplicationControllerAvailablePods,
+                                         unitMetricK8sReplicationControllerAvailablePods);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationControllerAvailablePods,
+                                          descrMetricK8sReplicationControllerAvailablePods,
+                                          unitMetricK8sReplicationControllerAvailablePods);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationControllerAvailablePods,
+                                                   descrMetricK8sReplicationControllerAvailablePods,
+                                                   unitMetricK8sReplicationControllerAvailablePods);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sReplicationControllerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricK8sReplicationControllerAvailablePods,
+      descrMetricK8sReplicationControllerAvailablePods,
+      unitMetricK8sReplicationControllerAvailablePods);
+}
+
+/**
+ * Deprecated, use @code k8s.replicationcontroller.desired_pods @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code k8s.replicationcontroller.desired_pods @endcode.", "reason":
+ * "uncategorized"} <p> This metric aligns with the @code replicas @endcode field of the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerspec-v1-core">K8s
+ * ReplicationControllerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
+ * resource. <p> updowncounter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricK8sReplicationControllerDesiredPods =
+    "k8s.replication_controller.desired_pods";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *descrMetricK8sReplicationControllerDesiredPods =
+        "Deprecated, use `k8s.replicationcontroller.desired_pods` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char
+    *unitMetricK8sReplicationControllerDesiredPods = "{pod}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sReplicationControllerDesiredPods,
+                                         descrMetricK8sReplicationControllerDesiredPods,
+                                         unitMetricK8sReplicationControllerDesiredPods);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationControllerDesiredPods,
+                                          descrMetricK8sReplicationControllerDesiredPods,
+                                          unitMetricK8sReplicationControllerDesiredPods);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationControllerDesiredPods,
+                                                   descrMetricK8sReplicationControllerDesiredPods,
+                                                   unitMetricK8sReplicationControllerDesiredPods);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sReplicationControllerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicationControllerDesiredPods,
+                                                    descrMetricK8sReplicationControllerDesiredPods,
+                                                    unitMetricK8sReplicationControllerDesiredPods);
+}
+
+/**
+ * Total number of available replica pods (ready for at least minReadySeconds) targeted by this
+ * replication controller <p> This metric aligns with the @code availableReplicas @endcode field of
+ * the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerstatus-v1-core">K8s
+ * ReplicationControllerStatus</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
+ * resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sReplicationcontrollerAvailablePods =
+    "k8s.replicationcontroller.available_pods";
+static constexpr const char *descrMetricK8sReplicationcontrollerAvailablePods =
+    "Total number of available replica pods (ready for at least minReadySeconds) targeted by this "
+    "replication controller";
+static constexpr const char *unitMetricK8sReplicationcontrollerAvailablePods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sReplicationcontrollerAvailablePods,
+                                         descrMetricK8sReplicationcontrollerAvailablePods,
+                                         unitMetricK8sReplicationcontrollerAvailablePods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationcontrollerAvailablePods,
+                                          descrMetricK8sReplicationcontrollerAvailablePods,
+                                          unitMetricK8sReplicationcontrollerAvailablePods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationcontrollerAvailablePods,
+                                                   descrMetricK8sReplicationcontrollerAvailablePods,
+                                                   unitMetricK8sReplicationcontrollerAvailablePods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sReplicationcontrollerAvailablePods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricK8sReplicationcontrollerAvailablePods,
+      descrMetricK8sReplicationcontrollerAvailablePods,
+      unitMetricK8sReplicationcontrollerAvailablePods);
+}
+
+/**
+ * Number of desired replica pods in this replication controller
+ * <p>
+ * This metric aligns with the @code replicas @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#replicationcontrollerspec-v1-core">K8s
+ * ReplicationControllerSpec</a> <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#replicationcontroller">@code k8s.replicationcontroller @endcode</a>
+ * resource. <p> updowncounter
+ */
+static constexpr const char *kMetricK8sReplicationcontrollerDesiredPods =
+    "k8s.replicationcontroller.desired_pods";
+static constexpr const char *descrMetricK8sReplicationcontrollerDesiredPods =
+    "Number of desired replica pods in this replication controller";
+static constexpr const char *unitMetricK8sReplicationcontrollerDesiredPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
+                                         descrMetricK8sReplicationcontrollerDesiredPods,
+                                         unitMetricK8sReplicationcontrollerDesiredPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
+                                          descrMetricK8sReplicationcontrollerDesiredPods,
+                                          unitMetricK8sReplicationcontrollerDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
+                                                   descrMetricK8sReplicationcontrollerDesiredPods,
+                                                   unitMetricK8sReplicationcontrollerDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sReplicationcontrollerDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sReplicationcontrollerDesiredPods,
+                                                    descrMetricK8sReplicationcontrollerDesiredPods,
+                                                    unitMetricK8sReplicationcontrollerDesiredPods);
+}
+
+/**
+ * The number of replica pods created by the statefulset controller from the statefulset version
+ * indicated by currentRevision <p> This metric aligns with the @code currentReplicas @endcode field
+ * of the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps">K8s
+ * StatefulSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#statefulset">@code k8s.statefulset @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sStatefulsetCurrentPods = "k8s.statefulset.current_pods";
+static constexpr const char *descrMetricK8sStatefulsetCurrentPods =
+    "The number of replica pods created by the statefulset controller from the statefulset version "
+    "indicated by currentRevision";
+static constexpr const char *unitMetricK8sStatefulsetCurrentPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sStatefulsetCurrentPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetCurrentPods,
+                                         descrMetricK8sStatefulsetCurrentPods,
+                                         unitMetricK8sStatefulsetCurrentPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sStatefulsetCurrentPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetCurrentPods,
+                                          descrMetricK8sStatefulsetCurrentPods,
+                                          unitMetricK8sStatefulsetCurrentPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sStatefulsetCurrentPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetCurrentPods,
+                                                   descrMetricK8sStatefulsetCurrentPods,
+                                                   unitMetricK8sStatefulsetCurrentPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sStatefulsetCurrentPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetCurrentPods,
+                                                    descrMetricK8sStatefulsetCurrentPods,
+                                                    unitMetricK8sStatefulsetCurrentPods);
+}
+
+/**
+ * Number of desired replica pods in this statefulset
+ * <p>
+ * This metric aligns with the @code replicas @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetspec-v1-apps">K8s
+ * StatefulSetSpec</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#statefulset">@code k8s.statefulset @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sStatefulsetDesiredPods = "k8s.statefulset.desired_pods";
+static constexpr const char *descrMetricK8sStatefulsetDesiredPods =
+    "Number of desired replica pods in this statefulset";
+static constexpr const char *unitMetricK8sStatefulsetDesiredPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sStatefulsetDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetDesiredPods,
+                                         descrMetricK8sStatefulsetDesiredPods,
+                                         unitMetricK8sStatefulsetDesiredPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sStatefulsetDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetDesiredPods,
+                                          descrMetricK8sStatefulsetDesiredPods,
+                                          unitMetricK8sStatefulsetDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sStatefulsetDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetDesiredPods,
+                                                   descrMetricK8sStatefulsetDesiredPods,
+                                                   unitMetricK8sStatefulsetDesiredPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sStatefulsetDesiredPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetDesiredPods,
+                                                    descrMetricK8sStatefulsetDesiredPods,
+                                                    unitMetricK8sStatefulsetDesiredPods);
+}
+
+/**
+ * The number of replica pods created for this statefulset with a Ready Condition
+ * <p>
+ * This metric aligns with the @code readyReplicas @endcode field of the
+ * <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps">K8s
+ * StatefulSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#statefulset">@code k8s.statefulset @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sStatefulsetReadyPods = "k8s.statefulset.ready_pods";
+static constexpr const char *descrMetricK8sStatefulsetReadyPods =
+    "The number of replica pods created for this statefulset with a Ready Condition";
+static constexpr const char *unitMetricK8sStatefulsetReadyPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sStatefulsetReadyPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetReadyPods,
+                                         descrMetricK8sStatefulsetReadyPods,
+                                         unitMetricK8sStatefulsetReadyPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sStatefulsetReadyPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetReadyPods,
+                                          descrMetricK8sStatefulsetReadyPods,
+                                          unitMetricK8sStatefulsetReadyPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sStatefulsetReadyPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetReadyPods,
+                                                   descrMetricK8sStatefulsetReadyPods,
+                                                   unitMetricK8sStatefulsetReadyPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sStatefulsetReadyPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetReadyPods,
+                                                    descrMetricK8sStatefulsetReadyPods,
+                                                    unitMetricK8sStatefulsetReadyPods);
+}
+
+/**
+ * Number of replica pods created by the statefulset controller from the statefulset version
+ * indicated by updateRevision <p> This metric aligns with the @code updatedReplicas @endcode field
+ * of the <a
+ * href="https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#statefulsetstatus-v1-apps">K8s
+ * StatefulSetStatus</a>. <p> This metric SHOULD, at a minimum, be reported against a <a
+ * href="../resource/k8s.md#statefulset">@code k8s.statefulset @endcode</a> resource. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricK8sStatefulsetUpdatedPods = "k8s.statefulset.updated_pods";
+static constexpr const char *descrMetricK8sStatefulsetUpdatedPods =
+    "Number of replica pods created by the statefulset controller from the statefulset version "
+    "indicated by updateRevision";
+static constexpr const char *unitMetricK8sStatefulsetUpdatedPods = "{pod}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricK8sStatefulsetUpdatedPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricK8sStatefulsetUpdatedPods,
+                                         descrMetricK8sStatefulsetUpdatedPods,
+                                         unitMetricK8sStatefulsetUpdatedPods);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricK8sStatefulsetUpdatedPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricK8sStatefulsetUpdatedPods,
+                                          descrMetricK8sStatefulsetUpdatedPods,
+                                          unitMetricK8sStatefulsetUpdatedPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricK8sStatefulsetUpdatedPods(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricK8sStatefulsetUpdatedPods,
+                                                   descrMetricK8sStatefulsetUpdatedPods,
+                                                   unitMetricK8sStatefulsetUpdatedPods);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricK8sStatefulsetUpdatedPods(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricK8sStatefulsetUpdatedPods,
+                                                    descrMetricK8sStatefulsetUpdatedPods,
+                                                    unitMetricK8sStatefulsetUpdatedPods);
+}
+
+}  // namespace k8s
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/messaging_metrics.h b/api/include/opentelemetry/semconv/messaging_metrics.h
new file mode 100644
index 0000000000..91cb19f726
--- /dev/null
+++ b/api/include/opentelemetry/semconv/messaging_metrics.h
@@ -0,0 +1,414 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace messaging
+{
+
+/**
+ * Number of messages that were delivered to the application.
+ * <p>
+ * Records the number of messages pulled from the broker or number of messages dispatched to the
+ * application in push-based scenarios. The metric SHOULD be reported once per message delivery. For
+ * example, if receiving and processing operations are both instrumented for a single message
+ * delivery, this counter is incremented when the message is received and not reported when it is
+ * processed. <p> counter
+ */
+static constexpr const char *kMetricMessagingClientConsumedMessages =
+    "messaging.client.consumed.messages";
+static constexpr const char *descrMetricMessagingClientConsumedMessages =
+    "Number of messages that were delivered to the application.";
+static constexpr const char *unitMetricMessagingClientConsumedMessages = "{message}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricMessagingClientConsumedMessages(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricMessagingClientConsumedMessages,
+                                    descrMetricMessagingClientConsumedMessages,
+                                    unitMetricMessagingClientConsumedMessages);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricMessagingClientConsumedMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricMessagingClientConsumedMessages,
+                                    descrMetricMessagingClientConsumedMessages,
+                                    unitMetricMessagingClientConsumedMessages);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricMessagingClientConsumedMessages(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricMessagingClientConsumedMessages,
+                                             descrMetricMessagingClientConsumedMessages,
+                                             unitMetricMessagingClientConsumedMessages);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricMessagingClientConsumedMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricMessagingClientConsumedMessages,
+                                              descrMetricMessagingClientConsumedMessages,
+                                              unitMetricMessagingClientConsumedMessages);
+}
+
+/**
+ * Duration of messaging operation initiated by a producer or consumer client.
+ * <p>
+ * This metric SHOULD NOT be used to report processing duration - processing duration is reported in
+ * @code messaging.process.duration @endcode metric. <p> histogram
+ */
+static constexpr const char *kMetricMessagingClientOperationDuration =
+    "messaging.client.operation.duration";
+static constexpr const char *descrMetricMessagingClientOperationDuration =
+    "Duration of messaging operation initiated by a producer or consumer client.";
+static constexpr const char *unitMetricMessagingClientOperationDuration = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricMessagingClientOperationDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricMessagingClientOperationDuration,
+                                      descrMetricMessagingClientOperationDuration,
+                                      unitMetricMessagingClientOperationDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricMessagingClientOperationDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricMessagingClientOperationDuration,
+                                      descrMetricMessagingClientOperationDuration,
+                                      unitMetricMessagingClientOperationDuration);
+}
+
+/**
+ * Deprecated. Use @code messaging.client.sent.messages @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code messaging.client.sent.messages @endcode.", "reason": "uncategorized"}
+ * <p>
+ * counter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingClientPublishedMessages =
+    "messaging.client.published.messages";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricMessagingClientPublishedMessages =
+    "Deprecated. Use `messaging.client.sent.messages` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricMessagingClientPublishedMessages =
+    "{message}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricMessagingClientPublishedMessages(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricMessagingClientPublishedMessages,
+                                    descrMetricMessagingClientPublishedMessages,
+                                    unitMetricMessagingClientPublishedMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricMessagingClientPublishedMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricMessagingClientPublishedMessages,
+                                    descrMetricMessagingClientPublishedMessages,
+                                    unitMetricMessagingClientPublishedMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricMessagingClientPublishedMessages(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricMessagingClientPublishedMessages,
+                                             descrMetricMessagingClientPublishedMessages,
+                                             unitMetricMessagingClientPublishedMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricMessagingClientPublishedMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricMessagingClientPublishedMessages,
+                                              descrMetricMessagingClientPublishedMessages,
+                                              unitMetricMessagingClientPublishedMessages);
+}
+
+/**
+ * Number of messages producer attempted to send to the broker.
+ * <p>
+ * This metric MUST NOT count messages that were created but haven't yet been sent.
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricMessagingClientSentMessages = "messaging.client.sent.messages";
+static constexpr const char *descrMetricMessagingClientSentMessages =
+    "Number of messages producer attempted to send to the broker.";
+static constexpr const char *unitMetricMessagingClientSentMessages = "{message}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricMessagingClientSentMessages(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricMessagingClientSentMessages,
+                                    descrMetricMessagingClientSentMessages,
+                                    unitMetricMessagingClientSentMessages);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricMessagingClientSentMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricMessagingClientSentMessages,
+                                    descrMetricMessagingClientSentMessages,
+                                    unitMetricMessagingClientSentMessages);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricMessagingClientSentMessages(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricMessagingClientSentMessages,
+                                             descrMetricMessagingClientSentMessages,
+                                             unitMetricMessagingClientSentMessages);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricMessagingClientSentMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricMessagingClientSentMessages,
+                                              descrMetricMessagingClientSentMessages,
+                                              unitMetricMessagingClientSentMessages);
+}
+
+/**
+ * Duration of processing operation.
+ * <p>
+ * This metric MUST be reported for operations with @code messaging.operation.type @endcode that
+ * matches @code process @endcode. <p> histogram
+ */
+static constexpr const char *kMetricMessagingProcessDuration = "messaging.process.duration";
+static constexpr const char *descrMetricMessagingProcessDuration =
+    "Duration of processing operation.";
+static constexpr const char *unitMetricMessagingProcessDuration = "s";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricMessagingProcessDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricMessagingProcessDuration,
+                                      descrMetricMessagingProcessDuration,
+                                      unitMetricMessagingProcessDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricMessagingProcessDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricMessagingProcessDuration,
+                                      descrMetricMessagingProcessDuration,
+                                      unitMetricMessagingProcessDuration);
+}
+
+/**
+ * Deprecated. Use @code messaging.client.consumed.messages @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code messaging.client.consumed.messages @endcode.", "reason":
+ * "uncategorized"} <p> counter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingProcessMessages =
+    "messaging.process.messages";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricMessagingProcessMessages =
+    "Deprecated. Use `messaging.client.consumed.messages` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricMessagingProcessMessages =
+    "{message}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricMessagingProcessMessages(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricMessagingProcessMessages,
+                                    descrMetricMessagingProcessMessages,
+                                    unitMetricMessagingProcessMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricMessagingProcessMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricMessagingProcessMessages,
+                                    descrMetricMessagingProcessMessages,
+                                    unitMetricMessagingProcessMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricMessagingProcessMessages(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricMessagingProcessMessages,
+                                             descrMetricMessagingProcessMessages,
+                                             unitMetricMessagingProcessMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricMessagingProcessMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricMessagingProcessMessages,
+                                              descrMetricMessagingProcessMessages,
+                                              unitMetricMessagingProcessMessages);
+}
+
+/**
+ * Deprecated. Use @code messaging.client.operation.duration @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code messaging.client.operation.duration @endcode.", "reason":
+ * "uncategorized"} <p> histogram
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingPublishDuration =
+    "messaging.publish.duration";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricMessagingPublishDuration =
+    "Deprecated. Use `messaging.client.operation.duration` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricMessagingPublishDuration = "s";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricMessagingPublishDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricMessagingPublishDuration,
+                                      descrMetricMessagingPublishDuration,
+                                      unitMetricMessagingPublishDuration);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricMessagingPublishDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricMessagingPublishDuration,
+                                      descrMetricMessagingPublishDuration,
+                                      unitMetricMessagingPublishDuration);
+}
+
+/**
+ * Deprecated. Use @code messaging.client.produced.messages @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code messaging.client.produced.messages @endcode.", "reason":
+ * "uncategorized"} <p> counter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingPublishMessages =
+    "messaging.publish.messages";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricMessagingPublishMessages =
+    "Deprecated. Use `messaging.client.produced.messages` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricMessagingPublishMessages =
+    "{message}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricMessagingPublishMessages(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricMessagingPublishMessages,
+                                    descrMetricMessagingPublishMessages,
+                                    unitMetricMessagingPublishMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricMessagingPublishMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricMessagingPublishMessages,
+                                    descrMetricMessagingPublishMessages,
+                                    unitMetricMessagingPublishMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricMessagingPublishMessages(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricMessagingPublishMessages,
+                                             descrMetricMessagingPublishMessages,
+                                             unitMetricMessagingPublishMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricMessagingPublishMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricMessagingPublishMessages,
+                                              descrMetricMessagingPublishMessages,
+                                              unitMetricMessagingPublishMessages);
+}
+
+/**
+ * Deprecated. Use @code messaging.client.operation.duration @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code messaging.client.operation.duration @endcode.", "reason":
+ * "uncategorized"} <p> histogram
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingReceiveDuration =
+    "messaging.receive.duration";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricMessagingReceiveDuration =
+    "Deprecated. Use `messaging.client.operation.duration` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricMessagingReceiveDuration = "s";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricMessagingReceiveDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricMessagingReceiveDuration,
+                                      descrMetricMessagingReceiveDuration,
+                                      unitMetricMessagingReceiveDuration);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricMessagingReceiveDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricMessagingReceiveDuration,
+                                      descrMetricMessagingReceiveDuration,
+                                      unitMetricMessagingReceiveDuration);
+}
+
+/**
+ * Deprecated. Use @code messaging.client.consumed.messages @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code messaging.client.consumed.messages @endcode.", "reason":
+ * "uncategorized"} <p> counter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricMessagingReceiveMessages =
+    "messaging.receive.messages";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricMessagingReceiveMessages =
+    "Deprecated. Use `messaging.client.consumed.messages` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricMessagingReceiveMessages =
+    "{message}";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricMessagingReceiveMessages(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricMessagingReceiveMessages,
+                                    descrMetricMessagingReceiveMessages,
+                                    unitMetricMessagingReceiveMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricMessagingReceiveMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricMessagingReceiveMessages,
+                                    descrMetricMessagingReceiveMessages,
+                                    unitMetricMessagingReceiveMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricMessagingReceiveMessages(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricMessagingReceiveMessages,
+                                             descrMetricMessagingReceiveMessages,
+                                             unitMetricMessagingReceiveMessages);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricMessagingReceiveMessages(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricMessagingReceiveMessages,
+                                              descrMetricMessagingReceiveMessages,
+                                              unitMetricMessagingReceiveMessages);
+}
+
+}  // namespace messaging
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/otel_metrics.h b/api/include/opentelemetry/semconv/otel_metrics.h
new file mode 100644
index 0000000000..0308a324b0
--- /dev/null
+++ b/api/include/opentelemetry/semconv/otel_metrics.h
@@ -0,0 +1,337 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace otel
+{
+
+/**
+ * The number of spans for which the export has finished, either successful or failed
+ * <p>
+ * For successful exports, @code error.type @endcode MUST NOT be set. For failed exports, @code
+ * error.type @endcode must contain the failure cause. For exporters with partial success semantics
+ * (e.g. OTLP with @code rejected_spans @endcode), rejected spans must count as failed and only
+ * non-rejected spans count as success. If no rejection reason is available, @code rejected @endcode
+ * SHOULD be used as value for @code error.type @endcode. <p> counter
+ */
+static constexpr const char *kMetricOtelSdkExporterSpanExportedCount =
+    "otel.sdk.exporter.span.exported.count";
+static constexpr const char *descrMetricOtelSdkExporterSpanExportedCount =
+    "The number of spans for which the export has finished, either successful or failed";
+static constexpr const char *unitMetricOtelSdkExporterSpanExportedCount = "{span}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricOtelSdkExporterSpanExportedCount,
+                                    descrMetricOtelSdkExporterSpanExportedCount,
+                                    unitMetricOtelSdkExporterSpanExportedCount);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricOtelSdkExporterSpanExportedCount,
+                                    descrMetricOtelSdkExporterSpanExportedCount,
+                                    unitMetricOtelSdkExporterSpanExportedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricOtelSdkExporterSpanExportedCount,
+                                             descrMetricOtelSdkExporterSpanExportedCount,
+                                             unitMetricOtelSdkExporterSpanExportedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkExporterSpanExportedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricOtelSdkExporterSpanExportedCount,
+                                              descrMetricOtelSdkExporterSpanExportedCount,
+                                              unitMetricOtelSdkExporterSpanExportedCount);
+}
+
+/**
+ * The number of spans which were passed to the exporter, but that have not been exported yet
+ * (neither successful, nor failed) <p> For successful exports, @code error.type @endcode MUST NOT
+ * be set. For failed exports, @code error.type @endcode must contain the failure cause. <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricOtelSdkExporterSpanInflightCount =
+    "otel.sdk.exporter.span.inflight.count";
+static constexpr const char *descrMetricOtelSdkExporterSpanInflightCount =
+    "The number of spans which were passed to the exporter, but that have not been exported yet "
+    "(neither successful, nor failed)";
+static constexpr const char *unitMetricOtelSdkExporterSpanInflightCount = "{span}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
+                                         descrMetricOtelSdkExporterSpanInflightCount,
+                                         unitMetricOtelSdkExporterSpanInflightCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
+                                          descrMetricOtelSdkExporterSpanInflightCount,
+                                          unitMetricOtelSdkExporterSpanInflightCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
+                                                   descrMetricOtelSdkExporterSpanInflightCount,
+                                                   unitMetricOtelSdkExporterSpanInflightCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkExporterSpanInflightCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkExporterSpanInflightCount,
+                                                    descrMetricOtelSdkExporterSpanInflightCount,
+                                                    unitMetricOtelSdkExporterSpanInflightCount);
+}
+
+/**
+ * The number of spans for which the processing has finished, either successful or failed
+ * <p>
+ * For successful processing, @code error.type @endcode MUST NOT be set. For failed processing,
+ * @code error.type @endcode must contain the failure cause. For the SDK Simple and Batching Span
+ * Processor a span is considered to be processed already when it has been submitted to the
+ * exporter, not when the corresponding export call has finished. <p> counter
+ */
+static constexpr const char *kMetricOtelSdkProcessorSpanProcessedCount =
+    "otel.sdk.processor.span.processed.count";
+static constexpr const char *descrMetricOtelSdkProcessorSpanProcessedCount =
+    "The number of spans for which the processing has finished, either successful or failed";
+static constexpr const char *unitMetricOtelSdkProcessorSpanProcessedCount = "{span}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricOtelSdkProcessorSpanProcessedCount,
+                                    descrMetricOtelSdkProcessorSpanProcessedCount,
+                                    unitMetricOtelSdkProcessorSpanProcessedCount);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricOtelSdkProcessorSpanProcessedCount,
+                                    descrMetricOtelSdkProcessorSpanProcessedCount,
+                                    unitMetricOtelSdkProcessorSpanProcessedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricOtelSdkProcessorSpanProcessedCount,
+                                             descrMetricOtelSdkProcessorSpanProcessedCount,
+                                             unitMetricOtelSdkProcessorSpanProcessedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkProcessorSpanProcessedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricOtelSdkProcessorSpanProcessedCount,
+                                              descrMetricOtelSdkProcessorSpanProcessedCount,
+                                              unitMetricOtelSdkProcessorSpanProcessedCount);
+}
+
+/**
+ * The maximum number of spans the queue of a given instance of an SDK span processor can hold
+ * <p>
+ * Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricOtelSdkProcessorSpanQueueCapacity =
+    "otel.sdk.processor.span.queue.capacity";
+static constexpr const char *descrMetricOtelSdkProcessorSpanQueueCapacity =
+    "The maximum number of spans the queue of a given instance of an SDK span processor can hold";
+static constexpr const char *unitMetricOtelSdkProcessorSpanQueueCapacity = "{span}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
+                                         descrMetricOtelSdkProcessorSpanQueueCapacity,
+                                         unitMetricOtelSdkProcessorSpanQueueCapacity);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
+                                          descrMetricOtelSdkProcessorSpanQueueCapacity,
+                                          unitMetricOtelSdkProcessorSpanQueueCapacity);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
+                                                   descrMetricOtelSdkProcessorSpanQueueCapacity,
+                                                   unitMetricOtelSdkProcessorSpanQueueCapacity);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkProcessorSpanQueueCapacity(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueCapacity,
+                                                    descrMetricOtelSdkProcessorSpanQueueCapacity,
+                                                    unitMetricOtelSdkProcessorSpanQueueCapacity);
+}
+
+/**
+ * The number of spans in the queue of a given instance of an SDK span processor
+ * <p>
+ * Only applies to span processors which use a queue, e.g. the SDK Batching Span Processor.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricOtelSdkProcessorSpanQueueSize =
+    "otel.sdk.processor.span.queue.size";
+static constexpr const char *descrMetricOtelSdkProcessorSpanQueueSize =
+    "The number of spans in the queue of a given instance of an SDK span processor";
+static constexpr const char *unitMetricOtelSdkProcessorSpanQueueSize = "{span}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
+                                         descrMetricOtelSdkProcessorSpanQueueSize,
+                                         unitMetricOtelSdkProcessorSpanQueueSize);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
+                                          descrMetricOtelSdkProcessorSpanQueueSize,
+                                          unitMetricOtelSdkProcessorSpanQueueSize);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
+                                                   descrMetricOtelSdkProcessorSpanQueueSize,
+                                                   unitMetricOtelSdkProcessorSpanQueueSize);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkProcessorSpanQueueSize(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricOtelSdkProcessorSpanQueueSize,
+                                                    descrMetricOtelSdkProcessorSpanQueueSize,
+                                                    unitMetricOtelSdkProcessorSpanQueueSize);
+}
+
+/**
+ * The number of created spans for which the end operation was called
+ * <p>
+ * For spans with @code recording=true @endcode: Implementations MUST record both @code
+ * otel.sdk.span.live.count @endcode and @code otel.sdk.span.ended.count @endcode. For spans with
+ * @code recording=false @endcode: If implementations decide to record this metric, they MUST also
+ * record @code otel.sdk.span.live.count @endcode. <p> counter
+ */
+static constexpr const char *kMetricOtelSdkSpanEndedCount = "otel.sdk.span.ended.count";
+static constexpr const char *descrMetricOtelSdkSpanEndedCount =
+    "The number of created spans for which the end operation was called";
+static constexpr const char *unitMetricOtelSdkSpanEndedCount = "{span}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricOtelSdkSpanEndedCount(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricOtelSdkSpanEndedCount, descrMetricOtelSdkSpanEndedCount,
+                                    unitMetricOtelSdkSpanEndedCount);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricOtelSdkSpanEndedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricOtelSdkSpanEndedCount, descrMetricOtelSdkSpanEndedCount,
+                                    unitMetricOtelSdkSpanEndedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkSpanEndedCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricOtelSdkSpanEndedCount,
+                                             descrMetricOtelSdkSpanEndedCount,
+                                             unitMetricOtelSdkSpanEndedCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkSpanEndedCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricOtelSdkSpanEndedCount,
+                                              descrMetricOtelSdkSpanEndedCount,
+                                              unitMetricOtelSdkSpanEndedCount);
+}
+
+/**
+ * The number of created spans for which the end operation has not been called yet
+ * <p>
+ * For spans with @code recording=true @endcode: Implementations MUST record both @code
+ * otel.sdk.span.live.count @endcode and @code otel.sdk.span.ended.count @endcode. For spans with
+ * @code recording=false @endcode: If implementations decide to record this metric, they MUST also
+ * record @code otel.sdk.span.ended.count @endcode. <p> updowncounter
+ */
+static constexpr const char *kMetricOtelSdkSpanLiveCount = "otel.sdk.span.live.count";
+static constexpr const char *descrMetricOtelSdkSpanLiveCount =
+    "The number of created spans for which the end operation has not been called yet";
+static constexpr const char *unitMetricOtelSdkSpanLiveCount = "{span}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricOtelSdkSpanLiveCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(
+      kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricOtelSdkSpanLiveCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(
+      kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricOtelSdkSpanLiveCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricOtelSdkSpanLiveCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricOtelSdkSpanLiveCount, descrMetricOtelSdkSpanLiveCount, unitMetricOtelSdkSpanLiveCount);
+}
+
+}  // namespace otel
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/process_metrics.h b/api/include/opentelemetry/semconv/process_metrics.h
new file mode 100644
index 0000000000..d76db55c9e
--- /dev/null
+++ b/api/include/opentelemetry/semconv/process_metrics.h
@@ -0,0 +1,458 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace process
+{
+
+/**
+ * Number of times the process has been context switched.
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricProcessContextSwitches = "process.context_switches";
+static constexpr const char *descrMetricProcessContextSwitches =
+    "Number of times the process has been context switched.";
+static constexpr const char *unitMetricProcessContextSwitches = "{context_switch}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricProcessContextSwitches(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricProcessContextSwitches,
+                                    descrMetricProcessContextSwitches,
+                                    unitMetricProcessContextSwitches);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricProcessContextSwitches(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricProcessContextSwitches,
+                                    descrMetricProcessContextSwitches,
+                                    unitMetricProcessContextSwitches);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricProcessContextSwitches(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricProcessContextSwitches,
+                                             descrMetricProcessContextSwitches,
+                                             unitMetricProcessContextSwitches);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricProcessContextSwitches(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricProcessContextSwitches,
+                                              descrMetricProcessContextSwitches,
+                                              unitMetricProcessContextSwitches);
+}
+
+/**
+ * Total CPU seconds broken down by different states.
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricProcessCpuTime = "process.cpu.time";
+static constexpr const char *descrMetricProcessCpuTime =
+    "Total CPU seconds broken down by different states.";
+static constexpr const char *unitMetricProcessCpuTime = "s";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricProcessCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricProcessCpuTime, descrMetricProcessCpuTime,
+                                    unitMetricProcessCpuTime);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricProcessCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricProcessCpuTime, descrMetricProcessCpuTime,
+                                    unitMetricProcessCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricProcessCpuTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricProcessCpuTime, descrMetricProcessCpuTime,
+                                             unitMetricProcessCpuTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricProcessCpuTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricProcessCpuTime, descrMetricProcessCpuTime,
+                                              unitMetricProcessCpuTime);
+}
+
+/**
+ * Difference in process.cpu.time since the last measurement, divided by the elapsed time and number
+ * of CPUs available to the process. <p> gauge
+ */
+static constexpr const char *kMetricProcessCpuUtilization = "process.cpu.utilization";
+static constexpr const char *descrMetricProcessCpuUtilization =
+    "Difference in process.cpu.time since the last measurement, divided by the elapsed time and "
+    "number of CPUs available to the process.";
+static constexpr const char *unitMetricProcessCpuUtilization = "1";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricProcessCpuUtilization(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricProcessCpuUtilization, descrMetricProcessCpuUtilization,
+                                 unitMetricProcessCpuUtilization);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricProcessCpuUtilization(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricProcessCpuUtilization, descrMetricProcessCpuUtilization,
+                                  unitMetricProcessCpuUtilization);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricProcessCpuUtilization(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricProcessCpuUtilization,
+                                           descrMetricProcessCpuUtilization,
+                                           unitMetricProcessCpuUtilization);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricProcessCpuUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricProcessCpuUtilization,
+                                            descrMetricProcessCpuUtilization,
+                                            unitMetricProcessCpuUtilization);
+}
+
+/**
+ * Disk bytes transferred.
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricProcessDiskIo     = "process.disk.io";
+static constexpr const char *descrMetricProcessDiskIo = "Disk bytes transferred.";
+static constexpr const char *unitMetricProcessDiskIo  = "By";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricProcessDiskIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricProcessDiskIo, descrMetricProcessDiskIo,
+                                    unitMetricProcessDiskIo);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricProcessDiskIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricProcessDiskIo, descrMetricProcessDiskIo,
+                                    unitMetricProcessDiskIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricProcessDiskIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricProcessDiskIo, descrMetricProcessDiskIo,
+                                             unitMetricProcessDiskIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricProcessDiskIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricProcessDiskIo, descrMetricProcessDiskIo,
+                                              unitMetricProcessDiskIo);
+}
+
+/**
+ * The amount of physical memory in use.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricProcessMemoryUsage = "process.memory.usage";
+static constexpr const char *descrMetricProcessMemoryUsage =
+    "The amount of physical memory in use.";
+static constexpr const char *unitMetricProcessMemoryUsage = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricProcessMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricProcessMemoryUsage, descrMetricProcessMemoryUsage,
+                                         unitMetricProcessMemoryUsage);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricProcessMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricProcessMemoryUsage, descrMetricProcessMemoryUsage,
+                                          unitMetricProcessMemoryUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricProcessMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricProcessMemoryUsage, descrMetricProcessMemoryUsage, unitMetricProcessMemoryUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricProcessMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricProcessMemoryUsage, descrMetricProcessMemoryUsage, unitMetricProcessMemoryUsage);
+}
+
+/**
+ * The amount of committed virtual memory.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricProcessMemoryVirtual = "process.memory.virtual";
+static constexpr const char *descrMetricProcessMemoryVirtual =
+    "The amount of committed virtual memory.";
+static constexpr const char *unitMetricProcessMemoryVirtual = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricProcessMemoryVirtual(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(
+      kMetricProcessMemoryVirtual, descrMetricProcessMemoryVirtual, unitMetricProcessMemoryVirtual);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricProcessMemoryVirtual(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(
+      kMetricProcessMemoryVirtual, descrMetricProcessMemoryVirtual, unitMetricProcessMemoryVirtual);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricProcessMemoryVirtual(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricProcessMemoryVirtual, descrMetricProcessMemoryVirtual, unitMetricProcessMemoryVirtual);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricProcessMemoryVirtual(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricProcessMemoryVirtual, descrMetricProcessMemoryVirtual, unitMetricProcessMemoryVirtual);
+}
+
+/**
+ * Network bytes transferred.
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricProcessNetworkIo     = "process.network.io";
+static constexpr const char *descrMetricProcessNetworkIo = "Network bytes transferred.";
+static constexpr const char *unitMetricProcessNetworkIo  = "By";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricProcessNetworkIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricProcessNetworkIo, descrMetricProcessNetworkIo,
+                                    unitMetricProcessNetworkIo);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricProcessNetworkIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricProcessNetworkIo, descrMetricProcessNetworkIo,
+                                    unitMetricProcessNetworkIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricProcessNetworkIo(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricProcessNetworkIo, descrMetricProcessNetworkIo,
+                                             unitMetricProcessNetworkIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricProcessNetworkIo(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricProcessNetworkIo, descrMetricProcessNetworkIo,
+                                              unitMetricProcessNetworkIo);
+}
+
+/**
+ * Number of file descriptors in use by the process.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricProcessOpenFileDescriptorCount =
+    "process.open_file_descriptor.count";
+static constexpr const char *descrMetricProcessOpenFileDescriptorCount =
+    "Number of file descriptors in use by the process.";
+static constexpr const char *unitMetricProcessOpenFileDescriptorCount = "{file_descriptor}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricProcessOpenFileDescriptorCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricProcessOpenFileDescriptorCount,
+                                         descrMetricProcessOpenFileDescriptorCount,
+                                         unitMetricProcessOpenFileDescriptorCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricProcessOpenFileDescriptorCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricProcessOpenFileDescriptorCount,
+                                          descrMetricProcessOpenFileDescriptorCount,
+                                          unitMetricProcessOpenFileDescriptorCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricProcessOpenFileDescriptorCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricProcessOpenFileDescriptorCount,
+                                                   descrMetricProcessOpenFileDescriptorCount,
+                                                   unitMetricProcessOpenFileDescriptorCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricProcessOpenFileDescriptorCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricProcessOpenFileDescriptorCount,
+                                                    descrMetricProcessOpenFileDescriptorCount,
+                                                    unitMetricProcessOpenFileDescriptorCount);
+}
+
+/**
+ * Number of page faults the process has made.
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricProcessPagingFaults = "process.paging.faults";
+static constexpr const char *descrMetricProcessPagingFaults =
+    "Number of page faults the process has made.";
+static constexpr const char *unitMetricProcessPagingFaults = "{fault}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricProcessPagingFaults(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricProcessPagingFaults, descrMetricProcessPagingFaults,
+                                    unitMetricProcessPagingFaults);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricProcessPagingFaults(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricProcessPagingFaults, descrMetricProcessPagingFaults,
+                                    unitMetricProcessPagingFaults);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricProcessPagingFaults(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricProcessPagingFaults, descrMetricProcessPagingFaults, unitMetricProcessPagingFaults);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricProcessPagingFaults(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricProcessPagingFaults, descrMetricProcessPagingFaults, unitMetricProcessPagingFaults);
+}
+
+/**
+ * Process threads count.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricProcessThreadCount     = "process.thread.count";
+static constexpr const char *descrMetricProcessThreadCount = "Process threads count.";
+static constexpr const char *unitMetricProcessThreadCount  = "{thread}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricProcessThreadCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricProcessThreadCount, descrMetricProcessThreadCount,
+                                         unitMetricProcessThreadCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricProcessThreadCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricProcessThreadCount, descrMetricProcessThreadCount,
+                                          unitMetricProcessThreadCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricProcessThreadCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricProcessThreadCount, descrMetricProcessThreadCount, unitMetricProcessThreadCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricProcessThreadCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricProcessThreadCount, descrMetricProcessThreadCount, unitMetricProcessThreadCount);
+}
+
+/**
+ * The time the process has been running.
+ * <p>
+ * Instrumentations SHOULD use a gauge with type @code double @endcode and measure uptime in seconds
+ * as a floating point number with the highest precision available. The actual accuracy would depend
+ * on the instrumentation and operating system. <p> gauge
+ */
+static constexpr const char *kMetricProcessUptime     = "process.uptime";
+static constexpr const char *descrMetricProcessUptime = "The time the process has been running.";
+static constexpr const char *unitMetricProcessUptime  = "s";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricProcessUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricProcessUptime, descrMetricProcessUptime,
+                                 unitMetricProcessUptime);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricProcessUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricProcessUptime, descrMetricProcessUptime,
+                                  unitMetricProcessUptime);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricProcessUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricProcessUptime, descrMetricProcessUptime,
+                                           unitMetricProcessUptime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricProcessUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricProcessUptime, descrMetricProcessUptime,
+                                            unitMetricProcessUptime);
+}
+
+}  // namespace process
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/rpc_metrics.h b/api/include/opentelemetry/semconv/rpc_metrics.h
new file mode 100644
index 0000000000..4996ebf859
--- /dev/null
+++ b/api/include/opentelemetry/semconv/rpc_metrics.h
@@ -0,0 +1,310 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace rpc
+{
+
+/**
+ * Measures the duration of outbound RPC.
+ * <p>
+ * While streaming RPCs may record this metric as start-of-batch
+ * to end-of-batch, it's hard to interpret in practice.
+ * <p>
+ * <strong>Streaming</strong>: N/A.
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricRpcClientDuration = "rpc.client.duration";
+static constexpr const char *descrMetricRpcClientDuration =
+    "Measures the duration of outbound RPC.";
+static constexpr const char *unitMetricRpcClientDuration = "ms";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricRpcClientDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricRpcClientDuration, descrMetricRpcClientDuration,
+                                      unitMetricRpcClientDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>> CreateSyncDoubleMetricRpcClientDuration(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricRpcClientDuration, descrMetricRpcClientDuration,
+                                      unitMetricRpcClientDuration);
+}
+
+/**
+ * Measures the size of RPC request messages (uncompressed).
+ * <p>
+ * <strong>Streaming</strong>: Recorded per message in a streaming batch
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricRpcClientRequestSize = "rpc.client.request.size";
+static constexpr const char *descrMetricRpcClientRequestSize =
+    "Measures the size of RPC request messages (uncompressed).";
+static constexpr const char *unitMetricRpcClientRequestSize = "By";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricRpcClientRequestSize(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricRpcClientRequestSize, descrMetricRpcClientRequestSize,
+                                      unitMetricRpcClientRequestSize);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricRpcClientRequestSize(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricRpcClientRequestSize, descrMetricRpcClientRequestSize,
+                                      unitMetricRpcClientRequestSize);
+}
+
+/**
+ * Measures the number of messages received per RPC.
+ * <p>
+ * Should be 1 for all non-streaming RPCs.
+ * <p>
+ * <strong>Streaming</strong>: This metric is required for server and client streaming RPCs
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricRpcClientRequestsPerRpc = "rpc.client.requests_per_rpc";
+static constexpr const char *descrMetricRpcClientRequestsPerRpc =
+    "Measures the number of messages received per RPC.";
+static constexpr const char *unitMetricRpcClientRequestsPerRpc = "{count}";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricRpcClientRequestsPerRpc(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricRpcClientRequestsPerRpc,
+                                      descrMetricRpcClientRequestsPerRpc,
+                                      unitMetricRpcClientRequestsPerRpc);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricRpcClientRequestsPerRpc(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricRpcClientRequestsPerRpc,
+                                      descrMetricRpcClientRequestsPerRpc,
+                                      unitMetricRpcClientRequestsPerRpc);
+}
+
+/**
+ * Measures the size of RPC response messages (uncompressed).
+ * <p>
+ * <strong>Streaming</strong>: Recorded per response in a streaming batch
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricRpcClientResponseSize = "rpc.client.response.size";
+static constexpr const char *descrMetricRpcClientResponseSize =
+    "Measures the size of RPC response messages (uncompressed).";
+static constexpr const char *unitMetricRpcClientResponseSize = "By";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricRpcClientResponseSize(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricRpcClientResponseSize,
+                                      descrMetricRpcClientResponseSize,
+                                      unitMetricRpcClientResponseSize);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricRpcClientResponseSize(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricRpcClientResponseSize,
+                                      descrMetricRpcClientResponseSize,
+                                      unitMetricRpcClientResponseSize);
+}
+
+/**
+ * Measures the number of messages sent per RPC.
+ * <p>
+ * Should be 1 for all non-streaming RPCs.
+ * <p>
+ * <strong>Streaming</strong>: This metric is required for server and client streaming RPCs
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricRpcClientResponsesPerRpc = "rpc.client.responses_per_rpc";
+static constexpr const char *descrMetricRpcClientResponsesPerRpc =
+    "Measures the number of messages sent per RPC.";
+static constexpr const char *unitMetricRpcClientResponsesPerRpc = "{count}";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricRpcClientResponsesPerRpc(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricRpcClientResponsesPerRpc,
+                                      descrMetricRpcClientResponsesPerRpc,
+                                      unitMetricRpcClientResponsesPerRpc);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricRpcClientResponsesPerRpc(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricRpcClientResponsesPerRpc,
+                                      descrMetricRpcClientResponsesPerRpc,
+                                      unitMetricRpcClientResponsesPerRpc);
+}
+
+/**
+ * Measures the duration of inbound RPC.
+ * <p>
+ * While streaming RPCs may record this metric as start-of-batch
+ * to end-of-batch, it's hard to interpret in practice.
+ * <p>
+ * <strong>Streaming</strong>: N/A.
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricRpcServerDuration     = "rpc.server.duration";
+static constexpr const char *descrMetricRpcServerDuration = "Measures the duration of inbound RPC.";
+static constexpr const char *unitMetricRpcServerDuration  = "ms";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricRpcServerDuration(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricRpcServerDuration, descrMetricRpcServerDuration,
+                                      unitMetricRpcServerDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>> CreateSyncDoubleMetricRpcServerDuration(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricRpcServerDuration, descrMetricRpcServerDuration,
+                                      unitMetricRpcServerDuration);
+}
+
+/**
+ * Measures the size of RPC request messages (uncompressed).
+ * <p>
+ * <strong>Streaming</strong>: Recorded per message in a streaming batch
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricRpcServerRequestSize = "rpc.server.request.size";
+static constexpr const char *descrMetricRpcServerRequestSize =
+    "Measures the size of RPC request messages (uncompressed).";
+static constexpr const char *unitMetricRpcServerRequestSize = "By";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricRpcServerRequestSize(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricRpcServerRequestSize, descrMetricRpcServerRequestSize,
+                                      unitMetricRpcServerRequestSize);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricRpcServerRequestSize(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricRpcServerRequestSize, descrMetricRpcServerRequestSize,
+                                      unitMetricRpcServerRequestSize);
+}
+
+/**
+ * Measures the number of messages received per RPC.
+ * <p>
+ * Should be 1 for all non-streaming RPCs.
+ * <p>
+ * <strong>Streaming</strong> : This metric is required for server and client streaming RPCs
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricRpcServerRequestsPerRpc = "rpc.server.requests_per_rpc";
+static constexpr const char *descrMetricRpcServerRequestsPerRpc =
+    "Measures the number of messages received per RPC.";
+static constexpr const char *unitMetricRpcServerRequestsPerRpc = "{count}";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricRpcServerRequestsPerRpc(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricRpcServerRequestsPerRpc,
+                                      descrMetricRpcServerRequestsPerRpc,
+                                      unitMetricRpcServerRequestsPerRpc);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricRpcServerRequestsPerRpc(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricRpcServerRequestsPerRpc,
+                                      descrMetricRpcServerRequestsPerRpc,
+                                      unitMetricRpcServerRequestsPerRpc);
+}
+
+/**
+ * Measures the size of RPC response messages (uncompressed).
+ * <p>
+ * <strong>Streaming</strong>: Recorded per response in a streaming batch
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricRpcServerResponseSize = "rpc.server.response.size";
+static constexpr const char *descrMetricRpcServerResponseSize =
+    "Measures the size of RPC response messages (uncompressed).";
+static constexpr const char *unitMetricRpcServerResponseSize = "By";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricRpcServerResponseSize(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricRpcServerResponseSize,
+                                      descrMetricRpcServerResponseSize,
+                                      unitMetricRpcServerResponseSize);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricRpcServerResponseSize(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricRpcServerResponseSize,
+                                      descrMetricRpcServerResponseSize,
+                                      unitMetricRpcServerResponseSize);
+}
+
+/**
+ * Measures the number of messages sent per RPC.
+ * <p>
+ * Should be 1 for all non-streaming RPCs.
+ * <p>
+ * <strong>Streaming</strong>: This metric is required for server and client streaming RPCs
+ * <p>
+ * histogram
+ */
+static constexpr const char *kMetricRpcServerResponsesPerRpc = "rpc.server.responses_per_rpc";
+static constexpr const char *descrMetricRpcServerResponsesPerRpc =
+    "Measures the number of messages sent per RPC.";
+static constexpr const char *unitMetricRpcServerResponsesPerRpc = "{count}";
+
+static inline nostd::unique_ptr<metrics::Histogram<uint64_t>>
+CreateSyncInt64MetricRpcServerResponsesPerRpc(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Histogram(kMetricRpcServerResponsesPerRpc,
+                                      descrMetricRpcServerResponsesPerRpc,
+                                      unitMetricRpcServerResponsesPerRpc);
+}
+
+static inline nostd::unique_ptr<metrics::Histogram<double>>
+CreateSyncDoubleMetricRpcServerResponsesPerRpc(metrics::Meter *meter)
+{
+  return meter->CreateDoubleHistogram(kMetricRpcServerResponsesPerRpc,
+                                      descrMetricRpcServerResponsesPerRpc,
+                                      unitMetricRpcServerResponsesPerRpc);
+}
+
+}  // namespace rpc
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/schema_url.h b/api/include/opentelemetry/semconv/schema_url.h
index 79bd51c0dc..34902e0416 100644
--- a/api/include/opentelemetry/semconv/schema_url.h
+++ b/api/include/opentelemetry/semconv/schema_url.h
@@ -19,6 +19,6 @@ namespace semconv
 /**
  * The URL of the OpenTelemetry schema for these keys and values.
  */
-static constexpr const char *kSchemaUrl = "https://opentelemetry.io/schemas/1.30.0";
+static constexpr const char *kSchemaUrl = "https://opentelemetry.io/schemas/1.31.0";
 }  // namespace semconv
 OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/system_metrics.h b/api/include/opentelemetry/semconv/system_metrics.h
new file mode 100644
index 0000000000..a985dac901
--- /dev/null
+++ b/api/include/opentelemetry/semconv/system_metrics.h
@@ -0,0 +1,1339 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace system
+{
+
+/**
+ * Deprecated. Use @code cpu.frequency @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code cpu.frequency @endcode.", "reason": "uncategorized"}
+ * <p>
+ * gauge
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricSystemCpuFrequency =
+    "system.cpu.frequency";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricSystemCpuFrequency =
+    "Deprecated. Use `cpu.frequency` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricSystemCpuFrequency = "{Hz}";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
+CreateSyncInt64MetricSystemCpuFrequency(metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency,
+                                 unitMetricSystemCpuFrequency);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Gauge<double>>
+CreateSyncDoubleMetricSystemCpuFrequency(metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency,
+                                  unitMetricSystemCpuFrequency);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemCpuFrequency(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency,
+                                           unitMetricSystemCpuFrequency);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemCpuFrequency(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(
+      kMetricSystemCpuFrequency, descrMetricSystemCpuFrequency, unitMetricSystemCpuFrequency);
+}
+
+/**
+ * Reports the number of logical (virtual) processor cores created by the operating system to manage
+ * multitasking <p> Calculated by multiplying the number of sockets by the number of cores per
+ * socket, and then by the number of threads per core <p> updowncounter
+ */
+static constexpr const char *kMetricSystemCpuLogicalCount = "system.cpu.logical.count";
+static constexpr const char *descrMetricSystemCpuLogicalCount =
+    "Reports the number of logical (virtual) processor cores created by the operating system to "
+    "manage multitasking";
+static constexpr const char *unitMetricSystemCpuLogicalCount = "{cpu}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemCpuLogicalCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemCpuLogicalCount,
+                                         descrMetricSystemCpuLogicalCount,
+                                         unitMetricSystemCpuLogicalCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemCpuLogicalCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemCpuLogicalCount,
+                                          descrMetricSystemCpuLogicalCount,
+                                          unitMetricSystemCpuLogicalCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemCpuLogicalCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemCpuLogicalCount,
+                                                   descrMetricSystemCpuLogicalCount,
+                                                   unitMetricSystemCpuLogicalCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemCpuLogicalCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemCpuLogicalCount,
+                                                    descrMetricSystemCpuLogicalCount,
+                                                    unitMetricSystemCpuLogicalCount);
+}
+
+/**
+ * Reports the number of actual physical processor cores on the hardware
+ * <p>
+ * Calculated by multiplying the number of sockets by the number of cores per socket
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricSystemCpuPhysicalCount = "system.cpu.physical.count";
+static constexpr const char *descrMetricSystemCpuPhysicalCount =
+    "Reports the number of actual physical processor cores on the hardware";
+static constexpr const char *unitMetricSystemCpuPhysicalCount = "{cpu}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemCpuPhysicalCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemCpuPhysicalCount,
+                                         descrMetricSystemCpuPhysicalCount,
+                                         unitMetricSystemCpuPhysicalCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemCpuPhysicalCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemCpuPhysicalCount,
+                                          descrMetricSystemCpuPhysicalCount,
+                                          unitMetricSystemCpuPhysicalCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemCpuPhysicalCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemCpuPhysicalCount,
+                                                   descrMetricSystemCpuPhysicalCount,
+                                                   unitMetricSystemCpuPhysicalCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemCpuPhysicalCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemCpuPhysicalCount,
+                                                    descrMetricSystemCpuPhysicalCount,
+                                                    unitMetricSystemCpuPhysicalCount);
+}
+
+/**
+ * Deprecated. Use @code cpu.time @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code cpu.time @endcode.", "reason": "uncategorized"}
+ * <p>
+ * counter
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricSystemCpuTime = "system.cpu.time";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricSystemCpuTime =
+    "Deprecated. Use `cpu.time` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricSystemCpuTime = "s";
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricSystemCpuTime(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
+                                    unitMetricSystemCpuTime);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricSystemCpuTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
+                                    unitMetricSystemCpuTime);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemCpuTime(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
+                                             unitMetricSystemCpuTime);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemCpuTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricSystemCpuTime, descrMetricSystemCpuTime,
+                                              unitMetricSystemCpuTime);
+}
+
+/**
+ * Deprecated. Use @code cpu.utilization @endcode instead.
+ *
+ * @deprecated
+ * {"note": "Replaced by @code cpu.utilization @endcode.", "reason": "uncategorized"}
+ * <p>
+ * gauge
+ */
+OPENTELEMETRY_DEPRECATED static constexpr const char *kMetricSystemCpuUtilization =
+    "system.cpu.utilization";
+OPENTELEMETRY_DEPRECATED static constexpr const char *descrMetricSystemCpuUtilization =
+    "Deprecated. Use `cpu.utilization` instead.";
+OPENTELEMETRY_DEPRECATED static constexpr const char *unitMetricSystemCpuUtilization = "1";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
+CreateSyncInt64MetricSystemCpuUtilization(metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization,
+                                 unitMetricSystemCpuUtilization);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::unique_ptr<metrics::Gauge<double>>
+CreateSyncDoubleMetricSystemCpuUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization,
+                                  unitMetricSystemCpuUtilization);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemCpuUtilization(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(
+      kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization, unitMetricSystemCpuUtilization);
+}
+
+OPENTELEMETRY_DEPRECATED static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemCpuUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(
+      kMetricSystemCpuUtilization, descrMetricSystemCpuUtilization, unitMetricSystemCpuUtilization);
+}
+
+/**
+ * counter
+ */
+static constexpr const char *kMetricSystemDiskIo     = "system.disk.io";
+static constexpr const char *descrMetricSystemDiskIo = "";
+static constexpr const char *unitMetricSystemDiskIo  = "By";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemDiskIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemDiskIo, descrMetricSystemDiskIo,
+                                    unitMetricSystemDiskIo);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemDiskIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemDiskIo, descrMetricSystemDiskIo,
+                                    unitMetricSystemDiskIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricSystemDiskIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricSystemDiskIo, descrMetricSystemDiskIo,
+                                             unitMetricSystemDiskIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricSystemDiskIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricSystemDiskIo, descrMetricSystemDiskIo,
+                                              unitMetricSystemDiskIo);
+}
+
+/**
+ * Time disk spent activated
+ * <p>
+ * The real elapsed time ("wall clock") used in the I/O path (time from operations running in
+ * parallel are not counted). Measured as: <ul> <li>Linux: Field 13 from <a
+ * href="https://www.kernel.org/doc/Documentation/ABI/testing/procfs-diskstats">procfs-diskstats</a></li>
+ *   <li>Windows: The complement of
+ * <a
+ * href="https://learn.microsoft.com/archive/blogs/askcore/windows-performance-monitor-disk-counters-explained#windows-performance-monitor-disk-counters-explained">"Disk%
+ * Idle Time"</a> performance counter: @code uptime * (100 - "Disk\% Idle Time") / 100 @endcode</li>
+ * </ul>
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricSystemDiskIoTime     = "system.disk.io_time";
+static constexpr const char *descrMetricSystemDiskIoTime = "Time disk spent activated";
+static constexpr const char *unitMetricSystemDiskIoTime  = "s";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemDiskIoTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemDiskIoTime, descrMetricSystemDiskIoTime,
+                                    unitMetricSystemDiskIoTime);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemDiskIoTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemDiskIoTime, descrMetricSystemDiskIoTime,
+                                    unitMetricSystemDiskIoTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemDiskIoTime(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricSystemDiskIoTime, descrMetricSystemDiskIoTime,
+                                             unitMetricSystemDiskIoTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemDiskIoTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricSystemDiskIoTime, descrMetricSystemDiskIoTime,
+                                              unitMetricSystemDiskIoTime);
+}
+
+/**
+ * The total storage capacity of the disk
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricSystemDiskLimit     = "system.disk.limit";
+static constexpr const char *descrMetricSystemDiskLimit = "The total storage capacity of the disk";
+static constexpr const char *unitMetricSystemDiskLimit  = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemDiskLimit(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemDiskLimit, descrMetricSystemDiskLimit,
+                                         unitMetricSystemDiskLimit);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemDiskLimit(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemDiskLimit, descrMetricSystemDiskLimit,
+                                          unitMetricSystemDiskLimit);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemDiskLimit(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricSystemDiskLimit, descrMetricSystemDiskLimit, unitMetricSystemDiskLimit);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemDiskLimit(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricSystemDiskLimit, descrMetricSystemDiskLimit, unitMetricSystemDiskLimit);
+}
+
+/**
+ * counter
+ */
+static constexpr const char *kMetricSystemDiskMerged     = "system.disk.merged";
+static constexpr const char *descrMetricSystemDiskMerged = "";
+static constexpr const char *unitMetricSystemDiskMerged  = "{operation}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemDiskMerged(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemDiskMerged, descrMetricSystemDiskMerged,
+                                    unitMetricSystemDiskMerged);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemDiskMerged(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemDiskMerged, descrMetricSystemDiskMerged,
+                                    unitMetricSystemDiskMerged);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemDiskMerged(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricSystemDiskMerged, descrMetricSystemDiskMerged,
+                                             unitMetricSystemDiskMerged);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemDiskMerged(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricSystemDiskMerged, descrMetricSystemDiskMerged,
+                                              unitMetricSystemDiskMerged);
+}
+
+/**
+ * Sum of the time each operation took to complete
+ * <p>
+ * Because it is the sum of time each request took, parallel-issued requests each contribute to make
+ * the count grow. Measured as: <ul> <li>Linux: Fields 7 & 11 from <a
+ * href="https://www.kernel.org/doc/Documentation/ABI/testing/procfs-diskstats">procfs-diskstats</a></li>
+ *   <li>Windows: "Avg. Disk sec/Read" perf counter multiplied by "Disk Reads/sec" perf counter
+ * (similar for Writes)</li>
+ * </ul>
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricSystemDiskOperationTime = "system.disk.operation_time";
+static constexpr const char *descrMetricSystemDiskOperationTime =
+    "Sum of the time each operation took to complete";
+static constexpr const char *unitMetricSystemDiskOperationTime = "s";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricSystemDiskOperationTime(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemDiskOperationTime,
+                                    descrMetricSystemDiskOperationTime,
+                                    unitMetricSystemDiskOperationTime);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricSystemDiskOperationTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemDiskOperationTime,
+                                    descrMetricSystemDiskOperationTime,
+                                    unitMetricSystemDiskOperationTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemDiskOperationTime(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricSystemDiskOperationTime,
+                                             descrMetricSystemDiskOperationTime,
+                                             unitMetricSystemDiskOperationTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemDiskOperationTime(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricSystemDiskOperationTime,
+                                              descrMetricSystemDiskOperationTime,
+                                              unitMetricSystemDiskOperationTime);
+}
+
+/**
+ * counter
+ */
+static constexpr const char *kMetricSystemDiskOperations     = "system.disk.operations";
+static constexpr const char *descrMetricSystemDiskOperations = "";
+static constexpr const char *unitMetricSystemDiskOperations  = "{operation}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricSystemDiskOperations(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemDiskOperations, descrMetricSystemDiskOperations,
+                                    unitMetricSystemDiskOperations);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricSystemDiskOperations(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemDiskOperations, descrMetricSystemDiskOperations,
+                                    unitMetricSystemDiskOperations);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemDiskOperations(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricSystemDiskOperations, descrMetricSystemDiskOperations, unitMetricSystemDiskOperations);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemDiskOperations(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricSystemDiskOperations, descrMetricSystemDiskOperations, unitMetricSystemDiskOperations);
+}
+
+/**
+ * The total storage capacity of the filesystem
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricSystemFilesystemLimit = "system.filesystem.limit";
+static constexpr const char *descrMetricSystemFilesystemLimit =
+    "The total storage capacity of the filesystem";
+static constexpr const char *unitMetricSystemFilesystemLimit = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemFilesystemLimit(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemFilesystemLimit,
+                                         descrMetricSystemFilesystemLimit,
+                                         unitMetricSystemFilesystemLimit);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemFilesystemLimit(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemFilesystemLimit,
+                                          descrMetricSystemFilesystemLimit,
+                                          unitMetricSystemFilesystemLimit);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemFilesystemLimit(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemFilesystemLimit,
+                                                   descrMetricSystemFilesystemLimit,
+                                                   unitMetricSystemFilesystemLimit);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemFilesystemLimit(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemFilesystemLimit,
+                                                    descrMetricSystemFilesystemLimit,
+                                                    unitMetricSystemFilesystemLimit);
+}
+
+/**
+ * Reports a filesystem's space usage across different states.
+ * <p>
+ * The sum of all @code system.filesystem.usage @endcode values over the different @code
+ * system.filesystem.state @endcode attributes SHOULD equal the total storage capacity of the
+ * filesystem, that is @code system.filesystem.limit @endcode. <p> updowncounter
+ */
+static constexpr const char *kMetricSystemFilesystemUsage = "system.filesystem.usage";
+static constexpr const char *descrMetricSystemFilesystemUsage =
+    "Reports a filesystem's space usage across different states.";
+static constexpr const char *unitMetricSystemFilesystemUsage = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemFilesystemUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemFilesystemUsage,
+                                         descrMetricSystemFilesystemUsage,
+                                         unitMetricSystemFilesystemUsage);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemFilesystemUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemFilesystemUsage,
+                                          descrMetricSystemFilesystemUsage,
+                                          unitMetricSystemFilesystemUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemFilesystemUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemFilesystemUsage,
+                                                   descrMetricSystemFilesystemUsage,
+                                                   unitMetricSystemFilesystemUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemFilesystemUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemFilesystemUsage,
+                                                    descrMetricSystemFilesystemUsage,
+                                                    unitMetricSystemFilesystemUsage);
+}
+
+/**
+ * gauge
+ */
+static constexpr const char *kMetricSystemFilesystemUtilization = "system.filesystem.utilization";
+static constexpr const char *descrMetricSystemFilesystemUtilization = "";
+static constexpr const char *unitMetricSystemFilesystemUtilization  = "1";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
+CreateSyncInt64MetricSystemFilesystemUtilization(metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricSystemFilesystemUtilization,
+                                 descrMetricSystemFilesystemUtilization,
+                                 unitMetricSystemFilesystemUtilization);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>>
+CreateSyncDoubleMetricSystemFilesystemUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricSystemFilesystemUtilization,
+                                  descrMetricSystemFilesystemUtilization,
+                                  unitMetricSystemFilesystemUtilization);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemFilesystemUtilization(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricSystemFilesystemUtilization,
+                                           descrMetricSystemFilesystemUtilization,
+                                           unitMetricSystemFilesystemUtilization);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemFilesystemUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricSystemFilesystemUtilization,
+                                            descrMetricSystemFilesystemUtilization,
+                                            unitMetricSystemFilesystemUtilization);
+}
+
+/**
+ * An estimate of how much memory is available for starting new applications, without causing
+ * swapping <p> This is an alternative to @code system.memory.usage @endcode metric with @code
+ * state=free @endcode. Linux starting from 3.14 exports "available" memory. It takes "free" memory
+ * as a baseline, and then factors in kernel-specific values. This is supposed to be more accurate
+ * than just "free" memory. For reference, see the calculations <a
+ * href="https://superuser.com/a/980821">here</a>. See also @code MemAvailable @endcode in <a
+ * href="https://man7.org/linux/man-pages/man5/proc.5.html">/proc/meminfo</a>. <p> updowncounter
+ */
+static constexpr const char *kMetricSystemLinuxMemoryAvailable = "system.linux.memory.available";
+static constexpr const char *descrMetricSystemLinuxMemoryAvailable =
+    "An estimate of how much memory is available for starting new applications, without causing "
+    "swapping";
+static constexpr const char *unitMetricSystemLinuxMemoryAvailable = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemLinuxMemoryAvailable(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemLinuxMemoryAvailable,
+                                         descrMetricSystemLinuxMemoryAvailable,
+                                         unitMetricSystemLinuxMemoryAvailable);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemLinuxMemoryAvailable(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemLinuxMemoryAvailable,
+                                          descrMetricSystemLinuxMemoryAvailable,
+                                          unitMetricSystemLinuxMemoryAvailable);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemLinuxMemoryAvailable(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemLinuxMemoryAvailable,
+                                                   descrMetricSystemLinuxMemoryAvailable,
+                                                   unitMetricSystemLinuxMemoryAvailable);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemLinuxMemoryAvailable(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemLinuxMemoryAvailable,
+                                                    descrMetricSystemLinuxMemoryAvailable,
+                                                    unitMetricSystemLinuxMemoryAvailable);
+}
+
+/**
+ * Reports the memory used by the Linux kernel for managing caches of frequently used objects.
+ * <p>
+ * The sum over the @code reclaimable @endcode and @code unreclaimable @endcode state values in
+ * @code linux.memory.slab.usage @endcode SHOULD be equal to the total slab memory available on the
+ * system. Note that the total slab memory is not constant and may vary over time. See also the <a
+ * href="https://blogs.oracle.com/linux/post/understanding-linux-kernel-memory-statistics">Slab
+ * allocator</a> and @code Slab @endcode in <a
+ * href="https://man7.org/linux/man-pages/man5/proc.5.html">/proc/meminfo</a>. <p> updowncounter
+ */
+static constexpr const char *kMetricSystemLinuxMemorySlabUsage = "system.linux.memory.slab.usage";
+static constexpr const char *descrMetricSystemLinuxMemorySlabUsage =
+    "Reports the memory used by the Linux kernel for managing caches of frequently used objects.";
+static constexpr const char *unitMetricSystemLinuxMemorySlabUsage = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemLinuxMemorySlabUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemLinuxMemorySlabUsage,
+                                         descrMetricSystemLinuxMemorySlabUsage,
+                                         unitMetricSystemLinuxMemorySlabUsage);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemLinuxMemorySlabUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemLinuxMemorySlabUsage,
+                                          descrMetricSystemLinuxMemorySlabUsage,
+                                          unitMetricSystemLinuxMemorySlabUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemLinuxMemorySlabUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemLinuxMemorySlabUsage,
+                                                   descrMetricSystemLinuxMemorySlabUsage,
+                                                   unitMetricSystemLinuxMemorySlabUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemLinuxMemorySlabUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemLinuxMemorySlabUsage,
+                                                    descrMetricSystemLinuxMemorySlabUsage,
+                                                    unitMetricSystemLinuxMemorySlabUsage);
+}
+
+/**
+ * Total memory available in the system.
+ * <p>
+ * Its value SHOULD equal the sum of @code system.memory.state @endcode over all states.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricSystemMemoryLimit     = "system.memory.limit";
+static constexpr const char *descrMetricSystemMemoryLimit = "Total memory available in the system.";
+static constexpr const char *unitMetricSystemMemoryLimit  = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemMemoryLimit(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemMemoryLimit, descrMetricSystemMemoryLimit,
+                                         unitMetricSystemMemoryLimit);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemMemoryLimit(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemMemoryLimit, descrMetricSystemMemoryLimit,
+                                          unitMetricSystemMemoryLimit);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemMemoryLimit(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricSystemMemoryLimit, descrMetricSystemMemoryLimit, unitMetricSystemMemoryLimit);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemMemoryLimit(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricSystemMemoryLimit, descrMetricSystemMemoryLimit, unitMetricSystemMemoryLimit);
+}
+
+/**
+ * Shared memory used (mostly by tmpfs).
+ * <p>
+ * Equivalent of @code shared @endcode from <a
+ * href="https://man7.org/linux/man-pages/man1/free.1.html">@code free @endcode command</a> or
+ * @code Shmem @endcode from <a href="https://man7.org/linux/man-pages/man5/proc.5.html">@code
+ * /proc/meminfo @endcode</a>" <p> updowncounter
+ */
+static constexpr const char *kMetricSystemMemoryShared = "system.memory.shared";
+static constexpr const char *descrMetricSystemMemoryShared =
+    "Shared memory used (mostly by tmpfs).";
+static constexpr const char *unitMetricSystemMemoryShared = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemMemoryShared(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemMemoryShared, descrMetricSystemMemoryShared,
+                                         unitMetricSystemMemoryShared);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemMemoryShared(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemMemoryShared, descrMetricSystemMemoryShared,
+                                          unitMetricSystemMemoryShared);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemMemoryShared(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricSystemMemoryShared, descrMetricSystemMemoryShared, unitMetricSystemMemoryShared);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemMemoryShared(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricSystemMemoryShared, descrMetricSystemMemoryShared, unitMetricSystemMemoryShared);
+}
+
+/**
+ * Reports memory in use by state.
+ * <p>
+ * The sum over all @code system.memory.state @endcode values SHOULD equal the total memory
+ * available on the system, that is @code system.memory.limit @endcode.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricSystemMemoryUsage     = "system.memory.usage";
+static constexpr const char *descrMetricSystemMemoryUsage = "Reports memory in use by state.";
+static constexpr const char *unitMetricSystemMemoryUsage  = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemMemoryUsage, descrMetricSystemMemoryUsage,
+                                         unitMetricSystemMemoryUsage);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemMemoryUsage, descrMetricSystemMemoryUsage,
+                                          unitMetricSystemMemoryUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricSystemMemoryUsage, descrMetricSystemMemoryUsage, unitMetricSystemMemoryUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemMemoryUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricSystemMemoryUsage, descrMetricSystemMemoryUsage, unitMetricSystemMemoryUsage);
+}
+
+/**
+ * gauge
+ */
+static constexpr const char *kMetricSystemMemoryUtilization     = "system.memory.utilization";
+static constexpr const char *descrMetricSystemMemoryUtilization = "";
+static constexpr const char *unitMetricSystemMemoryUtilization  = "1";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
+CreateSyncInt64MetricSystemMemoryUtilization(metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricSystemMemoryUtilization, descrMetricSystemMemoryUtilization,
+                                 unitMetricSystemMemoryUtilization);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>>
+CreateSyncDoubleMetricSystemMemoryUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricSystemMemoryUtilization,
+                                  descrMetricSystemMemoryUtilization,
+                                  unitMetricSystemMemoryUtilization);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemMemoryUtilization(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricSystemMemoryUtilization,
+                                           descrMetricSystemMemoryUtilization,
+                                           unitMetricSystemMemoryUtilization);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemMemoryUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricSystemMemoryUtilization,
+                                            descrMetricSystemMemoryUtilization,
+                                            unitMetricSystemMemoryUtilization);
+}
+
+/**
+ * updowncounter
+ */
+static constexpr const char *kMetricSystemNetworkConnections     = "system.network.connections";
+static constexpr const char *descrMetricSystemNetworkConnections = "";
+static constexpr const char *unitMetricSystemNetworkConnections  = "{connection}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemNetworkConnections(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemNetworkConnections,
+                                         descrMetricSystemNetworkConnections,
+                                         unitMetricSystemNetworkConnections);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemNetworkConnections(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemNetworkConnections,
+                                          descrMetricSystemNetworkConnections,
+                                          unitMetricSystemNetworkConnections);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemNetworkConnections(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricSystemNetworkConnections,
+                                                   descrMetricSystemNetworkConnections,
+                                                   unitMetricSystemNetworkConnections);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemNetworkConnections(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricSystemNetworkConnections,
+                                                    descrMetricSystemNetworkConnections,
+                                                    unitMetricSystemNetworkConnections);
+}
+
+/**
+ * Count of packets that are dropped or discarded even though there was no error
+ * <p>
+ * Measured as:
+ * <ul>
+ *   <li>Linux: the @code drop @endcode column in @code /proc/dev/net @endcode (<a
+ * href="https://web.archive.org/web/20180321091318/http://www.onlamp.com/pub/a/linux/2000/11/16/LinuxAdmin.html">source</a>)</li>
+ *   <li>Windows: <a
+ * href="https://docs.microsoft.com/windows/win32/api/netioapi/ns-netioapi-mib_if_row2">@code
+ * InDiscards @endcode/@code OutDiscards @endcode</a> from <a
+ * href="https://docs.microsoft.com/windows/win32/api/netioapi/nf-netioapi-getifentry2">@code
+ * GetIfEntry2 @endcode</a></li>
+ * </ul>
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricSystemNetworkDropped = "system.network.dropped";
+static constexpr const char *descrMetricSystemNetworkDropped =
+    "Count of packets that are dropped or discarded even though there was no error";
+static constexpr const char *unitMetricSystemNetworkDropped = "{packet}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricSystemNetworkDropped(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemNetworkDropped, descrMetricSystemNetworkDropped,
+                                    unitMetricSystemNetworkDropped);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricSystemNetworkDropped(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemNetworkDropped, descrMetricSystemNetworkDropped,
+                                    unitMetricSystemNetworkDropped);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemNetworkDropped(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricSystemNetworkDropped, descrMetricSystemNetworkDropped, unitMetricSystemNetworkDropped);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemNetworkDropped(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricSystemNetworkDropped, descrMetricSystemNetworkDropped, unitMetricSystemNetworkDropped);
+}
+
+/**
+ * Count of network errors detected
+ * <p>
+ * Measured as:
+ * <ul>
+ *   <li>Linux: the @code errs @endcode column in @code /proc/dev/net @endcode (<a
+ * href="https://web.archive.org/web/20180321091318/http://www.onlamp.com/pub/a/linux/2000/11/16/LinuxAdmin.html">source</a>).</li>
+ *   <li>Windows: <a
+ * href="https://docs.microsoft.com/windows/win32/api/netioapi/ns-netioapi-mib_if_row2">@code
+ * InErrors @endcode/@code OutErrors @endcode</a> from <a
+ * href="https://docs.microsoft.com/windows/win32/api/netioapi/nf-netioapi-getifentry2">@code
+ * GetIfEntry2 @endcode</a>.</li>
+ * </ul>
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricSystemNetworkErrors     = "system.network.errors";
+static constexpr const char *descrMetricSystemNetworkErrors = "Count of network errors detected";
+static constexpr const char *unitMetricSystemNetworkErrors  = "{error}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricSystemNetworkErrors(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemNetworkErrors, descrMetricSystemNetworkErrors,
+                                    unitMetricSystemNetworkErrors);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemNetworkErrors(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemNetworkErrors, descrMetricSystemNetworkErrors,
+                                    unitMetricSystemNetworkErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemNetworkErrors(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricSystemNetworkErrors, descrMetricSystemNetworkErrors, unitMetricSystemNetworkErrors);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemNetworkErrors(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricSystemNetworkErrors, descrMetricSystemNetworkErrors, unitMetricSystemNetworkErrors);
+}
+
+/**
+ * counter
+ */
+static constexpr const char *kMetricSystemNetworkIo     = "system.network.io";
+static constexpr const char *descrMetricSystemNetworkIo = "";
+static constexpr const char *unitMetricSystemNetworkIo  = "By";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemNetworkIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemNetworkIo, descrMetricSystemNetworkIo,
+                                    unitMetricSystemNetworkIo);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemNetworkIo(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemNetworkIo, descrMetricSystemNetworkIo,
+                                    unitMetricSystemNetworkIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemNetworkIo(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricSystemNetworkIo, descrMetricSystemNetworkIo,
+                                             unitMetricSystemNetworkIo);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemNetworkIo(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricSystemNetworkIo, descrMetricSystemNetworkIo,
+                                              unitMetricSystemNetworkIo);
+}
+
+/**
+ * counter
+ */
+static constexpr const char *kMetricSystemNetworkPackets     = "system.network.packets";
+static constexpr const char *descrMetricSystemNetworkPackets = "";
+static constexpr const char *unitMetricSystemNetworkPackets  = "{packet}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricSystemNetworkPackets(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemNetworkPackets, descrMetricSystemNetworkPackets,
+                                    unitMetricSystemNetworkPackets);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricSystemNetworkPackets(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemNetworkPackets, descrMetricSystemNetworkPackets,
+                                    unitMetricSystemNetworkPackets);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemNetworkPackets(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricSystemNetworkPackets, descrMetricSystemNetworkPackets, unitMetricSystemNetworkPackets);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemNetworkPackets(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricSystemNetworkPackets, descrMetricSystemNetworkPackets, unitMetricSystemNetworkPackets);
+}
+
+/**
+ * counter
+ */
+static constexpr const char *kMetricSystemPagingFaults     = "system.paging.faults";
+static constexpr const char *descrMetricSystemPagingFaults = "";
+static constexpr const char *unitMetricSystemPagingFaults  = "{fault}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>> CreateSyncInt64MetricSystemPagingFaults(
+    metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemPagingFaults, descrMetricSystemPagingFaults,
+                                    unitMetricSystemPagingFaults);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>> CreateSyncDoubleMetricSystemPagingFaults(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemPagingFaults, descrMetricSystemPagingFaults,
+                                    unitMetricSystemPagingFaults);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemPagingFaults(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricSystemPagingFaults, descrMetricSystemPagingFaults, unitMetricSystemPagingFaults);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemPagingFaults(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricSystemPagingFaults, descrMetricSystemPagingFaults, unitMetricSystemPagingFaults);
+}
+
+/**
+ * counter
+ */
+static constexpr const char *kMetricSystemPagingOperations     = "system.paging.operations";
+static constexpr const char *descrMetricSystemPagingOperations = "";
+static constexpr const char *unitMetricSystemPagingOperations  = "{operation}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricSystemPagingOperations(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemPagingOperations,
+                                    descrMetricSystemPagingOperations,
+                                    unitMetricSystemPagingOperations);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricSystemPagingOperations(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemPagingOperations,
+                                    descrMetricSystemPagingOperations,
+                                    unitMetricSystemPagingOperations);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemPagingOperations(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(kMetricSystemPagingOperations,
+                                             descrMetricSystemPagingOperations,
+                                             unitMetricSystemPagingOperations);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemPagingOperations(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(kMetricSystemPagingOperations,
+                                              descrMetricSystemPagingOperations,
+                                              unitMetricSystemPagingOperations);
+}
+
+/**
+ * Unix swap or windows pagefile usage
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricSystemPagingUsage     = "system.paging.usage";
+static constexpr const char *descrMetricSystemPagingUsage = "Unix swap or windows pagefile usage";
+static constexpr const char *unitMetricSystemPagingUsage  = "By";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemPagingUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemPagingUsage, descrMetricSystemPagingUsage,
+                                         unitMetricSystemPagingUsage);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemPagingUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemPagingUsage, descrMetricSystemPagingUsage,
+                                          unitMetricSystemPagingUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemPagingUsage(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricSystemPagingUsage, descrMetricSystemPagingUsage, unitMetricSystemPagingUsage);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemPagingUsage(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricSystemPagingUsage, descrMetricSystemPagingUsage, unitMetricSystemPagingUsage);
+}
+
+/**
+ * gauge
+ */
+static constexpr const char *kMetricSystemPagingUtilization     = "system.paging.utilization";
+static constexpr const char *descrMetricSystemPagingUtilization = "";
+static constexpr const char *unitMetricSystemPagingUtilization  = "1";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
+CreateSyncInt64MetricSystemPagingUtilization(metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricSystemPagingUtilization, descrMetricSystemPagingUtilization,
+                                 unitMetricSystemPagingUtilization);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>>
+CreateSyncDoubleMetricSystemPagingUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricSystemPagingUtilization,
+                                  descrMetricSystemPagingUtilization,
+                                  unitMetricSystemPagingUtilization);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemPagingUtilization(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricSystemPagingUtilization,
+                                           descrMetricSystemPagingUtilization,
+                                           unitMetricSystemPagingUtilization);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemPagingUtilization(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricSystemPagingUtilization,
+                                            descrMetricSystemPagingUtilization,
+                                            unitMetricSystemPagingUtilization);
+}
+
+/**
+ * Total number of processes in each state
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricSystemProcessCount = "system.process.count";
+static constexpr const char *descrMetricSystemProcessCount =
+    "Total number of processes in each state";
+static constexpr const char *unitMetricSystemProcessCount = "{process}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricSystemProcessCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricSystemProcessCount, descrMetricSystemProcessCount,
+                                         unitMetricSystemProcessCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricSystemProcessCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricSystemProcessCount, descrMetricSystemProcessCount,
+                                          unitMetricSystemProcessCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemProcessCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricSystemProcessCount, descrMetricSystemProcessCount, unitMetricSystemProcessCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemProcessCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricSystemProcessCount, descrMetricSystemProcessCount, unitMetricSystemProcessCount);
+}
+
+/**
+ * Total number of processes created over uptime of the host
+ * <p>
+ * counter
+ */
+static constexpr const char *kMetricSystemProcessCreated = "system.process.created";
+static constexpr const char *descrMetricSystemProcessCreated =
+    "Total number of processes created over uptime of the host";
+static constexpr const char *unitMetricSystemProcessCreated = "{process}";
+
+static inline nostd::unique_ptr<metrics::Counter<uint64_t>>
+CreateSyncInt64MetricSystemProcessCreated(metrics::Meter *meter)
+{
+  return meter->CreateUInt64Counter(kMetricSystemProcessCreated, descrMetricSystemProcessCreated,
+                                    unitMetricSystemProcessCreated);
+}
+
+static inline nostd::unique_ptr<metrics::Counter<double>>
+CreateSyncDoubleMetricSystemProcessCreated(metrics::Meter *meter)
+{
+  return meter->CreateDoubleCounter(kMetricSystemProcessCreated, descrMetricSystemProcessCreated,
+                                    unitMetricSystemProcessCreated);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricSystemProcessCreated(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableCounter(
+      kMetricSystemProcessCreated, descrMetricSystemProcessCreated, unitMetricSystemProcessCreated);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricSystemProcessCreated(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableCounter(
+      kMetricSystemProcessCreated, descrMetricSystemProcessCreated, unitMetricSystemProcessCreated);
+}
+
+/**
+ * The time the system has been running
+ * <p>
+ * Instrumentations SHOULD use a gauge with type @code double @endcode and measure uptime in seconds
+ * as a floating point number with the highest precision available. The actual accuracy would depend
+ * on the instrumentation and operating system. <p> gauge
+ */
+static constexpr const char *kMetricSystemUptime     = "system.uptime";
+static constexpr const char *descrMetricSystemUptime = "The time the system has been running";
+static constexpr const char *unitMetricSystemUptime  = "s";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricSystemUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricSystemUptime, descrMetricSystemUptime,
+                                 unitMetricSystemUptime);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricSystemUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricSystemUptime, descrMetricSystemUptime,
+                                  unitMetricSystemUptime);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricSystemUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricSystemUptime, descrMetricSystemUptime,
+                                           unitMetricSystemUptime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricSystemUptime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricSystemUptime, descrMetricSystemUptime,
+                                            unitMetricSystemUptime);
+}
+
+}  // namespace system
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/api/include/opentelemetry/semconv/vcs_metrics.h b/api/include/opentelemetry/semconv/vcs_metrics.h
new file mode 100644
index 0000000000..1f2885b8fe
--- /dev/null
+++ b/api/include/opentelemetry/semconv/vcs_metrics.h
@@ -0,0 +1,435 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * DO NOT EDIT, this is an Auto-generated file from:
+ * buildscripts/semantic-convention/templates/registry/semantic_metrics-h.j2
+ */
+
+#pragma once
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace semconv
+{
+namespace vcs
+{
+
+/**
+ * The number of changes (pull requests/merge requests/changelists) in a repository, categorized by
+ * their state (e.g. open or merged) <p> updowncounter
+ */
+static constexpr const char *kMetricVcsChangeCount = "vcs.change.count";
+static constexpr const char *descrMetricVcsChangeCount =
+    "The number of changes (pull requests/merge requests/changelists) in a repository, categorized "
+    "by their state (e.g. open or merged)";
+static constexpr const char *unitMetricVcsChangeCount = "{change}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricVcsChangeCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricVcsChangeCount, descrMetricVcsChangeCount,
+                                         unitMetricVcsChangeCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricVcsChangeCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricVcsChangeCount, descrMetricVcsChangeCount,
+                                          unitMetricVcsChangeCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricVcsChangeCount(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricVcsChangeCount, descrMetricVcsChangeCount,
+                                                   unitMetricVcsChangeCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricVcsChangeCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricVcsChangeCount, descrMetricVcsChangeCount, unitMetricVcsChangeCount);
+}
+
+/**
+ * The time duration a change (pull request/merge request/changelist) has been in a given state.
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricVcsChangeDuration = "vcs.change.duration";
+static constexpr const char *descrMetricVcsChangeDuration =
+    "The time duration a change (pull request/merge request/changelist) has been in a given state.";
+static constexpr const char *unitMetricVcsChangeDuration = "s";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricVcsChangeDuration(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricVcsChangeDuration, descrMetricVcsChangeDuration,
+                                 unitMetricVcsChangeDuration);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricVcsChangeDuration(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricVcsChangeDuration, descrMetricVcsChangeDuration,
+                                  unitMetricVcsChangeDuration);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricVcsChangeDuration(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricVcsChangeDuration, descrMetricVcsChangeDuration,
+                                           unitMetricVcsChangeDuration);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricVcsChangeDuration(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricVcsChangeDuration, descrMetricVcsChangeDuration,
+                                            unitMetricVcsChangeDuration);
+}
+
+/**
+ * The amount of time since its creation it took a change (pull request/merge request/changelist) to
+ * get the first approval. <p> gauge
+ */
+static constexpr const char *kMetricVcsChangeTimeToApproval = "vcs.change.time_to_approval";
+static constexpr const char *descrMetricVcsChangeTimeToApproval =
+    "The amount of time since its creation it took a change (pull request/merge "
+    "request/changelist) to get the first approval.";
+static constexpr const char *unitMetricVcsChangeTimeToApproval = "s";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>>
+CreateSyncInt64MetricVcsChangeTimeToApproval(metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricVcsChangeTimeToApproval, descrMetricVcsChangeTimeToApproval,
+                                 unitMetricVcsChangeTimeToApproval);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>>
+CreateSyncDoubleMetricVcsChangeTimeToApproval(metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricVcsChangeTimeToApproval,
+                                  descrMetricVcsChangeTimeToApproval,
+                                  unitMetricVcsChangeTimeToApproval);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricVcsChangeTimeToApproval(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricVcsChangeTimeToApproval,
+                                           descrMetricVcsChangeTimeToApproval,
+                                           unitMetricVcsChangeTimeToApproval);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricVcsChangeTimeToApproval(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricVcsChangeTimeToApproval,
+                                            descrMetricVcsChangeTimeToApproval,
+                                            unitMetricVcsChangeTimeToApproval);
+}
+
+/**
+ * The amount of time since its creation it took a change (pull request/merge request/changelist) to
+ * get merged into the target(base) ref. <p> gauge
+ */
+static constexpr const char *kMetricVcsChangeTimeToMerge = "vcs.change.time_to_merge";
+static constexpr const char *descrMetricVcsChangeTimeToMerge =
+    "The amount of time since its creation it took a change (pull request/merge "
+    "request/changelist) to get merged into the target(base) ref.";
+static constexpr const char *unitMetricVcsChangeTimeToMerge = "s";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricVcsChangeTimeToMerge(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricVcsChangeTimeToMerge, descrMetricVcsChangeTimeToMerge,
+                                 unitMetricVcsChangeTimeToMerge);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricVcsChangeTimeToMerge(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricVcsChangeTimeToMerge, descrMetricVcsChangeTimeToMerge,
+                                  unitMetricVcsChangeTimeToMerge);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricVcsChangeTimeToMerge(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(
+      kMetricVcsChangeTimeToMerge, descrMetricVcsChangeTimeToMerge, unitMetricVcsChangeTimeToMerge);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricVcsChangeTimeToMerge(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(
+      kMetricVcsChangeTimeToMerge, descrMetricVcsChangeTimeToMerge, unitMetricVcsChangeTimeToMerge);
+}
+
+/**
+ * The number of unique contributors to a repository
+ * <p>
+ * gauge
+ */
+static constexpr const char *kMetricVcsContributorCount = "vcs.contributor.count";
+static constexpr const char *descrMetricVcsContributorCount =
+    "The number of unique contributors to a repository";
+static constexpr const char *unitMetricVcsContributorCount = "{contributor}";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricVcsContributorCount(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricVcsContributorCount, descrMetricVcsContributorCount,
+                                 unitMetricVcsContributorCount);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricVcsContributorCount(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricVcsContributorCount, descrMetricVcsContributorCount,
+                                  unitMetricVcsContributorCount);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricVcsContributorCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(
+      kMetricVcsContributorCount, descrMetricVcsContributorCount, unitMetricVcsContributorCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricVcsContributorCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(
+      kMetricVcsContributorCount, descrMetricVcsContributorCount, unitMetricVcsContributorCount);
+}
+
+/**
+ * The number of refs of type branch or tag in a repository.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricVcsRefCount = "vcs.ref.count";
+static constexpr const char *descrMetricVcsRefCount =
+    "The number of refs of type branch or tag in a repository.";
+static constexpr const char *unitMetricVcsRefCount = "{ref}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>> CreateSyncInt64MetricVcsRefCount(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricVcsRefCount, descrMetricVcsRefCount,
+                                         unitMetricVcsRefCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>> CreateSyncDoubleMetricVcsRefCount(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricVcsRefCount, descrMetricVcsRefCount,
+                                          unitMetricVcsRefCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricVcsRefCount(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(kMetricVcsRefCount, descrMetricVcsRefCount,
+                                                   unitMetricVcsRefCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricVcsRefCount(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(kMetricVcsRefCount, descrMetricVcsRefCount,
+                                                    unitMetricVcsRefCount);
+}
+
+/**
+ * The number of lines added/removed in a ref (branch) relative to the ref from the @code
+ * vcs.ref.base.name @endcode attribute. <p> This metric should be reported for each @code
+ * vcs.line_change.type @endcode value. For example if a ref added 3 lines and removed 2 lines,
+ * instrumentation SHOULD report two measurements: 3 and 2 (both positive numbers).
+ * If number of lines added/removed should be calculated from the start of time, then @code
+ * vcs.ref.base.name @endcode SHOULD be set to an empty string. <p> gauge
+ */
+static constexpr const char *kMetricVcsRefLinesDelta = "vcs.ref.lines_delta";
+static constexpr const char *descrMetricVcsRefLinesDelta =
+    "The number of lines added/removed in a ref (branch) relative to the ref from the "
+    "`vcs.ref.base.name` attribute.";
+static constexpr const char *unitMetricVcsRefLinesDelta = "{line}";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricVcsRefLinesDelta(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricVcsRefLinesDelta, descrMetricVcsRefLinesDelta,
+                                 unitMetricVcsRefLinesDelta);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricVcsRefLinesDelta(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricVcsRefLinesDelta, descrMetricVcsRefLinesDelta,
+                                  unitMetricVcsRefLinesDelta);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricVcsRefLinesDelta(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricVcsRefLinesDelta, descrMetricVcsRefLinesDelta,
+                                           unitMetricVcsRefLinesDelta);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricVcsRefLinesDelta(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricVcsRefLinesDelta, descrMetricVcsRefLinesDelta,
+                                            unitMetricVcsRefLinesDelta);
+}
+
+/**
+ * The number of revisions (commits) a ref (branch) is ahead/behind the branch from the @code
+ * vcs.ref.base.name @endcode attribute <p> This metric should be reported for each @code
+ * vcs.revision_delta.direction @endcode value. For example if branch @code a @endcode is 3 commits
+ * behind and 2 commits ahead of @code trunk @endcode, instrumentation SHOULD report two
+ * measurements: 3 and 2 (both positive numbers) and @code vcs.ref.base.name @endcode is set to
+ * @code trunk @endcode. <p> gauge
+ */
+static constexpr const char *kMetricVcsRefRevisionsDelta = "vcs.ref.revisions_delta";
+static constexpr const char *descrMetricVcsRefRevisionsDelta =
+    "The number of revisions (commits) a ref (branch) is ahead/behind the branch from the "
+    "`vcs.ref.base.name` attribute";
+static constexpr const char *unitMetricVcsRefRevisionsDelta = "{revision}";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricVcsRefRevisionsDelta(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricVcsRefRevisionsDelta, descrMetricVcsRefRevisionsDelta,
+                                 unitMetricVcsRefRevisionsDelta);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricVcsRefRevisionsDelta(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricVcsRefRevisionsDelta, descrMetricVcsRefRevisionsDelta,
+                                  unitMetricVcsRefRevisionsDelta);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricVcsRefRevisionsDelta(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(
+      kMetricVcsRefRevisionsDelta, descrMetricVcsRefRevisionsDelta, unitMetricVcsRefRevisionsDelta);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricVcsRefRevisionsDelta(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(
+      kMetricVcsRefRevisionsDelta, descrMetricVcsRefRevisionsDelta, unitMetricVcsRefRevisionsDelta);
+}
+
+/**
+ * Time a ref (branch) created from the default branch (trunk) has existed. The @code ref.type
+ * @endcode attribute will always be @code branch @endcode <p> gauge
+ */
+static constexpr const char *kMetricVcsRefTime = "vcs.ref.time";
+static constexpr const char *descrMetricVcsRefTime =
+    "Time a ref (branch) created from the default branch (trunk) has existed. The `ref.type` "
+    "attribute will always be `branch`";
+static constexpr const char *unitMetricVcsRefTime = "s";
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+
+static inline nostd::unique_ptr<metrics::Gauge<int64_t>> CreateSyncInt64MetricVcsRefTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64Gauge(kMetricVcsRefTime, descrMetricVcsRefTime, unitMetricVcsRefTime);
+}
+
+static inline nostd::unique_ptr<metrics::Gauge<double>> CreateSyncDoubleMetricVcsRefTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleGauge(kMetricVcsRefTime, descrMetricVcsRefTime, unitMetricVcsRefTime);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncInt64MetricVcsRefTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableGauge(kMetricVcsRefTime, descrMetricVcsRefTime,
+                                           unitMetricVcsRefTime);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument> CreateAsyncDoubleMetricVcsRefTime(
+    metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableGauge(kMetricVcsRefTime, descrMetricVcsRefTime,
+                                            unitMetricVcsRefTime);
+}
+
+/**
+ * The number of repositories in an organization.
+ * <p>
+ * updowncounter
+ */
+static constexpr const char *kMetricVcsRepositoryCount = "vcs.repository.count";
+static constexpr const char *descrMetricVcsRepositoryCount =
+    "The number of repositories in an organization.";
+static constexpr const char *unitMetricVcsRepositoryCount = "{repository}";
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<int64_t>>
+CreateSyncInt64MetricVcsRepositoryCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64UpDownCounter(kMetricVcsRepositoryCount, descrMetricVcsRepositoryCount,
+                                         unitMetricVcsRepositoryCount);
+}
+
+static inline nostd::unique_ptr<metrics::UpDownCounter<double>>
+CreateSyncDoubleMetricVcsRepositoryCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleUpDownCounter(kMetricVcsRepositoryCount, descrMetricVcsRepositoryCount,
+                                          unitMetricVcsRepositoryCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncInt64MetricVcsRepositoryCount(metrics::Meter *meter)
+{
+  return meter->CreateInt64ObservableUpDownCounter(
+      kMetricVcsRepositoryCount, descrMetricVcsRepositoryCount, unitMetricVcsRepositoryCount);
+}
+
+static inline nostd::shared_ptr<metrics::ObservableInstrument>
+CreateAsyncDoubleMetricVcsRepositoryCount(metrics::Meter *meter)
+{
+  return meter->CreateDoubleObservableUpDownCounter(
+      kMetricVcsRepositoryCount, descrMetricVcsRepositoryCount, unitMetricVcsRepositoryCount);
+}
+
+}  // namespace vcs
+}  // namespace semconv
+OPENTELEMETRY_END_NAMESPACE
diff --git a/buildscripts/semantic-convention/generate.sh b/buildscripts/semantic-convention/generate.sh
index aa09991454..061b5f9b74 100755
--- a/buildscripts/semantic-convention/generate.sh
+++ b/buildscripts/semantic-convention/generate.sh
@@ -16,10 +16,10 @@ ROOT_DIR="${SCRIPT_DIR}/../../"
 # freeze the spec & generator tools versions to make the generation reproducible
 
 # repository: https://github.com/open-telemetry/semantic-conventions
-SEMCONV_VERSION=1.30.0
+SEMCONV_VERSION=1.31.0
 
 # repository: https://github.com/open-telemetry/weaver
-WEAVER_VERSION=0.12.0
+WEAVER_VERSION=0.13.2
 
 SEMCONV_VERSION_TAG=v$SEMCONV_VERSION
 WEAVER_VERSION_TAG=v$WEAVER_VERSION
diff --git a/buildscripts/semantic-convention/templates/registry/weaver.yaml b/buildscripts/semantic-convention/templates/registry/weaver.yaml
index e0543b2652..ad33be509d 100644
--- a/buildscripts/semantic-convention/templates/registry/weaver.yaml
+++ b/buildscripts/semantic-convention/templates/registry/weaver.yaml
@@ -34,7 +34,7 @@ templates:
     filter: >
       semconv_grouped_attributes({
         "exclude_root_namespace": $excluded_namespaces,
-        "exclude_stability": if $filter == "any" then [] else ["experimental"] end,
+        "stable_only": if $filter == "stable" then true else false end,
       })
       | map({
           root_namespace: .root_namespace,
@@ -49,7 +49,7 @@ templates:
     filter: >
       semconv_grouped_metrics({
         "exclude_root_namespace": $excluded_namespaces,
-        "exclude_stability": if $filter == "any" then [] else ["experimental"] end,
+        "stable_only": if $filter == "stable" then true else false end,
       })
       | map({
         root_namespace: .root_namespace,