diff --git a/.config/mise/tasks/semconv/check b/.config/mise/tasks/semconv/check
index 55edb693fe..9408a4acdb 100755
--- a/.config/mise/tasks/semconv/check
+++ b/.config/mise/tasks/semconv/check
@@ -10,3 +10,11 @@ trap 'rm -rf "$generated"' EXIT HUP INT TERM
 
 "$root/.config/mise/tasks/semconv/generate" "$generated"
 diff -ru "$expected" "$generated"
+
+if grep -n '"eventstore-' \
+	"$root/src/EventStore.Core/MetricsBootstrapper.cs" \
+	"$root/src/EventStore.Projections.Core/ProjectionsSubsystem.cs"
+then
+	echo "Built-in metric names must come from the generated MetricNames catalog." >&2
+	exit 1
+fi
diff --git a/.config/mise/tasks/semconv/generate b/.config/mise/tasks/semconv/generate
index f808e5479e..b0ce43f4c1 100755
--- a/.config/mise/tasks/semconv/generate
+++ b/.config/mise/tasks/semconv/generate
@@ -6,10 +6,13 @@ set -eu
 root=$(CDPATH='' cd -- "$(dirname -- "$0")/../../../.." && pwd)
 output=${1:-"$root/src/TrogonEventStore.SemanticConventions/Generated"}
 registry_version=$(sed -n '1p' "$root/otel/semconv/registry-version")
-registry="https://github.com/open-telemetry/semantic-conventions@${registry_version}[model]"
+registry="$root/otel/semconv/registry"
+official_registry="https://github.com/open-telemetry/semantic-conventions@${registry_version}[model]"
 staging=$(mktemp -d)
 trap 'rm -rf "$staging"' EXIT HUP INT TERM
 
+grep -Fqx "    registry_path: $official_registry" "$registry/manifest.yaml"
+
 weaver registry check \
 	--future \
 	--registry "$registry"
@@ -17,7 +20,18 @@ weaver registry check \
 weaver registry generate csharp "$staging" \
 	--future \
 	--registry "$registry" \
-	--templates "$root/otel/semconv/templates"
+	--templates "$root/otel/semconv/templates" \
+	-D attributes=false \
+	-D custom_attributes=true \
+	-D official_metrics=false
+
+weaver registry generate csharp "$staging" \
+	--future \
+	--registry "$official_registry" \
+	--templates "$root/otel/semconv/templates" \
+	-D custom_attributes=false \
+	-D metrics=false \
+	-D official_metrics=true
 
 set -- "$staging"/*.g.cs
 [ -e "$1" ] || exit 1
diff --git a/docs/diagnostics/metrics.md b/docs/diagnostics/metrics.md
index 63f8c50551..ae011b7174 100644
--- a/docs/diagnostics/metrics.md
+++ b/docs/diagnostics/metrics.md
@@ -1,604 +1,174 @@
-# Metrics
+<!-- markdownlint-disable MD013 -->
 
-TrogonEventStore collects metrics in [Prometheus format](https://prometheus.io/docs/instrumenting/exposition_formats/#text-based-format), available on the `/-/metrics` endpoint. Prometheus can be configured to scrape this endpoint directly. The metrics are configured in `metricsconfig.json`.
+# Metrics reference
 
-In addition, TrogonEventStore can actively export metrics to a specified endpoint using the [OpenTelemetry Protocol](https://opentelemetry.io/docs/specs/otel/protocol/) (OTLP).
+TrogonEventStore exposes metrics through the OpenTelemetry Protocol (OTLP) and the Prometheus-compatible `/-/metrics` endpoint. The canonical instrument identity is the dotted OpenTelemetry name documented here. Prometheus exporters may translate dots, units, or other name components according to their configured translation strategy.
 
-The built-in Core and Projections meter sources are always registered. Use the `Meters` array in `metricsconfig.json` only when additional components expose their own `System.Diagnostics.Metrics` meter sources.
+Configure node-specific metrics in `metricsconfig.json`. The `Meters` array adds third-party `System.Diagnostics.Metrics` meter sources; the built-in sources do not need to be listed there.
 
-## Metrics reference
+Units use UCUM notation: `s` is seconds, `By` is bytes, and `1` is dimensionless. Units such as `{event}` are annotated counts. The unit is metadata and is not repeated in the canonical instrument name.
 
-### Caches
+Telemetry resources include service identity, process creation time and PID, executable and runtime identity, and host name and architecture. Deployments should provide `host.id` through `OTEL_RESOURCE_ATTRIBUTES` when a stable machine or cloud instance identifier is available.
 
-#### Cache hits and misses
+## Built-in meter sources
 
-TrogonEventStore tracks cache hits/misses metrics for `stream-info` and `chunk` caches.
+The meter provider always subscribes to these sources:
 
-| Time series                                                                | Type                     | Description                             |
-|:---------------------------------------------------------------------------|:-------------------------|:----------------------------------------|
-| `eventstore_cache_hits_misses{cache=<CACHE_NAME>,kind=<"hits"\|"misses">}` | [Counter](#common-types) | Total hits/misses on _CACHE_NAME_ cache |
+| Meter | Source |
+| --- | --- |
+| `EventStore.Core` | Core TrogonEventStore instruments |
+| `EventStore.Projections.Core` | Projection instruments |
+| `System.Runtime` | Native .NET process, garbage collection, exception, lock, and thread pool instruments |
+| `Microsoft.AspNetCore.Server.Kestrel` | Native Kestrel connection and server instruments |
 
-Example configuration:
-```json
-"CacheHitsMisses": {
-  "StreamInfo": true,
-  "Chunk": false
-}
-```
-
-Example output:
-```
-# TYPE eventstore_cache_hits_misses counter
-eventstore_cache_hits_misses{cache="stream-info",kind="hits"} 104329 1688157489545
-eventstore_cache_hits_misses{cache="stream-info",kind="misses"} 117 1688157489545
-```
-
-#### Dynamic cache resources
-
-Certain caches that TrogonEventStore uses are dynamic in nature i.e. their capacity scales up/down during their lifetime. TrogonEventStore records metrics for resources being used by each such dynamic cache.
-
-| Time series                                                                      | Type                   | Description                                          |
-|:---------------------------------------------------------------------------------|:-----------------------|:-----------------------------------------------------|
-| `eventstore_cache_resources_bytes{cache=<CACHE_NAME>,kind=<"capacity"\|"size">}` | [Gauge](#common-types) | Current capacity/size of _CACHE_NAME_ cache in bytes |
-| `eventstore_cache_resources_entries{cache=<CACHE_NAME>,kind="count"}`            | [Gauge](#common-types) | Current number of entries in _CACHE_NAME_ cache      |
-
-Example configuration:
-```json
-"CacheResources": true
-```
-
-Example output:
-```
-# TYPE eventstore_cache_resources_bytes gauge
-# UNIT eventstore_cache_resources_bytes bytes
-eventstore_cache_resources_bytes{cache="LastEventNumber",kind="capacity"} 50000000 1688157491029
-eventstore_cache_resources_bytes{cache="LastEventNumber",kind="size"} 15804 1688157491029
-
-# TYPE eventstore_cache_resources_entries gauge
-# UNIT eventstore_cache_resources_entries entries
-eventstore_cache_resources_entries{cache="LastEventNumber",kind="count"} 75 1688157491029
-```
-
-### Checkpoints
-
-| Time series                                                         | Type                   | Description                            |
-|:--------------------------------------------------------------------|:-----------------------|:---------------------------------------|
-| `eventstore_checkpoints{name=<CHECKPOINT_NAME>,read="non-flushed"}` | [Gauge](#common-types) | Value for _CHECKPOINT_NAME_ checkpoint |
-
-Example configuration:
-```json
-"Checkpoints": {
-  "Replication": true,
-  "Chaser": false,
-  "Epoch": false,
-  "Index": false,
-  "Proposal": false,
-  "Truncate": false,
-  "Writer": false,
-  "StreamExistenceFilter": false
-}
-```
-
-Example output:
-```
-# TYPE eventstore_checkpoints gauge
-eventstore_checkpoints{name="replication",read="non-flushed"} 613363 1688054162478
-```
-
-### Elections Count
-
-This metric tracks the number of elections that have been completed.
-
-| Time series                  | Type                     | Description                  |
-|:-----------------------------|:-------------------------|:-----------------------------|
-| `eventstore_elections_count` | [Counter](#common-types) | Elections count in a cluster |
-
-Example configuration:
-```json
-"ElectionsCount": true
-```
-
-Example output:
-```
-# TYPE eventstore_elections_count counter
-eventstore_elections_count 0 1710188996949
-```
-
-### Events
-
-These metrics track events written to and read from the server, including reads from caches.
-
-| Time series                                          | Type                     | Description         |
-|:-----------------------------------------------------|:-------------------------|:--------------------|
-| `eventstore_io_bytes{activity="read"}`               | [Counter](#common-types) | Event bytes read    |
-| `eventstore_io_events{activity=<"read"\|"written">}` | [Counter](#common-types) | Events read/written |
-
-Example configuration:
-```json
-"Events": {
-  "Read": false,
-  "Written": true
-}
-```
-
-Example output:
-```
-# TYPE eventstore_io_events counter
-# UNIT eventstore_io_events events
-eventstore_io_events{activity="written"} 320 1687963622074
-```
-
-### Gossip
-
-Measures the round trip latency and processing time of gossip.
-Usually a node pushes new gossip to other nodes periodically or when its view of the cluster changes. Sometimes nodes pull gossip from each other if there is a suspected network problem. 
-
-#### Gossip latency
-
-| Time series                                                                                                         | Type                       | Description                                                                                  |
-|:--------------------------------------------------------------------------------------------------------------------|:---------------------------|:---------------------------------------------------------------------------------------------|
-| `eventstore_gossip_latency_seconds_bucket{activity="pull-from-peer",status=<"successful"\|"failed">,le=<DURATION>}` | [Histogram](#common-types) | Number of gossips pulled from peers with latency less than or equal to _DURATION_ in seconds |
-| `eventstore_gossip_latency_seconds_bucket{activity="push-to-peer",status=<"successful"\|"failed">,le=<DURATION>}`   | [Histogram](#common-types) | Number of gossips pushed to peers with latency less than or equal to _DURATION_ in seconds   |
-
-#### Gossip processing
-
-| Time Series                                                                                                                                                    | Type                       | Description                                                                                                  |
-|:---------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------|:-------------------------------------------------------------------------------------------------------------|
-| `eventstore_gossip_processing_duration_seconds_bucket{`<br/>`activity="push-from-peer",`<br/>`status=<"successful"\|"failed">,`<br/>`le=<DURATION>}`           | [Histogram](#common-types) | Number of gossips pushed from peers that took less than or equal to _DURATION_ in seconds to process         |
-| `eventstore_gossip_processing_duration_seconds_bucket{`<br/>`activity="request-from-peer",`<br/>`status=<"successful"\|"failed">,`<br/>`le=<DURATION>}`        | [Histogram](#common-types) | Number of gossip requests from peers that took less than or equal to _DURATION_ in seconds to process        |
-| `eventstore_gossip_processing_duration_seconds_bucket{`<br/>`activity="request-from-grpc-client",`<br/>`status=<"successful"\|"failed">,`<br/>`le=<DURATION>}` | [Histogram](#common-types) | Number of gossip requests from gRPC clients that took less than or equal to _DURATION_ in seconds to process |
-
-Example configuration:
-```json
-"Gossip": {
-  "PullFromPeer": false,
-  "PushToPeer": true,
-  "ProcessingPushFromPeer": false,
-  "ProcessingRequestFromPeer": false,
-  "ProcessingRequestFromGrpcClient": false
-}
-```
-
-Example output:
-```
-# TYPE eventstore_gossip_latency_seconds histogram
-# UNIT eventstore_gossip_latency_seconds seconds
-eventstore_gossip_latency_seconds_bucket{activity="push-to-peer",status="successful",le="0.005"} 8 1687972306948
-```
-
-### Incoming gRPC calls
-
-| Time series                                                       | Type                     | Description                                                                                |
-|:------------------------------------------------------------------|:-------------------------|:-------------------------------------------------------------------------------------------|
-| `eventstore_current_incoming_grpc_calls`                          | [Gauge](#common-types)   | Inflight gRPC calls i.e. gRPC requests that have started on the server but not yet stopped |
-| `eventstore_incoming_grpc_calls{kind="total"}`                    | [Counter](#common-types) | Total gRPC requests served                                                                 |
-| `eventstore_incoming_grpc_calls{kind="failed"}`                   | [Counter](#common-types) | Total gRPC requests failed                                                                 |
-| `eventstore_incoming_grpc_calls{`<br/>`kind="unimplemented"}`     | [Counter](#common-types) | Total gRPC requests made to unimplemented methods                                          |
-| `eventstore_incoming_grpc_calls{`<br/>`kind="deadline-exceeded"}` | [Counter](#common-types) | Total gRPC requests for which deadline have exceeded                                       |
-
-Example configuration:
-```json
-"IncomingGrpcCalls": {
-  "Current": true,
-  "Total": false,
-  "Failed": true,
-  "Unimplemented": false,
-  "DeadlineExceeded": false
-}
-```
-
-Example output:
-```
-# TYPE eventstore_current_incoming_grpc_calls gauge
-eventstore_current_incoming_grpc_calls 1 1687963622074
-
-# TYPE eventstore_incoming_grpc_calls counter
-eventstore_incoming_grpc_calls{kind="failed"} 1 1687962877623
-```
-
-#### Client protocol gRPC methods
-
-In addition, TrogonEventStore also records metrics for each of client protocol gRPC methods: `StreamRead`, `StreamAppend`, `StreamBatchAppend`, `StreamDelete` and `StreamTombstone`. They are grouped together according to the mapping defined in the configuration.
-
-| Time series                                                                                                    | Type                       | Description                                                                                      |
-|:---------------------------------------------------------------------------------------------------------------|:---------------------------|:-------------------------------------------------------------------------------------------------|
-| `eventstore_grpc_method_duration_seconds_bucket{`<br/>`activity=<LABEL>,`<br/>`status="successful"\|"failed",`<br/>`le=<DURATION>}` | [Histogram](#common-types) | Number of _LABEL_ gRPC requests that took less than or equal to _DURATION_ in seconds to process |
-
-Example configuration:
-```json
-"GrpcMethods": {
-  "StreamAppend": "append",
-  "StreamBatchAppend": "append",
-  // leaving label as blank will disable metric collection
-  "StreamRead": "",
-  "StreamDelete": "",
-  "StreamTombstone": ""
-}
-```
-
-Example output:
-```
-# TYPE eventstore_grpc_method_duration_seconds histogram
-# UNIT eventstore_grpc_method_duration_seconds seconds
-eventstore_grpc_method_duration_seconds_bucket{activity="append",status="successful",le="1E-06"} 0 1688157491029
-eventstore_grpc_method_duration_seconds_bucket{activity="append",status="successful",le="1E-05"} 0 1688157491029
-eventstore_grpc_method_duration_seconds_bucket{activity="append",status="successful",le="0.0001"} 129 1688157491029
-eventstore_grpc_method_duration_seconds_bucket{activity="append",status="successful",le="0.001"} 143 1688157491029
-eventstore_grpc_method_duration_seconds_bucket{activity="append",status="successful",le="0.01"} 168 1688157491029
-eventstore_grpc_method_duration_seconds_bucket{activity="append",status="successful",le="0.1"} 169 1688157491029
-eventstore_grpc_method_duration_seconds_bucket{activity="append",status="successful",le="1"} 169 1688157491029
-eventstore_grpc_method_duration_seconds_bucket{activity="append",status="successful",le="10"} 169 1688157491029
-eventstore_grpc_method_duration_seconds_bucket{activity="append",status="successful",le="+Inf"} 169 1688157491029
-```
-
-### Kestrel
-
-| Time series                      | Type                   | Description                        |
-|:---------------------------------|:-----------------------|:-----------------------------------|
-| `eventstore_kestrel_connections` | [Gauge](#common-types) | Number of open kestrel connections |
-
-Example configuration:
-```json
-"Kestrel": {
-  "ConnectionCount": true
-}
-```
-
-Example output:
-```
-# TYPE eventstore_kestrel_connections gauge
-eventstore_kestrel_connections 1 1688070655500
-```
+The exact native runtime and Kestrel instrument set is determined by the installed .NET runtime. TrogonEventStore does not duplicate those signals under custom names.
 
-### Persistent Subscriptions
+For example, GC pause telemetry is the native cumulative `dotnet.gc.pause.time` Counter in seconds. Derive pause rates and alert thresholds in the telemetry backend rather than relying on a node-specific rolling maximum.
 
-Persistent subscription metrics track the statistics for the persistent subscriptions.
+## Standard instruments
 
-| Time series                                                                                                           | Type                     | Description                                                    |
-|:----------------------------------------------------------------------------------------------------------------------|:-------------------------|:---------------------------------------------------------------|
-| `eventstore_persistent_sub_connections{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>}`                        | [Gauge](#common-types)   | Number of connections                                          |
-| `eventstore_persistent_sub_parked_messages{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>}`                    | [Gauge](#common-types)   | Number of parked messages                                      |
-| `eventstore_persistent_sub_park_message_requests{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>,reason=<REASON>}` | [Counter](#common-types) | Number of park message requests by reason                      |
-| `eventstore_persistent_sub_parked_message_replays{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>}`              | [Counter](#common-types) | Number of parked message replay requests                       |
-| `eventstore_persistent_sub_in_flight_messages{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>}`                 | [Gauge](#common-types)   | Number of messages in flight                                   |
-| `eventstore_persistent_sub_oldest_parked_message_seconds{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>}`      | [Gauge](#common-types)   | Oldest parked message age in seconds                           |
-| `eventstore_persistent_sub_items_processed{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>}`                    | [Counter](#common-types) | Total items processed                                          |
-| `eventstore_persistent_sub_last_known_event_number{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>}`            | [Counter](#common-types) | Last known event number (streams other than `$all`)            |
-| `eventstore_persistent_sub_last_known_event_commit_position{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>}`   | [Counter](#common-types) | Last known event's commit position (`$all` stream only)        |
-| `eventstore_persistent_sub_checkpointed_event_number{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>}`          | [Counter](#common-types) | Last checkpointed event number (streams other than `$all)`     |
-| `eventstore_persistent_sub_checkpointed_event_commit_position{event_stream_id=<STREAM_NAME>,group_name=<GROUP_NAME>}` | [Counter](#common-types) | Last checkpointed event's commit position (`$all` stream only) |
+These instruments use OpenTelemetry semantic convention names.
 
-Example configuration:
+| Instrument | Kind | Unit | Attributes | Description |
+| --- | --- | --- | --- | --- |
+| `process.uptime` | Gauge | `s` | None | Time the process has been running |
+| `process.disk.io` | Counter | `By` | `disk.io.direction` | Disk bytes transferred by the process; direction is `read` or `write` |
+| `system.filesystem.usage` | UpDownCounter | `By` | `system.filesystem.state`, `system.filesystem.mountpoint` | Used and free space on the filesystem containing the database; state is `used` or `free` |
+| `system.filesystem.limit` | UpDownCounter | `By` | `system.filesystem.mountpoint` | Total capacity of the filesystem containing the database |
 
-```json
-"PersistentSubscriptionStats": true,
-```
-
-Example output:
-
-```
-# TYPE eventstore_persistent_sub_connections gauge
-eventstore_persistent_sub_connections{event_stream_id="test-stream",group_name="group1"} 1 1720172078179
-eventstore_persistent_sub_connections{event_stream_id="$all",group_name="group1"} 1 1720172078179
-
-# TYPE eventstore_persistent_sub_parked_messages gauge
-eventstore_persistent_sub_parked_messages{event_stream_id="test-stream",group_name="group1"} 0 1720172078179
-eventstore_persistent_sub_parked_messages{event_stream_id="$all",group_name="group1"} 0 1720172078179
-
-# TYPE eventstore_persistent_sub_park_message_requests counter
-eventstore_persistent_sub_park_message_requests{event_stream_id="test-stream",group_name="group1",reason="client-nak"} 0 1720172078179
-eventstore_persistent_sub_park_message_requests{event_stream_id="test-stream",group_name="group1",reason="max-retries"} 0 1720172078179
-eventstore_persistent_sub_park_message_requests{event_stream_id="$all",group_name="group1",reason="client-nak"} 0 1720172078179
-eventstore_persistent_sub_park_message_requests{event_stream_id="$all",group_name="group1",reason="max-retries"} 0 1720172078179
-
-# TYPE eventstore_persistent_sub_parked_message_replays counter
-eventstore_persistent_sub_parked_message_replays{event_stream_id="test-stream",group_name="group1"} 0 1720172078179
-eventstore_persistent_sub_parked_message_replays{event_stream_id="$all",group_name="group1"} 0 1720172078179
-
-# TYPE eventstore_persistent_sub_in_flight_messages gauge
-eventstore_persistent_sub_in_flight_messages{event_stream_id="test-stream",group_name="group1"} 0 1720172078179
-eventstore_persistent_sub_in_flight_messages{event_stream_id="$all",group_name="group1"} 0 1720172078179
-
-# TYPE eventstore_persistent_sub_oldest_parked_message_seconds gauge
-eventstore_persistent_sub_oldest_parked_message_seconds{event_stream_id="test-stream",group_name="group1"} 0 1720172078179
-eventstore_persistent_sub_oldest_parked_message_seconds{event_stream_id="$all",group_name="group1"} 0 1720172078179
-
-# TYPE eventstore_persistent_sub_items_processed counter
-eventstore_persistent_sub_items_processed{event_stream_id="test-stream",group_name="group1"} 0 1720172078179
-eventstore_persistent_sub_items_processed{event_stream_id="$all",group_name="group1"} 5 1720172078179
+## TrogonEventStore instruments
 
-# TYPE eventstore_persistent_sub_last_known_event_number counter
-eventstore_persistent_sub_last_known_event_number{event_stream_id="test-stream",group_name="group1"} 0 1720172078179
+All `trogon.eventstore.*` instruments are development semantic conventions. Attribute names are part of each instrument contract and should be used instead of parsing instrument names.
 
-# TYPE eventstore_persistent_sub_last_known_event_commit_position counter
-eventstore_persistent_sub_last_known_event_commit_position{event_stream_id="$all",group_name="group1"} 4113 1720172078179
+### Runtime and operations
 
-# TYPE eventstore_persistent_sub_checkpointed_event_number counter
-eventstore_persistent_sub_checkpointed_event_number{event_stream_id="test-stream",group_name="group1"} 0 1720172078179
+| Instrument | Kind | Unit | Attributes | Description |
+| --- | --- | --- | --- | --- |
+| `trogon.eventstore.component.status` | UpDownCounter | `1` | `trogon.eventstore.component.name`, `trogon.eventstore.component.status` | Current component status represented by one active series with value `1` and inactive series with value `0` |
+| `trogon.eventstore.grpc.server.call.duration` | Histogram | `s` | `trogon.eventstore.activity.name`, `trogon.eventstore.activity.outcome` | Duration of configured gRPC server calls |
+| `trogon.eventstore.gossip.exchange.duration` | Histogram | `s` | `trogon.eventstore.activity.name`, `trogon.eventstore.activity.outcome` | Duration of gossip exchanges |
+| `trogon.eventstore.gossip.message.processing.duration` | Histogram | `s` | `trogon.eventstore.activity.name`, `trogon.eventstore.activity.outcome` | Duration of gossip message processing |
+| `trogon.eventstore.cluster.election.count` | Counter | `{election}` | None | Number of cluster elections |
+| `trogon.eventstore.grpc.server.call.active` | UpDownCounter | `{call}` | None | Number of active incoming gRPC calls |
+| `trogon.eventstore.grpc.server.call.count` | Counter | `{call}` | None | Number of incoming gRPC calls |
+| `trogon.eventstore.grpc.server.call.failure.count` | Counter | `{call}` | None | Number of failed incoming gRPC calls |
+| `trogon.eventstore.grpc.server.call.unimplemented.count` | Counter | `{call}` | None | Number of unimplemented incoming gRPC calls |
+| `trogon.eventstore.grpc.server.call.deadline_exceeded.count` | Counter | `{call}` | None | Number of incoming gRPC calls that exceeded their deadline |
+| `trogon.eventstore.system.load_average` | Gauge | `1` | `trogon.eventstore.system.load_average.period` | System load average for period `1m`, `5m`, or `15m`; not emitted on Windows |
+| `trogon.eventstore.process.disk.operation.count` | Counter | `{operation}` | `disk.io.direction` | Number of process disk operations; direction is `read` or `write` |
 
-# TYPE eventstore_persistent_sub_checkpointed_event_commit_position counter
-eventstore_persistent_sub_checkpointed_event_commit_position{event_stream_id="$all",group_name="group1"} 4013 1720172078179
-```
-
-### Process
-
-TrogonEventStore collects key metrics about the running process.
-
-| Time Series                                                                              | Type                     | Description                                                                                                                                                                                                                                                                                                                                                                          |
-|:-----------------------------------------------------------------------------------------|:-------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `eventstore_proc_up_time{pid=<PID>}`                                                     | [Counter](#common-types) | Time in seconds this process has been running for. _PID_ is process Id of TrogonEventStore process                                                                                                                                                                                                                                                                                       |
-| `eventstore_proc_cpu`                                                                    | [Gauge](#common-types)   | Process CPU usage                                                                                                                                                                                                                                                                                                                                                                    |
-| `eventstore_proc_thread_count`                                                           | [Gauge](#common-types)   | Current number of threadpool threads ([ThreadPool.ThreadCount](https://learn.microsoft.com/en-us/dotnet/api/system.threading.threadpool.threadcount?view=net-6.0))                                                                                                                                                                                                                   |
-| `eventstore_proc_thread_pool_pending_work_item_count`                                    | [Gauge](#common-types)   | Current number of items that are queued to be processed by threadpool threads ([ThreadPool.PendingWorkItemCount](https://learn.microsoft.com/en-us/dotnet/api/system.threading.threadpool.pendingworkitemcount?view=net-6.0))                                                                                                                                                        |
-| `eventstore_proc_contention_count`                                                       | [Counter](#common-types) | Total number of times there was contention when trying to take monitor's lock ([Monitor.LockContentionCount](https://learn.microsoft.com/en-us/dotnet/api/system.threading.monitor.lockcontentioncount?view=net-6.0))                                                                                                                                                                |
-| `eventstore_proc_exception_count`                                                        | [Counter](#common-types) | Total number of exceptions thrown                                                                                                                                                                                                                                                                                                                                                    |
-| `eventstore_gc_time_in_gc`                                                               | [Gauge](#common-types)   | Percentage of CPU time spent collecting garbage during last garbage collection                                                                                                                                                                                                                                                                                                       |
-| `eventstore_gc_heap_size_bytes`                                                          | [Gauge](#common-types)   | [Heap size in bytes](https://learn.microsoft.com/en-us/dotnet/api/system.gcmemoryinfo.heapsizebytes?view=net-6.0)                                                                                                                                                                                                                                                                    |
-| `eventstore_gc_heap_fragmentation`                                                       | [Gauge](#common-types)   | Percentage of heap [fragmentation](https://learn.microsoft.com/en-us/dotnet/api/system.gcmemoryinfo.fragmentedbytes?view=net-6.0) during last garbage collection                                                                                                                                                                                                                     |
-| `eventstore_gc_total_allocated`                                                          | [Counter](#common-types) | [Total allocated bytes](https://learn.microsoft.com/en-us/dotnet/api/system.gc.gettotalallocatedbytes?view=net-6.0) over the lifetime of this process                                                                                                                                                                                                                                |
-| `eventstore_gc_pause_duration_max_seconds{`<br/>`range=<RANGE>}`                         | [RecentMax](#recentmax)  | Recent maximum garbage collection pause in seconds. This measures the times that the execution engine is paused for GC                                                                                                                                                                                                                                                               |
-| `eventstore_gc_generation_size_bytes{`<br/>`generation=<"gen0"\|"gen1"\|"gen2"\|"loh">}` | [Gauge](#common-types)   | Size of each generation in bytes                                                                                                                                                                                                                                                                                                                                                     |
-| `eventstore_gc_collection_count{`<br/>`generation=<"gen0"\|"gen1"\|"gen2">}`             | [Counter](#common-types) | [Number of garbage collections](https://learn.microsoft.com/en-us/dotnet/api/system.gc.collectioncount?view=net-6.0) from each generation                                                                                                                                                                                                                                            |
-| `eventstore_proc_mem_bytes{`<br/>`kind=<"working-set"\|"paged-bytes"\|"virtual-bytes">}` | [Gauge](#common-types)   | Size in bytes of the [working set](https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.process.workingset64?view=net-6.0), [paged](https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.process.pagedmemorysize64?view=net-6.0) or [virtual](https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.process.virtualmemorysize64?view=net-6.0) memory |
-| `eventstore_disk_io_bytes{`<br/>`activity=<"read"\|"written">}`                          | [Counter](#common-types) | Number of bytes read from/written to the disk                                                                                                                                                                                                                                                                                                                                        |
-| `eventstore_disk_io_operations{`<br/>`activity=<"read"\|"written">}`                     | [Counter](#common-types) | Number of OS read/write operations issued to the disk                                                                                                                                                                                                                                                                                                                                |
-
-Example configuration:
-```json
-"Process": {
-  "UpTime": false,
-  "Cpu": false,
-  "MemWorkingSet": false,
-  "MemPagedBytes": false,
-  "MemVirtualBytes": false,
-  "ThreadCount": true,
-  "ThreadPoolPendingWorkItemCount": false,
-  "LockContentionCount": true,
-  "ExceptionCount": false,
-  "Gen0CollectionCount": false,
-  "Gen1CollectionCount": false,
-  "Gen2CollectionCount": false,
-  "Gen0Size": false,
-  "Gen1Size": false,
-  "Gen2Size": false,
-  "LohSize": false,
-  "TimeInGc": false,
-  "GcPauseDuration": true,
-  "HeapSize": false,
-  "HeapFragmentation": false,
-  "TotalAllocatedBytes": false,
-  "DiskReadBytes": false,
-  "DiskReadOps": false,
-  "DiskWrittenBytes": false,
-  "DiskWrittenOps": false
-}
-```
+The failure, unimplemented, and deadline-exceeded counters mirror distinct diagnostic events. They are separate instruments because the source events can overlap for one call and therefore must not be summed as mutually exclusive outcomes.
 
-Example output:
-```
-# TYPE eventstore_proc_thread_count gauge
-eventstore_proc_thread_count 15 1688070655500
-
-# TYPE eventstore_proc_contention_count counter
-eventstore_proc_contention_count 297 1688147136862
+### Queues
 
-# TYPE eventstore_gc_pause_duration_max_seconds gauge
-# UNIT eventstore_gc_pause_duration_max_seconds seconds
-eventstore_gc_pause_duration_max_seconds{range="16-20 seconds"} 0.0485873 1688147136862
-```
+| Instrument | Kind | Unit | Attributes | Description |
+| --- | --- | --- | --- | --- |
+| `trogon.eventstore.queue.message.wait.duration.max` | Gauge | `s` | `trogon.eventstore.queue.name`, `trogon.eventstore.measurement.window` | Maximum queue wait during the measurement window |
+| `trogon.eventstore.queue.message.processing.duration` | Histogram | `s` | `trogon.eventstore.queue.name`, `trogon.eventstore.queue.message.type` | Queue message processing duration |
+| `trogon.eventstore.queue.busy.time` | Counter | `s` | `trogon.eventstore.queue.name` | Total time a queue has spent processing messages |
+| `trogon.eventstore.queue.message.count` | UpDownCounter | `{message}` | `trogon.eventstore.queue.name` | Messages waiting in a queue |
+
+Queue and message labels come from the `QueueLabels` and `MessageTypes` regular-expression mappings in `metricsconfig.json`. Processing histograms have the highest cardinality and collection cost because they combine queue and message-type labels.
+
+### Storage and caches
+
+| Instrument | Kind | Unit | Attributes | Description |
+| --- | --- | --- | --- | --- |
+| `trogon.eventstore.storage.io` | Counter | `By` | `trogon.eventstore.storage.activity` | Bytes transferred by storage operations |
+| `trogon.eventstore.storage.event.count` | Counter | `{event}` | `trogon.eventstore.storage.activity` | Events processed by storage operations |
+| `trogon.eventstore.storage.record.read.duration` | Histogram | `s` | `trogon.eventstore.storage.source` | Transaction file record read duration |
+| `trogon.eventstore.storage.chunk.read.distance` | Histogram | `{chunk}` | None | Logical chunk distance between a read and the writer position |
+| `trogon.eventstore.cache.operation.count` | Counter | `{operation}` | `trogon.eventstore.cache.name`, `trogon.eventstore.cache.result` | Cache lookups by result |
+| `trogon.eventstore.cache.resource.size` | UpDownCounter | `By` | `trogon.eventstore.cache.name`, `trogon.eventstore.cache.resource` | Cache size and capacity in bytes |
+| `trogon.eventstore.cache.resource.count` | UpDownCounter | `{entry}` | `trogon.eventstore.cache.name`, `trogon.eventstore.cache.resource` | Cache size, capacity, and count in entries |
+| `trogon.eventstore.checkpoint.position` | Gauge | `1` | `trogon.eventstore.checkpoint.name`, `trogon.eventstore.checkpoint.read_kind` | Transaction log checkpoint position |
+| `trogon.eventstore.writer.flush.size.max` | Gauge | `By` | `trogon.eventstore.measurement.window` | Maximum writer flush size during the measurement window |
+| `trogon.eventstore.writer.flush.duration.max` | Gauge | `s` | `trogon.eventstore.measurement.window` | Maximum writer flush duration during the measurement window |
+
+The `trogon.eventstore.storage.activity` attribute is `read` or `write`. The checkpoint read kind currently emitted by the node is `non_flushed`.
+
+### Persistent subscriptions
+
+Every persistent subscription instrument includes `trogon.eventstore.persistent_subscription.stream` and `trogon.eventstore.persistent_subscription.group`.
+
+| Instrument | Kind | Unit | Additional attributes | Description |
+| --- | --- | --- | --- | --- |
+| `trogon.eventstore.persistent_subscription.connection.count` | UpDownCounter | `{connection}` | None | Subscription connections |
+| `trogon.eventstore.persistent_subscription.parked_message.count` | UpDownCounter | `{message}` | None | Parked messages |
+| `trogon.eventstore.persistent_subscription.in_flight_message.count` | UpDownCounter | `{message}` | None | In-flight messages |
+| `trogon.eventstore.persistent_subscription.oldest_parked_message.age` | Gauge | `s` | None | Age of the oldest parked message |
+| `trogon.eventstore.persistent_subscription.park_request.count` | Counter | `{request}` | `trogon.eventstore.persistent_subscription.reason` | Park requests by reason |
+| `trogon.eventstore.persistent_subscription.parked_message.replay.count` | Counter | `{operation}` | None | Parked-message replay operations |
+| `trogon.eventstore.persistent_subscription.parked_message.truncate.count` | Counter | `{operation}` | None | Parked-message truncate operations |
+| `trogon.eventstore.persistent_subscription.item.processed.count` | Counter | `{item}` | None | Processed subscription items |
+| `trogon.eventstore.persistent_subscription.last_known.event.revision` | Gauge | `1` | None | Last known stream revision |
+| `trogon.eventstore.persistent_subscription.last_known.commit.position` | Gauge | `1` | None | Last known commit position |
+| `trogon.eventstore.persistent_subscription.checkpoint.event.revision` | Gauge | `1` | None | Last checkpointed stream revision |
+| `trogon.eventstore.persistent_subscription.checkpoint.commit.position` | Gauge | `1` | None | Last checkpointed commit position |
 
 ### Projections
 
-Projection metrics track the statistics for projections.
+| Instrument | Kind | Unit | Attributes | Description |
+| --- | --- | --- | --- | --- |
+| `trogon.eventstore.projection.event.processed.count` | Counter | `{event}` | `trogon.eventstore.projection.name` | Events processed by a projection after restart |
+| `trogon.eventstore.projection.progress` | Gauge | `1` | `trogon.eventstore.projection.name` | Completion fraction clamped to the range from `0` to `1` |
+| `trogon.eventstore.projection.status` | UpDownCounter | `1` | `trogon.eventstore.projection.name`, `trogon.eventstore.projection.status` | One-hot projection state using `running`, `faulted`, and `stopped` series |
+| `trogon.eventstore.projection.state.size` | UpDownCounter | `By` | `trogon.eventstore.projection.name` | Total projection state size across partitions |
 
-| Time series                                                                                | Type                     | Description                                                      |
-|:-------------------------------------------------------------------------------------------|:-------------------------|:-----------------------------------------------------------------|
-| `eventstore_projection_events_processed_after_restart_total{projection=<PROJECTION_NAME>}` | [Counter](#common-types) | Projection event processed count after restart                   |
-| `eventstore_projection_progress{projection=<PROJECTION_NAME>}`                             | [Gauge](#common-types)   | Projection progress 0 - 1, where 1 = projection progress at 100% |
-| `eventstore_projection_running{projection=<PROJECTION_NAME>}`                              | [Gauge](#common-types)   | If 1, projection is in 'Running' state                           |
-| `eventstore_projection_state_size{projection=<PROJECTION_NAME>,partition=<PARTITION>}`     | [Gauge](#common-types)   | Projection state size in bytes when close to the configured limit |
-| `eventstore_projection_status{projection=<PROJECTION_NAME>,status=<PROJECTION_STATUS>}`    | [Gauge](#common-types)   | If 1, projection is in specified state                           |
+There is no separate projection-running instrument. Use `trogon.eventstore.projection.status` with `trogon.eventstore.projection.status="running"`.
 
-The `partition` label is omitted for the root projection state.
+## Configuration
 
-`Status` can have one of the following statuses:
+`ExpectedScrapeIntervalSeconds` must be `1`, `5`, `10`, or a multiple of `15`. A value of `0` disables node-specific Core metric collection. The value also defines the window used by recent-maximum instruments.
 
-- Running
-- Faulted
-- Stopped
-
-Example configuration:
+This example uses only current configuration keys:
 
 ```json
-"ProjectionStats": true
-```
-
-Example output:
-
-```
-# TYPE eventstore_projection_events_processed_after_restart_total counter
-eventstore_projection_events_processed_after_restart_total{projection="$by_category"} 83 1719526306309
-
-# TYPE eventstore_projection_progress gauge
-eventstore_projection_progress{projection="$stream_by_category"} 1 1719526306309
-
-# TYPE eventstore_projection_running gauge
-eventstore_projection_running{projection="$by_category"} 1 1719526306309
-
-# TYPE eventstore_projection_state_size gauge
-eventstore_projection_state_size{projection="$by_category"} 1048576 1719526306309
-
-# TYPE eventstore_projection_status gauge
-eventstore_projection_status{projection="$by_category",status="Running"} 1 1719526306309
-eventstore_projection_status{projection="$by_category",status="Faulted"} 0 1719526306309
-eventstore_projection_status{projection="$by_category",status="Stopped"} 0 1719526306309
-```
-
-### Queues
-
-TrogonEventStore uses various queues for asynchronous processing for which it also collects different metrics. In addition, TrogonEventStore allows users to group queues and monitor them as a unit.
-
-| Time series                                                                                                         | Type                       | Description                                                                                                                                                                                      |
-|:--------------------------------------------------------------------------------------------------------------------|:---------------------------|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `eventstore_queue_busy_seconds{queue=<QUEUE_GROUP>}`                                                                | [Counter](#common-types)   | Total time spent processing in seconds, averaged across the queues in the _QUEUE_GROUP_. The rate of this metric is therefore the average busyness of the group during the period (from 0-1 s/s) |
-| `eventstore_queue_length_items{queue=<QUEUE_GROUP>}`                                                                | [Gauge](#common-types)     | Current number of queued items in queues belonging to the _QUEUE_GROUP_                                                                                                                           |
-| `eventstore_queue_queueing_duration_max_seconds{`<br/>`name=<QUEUE_GROUP>,range=<RANGE>}`                           | [RecentMax](#recentmax)    | Recent maximum time in seconds for which any item was queued in queues belonging to the _QUEUE_GROUP_. This is essentially the length of the longest queue in the group in seconds               |
-| `eventstore_queue_processing_duration_seconds_bucket{`<br/>`message_type=<TYPE>,queue=<QUEUE_GROUP>,le=<DURATION>}` | [Histogram](#common-types) | Number of messages of type _TYPE_ processed by _QUEUE_GROUP_ group that took less than or equal to _DURATION_ in seconds                                                                         |
-
-`QueueLabels` setting within `metricsconfig.json` can be used to group queues, based on regex which gets matched on queue names, and label them for metrics reporting. Capture groups are also supported. Message types can be grouped in the same way in the `MessageTypes` setting in `metricsconfig.json`.
-
-::: note
-Enabling `Queues.Processing` can cause a lot more time series to be generated, according to the `QueueLabels` and `MessageTypes` configuration.
-:::
-
-Example configuration:
-```json
-"Queues": {
-  "Busy": true,
-  "Length": true,
-  "Processing": false
-}
-
-"QueueLabels": [
-  {
-    "Regex": "StorageReaderQueue #.*",
-    "Label": "Readers"
+{
+  "ExpectedScrapeIntervalSeconds": 15,
+  "Otlp": {
+    "Enabled": true
   },
-  {
-    "Regex": ".*",
-    "Label": "Others"
-  }
-]
-```
-
-Example output:
-```
-# TYPE eventstore_queue_busy_seconds counter
-# UNIT eventstore_queue_busy_seconds seconds
-eventstore_queue_busy_seconds{queue="Readers"} 1.04568158125 1688157491029
-eventstore_queue_busy_seconds{queue="Others"} 0 1688157491029
-
-# TYPE eventstore_queue_queueing_duration_max_seconds gauge
-# UNIT eventstore_queue_queueing_duration_max_seconds seconds
-eventstore_queue_queueing_duration_max_seconds{name="Readers",range="16-20 seconds"} 0.06434454 1688157489545
-eventstore_queue_queueing_duration_max_seconds{name="Others",range="16-20 seconds"} 0 1688157489545
-```
-
-### Status
-
-TrogonEventStore tracks the current status of the `Node` role  as well as  progress of  `Index`, and `Scavenge` processes.
-
-| Time series                                        | Type                   | Description                                                                              |
-|:---------------------------------------------------|:-----------------------|:-----------------------------------------------------------------------------------------|
-| `eventstore_statuses{name=<NAME>,status=<STATUS>}` | [Gauge](#common-types) | Number of seconds since the 1970 epoch when _NAME_ most recently had the status _STATUS_ |
-
-For a given _NAME_, the current status can be determined by taking the max of all the time series with that name.
-
-`Index` can have one of the following statuses:
-- Opening (loading/verifying the PTables)
-- Rebuilding (indexing previously written records on start up)
-- Initializing (initializing any other parts of the index e.g. StreamExistenceFilter on start up)
-- Merging
-- Scavenging
-- Idle
-
-`Scavenge` can have one of the following statuses:
-- Accumulation
-- Calculation
-- Chunk Execution
-- Chunk Merging
-- Index Execution
-- Cleaning
-- Idle
-
-`Node` can be one of the [node roles](../cluster.md#node-roles).
-
-Example configuration:
-```json
-"Statuses": {
-  "Index": true,
-  "Node": false,
-  "Scavenge": false
-}
-```
-
-Example output:
-```
-# TYPE eventstore_checkpoints gauge
-eventstore_statuses{name="Index",status="Idle"} 1688054162 1688054162477
-```
-
-### Storage Writer
-
-| Time series                                                   | Type                    | Description                              |
-|:--------------------------------------------------------------|:------------------------|:-----------------------------------------|
-| `eventstore_writer_flush_size_max{range=<RANGE>}`             | [RecentMax](#recentmax) | Recent maximum flush size in bytes       |
-| `eventstore_writer_flush_duration_max_seconds{range=<RANGE>}` | [RecentMax](#recentmax) | Recent maximum flush duration in seconds |
-
-Example configuration:
-```json
-"Writer": {
-  "FlushSize": true,
-  "FlushDuration": false
-}
-```
-
-Example output:
-```
-# TYPE eventstore_writer_flush_size_max gauge
-eventstore_writer_flush_size_max{range="16-20 seconds"} 410 1688056823193
-```
-
-### System
-
-| Time series                                                            | Type                   | Description                                                                                                 |
-|:-----------------------------------------------------------------------|:-----------------------|:------------------------------------------------------------------------------------------------------------|
-| `eventstore_sys_load_avg{period=<"1m"\|"5m"\|"15m">}`                  | [Gauge](#common-types) | Average system load in last `1`, `5`, and `15` minutes. This metric is only available for Unix-like systems |
-| `eventstore_sys_cpu`                                                   | [Gauge](#common-types) | Current CPU usage in percentage. This metric is unavailable for Unix-like systems                           |
-| `eventstore_sys_mem_bytes{kind=<"free"\|"total">}`                     | [Gauge](#common-types) | Current free/total memory in bytes                                                                          |
-| `eventstore_sys_disk_bytes{disk=<MOUNT_POINT>,kind=<"used"\|"total">}` | [Gauge](#common-types) | Current used/total bytes of disk mounted at _MOUNT_POINT_                                                   |
-
-Example configuration:
-```json
-"System": {
-  "Cpu": false,
-  "LoadAverage1m": false,
-  "LoadAverage5m": false,
-  "LoadAverage15m": false,
-  "FreeMem": false,
-  "TotalMem": false,
-  "DriveTotalBytes": false,
-  "DriveUsedBytes": true
+  "Meters": [],
+  "System": {
+    "LoadAverage1m": true,
+    "LoadAverage5m": true,
+    "LoadAverage15m": true,
+    "DriveTotalBytes": true,
+    "DriveUsedBytes": true
+  },
+  "Process": {
+    "UpTime": true,
+    "DiskReadBytes": true,
+    "DiskReadOps": true,
+    "DiskWrittenBytes": true,
+    "DiskWrittenOps": true
+  },
+  "ProjectionStats": true,
+  "PersistentSubscriptionStats": true
 }
 ```
 
-Example output:
-```
-# TYPE eventstore_sys_disk_bytes gauge
-# UNIT eventstore_sys_disk_bytes bytes
-eventstore_sys_disk_bytes{disk="/home",kind="used"} 38947205120 1688070655500
-```
-
-## Metric types
-
-### Common types
-
-Please refer to [Prometheus documentation](https://prometheus.io/docs/concepts/metric_types/) for explanation of common metric types (`Gauge`, `Counter` and `Histogram`).
-
-### RecentMax
-
-A gauge whose value represents the maximum out of a set of _recent_ measurements. Its purpose is to capture spikes that would otherwise have fallen in-between scrapes.
-
-::: note
-The `ExpectedScrapeIntervalSeconds` setting within `metricsconfig.json` can be used to control the size of the window that the max is calculated over. It represents the expected interval between scrapes by a consumer such as Prometheus. It can only take specific values: `0`, `1`, `5`, `10` or multiples of `15`.
-
-Setting the expected scape interval correctly ensures that spikes in the time series will be captured by at least one scrape and at most two.
-:::
-
-Example output:
-Following metric is reported when `ExpectedScrapeIntervalSeconds` is set to `15` seconds
-```
-# TYPE eventstore_writer_flush_size_max gauge
-eventstore_writer_flush_size_max{range="16-20 seconds"} 1854 1688070655500
-```
-In above example, maximum reported is `1854`. It is not a maximum measurement in last `15s` but rather maximum measurement in last `16` to last `20` seconds i.e. the maximum measurement could have been recorded in last `16s`, last `17s`, …, upto last `20s`.
+OTLP exporter endpoint, protocol, headers, and export interval settings use the standard OpenTelemetry .NET `OTEL_*` environment variables.
+
+The remaining node-specific switches map to these instrument groups:
+
+| Configuration key | Instruments controlled |
+| --- | --- |
+| `Statuses` | Component status |
+| `ElectionsCount` | Cluster election count |
+| `Checkpoints` | Checkpoint position |
+| `Events` | Storage I/O, event count, record read duration, and chunk read distance |
+| `GrpcMethods` | Configured gRPC method duration histograms |
+| `IncomingGrpcCalls` | Active, total, failure, unimplemented, and deadline-exceeded incoming gRPC calls |
+| `Gossip` | Gossip exchange and processing durations |
+| `Writer` | Writer flush maximum size and duration |
+| `CacheHitsMisses` | Cache operation count |
+| `CacheResources` | Cache resource size and count |
+| `System` | Load average and filesystem usage or limit |
+| `Process` | Process uptime, disk bytes, and disk operation count |
+| `Queues` | Queue busy time, length, wait maximum, and processing duration |
+| `ProjectionStats` | Projection instruments |
+| `PersistentSubscriptionStats` | Persistent subscription instruments |
+
+Native `System.Runtime` and Kestrel instruments are not controlled by node-specific metric switches. Use OpenTelemetry views or exporter configuration when filtering those sources.
diff --git a/otel/semconv/registry/manifest.yaml b/otel/semconv/registry/manifest.yaml
new file mode 100644
index 0000000000..bace77c70f
--- /dev/null
+++ b/otel/semconv/registry/manifest.yaml
@@ -0,0 +1,6 @@
+name: trogon_eventstore
+description: Semantic conventions for TrogonEventStore telemetry.
+schema_url: https://trogondb.com/schemas/0.1.0
+dependencies:
+  - schema_url: https://opentelemetry.io/schemas/1.43.0
+    registry_path: https://github.com/open-telemetry/semantic-conventions@v1.43.0[model]
diff --git a/otel/semconv/registry/trogon/eventstore/metrics.yaml b/otel/semconv/registry/trogon/eventstore/metrics.yaml
new file mode 100644
index 0000000000..0540fa0f04
--- /dev/null
+++ b/otel/semconv/registry/trogon/eventstore/metrics.yaml
@@ -0,0 +1,514 @@
+groups:
+  - id: registry.trogon.eventstore.metric.attributes
+    type: attribute_group
+    stability: development
+    brief: Attributes used by TrogonEventStore metrics.
+    attributes:
+      - id: trogon.eventstore.activity.name
+        type: string
+        stability: development
+        brief: Low-cardinality operation or activity name.
+        examples: [read, push_to_peer]
+      - id: trogon.eventstore.activity.outcome
+        type: string
+        stability: development
+        brief: Low-cardinality operation outcome.
+        examples: [success, error]
+      - id: trogon.eventstore.cache.name
+        type: string
+        stability: development
+        brief: Cache name.
+        examples: [chunk, stream_info]
+      - id: trogon.eventstore.cache.resource
+        type: string
+        stability: development
+        brief: Cache resource measurement.
+        examples: [size, capacity]
+      - id: trogon.eventstore.cache.result
+        type: string
+        stability: development
+        brief: Cache lookup result.
+        examples: [hit, miss]
+      - id: trogon.eventstore.checkpoint.name
+        type: string
+        stability: development
+        brief: Transaction log checkpoint name.
+        examples: [writer, chaser]
+      - id: trogon.eventstore.checkpoint.read_kind
+        type: string
+        stability: development
+        brief: Checkpoint read mode.
+        examples: [non_flushed]
+      - id: trogon.eventstore.component.name
+        type: string
+        stability: development
+        brief: Component name.
+        examples: [node, index]
+      - id: trogon.eventstore.component.status
+        type: string
+        stability: development
+        brief: Component status.
+        examples: [leader, ready]
+      - id: trogon.eventstore.measurement.window
+        type: string
+        stability: development
+        brief: Time window represented by a rolling measurement.
+        examples: [16-20s]
+      - id: trogon.eventstore.persistent_subscription.group
+        type: string
+        stability: development
+        brief: Persistent subscription group name.
+        examples: [billing]
+      - id: trogon.eventstore.persistent_subscription.reason
+        type: string
+        stability: development
+        brief: Persistent subscription operation reason.
+        examples: [client_nack, max_retries]
+      - id: trogon.eventstore.persistent_subscription.stream
+        type: string
+        stability: development
+        brief: Persistent subscription event source.
+        examples: [orders, "$all"]
+      - id: trogon.eventstore.projection.name
+        type: string
+        stability: development
+        brief: Projection name.
+        examples: [order_totals]
+      - id: trogon.eventstore.projection.status
+        type: string
+        stability: development
+        brief: Projection status.
+        examples: [running, faulted]
+      - id: trogon.eventstore.queue.message.type
+        type: string
+        stability: development
+        brief: Queue message type.
+        examples: [read_stream_events_forward]
+      - id: trogon.eventstore.queue.name
+        type: string
+        stability: development
+        brief: Queue name.
+        examples: [storage_reader]
+      - id: trogon.eventstore.storage.activity
+        type: string
+        stability: development
+        brief: Storage activity.
+        examples: [read, write]
+      - id: trogon.eventstore.storage.source
+        type: string
+        stability: development
+        brief: Source that served a storage read.
+        examples: [chunk_cache, file_system]
+      - id: trogon.eventstore.system.load_average.period
+        type: string
+        stability: development
+        brief: Load average sampling period.
+        examples: [1m, 5m, 15m]
+
+  - id: metric.trogon.eventstore.component.status
+    type: metric
+    stability: development
+    brief: Current component status represented as one-hot state series.
+    metric_name: trogon.eventstore.component.status
+    instrument: updowncounter
+    unit: "1"
+    attributes:
+      - ref: trogon.eventstore.component.name
+        requirement_level: required
+      - ref: trogon.eventstore.component.status
+        requirement_level: required
+  - id: metric.trogon.eventstore.grpc.server.call.duration
+    type: metric
+    stability: development
+    brief: Duration of configured gRPC server calls.
+    metric_name: trogon.eventstore.grpc.server.call.duration
+    instrument: histogram
+    unit: s
+    attributes:
+      - ref: trogon.eventstore.activity.name
+        requirement_level: required
+      - ref: trogon.eventstore.activity.outcome
+        requirement_level: required
+  - id: metric.trogon.eventstore.gossip.exchange.duration
+    type: metric
+    stability: development
+    brief: Duration of gossip exchanges.
+    metric_name: trogon.eventstore.gossip.exchange.duration
+    instrument: histogram
+    unit: s
+    attributes:
+      - ref: trogon.eventstore.activity.name
+        requirement_level: required
+      - ref: trogon.eventstore.activity.outcome
+        requirement_level: required
+  - id: metric.trogon.eventstore.gossip.message.processing.duration
+    type: metric
+    stability: development
+    brief: Duration of gossip message processing.
+    metric_name: trogon.eventstore.gossip.message.processing.duration
+    instrument: histogram
+    unit: s
+    attributes:
+      - ref: trogon.eventstore.activity.name
+        requirement_level: required
+      - ref: trogon.eventstore.activity.outcome
+        requirement_level: required
+  - id: metric.trogon.eventstore.queue.message.wait.duration.max
+    type: metric
+    stability: development
+    brief: Maximum time a message waited in a queue during the measurement window.
+    metric_name: trogon.eventstore.queue.message.wait.duration.max
+    instrument: gauge
+    unit: s
+    attributes:
+      - ref: trogon.eventstore.queue.name
+        requirement_level: required
+      - ref: trogon.eventstore.measurement.window
+        requirement_level: required
+  - id: metric.trogon.eventstore.queue.message.processing.duration
+    type: metric
+    stability: development
+    brief: Duration of queue message processing.
+    metric_name: trogon.eventstore.queue.message.processing.duration
+    instrument: histogram
+    unit: s
+    attributes:
+      - ref: trogon.eventstore.queue.name
+        requirement_level: required
+      - ref: trogon.eventstore.queue.message.type
+        requirement_level: required
+  - id: metric.trogon.eventstore.queue.busy.time
+    type: metric
+    stability: development
+    brief: Total time a queue has spent processing messages.
+    metric_name: trogon.eventstore.queue.busy.time
+    instrument: counter
+    unit: s
+    attributes:
+      - ref: trogon.eventstore.queue.name
+        requirement_level: required
+  - id: metric.trogon.eventstore.queue.message.count
+    type: metric
+    stability: development
+    brief: Number of messages waiting in a queue.
+    metric_name: trogon.eventstore.queue.message.count
+    instrument: updowncounter
+    unit: "{message}"
+    attributes:
+      - ref: trogon.eventstore.queue.name
+        requirement_level: required
+  - id: metric.trogon.eventstore.storage.io
+    type: metric
+    stability: development
+    brief: Bytes transferred by storage operations.
+    metric_name: trogon.eventstore.storage.io
+    instrument: counter
+    unit: By
+    attributes:
+      - ref: trogon.eventstore.storage.activity
+        requirement_level: required
+  - id: metric.trogon.eventstore.storage.event.count
+    type: metric
+    stability: development
+    brief: Number of events processed by storage operations.
+    metric_name: trogon.eventstore.storage.event.count
+    instrument: counter
+    unit: "{event}"
+    attributes:
+      - ref: trogon.eventstore.storage.activity
+        requirement_level: required
+  - id: metric.trogon.eventstore.storage.record.read.duration
+    type: metric
+    stability: development
+    brief: Duration of transaction file record reads.
+    metric_name: trogon.eventstore.storage.record.read.duration
+    instrument: histogram
+    unit: s
+    attributes:
+      - ref: trogon.eventstore.storage.source
+        requirement_level: required
+  - id: metric.trogon.eventstore.cluster.election.count
+    type: metric
+    stability: development
+    brief: Number of cluster elections.
+    metric_name: trogon.eventstore.cluster.election.count
+    instrument: counter
+    unit: "{election}"
+  - id: metric.trogon.eventstore.grpc.server.call.active
+    type: metric
+    stability: development
+    brief: Number of active incoming gRPC calls.
+    metric_name: trogon.eventstore.grpc.server.call.active
+    instrument: updowncounter
+    unit: "{call}"
+  - id: metric.trogon.eventstore.grpc.server.call.count
+    type: metric
+    stability: development
+    brief: Number of incoming gRPC calls.
+    metric_name: trogon.eventstore.grpc.server.call.count
+    instrument: counter
+    unit: "{call}"
+  - id: metric.trogon.eventstore.grpc.server.call.failure.count
+    type: metric
+    stability: development
+    brief: Number of failed incoming gRPC calls.
+    metric_name: trogon.eventstore.grpc.server.call.failure.count
+    instrument: counter
+    unit: "{call}"
+  - id: metric.trogon.eventstore.grpc.server.call.unimplemented.count
+    type: metric
+    stability: development
+    brief: Number of unimplemented incoming gRPC calls.
+    metric_name: trogon.eventstore.grpc.server.call.unimplemented.count
+    instrument: counter
+    unit: "{call}"
+  - id: metric.trogon.eventstore.grpc.server.call.deadline_exceeded.count
+    type: metric
+    stability: development
+    brief: Number of incoming gRPC calls that exceeded their deadline.
+    metric_name: trogon.eventstore.grpc.server.call.deadline_exceeded.count
+    instrument: counter
+    unit: "{call}"
+  - id: metric.trogon.eventstore.cache.operation.count
+    type: metric
+    stability: development
+    brief: Number of cache lookups by result.
+    metric_name: trogon.eventstore.cache.operation.count
+    instrument: counter
+    unit: "{operation}"
+    attributes:
+      - ref: trogon.eventstore.cache.name
+        requirement_level: required
+      - ref: trogon.eventstore.cache.result
+        requirement_level: required
+  - id: metric.trogon.eventstore.cache.resource.size
+    type: metric
+    stability: development
+    brief: Cache resource size and capacity in bytes.
+    metric_name: trogon.eventstore.cache.resource.size
+    instrument: updowncounter
+    unit: By
+    attributes:
+      - ref: trogon.eventstore.cache.name
+        requirement_level: required
+      - ref: trogon.eventstore.cache.resource
+        requirement_level: required
+  - id: metric.trogon.eventstore.cache.resource.count
+    type: metric
+    stability: development
+    brief: Cache resource size, capacity, and count in entries.
+    metric_name: trogon.eventstore.cache.resource.count
+    instrument: updowncounter
+    unit: "{entry}"
+    attributes:
+      - ref: trogon.eventstore.cache.name
+        requirement_level: required
+      - ref: trogon.eventstore.cache.resource
+        requirement_level: required
+  - id: metric.trogon.eventstore.storage.chunk.read.distance
+    type: metric
+    stability: development
+    brief: Logical chunk distance between a read and the writer position.
+    metric_name: trogon.eventstore.storage.chunk.read.distance
+    instrument: histogram
+    unit: "{chunk}"
+  - id: metric.trogon.eventstore.persistent_subscription.connection.count
+    type: metric
+    stability: development
+    brief: Number of persistent subscription connections.
+    metric_name: trogon.eventstore.persistent_subscription.connection.count
+    instrument: updowncounter
+    unit: "{connection}"
+    attributes: &persistent_subscription_attributes
+      - ref: trogon.eventstore.persistent_subscription.stream
+        requirement_level: required
+      - ref: trogon.eventstore.persistent_subscription.group
+        requirement_level: required
+  - id: metric.trogon.eventstore.persistent_subscription.parked_message.count
+    type: metric
+    stability: development
+    brief: Number of parked persistent subscription messages.
+    metric_name: trogon.eventstore.persistent_subscription.parked_message.count
+    instrument: updowncounter
+    unit: "{message}"
+    attributes: *persistent_subscription_attributes
+  - id: metric.trogon.eventstore.persistent_subscription.in_flight_message.count
+    type: metric
+    stability: development
+    brief: Number of in-flight persistent subscription messages.
+    metric_name: trogon.eventstore.persistent_subscription.in_flight_message.count
+    instrument: updowncounter
+    unit: "{message}"
+    attributes: *persistent_subscription_attributes
+  - id: metric.trogon.eventstore.persistent_subscription.oldest_parked_message.age
+    type: metric
+    stability: development
+    brief: Age of the oldest parked persistent subscription message.
+    metric_name: trogon.eventstore.persistent_subscription.oldest_parked_message.age
+    instrument: gauge
+    unit: s
+    attributes: *persistent_subscription_attributes
+  - id: metric.trogon.eventstore.persistent_subscription.park_request.count
+    type: metric
+    stability: development
+    brief: Number of persistent subscription park requests.
+    metric_name: trogon.eventstore.persistent_subscription.park_request.count
+    instrument: counter
+    unit: "{request}"
+    attributes:
+      - ref: trogon.eventstore.persistent_subscription.stream
+        requirement_level: required
+      - ref: trogon.eventstore.persistent_subscription.group
+        requirement_level: required
+      - ref: trogon.eventstore.persistent_subscription.reason
+        requirement_level: required
+  - id: metric.trogon.eventstore.persistent_subscription.parked_message.replay.count
+    type: metric
+    stability: development
+    brief: Number of persistent subscription parked-message replays.
+    metric_name: trogon.eventstore.persistent_subscription.parked_message.replay.count
+    instrument: counter
+    unit: "{operation}"
+    attributes: *persistent_subscription_attributes
+  - id: metric.trogon.eventstore.persistent_subscription.parked_message.truncate.count
+    type: metric
+    stability: development
+    brief: Number of persistent subscription parked-message truncations.
+    metric_name: trogon.eventstore.persistent_subscription.parked_message.truncate.count
+    instrument: counter
+    unit: "{operation}"
+    attributes: *persistent_subscription_attributes
+  - id: metric.trogon.eventstore.persistent_subscription.item.processed.count
+    type: metric
+    stability: development
+    brief: Number of items processed by persistent subscriptions.
+    metric_name: trogon.eventstore.persistent_subscription.item.processed.count
+    instrument: counter
+    unit: "{item}"
+    attributes: *persistent_subscription_attributes
+  - id: metric.trogon.eventstore.persistent_subscription.last_known.event.revision
+    type: metric
+    stability: development
+    brief: Last known stream revision for persistent subscriptions.
+    metric_name: trogon.eventstore.persistent_subscription.last_known.event.revision
+    instrument: gauge
+    unit: "1"
+    attributes: *persistent_subscription_attributes
+  - id: metric.trogon.eventstore.persistent_subscription.last_known.commit.position
+    type: metric
+    stability: development
+    brief: Last known commit position for persistent subscriptions.
+    metric_name: trogon.eventstore.persistent_subscription.last_known.commit.position
+    instrument: gauge
+    unit: "1"
+    attributes: *persistent_subscription_attributes
+  - id: metric.trogon.eventstore.persistent_subscription.checkpoint.event.revision
+    type: metric
+    stability: development
+    brief: Last checkpointed stream revision for persistent subscriptions.
+    metric_name: trogon.eventstore.persistent_subscription.checkpoint.event.revision
+    instrument: gauge
+    unit: "1"
+    attributes: *persistent_subscription_attributes
+  - id: metric.trogon.eventstore.persistent_subscription.checkpoint.commit.position
+    type: metric
+    stability: development
+    brief: Last checkpointed commit position for persistent subscriptions.
+    metric_name: trogon.eventstore.persistent_subscription.checkpoint.commit.position
+    instrument: gauge
+    unit: "1"
+    attributes: *persistent_subscription_attributes
+  - id: metric.trogon.eventstore.checkpoint.position
+    type: metric
+    stability: development
+    brief: Transaction log checkpoint position.
+    metric_name: trogon.eventstore.checkpoint.position
+    instrument: gauge
+    unit: "1"
+    attributes:
+      - ref: trogon.eventstore.checkpoint.name
+        requirement_level: required
+      - ref: trogon.eventstore.checkpoint.read_kind
+        requirement_level: required
+  - id: metric.trogon.eventstore.writer.flush.size.max
+    type: metric
+    stability: development
+    brief: Maximum writer flush size during the measurement window.
+    metric_name: trogon.eventstore.writer.flush.size.max
+    instrument: gauge
+    unit: By
+    attributes:
+      - ref: trogon.eventstore.measurement.window
+        requirement_level: required
+  - id: metric.trogon.eventstore.writer.flush.duration.max
+    type: metric
+    stability: development
+    brief: Maximum writer flush duration during the measurement window.
+    metric_name: trogon.eventstore.writer.flush.duration.max
+    instrument: gauge
+    unit: s
+    attributes:
+      - ref: trogon.eventstore.measurement.window
+        requirement_level: required
+  - id: metric.trogon.eventstore.system.load_average
+    type: metric
+    stability: development
+    brief: System load average.
+    metric_name: trogon.eventstore.system.load_average
+    instrument: gauge
+    unit: "1"
+    attributes:
+      - ref: trogon.eventstore.system.load_average.period
+        requirement_level: required
+  - id: metric.trogon.eventstore.process.disk.operation.count
+    type: metric
+    stability: development
+    brief: Number of disk operations performed by the process.
+    metric_name: trogon.eventstore.process.disk.operation.count
+    instrument: counter
+    unit: "{operation}"
+    attributes:
+      - ref: disk.io.direction
+        requirement_level: required
+  - id: metric.trogon.eventstore.projection.event.processed.count
+    type: metric
+    stability: development
+    brief: Number of events processed by a projection after restart.
+    metric_name: trogon.eventstore.projection.event.processed.count
+    instrument: counter
+    unit: "{event}"
+    attributes:
+      - ref: trogon.eventstore.projection.name
+        requirement_level: required
+  - id: metric.trogon.eventstore.projection.progress
+    type: metric
+    stability: development
+    brief: Fraction of projection processing completed.
+    metric_name: trogon.eventstore.projection.progress
+    instrument: gauge
+    unit: "1"
+    attributes:
+      - ref: trogon.eventstore.projection.name
+        requirement_level: required
+  - id: metric.trogon.eventstore.projection.status
+    type: metric
+    stability: development
+    brief: Projection state represented as one active status series.
+    metric_name: trogon.eventstore.projection.status
+    instrument: updowncounter
+    unit: "1"
+    attributes:
+      - ref: trogon.eventstore.projection.name
+        requirement_level: required
+      - ref: trogon.eventstore.projection.status
+        requirement_level: required
+  - id: metric.trogon.eventstore.projection.state.size
+    type: metric
+    stability: development
+    brief: Projection state size.
+    metric_name: trogon.eventstore.projection.state.size
+    instrument: updowncounter
+    unit: By
+    attributes:
+      - ref: trogon.eventstore.projection.name
+        requirement_level: required
diff --git a/otel/semconv/templates/registry/csharp/metric-names.cs.j2 b/otel/semconv/templates/registry/csharp/metric-names.cs.j2
new file mode 100644
index 0000000000..ca88be8329
--- /dev/null
+++ b/otel/semconv/templates/registry/csharp/metric-names.cs.j2
@@ -0,0 +1,33 @@
+// <auto-generated />
+
+using System;
+using System.Collections.Generic;
+
+namespace TrogonEventStore.SemanticConventions
+{
+	public static class MetricDefinitions
+	{
+{% for group in ctx %}
+{% for metric in group.metrics | sort(attribute="metric_name") %}
+		public static MetricDefinition {{ metric.metric_name | pascal_case | regex_replace("^Eventstore", "") }} { get; } = new MetricDefinition(
+			"{{ metric.metric_name }}",
+			"{{ metric.unit }}",
+			"{{ metric.brief }}",
+{% if metric.instrument == "updowncounter" %}
+			MetricInstrumentKind.UpDownCounter);
+{% else %}
+			MetricInstrumentKind.{{ metric.instrument | pascal_case }});
+{% endif %}
+{% endfor %}
+{% endfor %}
+
+		public static IReadOnlyList<MetricDefinition> All { get; } = Array.AsReadOnly(new[]
+		{
+{% for group in ctx %}
+{% for metric in group.metrics | sort(attribute="metric_name") %}
+			{{ metric.metric_name | pascal_case | regex_replace("^Eventstore", "") }},
+{% endfor %}
+{% endfor %}
+		});
+	}
+}{{ "\n" }}
diff --git a/otel/semconv/templates/registry/csharp/open-telemetry-metric-definitions.cs.j2 b/otel/semconv/templates/registry/csharp/open-telemetry-metric-definitions.cs.j2
new file mode 100644
index 0000000000..cef68ff3d5
--- /dev/null
+++ b/otel/semconv/templates/registry/csharp/open-telemetry-metric-definitions.cs.j2
@@ -0,0 +1,33 @@
+// <auto-generated />
+
+using System;
+using System.Collections.Generic;
+
+namespace TrogonEventStore.SemanticConventions
+{
+	public static class OpenTelemetryMetricDefinitions
+	{
+{% for group in ctx %}
+{% for metric in group.metrics | sort(attribute="metric_name") %}
+		public static MetricDefinition {{ metric.metric_name | pascal_case }} { get; } = new MetricDefinition(
+			"{{ metric.metric_name }}",
+			"{{ metric.unit }}",
+			"{{ metric.brief }}",
+{% if metric.instrument == "updowncounter" %}
+			MetricInstrumentKind.UpDownCounter);
+{% else %}
+			MetricInstrumentKind.{{ metric.instrument | pascal_case }});
+{% endif %}
+{% endfor %}
+{% endfor %}
+
+		public static IReadOnlyList<MetricDefinition> All { get; } = Array.AsReadOnly(new[]
+		{
+{% for group in ctx %}
+{% for metric in group.metrics | sort(attribute="metric_name") %}
+			{{ metric.metric_name | pascal_case }},
+{% endfor %}
+{% endfor %}
+		});
+	}
+}{{ "\n" }}
diff --git a/otel/semconv/templates/registry/csharp/trogon-attribute-names.cs.j2 b/otel/semconv/templates/registry/csharp/trogon-attribute-names.cs.j2
new file mode 100644
index 0000000000..20fff3d491
--- /dev/null
+++ b/otel/semconv/templates/registry/csharp/trogon-attribute-names.cs.j2
@@ -0,0 +1,25 @@
+// <auto-generated />
+
+using System;
+using System.Collections.Generic;
+
+namespace TrogonEventStore.SemanticConventions
+{
+	public static class TrogonAttributeNames
+	{
+{% for group in ctx %}
+{% for attribute in group.attributes | sort(attribute="name") %}
+		public const string {{ attribute.name | pascal_case | regex_replace("^TrogonEventstore", "") }} = "{{ attribute.name }}";
+{% endfor %}
+{% endfor %}
+
+		public static IReadOnlyList<string> All { get; } = Array.AsReadOnly(new[]
+		{
+{% for group in ctx %}
+{% for attribute in group.attributes | sort(attribute="name") %}
+			{{ attribute.name | pascal_case | regex_replace("^TrogonEventstore", "") }},
+{% endfor %}
+{% endfor %}
+		});
+	}
+}{{ "\n" }}
diff --git a/otel/semconv/templates/registry/csharp/weaver.yaml b/otel/semconv/templates/registry/csharp/weaver.yaml
index 416da1351b..1c4a9789dc 100644
--- a/otel/semconv/templates/registry/csharp/weaver.yaml
+++ b/otel/semconv/templates/registry/csharp/weaver.yaml
@@ -2,18 +2,80 @@ whitespace_control:
   trim_blocks: true
   lstrip_blocks: true
 
+params:
+  attributes: true
+  custom_attributes: false
+  metrics: true
+  official_metrics: false
+
 templates:
   - template: attribute-names.cs.j2
     filter: >
-      semconv_grouped_attributes
-      | map({
-          root_namespace: .root_namespace,
-          attributes: [.attributes[] | select(
-            .name == "service.name" or
-            .name == "service.instance.id" or
-            .name == "service.version"
-          )]
-        })
-      | map(select(.attributes | length > 0))
+      if $attributes then
+        semconv_grouped_attributes
+        | map({
+            root_namespace: .root_namespace,
+            attributes: [.attributes[] | select(
+              .name == "disk.io.direction" or
+              .name == "host.arch" or
+              .name == "host.name" or
+              .name == "process.creation.time" or
+              .name == "process.executable.name" or
+              .name == "process.pid" or
+              .name == "process.runtime.name" or
+              .name == "process.runtime.version" or
+              .name == "service.name" or
+              .name == "service.instance.id" or
+              .name == "service.version" or
+              .name == "system.filesystem.mountpoint" or
+              .name == "system.filesystem.state"
+            )]
+          })
+        | map(select(.attributes | length > 0))
+      else
+        empty
+      end
     application_mode: single
     file_name: AttributeNames.g.cs
+  - template: metric-names.cs.j2
+    filter: >
+      if $metrics then
+        semconv_grouped_metrics
+      else
+        empty
+      end
+    application_mode: single
+    file_name: MetricDefinitions.g.cs
+  - template: trogon-attribute-names.cs.j2
+    filter: >
+      if $custom_attributes then
+        semconv_grouped_attributes
+        | map({
+            root_namespace: .root_namespace,
+            attributes: [.attributes[] | select(.name | startswith("trogon.eventstore."))]
+          })
+        | map(select(.attributes | length > 0))
+      else
+        empty
+      end
+    application_mode: single
+    file_name: TrogonAttributeNames.g.cs
+  - template: open-telemetry-metric-definitions.cs.j2
+    filter: >
+      if $official_metrics then
+        semconv_grouped_metrics
+        | map({
+            root_namespace: .root_namespace,
+            metrics: [.metrics[] | select(
+              .metric_name == "process.uptime" or
+              .metric_name == "process.disk.io" or
+              .metric_name == "system.filesystem.usage" or
+              .metric_name == "system.filesystem.limit"
+            )]
+          })
+        | map(select(.metrics | length > 0))
+      else
+        empty
+      end
+    application_mode: single
+    file_name: OpenTelemetryMetricDefinitions.g.cs
diff --git a/src/EventStore.ClusterNode/metricsconfig.json b/src/EventStore.ClusterNode/metricsconfig.json
index ac6aaae24f..cb1edb93ff 100644
--- a/src/EventStore.ClusterNode/metricsconfig.json
+++ b/src/EventStore.ClusterNode/metricsconfig.json
@@ -70,43 +70,16 @@
 
 	"CacheResources": true,
 
-	"Kestrel": {
-		"ConnectionCount": true
-	},
-
 	"System": {
-		"Cpu": true,
 		"LoadAverage1m": true,
 		"LoadAverage5m": true,
 		"LoadAverage15m": true,
-		"FreeMem": true,
-		"TotalMem": true,
 		"DriveTotalBytes": true,
 		"DriveUsedBytes": true
 	},
 
 	"Process": {
 		"UpTime": true,
-		"Cpu": true,
-		"MemWorkingSet": true,
-		"MemPagedBytes": false,
-		"MemVirtualBytes": false,
-		"ThreadCount": true,
-		"ThreadPoolPendingWorkItemCount": true,
-		"LockContentionCount": true,
-		"ExceptionCount": true,
-		"Gen0CollectionCount": true,
-		"Gen1CollectionCount": true,
-		"Gen2CollectionCount": true,
-		"Gen0Size": true,
-		"Gen1Size": true,
-		"Gen2Size": true,
-		"LohSize": true,
-		"TimeInGc": true,
-		"GcPauseDuration": true,
-		"HeapSize": true,
-		"HeapFragmentation": true,
-		"TotalAllocatedBytes": true,
 		"DiskReadBytes": true,
 		"DiskReadOps": true,
 		"DiskWrittenBytes": true,
diff --git a/src/EventStore.Common/Configuration/MetricsConfiguration.cs b/src/EventStore.Common/Configuration/MetricsConfiguration.cs
index 934c12dbef..34fb230ce2 100644
--- a/src/EventStore.Common/Configuration/MetricsConfiguration.cs
+++ b/src/EventStore.Common/Configuration/MetricsConfiguration.cs
@@ -87,19 +87,11 @@ public enum Cache
 		Chunk,
 	}
 
-	public enum KestrelTracker
-	{
-		ConnectionCount = 1,
-	}
-
 	public enum SystemTracker
 	{
-		Cpu = 1,
-		LoadAverage1m,
+		LoadAverage1m = 1,
 		LoadAverage5m,
 		LoadAverage15m,
-		FreeMem,
-		TotalMem,
 		DriveTotalBytes,
 		DriveUsedBytes,
 	}
@@ -107,30 +99,10 @@ public enum SystemTracker
 	public enum ProcessTracker
 	{
 		UpTime = 1,
-		Cpu,
-		MemWorkingSet,
-		MemPagedBytes,
-		MemVirtualBytes,
-		ThreadCount,
-		ThreadPoolPendingWorkItemCount,
-		LockContentionCount,
-		ExceptionCount,
-		Gen0CollectionCount,
-		Gen1CollectionCount,
-		Gen2CollectionCount,
-		Gen0Size,
-		Gen1Size,
-		Gen2Size,
-		LohSize,
-		TimeInGc,
-		HeapSize,
-		HeapFragmentation,
-		TotalAllocatedBytes,
 		DiskReadBytes,
 		DiskReadOps,
 		DiskWrittenBytes,
 		DiskWrittenOps,
-		GcPauseDuration,
 	}
 
 	public enum QueueTracker
@@ -163,8 +135,6 @@ public class OtlpExporterConfiguration
 
 	public Dictionary<GossipTracker, bool> Gossip { get; set; } = new();
 
-	public Dictionary<KestrelTracker, bool> Kestrel { get; set; } = new();
-
 	public Dictionary<SystemTracker, bool> System { get; set; } = new();
 
 	public Dictionary<ProcessTracker, bool> Process { get; set; } = new();
diff --git a/src/EventStore.Core.XUnit.Tests/Index/IndexStatusTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Index/IndexStatusTrackerTests.cs
index 4c2734f40c..7e330e4f74 100644
--- a/src/EventStore.Core.XUnit.Tests/Index/IndexStatusTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Index/IndexStatusTrackerTests.cs
@@ -4,6 +4,7 @@
 using EventStore.Core.Index;
 using EventStore.Core.Metrics;
 using EventStore.Core.XUnit.Tests.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Index;
@@ -11,7 +12,6 @@ namespace EventStore.Core.XUnit.Tests.Index;
 public class IndexStatusTrackerTests : IDisposable
 {
 	private readonly TestMeterListener<long> _listener;
-	private readonly FakeClock _clock = new();
 	private readonly StatusMetric _metric;
 	private readonly IndexStatusTracker _sut;
 
@@ -21,8 +21,7 @@ public IndexStatusTrackerTests()
 		_listener = new TestMeterListener<long>(meter);
 		_metric = new StatusMetric(
 			meter,
-			"eventstore-statuses",
-			_clock);
+			MetricDefinitions.TrogonEventstoreComponentStatus);
 		_sut = new IndexStatusTracker(_metric);
 	}
 
@@ -34,104 +33,86 @@ public void Dispose()
 	[Fact]
 	public void can_observe_opening()
 	{
-		_clock.SecondsSinceEpoch = 500;
-		AssertMeasurements("Idle", 500);
+		AssertMeasurements("Idle");
 
 		using (_sut.StartOpening())
 		{
-			_clock.SecondsSinceEpoch = 501;
-			AssertMeasurements("Opening", 501);
+			AssertMeasurements("Opening");
 		}
 
-		_clock.SecondsSinceEpoch = 502;
-		AssertMeasurements("Idle", 502);
+		AssertMeasurements("Idle");
 	}
 
 	[Fact]
 	public void can_observe_rebuilding()
 	{
-		_clock.SecondsSinceEpoch = 500;
-		AssertMeasurements("Idle", 500);
+		AssertMeasurements("Idle");
 
 		using (_sut.StartRebuilding())
 		{
-			_clock.SecondsSinceEpoch = 501;
-			AssertMeasurements("Rebuilding", 501);
+			AssertMeasurements("Rebuilding");
 		}
 
-		_clock.SecondsSinceEpoch = 502;
-		AssertMeasurements("Idle", 502);
+		AssertMeasurements("Idle");
 	}
 
 	[Fact]
 	public void can_observe_initializing()
 	{
-		_clock.SecondsSinceEpoch = 500;
-		AssertMeasurements("Idle", 500);
+		AssertMeasurements("Idle");
 
 		using (_sut.StartInitializing())
 		{
-			_clock.SecondsSinceEpoch = 501;
-			AssertMeasurements("Initializing", 501);
+			AssertMeasurements("Initializing");
 		}
 
-		_clock.SecondsSinceEpoch = 502;
-		AssertMeasurements("Idle", 502);
+		AssertMeasurements("Idle");
 	}
 
 	[Fact]
 	public void can_observe_merging()
 	{
-		_clock.SecondsSinceEpoch = 500;
-		AssertMeasurements("Idle", 500);
+		AssertMeasurements("Idle");
 
 		using (_sut.StartMerging())
 		{
-			_clock.SecondsSinceEpoch = 501;
-			AssertMeasurements("Merging", 501);
+			AssertMeasurements("Merging");
 		}
 
-		_clock.SecondsSinceEpoch = 502;
-		AssertMeasurements("Idle", 502);
+		AssertMeasurements("Idle");
 	}
 
 	[Fact]
 	public void can_observe_scavenging()
 	{
-		_clock.SecondsSinceEpoch = 500;
-		AssertMeasurements("Idle", 500);
+		AssertMeasurements("Idle");
 
 		using (_sut.StartScavenging())
 		{
-			_clock.SecondsSinceEpoch = 501;
-			AssertMeasurements("Scavenging", 501);
+			AssertMeasurements("Scavenging");
 		}
 
-		_clock.SecondsSinceEpoch = 502;
-		AssertMeasurements("Idle", 502);
+		AssertMeasurements("Idle");
 	}
 
-	void AssertMeasurements(string expectedStatus, int expectedValue)
+	void AssertMeasurements(string expectedStatus)
 	{
 		_listener.Observe();
 
+		var measurements = _listener.RetrieveMeasurements(MetricDefinitions.TrogonEventstoreComponentStatus.Name);
+		var active = Assert.Single(measurements, measurement => measurement.Value == 1);
+		Assert.All(measurements.Where(measurement => measurement != active), measurement => Assert.Equal(0, measurement.Value));
 		Assert.Collection(
-			_listener.RetrieveMeasurements("eventstore-statuses"),
-			m =>
+			active.Tags.ToArray(),
+			t =>
 			{
-				Assert.Equal(expectedValue, m.Value);
-				Assert.Collection(
-					m.Tags.ToArray(),
-					t =>
-					{
-						Assert.Equal("name", t.Key);
-						Assert.Equal("Index", t.Value);
-					},
-					t =>
-					{
-						Assert.Equal("status", t.Key);
-						Assert.Equal(expectedStatus, t.Value);
-					});
+				Assert.Equal(TrogonAttributeNames.ComponentName, t.Key);
+				Assert.Equal("index", t.Value);
+			},
+			t =>
+			{
+				Assert.Equal(TrogonAttributeNames.ComponentStatus, t.Key);
+				Assert.Equal(expectedStatus.ToLowerInvariant(), t.Value);
 			});
 	}
 }
diff --git a/src/EventStore.Core.XUnit.Tests/Index/IndexTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Index/IndexTrackerTests.cs
index a2d7e88d3c..d2f8a23032 100644
--- a/src/EventStore.Core.XUnit.Tests/Index/IndexTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Index/IndexTrackerTests.cs
@@ -6,6 +6,7 @@
 using EventStore.Core.Metrics;
 using EventStore.Core.TransactionLog.LogRecords;
 using EventStore.Core.XUnit.Tests.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Index;
@@ -20,8 +21,9 @@ public IndexTrackerTests()
 		var meter = new Meter($"{typeof(IndexTrackerTests)}");
 		_listener = new TestMeterListener<long>(meter);
 
-		var eventMetric = new CounterMetric(meter, "eventstore-io", "events");
-		_sut = new IndexTracker(new CounterSubMetric(eventMetric, new[] { new KeyValuePair<string, object>("activity", "written") }));
+		var eventMetric = new CounterMetric(meter, MetricDefinitions.TrogonEventstoreStorageEventCount);
+		_sut = new IndexTracker(new CounterSubMetric(eventMetric,
+			new[] { new KeyValuePair<string, object>(TrogonAttributeNames.StorageActivity, "write") }));
 	}
 
 	public void Dispose()
@@ -53,14 +55,14 @@ private static PrepareLogRecord CreatePrepare()
 	private void AssertMeasurements(long expectedEventsWritten)
 	{
 		Assert.Collection(
-			_listener.RetrieveMeasurements("eventstore-io-events"),
+			_listener.RetrieveMeasurements(MetricDefinitions.TrogonEventstoreStorageEventCount.Name),
 			m =>
 			{
 				Assert.Equal(expectedEventsWritten, m.Value);
 				Assert.Collection(m.Tags.ToArray(), t =>
 				{
-					Assert.Equal("activity", t.Key);
-					Assert.Equal("written", t.Value);
+					Assert.Equal(TrogonAttributeNames.StorageActivity, t.Key);
+					Assert.Equal("write", t.Value);
 				});
 			});
 	}
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/AverageMetricTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/AverageMetricTests.cs
index ebfe0472a6..8f0da1aa7d 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/AverageMetricTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/AverageMetricTests.cs
@@ -1,36 +1,41 @@
 using System.Diagnostics.Metrics;
 using EventStore.Core.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
 
-public class AverageMetricTests
+public class SummedCounterMetricTests
 {
 	[Fact]
-	public void calculates_average()
+	public void calculates_sum()
 	{
 		using var meter = new Meter($"{typeof(QueueProcessingTrackerTests)}");
 		using var listener = new TestMeterListener<double>(meter);
-		var sut = new AverageMetric(meter, "the-metric", "seconds", label => new("queue", label));
+		var definition = MetricDefinitions.TrogonEventstoreQueueBusyTime;
+		var sut = new SummedCounterMetric(
+			meter,
+			definition,
+			label => new(TrogonAttributeNames.QueueName, label));
 		sut.Register("readers", () => 1);
 		sut.Register("readers", () => 2);
 		sut.Register("writer", () => 3);
 		listener.Observe();
 
 		Assert.Collection(
-			listener.RetrieveMeasurements("the-metric-seconds"),
+			listener.RetrieveMeasurements(definition.Name),
 				m =>
 				{
-					Assert.Equal(1.5, m.Value);
+					Assert.Equal(3, m.Value);
 					var tag = Assert.Single(m.Tags);
-					Assert.Equal("queue", tag.Key);
+					Assert.Equal(TrogonAttributeNames.QueueName, tag.Key);
 					Assert.Equal("readers", tag.Value);
 				},
 				m =>
 				{
 					Assert.Equal(3, m.Value);
 					var tag = Assert.Single(m.Tags);
-					Assert.Equal("queue", tag.Key);
+					Assert.Equal(TrogonAttributeNames.QueueName, tag.Key);
 					Assert.Equal("writer", tag.Value);
 				});
 	}
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/CacheHitsMiseesTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/CacheHitsMiseesTrackerTests.cs
index f895676349..02cc9801eb 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/CacheHitsMiseesTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/CacheHitsMiseesTrackerTests.cs
@@ -5,6 +5,7 @@
 using DotNext.Runtime.CompilerServices;
 using EventStore.Core.Metrics;
 using EventStore.Core.Tests;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 using static EventStore.Common.Configuration.MetricsConfiguration;
@@ -30,7 +31,11 @@ public void Dispose()
 
 		var listener = new TestMeterListener<long>(meter);
 		_disposables.RegisterForDispose(listener);
-		var metric = new CacheHitsMissesMetric(meter, enabledCaches, "the-metric", new() {
+		var metric = new CacheHitsMissesMetric(
+			meter,
+			enabledCaches,
+			MetricDefinitions.TrogonEventstoreCacheOperationCount,
+			new() {
 			{ Cache.StreamInfo, "stream-info" },
 			{ Cache.Chunk, "chunk" },
 		});
@@ -45,10 +50,10 @@ public void observes_all_caches()
 		sut.Register(Cache.Chunk, () => 1, () => 2);
 		sut.Register(Cache.StreamInfo, () => 3, () => 4);
 		AssertMeasurements(listener,
-			AssertMeasurement("chunk", "hits", 1),
-			AssertMeasurement("chunk", "misses", 2),
-			AssertMeasurement("stream-info", "hits", 3),
-			AssertMeasurement("stream-info", "misses", 4));
+			AssertMeasurement("chunk", "hit", 1),
+			AssertMeasurement("chunk", "miss", 2),
+			AssertMeasurement("stream-info", "hit", 3),
+			AssertMeasurement("stream-info", "miss", 4));
 	}
 
 	[Fact]
@@ -58,8 +63,8 @@ public void ignores_disabled_cache()
 		sut.Register(Cache.Chunk, () => 1, () => 2);
 		sut.Register(Cache.StreamInfo, () => 3, () => 4);
 		AssertMeasurements(listener,
-			AssertMeasurement("stream-info", "hits", 3),
-			AssertMeasurement("stream-info", "misses", 4));
+			AssertMeasurement("stream-info", "hit", 3),
+			AssertMeasurement("stream-info", "miss", 4));
 	}
 
 	[Fact]
@@ -68,8 +73,8 @@ public void ignores_unregistered_cache()
 		var (sut, listener) = GenSut(new[] { Cache.Chunk, Cache.StreamInfo });
 		sut.Register(Cache.Chunk, () => 1, () => 2);
 		AssertMeasurements(listener,
-			AssertMeasurement("chunk", "hits", 1),
-			AssertMeasurement("chunk", "misses", 2));
+			AssertMeasurement("chunk", "hit", 1),
+			AssertMeasurement("chunk", "miss", 2));
 	}
 
 	static Action<TestMeterListener<long>.TestMeasurement> AssertMeasurement(
@@ -84,12 +89,12 @@ public void ignores_unregistered_cache()
 				actualMeasurement.Tags.ToArray(),
 				tag =>
 				{
-					Assert.Equal("cache", tag.Key);
+					Assert.Equal(TrogonAttributeNames.CacheName, tag.Key);
 					Assert.Equal(cacheName, tag.Value);
 				},
 				tag =>
 				{
-					Assert.Equal("kind", tag.Key);
+					Assert.Equal(TrogonAttributeNames.CacheResult, tag.Key);
 					Assert.Equal(kind, tag.Value);
 				});
 		};
@@ -100,6 +105,8 @@ static void AssertMeasurements(
 	{
 
 		listener.Observe();
-		Assert.Collection(listener.RetrieveMeasurements("the-metric"), actions);
+		Assert.Collection(
+			listener.RetrieveMeasurements(MetricDefinitions.TrogonEventstoreCacheOperationCount.Name),
+			actions);
 	}
 }
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/CacheResourcesTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/CacheResourcesTrackerTests.cs
index 09ce8224da..6501fd7bf4 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/CacheResourcesTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/CacheResourcesTrackerTests.cs
@@ -5,6 +5,7 @@
 using DotNext.Runtime.CompilerServices;
 using EventStore.Core.Metrics;
 using EventStore.Core.Tests;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
@@ -27,7 +28,10 @@ public void Dispose()
 
 		var listener = new TestMeterListener<long>(meter);
 		_disposables.RegisterForDispose(listener);
-		var metrics = new CacheResourcesMetrics(meter, "the-metric");
+		var metrics = new CacheResourcesMetrics(
+			meter,
+			MetricDefinitions.TrogonEventstoreCacheResourceSize,
+			MetricDefinitions.TrogonEventstoreCacheResourceCount);
 		var sut = new CacheResourcesTracker(metrics);
 		return (sut, listener);
 	}
@@ -50,13 +54,13 @@ public void observes_all_caches()
 			numChildren: 0));
 
 		listener.Observe();
-		AssertMeasurements(listener, "the-metric-entries",
+		AssertMeasurements(listener, MetricDefinitions.TrogonEventstoreCacheResourceCount.Name,
 			AssertMeasurement("cacheA", "capacity", 1),
 			AssertMeasurement("cacheA", "size", 2),
 			AssertMeasurement("cacheA", "count", 3),
 			AssertMeasurement("cacheB", "count", 6));
 
-		AssertMeasurements(listener, "the-metric-bytes",
+		AssertMeasurements(listener, MetricDefinitions.TrogonEventstoreCacheResourceSize.Name,
 			AssertMeasurement("cacheB", "capacity", 4),
 			AssertMeasurement("cacheB", "size", 5));
 	}
@@ -73,12 +77,12 @@ public void observes_all_caches()
 				actualMeasurement.Tags.ToArray(),
 				tag =>
 				{
-					Assert.Equal("cache", tag.Key);
+					Assert.Equal(TrogonAttributeNames.CacheName, tag.Key);
 					Assert.Equal(cacheKey, tag.Value);
 				},
 				tag =>
 				{
-					Assert.Equal("kind", tag.Key);
+					Assert.Equal(TrogonAttributeNames.CacheResource, tag.Key);
 					Assert.Equal(kind, tag.Value);
 				});
 		};
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/DurationMaxTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/DurationMaxTrackerTests.cs
index f43717223a..f3427a5ff5 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/DurationMaxTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/DurationMaxTrackerTests.cs
@@ -2,6 +2,7 @@
 using System.Diagnostics.Metrics;
 using System.Linq;
 using EventStore.Core.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
@@ -11,12 +12,14 @@ public class DurationMaxTrackerTests : IDisposable
 	private readonly TestMeterListener<double> _listener;
 	private readonly FakeClock _clock = new();
 	private readonly DurationMaxTracker _sut;
+	private readonly MetricDefinition _definition =
+		MetricDefinitions.TrogonEventstoreQueueMessageWaitDurationMax;
 
 	public DurationMaxTrackerTests()
 	{
 		var meter = new Meter($"{typeof(DurationMaxTrackerTests)}");
 		_listener = new TestMeterListener<double>(meter);
-		var metric = new DurationMaxMetric(meter, "the-metric");
+		var metric = new DurationMaxMetric(meter, _definition);
 		_sut = new DurationMaxTracker(
 			metric: metric,
 			name: "the-tracker",
@@ -173,7 +176,7 @@ void AssertMeasurements(double expectedValue)
 		_listener.Observe();
 
 		Assert.Collection(
-			_listener.RetrieveMeasurements("the-metric-seconds"),
+			_listener.RetrieveMeasurements(_definition.Name),
 			m =>
 			{
 				Assert.Equal(expectedValue, m.Value);
@@ -181,13 +184,13 @@ void AssertMeasurements(double expectedValue)
 					m.Tags.ToArray(),
 					t =>
 					{
-						Assert.Equal("name", t.Key);
+						Assert.Equal(TrogonAttributeNames.QueueName, t.Key);
 						Assert.Equal("the-tracker", t.Value);
 					},
 					t =>
 					{
-						Assert.Equal("range", t.Key);
-						Assert.Equal("16-20 seconds", t.Value);
+						Assert.Equal(TrogonAttributeNames.MeasurementWindow, t.Key);
+						Assert.Equal("16-20s", t.Value);
 					});
 			});
 	}
@@ -198,14 +201,14 @@ public void no_name()
 		using var meter = new Meter($"{typeof(DurationMaxTrackerTests)}");
 		using var listener = new TestMeterListener<double>(meter);
 		var sut = new DurationMaxTracker(
-			metric: new DurationMaxMetric(meter, "the-metric"),
+			metric: new DurationMaxMetric(meter, _definition),
 			name: null,
 			expectedScrapeIntervalSeconds: 15);
 
 		listener.Observe();
 
 		Assert.Collection(
-			listener.RetrieveMeasurements("the-metric-seconds"),
+			listener.RetrieveMeasurements(_definition.Name),
 			m =>
 			{
 				Assert.Equal(0, m.Value);
@@ -213,8 +216,8 @@ public void no_name()
 					m.Tags.ToArray(),
 					t =>
 					{
-						Assert.Equal("range", t.Key);
-						Assert.Equal("16-20 seconds", t.Value);
+						Assert.Equal(TrogonAttributeNames.MeasurementWindow, t.Key);
+						Assert.Equal("16-20s", t.Value);
 					});
 			});
 	}
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/DurationTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/DurationTrackerTests.cs
index 045f59dba4..97d30af168 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/DurationTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/DurationTrackerTests.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics.Metrics;
 using EventStore.Core.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
@@ -10,12 +11,14 @@ public class DurationTrackerTests : IDisposable
 	private readonly TestMeterListener<double> _listener;
 	private readonly FakeClock _clock = new();
 	private readonly DurationTracker _sut;
+	private readonly MetricDefinition _definition =
+		MetricDefinitions.TrogonEventstoreGossipExchangeDuration;
 
 	public DurationTrackerTests()
 	{
 		var meter = new Meter($"{typeof(DurationTrackerTests)}");
 		_listener = new TestMeterListener<double>(meter);
-		var durationMetric = new DurationMetric(meter, "the-histogram", _clock);
+		var durationMetric = new DurationMetric(meter, _definition, _clock);
 		_sut = new DurationTracker(durationMetric, "the-duration");
 	}
 
@@ -33,7 +36,7 @@ public void records_success()
 			_clock.SecondsSinceEpoch = 501;
 		}
 
-		AssertMeasurements("successful", 1);
+		AssertMeasurements("success", 1);
 	}
 
 	[Fact]
@@ -46,7 +49,7 @@ public void records_failure()
 			duration.SetException(new Exception("failed"));
 		}
 
-		AssertMeasurements("failed", 1);
+		AssertMeasurements("error", 1);
 	}
 
 	void AssertMeasurements(
@@ -55,7 +58,7 @@ void AssertMeasurements(
 	{
 
 		Assert.Collection(
-			_listener.RetrieveMeasurements("the-histogram-seconds"),
+			_listener.RetrieveMeasurements(_definition.Name),
 			m =>
 			{
 				Assert.Equal(expectedValue, m.Value);
@@ -63,12 +66,12 @@ void AssertMeasurements(
 					m.Tags,
 					t =>
 					{
-						Assert.Equal("activity", t.Key);
+						Assert.Equal(TrogonAttributeNames.ActivityName, t.Key);
 						Assert.Equal("the-duration", t.Value);
 					},
 					t =>
 					{
-						Assert.Equal("status", t.Key);
+						Assert.Equal(TrogonAttributeNames.ActivityOutcome, t.Key);
 						Assert.Equal(expectedStatus, t.Value);
 					});
 			});
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/ElectionsCounterTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/ElectionsCounterTrackerTests.cs
index 1066300230..4b2e6ba989 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/ElectionsCounterTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/ElectionsCounterTrackerTests.cs
@@ -8,6 +8,7 @@
 using EventStore.Core.Messages;
 using EventStore.Core.Metrics;
 using EventStore.Core.Tests;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
@@ -16,6 +17,8 @@ public class ElectionsCounterTrackerTests : IDisposable
 {
 	private Scope _disposables = new();
 	private readonly ElectionMessage.ElectionsDone _electionsDoneMessage;
+	private static readonly MetricDefinition Definition =
+		MetricDefinitions.TrogonEventstoreClusterElectionCount;
 
 	public ElectionsCounterTrackerTests()
 	{
@@ -41,7 +44,7 @@ public void Dispose()
 
 		var listener = new TestMeterListener<long>(meter);
 		_disposables.RegisterForDispose(meter);
-		var metric = new CounterMetric(meter, "test-metric", unit: "");
+		var metric = new CounterMetric(meter, Definition);
 		var sut = new ElectionsCounterTracker(new CounterSubMetric(metric, []));
 
 		return (sut, listener);
@@ -82,6 +85,6 @@ static void AssertMeasurements(
 	{
 
 		listener.Observe();
-		Assert.Collection(listener.RetrieveMeasurements("test-metric"), actions);
+		Assert.Collection(listener.RetrieveMeasurements(Definition.Name), actions);
 	}
 }
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/IncomingGrpcCallsMetricTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/IncomingGrpcCallsMetricTests.cs
index b9f7dc4ce8..31c3cdcd5a 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/IncomingGrpcCallsMetricTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/IncomingGrpcCallsMetricTests.cs
@@ -1,8 +1,7 @@
-using System;
 using System.Diagnostics.Metrics;
 using System.Diagnostics.Tracing;
-using System.Linq;
 using EventStore.Core.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 using Conf = EventStore.Common.Configuration.MetricsConfiguration;
 
@@ -21,156 +20,84 @@ private class TestEventSource : EventSource
 	}
 
 	[Fact]
-	public void can_collect()
+	public void reports_each_diagnostic_counter_without_overlapping_attributes()
 	{
 		using var testSource = new TestEventSource();
 		using var meter = new Meter($"{typeof(IncomingGrpcCallsMetricTests)}");
 		using var listener = new TestMeterListener<long>(meter);
-		using var sut = new IncomingGrpcCallsMetric(meter, "current", "totals", new[] {
-			Conf.IncomingGrpcCall.Current,
-			Conf.IncomingGrpcCall.Total,
-			Conf.IncomingGrpcCall.Failed,
-			Conf.IncomingGrpcCall.Unimplemented,
-			Conf.IncomingGrpcCall.DeadlineExceeded
-		});
+		using var sut = CreateMetric(
+			meter,
+			[
+				Conf.IncomingGrpcCall.Current,
+				Conf.IncomingGrpcCall.Total,
+				Conf.IncomingGrpcCall.Failed,
+				Conf.IncomingGrpcCall.Unimplemented,
+				Conf.IncomingGrpcCall.DeadlineExceeded,
+			]);
 
 		sut.EnableEvents(testSource, EventLevel.Verbose);
-
-		listener.Observe();
-		AssertMeasurements(listener, "current", AssertCurrentMeasurement(0));
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 0),
-			AssertMeasurement("failed", 0),
-			AssertMeasurement("unimplemented", 0),
-			AssertMeasurement("deadline-exceeded", 0));
-
 		testSource.CallStart();
-		listener.Observe();
-		AssertMeasurements(listener, "current", AssertCurrentMeasurement(1));
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 1),
-			AssertMeasurement("failed", 0),
-			AssertMeasurement("unimplemented", 0),
-			AssertMeasurement("deadline-exceeded", 0));
-
 		testSource.CallFailed();
-		listener.Observe();
-		AssertMeasurements(listener, "current", AssertCurrentMeasurement(1));
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 1),
-			AssertMeasurement("failed", 1),
-			AssertMeasurement("unimplemented", 0),
-			AssertMeasurement("deadline-exceeded", 0));
-
 		testSource.CallUnimplemented();
-		listener.Observe();
-		AssertMeasurements(listener, "current", AssertCurrentMeasurement(1));
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 1),
-			AssertMeasurement("failed", 1),
-			AssertMeasurement("unimplemented", 1),
-			AssertMeasurement("deadline-exceeded", 0));
-
 		testSource.CallDeadlineExceeded();
 		listener.Observe();
-		AssertMeasurements(listener, "current", AssertCurrentMeasurement(1));
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 1),
-			AssertMeasurement("failed", 1),
-			AssertMeasurement("unimplemented", 1),
-			AssertMeasurement("deadline-exceeded", 1));
+
+		AssertScalar(listener, MetricDefinitions.TrogonEventstoreGrpcServerCallActive, 1);
+		AssertScalar(listener, MetricDefinitions.TrogonEventstoreGrpcServerCallCount, 1);
+		AssertScalar(listener, MetricDefinitions.TrogonEventstoreGrpcServerCallFailureCount, 1);
+		AssertScalar(listener, MetricDefinitions.TrogonEventstoreGrpcServerCallUnimplementedCount, 1);
+		AssertScalar(listener, MetricDefinitions.TrogonEventstoreGrpcServerCallDeadlineExceededCount, 1);
 
 		testSource.CallStop();
 		listener.Observe();
-		AssertMeasurements(listener, "current", AssertCurrentMeasurement(0));
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 1),
-			AssertMeasurement("failed", 1),
-			AssertMeasurement("unimplemented", 1),
-			AssertMeasurement("deadline-exceeded", 1));
+		AssertScalar(listener, MetricDefinitions.TrogonEventstoreGrpcServerCallActive, 0);
 	}
 
 	[Fact]
-	public void can_collect_filtered()
+	public void publishes_only_configured_counters()
 	{
 		using var testSource = new TestEventSource();
 		using var meter = new Meter($"{typeof(IncomingGrpcCallsMetricTests)}");
 		using var listener = new TestMeterListener<long>(meter);
-		using var sut = new IncomingGrpcCallsMetric(meter, "current", "totals", new[] {
-			Conf.IncomingGrpcCall.Total,
-			Conf.IncomingGrpcCall.DeadlineExceeded
-		});
+		using var sut = CreateMetric(
+			meter,
+			[
+				Conf.IncomingGrpcCall.Total,
+				Conf.IncomingGrpcCall.DeadlineExceeded,
+			]);
 
 		sut.EnableEvents(testSource, EventLevel.Verbose);
-		listener.Observe();
-		AssertMeasurements(listener, "current");
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 0),
-			AssertMeasurement("deadline-exceeded", 0));
-
 		testSource.CallStart();
-		listener.Observe();
-		AssertMeasurements(listener, "current");
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 1),
-			AssertMeasurement("deadline-exceeded", 0));
-
 		testSource.CallFailed();
-		listener.Observe();
-		AssertMeasurements(listener, "current");
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 1),
-			AssertMeasurement("deadline-exceeded", 0));
-
 		testSource.CallUnimplemented();
-		listener.Observe();
-		AssertMeasurements(listener, "current");
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 1),
-			AssertMeasurement("deadline-exceeded", 0));
-
 		testSource.CallDeadlineExceeded();
-		listener.Observe();
-		AssertMeasurements(listener, "current");
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 1),
-			AssertMeasurement("deadline-exceeded", 1));
-
 		testSource.CallStop();
 		listener.Observe();
-		AssertMeasurements(listener, "current");
-		AssertMeasurements(listener, "totals",
-			AssertMeasurement("total", 1),
-			AssertMeasurement("deadline-exceeded", 1));
-	}
-
-	static Action<TestMeterListener<long>.TestMeasurement> AssertCurrentMeasurement(
-		long expectedValue) =>
-
-		actualMeasurement =>
-		{
-			Assert.Equal(expectedValue, actualMeasurement.Value);
-			Assert.Empty(actualMeasurement.Tags);
-		};
 
-	static Action<TestMeterListener<long>.TestMeasurement> AssertMeasurement(
-		string expectedKind,
-		long expectedValue) =>
-
-		actualMeasurement =>
-		{
-			Assert.Equal(expectedValue, actualMeasurement.Value);
-			var tag = Assert.Single(actualMeasurement.Tags.ToArray());
-			Assert.Equal("kind", tag.Key);
-			Assert.Equal(expectedKind, tag.Value);
-		};
+		Assert.Empty(listener.RetrieveMeasurements(MetricDefinitions.TrogonEventstoreGrpcServerCallActive.Name));
+		Assert.Empty(listener.RetrieveMeasurements(MetricDefinitions.TrogonEventstoreGrpcServerCallFailureCount.Name));
+		Assert.Empty(listener.RetrieveMeasurements(MetricDefinitions.TrogonEventstoreGrpcServerCallUnimplementedCount.Name));
+		AssertScalar(listener, MetricDefinitions.TrogonEventstoreGrpcServerCallCount, 1);
+		AssertScalar(listener, MetricDefinitions.TrogonEventstoreGrpcServerCallDeadlineExceededCount, 1);
+	}
 
-	static void AssertMeasurements(
+	private static IncomingGrpcCallsMetric CreateMetric(Meter meter, Conf.IncomingGrpcCall[] filter) =>
+		new(
+			meter,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallActive,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallCount,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallFailureCount,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallUnimplementedCount,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallDeadlineExceededCount,
+			filter);
+
+	private static void AssertScalar(
 		TestMeterListener<long> listener,
-		string name,
-		params Action<TestMeterListener<long>.TestMeasurement>[] actions)
+		MetricDefinition definition,
+		long expectedValue)
 	{
-
-		Assert.Collection(listener.RetrieveMeasurements(name), actions);
+		var measurement = Assert.Single(listener.RetrieveMeasurements(definition.Name));
+		Assert.Equal(expectedValue, measurement.Value);
+		Assert.Empty(measurement.Tags);
 	}
 }
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/MaxTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/MaxTrackerTests.cs
index 7fe0f66ae9..57fe23981b 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/MaxTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/MaxTrackerTests.cs
@@ -2,6 +2,7 @@
 using System.Diagnostics.Metrics;
 using System.Linq;
 using EventStore.Core.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
@@ -11,12 +12,14 @@ public class MaxTrackerTests : IDisposable
 	private readonly TestMeterListener<long> _listener;
 	private readonly FakeClock _clock = new();
 	private readonly MaxTracker<long> _sut;
+	private readonly MetricDefinition _definition =
+		MetricDefinitions.TrogonEventstoreWriterFlushSizeMax;
 
 	public MaxTrackerTests()
 	{
 		var meter = new Meter($"{typeof(MaxTrackerTests)}");
 		_listener = new TestMeterListener<long>(meter);
-		var metric = new MaxMetric<long>(meter, "the-metric");
+		var metric = new MaxMetric<long>(meter, _definition);
 		_sut = new MaxTracker<long>(
 			metric: metric,
 			name: "the-tracker",
@@ -71,19 +74,19 @@ void AssertMeasurements(double expectedValue)
 	{
 		_listener.Observe();
 
-		var measurement = Assert.Single(_listener.RetrieveMeasurements("the-metric"));
+		var measurement = Assert.Single(_listener.RetrieveMeasurements(_definition.Name));
 		Assert.Equal(expectedValue, measurement.Value);
 		Assert.Collection(
 			measurement.Tags.ToArray(),
 			t =>
 			{
-				Assert.Equal("name", t.Key);
+				Assert.Equal(TrogonAttributeNames.QueueName, t.Key);
 				Assert.Equal("the-tracker", t.Value);
 			},
 			t =>
 			{
-				Assert.Equal("range", t.Key);
-				Assert.Equal("16-20 seconds", t.Value);
+				Assert.Equal(TrogonAttributeNames.MeasurementWindow, t.Key);
+				Assert.Equal("16-20s", t.Value);
 			});
 	}
 
@@ -93,16 +96,16 @@ public void no_name()
 		using var meter = new Meter($"{typeof(MaxTrackerTests)}");
 		using var listener = new TestMeterListener<long>(meter);
 		var sut = new MaxTracker<long>(
-			metric: new MaxMetric<long>(meter, "the-metric"),
+			metric: new MaxMetric<long>(meter, _definition),
 			name: null,
 			expectedScrapeIntervalSeconds: 15);
 
 		listener.Observe();
 
-		var measurement = Assert.Single(listener.RetrieveMeasurements("the-metric"));
+		var measurement = Assert.Single(listener.RetrieveMeasurements(_definition.Name));
 		Assert.Equal(0, measurement.Value);
 		var tag = Assert.Single(measurement.Tags.ToArray());
-		Assert.Equal("range", tag.Key);
-		Assert.Equal("16-20 seconds", tag.Value);
+		Assert.Equal(TrogonAttributeNames.MeasurementWindow, tag.Key);
+		Assert.Equal("16-20s", tag.Value);
 	}
 }
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/MetricInstrumentDefinitionTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/MetricInstrumentDefinitionTests.cs
new file mode 100644
index 0000000000..3d38f94c91
--- /dev/null
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/MetricInstrumentDefinitionTests.cs
@@ -0,0 +1,156 @@
+using System.Collections.Generic;
+using System.Diagnostics.Metrics;
+using EventStore.Common.Configuration;
+using EventStore.Core.Metrics;
+using EventStore.Core.TransactionLog.Checkpoint;
+using TrogonEventStore.SemanticConventions;
+using Xunit;
+
+namespace EventStore.Core.XUnit.Tests.Metrics;
+
+public class MetricInstrumentDefinitionTests
+{
+	[Fact]
+	public void wrappers_apply_complete_metric_definitions()
+	{
+		using var meter = new Meter($"{typeof(MetricInstrumentDefinitionTests)}");
+		using var listener = new TestMeterListener<long>(meter);
+
+		_ = new DurationMetric(
+			meter,
+			MetricDefinitions.TrogonEventstoreQueueMessageProcessingDuration);
+		_ = new SummedCounterMetric(
+			meter,
+			MetricDefinitions.TrogonEventstoreQueueBusyTime,
+			label => new(TrogonAttributeNames.QueueName, label));
+		_ = new ObservableUpDownMetric<int>(
+			meter,
+			MetricDefinitions.TrogonEventstoreQueueMessageCount);
+		_ = new CounterMetric(
+			meter,
+			MetricDefinitions.TrogonEventstoreClusterElectionCount);
+		_ = new MaxMetric<long>(
+			meter,
+			MetricDefinitions.TrogonEventstoreWriterFlushSizeMax);
+		_ = new DurationMaxMetric(
+			meter,
+			MetricDefinitions.TrogonEventstoreQueueMessageWaitDurationMax);
+		_ = new StatusMetric(
+			meter,
+			MetricDefinitions.TrogonEventstoreComponentStatus);
+		_ = new CacheHitsMissesMetric(
+			meter,
+			[],
+			MetricDefinitions.TrogonEventstoreCacheOperationCount,
+			new Dictionary<MetricsConfiguration.Cache, string>());
+		using var incomingCalls = new IncomingGrpcCallsMetric(
+			meter,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallActive,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallCount,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallFailureCount,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallUnimplementedCount,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallDeadlineExceededCount,
+			[
+				MetricsConfiguration.IncomingGrpcCall.Current,
+				MetricsConfiguration.IncomingGrpcCall.Total,
+				MetricsConfiguration.IncomingGrpcCall.Failed,
+			]);
+		_ = new CacheResourcesMetrics(
+			meter,
+			MetricDefinitions.TrogonEventstoreCacheResourceSize,
+			MetricDefinitions.TrogonEventstoreCacheResourceCount);
+		_ = new LogicalChunkReadDistributionMetric(
+			meter,
+			MetricDefinitions.TrogonEventstoreStorageChunkReadDistance,
+			new InMemoryCheckpoint(),
+			chunkSize: 1);
+		_ = new CheckpointMetric(
+			meter,
+			MetricDefinitions.TrogonEventstoreCheckpointPosition);
+
+		AssertInstrument<Histogram<double>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreQueueMessageProcessingDuration);
+		AssertInstrument<ObservableCounter<double>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreQueueBusyTime);
+		AssertInstrument<ObservableUpDownCounter<int>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreQueueMessageCount);
+		AssertInstrument<ObservableCounter<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreClusterElectionCount);
+		AssertInstrument<ObservableGauge<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreWriterFlushSizeMax);
+		AssertInstrument<ObservableGauge<double>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreQueueMessageWaitDurationMax);
+		AssertInstrument<ObservableUpDownCounter<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreComponentStatus);
+		AssertInstrument<ObservableCounter<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreCacheOperationCount);
+		AssertInstrument<ObservableUpDownCounter<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallActive);
+		AssertInstrument<ObservableCounter<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallCount);
+		AssertInstrument<ObservableCounter<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreGrpcServerCallFailureCount);
+		AssertInstrument<ObservableUpDownCounter<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreCacheResourceSize);
+		AssertInstrument<ObservableUpDownCounter<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreCacheResourceCount);
+		AssertInstrument<Histogram<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreStorageChunkReadDistance);
+		AssertInstrument<ObservableGauge<long>>(
+			listener,
+			MetricDefinitions.TrogonEventstoreCheckpointPosition);
+	}
+
+	private static void AssertInstrument<TInstrument>(
+		TestMeterListener<long> listener,
+		MetricDefinition definition)
+		where TInstrument : Instrument
+	{
+		var instrument = listener.GetInstrument(definition.Name);
+		Assert.IsType<TInstrument>(instrument);
+		Assert.Equal(definition.InstrumentKind, GetInstrumentKind(instrument));
+		Assert.Equal(definition.Name, instrument.Name);
+		Assert.Equal(definition.Unit, instrument.Unit);
+		Assert.Equal(definition.Description, instrument.Description);
+	}
+
+	private static MetricInstrumentKind GetInstrumentKind(Instrument instrument)
+	{
+		var instrumentType = instrument.GetType().GetGenericTypeDefinition();
+		if (instrumentType == typeof(Histogram<>))
+		{
+			return MetricInstrumentKind.Histogram;
+		}
+
+		if (instrumentType == typeof(ObservableCounter<>))
+		{
+			return MetricInstrumentKind.Counter;
+		}
+
+		if (instrumentType == typeof(ObservableGauge<>))
+		{
+			return MetricInstrumentKind.Gauge;
+		}
+
+		if (instrumentType == typeof(ObservableUpDownCounter<>))
+		{
+			return MetricInstrumentKind.UpDownCounter;
+		}
+
+		throw new Xunit.Sdk.XunitException($"Unsupported instrument type '{instrumentType}'.");
+	}
+}
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/PersistentSubscriptionMetricsTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/PersistentSubscriptionMetricsTests.cs
index 714590aa9e..6ea9937b02 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/PersistentSubscriptionMetricsTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/PersistentSubscriptionMetricsTests.cs
@@ -4,6 +4,7 @@
 using EventStore.Core.Messages;
 using EventStore.Core.Metrics;
 using EventStore.Core.Services.PersistentSubscription;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
@@ -117,10 +118,10 @@ public void ObserveParkMessageRequests()
 	{
 		var measurements = _sut.ObserveParkMessageRequests();
 		Assert.Collection(measurements,
-			AssertMeasurement("test", "testGroup", "client-nak", 1015),
-			AssertMeasurement("test", "testGroup", "max-retries", 1016),
-			AssertMeasurement("$all", "testGroup", "client-nak", 1018),
-			AssertMeasurement("$all", "testGroup", "max-retries", 1019));
+			AssertMeasurement("test", "testGroup", "client_nack", 1015),
+			AssertMeasurement("test", "testGroup", "max_retries", 1016),
+			AssertMeasurement("$all", "testGroup", "client_nack", 1018),
+			AssertMeasurement("$all", "testGroup", "max_retries", 1019));
 	}
 
 	[Fact]
@@ -208,12 +209,12 @@ static Action<Measurement<long>> AssertMeasurement(
 				actualMeasurement.Tags.ToArray(),
 				tag =>
 				{
-					Assert.Equal("event_stream_id", tag.Key);
+					Assert.Equal(TrogonAttributeNames.PersistentSubscriptionStream, tag.Key);
 					Assert.Equal(sourceName, tag.Value);
 				},
 				tag =>
 				{
-					Assert.Equal("group_name", tag.Key);
+					Assert.Equal(TrogonAttributeNames.PersistentSubscriptionGroup, tag.Key);
 					Assert.Equal(groupName, tag.Value);
 				}
 			);
@@ -232,17 +233,17 @@ static Action<Measurement<long>> AssertMeasurement(
 				actualMeasurement.Tags.ToArray(),
 				tag =>
 				{
-					Assert.Equal("event_stream_id", tag.Key);
+					Assert.Equal(TrogonAttributeNames.PersistentSubscriptionStream, tag.Key);
 					Assert.Equal(sourceName, tag.Value);
 				},
 				tag =>
 				{
-					Assert.Equal("group_name", tag.Key);
+					Assert.Equal(TrogonAttributeNames.PersistentSubscriptionGroup, tag.Key);
 					Assert.Equal(groupName, tag.Value);
 				},
 				tag =>
 				{
-					Assert.Equal("reason", tag.Key);
+					Assert.Equal(TrogonAttributeNames.PersistentSubscriptionReason, tag.Key);
 					Assert.Equal(reason, tag.Value);
 				}
 			);
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/ProcessMetricsTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/ProcessMetricsTests.cs
index 1ecf2ab741..6c98dc9b37 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/ProcessMetricsTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/ProcessMetricsTests.cs
@@ -1,410 +1,140 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
-using System.Threading;
+using System.Linq;
 using EventStore.Common.Configuration;
 using EventStore.Core.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
-using Xunit.Sdk;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
 
 public class ProcessMetricsTests : IDisposable
 {
-	private readonly TestMeterListener<int> _intListener;
+	private readonly Meter _meter;
+	private readonly MeterListener _instrumentListener;
+	private readonly List<Instrument> _instruments = new();
 	private readonly TestMeterListener<double> _doubleListener;
 	private readonly TestMeterListener<long> _longListener;
-	private readonly ProcessMetrics _sut;
 
 	public ProcessMetricsTests()
 	{
-		var meter = new Meter($"{typeof(ProcessMetricsTests)}");
-		_intListener = new TestMeterListener<int>(meter);
-		_doubleListener = new TestMeterListener<double>(meter);
-		_longListener = new TestMeterListener<long>(meter);
-
-		var config = new Dictionary<MetricsConfiguration.ProcessTracker, bool>();
-
-		foreach (var value in Enum.GetValues<MetricsConfiguration.ProcessTracker>())
+		_meter = new Meter(typeof(ProcessMetricsTests).FullName!);
+		_instrumentListener = new MeterListener
 		{
-			config[value] = true;
-		}
-
-		_sut = new ProcessMetrics(meter, TimeSpan.FromSeconds(42), scrapingPeriodInSeconds: 15, config);
-		_sut.CreateObservableMetrics(new() {
-			{ MetricsConfiguration.ProcessTracker.UpTime, "eventstore-proc-up-time" },
-			{ MetricsConfiguration.ProcessTracker.Cpu, "eventstore-proc-cpu" },
-			{ MetricsConfiguration.ProcessTracker.ThreadCount, "eventstore-proc-thread-count" },
-			{ MetricsConfiguration.ProcessTracker.ThreadPoolPendingWorkItemCount, "eventstore-proc-thread-pool-pending-work-item-count" },
-			{ MetricsConfiguration.ProcessTracker.LockContentionCount, "eventstore-proc-contention-count" },
-			{ MetricsConfiguration.ProcessTracker.ExceptionCount, "eventstore-proc-exception-count" },
-			{ MetricsConfiguration.ProcessTracker.TimeInGc, "eventstore-gc-time-in-gc" },
-			{ MetricsConfiguration.ProcessTracker.HeapSize, "eventstore-gc-heap-size" },
-			{ MetricsConfiguration.ProcessTracker.HeapFragmentation, "eventstore-gc-heap-fragmentation" },
-			{ MetricsConfiguration.ProcessTracker.TotalAllocatedBytes, "eventstore-gc-total-allocated" },
-			{ MetricsConfiguration.ProcessTracker.GcPauseDuration, "eventstore-gc-pause-duration" },
-		});
-
-		_sut.CreateMemoryMetric("eventstore-proc-mem", new() {
-			{ MetricsConfiguration.ProcessTracker.MemWorkingSet, "working-set" },
-			{ MetricsConfiguration.ProcessTracker.MemPagedBytes, "paged-bytes" },
-			{ MetricsConfiguration.ProcessTracker.MemVirtualBytes, "virtual-bytes" },
-		});
-
-		_sut.CreateGcGenerationSizeMetric("eventstore-gc-generation-size", new() {
-			{ MetricsConfiguration.ProcessTracker.Gen0Size, "gen0" },
-			{ MetricsConfiguration.ProcessTracker.Gen1Size, "gen1" },
-			{ MetricsConfiguration.ProcessTracker.Gen2Size, "gen2" },
-			{ MetricsConfiguration.ProcessTracker.LohSize, "loh" },
-		});
-
-		_sut.CreateGcCollectionCountMetric("eventstore-gc-collection-count", new() {
-			{ MetricsConfiguration.ProcessTracker.Gen0CollectionCount, "gen0" },
-			{ MetricsConfiguration.ProcessTracker.Gen1CollectionCount, "gen1" },
-			{ MetricsConfiguration.ProcessTracker.Gen2CollectionCount, "gen2" },
-		});
-
-		_sut.CreateDiskBytesMetric("eventstore-disk-io", new() {
-			{ MetricsConfiguration.ProcessTracker.DiskReadBytes, "read" },
-			{ MetricsConfiguration.ProcessTracker.DiskWrittenBytes, "written" },
-		});
-
-		_sut.CreateDiskOpsMetric("eventstore-disk-io", new() {
-			{ MetricsConfiguration.ProcessTracker.DiskReadBytes, "read" },
-			{ MetricsConfiguration.ProcessTracker.DiskWrittenBytes, "written" },
-		});
+			InstrumentPublished = (instrument, _) =>
+			{
+				if (instrument.Meter == _meter)
+				{
+					_instruments.Add(instrument);
+				}
+			},
+		};
+		_instrumentListener.Start();
+		_doubleListener = new TestMeterListener<double>(_meter);
+		_longListener = new TestMeterListener<long>(_meter);
 
-		// To trigger the GC pause detection metric.
-		GC.Collect();
+		var config = new Dictionary<MetricsConfiguration.ProcessTracker, bool>
+		{
+			[MetricsConfiguration.ProcessTracker.UpTime] = true,
+			[MetricsConfiguration.ProcessTracker.DiskReadBytes] = true,
+			[MetricsConfiguration.ProcessTracker.DiskWrittenBytes] = true,
+			[MetricsConfiguration.ProcessTracker.DiskReadOps] = true,
+			[MetricsConfiguration.ProcessTracker.DiskWrittenOps] = true,
+		};
+
+		var sut = new ProcessMetrics(_meter, TimeSpan.Zero, config);
+		sut.CreateUptimeMetric();
+		sut.CreateDiskIoMetric();
+		sut.CreateDiskOperationMetric();
 
-		_intListener.Observe();
 		_doubleListener.Observe();
 		_longListener.Observe();
 	}
 
 	public void Dispose()
 	{
-		_intListener.Dispose();
+		_instrumentListener.Dispose();
 		_doubleListener.Dispose();
 		_longListener.Dispose();
+		_meter.Dispose();
 	}
 
 	[Fact]
-	public void can_collect_proc_up_time()
-	{
-		Assert.Collection(
-			_doubleListener.RetrieveMeasurements("eventstore-proc-up-time"),
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("pid", tag.Key);
-						Assert.NotNull(tag.Value);
-					});
-			});
-	}
-
-	[Fact]
-	public void can_collect_proc_cpu()
-	{
-		Assert.Collection(
-			_doubleListener.RetrieveMeasurements("eventstore-proc-cpu"),
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Empty(m.Tags);
-			});
-	}
-
-	[Fact]
-	public void can_collect_proc_contention_count()
-	{
-		Assert.Collection(
-			_longListener.RetrieveMeasurements("eventstore-proc-contention-count"),
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Empty(m.Tags);
-			});
-	}
-
-	[Fact]
-	public void can_collect_thread_pool_pending_work_item_count()
-	{
-		Assert.Collection(
-			_longListener.RetrieveMeasurements("eventstore-proc-thread-pool-pending-work-item-count"),
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Empty(m.Tags);
-			});
-	}
-
-	[Fact]
-	public void can_collect_proc_exception_count()
-	{
-		Assert.Collection(
-			_intListener.RetrieveMeasurements("eventstore-proc-exception-count"),
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Empty(m.Tags);
-			});
-	}
-
-	[Fact]
-	public void can_collect_gc_total_allocated()
-	{
-		Assert.Collection(
-			_longListener.RetrieveMeasurements("eventstore-gc-total-allocated"),
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Empty(m.Tags);
-			});
-	}
-
-	[Fact]
-	public void can_collect_thread_count()
+	public void publishes_the_process_metric_contract()
 	{
 		Assert.Collection(
-			_intListener.RetrieveMeasurements("eventstore-proc-thread-count"),
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Empty(m.Tags);
-			});
+			_instruments.OrderBy(instrument => instrument.Name),
+			instrument => AssertInstrument<ObservableCounter<long>>(
+				instrument,
+				OpenTelemetryMetricDefinitions.ProcessDiskIo),
+			instrument => AssertInstrument<ObservableGauge<double>>(
+				instrument,
+				OpenTelemetryMetricDefinitions.ProcessUptime),
+			instrument => AssertInstrument<ObservableCounter<long>>(
+				instrument,
+				MetricDefinitions.TrogonEventstoreProcessDiskOperationCount));
 	}
 
 	[Fact]
-	public void can_collect_gc_time_in_gc()
+	public void exposes_only_the_retained_process_trackers()
 	{
-		Assert.Collection(
-			_intListener.RetrieveMeasurements("eventstore-gc-time-in-gc"),
-			m =>
+		Assert.Equal(
+			new[]
 			{
-				Assert.True(m.Value >= 0);
-				Assert.Empty(m.Tags);
-			});
+				MetricsConfiguration.ProcessTracker.UpTime,
+				MetricsConfiguration.ProcessTracker.DiskReadBytes,
+				MetricsConfiguration.ProcessTracker.DiskReadOps,
+				MetricsConfiguration.ProcessTracker.DiskWrittenBytes,
+				MetricsConfiguration.ProcessTracker.DiskWrittenOps,
+			},
+			Enum.GetValues<MetricsConfiguration.ProcessTracker>());
 	}
 
 	[Fact]
-	public void can_collect_gc_heap_size()
+	public void process_uptime_is_in_seconds_without_point_attributes()
 	{
-		Assert.Collection(
-			_longListener.RetrieveMeasurements("eventstore-gc-heap-size-bytes"),
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Empty(m.Tags);
-			});
-	}
+		var measurement = Assert.Single(
+			_doubleListener.RetrieveMeasurements(Key(OpenTelemetryMetricDefinitions.ProcessUptime)));
 
-	[Fact]
-	public void can_collect_gc_heap_fragmentation()
-	{
-		Assert.Collection(
-			_doubleListener.RetrieveMeasurements("eventstore-gc-heap-fragmentation"),
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Empty(m.Tags);
-			});
+		Assert.True(measurement.Value > 0);
+		Assert.Empty(measurement.Tags);
 	}
 
 	[Fact]
-	public void can_collect_proc_mem()
+	public void process_disk_io_has_the_required_direction_attribute()
 	{
 		Assert.Collection(
-			_longListener.RetrieveMeasurements("eventstore-proc-mem-bytes"),
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("kind", tag.Key);
-						Assert.Equal("working-set", tag.Value);
-					});
-			},
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("kind", tag.Key);
-						Assert.Equal("paged-bytes", tag.Value);
-					});
-			},
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("kind", tag.Key);
-						Assert.Equal("virtual-bytes", tag.Value);
-					});
-			});
+			_longListener.RetrieveMeasurements(Key(OpenTelemetryMetricDefinitions.ProcessDiskIo)),
+			measurement => AssertDirection(measurement, "read"),
+			measurement => AssertDirection(measurement, "write"));
 	}
 
 	[Fact]
-	public void can_collect_gc_generation_size()
+	public void process_disk_operations_have_the_required_direction_attribute()
 	{
 		Assert.Collection(
-			_longListener.RetrieveMeasurements("eventstore-gc-generation-size-bytes"),
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("generation", tag.Key);
-						Assert.Equal("gen0", tag.Value);
-					});
-			},
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("generation", tag.Key);
-						Assert.Equal("gen1", tag.Value);
-					});
-			},
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("generation", tag.Key);
-						Assert.Equal("gen2", tag.Value);
-					});
-			},
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("generation", tag.Key);
-						Assert.Equal("loh", tag.Value);
-					});
-			});
+			_longListener.RetrieveMeasurements(Key(MetricDefinitions.TrogonEventstoreProcessDiskOperationCount)),
+			measurement => AssertDirection(measurement, "read"),
+			measurement => AssertDirection(measurement, "write"));
 	}
 
-	[Fact]
-	public void can_collect_gc_collections_count()
+	private static void AssertDirection(TestMeterListener<long>.TestMeasurement measurement, string direction)
 	{
-		Assert.Collection(
-			_intListener.RetrieveMeasurements("eventstore-gc-collection-count"),
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("generation", tag.Key);
-						Assert.Equal("gen0", tag.Value);
-					});
-			},
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("generation", tag.Key);
-						Assert.Equal("gen1", tag.Value);
-					});
-			},
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("generation", tag.Key);
-						Assert.Equal("gen2", tag.Value);
-					});
-			});
+		Assert.True(measurement.Value >= 0);
+		var tag = Assert.Single(measurement.Tags);
+		Assert.Equal(AttributeNames.DiskIoDirection, tag.Key);
+		Assert.Equal(direction, tag.Value);
 	}
 
-	[Fact]
-	public void can_collect_disk_io_bytes()
+	private static void AssertInstrument<TInstrument>(Instrument instrument, MetricDefinition definition)
+		where TInstrument : Instrument
 	{
-		Assert.Collection(
-			_longListener.RetrieveMeasurements("eventstore-disk-io-bytes"),
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("activity", tag.Key);
-						Assert.Equal("read", tag.Value);
-					});
-			},
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("activity", tag.Key);
-						Assert.Equal("written", tag.Value);
-					});
-			});
+		Assert.IsType<TInstrument>(instrument);
+		Assert.Equal(definition.Name, instrument.Name);
+		Assert.Equal(definition.Unit, instrument.Unit);
+		Assert.Equal(definition.Description, instrument.Description);
 	}
 
-	[Fact]
-	public void can_detect_gc_pauses()
-	{
-		for (var count = 0; count < 50; ++count)
-		{
-			try
-			{
-				Assert.Collection(
-					_doubleListener.RetrieveMeasurements("eventstore-gc-pause-duration-seconds"),
-					m =>
-					{
-						Assert.Collection(
-							m.Tags,
-							tag =>
-							{
-								Assert.Equal("range", tag.Key);
-								Assert.Equal("16-20 seconds", tag.Value);
-							});
-
-						Assert.True(m.Value > 0);
-					});
-
-				return;
-			}
-			catch (CollectionException)
-			{
-			}
-
-			Thread.Sleep(10);
-			_doubleListener.Observe();
-		}
-	}
+	private static string Key(MetricDefinition definition) => definition.Name;
 }
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/QueueBusyTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/QueueBusyTrackerTests.cs
index 08155e6ab2..5f138f4ebd 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/QueueBusyTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/QueueBusyTrackerTests.cs
@@ -1,6 +1,7 @@
 using System.Diagnostics.Metrics;
 using System.Threading.Tasks;
 using EventStore.Core.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
@@ -12,7 +13,11 @@ public async Task records()
 	{
 		using var meter = new Meter($"{typeof(QueueProcessingTrackerTests)}");
 		using var listener = new TestMeterListener<double>(meter);
-		var metric = new AverageMetric(meter, "the-metric", "seconds", label => new("queue", label));
+		var definition = MetricDefinitions.TrogonEventstoreQueueBusyTime;
+		var metric = new SummedCounterMetric(
+			meter,
+			definition,
+			label => new(TrogonAttributeNames.QueueName, label));
 		var sut = new QueueBusyTracker(metric, "the-queue");
 
 		sut.EnterBusy();
@@ -20,10 +25,10 @@ public async Task records()
 		sut.EnterIdle();
 		listener.Observe();
 
-		var measurement = Assert.Single(listener.RetrieveMeasurements("the-metric-seconds"));
+		var measurement = Assert.Single(listener.RetrieveMeasurements(definition.Name));
 		Assert.True(measurement.Value > 0.0001);
 		var tag = Assert.Single(measurement.Tags);
-		Assert.Equal("queue", tag.Key);
+		Assert.Equal(TrogonAttributeNames.QueueName, tag.Key);
 		Assert.Equal("the-queue", tag.Value);
 	}
 }
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/QueueProcessingTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/QueueProcessingTrackerTests.cs
index a4bc94d997..bdfb836a84 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/QueueProcessingTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/QueueProcessingTrackerTests.cs
@@ -3,6 +3,7 @@
 using System.Threading.Tasks;
 using EventStore.Core.Metrics;
 using EventStore.Core.Time;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
@@ -12,11 +13,13 @@ public class QueueProcessingTrackerTests : IDisposable
 	private readonly TestMeterListener<double> _listener;
 	private readonly FakeClock _clock = new();
 	private readonly QueueProcessingTracker _sut;
+	private readonly MetricDefinition _definition =
+		MetricDefinitions.TrogonEventstoreQueueMessageProcessingDuration;
 
 	public QueueProcessingTrackerTests()
 	{
 		var meter = new Meter($"{typeof(QueueProcessingTrackerTests)}");
-		var metric = new DurationMetric(meter, "the-metric", _clock);
+		var metric = new DurationMetric(meter, _definition, _clock);
 		_listener = new TestMeterListener<double>(meter);
 		_sut = new(metric, "the-queue");
 	}
@@ -42,7 +45,7 @@ void AssertMeasurements(int expectedValue)
 	{
 
 		Assert.Collection(
-			_listener.RetrieveMeasurements("the-metric-seconds"),
+			_listener.RetrieveMeasurements(_definition.Name),
 			m =>
 			{
 				Assert.Equal(expectedValue, m.Value);
@@ -50,12 +53,12 @@ void AssertMeasurements(int expectedValue)
 					m.Tags,
 					t =>
 					{
-						Assert.Equal("queue", t.Key);
+						Assert.Equal(TrogonAttributeNames.QueueName, t.Key);
 						Assert.Equal("the-queue", t.Value);
 					},
 					t =>
 					{
-						Assert.Equal("message-type", t.Key);
+						Assert.Equal(TrogonAttributeNames.QueueMessageType, t.Key);
 						Assert.Equal("the-message-type", t.Value);
 					});
 			});
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/SystemMetricsTests.cs b/src/EventStore.Core.XUnit.Tests/Metrics/SystemMetricsTests.cs
index 54df6c337a..8580e9a29c 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/SystemMetricsTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/SystemMetricsTests.cs
@@ -1,207 +1,195 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
+using System.Linq;
 using System.Runtime;
 using EventStore.Common.Configuration;
 using EventStore.Core.Metrics;
-using FluentAssertions;
-using Microsoft.Extensions.Diagnostics.Metrics.Testing;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Metrics;
 
 public class SystemMetricsTests : IDisposable
 {
-	private readonly TestMeterListener<float> _floatListener;
+	private readonly Meter _meter;
+	private readonly MeterListener _instrumentListener;
+	private readonly List<Instrument> _instruments = new();
 	private readonly TestMeterListener<double> _doubleListener;
 	private readonly TestMeterListener<long> _longListener;
-	private readonly FakeClock _clock = new();
-	private readonly SystemMetrics _sut;
-	private readonly Meter _meter;
+
 	public SystemMetricsTests()
 	{
-		_meter = new Meter($"{typeof(ProcessMetricsTests)}");
-		_floatListener = new TestMeterListener<float>(_meter);
+		_meter = new Meter(typeof(SystemMetricsTests).FullName!);
+		_instrumentListener = new MeterListener
+		{
+			InstrumentPublished = (instrument, _) =>
+			{
+				if (instrument.Meter == _meter)
+				{
+					_instruments.Add(instrument);
+				}
+			},
+		};
+		_instrumentListener.Start();
 		_doubleListener = new TestMeterListener<double>(_meter);
 		_longListener = new TestMeterListener<long>(_meter);
 
-		var config = new Dictionary<MetricsConfiguration.SystemTracker, bool>();
-
-		foreach (var value in Enum.GetValues<MetricsConfiguration.SystemTracker>())
+		var config = new Dictionary<MetricsConfiguration.SystemTracker, bool>
 		{
-			config[value] = true;
-		}
-		_sut = new SystemMetrics(_meter, TimeSpan.FromSeconds(42), config);
-		_sut.CreateLoadAverageMetric("eventstore-sys-load-avg", new() {
-			{ MetricsConfiguration.SystemTracker.LoadAverage1m, "1m" },
-			{ MetricsConfiguration.SystemTracker.LoadAverage5m, "5m" },
-			{ MetricsConfiguration.SystemTracker.LoadAverage15m, "15m" },
-		});
-
-		_sut.CreateCpuMetric("eventstore-sys-cpu");
-
-		_sut.CreateMemoryMetric("eventstore-sys-mem", new() {
-			{ MetricsConfiguration.SystemTracker.FreeMem, "free" },
-			{ MetricsConfiguration.SystemTracker.TotalMem, "total" },
-		});
-
-		_sut.CreateDiskMetric("eventstore-sys-disk", ".", new() {
-			{ MetricsConfiguration.SystemTracker.DriveTotalBytes, "total" },
-			{ MetricsConfiguration.SystemTracker.DriveUsedBytes, "used" },
-		});
-
-		_floatListener.Observe();
+			[MetricsConfiguration.SystemTracker.LoadAverage1m] = true,
+			[MetricsConfiguration.SystemTracker.LoadAverage5m] = true,
+			[MetricsConfiguration.SystemTracker.LoadAverage15m] = true,
+			[MetricsConfiguration.SystemTracker.DriveUsedBytes] = true,
+			[MetricsConfiguration.SystemTracker.DriveTotalBytes] = true,
+		};
+
+		var sut = new SystemMetrics(_meter, TimeSpan.Zero, config);
+		sut.CreateLoadAverageMetric();
+		sut.CreateFileSystemMetrics(".");
+
 		_doubleListener.Observe();
 		_longListener.Observe();
 	}
 
 	public void Dispose()
 	{
-		_floatListener.Dispose();
+		_instrumentListener.Dispose();
 		_doubleListener.Dispose();
 		_longListener.Dispose();
+		_meter.Dispose();
 	}
 
 	[Fact]
-	public void can_collect_sys_load_avg()
+	public void publishes_the_system_metric_contract()
 	{
+		var instruments = _instruments.OrderBy(instrument => instrument.Name).ToArray();
 		if (RuntimeInformation.IsWindows)
 		{
+			Assert.Collection(
+				instruments,
+				instrument => AssertInstrument<ObservableUpDownCounter<long>>(
+					instrument,
+					OpenTelemetryMetricDefinitions.SystemFilesystemLimit),
+				instrument => AssertInstrument<ObservableUpDownCounter<long>>(
+					instrument,
+					OpenTelemetryMetricDefinitions.SystemFilesystemUsage));
 			return;
 		}
 
 		Assert.Collection(
-			_doubleListener.RetrieveMeasurements("eventstore-sys-load-avg"),
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("period", tag.Key);
-						Assert.Equal("1m", tag.Value);
-					});
-			},
-			m =>
+			instruments,
+			instrument => AssertInstrument<ObservableUpDownCounter<long>>(
+				instrument,
+				OpenTelemetryMetricDefinitions.SystemFilesystemLimit),
+			instrument => AssertInstrument<ObservableUpDownCounter<long>>(
+				instrument,
+				OpenTelemetryMetricDefinitions.SystemFilesystemUsage),
+			instrument => AssertInstrument<ObservableGauge<double>>(
+				instrument,
+				MetricDefinitions.TrogonEventstoreSystemLoadAverage));
+	}
+
+	[Fact]
+	public void exposes_only_the_retained_system_trackers()
+	{
+		Assert.Equal(
+			new[]
 			{
-				Assert.True(m.Value > 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("period", tag.Key);
-						Assert.Equal("5m", tag.Value);
-					});
+				MetricsConfiguration.SystemTracker.LoadAverage1m,
+				MetricsConfiguration.SystemTracker.LoadAverage5m,
+				MetricsConfiguration.SystemTracker.LoadAverage15m,
+				MetricsConfiguration.SystemTracker.DriveTotalBytes,
+				MetricsConfiguration.SystemTracker.DriveUsedBytes,
 			},
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("period", tag.Key);
-						Assert.Equal("15m", tag.Value);
-					});
-			});
+			Enum.GetValues<MetricsConfiguration.SystemTracker>());
 	}
 
 	[Fact]
-	public void can_collect_sys_cpu()
+	public void load_average_has_the_required_period_attribute()
 	{
+		if (RuntimeInformation.IsWindows)
+		{
+			return;
+		}
+
 		Assert.Collection(
-			_doubleListener.RetrieveMeasurements("eventstore-sys-cpu"),
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Empty(m.Tags);
-			});
+			_doubleListener.RetrieveMeasurements(Key(MetricDefinitions.TrogonEventstoreSystemLoadAverage)),
+			measurement => AssertPeriod(measurement, "1m"),
+			measurement => AssertPeriod(measurement, "5m"),
+			measurement => AssertPeriod(measurement, "15m"));
 	}
 
 	[Fact]
-	public void can_collect_sys_cpu_using_metrics_collector()
+	public void filesystem_usage_has_state_and_mountpoint_attributes()
 	{
-		// Arrange
-		using var collector = new MetricCollector<double>(
-			null, _meter.Name, "eventstore-sys-cpu"
-		);
+		Assert.Collection(
+			_longListener.RetrieveMeasurements(Key(OpenTelemetryMetricDefinitions.SystemFilesystemUsage)),
+			measurement => AssertFileSystemUsage(measurement, "used"),
+			measurement => AssertFileSystemUsage(measurement, "free"));
+	}
 
-		// Act
-		collector.RecordObservableInstruments();
+	[Fact]
+	public void filesystem_usage_states_sum_to_limit()
+	{
+		var usage = _longListener
+			.RetrieveMeasurements(Key(OpenTelemetryMetricDefinitions.SystemFilesystemUsage))
+			.Sum(measurement => measurement.Value);
+		var limit = Assert.Single(
+			_longListener.RetrieveMeasurements(Key(OpenTelemetryMetricDefinitions.SystemFilesystemLimit)));
 
-		// Assert
-		collector.LastMeasurement.Should().NotBeNull();
-		collector.LastMeasurement!.Value.Should().BeGreaterThanOrEqualTo(0);
+		Assert.Equal(limit.Value, usage);
 	}
 
+	[Fact]
+	public void filesystem_limit_has_mountpoint_attribute()
+	{
+		var measurement = Assert.Single(
+			_longListener.RetrieveMeasurements(Key(OpenTelemetryMetricDefinitions.SystemFilesystemLimit)));
 
+		Assert.True(measurement.Value > 0);
+		var tag = Assert.Single(measurement.Tags);
+		AssertNonEmptyTag(tag, AttributeNames.SystemFilesystemMountpoint);
+	}
 
-	[Fact]
-	public void can_collect_sys_mem()
+	private static void AssertPeriod(TestMeterListener<double>.TestMeasurement measurement, string period)
 	{
-		Assert.Collection(
-			_longListener.RetrieveMeasurements("eventstore-sys-mem-bytes"),
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("kind", tag.Key);
-						Assert.Equal("free", tag.Value);
-					});
-			},
-			m =>
-			{
-				Assert.True(m.Value > 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("kind", tag.Key);
-						Assert.Equal("total", tag.Value);
-					});
-			});
+		Assert.True(measurement.Value >= 0);
+		var tag = Assert.Single(measurement.Tags);
+		AssertTag(tag, TrogonAttributeNames.SystemLoadAveragePeriod, period);
 	}
 
-	[Fact]
-	public void can_collect_sys_disk()
+	private static void AssertFileSystemUsage(
+		TestMeterListener<long>.TestMeasurement measurement,
+		string state)
 	{
+		Assert.True(measurement.Value >= 0);
 		Assert.Collection(
-			_longListener.RetrieveMeasurements("eventstore-sys-disk-bytes"),
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("kind", tag.Key);
-						Assert.Equal("used", tag.Value);
-					},
-					tag =>
-					{
-						Assert.Equal("disk", tag.Key);
-						Assert.NotNull(tag.Value);
-					});
-			},
-			m =>
-			{
-				Assert.True(m.Value >= 0);
-				Assert.Collection(
-					m.Tags,
-					tag =>
-					{
-						Assert.Equal("kind", tag.Key);
-						Assert.Equal("total", tag.Value);
-					},
-					tag =>
-					{
-						Assert.Equal("disk", tag.Key);
-						Assert.NotNull(tag.Value);
-					});
-			});
+			measurement.Tags,
+			tag => AssertTag(tag, AttributeNames.SystemFilesystemState, state),
+			tag => AssertNonEmptyTag(tag, AttributeNames.SystemFilesystemMountpoint));
+	}
+
+	private static void AssertNonEmptyTag(KeyValuePair<string, object> tag, string name)
+	{
+		Assert.Equal(name, tag.Key);
+		Assert.False(string.IsNullOrWhiteSpace(Assert.IsType<string>(tag.Value)));
+	}
+
+	private static void AssertTag(KeyValuePair<string, object> tag, string name, string value)
+	{
+		Assert.Equal(name, tag.Key);
+		Assert.Equal(value, tag.Value);
+	}
+
+	private static void AssertInstrument<TInstrument>(Instrument instrument, MetricDefinition definition)
+		where TInstrument : Instrument
+	{
+		Assert.IsType<TInstrument>(instrument);
+		Assert.Equal(definition.Name, instrument.Name);
+		Assert.Equal(definition.Unit, instrument.Unit);
+		Assert.Equal(definition.Description, instrument.Description);
 	}
+
+	private static string Key(MetricDefinition definition) => definition.Name;
 }
diff --git a/src/EventStore.Core.XUnit.Tests/Metrics/TestMeterListener.cs b/src/EventStore.Core.XUnit.Tests/Metrics/TestMeterListener.cs
index 3aac2bf55e..e89920e00e 100644
--- a/src/EventStore.Core.XUnit.Tests/Metrics/TestMeterListener.cs
+++ b/src/EventStore.Core.XUnit.Tests/Metrics/TestMeterListener.cs
@@ -8,16 +8,19 @@ public class TestMeterListener<T> : IDisposable where T : struct
 {
 	private readonly MeterListener _listener;
 	private readonly Dictionary<string, List<TestMeasurement>> _measurementsByInstrument;
+	private readonly Dictionary<string, Instrument> _instrumentsByName;
 
 	public TestMeterListener(Meter meter)
 	{
 		_measurementsByInstrument = new();
+		_instrumentsByName = new();
 		_listener = new MeterListener
 		{
 			InstrumentPublished = (instrument, listener) =>
 			{
 				if (instrument.Meter == meter)
 				{
+					_instrumentsByName[instrument.Name] = instrument;
 					listener.EnableMeasurementEvents(instrument);
 				}
 			}
@@ -47,6 +50,9 @@ public IReadOnlyList<TestMeasurement> RetrieveMeasurements(string instrumentName
 		return measurements;
 	}
 
+	public Instrument GetInstrument(string instrumentName) =>
+		_instrumentsByName[instrumentName];
+
 	private void OnMeasurement(
 		Instrument instrument,
 		T value,
@@ -54,7 +60,7 @@ private void OnMeasurement(
 		object state)
 	{
 
-		var instrumentName = GenName(instrument);
+		var instrumentName = instrument.Name;
 		if (!_measurementsByInstrument.TryGetValue(instrumentName, out var measurements))
 		{
 			measurements = new();
@@ -68,11 +74,6 @@ private void OnMeasurement(
 		});
 	}
 
-	private static string GenName(Instrument instrument) =>
-		string.IsNullOrWhiteSpace(instrument.Unit)
-		? instrument.Name
-		: instrument.Name + "-" + instrument.Unit;
-
 	public class TestMeasurement
 	{
 		public T Value { get; init; }
diff --git a/src/EventStore.Core.XUnit.Tests/OpenTelemetry/MetricNamesTests.cs b/src/EventStore.Core.XUnit.Tests/OpenTelemetry/MetricNamesTests.cs
new file mode 100644
index 0000000000..82d10ff680
--- /dev/null
+++ b/src/EventStore.Core.XUnit.Tests/OpenTelemetry/MetricNamesTests.cs
@@ -0,0 +1,162 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using TrogonEventStore.SemanticConventions;
+using Xunit;
+
+namespace EventStore.Core.XUnit.Tests.OpenTelemetry;
+
+public class MetricNamesTests
+{
+	[Fact]
+	public void all_contains_every_metric_definition_once_in_name_order()
+	{
+		var definitions = typeof(MetricDefinitions)
+			.GetProperties(BindingFlags.Public | BindingFlags.Static)
+			.Where(property => property.PropertyType == typeof(MetricDefinition))
+			.Select(property => (MetricDefinition)property.GetValue(null))
+			.OrderBy(definition => definition.Name, StringComparer.Ordinal)
+			.ToArray();
+
+		Assert.Equal(definitions, MetricDefinitions.All);
+		Assert.Equal(definitions.Length, definitions.Distinct().Count());
+	}
+
+	[Fact]
+	public void every_metric_definition_has_complete_metadata()
+	{
+		foreach (var definition in MetricDefinitions.All)
+		{
+			Assert.False(string.IsNullOrWhiteSpace(definition.Name));
+			Assert.False(string.IsNullOrWhiteSpace(definition.Unit));
+			Assert.False(string.IsNullOrWhiteSpace(definition.Description));
+			Assert.True(Enum.IsDefined(typeof(MetricInstrumentKind), definition.InstrumentKind));
+		}
+	}
+
+	[Fact]
+	public void metric_definition_contains_weaver_metadata()
+	{
+		Assert.Equal(
+			new MetricDefinition(
+				"trogon.eventstore.grpc.server.call.duration",
+				"s",
+				"Duration of configured gRPC server calls.",
+				MetricInstrumentKind.Histogram),
+			MetricDefinitions.TrogonEventstoreGrpcServerCallDuration);
+	}
+
+	[Fact]
+	public void official_catalog_contains_only_selected_metrics_in_name_order()
+	{
+		var definitions = typeof(OpenTelemetryMetricDefinitions)
+			.GetProperties(BindingFlags.Public | BindingFlags.Static)
+			.Where(property => property.PropertyType == typeof(MetricDefinition))
+			.Select(property => (MetricDefinition)property.GetValue(null))
+			.OrderBy(definition => definition.Name, StringComparer.Ordinal)
+			.ToArray();
+
+		Assert.Equal(definitions, OpenTelemetryMetricDefinitions.All);
+		Assert.Equal(
+			new[]
+			{
+				"process.disk.io",
+				"process.uptime",
+				"system.filesystem.limit",
+				"system.filesystem.usage",
+			},
+			OpenTelemetryMetricDefinitions.All.Select(definition => definition.Name));
+	}
+
+	[Fact]
+	public void trogon_attribute_catalog_contains_all_custom_attributes_in_name_order()
+	{
+		var constants = typeof(TrogonAttributeNames)
+			.GetFields(BindingFlags.Public | BindingFlags.Static)
+			.Where(field => field.IsLiteral && field.FieldType == typeof(string))
+			.Select(field => (string)field.GetRawConstantValue())
+			.OrderBy(value => value, StringComparer.Ordinal)
+			.ToArray();
+
+		Assert.Equal(
+			new[]
+			{
+				"trogon.eventstore.activity.name",
+				"trogon.eventstore.activity.outcome",
+				"trogon.eventstore.cache.name",
+				"trogon.eventstore.cache.resource",
+				"trogon.eventstore.cache.result",
+				"trogon.eventstore.checkpoint.name",
+				"trogon.eventstore.checkpoint.read_kind",
+				"trogon.eventstore.component.name",
+				"trogon.eventstore.component.status",
+				"trogon.eventstore.measurement.window",
+				"trogon.eventstore.persistent_subscription.group",
+				"trogon.eventstore.persistent_subscription.reason",
+				"trogon.eventstore.persistent_subscription.stream",
+				"trogon.eventstore.projection.name",
+				"trogon.eventstore.projection.status",
+				"trogon.eventstore.queue.message.type",
+				"trogon.eventstore.queue.name",
+				"trogon.eventstore.storage.activity",
+				"trogon.eventstore.storage.source",
+				"trogon.eventstore.system.load_average.period",
+			},
+			TrogonAttributeNames.All);
+		Assert.Equal(constants, TrogonAttributeNames.All);
+	}
+
+	[Fact]
+	public void official_attribute_catalog_contains_only_selected_attributes()
+	{
+		var constants = typeof(AttributeNames)
+			.GetFields(BindingFlags.Public | BindingFlags.Static)
+			.Where(field => field.IsLiteral && field.FieldType == typeof(string))
+			.Select(field => (string)field.GetRawConstantValue())
+			.OrderBy(value => value, StringComparer.Ordinal)
+			.ToArray();
+
+		Assert.Equal(
+			new[]
+			{
+				"disk.io.direction",
+				"host.arch",
+				"host.name",
+				"process.creation.time",
+				"process.executable.name",
+				"process.pid",
+				"process.runtime.name",
+				"process.runtime.version",
+				"service.instance.id",
+				"service.name",
+				"service.version",
+				"system.filesystem.mountpoint",
+				"system.filesystem.state",
+			},
+			constants);
+	}
+
+	[Fact]
+	public void metric_definition_has_value_semantics()
+	{
+		var expected = new MetricDefinition("metric", "s", "Description.", MetricInstrumentKind.Histogram);
+		var actual = new MetricDefinition("metric", "s", "Description.", MetricInstrumentKind.Histogram);
+
+		Assert.Equal(expected, actual);
+		Assert.Equal(expected.GetHashCode(), actual.GetHashCode());
+		Assert.Equal("metric", actual.ToString());
+	}
+
+	[Fact]
+	public void metric_definition_rejects_invalid_metadata()
+	{
+		Assert.Throws<ArgumentException>(() =>
+			new MetricDefinition("", "s", "Description.", MetricInstrumentKind.Histogram));
+		Assert.Throws<ArgumentException>(() =>
+			new MetricDefinition("metric", "", "Description.", MetricInstrumentKind.Histogram));
+		Assert.Throws<ArgumentException>(() =>
+			new MetricDefinition("metric", "s", "", MetricInstrumentKind.Histogram));
+		Assert.Throws<ArgumentOutOfRangeException>(() =>
+			new MetricDefinition("metric", "s", "Description.", (MetricInstrumentKind)(-1)));
+	}
+}
diff --git a/src/EventStore.Core.XUnit.Tests/OpenTelemetry/TelemetryMeterInstrumentationTests.cs b/src/EventStore.Core.XUnit.Tests/OpenTelemetry/TelemetryMeterInstrumentationTests.cs
index 1ea0861a7a..01b74ba66b 100644
--- a/src/EventStore.Core.XUnit.Tests/OpenTelemetry/TelemetryMeterInstrumentationTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/OpenTelemetry/TelemetryMeterInstrumentationTests.cs
@@ -12,6 +12,8 @@ public class TelemetryMeterInstrumentationTests
 	public void PreservesBuiltInMeterNames()
 	{
 		TelemetryMeterInstrumentation.CoreName.Should().Be("EventStore.Core");
+		TelemetryMeterInstrumentation.DotNetRuntimeName.Should().Be("System.Runtime");
+		TelemetryMeterInstrumentation.KestrelName.Should().Be("Microsoft.AspNetCore.Server.Kestrel");
 		TelemetryMeterInstrumentation.ProjectionsName.Should().Be("EventStore.Projections.Core");
 	}
 
@@ -36,6 +38,8 @@ public void IncludesBuiltInMetersOnceBeforeAdditionalMeters()
 		names.Should().Equal(
 			TelemetryMeterInstrumentation.CoreName,
 			TelemetryMeterInstrumentation.ProjectionsName,
+			TelemetryMeterInstrumentation.DotNetRuntimeName,
+			TelemetryMeterInstrumentation.KestrelName,
 			"Custom.Component");
 	}
 
diff --git a/src/EventStore.Core.XUnit.Tests/OpenTelemetry/TelemetryServiceIdentityTests.cs b/src/EventStore.Core.XUnit.Tests/OpenTelemetry/TelemetryServiceIdentityTests.cs
index d01db07d0b..00ec167496 100644
--- a/src/EventStore.Core.XUnit.Tests/OpenTelemetry/TelemetryServiceIdentityTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/OpenTelemetry/TelemetryServiceIdentityTests.cs
@@ -21,6 +21,13 @@ public void UsesTheSameIdentityForAttributeDictionariesAndResources()
 		dictionary.Should().Contain(AttributeNames.ServiceName, "eventstore");
 		dictionary.Should().Contain(AttributeNames.ServiceInstanceId, "test-node");
 		dictionary.Should().Contain(AttributeNames.ServiceVersion, VersionInfo.Version);
+		dictionary.Should().ContainKey(AttributeNames.ProcessCreationTime).WhoseValue.Should().BeOfType<string>();
+		dictionary.Should().Contain(AttributeNames.ProcessPid, Environment.ProcessId);
+		dictionary.Should().ContainKey(AttributeNames.ProcessExecutableName).WhoseValue.Should().BeOfType<string>();
+		dictionary.Should().Contain(AttributeNames.ProcessRuntimeName, ".NET");
+		dictionary.Should().Contain(AttributeNames.ProcessRuntimeVersion, Environment.Version.ToString());
+		dictionary.Should().Contain(AttributeNames.HostName, Environment.MachineName);
+		dictionary.Should().ContainKey(AttributeNames.HostArch).WhoseValue.Should().BeOfType<string>();
 		resource.Should().Contain(dictionary);
 	}
 
diff --git a/src/EventStore.Core.XUnit.Tests/Scavenge/ScavengeStatusTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Scavenge/ScavengeStatusTrackerTests.cs
index d7abab7964..914a41618c 100644
--- a/src/EventStore.Core.XUnit.Tests/Scavenge/ScavengeStatusTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Scavenge/ScavengeStatusTrackerTests.cs
@@ -4,6 +4,7 @@
 using EventStore.Core.Metrics;
 using EventStore.Core.TransactionLog.Scavenging;
 using EventStore.Core.XUnit.Tests.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.Scavenge;
@@ -11,7 +12,6 @@ namespace EventStore.Core.XUnit.Tests.Scavenge;
 public class ScavengeStatusTrackerTests : IDisposable
 {
 	private readonly TestMeterListener<long> _listener;
-	private readonly FakeClock _clock = new();
 	private readonly StatusMetric _metric;
 	private readonly ScavengeStatusTracker _sut;
 
@@ -21,8 +21,7 @@ public ScavengeStatusTrackerTests()
 		_listener = new TestMeterListener<long>(meter);
 		_metric = new StatusMetric(
 			meter,
-			"eventstore-statuses",
-			_clock);
+			MetricDefinitions.TrogonEventstoreComponentStatus);
 		_sut = new ScavengeStatusTracker(_metric);
 	}
 
@@ -32,39 +31,43 @@ public void Dispose()
 		GC.SuppressFinalize(this);
 	}
 
-	[Fact]
-	public void can_observe_activity()
+	[Theory]
+	[InlineData("Accumulation")]
+	[InlineData("Calculation")]
+	[InlineData("Chunk execution")]
+	[InlineData("Chunk merging")]
+	[InlineData("Index execution")]
+	[InlineData("Cleaning")]
+	public void can_observe_activity(string activity)
 	{
-		_clock.SecondsSinceEpoch = 500;
-		AssertMeasurements("Idle", 500);
+		AssertMeasurements("Idle");
 
-		using (_sut.StartActivity("Accumulation"))
+		using (_sut.StartActivity(activity))
 		{
-			_clock.SecondsSinceEpoch = 501;
-			AssertMeasurements("Accumulation Phase", 501);
+			AssertMeasurements($"{activity} Phase");
 		}
 
-		_clock.SecondsSinceEpoch = 502;
-		AssertMeasurements("Idle", 502);
+		AssertMeasurements("Idle");
 	}
 
-	void AssertMeasurements(string expectedStatus, int expectedValue)
+	void AssertMeasurements(string expectedStatus)
 	{
 		_listener.Observe();
 
-		var measurement = Assert.Single(_listener.RetrieveMeasurements("eventstore-statuses"));
-		Assert.Equal(expectedValue, measurement.Value);
+		var measurements = _listener.RetrieveMeasurements(MetricDefinitions.TrogonEventstoreComponentStatus.Name);
+		var measurement = Assert.Single(measurements, candidate => candidate.Value == 1);
+		Assert.All(measurements.Where(candidate => candidate != measurement), candidate => Assert.Equal(0, candidate.Value));
 		Assert.Collection(
 			measurement.Tags.ToArray(),
 			t =>
 			{
-				Assert.Equal("name", t.Key);
-				Assert.Equal("Scavenge", t.Value);
+				Assert.Equal(TrogonAttributeNames.ComponentName, t.Key);
+				Assert.Equal("scavenge", t.Value);
 			},
 			t =>
 			{
-				Assert.Equal("status", t.Key);
-				Assert.Equal(expectedStatus, t.Value);
+				Assert.Equal(TrogonAttributeNames.ComponentStatus, t.Key);
+				Assert.Equal(expectedStatus.ToLowerInvariant(), t.Value);
 			});
 	}
 }
diff --git a/src/EventStore.Core.XUnit.Tests/Services/VNode/NodeStatusTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/Services/VNode/NodeStatusTrackerTests.cs
index a35a4a4d70..ce5c31849e 100644
--- a/src/EventStore.Core.XUnit.Tests/Services/VNode/NodeStatusTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/Services/VNode/NodeStatusTrackerTests.cs
@@ -4,6 +4,7 @@
 using EventStore.Core.Metrics;
 using EventStore.Core.Services.VNode;
 using EventStore.Core.XUnit.Tests.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.TransactionLog.Services.VNode;
@@ -11,7 +12,6 @@ namespace EventStore.Core.TransactionLog.Services.VNode;
 public class NodeStatusTrackerTests : IDisposable
 {
 	private readonly TestMeterListener<long> _listener;
-	private readonly FakeClock _clock = new();
 	private readonly StatusMetric _metric;
 	private readonly NodeStatusTracker _sut;
 
@@ -21,8 +21,7 @@ public NodeStatusTrackerTests()
 		_listener = new TestMeterListener<long>(meter);
 		_metric = new StatusMetric(
 			meter,
-			"eventstore-statuses",
-			_clock);
+			MetricDefinitions.TrogonEventstoreComponentStatus);
 		_sut = new NodeStatusTracker(_metric);
 	}
 
@@ -34,100 +33,99 @@ public void Dispose()
 	[Fact]
 	public void can_observe_state_change()
 	{
-		_clock.SecondsSinceEpoch = 500;
-		AssertMeasurements("Initializing", 500);
+		AssertMeasurements("Initializing");
 
 		_sut.OnStateChange(Data.VNodeState.PreReplica);
-		_clock.SecondsSinceEpoch = 501;
-		AssertMeasurements("PreReplica", 501);
+		AssertMeasurements("PreReplica");
 
 		_sut.OnStateChange(Data.VNodeState.Follower);
-		_clock.SecondsSinceEpoch = 502;
-		AssertMeasurements("Follower", 502);
+		AssertMeasurements("Follower");
+	}
+
+	[Fact]
+	public void previously_seen_states_are_reported_as_inactive()
+	{
+		_sut.OnStateChange(Data.VNodeState.PreReplica);
+		_listener.Observe();
+
+		var measurements = _listener.RetrieveMeasurements(MetricDefinitions.TrogonEventstoreComponentStatus.Name);
+		Assert.Contains(
+			measurements,
+			measurement => measurement.Value == 0 &&
+				measurement.Tags.Any(tag =>
+					tag.Key == TrogonAttributeNames.ComponentStatus &&
+					tag.Value as string == "initializing"));
 	}
 
 	[Fact]
 	public void can_observe_initial()
 	{
-		_clock.SecondsSinceEpoch = 500;
 		_sut.OnStateChange(Data.VNodeState.PreLeader);
 		_sut.OnStateChange(InaugurationManager.ManagerState.BecomingLeader);
-		AssertMeasurements("PreLeader - BecomingLeader", 500);
+		AssertMeasurements("PreLeader - BecomingLeader");
 
-		_clock.SecondsSinceEpoch = 502;
 		_sut.OnStateChange(InaugurationManager.ManagerState.Idle);
-		AssertMeasurements("PreLeader", 502);
+		AssertMeasurements("PreLeader");
 	}
 
 	[Fact]
 	public void can_observe_waiting_for_chaser()
 	{
-		_clock.SecondsSinceEpoch = 500;
 		_sut.OnStateChange(Data.VNodeState.PreLeader);
-		AssertMeasurements("PreLeader", 500);
+		AssertMeasurements("PreLeader");
 
-		_clock.SecondsSinceEpoch = 502;
 		_sut.OnStateChange(InaugurationManager.ManagerState.WaitingForChaser);
-		AssertMeasurements("PreLeader - WaitingForChaser", 502);
+		AssertMeasurements("PreLeader - WaitingForChaser");
 	}
 
 	[Fact]
 	public void can_observe_writing_epoch()
 	{
-		_clock.SecondsSinceEpoch = 500;
 		_sut.OnStateChange(Data.VNodeState.PreLeader);
-		AssertMeasurements("PreLeader", 500);
+		AssertMeasurements("PreLeader");
 
-		_clock.SecondsSinceEpoch = 502;
 		_sut.OnStateChange(InaugurationManager.ManagerState.WritingEpoch);
-		AssertMeasurements("PreLeader - WritingEpoch", 502);
+		AssertMeasurements("PreLeader - WritingEpoch");
 	}
 
 	[Fact]
 	public void can_observe_waiting_for_conditions()
 	{
-		_clock.SecondsSinceEpoch = 500;
 		_sut.OnStateChange(Data.VNodeState.PreLeader);
-		AssertMeasurements("PreLeader", 500);
+		AssertMeasurements("PreLeader");
 
-		_clock.SecondsSinceEpoch = 502;
 		_sut.OnStateChange(InaugurationManager.ManagerState.WaitingForConditions);
-		AssertMeasurements("PreLeader - WaitingForConditions", 502);
+		AssertMeasurements("PreLeader - WaitingForConditions");
 	}
 
 	[Fact]
 	public void can_observe_becoming_leader()
 	{
-		_clock.SecondsSinceEpoch = 500;
 		_sut.OnStateChange(Data.VNodeState.PreLeader);
-		AssertMeasurements("PreLeader", 500);
+		AssertMeasurements("PreLeader");
 
-		_clock.SecondsSinceEpoch = 502;
 		_sut.OnStateChange(InaugurationManager.ManagerState.BecomingLeader);
-		AssertMeasurements("PreLeader - BecomingLeader", 502);
+		AssertMeasurements("PreLeader - BecomingLeader");
 	}
 
-	void AssertMeasurements(string expectedStatus, int expectedValue)
+	void AssertMeasurements(string expectedStatus)
 	{
 		_listener.Observe();
 
+		var measurements = _listener.RetrieveMeasurements(MetricDefinitions.TrogonEventstoreComponentStatus.Name);
+		var active = Assert.Single(measurements, measurement => measurement.Value == 1);
+		Assert.All(measurements.Where(measurement => measurement != active), measurement => Assert.Equal(0, measurement.Value));
 		Assert.Collection(
-			_listener.RetrieveMeasurements("eventstore-statuses"),
-			m =>
+			active.Tags.ToArray(),
+			t =>
+			{
+				Assert.Equal(TrogonAttributeNames.ComponentName, t.Key);
+				Assert.Equal("node", t.Value);
+			},
+			t =>
 			{
-				Assert.Equal(expectedValue, m.Value);
-				Assert.Collection(
-					m.Tags.ToArray(),
-					t =>
-					{
-						Assert.Equal("name", t.Key);
-						Assert.Equal("Node", t.Value);
-					},
-					t =>
-					{
-						Assert.Equal("status", t.Key);
-						Assert.Equal(expectedStatus, t.Value);
-					});
+				Assert.Equal(TrogonAttributeNames.ComponentStatus, t.Key);
+				Assert.Equal(expectedStatus.ToLowerInvariant(), t.Value);
 			});
 	}
 }
diff --git a/src/EventStore.Core.XUnit.Tests/TransactionLog/Checkpoint/CheckpointMetricTests.cs b/src/EventStore.Core.XUnit.Tests/TransactionLog/Checkpoint/CheckpointMetricTests.cs
index 7068c1a2ae..9610556868 100644
--- a/src/EventStore.Core.XUnit.Tests/TransactionLog/Checkpoint/CheckpointMetricTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/TransactionLog/Checkpoint/CheckpointMetricTests.cs
@@ -2,6 +2,7 @@
 using System.Linq;
 using EventStore.Core.TransactionLog.Checkpoint;
 using EventStore.Core.XUnit.Tests.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Core.XUnit.Tests.TransactionLog.Checkpoint;
@@ -15,23 +16,24 @@ public void can_collect()
 		using var listener = new TestMeterListener<long>(meter);
 		var metric = new CheckpointMetric(
 			meter,
-			"eventstore-checkpoints",
+			MetricDefinitions.TrogonEventstoreCheckpointPosition,
 			new InMemoryCheckpoint("checkpoint", 5));
 
 		listener.Observe();
-		var measurement = Assert.Single(listener.RetrieveMeasurements("eventstore-checkpoints"));
+		var measurement = Assert.Single(listener.RetrieveMeasurements(
+			MetricDefinitions.TrogonEventstoreCheckpointPosition.Name));
 		Assert.Equal(5, measurement.Value);
 		Assert.Collection(
 			measurement.Tags.ToArray(),
 			tag =>
 			{
-				Assert.Equal("name", tag.Key);
+				Assert.Equal(TrogonAttributeNames.CheckpointName, tag.Key);
 				Assert.Equal("checkpoint", tag.Value);
 			},
 			tag =>
 			{
-				Assert.Equal("read", tag.Key);
-				Assert.Equal("non-flushed", tag.Value);
+				Assert.Equal(TrogonAttributeNames.CheckpointReadKind, tag.Key);
+				Assert.Equal("non_flushed", tag.Value);
 			});
 	}
 }
diff --git a/src/EventStore.Core.XUnit.Tests/TransactionLog/Chunks/TFChunkTrackerTests.cs b/src/EventStore.Core.XUnit.Tests/TransactionLog/Chunks/TFChunkTrackerTests.cs
index 5cfb553f9c..a905b12fb8 100644
--- a/src/EventStore.Core.XUnit.Tests/TransactionLog/Chunks/TFChunkTrackerTests.cs
+++ b/src/EventStore.Core.XUnit.Tests/TransactionLog/Chunks/TFChunkTrackerTests.cs
@@ -7,6 +7,7 @@
 using EventStore.Core.TransactionLog.Chunks;
 using EventStore.Core.TransactionLog.LogRecords;
 using EventStore.Core.XUnit.Tests.Metrics;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 using static EventStore.Core.TransactionLog.ITransactionFileTracker;
 
@@ -27,14 +28,16 @@ public TFChunkTrackerTests()
 		var meter = new Meter($"{typeof(TFChunkTrackerTests)}");
 		_listener = new TestMeterListener<long>(meter);
 		_doubleListener = new TestMeterListener<double>(meter);
-		var byteMetric = new CounterMetric(meter, "eventstore-io", unit: "bytes");
-		var eventMetric = new CounterMetric(meter, "eventstore-io", unit: "events");
+		var byteMetric = new CounterMetric(meter, MetricDefinitions.TrogonEventstoreStorageIo);
+		var eventMetric = new CounterMetric(meter, MetricDefinitions.TrogonEventstoreStorageEventCount);
 		var writerCheckpoint = new InMemoryCheckpoint(WriterCheckpoint);
 
-		var readTag = new KeyValuePair<string, object>("activity", "read");
+		var readTag = new KeyValuePair<string, object>(TrogonAttributeNames.StorageActivity, "read");
 		_sut = new TFChunkTracker(
-			readDistribution: new LogicalChunkReadDistributionMetric(meter, "chunk-read-distribution", writerCheckpoint, ChunkSize),
-			readDurationMetric: new DurationMetric(meter, "eventstore-io-record-read-duration", _clock),
+			readDistribution: new LogicalChunkReadDistributionMetric(
+				meter, MetricDefinitions.TrogonEventstoreStorageChunkReadDistance, writerCheckpoint, ChunkSize),
+			readDurationMetric: new DurationMetric(
+				meter, MetricDefinitions.TrogonEventstoreStorageRecordReadDuration, _clock),
 			readBytes: new CounterSubMetric(byteMetric, [readTag]),
 			readEvents: new CounterSubMetric(eventMetric, [readTag]));
 	}
@@ -96,7 +99,8 @@ public void records_record_read_duration(Source source)
 		_sut.OnRead(start, prepare, source);
 		_doubleListener.Observe();
 
-		var actual = _doubleListener.RetrieveMeasurements("eventstore-io-record-read-duration-seconds");
+		var actual = _doubleListener.RetrieveMeasurements(
+			MetricDefinitions.TrogonEventstoreStorageRecordReadDuration.Name);
 		Assert.Collection(
 			actual,
 			m =>
@@ -106,8 +110,8 @@ public void records_record_read_duration(Source source)
 					m.Tags.ToArray(),
 					t =>
 					{
-						Assert.Equal("source", t.Key);
-						Assert.Equal(source, t.Value);
+						Assert.Equal(TrogonAttributeNames.StorageSource, t.Key);
+						Assert.Equal(source == Source.ChunkCache ? "chunk_cache" : "file_system", t.Value);
 					});
 			});
 	}
@@ -132,7 +136,7 @@ public void records_read_distribution(long logPosition, long expectedChunk)
 			Source.Unknown);
 
 		_listener.Observe();
-		var actual = _listener.RetrieveMeasurements("chunk-read-distribution");
+		var actual = _listener.RetrieveMeasurements(MetricDefinitions.TrogonEventstoreStorageChunkReadDistance.Name);
 		Assert.Collection(
 			actual,
 			m =>
@@ -143,10 +147,10 @@ public void records_read_distribution(long logPosition, long expectedChunk)
 	}
 
 	private void AssertEventsRead(long? expectedEventsRead) =>
-		AssertMeasurements("eventstore-io-events", expectedEventsRead);
+		AssertMeasurements(MetricDefinitions.TrogonEventstoreStorageEventCount.Name, expectedEventsRead);
 
 	private void AssertBytesRead(long? expectedBytesRead) =>
-		AssertMeasurements("eventstore-io-bytes", expectedBytesRead);
+		AssertMeasurements(MetricDefinitions.TrogonEventstoreStorageIo.Name, expectedBytesRead);
 
 	private void AssertMeasurements(string instrumentName, long? expectedValue)
 	{
@@ -165,7 +169,7 @@ private void AssertMeasurements(string instrumentName, long? expectedValue)
 					Assert.Equal(expectedValue, m.Value);
 					Assert.Collection(m.Tags.ToArray(), t =>
 					{
-						Assert.Equal("activity", t.Key);
+						Assert.Equal(TrogonAttributeNames.StorageActivity, t.Key);
 						Assert.Equal("read", t.Value);
 					});
 				});
diff --git a/src/EventStore.Core/ClusterVNodeStartup.cs b/src/EventStore.Core/ClusterVNodeStartup.cs
index a6e1dbdc4e..a3b11231d0 100644
--- a/src/EventStore.Core/ClusterVNodeStartup.cs
+++ b/src/EventStore.Core/ClusterVNodeStartup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.Metrics;
 using System.IO.Compression;
 using System.Linq;
 using System.Threading.Tasks;
@@ -29,6 +30,7 @@
 using OpenTelemetry;
 using OpenTelemetry.Metrics;
 using OpenTelemetry.Trace;
+using TrogonEventStore.SemanticConventions;
 using ClientGossip = EventStore.Core.Services.Transport.Grpc.Gossip;
 using ClusterGossip = EventStore.Core.Services.Transport.Grpc.Cluster.Gossip;
 using GrpcOperations = EventStore.Core.Services.Transport.Grpc.Operations;
@@ -304,7 +306,7 @@ private static void ConfigureMetrics(
 			.AddMeter(TelemetryMeterInstrumentation.GetNames(metricsConfiguration.Meters))
 			.AddView(i =>
 			{
-				if (i.Name == MetricsBootstrapper.LogicalChunkReadDistributionName)
+				if (i.Name == MetricDefinitions.TrogonEventstoreStorageChunkReadDistance.Name)
 				{
 					// 20 buckets, 0, 1, 2, 4, 8, ...
 					return new ExplicitBucketHistogramConfiguration
@@ -316,26 +318,32 @@ .. Enumerable.Range(0, count: 19).Select(x => 1 << x)
 						]
 					};
 				}
-				else if (i.Name.StartsWith("eventstore-") &&
-						 i.Name.EndsWith("-latency-seconds"))
+				else if (i.Name == MetricDefinitions.TrogonEventstoreGrpcServerCallDuration.Name)
 				{
 					return new ExplicitBucketHistogramConfiguration
 					{
 						Boundaries =
 						[
-							0.001, //    1 ms
-							0.005, //    5 ms
-							0.01, //   10 ms
-							0.05, //   50 ms
-							0.1, //  100 ms
-							0.5, //  500 ms
-							1, // 1000 ms
-							5, // 5000 ms
+							0.005,
+							0.01,
+							0.025,
+							0.05,
+							0.075,
+							0.1,
+							0.25,
+							0.5,
+							0.75,
+							1,
+							2.5,
+							5,
+							7.5,
+							10,
 						]
 					};
 				}
-				else if (i.Name.StartsWith("eventstore-") &&
-						 i.Name.EndsWith("-seconds"))
+				else if (i is Histogram<double> &&
+						 i.Unit == "s" &&
+						 i.Meter.Name == TelemetryMeterInstrumentation.CoreName)
 				{
 					return new ExplicitBucketHistogramConfiguration
 					{
diff --git a/src/EventStore.Core/Diagnostics/TelemetryMeterInstrumentation.cs b/src/EventStore.Core/Diagnostics/TelemetryMeterInstrumentation.cs
index 17d830b9c9..77fbfa0491 100644
--- a/src/EventStore.Core/Diagnostics/TelemetryMeterInstrumentation.cs
+++ b/src/EventStore.Core/Diagnostics/TelemetryMeterInstrumentation.cs
@@ -7,6 +7,8 @@ namespace EventStore.Core.Diagnostics;
 public static class TelemetryMeterInstrumentation
 {
 	public const string CoreName = "EventStore.Core";
+	public const string DotNetRuntimeName = "System.Runtime";
+	public const string KestrelName = "Microsoft.AspNetCore.Server.Kestrel";
 	public const string ProjectionsName = "EventStore.Projections.Core";
 
 	public static string ScopeVersion { get; } = GetScopeVersion();
@@ -15,7 +17,7 @@ public static string[] GetNames(IEnumerable<string> additionalMeterNames)
 	{
 		ArgumentNullException.ThrowIfNull(additionalMeterNames);
 
-		var names = new List<string> { CoreName, ProjectionsName };
+		var names = new List<string> { CoreName, ProjectionsName, DotNetRuntimeName, KestrelName };
 		var seen = new HashSet<string>(names, StringComparer.Ordinal);
 
 		foreach (var name in additionalMeterNames)
diff --git a/src/EventStore.Core/Diagnostics/TelemetryServiceIdentity.cs b/src/EventStore.Core/Diagnostics/TelemetryServiceIdentity.cs
index 400dc513c9..a722b29765 100644
--- a/src/EventStore.Core/Diagnostics/TelemetryServiceIdentity.cs
+++ b/src/EventStore.Core/Diagnostics/TelemetryServiceIdentity.cs
@@ -1,5 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Runtime.InteropServices;
 using EventStore.Common.Utils;
 using OpenTelemetry.Resources;
 using TrogonEventStore.SemanticConventions;
@@ -9,6 +13,7 @@ namespace EventStore.Core.Diagnostics;
 public sealed record TelemetryServiceIdentity
 {
 	private const string DefaultServiceName = "eventstore";
+	private static readonly string ProcessCreationTime = GetProcessCreationTime();
 
 	public string ServiceName { get; }
 	public string ServiceInstanceId { get; }
@@ -38,5 +43,30 @@ private IEnumerable<KeyValuePair<string, object>> GetAttributes()
 		yield return new KeyValuePair<string, object>(AttributeNames.ServiceName, ServiceName);
 		yield return new KeyValuePair<string, object>(AttributeNames.ServiceInstanceId, ServiceInstanceId);
 		yield return new KeyValuePair<string, object>(AttributeNames.ServiceVersion, ServiceVersion);
+		yield return new KeyValuePair<string, object>(AttributeNames.ProcessCreationTime, ProcessCreationTime);
+		yield return new KeyValuePair<string, object>(AttributeNames.ProcessPid, Environment.ProcessId);
+		yield return new KeyValuePair<string, object>(
+			AttributeNames.ProcessExecutableName,
+			Path.GetFileName(Environment.ProcessPath) ?? AppDomain.CurrentDomain.FriendlyName);
+		yield return new KeyValuePair<string, object>(AttributeNames.ProcessRuntimeName, ".NET");
+		yield return new KeyValuePair<string, object>(AttributeNames.ProcessRuntimeVersion, Environment.Version.ToString());
+		yield return new KeyValuePair<string, object>(AttributeNames.HostName, Environment.MachineName);
+		yield return new KeyValuePair<string, object>(AttributeNames.HostArch, GetHostArchitecture());
 	}
+
+	private static string GetProcessCreationTime()
+	{
+		using var process = Process.GetCurrentProcess();
+		return process.StartTime.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture);
+	}
+
+	private static string GetHostArchitecture() =>
+		RuntimeInformation.OSArchitecture switch
+		{
+			Architecture.X64 => "amd64",
+			Architecture.X86 => "x86",
+			Architecture.Arm => "arm32",
+			Architecture.Arm64 => "arm64",
+			var architecture => architecture.ToString().ToLowerInvariant(),
+		};
 }
diff --git a/src/EventStore.Core/Index/IndexStatusTracker.cs b/src/EventStore.Core/Index/IndexStatusTracker.cs
index 94c9d278bb..adba7f421c 100644
--- a/src/EventStore.Core/Index/IndexStatusTracker.cs
+++ b/src/EventStore.Core/Index/IndexStatusTracker.cs
@@ -18,7 +18,14 @@ public class IndexStatusTracker : IIndexStatusTracker
 
 		public IndexStatusTracker(StatusMetric metric)
 		{
-			_metric = new("Index", metric);
+			_metric = new(
+				"Index",
+				metric,
+				"Opening",
+				"Rebuilding",
+				"Initializing",
+				"Merging",
+				"Scavenging");
 		}
 
 		public IDisposable StartOpening() => _metric.StartActivity("Opening");
diff --git a/src/EventStore.Core/Metrics/ActivityStatusSubMetric.cs b/src/EventStore.Core/Metrics/ActivityStatusSubMetric.cs
index 2e1b41acaf..ed57754e67 100644
--- a/src/EventStore.Core/Metrics/ActivityStatusSubMetric.cs
+++ b/src/EventStore.Core/Metrics/ActivityStatusSubMetric.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 
 namespace EventStore.Core.Metrics
 {
@@ -9,8 +10,8 @@ public class ActivityStatusSubMetric : StatusSubMetric, IDisposable
 	{
 		private const string Idle = "Idle";
 
-		public ActivityStatusSubMetric(string componentName, StatusMetric metric)
-			: base(componentName, Idle, metric)
+		public ActivityStatusSubMetric(string componentName, StatusMetric metric, params string[] activities)
+			: base(componentName, Idle, metric, activities.Prepend(Idle))
 		{
 		}
 
diff --git a/src/EventStore.Core/Metrics/AverageMetric.cs b/src/EventStore.Core/Metrics/AverageMetric.cs
deleted file mode 100644
index a887f8f887..0000000000
--- a/src/EventStore.Core/Metrics/AverageMetric.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.Metrics;
-using Tag = System.Collections.Generic.KeyValuePair<string, object>;
-
-namespace EventStore.Core.Metrics
-{
-	// When observed, this calculates the average for each group
-	public class AverageMetric
-	{
-		private readonly object _lock = new();
-		private readonly Func<string, Tag> _genTag;
-		private readonly Dictionary<string, (List<Func<double>>, Tag[])> _subMetricGroups = new();
-
-		public AverageMetric(Meter meter, string name, string unit, Func<string, Tag> genTag)
-		{
-			_genTag = genTag;
-			meter.CreateObservableCounter(name + "-" + unit, Observe);
-		}
-
-		public void Register(string group, Func<double> subMetric)
-		{
-			lock (_lock)
-			{
-				if (_subMetricGroups.TryGetValue(group, out var pair))
-				{
-					pair.Item1.Add(subMetric);
-				}
-				else
-				{
-					var tags = new[] { _genTag(group) };
-					_subMetricGroups[group] = (new() { subMetric }, tags);
-				}
-			}
-		}
-
-		private IEnumerable<Measurement<double>> Observe()
-		{
-			lock (_lock)
-			{
-				foreach (var (groupFuncs, groupTags) in _subMetricGroups.Values)
-				{
-					var total = 0d;
-					foreach (var observe in groupFuncs)
-					{
-						total += observe();
-					}
-					var average = total / groupFuncs.Count;
-					yield return new(average, groupTags);
-				}
-			}
-		}
-	}
-}
diff --git a/src/EventStore.Core/Metrics/CacheHitsMissesMetric.cs b/src/EventStore.Core/Metrics/CacheHitsMissesMetric.cs
index 54f188be10..dabdf30a1f 100644
--- a/src/EventStore.Core/Metrics/CacheHitsMissesMetric.cs
+++ b/src/EventStore.Core/Metrics/CacheHitsMissesMetric.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using System.Linq;
+using TrogonEventStore.SemanticConventions;
 using static EventStore.Common.Configuration.MetricsConfiguration;
 
 namespace EventStore.Core.Metrics;
@@ -16,18 +17,23 @@ public class CacheHitsMissesMetric
 	public CacheHitsMissesMetric(
 		Meter meter,
 		Cache[] enabledCaches,
-		string name,
+		MetricDefinition definition,
 		Dictionary<Cache, string> cacheNames)
 	{
 
+		definition.EnsureInstrumentKind(MetricInstrumentKind.Counter);
 		_enabledCaches = new(cacheNames.Where(x => enabledCaches.Contains(x.Key)));
-		meter.CreateObservableCounter(name, Observe);
+		meter.CreateObservableCounter(
+			definition.Name,
+			Observe,
+			definition.Unit,
+			definition.Description);
 	}
 
 	public void Register(Cache cache, Func<long> getHits, Func<long> getMisses)
 	{
-		Register(cache, "hits", getHits);
-		Register(cache, "misses", getMisses);
+		Register(cache, "hit", getHits);
+		Register(cache, "miss", getMisses);
 	}
 
 	private void Register(Cache cache, string kind, Func<long> func)
@@ -41,8 +47,8 @@ private void Register(Cache cache, string kind, Func<long> func)
 		{
 			_funcs.Add(func);
 			_tagss.Add(new KeyValuePair<string, object>[] {
-				new("cache", cacheName),
-				new("kind", kind),
+				new(TrogonAttributeNames.CacheName, cacheName),
+				new(TrogonAttributeNames.CacheResult, kind),
 			});
 		}
 	}
diff --git a/src/EventStore.Core/Metrics/CacheResourcesMetrics.cs b/src/EventStore.Core/Metrics/CacheResourcesMetrics.cs
index 850ca06d31..35df96bf8f 100644
--- a/src/EventStore.Core/Metrics/CacheResourcesMetrics.cs
+++ b/src/EventStore.Core/Metrics/CacheResourcesMetrics.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using EventStore.Core.Caching;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics;
 
@@ -10,10 +11,13 @@ public class CacheResourcesMetrics
 	private readonly ObservableUpDownMetric<long> _bytesMetric;
 	private readonly ObservableUpDownMetric<long> _entriesMetric;
 
-	public CacheResourcesMetrics(Meter meter, string name)
+	public CacheResourcesMetrics(
+		Meter meter,
+		MetricDefinition bytesMetricDefinition,
+		MetricDefinition entriesMetricDefinition)
 	{
-		_bytesMetric = new ObservableUpDownMetric<long>(meter, name + "-bytes");
-		_entriesMetric = new ObservableUpDownMetric<long>(meter, name + "-entries");
+		_bytesMetric = new ObservableUpDownMetric<long>(meter, bytesMetricDefinition);
+		_entriesMetric = new ObservableUpDownMetric<long>(meter, entriesMetricDefinition);
 	}
 
 	public void Register(string cache, ResizerUnit unit, Func<CacheStats> getStats)
@@ -35,8 +39,8 @@ private static void Register(
 	{
 
 		var tags = new KeyValuePair<string, object>[] {
-			new("cache", cache),
-			new("kind", metricName)
+			new(TrogonAttributeNames.CacheName, cache),
+			new(TrogonAttributeNames.CacheResource, metricName)
 		};
 		metric.Register(() => new(measurementProvider(), tags));
 	}
diff --git a/src/EventStore.Core/Metrics/ConnectionMetric.cs b/src/EventStore.Core/Metrics/ConnectionMetric.cs
deleted file mode 100644
index 9362994f88..0000000000
--- a/src/EventStore.Core/Metrics/ConnectionMetric.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System.Diagnostics.Metrics;
-using System.Diagnostics.Tracing;
-
-namespace EventStore.Core.Metrics;
-
-public class ConnectionMetric : EventListener
-{
-	private readonly UpDownCounter<long> _connectionsMetric;
-
-	public ConnectionMetric(Meter meter, string name)
-	{
-		_connectionsMetric = meter.CreateUpDownCounter<long>(name);
-	}
-
-	protected override void OnEventSourceCreated(EventSource eventSource)
-	{
-		if (eventSource.Name is not "Microsoft-AspNetCore-Server-Kestrel")
-		{
-			return;
-		}
-
-		EnableEvents(eventSource, EventLevel.Verbose);
-	}
-
-	protected override void OnEventWritten(EventWrittenEventArgs eventData)
-	{
-		if (_connectionsMetric == null)
-		{
-			return;
-		}
-
-		switch (eventData.EventName)
-		{
-			case "ConnectionStart":
-				{
-					_connectionsMetric.Add(1);
-					break;
-				}
-			case "ConnectionStop":
-				{
-					_connectionsMetric.Add(-1);
-					break;
-				}
-		}
-	}
-}
diff --git a/src/EventStore.Core/Metrics/CounterMetric.cs b/src/EventStore.Core/Metrics/CounterMetric.cs
index b8ec1961a0..d4b656c744 100644
--- a/src/EventStore.Core/Metrics/CounterMetric.cs
+++ b/src/EventStore.Core/Metrics/CounterMetric.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics
 {
@@ -8,14 +9,14 @@ public class CounterMetric
 		private readonly List<CounterSubMetric> _subMetrics = new();
 		private readonly object _lock = new();
 
-		public CounterMetric(Meter meter, string name, string unit)
+		public CounterMetric(Meter meter, MetricDefinition definition)
 		{
-			if (!string.IsNullOrWhiteSpace(unit))
-			{
-				name = name + "-" + unit;
-			}
-
-			meter.CreateObservableCounter(name, Observe);
+			definition.EnsureInstrumentKind(MetricInstrumentKind.Counter);
+			meter.CreateObservableCounter(
+				definition.Name,
+				Observe,
+				definition.Unit,
+				definition.Description);
 		}
 
 		public void Add(CounterSubMetric subMetric)
diff --git a/src/EventStore.Core/Metrics/Duration.cs b/src/EventStore.Core/Metrics/Duration.cs
index 2c1cff0f14..d84118659b 100644
--- a/src/EventStore.Core/Metrics/Duration.cs
+++ b/src/EventStore.Core/Metrics/Duration.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using EventStore.Core.Time;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics
 {
@@ -31,8 +32,8 @@ public void Dispose()
 		{
 			_metric?.Record(
 				_start,
-				new KeyValuePair<string, object>("activity", _name),
-				new KeyValuePair<string, object>("status", _failed ? "failed" : "successful"));
+				new KeyValuePair<string, object>(TrogonAttributeNames.ActivityName, _name),
+				new KeyValuePair<string, object>(TrogonAttributeNames.ActivityOutcome, _failed ? "error" : "success"));
 		}
 	}
 }
diff --git a/src/EventStore.Core/Metrics/DurationMaxMetric.cs b/src/EventStore.Core/Metrics/DurationMaxMetric.cs
index c23fdc1db2..bfbfe5ee74 100644
--- a/src/EventStore.Core/Metrics/DurationMaxMetric.cs
+++ b/src/EventStore.Core/Metrics/DurationMaxMetric.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics;
 
@@ -7,11 +8,16 @@ public class DurationMaxMetric
 {
 	private readonly List<DurationMaxTracker> _trackers = new();
 
-	public DurationMaxMetric(Meter meter, string name)
+	public DurationMaxMetric(Meter meter, MetricDefinition definition)
 	{
+		definition.EnsureInstrumentKind(MetricInstrumentKind.Gauge);
 		// gauge rather than updowncounter because the dimensions wont make sense to sum,
 		// because they are maxes and not necessarily from the same moment
-		meter.CreateObservableGauge(name + "-seconds", Observe);
+		meter.CreateObservableGauge(
+			definition.Name,
+			Observe,
+			definition.Unit,
+			definition.Description);
 	}
 
 	public void Add(DurationMaxTracker tracker)
diff --git a/src/EventStore.Core/Metrics/DurationMaxTracker.cs b/src/EventStore.Core/Metrics/DurationMaxTracker.cs
index 6ea9b0ba93..b55a607965 100644
--- a/src/EventStore.Core/Metrics/DurationMaxTracker.cs
+++ b/src/EventStore.Core/Metrics/DurationMaxTracker.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using EventStore.Core.Time;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics;
 
@@ -45,10 +46,12 @@ public DurationMaxTracker(
 		var maxTags = new List<KeyValuePair<string, object>>();
 		if (!string.IsNullOrWhiteSpace(name))
 		{
-			maxTags.Add(new("name", name));
+			maxTags.Add(new(TrogonAttributeNames.QueueName, name));
 		}
 
-		maxTags.Add(new("range", $"{_recentMax.MinPeriodSeconds}-{_recentMax.MaxPeriodSeconds} seconds"));
+		maxTags.Add(new(
+			TrogonAttributeNames.MeasurementWindow,
+			$"{_recentMax.MinPeriodSeconds}-{_recentMax.MaxPeriodSeconds}s"));
 		_maxTags = maxTags.ToArray();
 
 		metric.Add(this);
diff --git a/src/EventStore.Core/Metrics/DurationMetric.cs b/src/EventStore.Core/Metrics/DurationMetric.cs
index a9bf5f953d..867567eafd 100644
--- a/src/EventStore.Core/Metrics/DurationMetric.cs
+++ b/src/EventStore.Core/Metrics/DurationMetric.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using EventStore.Core.Time;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics
 {
@@ -9,10 +10,14 @@ public class DurationMetric
 		private readonly Histogram<double> _histogram;
 		private readonly IClock _clock;
 
-		public DurationMetric(Meter meter, string name, IClock clock = null)
+		public DurationMetric(Meter meter, MetricDefinition definition, IClock clock = null)
 		{
+			definition.EnsureInstrumentKind(MetricInstrumentKind.Histogram);
 			_clock = clock ?? Clock.Instance;
-			_histogram = meter.CreateHistogram<double>(name + "-seconds");
+			_histogram = meter.CreateHistogram<double>(
+				definition.Name,
+				definition.Unit,
+				definition.Description);
 		}
 
 		public Duration Start(string durationName) =>
diff --git a/src/EventStore.Core/Metrics/GCSuspensionMetric.cs b/src/EventStore.Core/Metrics/GCSuspensionMetric.cs
deleted file mode 100644
index ea5dc5efe3..0000000000
--- a/src/EventStore.Core/Metrics/GCSuspensionMetric.cs
+++ /dev/null
@@ -1,209 +0,0 @@
-using System;
-using System.Diagnostics.Tracing;
-using EventStore.Core.Bus;
-using Serilog;
-
-namespace EventStore.Core.Metrics;
-
-public class GcSuspensionMetric : EventListener
-{
-	private static readonly ILogger Log = Serilog.Log.ForContext<GcSuspensionMetric>();
-	private static readonly TimeSpan LongSuspensionThreshold = InMemoryBus.DefaultSlowMessageThreshold;
-	private static readonly TimeSpan VeryLongSuspensionThreshold = TimeSpan.FromMilliseconds(600);
-	private static readonly TimeSpan LongSuspensionLogPeriod = TimeSpan.FromSeconds(10);
-	private const int GcKeyword = 0x0000001;
-	private const int GCStart = 1;
-	private const int GCEnd = 2;
-	private const int GCSuspendEEBegin = 9;
-	private const int GCRestartEEEnd = 3;
-	private readonly DurationMaxTracker _tracker;
-	private DateTime? _fullGcStarted;
-	private uint? _fullGcNumber;
-	private DateTime? _suspendStarted;
-	private GCSuspendReason? _suspendReason;
-	private DateTime _lastLongSuspensionLog;
-	private TimeSpan _periodLongSuspensionsElapsedTotal;
-	private int _periodLongSuspensionCount;
-
-	private enum GCStartReason : uint
-	{
-		SmallObjectHeapAllocation = 0,
-		Induced = 1,
-		LowMemory = 2,
-		Empty = 3,
-		LargeObjectHeapAllocation = 4,
-		OutOfSpaceForSmallObjectHeap = 5,
-		OutOfSpaceForLargeObjectHeap = 6,
-		InducedButNotForcedAsBlocking = 7,
-		StressTesting = 8,
-		LowMemoryBlocking = 9,
-		UserCodeInducedCompacting = 10,
-	}
-
-	private enum GCStartType : uint
-	{
-		BlockingOutsideBackgroundGc = 0,
-		BackgroundGc = 1,
-		BlockingDuringBackgroundGc = 2,
-	}
-
-	private enum GCSuspendReason : uint
-	{
-		Other = 0,
-		GarbageCollection = 1,
-		AppDomainShutdown = 2,
-		CodePitching = 3,
-		Shutdown = 4,
-		Debugger = 5,
-		GarbageCollectionPreparation = 6,
-		DebuggerSweep = 7,
-	}
-
-	public GcSuspensionMetric(DurationMaxTracker tracker)
-	{
-		_tracker = tracker;
-	}
-
-	protected override void OnEventSourceCreated(EventSource eventSource)
-	{
-		if (eventSource.Name.Equals("Microsoft-Windows-DotNETRuntime"))
-		{
-			EnableEvents(eventSource, EventLevel.Informational, (EventKeywords)GcKeyword);
-		}
-	}
-
-	protected override void OnEventWritten(EventWrittenEventArgs eventData)
-	{
-		if (_tracker == null)
-		{
-			return;
-		}
-
-		switch (eventData.EventId)
-		{
-			case GCStart:
-				{
-					var payload = eventData.Payload!;
-					var payloadNames = eventData.PayloadNames!;
-					uint? gcNumber = null;
-					uint? generation = null;
-					GCStartReason? reason = null;
-					GCStartType? type = null;
-
-					for (var i = 0; i < payloadNames.Count; i++)
-					{
-						switch (payloadNames[i])
-						{
-							case "Count":
-								gcNumber = (uint)payload[i]!;
-								break;
-							case "Depth":
-								generation = (uint)payload[i]!;
-								break;
-							case "Reason":
-								reason = (GCStartReason)payload[i]!;
-								break;
-							case "Type":
-								type = (GCStartType)payload[i]!;
-								break;
-						}
-					}
-
-					if (generation >= 2 &&
-						type is GCStartType.BlockingOutsideBackgroundGc or GCStartType.BlockingDuringBackgroundGc)
-					{
-						Log.Information(
-							"Start of full blocking garbage collection at {TimeStamp}. GC: #{GCNumber}. Generation: {Generation}. Reason: {Reason}. Type: {Type}.",
-							eventData.TimeStamp, gcNumber, generation, reason, type);
-
-						_fullGcStarted = eventData.TimeStamp;
-						_fullGcNumber = gcNumber;
-					}
-
-					break;
-				}
-
-			case GCEnd:
-				{
-					var gcNumber = (uint)eventData.Payload![eventData.PayloadNames!.IndexOf("Count")]!;
-
-					if (gcNumber == _fullGcNumber && _fullGcStarted is { } started)
-					{
-						var elapsed = eventData.TimeStamp.Subtract(started);
-
-						Log.Information(
-							"End of full blocking garbage collection at {TimeStamp}. GC: #{GCNumber}. Took: {Elapsed:N0}ms",
-							eventData.TimeStamp, gcNumber, elapsed.TotalMilliseconds);
-
-						_fullGcStarted = null;
-						_fullGcNumber = null;
-					}
-
-					break;
-				}
-
-			case GCSuspendEEBegin:
-				{
-					_suspendReason = (GCSuspendReason)eventData.Payload![eventData.PayloadNames!.IndexOf("Reason")]!;
-					_suspendStarted = eventData.TimeStamp;
-					break;
-				}
-
-			case GCRestartEEEnd:
-				{
-					if (_suspendStarted is not { } started)
-					{
-						Log.Warning(
-							"Unexpected garbage collection GCRestartEEEnd event. Started: {Started}. Reason: {Reason}",
-							_suspendStarted, _suspendReason);
-						return;
-					}
-
-					var elapsed = eventData.TimeStamp.Subtract(started);
-					if (_suspendReason is GCSuspendReason.GarbageCollection
-						or GCSuspendReason.GarbageCollectionPreparation)
-					{
-						_tracker.RecordNow(elapsed);
-					}
-
-					if (elapsed >= VeryLongSuspensionThreshold)
-					{
-						Log.Warning(
-							"Garbage collection: Very long Execution Engine Suspension. Reason: {Reason}. Took: {Elapsed:N0}ms",
-							_suspendReason, elapsed.TotalMilliseconds);
-					}
-					else if (elapsed >= LongSuspensionThreshold)
-					{
-						var now = DateTime.Now;
-						if (now - _lastLongSuspensionLog > LongSuspensionLogPeriod)
-						{
-							if (_periodLongSuspensionCount > 0)
-							{
-								Log.Information(
-									"Garbage collection: Long Execution Engine Suspensions omitted. {Count} suspensions took {Elapsed:N0}ms each on average",
-									_periodLongSuspensionCount,
-									_periodLongSuspensionsElapsedTotal.TotalMilliseconds / _periodLongSuspensionCount);
-							}
-
-							Log.Information(
-								"Garbage collection: Long Execution Engine Suspension. Reason: {Reason}. Took: {Elapsed:N0}ms",
-								_suspendReason, elapsed.TotalMilliseconds);
-
-							_lastLongSuspensionLog = now;
-							_periodLongSuspensionCount = 0;
-							_periodLongSuspensionsElapsedTotal = TimeSpan.Zero;
-						}
-						else
-						{
-							_periodLongSuspensionCount++;
-							_periodLongSuspensionsElapsedTotal += elapsed;
-						}
-					}
-
-					_suspendStarted = null;
-					_suspendReason = null;
-					break;
-				}
-		}
-	}
-}
diff --git a/src/EventStore.Core/Metrics/IncomingGrpcCallsMetric.cs b/src/EventStore.Core/Metrics/IncomingGrpcCallsMetric.cs
index e43ba69a46..3dea26cfd3 100644
--- a/src/EventStore.Core/Metrics/IncomingGrpcCallsMetric.cs
+++ b/src/EventStore.Core/Metrics/IncomingGrpcCallsMetric.cs
@@ -1,17 +1,13 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using System.Diagnostics.Tracing;
 using System.Linq;
 using System.Threading;
+using TrogonEventStore.SemanticConventions;
 using static EventStore.Common.Configuration.MetricsConfiguration;
 
 namespace EventStore.Core.Metrics;
 
-// using observable counters rather than regular to reduce the cost of incrementing
-// (although, its probably not important at the rate calls are created)
-// works in a similar way to the PollingCounters here
-// https://github.com/grpc/grpc-dotnet/blob/master/src/Grpc.AspNetCore.Server/Internal/GrpcEventSource.cs
 public class IncomingGrpcCallsMetric : EventListener
 {
 	private long _callsCurrent;
@@ -22,74 +18,58 @@ public class IncomingGrpcCallsMetric : EventListener
 
 	public IncomingGrpcCallsMetric(
 		Meter meter,
-		string currentCallsMetricName,
-		string totalCallsMetricName,
+		MetricDefinition currentCallsDefinition,
+		MetricDefinition totalCallsDefinition,
+		MetricDefinition failedCallsDefinition,
+		MetricDefinition unimplementedCallsDefinition,
+		MetricDefinition deadlineExceededCallsDefinition,
 		IncomingGrpcCall[] filter)
 	{
+		currentCallsDefinition.EnsureInstrumentKind(MetricInstrumentKind.UpDownCounter);
+		totalCallsDefinition.EnsureInstrumentKind(MetricInstrumentKind.Counter);
+		failedCallsDefinition.EnsureInstrumentKind(MetricInstrumentKind.Counter);
+		unimplementedCallsDefinition.EnsureInstrumentKind(MetricInstrumentKind.Counter);
+		deadlineExceededCallsDefinition.EnsureInstrumentKind(MetricInstrumentKind.Counter);
 
 		if (filter.Contains(IncomingGrpcCall.Current))
 		{
 			meter.CreateObservableUpDownCounter(
-				currentCallsMetricName,
-				() => Volatile.Read(ref _callsCurrent));
+				currentCallsDefinition.Name,
+				() => Volatile.Read(ref _callsCurrent),
+				currentCallsDefinition.Unit,
+				currentCallsDefinition.Description);
 		}
 
-		var funcs = new List<Func<Measurement<long>>>();
-
-		if (filter.Contains(IncomingGrpcCall.Total))
-		{
-			var tags = GenTags("total");
-			funcs.Add(() => new(Volatile.Read(ref _callsTotal), tags.AsSpan()));
-		}
-
-		if (filter.Contains(IncomingGrpcCall.Failed))
-		{
-			var tags = GenTags("failed");
-			funcs.Add(() => new(Volatile.Read(ref _callsFailed), tags.AsSpan()));
-		}
-
-		if (filter.Contains(IncomingGrpcCall.Unimplemented))
+		CreateCounter(IncomingGrpcCall.Total, totalCallsDefinition, () => Volatile.Read(ref _callsTotal));
+		CreateCounter(IncomingGrpcCall.Failed, failedCallsDefinition, () => Volatile.Read(ref _callsFailed));
+		CreateCounter(
+			IncomingGrpcCall.Unimplemented,
+			unimplementedCallsDefinition,
+			() => Volatile.Read(ref _callsUnimplemented));
+		CreateCounter(
+			IncomingGrpcCall.DeadlineExceeded,
+			deadlineExceededCallsDefinition,
+			() => Volatile.Read(ref _callsDeadlineExceeded));
+
+		void CreateCounter(IncomingGrpcCall tracker, MetricDefinition definition, Func<long> observe)
 		{
-			var tags = GenTags("unimplemented");
-			funcs.Add(() => new(Volatile.Read(ref _callsUnimplemented), tags.AsSpan()));
-		}
-
-		if (filter.Contains(IncomingGrpcCall.DeadlineExceeded))
-		{
-			var tags = GenTags("deadline-exceeded");
-			funcs.Add(() => new(Volatile.Read(ref _callsDeadlineExceeded), tags.AsSpan()));
-		}
-
-		meter.CreateObservableCounter(totalCallsMetricName, GenObserveCalls(funcs.ToArray()));
-	}
-
-	private static KeyValuePair<string, object>[] GenTags(string kind) =>
-		new KeyValuePair<string, object>[] { new("kind", kind) };
-
-	private static Func<IEnumerable<Measurement<long>>> GenObserveCalls(
-		Func<Measurement<long>>[] funcs)
-	{
-
-		var measurements = new Measurement<long>[funcs.Length];
-
-		return () =>
-		{
-			for (var i = 0; i < measurements.Length; i++)
+			if (filter.Contains(tracker))
 			{
-				measurements[i] = funcs[i]();
+				meter.CreateObservableCounter(
+					definition.Name,
+					observe,
+					definition.Unit,
+					definition.Description);
 			}
-			return measurements;
-		};
+		}
 	}
 
 	protected override void OnEventSourceCreated(EventSource eventSource)
 	{
-		if (eventSource.Name != "Grpc.AspNetCore.Server")
+		if (eventSource.Name == "Grpc.AspNetCore.Server")
 		{
-			return;
+			EnableEvents(eventSource, EventLevel.Verbose);
 		}
-
-		EnableEvents(eventSource, EventLevel.Verbose);
 	}
 
 	protected override void OnEventWritten(EventWrittenEventArgs eventData)
@@ -100,19 +80,15 @@ protected override void OnEventWritten(EventWrittenEventArgs eventData)
 				Interlocked.Increment(ref _callsTotal);
 				Interlocked.Increment(ref _callsCurrent);
 				break;
-
 			case "CallStop":
 				Interlocked.Decrement(ref _callsCurrent);
 				break;
-
 			case "CallFailed":
 				Interlocked.Increment(ref _callsFailed);
 				break;
-
 			case "CallDeadlineExceeded":
 				Interlocked.Increment(ref _callsDeadlineExceeded);
 				break;
-
 			case "CallUnimplemented":
 				Interlocked.Increment(ref _callsUnimplemented);
 				break;
diff --git a/src/EventStore.Core/Metrics/LogicalChunkReadDistributionMetric.cs b/src/EventStore.Core/Metrics/LogicalChunkReadDistributionMetric.cs
index cfe74c90c9..70825f92bd 100644
--- a/src/EventStore.Core/Metrics/LogicalChunkReadDistributionMetric.cs
+++ b/src/EventStore.Core/Metrics/LogicalChunkReadDistributionMetric.cs
@@ -1,6 +1,7 @@
 using System.Diagnostics.Metrics;
 using EventStore.Core.TransactionLog.Checkpoint;
 using EventStore.Core.TransactionLog.LogRecords;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics;
 
@@ -10,9 +11,17 @@ public class LogicalChunkReadDistributionMetric
 	private readonly IReadOnlyCheckpoint _writer;
 	private readonly int _chunkSize;
 
-	public LogicalChunkReadDistributionMetric(Meter meter, string name, IReadOnlyCheckpoint writer, int chunkSize)
+	public LogicalChunkReadDistributionMetric(
+		Meter meter,
+		MetricDefinition definition,
+		IReadOnlyCheckpoint writer,
+		int chunkSize)
 	{
-		_histogram = meter.CreateHistogram<long>(name);
+		definition.EnsureInstrumentKind(MetricInstrumentKind.Histogram);
+		_histogram = meter.CreateHistogram<long>(
+			definition.Name,
+			definition.Unit,
+			definition.Description);
 		_writer = writer;
 		_chunkSize = chunkSize;
 	}
diff --git a/src/EventStore.Core/Metrics/MaxMetric.cs b/src/EventStore.Core/Metrics/MaxMetric.cs
index 6c0a994718..bc33f95b87 100644
--- a/src/EventStore.Core/Metrics/MaxMetric.cs
+++ b/src/EventStore.Core/Metrics/MaxMetric.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics;
 
@@ -7,11 +8,16 @@ public class MaxMetric<T> where T : struct
 {
 	private readonly List<MaxTracker<T>> _trackers = new();
 
-	public MaxMetric(Meter meter, string name)
+	public MaxMetric(Meter meter, MetricDefinition definition)
 	{
+		definition.EnsureInstrumentKind(MetricInstrumentKind.Gauge);
 		// gauge rather than updowncounter because the dimensions wont make sense to sum,
 		// because they are maxes and not necessarily from the same moment
-		meter.CreateObservableGauge(name, Observe);
+		meter.CreateObservableGauge(
+			definition.Name,
+			Observe,
+			definition.Unit,
+			definition.Description);
 	}
 
 	public void Add(MaxTracker<T> tracker)
diff --git a/src/EventStore.Core/Metrics/MaxTracker.cs b/src/EventStore.Core/Metrics/MaxTracker.cs
index 441cb87b2e..44301391a8 100644
--- a/src/EventStore.Core/Metrics/MaxTracker.cs
+++ b/src/EventStore.Core/Metrics/MaxTracker.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using EventStore.Core.Time;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics;
 
@@ -32,10 +33,12 @@ public MaxTracker(
 		var maxTags = new List<KeyValuePair<string, object>>();
 		if (!string.IsNullOrWhiteSpace(name))
 		{
-			maxTags.Add(new("name", name));
+			maxTags.Add(new(TrogonAttributeNames.QueueName, name));
 		}
 
-		maxTags.Add(new("range", $"{_recentMax.MinPeriodSeconds}-{_recentMax.MaxPeriodSeconds} seconds"));
+		maxTags.Add(new(
+			TrogonAttributeNames.MeasurementWindow,
+			$"{_recentMax.MinPeriodSeconds}-{_recentMax.MaxPeriodSeconds}s"));
 		_maxTags = maxTags.ToArray();
 
 		metric.Add(this);
diff --git a/src/EventStore.Core/Metrics/ObservableUpDownMetric.cs b/src/EventStore.Core/Metrics/ObservableUpDownMetric.cs
index 6c9bb309fe..62bf6f514b 100644
--- a/src/EventStore.Core/Metrics/ObservableUpDownMetric.cs
+++ b/src/EventStore.Core/Metrics/ObservableUpDownMetric.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics;
 
@@ -9,9 +10,14 @@ public class ObservableUpDownMetric<T> where T : struct
 	private readonly List<Func<Measurement<T>>> _measurementProviders = new();
 	private readonly object _lock = new();
 
-	public ObservableUpDownMetric(Meter meter, string name, string unit = null)
+	public ObservableUpDownMetric(Meter meter, MetricDefinition definition)
 	{
-		meter.CreateObservableUpDownCounter(name, Observe, unit);
+		definition.EnsureInstrumentKind(MetricInstrumentKind.UpDownCounter);
+		meter.CreateObservableUpDownCounter(
+			definition.Name,
+			Observe,
+			definition.Unit,
+			definition.Description);
 	}
 
 	public void Register(Func<Measurement<T>> measurementProvider)
@@ -38,3 +44,19 @@ private IEnumerable<Measurement<T>> Observe()
 		}
 	}
 }
+
+internal static class MetricDefinitionExtensions
+{
+	public static void EnsureInstrumentKind(
+		this MetricDefinition definition,
+		MetricInstrumentKind expected)
+	{
+		ArgumentNullException.ThrowIfNull(definition);
+		if (definition.InstrumentKind != expected)
+		{
+			throw new ArgumentException(
+				$"Metric '{definition.Name}' requires a {expected} instrument.",
+				nameof(definition));
+		}
+	}
+}
diff --git a/src/EventStore.Core/Metrics/PersistentSubscriptionTracker.cs b/src/EventStore.Core/Metrics/PersistentSubscriptionTracker.cs
index 3f409e680e..af0d79aa43 100644
--- a/src/EventStore.Core/Metrics/PersistentSubscriptionTracker.cs
+++ b/src/EventStore.Core/Metrics/PersistentSubscriptionTracker.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using EventStore.Common.Utils;
 using EventStore.Core.Messages;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics;
 
@@ -19,63 +20,63 @@ public void OnNewStats(IReadOnlyList<MonitoringMessage.PersistentSubscriptionInf
 	public IEnumerable<Measurement<long>> ObserveConnectionsCount() =>
 		_currentStats.Select(x =>
 			new Measurement<long>(x.Connections.Count, [
-				new("event_stream_id", x.EventSource),
-				new("group_name", x.GroupName)]));
+				new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+				new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName)]));
 
 	public IEnumerable<Measurement<long>> ObserveParkedMessages() =>
 		_currentStats.Select(x =>
 			new Measurement<long>(x.ParkedMessageCount, [
-				new("event_stream_id", x.EventSource),
-				new("group_name", x.GroupName)
+				new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+				new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName)
 			]));
 
 	public IEnumerable<Measurement<long>> ObserveParkMessageRequests() =>
 		_currentStats.SelectMany<MonitoringMessage.PersistentSubscriptionInfo, Measurement<long>>(x => [
 			new(x.ParkedDueToClientNak, [
-				new("event_stream_id", x.EventSource),
-				new("group_name", x.GroupName),
-				new("reason", "client-nak")
+				new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+				new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName),
+				new(TrogonAttributeNames.PersistentSubscriptionReason, "client_nack")
 			]),
 			new(x.ParkedDueToMaxRetries, [
-				new("event_stream_id", x.EventSource),
-				new("group_name", x.GroupName),
-				new("reason", "max-retries")
+				new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+				new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName),
+				new(TrogonAttributeNames.PersistentSubscriptionReason, "max_retries")
 			])
 		]);
 
 	public IEnumerable<Measurement<long>> ObserveParkedMessageReplays() =>
 		_currentStats.Select(x =>
 			new Measurement<long>(x.ParkedMessageReplays, [
-				new("event_stream_id", x.EventSource),
-				new("group_name", x.GroupName)
+				new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+				new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName)
 			]));
 
 	public IEnumerable<Measurement<long>> ObserveParkedMessageTruncates() =>
 		_currentStats.Select(x =>
 			new Measurement<long>(x.ParkedMessageTruncates, [
-				new("event_stream_id", x.EventSource),
-				new("group_name", x.GroupName)
+				new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+				new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName)
 			]));
 
 	public IEnumerable<Measurement<long>> ObserveInFlightMessages() =>
 		_currentStats.Select(x =>
 			new Measurement<long>(x.TotalInFlightMessages, [
-				new("event_stream_id", x.EventSource),
-				new("group_name", x.GroupName)
+				new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+				new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName)
 			]));
 
 	public IEnumerable<Measurement<long>> ObserveOldestParkedMessage() =>
 		_currentStats.Select(x =>
 			new Measurement<long>(x.OldestParkedMessage, [
-				new("event_stream_id", x.EventSource),
-				new("group_name", x.GroupName)
+				new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+				new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName)
 			]));
 
 	public IEnumerable<Measurement<long>> ObserveItemsProcessed() =>
 		_currentStats.Select(x =>
 			new Measurement<long>(x.TotalItems, [
-				new("event_stream_id", x.EventSource),
-				new("group_name", x.GroupName)
+				new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+				new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName)
 			]));
 
 	public IEnumerable<Measurement<long>> ObserveLastKnownEvent() =>
@@ -87,8 +88,8 @@ public IEnumerable<Measurement<long>> ObserveLastKnownEvent() =>
 					? lastEventPos
 					: 0;
 				return new Measurement<long>(measurement, [
-					new("event_stream_id", x.EventSource),
-					new("group_name", x.GroupName)
+					new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+					new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName)
 				]);
 			});
 
@@ -99,8 +100,8 @@ public IEnumerable<Measurement<long>> ObserveLastKnownEventCommitPosition() =>
 			{
 				var (eventCommitPosition, _) = EventPositionParser.ParseCommitPreparePosition(x.LastKnownEventPosition);
 				return new Measurement<long>(eventCommitPosition, [
-					new("event_stream_id", x.EventSource),
-					new("group_name", x.GroupName)
+					new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+					new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName)
 				]);
 			});
 
@@ -113,8 +114,8 @@ public IEnumerable<Measurement<long>> ObserveLastCheckpointedEvent() =>
 					? lastEventPos
 					: 0;
 				return new Measurement<long>(measurement, [
-					new("event_stream_id", x.EventSource),
-					new("group_name", x.GroupName)
+					new(TrogonAttributeNames.PersistentSubscriptionStream, x.EventSource),
+					new(TrogonAttributeNames.PersistentSubscriptionGroup, x.GroupName)
 				]);
 			});
 
@@ -125,8 +126,8 @@ public IEnumerable<Measurement<long>> ObserveLastCheckpointedEventCommitPosition
 			{
 				var (checkpointedCommitPosition, _) = EventPositionParser.ParseCommitPreparePosition(statistics.LastCheckpointedEventPosition);
 				return new Measurement<long>(checkpointedCommitPosition, [
-					new("event_stream_id", statistics.EventSource),
-					new("group_name", statistics.GroupName)
+					new(TrogonAttributeNames.PersistentSubscriptionStream, statistics.EventSource),
+					new(TrogonAttributeNames.PersistentSubscriptionGroup, statistics.GroupName)
 				]);
 			});
 }
diff --git a/src/EventStore.Core/Metrics/ProcessMetrics.cs b/src/EventStore.Core/Metrics/ProcessMetrics.cs
index 7e0eadf3bc..93e834ea06 100644
--- a/src/EventStore.Core/Metrics/ProcessMetrics.cs
+++ b/src/EventStore.Core/Metrics/ProcessMetrics.cs
@@ -4,147 +4,140 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.Metrics;
-using System.Linq;
-using System.Reflection;
-using System.Threading;
 using EventStore.Core.Util;
+using TrogonEventStore.SemanticConventions;
 
 using static EventStore.Common.Configuration.MetricsConfiguration;
 
 namespace EventStore.Core.Metrics;
 
-public class ProcessMetrics(Meter meter, TimeSpan timeout, int scrapingPeriodInSeconds, Dictionary<ProcessTracker, bool> config)
+public class ProcessMetrics
 {
-	private readonly Func<DiskIoData> _getDiskIo = Functions.Debounce(ProcessStats.GetDiskIo, timeout);
-	private readonly Func<Process> _getCurrentProc = Functions.Debounce(Process.GetCurrentProcess, timeout);
-
-	public void CreateObservableMetrics(Dictionary<ProcessTracker, string> metricNames)
+	private readonly Meter _meter;
+	private readonly Dictionary<ProcessTracker, bool> _config;
+	private readonly Func<DiskIoData> _getDiskIo;
+	private readonly DateTime _processStartTimeUtc;
+
+	public ProcessMetrics(
+		Meter meter,
+		TimeSpan timeout,
+		Dictionary<ProcessTracker, bool> config)
 	{
-		var enabledNames = metricNames
-			.Where(kvp => config.TryGetValue(kvp.Key, out var enabled) && enabled)
-			.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
-
-		if (enabledNames.TryGetValue(ProcessTracker.UpTime, out var upTimeName))
-		{
-			meter.CreateObservableCounter(upTimeName, () =>
-			{
-				var process = _getCurrentProc();
-				var upTime = (DateTime.Now - process.StartTime).TotalSeconds;
-				return new Measurement<double>(upTime, new KeyValuePair<string, object?>("pid", process.Id));
-			});
-		}
+		_meter = meter;
+		_config = config;
+		_getDiskIo = Functions.Debounce(ProcessStats.GetDiskIo, timeout);
+		using var process = Process.GetCurrentProcess();
+		_processStartTimeUtc = process.StartTime.ToUniversalTime();
+	}
 
-		if (enabledNames.TryGetValue(ProcessTracker.GcPauseDuration, out var gcMaxPauseName))
+	public void CreateUptimeMetric()
+	{
+		if (!IsEnabled(ProcessTracker.UpTime))
 		{
-			var maxGcPauseDurationMetric = new DurationMaxMetric(meter, gcMaxPauseName);
-			var maxGcPauseDurationTracker = new DurationMaxTracker(maxGcPauseDurationMetric, null, scrapingPeriodInSeconds);
-			_ = new GcSuspensionMetric(maxGcPauseDurationTracker);
+			return;
 		}
 
-		CreateObservableCounter(ProcessTracker.LockContentionCount, () => Monitor.LockContentionCount);
-		CreateObservableCounter(ProcessTracker.ExceptionCount, RuntimeStats.GetExceptionCount);
-		CreateObservableCounter(ProcessTracker.TotalAllocatedBytes, () => GC.GetTotalAllocatedBytes(), "bytes");
-
-		CreateObservableUpDownCounter(ProcessTracker.Cpu, RuntimeStats.GetCpuUsage);
-		CreateObservableUpDownCounter(ProcessTracker.ThreadCount, () => ThreadPool.ThreadCount);
-		CreateObservableUpDownCounter(ProcessTracker.ThreadPoolPendingWorkItemCount, () => ThreadPool.PendingWorkItemCount);
-		CreateObservableUpDownCounter(ProcessTracker.TimeInGc, RuntimeStats.GetLastGCPercentTimeInGC);
-		CreateObservableUpDownCounter(ProcessTracker.HeapSize, () => GC.GetGCMemoryInfo().HeapSizeBytes, "bytes");
-		CreateObservableUpDownCounter(ProcessTracker.HeapFragmentation, () =>
-		{
-			var info = GC.GetGCMemoryInfo();
-			return info.HeapSizeBytes != 0 ? info.FragmentedBytes * 100d / info.HeapSizeBytes : 0;
-		});
-
-		return;
+		CreateObservableGauge(
+			OpenTelemetryMetricDefinitions.ProcessUptime,
+			() => (DateTime.UtcNow - _processStartTimeUtc).TotalSeconds);
+	}
 
-		void CreateObservableCounter<T>(ProcessTracker tracker, Func<T> observe, string? unit = null) where T : struct
+	public void CreateDiskIoMetric()
+	{
+		var readEnabled = IsEnabled(ProcessTracker.DiskReadBytes);
+		var writeEnabled = IsEnabled(ProcessTracker.DiskWrittenBytes);
+		if (!readEnabled && !writeEnabled)
 		{
-			if (enabledNames.TryGetValue(tracker, out var name))
-			{
-				meter.CreateObservableCounter(name, observe);
-			}
+			return;
 		}
 
-		void CreateObservableUpDownCounter<T>(ProcessTracker tracker, Func<T> observe, string? unit = null) where T : struct
-		{
-			if (enabledNames.TryGetValue(tracker, out var name))
-			{
-				meter.CreateObservableUpDownCounter(unit is null ? name : $"{name}-{unit}", observe);
-			}
-		}
+		CreateObservableCounter(
+			OpenTelemetryMetricDefinitions.ProcessDiskIo,
+			() => ObserveDiskIo(readEnabled, writeEnabled));
 	}
 
-	public void CreateMemoryMetric(string metricName, Dictionary<ProcessTracker, string> dimNames)
+	public void CreateDiskOperationMetric()
 	{
-		var dims = new Dimensions<ProcessTracker, long>(config, dimNames, tag => new("kind", tag));
-
-		dims.Register(ProcessTracker.MemWorkingSet, () => _getCurrentProc().WorkingSet64);
-		dims.Register(ProcessTracker.MemPagedBytes, () => _getCurrentProc().PagedMemorySize64);
-		dims.Register(ProcessTracker.MemVirtualBytes, () => _getCurrentProc().VirtualMemorySize64);
-
-		if (dims.AnyRegistered())
+		var readEnabled = IsEnabled(ProcessTracker.DiskReadOps);
+		var writeEnabled = IsEnabled(ProcessTracker.DiskWrittenOps);
+		if (!readEnabled && !writeEnabled)
 		{
-			meter.CreateObservableGauge($"{metricName}-bytes", dims.GenObserve());
+			return;
 		}
+
+		CreateObservableCounter(
+			MetricDefinitions.TrogonEventstoreProcessDiskOperationCount,
+			() => ObserveDiskOperations(readEnabled, writeEnabled));
 	}
 
-	public void CreateGcGenerationSizeMetric(string metricName, Dictionary<ProcessTracker, string> dimNames)
+	private IEnumerable<Measurement<long>> ObserveDiskIo(bool readEnabled, bool writeEnabled)
 	{
-		var dims = new Dimensions<ProcessTracker, long>(config, dimNames, tag => new("generation", tag));
-
-		var getGcGenerationSize = typeof(GC)
-			.GetMethod("GetGenerationSize", BindingFlags.Static | BindingFlags.NonPublic)!
-			.CreateDelegate<Func<int, ulong>>();
-
-		dims.Register(ProcessTracker.Gen0Size, () => (long)getGcGenerationSize(0));
-		dims.Register(ProcessTracker.Gen1Size, () => (long)getGcGenerationSize(1));
-		dims.Register(ProcessTracker.Gen2Size, () => (long)getGcGenerationSize(2));
-		dims.Register(ProcessTracker.LohSize, () => (long)getGcGenerationSize(3));
+		var diskIo = _getDiskIo();
+		if (readEnabled)
+		{
+			yield return new(
+				(long)diskIo.ReadBytes,
+				new KeyValuePair<string, object?>(AttributeNames.DiskIoDirection, "read"));
+		}
 
-		if (dims.AnyRegistered())
+		if (writeEnabled)
 		{
-			meter.CreateObservableUpDownCounter($"{metricName}-bytes", dims.GenObserve());
+			yield return new(
+				(long)diskIo.WrittenBytes,
+				new KeyValuePair<string, object?>(AttributeNames.DiskIoDirection, "write"));
 		}
 	}
 
-	public void CreateGcCollectionCountMetric(string metricName, Dictionary<ProcessTracker, string> dimNames)
+	private IEnumerable<Measurement<long>> ObserveDiskOperations(bool readEnabled, bool writeEnabled)
 	{
-		var dims = new Dimensions<ProcessTracker, int>(config, dimNames, tag => new("generation", tag));
-
-		dims.Register(ProcessTracker.Gen0CollectionCount, () => GC.CollectionCount(0));
-		dims.Register(ProcessTracker.Gen1CollectionCount, () => GC.CollectionCount(1));
-		dims.Register(ProcessTracker.Gen2CollectionCount, () => GC.CollectionCount(2));
+		var diskIo = _getDiskIo();
+		if (readEnabled)
+		{
+			yield return new(
+				(long)diskIo.ReadOps,
+				new KeyValuePair<string, object?>(AttributeNames.DiskIoDirection, "read"));
+		}
 
-		if (dims.AnyRegistered())
+		if (writeEnabled)
 		{
-			meter.CreateObservableCounter(metricName, dims.GenObserve());
+			yield return new(
+				(long)diskIo.WriteOps,
+				new KeyValuePair<string, object?>(AttributeNames.DiskIoDirection, "write"));
 		}
 	}
 
-	public void CreateDiskBytesMetric(string metricName, Dictionary<ProcessTracker, string> dimNames)
+	private void CreateObservableGauge(MetricDefinition definition, Func<double> observe)
 	{
-		var dims = new Dimensions<ProcessTracker, long>(config, dimNames, tag => new("activity", tag));
-
-		dims.Register(ProcessTracker.DiskReadBytes, () => (long)_getDiskIo().ReadBytes);
-		dims.Register(ProcessTracker.DiskWrittenBytes, () => (long)_getDiskIo().WrittenBytes);
-
-		if (dims.AnyRegistered())
-		{
-			meter.CreateObservableCounter($"{metricName}-bytes", dims.GenObserve());
-		}
+		EnsureKind(definition, MetricInstrumentKind.Gauge);
+		_meter.CreateObservableGauge(
+			definition.Name,
+			observe,
+			definition.Unit,
+			definition.Description);
 	}
 
-	public void CreateDiskOpsMetric(string name, Dictionary<ProcessTracker, string> dimNames)
+	private void CreateObservableCounter(
+		MetricDefinition definition,
+		Func<IEnumerable<Measurement<long>>> observe)
 	{
-		var dims = new Dimensions<ProcessTracker, long>(config, dimNames, tag => new("activity", tag));
+		EnsureKind(definition, MetricInstrumentKind.Counter);
+		_meter.CreateObservableCounter(
+			definition.Name,
+			observe,
+			definition.Unit,
+			definition.Description);
+	}
 
-		dims.Register(ProcessTracker.DiskReadOps, () => (long)_getDiskIo().ReadOps);
-		dims.Register(ProcessTracker.DiskWrittenOps, () => (long)_getDiskIo().WriteOps);
+	private bool IsEnabled(ProcessTracker tracker) =>
+		_config.TryGetValue(tracker, out var enabled) && enabled;
 
-		if (dims.AnyRegistered())
+	private static void EnsureKind(MetricDefinition definition, MetricInstrumentKind expected)
+	{
+		if (definition.InstrumentKind != expected)
 		{
-			meter.CreateObservableCounter($"{name}-operations", dims.GenObserve());
+			throw new ArgumentException(
+				$"Metric '{definition.Name}' requires a {expected} instrument.",
+				nameof(definition));
 		}
 	}
 }
diff --git a/src/EventStore.Core/Metrics/QueueBusyTracker.cs b/src/EventStore.Core/Metrics/QueueBusyTracker.cs
index d8690ab882..efee926e4c 100644
--- a/src/EventStore.Core/Metrics/QueueBusyTracker.cs
+++ b/src/EventStore.Core/Metrics/QueueBusyTracker.cs
@@ -12,7 +12,7 @@ public class QueueBusyTracker : IQueueBusyTracker
 {
 	private readonly Stopwatch _stopwatch = new();
 
-	public QueueBusyTracker(AverageMetric metric, string label)
+	public QueueBusyTracker(SummedCounterMetric metric, string label)
 	{
 		metric.Register(label, () => _stopwatch.Elapsed.TotalSeconds);
 	}
diff --git a/src/EventStore.Core/Metrics/QueueLengthTracker.cs b/src/EventStore.Core/Metrics/QueueLengthTracker.cs
index 02cb1d39f9..3df5d325ad 100644
--- a/src/EventStore.Core/Metrics/QueueLengthTracker.cs
+++ b/src/EventStore.Core/Metrics/QueueLengthTracker.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
 using System.Threading;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics;
 
@@ -17,7 +18,7 @@ public class QueueLengthTracker : IQueueLengthTracker
 
 	public QueueLengthTracker(ObservableUpDownMetric<int> metric, string queueName)
 	{
-		_tags = [new("queue", queueName)];
+		_tags = [new(TrogonAttributeNames.QueueName, queueName)];
 		metric.Register(() => new Measurement<int>(Volatile.Read(ref _length), _tags.AsSpan()));
 	}
 
diff --git a/src/EventStore.Core/Metrics/QueueProcessingTracker.cs b/src/EventStore.Core/Metrics/QueueProcessingTracker.cs
index fd72748ef5..e333e72520 100644
--- a/src/EventStore.Core/Metrics/QueueProcessingTracker.cs
+++ b/src/EventStore.Core/Metrics/QueueProcessingTracker.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using EventStore.Core.Time;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics;
 
@@ -14,8 +15,8 @@ public Instant RecordNow(Instant start, string messageType)
 	{
 		return metric.Record(
 			start: start,
-			new KeyValuePair<string, object>("queue", queueName),
-			new KeyValuePair<string, object>("message-type", messageType));
+			new KeyValuePair<string, object>(TrogonAttributeNames.QueueName, queueName),
+			new KeyValuePair<string, object>(TrogonAttributeNames.QueueMessageType, messageType));
 	}
 
 	public class NoOp : IQueueProcessingTracker
diff --git a/src/EventStore.Core/Metrics/StatusMetric.cs b/src/EventStore.Core/Metrics/StatusMetric.cs
index 0ad00433d9..e9ad2ea9e4 100644
--- a/src/EventStore.Core/Metrics/StatusMetric.cs
+++ b/src/EventStore.Core/Metrics/StatusMetric.cs
@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
-using EventStore.Core.Time;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics
 {
@@ -9,15 +9,15 @@ namespace EventStore.Core.Metrics
 	public class StatusMetric
 	{
 		private readonly List<StatusSubMetric> _subMetrics = new();
-		private readonly IClock _clock;
 
-		public StatusMetric(Meter meter, string name, IClock clock = null)
+		public StatusMetric(Meter meter, MetricDefinition definition)
 		{
-			_clock = clock ?? Clock.Instance;
-
-			// The submetrics only go up, so we use a counter
-			// Observable because the value is the current time in seconds
-			meter.CreateObservableCounter(name, Observe);
+			definition.EnsureInstrumentKind(MetricInstrumentKind.UpDownCounter);
+			meter.CreateObservableUpDownCounter(
+				definition.Name,
+				Observe,
+				definition.Unit,
+				definition.Description);
 		}
 
 		public void Add(StatusSubMetric subMetric)
@@ -30,12 +30,14 @@ public void Add(StatusSubMetric subMetric)
 
 		private IEnumerable<Measurement<long>> Observe()
 		{
-			var secondsSinceEpoch = _clock.SecondsSinceEpoch;
 			lock (_subMetrics)
 			{
 				foreach (var instance in _subMetrics)
 				{
-					yield return instance.Observe(secondsSinceEpoch);
+					foreach (var measurement in instance.Observe())
+					{
+						yield return measurement;
+					}
 				}
 			}
 		}
diff --git a/src/EventStore.Core/Metrics/StatusSubMetric.cs b/src/EventStore.Core/Metrics/StatusSubMetric.cs
index 2df3eadbed..0a1fc38305 100644
--- a/src/EventStore.Core/Metrics/StatusSubMetric.cs
+++ b/src/EventStore.Core/Metrics/StatusSubMetric.cs
@@ -1,45 +1,76 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
-using System.Threading;
+using System.Linq;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.Metrics
 {
 	// Use this class if the status can transition from one to another, as in a state machine
 	// Use ActivityStatusMetric if the status represents an activity that starts and stops
 	//
-	// This does create a time series for each name * status that gets instantiated.
-	// However, prometheus does efficiently store series whose values are not changing.
+	// A closed state set keeps one-hot aggregation complete without unbounded cardinality.
 	//
 	// The component name and status are stored in tags
-	// The value contains time in seconds since epoch so we can tell which status is active
-	//
 	// Multiple threads can SetStatus and Observe concurrently
 	public class StatusSubMetric
 	{
-		private readonly KeyValuePair<string, object>[] _tags;
+		private readonly object _lock = new();
+		private readonly string _componentName;
+		private readonly string[] _statuses;
 		private string _status;
 
-		public StatusSubMetric(string componentName, object initialStatus, StatusMetric metric)
+		public StatusSubMetric(
+			string componentName,
+			object initialStatus,
+			StatusMetric metric,
+			IEnumerable<string> statuses)
 		{
-			_status = initialStatus?.ToString();
-			_tags = new[] {
-				new KeyValuePair<string, object>("name", componentName),
-				new KeyValuePair<string, object>("status", _status),
-			};
+			ArgumentNullException.ThrowIfNull(componentName);
+			ArgumentNullException.ThrowIfNull(metric);
+			ArgumentNullException.ThrowIfNull(statuses);
+			_componentName = componentName.ToLowerInvariant();
+			_statuses = new HashSet<string>(
+				statuses.Select(NormalizeStatus).Append("unknown"),
+				StringComparer.Ordinal).ToArray();
+			_status = ResolveStatus(initialStatus?.ToString());
 
 			metric.Add(this);
 		}
 
 		public void SetStatus(string status)
 		{
-			Interlocked.Exchange(ref _status, status);
+			lock (_lock)
+			{
+				_status = ResolveStatus(status);
+			}
+		}
+
+		public Measurement<long>[] Observe()
+		{
+			lock (_lock)
+			{
+				var measurements = new Measurement<long>[_statuses.Length];
+				var index = 0;
+				foreach (var status in _statuses)
+				{
+					measurements[index++] = new(
+						status == _status ? 1 : 0,
+						new KeyValuePair<string, object>(TrogonAttributeNames.ComponentName, _componentName),
+						new KeyValuePair<string, object>(TrogonAttributeNames.ComponentStatus, status));
+				}
+
+				return measurements;
+			}
 		}
 
-		public Measurement<long> Observe(long secondsSinceEpoch)
+		private string ResolveStatus(string status)
 		{
-			_tags[1] = new KeyValuePair<string, object>("status", _status);
-			return new Measurement<long>(secondsSinceEpoch, _tags.AsSpan());
+			var normalized = NormalizeStatus(status);
+			return Array.IndexOf(_statuses, normalized) >= 0 ? normalized : "unknown";
 		}
+
+		private static string NormalizeStatus(string status) =>
+			string.IsNullOrWhiteSpace(status) ? "unknown" : status.ToLowerInvariant();
 	}
 }
diff --git a/src/EventStore.Core/Metrics/SummedCounterMetric.cs b/src/EventStore.Core/Metrics/SummedCounterMetric.cs
new file mode 100644
index 0000000000..21d8fa5320
--- /dev/null
+++ b/src/EventStore.Core/Metrics/SummedCounterMetric.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.Metrics;
+using TrogonEventStore.SemanticConventions;
+using Tag = System.Collections.Generic.KeyValuePair<string, object>;
+
+namespace EventStore.Core.Metrics;
+
+public class SummedCounterMetric
+{
+	private readonly object _lock = new();
+	private readonly Func<string, Tag> _genTag;
+	private readonly Dictionary<string, (List<Func<double>>, Tag[])> _subMetricGroups = new();
+
+	public SummedCounterMetric(Meter meter, MetricDefinition definition, Func<string, Tag> genTag)
+	{
+		definition.EnsureInstrumentKind(MetricInstrumentKind.Counter);
+		_genTag = genTag;
+		meter.CreateObservableCounter(
+			definition.Name,
+			Observe,
+			definition.Unit,
+			definition.Description);
+	}
+
+	public void Register(string group, Func<double> subMetric)
+	{
+		lock (_lock)
+		{
+			if (_subMetricGroups.TryGetValue(group, out var pair))
+			{
+				pair.Item1.Add(subMetric);
+			}
+			else
+			{
+				var tags = new[] { _genTag(group) };
+				_subMetricGroups[group] = (new() { subMetric }, tags);
+			}
+		}
+	}
+
+	private IEnumerable<Measurement<double>> Observe()
+	{
+		lock (_lock)
+		{
+			foreach (var (groupFuncs, groupTags) in _subMetricGroups.Values)
+			{
+				var total = 0d;
+				foreach (var observe in groupFuncs)
+				{
+					total += observe();
+				}
+
+				yield return new(total, groupTags);
+			}
+		}
+	}
+}
diff --git a/src/EventStore.Core/Metrics/SystemMetrics.cs b/src/EventStore.Core/Metrics/SystemMetrics.cs
index 46f3618c0c..b04c3d23cf 100644
--- a/src/EventStore.Core/Metrics/SystemMetrics.cs
+++ b/src/EventStore.Core/Metrics/SystemMetrics.cs
@@ -6,80 +6,156 @@
 using System.Diagnostics.Metrics;
 using System.Runtime;
 using EventStore.Core.Util;
+using TrogonEventStore.SemanticConventions;
+
 using static EventStore.Common.Configuration.MetricsConfiguration;
 
 namespace EventStore.Core.Metrics;
 
-public class SystemMetrics(Meter meter, TimeSpan timeout, Dictionary<SystemTracker, bool> config)
+public class SystemMetrics
 {
-	public void CreateLoadAverageMetric(string metricName, Dictionary<SystemTracker, string> dimNames)
+	private readonly Meter _meter;
+	private readonly TimeSpan _timeout;
+	private readonly Dictionary<SystemTracker, bool> _config;
+
+	public SystemMetrics(Meter meter, TimeSpan timeout, Dictionary<SystemTracker, bool> config)
+	{
+		_meter = meter;
+		_timeout = timeout;
+		_config = config;
+	}
+
+	public void CreateLoadAverageMetric()
 	{
 		if (RuntimeInformation.IsWindows)
 		{
 			return;
 		}
 
-		var dims = new Dimensions<SystemTracker, double>(config, dimNames, tag => new("period", tag));
-
-		var getLoadAverages = Functions.Debounce(RuntimeStats.GetCpuLoadAverages, timeout);
-		dims.Register(SystemTracker.LoadAverage1m, () => getLoadAverages().OneMinute);
-		dims.Register(SystemTracker.LoadAverage5m, () => getLoadAverages().FiveMinutes);
-		dims.Register(SystemTracker.LoadAverage15m, () => getLoadAverages().FifteenMinutes);
-
-		if (dims.AnyRegistered())
+		var oneMinuteEnabled = IsEnabled(SystemTracker.LoadAverage1m);
+		var fiveMinutesEnabled = IsEnabled(SystemTracker.LoadAverage5m);
+		var fifteenMinutesEnabled = IsEnabled(SystemTracker.LoadAverage15m);
+		if (!oneMinuteEnabled && !fiveMinutesEnabled && !fifteenMinutesEnabled)
 		{
-			meter.CreateObservableGauge(metricName, dims.GenObserve());
+			return;
 		}
+
+		var getLoadAverages = Functions.Debounce(RuntimeStats.GetCpuLoadAverages, _timeout);
+		CreateObservableGauge(
+			MetricDefinitions.TrogonEventstoreSystemLoadAverage,
+			() => ObserveLoadAverage(
+				getLoadAverages(),
+				oneMinuteEnabled,
+				fiveMinutesEnabled,
+				fifteenMinutesEnabled));
 	}
 
-	public void CreateCpuMetric(string name)
+	public void CreateFileSystemMetrics(string dbPath)
 	{
-		if (!config.TryGetValue(SystemTracker.Cpu, out var enabled) || !enabled)
+		var usageEnabled = IsEnabled(SystemTracker.DriveUsedBytes);
+		var limitEnabled = IsEnabled(SystemTracker.DriveTotalBytes);
+		if (!usageEnabled && !limitEnabled)
 		{
 			return;
 		}
 
-		meter.CreateObservableUpDownCounter(name, RuntimeStats.GetCpuUsage);
+		var getDriveInfo = Functions.Debounce(() => DriveStats.GetDriveInfo(dbPath), _timeout);
+		if (usageEnabled)
+		{
+			CreateObservableUpDownCounter(
+				OpenTelemetryMetricDefinitions.SystemFilesystemUsage,
+				() => ObserveFileSystemUsage(getDriveInfo()));
+		}
+
+		if (limitEnabled)
+		{
+			CreateObservableUpDownCounter(
+				OpenTelemetryMetricDefinitions.SystemFilesystemLimit,
+				() => ObserveFileSystemLimit(getDriveInfo()));
+		}
 	}
 
-	public void CreateMemoryMetric(string metricName, Dictionary<SystemTracker, string> dimNames)
+	private static IEnumerable<Measurement<double>> ObserveLoadAverage(
+		(double OneMinute, double FiveMinutes, double FifteenMinutes) loadAverage,
+		bool oneMinuteEnabled,
+		bool fiveMinutesEnabled,
+		bool fifteenMinutesEnabled)
 	{
-		var dims = new Dimensions<SystemTracker, long>(config, dimNames, tag => new("kind", tag));
+		if (oneMinuteEnabled)
+		{
+			yield return new(
+				loadAverage.OneMinute,
+				new KeyValuePair<string, object?>(TrogonAttributeNames.SystemLoadAveragePeriod, "1m"));
+		}
 
-		dims.Register(SystemTracker.FreeMem, RuntimeStats.GetFreeMemory);
-		dims.Register(SystemTracker.TotalMem, RuntimeStats.GetTotalMemory);
+		if (fiveMinutesEnabled)
+		{
+			yield return new(
+				loadAverage.FiveMinutes,
+				new KeyValuePair<string, object?>(TrogonAttributeNames.SystemLoadAveragePeriod, "5m"));
+		}
 
-		if (dims.AnyRegistered())
+		if (fifteenMinutesEnabled)
 		{
-			meter.CreateObservableGauge($"{metricName}-bytes", dims.GenObserve());
+			yield return new(
+				loadAverage.FifteenMinutes,
+				new KeyValuePair<string, object?>(TrogonAttributeNames.SystemLoadAveragePeriod, "15m"));
 		}
 	}
 
-	public void CreateDiskMetric(string metricName, string dbPath, Dictionary<SystemTracker, string> dimNames)
+	private static IEnumerable<Measurement<long>> ObserveFileSystemUsage(DriveData drive)
 	{
-		var dims = new Dimensions<SystemTracker, long>(config, dimNames, tag => new());
+		yield return new(
+			drive.UsedBytes,
+			new KeyValuePair<string, object?>(AttributeNames.SystemFilesystemState, "used"),
+			new KeyValuePair<string, object?>(AttributeNames.SystemFilesystemMountpoint, drive.DiskName));
+		yield return new(
+			drive.AvailableBytes,
+			new KeyValuePair<string, object?>(AttributeNames.SystemFilesystemState, "free"),
+			new KeyValuePair<string, object?>(AttributeNames.SystemFilesystemMountpoint, drive.DiskName));
+	}
 
-		var getDriveInfo = Functions.Debounce(() => DriveStats.GetDriveInfo(dbPath), timeout);
+	private static IEnumerable<Measurement<long>> ObserveFileSystemLimit(DriveData drive)
+	{
+		yield return new(
+			drive.TotalBytes,
+			new KeyValuePair<string, object?>(AttributeNames.SystemFilesystemMountpoint, drive.DiskName));
+	}
 
-		dims.Register(SystemTracker.DriveUsedBytes, GenMeasure(info => info.UsedBytes));
-		dims.Register(SystemTracker.DriveTotalBytes, GenMeasure(info => info.TotalBytes));
+	private void CreateObservableGauge(
+		MetricDefinition definition,
+		Func<IEnumerable<Measurement<double>>> observe)
+	{
+		EnsureKind(definition, MetricInstrumentKind.Gauge);
+		_meter.CreateObservableGauge(
+			definition.Name,
+			observe,
+			definition.Unit,
+			definition.Description);
+	}
 
-		if (dims.AnyRegistered())
-		{
-			meter.CreateObservableGauge($"{metricName}-bytes", dims.GenObserve());
-		}
+	private void CreateObservableUpDownCounter(
+		MetricDefinition definition,
+		Func<IEnumerable<Measurement<long>>> observe)
+	{
+		EnsureKind(definition, MetricInstrumentKind.UpDownCounter);
+		_meter.CreateObservableUpDownCounter(
+			definition.Name,
+			observe,
+			definition.Unit,
+			definition.Description);
+	}
 
-		return;
+	private bool IsEnabled(SystemTracker tracker) =>
+		_config.TryGetValue(tracker, out var enabled) && enabled;
 
-		Func<string, Measurement<long>> GenMeasure(Func<DriveData, long> func) => tag =>
+	private static void EnsureKind(MetricDefinition definition, MetricInstrumentKind expected)
+	{
+		if (definition.InstrumentKind != expected)
 		{
-			var info = getDriveInfo();
-
-			return new(
-				func(info),
-				new("kind", tag),
-				new("disk", info.DiskName)
-			);
-		};
+			throw new ArgumentException(
+				$"Metric '{definition.Name}' requires a {expected} instrument.",
+				nameof(definition));
+		}
 	}
 }
diff --git a/src/EventStore.Core/MetricsBootstrapper.cs b/src/EventStore.Core/MetricsBootstrapper.cs
index 50527f6f06..3eba419d01 100644
--- a/src/EventStore.Core/MetricsBootstrapper.cs
+++ b/src/EventStore.Core/MetricsBootstrapper.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.Metrics;
 using System.Linq;
 using EventStore.Core.Bus;
 using EventStore.Core.Diagnostics;
@@ -10,6 +11,7 @@
 using EventStore.Core.TransactionLog.Checkpoint;
 using EventStore.Core.TransactionLog.Chunks;
 using EventStore.Core.TransactionLog.Scavenging;
+using TrogonEventStore.SemanticConventions;
 using Conf = EventStore.Common.Configuration.MetricsConfiguration;
 
 namespace EventStore.Core;
@@ -66,8 +68,6 @@ public class GossipTrackers
 
 public static class MetricsBootstrapper
 {
-	public const string LogicalChunkReadDistributionName = "eventstore-logical-chunk-read-distribution";
-
 	public static void Bootstrap(
 		Conf conf,
 		TFChunkDbConfig dbConfig,
@@ -85,18 +85,23 @@ public static void Bootstrap(
 		}
 
 		var coreMeter = TelemetryMeterFactory.Create(TelemetryMeterInstrumentation.CoreName);
-		var statusMetric = new StatusMetric(coreMeter, "eventstore-statuses");
-		var grpcMethodMetric = new DurationMetric(coreMeter, "eventstore-grpc-method-duration");
-		var gossipLatencyMetric = new DurationMetric(coreMeter, "eventstore-gossip-latency");
-		var gossipProcessingMetric = new DurationMetric(coreMeter, "eventstore-gossip-processing-duration");
-		var queueQueueingDurationMaxMetric = new DurationMaxMetric(coreMeter, "eventstore-queue-queueing-duration-max");
-		var queueProcessingDurationMetric = new DurationMetric(coreMeter, "eventstore-queue-processing-duration");
-		var queueBusyMetric = new AverageMetric(coreMeter, "eventstore-queue-busy", "seconds", label => new("queue", label));
-		var queueLengthMetric = new ObservableUpDownMetric<int>(coreMeter, "eventstore-queue-length", "items");
-		var byteMetric = new CounterMetric(coreMeter, "eventstore-io", unit: "bytes");
-		var eventMetric = new CounterMetric(coreMeter, "eventstore-io", unit: "events");
-		var recordReadDurationMetric = new DurationMetric(coreMeter, "eventstore-io-record-read-duration");
-		var electionsCounterMetric = new CounterMetric(coreMeter, "eventstore-elections-count", unit: "");
+		var statusMetric = new StatusMetric(coreMeter, MetricDefinitions.TrogonEventstoreComponentStatus);
+		var grpcMethodMetric = new DurationMetric(coreMeter, MetricDefinitions.TrogonEventstoreGrpcServerCallDuration);
+		var gossipLatencyMetric = new DurationMetric(coreMeter, MetricDefinitions.TrogonEventstoreGossipExchangeDuration);
+		var gossipProcessingMetric = new DurationMetric(coreMeter, MetricDefinitions.TrogonEventstoreGossipMessageProcessingDuration);
+		var queueQueueingDurationMaxMetric = new DurationMaxMetric(coreMeter, MetricDefinitions.TrogonEventstoreQueueMessageWaitDurationMax);
+		var queueProcessingDurationMetric = new DurationMetric(coreMeter, MetricDefinitions.TrogonEventstoreQueueMessageProcessingDuration);
+		var queueBusyMetric = new SummedCounterMetric(
+			coreMeter,
+			MetricDefinitions.TrogonEventstoreQueueBusyTime,
+			label => new(TrogonAttributeNames.QueueName, label));
+		var queueLengthMetric = new ObservableUpDownMetric<int>(
+			coreMeter,
+			MetricDefinitions.TrogonEventstoreQueueMessageCount);
+		var byteMetric = new CounterMetric(coreMeter, MetricDefinitions.TrogonEventstoreStorageIo);
+		var eventMetric = new CounterMetric(coreMeter, MetricDefinitions.TrogonEventstoreStorageEventCount);
+		var recordReadDurationMetric = new DurationMetric(coreMeter, MetricDefinitions.TrogonEventstoreStorageRecordReadDuration);
+		var electionsCounterMetric = new CounterMetric(coreMeter, MetricDefinitions.TrogonEventstoreClusterElectionCount);
 
 		// incoming grpc calls
 		var enabledCalls = conf.IncomingGrpcCalls.Where(kvp => kvp.Value).Select(kvp => kvp.Key).ToArray();
@@ -104,8 +109,11 @@ public static void Bootstrap(
 		{
 			_ = new IncomingGrpcCallsMetric(
 				coreMeter,
-				"eventstore-current-incoming-grpc-calls",
-				"eventstore-incoming-grpc-calls",
+				MetricDefinitions.TrogonEventstoreGrpcServerCallActive,
+				MetricDefinitions.TrogonEventstoreGrpcServerCallCount,
+				MetricDefinitions.TrogonEventstoreGrpcServerCallFailureCount,
+				MetricDefinitions.TrogonEventstoreGrpcServerCallUnimplementedCount,
+				MetricDefinitions.TrogonEventstoreGrpcServerCallDeadlineExceededCount,
 				enabledCalls);
 		}
 
@@ -113,7 +121,11 @@ public static void Bootstrap(
 		var enabledCacheHitsMisses = conf.CacheHitsMisses.Where(kvp => kvp.Value).Select(kvp => kvp.Key).ToArray();
 		if (enabledCacheHitsMisses.Length > 0)
 		{
-			var metric = new CacheHitsMissesMetric(coreMeter, enabledCacheHitsMisses, "eventstore-cache-hits-misses", new() {
+			var metric = new CacheHitsMissesMetric(
+				coreMeter,
+				enabledCacheHitsMisses,
+				MetricDefinitions.TrogonEventstoreCacheOperationCount,
+				new() {
 				{ Conf.Cache.StreamInfo, "stream-info" },
 				{ Conf.Cache.Chunk, "chunk" },
 			});
@@ -123,7 +135,10 @@ public static void Bootstrap(
 		// dynamic cache resources
 		if (conf.CacheResources)
 		{
-			var metrics = new CacheResourcesMetrics(coreMeter, "eventstore-cache-resources");
+			var metrics = new CacheResourcesMetrics(
+				coreMeter,
+				MetricDefinitions.TrogonEventstoreCacheResourceSize,
+				MetricDefinitions.TrogonEventstoreCacheResourceCount);
 			trackers.CacheResourcesTracker = new CacheResourcesTracker(metrics);
 		}
 
@@ -136,11 +151,11 @@ public static void Bootstrap(
 		// events
 		if (conf.Events.TryGetValue(Conf.EventTracker.Read, out var readEnabled) && readEnabled)
 		{
-			var readTag = new KeyValuePair<string, object>("activity", "read");
+			var readTag = new KeyValuePair<string, object>(TrogonAttributeNames.StorageActivity, "read");
 			trackers.TransactionFileTracker = new TFChunkTracker(
 				readDistribution: new LogicalChunkReadDistributionMetric(
 					meter: coreMeter,
-					name: LogicalChunkReadDistributionName,
+					definition: MetricDefinitions.TrogonEventstoreStorageChunkReadDistance,
 					writer: dbConfig.WriterCheckpoint,
 					chunkSize: dbConfig.ChunkSize),
 				readDurationMetric: recordReadDurationMetric,
@@ -153,7 +168,7 @@ public static void Bootstrap(
 		{
 			trackers.IndexTracker = new IndexTracker(new CounterSubMetric(
 				eventMetric,
-				new[] { new KeyValuePair<string, object>("activity", "written") }));
+				new[] { new KeyValuePair<string, object>(TrogonAttributeNames.StorageActivity, "write") }));
 		}
 
 		// gossip
@@ -191,25 +206,34 @@ public static void Bootstrap(
 			var tracker = new PersistentSubscriptionTracker();
 			trackers.PersistentSubscriptionTracker = tracker;
 
-			coreMeter.CreateObservableUpDownCounter("eventstore-persistent-sub-connections", tracker.ObserveConnectionsCount);
-			coreMeter.CreateObservableUpDownCounter("eventstore-persistent-sub-parked-messages", tracker.ObserveParkedMessages);
-			coreMeter.CreateObservableUpDownCounter("eventstore-persistent-sub-in-flight-messages", tracker.ObserveInFlightMessages);
-			coreMeter.CreateObservableUpDownCounter("eventstore-persistent-sub-oldest-parked-message-seconds", tracker.ObserveOldestParkedMessage);
-
-			coreMeter.CreateObservableCounter("eventstore-persistent-sub-park-message-requests", tracker.ObserveParkMessageRequests);
-			coreMeter.CreateObservableCounter("eventstore-persistent-sub-parked-message-replays", tracker.ObserveParkedMessageReplays);
-			coreMeter.CreateObservableCounter("eventstore-persistent-sub-parked-message-truncates", tracker.ObserveParkedMessageTruncates);
-			coreMeter.CreateObservableCounter("eventstore-persistent-sub-items-processed", tracker.ObserveItemsProcessed);
-			coreMeter.CreateObservableCounter("eventstore-persistent-sub-last-known-event-number", tracker.ObserveLastKnownEvent);
-			coreMeter.CreateObservableCounter("eventstore-persistent-sub-last-known-event-commit-position", tracker.ObserveLastKnownEventCommitPosition);
-			coreMeter.CreateObservableCounter("eventstore-persistent-sub-checkpointed-event-number", tracker.ObserveLastCheckpointedEvent);
-			coreMeter.CreateObservableCounter("eventstore-persistent-sub-checkpointed-event-commit-position", tracker.ObserveLastCheckpointedEventCommitPosition);
+			CreateObservableUpDownCounter(MetricDefinitions.TrogonEventstorePersistentSubscriptionConnectionCount, tracker.ObserveConnectionsCount);
+			CreateObservableUpDownCounter(MetricDefinitions.TrogonEventstorePersistentSubscriptionParkedMessageCount, tracker.ObserveParkedMessages);
+			CreateObservableUpDownCounter(MetricDefinitions.TrogonEventstorePersistentSubscriptionInFlightMessageCount, tracker.ObserveInFlightMessages);
+			CreateObservableGauge(MetricDefinitions.TrogonEventstorePersistentSubscriptionOldestParkedMessageAge, tracker.ObserveOldestParkedMessage);
+
+			CreateObservableCounter(MetricDefinitions.TrogonEventstorePersistentSubscriptionParkRequestCount, tracker.ObserveParkMessageRequests);
+			CreateObservableCounter(MetricDefinitions.TrogonEventstorePersistentSubscriptionParkedMessageReplayCount, tracker.ObserveParkedMessageReplays);
+			CreateObservableCounter(MetricDefinitions.TrogonEventstorePersistentSubscriptionParkedMessageTruncateCount, tracker.ObserveParkedMessageTruncates);
+			CreateObservableCounter(MetricDefinitions.TrogonEventstorePersistentSubscriptionItemProcessedCount, tracker.ObserveItemsProcessed);
+			CreateObservableGauge(MetricDefinitions.TrogonEventstorePersistentSubscriptionLastKnownEventRevision, tracker.ObserveLastKnownEvent);
+			CreateObservableGauge(MetricDefinitions.TrogonEventstorePersistentSubscriptionLastKnownCommitPosition, tracker.ObserveLastKnownEventCommitPosition);
+			CreateObservableGauge(MetricDefinitions.TrogonEventstorePersistentSubscriptionCheckpointEventRevision, tracker.ObserveLastCheckpointedEvent);
+			CreateObservableGauge(MetricDefinitions.TrogonEventstorePersistentSubscriptionCheckpointCommitPosition, tracker.ObserveLastCheckpointedEventCommitPosition);
+
+			void CreateObservableCounter(MetricDefinition definition, Func<IEnumerable<Measurement<long>>> observe) =>
+				coreMeter.CreateObservableCounter(definition.Name, observe, definition.Unit, definition.Description);
+
+			void CreateObservableGauge(MetricDefinition definition, Func<IEnumerable<Measurement<long>>> observe) =>
+				coreMeter.CreateObservableGauge(definition.Name, observe, definition.Unit, definition.Description);
+
+			void CreateObservableUpDownCounter(MetricDefinition definition, Func<IEnumerable<Measurement<long>>> observe) =>
+				coreMeter.CreateObservableUpDownCounter(definition.Name, observe, definition.Unit, definition.Description);
 		}
 
 		// checkpoints
 		_ = new CheckpointMetric(
 			coreMeter,
-			"eventstore-checkpoints",
+			MetricDefinitions.TrogonEventstoreCheckpointPosition,
 			conf.Checkpoints.Where(x => x.Value).Select(x => x.Key switch
 			{
 				Conf.Checkpoint.Chaser => dbConfig.ChaserCheckpoint,
@@ -260,7 +284,7 @@ public static void Bootstrap(
 		{
 			if (conf.Writer.TryGetValue(Conf.WriterTracker.FlushSize, out var flushSizeEnabled) && flushSizeEnabled)
 			{
-				var maxMetric = new MaxMetric<long>(coreMeter, "eventstore-writer-flush-size-max");
+				var maxMetric = new MaxMetric<long>(coreMeter, MetricDefinitions.TrogonEventstoreWriterFlushSizeMax);
 				trackers.WriterFlushSizeTracker = new MaxTracker<long>(
 					metric: maxMetric,
 					name: null,
@@ -269,7 +293,7 @@ public static void Bootstrap(
 
 			if (conf.Writer.TryGetValue(Conf.WriterTracker.FlushDuration, out var flushDurationEnabled) && flushDurationEnabled)
 			{
-				var maxDurationmetric = new DurationMaxMetric(coreMeter, "eventstore-writer-flush-duration-max");
+				var maxDurationmetric = new DurationMaxMetric(coreMeter, MetricDefinitions.TrogonEventstoreWriterFlushDurationMax);
 				trackers.WriterFlushDurationTracker = new DurationMaxTracker(
 					maxDurationmetric,
 					name: null,
@@ -309,77 +333,17 @@ public static void Bootstrap(
 			queueingDurationFactory,
 			processingFactory);
 
-		// kestrel
-		if (conf.Kestrel.TryGetValue(Conf.KestrelTracker.ConnectionCount, out var kestrelConnections) && kestrelConnections)
-		{
-			_ = new ConnectionMetric(coreMeter, "eventstore-kestrel-connections");
-		}
-
 		var timeout = TimeSpan.FromSeconds(1);
 
 		// system
 		var systemMetrics = new SystemMetrics(coreMeter, timeout, conf.System);
-		systemMetrics.CreateLoadAverageMetric("eventstore-sys-load-avg", new() {
-			{ Conf.SystemTracker.LoadAverage1m, "1m" },
-			{ Conf.SystemTracker.LoadAverage5m, "5m" },
-			{ Conf.SystemTracker.LoadAverage15m, "15m" },
-		});
-
-		systemMetrics.CreateCpuMetric("eventstore-sys-cpu");
-
-		systemMetrics.CreateMemoryMetric("eventstore-sys-mem", new() {
-			{ Conf.SystemTracker.FreeMem, "free" },
-			{ Conf.SystemTracker.TotalMem, "total" },
-		});
-
-		systemMetrics.CreateDiskMetric("eventstore-sys-disk", dbConfig.Path, new() {
-			{ Conf.SystemTracker.DriveTotalBytes, "total" },
-			{ Conf.SystemTracker.DriveUsedBytes, "used" },
-		});
+		systemMetrics.CreateLoadAverageMetric();
+		systemMetrics.CreateFileSystemMetrics(dbConfig.Path);
 
 		// process
-		var processMetrics = new ProcessMetrics(coreMeter, timeout, conf.ExpectedScrapeIntervalSeconds, conf.Process);
-		processMetrics.CreateObservableMetrics(new() {
-			{ Conf.ProcessTracker.UpTime, "eventstore-proc-up-time" },
-			{ Conf.ProcessTracker.Cpu, "eventstore-proc-cpu" },
-			{ Conf.ProcessTracker.ThreadCount, "eventstore-proc-thread-count" },
-			{ Conf.ProcessTracker.ThreadPoolPendingWorkItemCount, "eventstore-proc-thread-pool-pending-work-item-count" },
-			{ Conf.ProcessTracker.LockContentionCount, "eventstore-proc-contention-count" },
-			{ Conf.ProcessTracker.ExceptionCount, "eventstore-proc-exception-count" },
-			{ Conf.ProcessTracker.TimeInGc, "eventstore-gc-time-in-gc" },
-			{ Conf.ProcessTracker.HeapSize, "eventstore-gc-heap-size" },
-			{ Conf.ProcessTracker.HeapFragmentation, "eventstore-gc-heap-fragmentation" },
-			{ Conf.ProcessTracker.TotalAllocatedBytes, "eventstore-gc-total-allocated" },
-			{ Conf.ProcessTracker.GcPauseDuration, "eventstore-gc-pause-duration-max" },
-		});
-
-		processMetrics.CreateMemoryMetric("eventstore-proc-mem", new() {
-			{ Conf.ProcessTracker.MemWorkingSet, "working-set" },
-			{ Conf.ProcessTracker.MemPagedBytes, "paged-bytes" },
-			{ Conf.ProcessTracker.MemVirtualBytes, "virtual-bytes" },
-		});
-
-		processMetrics.CreateGcGenerationSizeMetric("eventstore-gc-generation-size", new() {
-			{ Conf.ProcessTracker.Gen0Size, "gen0" },
-			{ Conf.ProcessTracker.Gen1Size, "gen1" },
-			{ Conf.ProcessTracker.Gen2Size, "gen2" },
-			{ Conf.ProcessTracker.LohSize, "loh" },
-		});
-
-		processMetrics.CreateGcCollectionCountMetric("eventstore-gc-collection-count", new() {
-			{ Conf.ProcessTracker.Gen0CollectionCount, "gen0" },
-			{ Conf.ProcessTracker.Gen1CollectionCount, "gen1" },
-			{ Conf.ProcessTracker.Gen2CollectionCount, "gen2" },
-		});
-
-		processMetrics.CreateDiskBytesMetric("eventstore-disk-io", new() {
-			{ Conf.ProcessTracker.DiskReadBytes, "read" },
-			{ Conf.ProcessTracker.DiskWrittenBytes, "written" },
-		});
-
-		processMetrics.CreateDiskOpsMetric("eventstore-disk-io", new() {
-			{ Conf.ProcessTracker.DiskReadOps, "read" },
-			{ Conf.ProcessTracker.DiskWrittenOps, "written" },
-		});
+		var processMetrics = new ProcessMetrics(coreMeter, timeout, conf.Process);
+		processMetrics.CreateUptimeMetric();
+		processMetrics.CreateDiskIoMetric();
+		processMetrics.CreateDiskOperationMetric();
 	}
 }
diff --git a/src/EventStore.Core/Services/VNode/NodeStatusTracker.cs b/src/EventStore.Core/Services/VNode/NodeStatusTracker.cs
index b60ec74c99..103dd8f7a1 100644
--- a/src/EventStore.Core/Services/VNode/NodeStatusTracker.cs
+++ b/src/EventStore.Core/Services/VNode/NodeStatusTracker.cs
@@ -1,3 +1,5 @@
+using System;
+using System.Linq;
 using EventStore.Core.Data;
 using EventStore.Core.Metrics;
 
@@ -15,6 +17,13 @@ public interface INodeStatusTracker : IInaugurationStatusTracker
 
 	public class NodeStatusTracker : INodeStatusTracker
 	{
+		private static readonly string[] Statuses = Enum.GetValues<VNodeState>()
+			.Select(nodeState => nodeState.ToString())
+			.Concat(Enum.GetValues<InaugurationManager.ManagerState>()
+				.Where(inaugurationState => inaugurationState != InaugurationManager.ManagerState.Idle)
+				.Select(inaugurationState => $"{VNodeState.PreLeader} - {inaugurationState}"))
+			.ToArray();
+
 		private readonly StatusSubMetric _subMetric;
 		private readonly object _lock = new();
 
@@ -25,7 +34,7 @@ public NodeStatusTracker(StatusMetric metric)
 		{
 			_nodeState = VNodeState.Initializing;
 			_inaugurationState = InaugurationManager.ManagerState.Idle;
-			_subMetric = new StatusSubMetric("Node", _nodeState, metric);
+			_subMetric = new StatusSubMetric("Node", _nodeState, metric, Statuses);
 		}
 
 		public void OnStateChange(VNodeState newState)
diff --git a/src/EventStore.Core/TransactionLog/Checkpoint/CheckpointMetric.cs b/src/EventStore.Core/TransactionLog/Checkpoint/CheckpointMetric.cs
index fba7f82132..5443b2ce23 100644
--- a/src/EventStore.Core/TransactionLog/Checkpoint/CheckpointMetric.cs
+++ b/src/EventStore.Core/TransactionLog/Checkpoint/CheckpointMetric.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
+using EventStore.Core.Metrics;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.TransactionLog.Checkpoint
 {
@@ -12,8 +14,12 @@ public class CheckpointMetric
 		private readonly Measurement<long>[] _measurements;
 		private readonly KeyValuePair<string, object>[][] _tagss;
 
-		public CheckpointMetric(Meter meter, string name, params IReadOnlyCheckpoint[] checkpoints)
+		public CheckpointMetric(
+			Meter meter,
+			MetricDefinition definition,
+			params IReadOnlyCheckpoint[] checkpoints)
 		{
+			definition.EnsureInstrumentKind(MetricInstrumentKind.Gauge);
 			_checkpoints = checkpoints;
 			_measurements = new Measurement<long>[checkpoints.Length];
 			_tagss = new KeyValuePair<string, object>[checkpoints.Length][];
@@ -21,14 +27,16 @@ public CheckpointMetric(Meter meter, string name, params IReadOnlyCheckpoint[] c
 			for (var i = 0; i < checkpoints.Length; i++)
 			{
 				_tagss[i] = new KeyValuePair<string, object>[] {
-					new("name", checkpoints[i].Name),
-					new("read", "non-flushed"),
+					new(TrogonAttributeNames.CheckpointName, checkpoints[i].Name),
+					new(TrogonAttributeNames.CheckpointReadKind, "non_flushed"),
 				};
 			}
 
-			// we could consider using ObservableCounter, but ICheckpoint does allow the values to
-			// go down as well as up, so we are currently supporting that here.
-			meter.CreateObservableUpDownCounter(name, Observe);
+			meter.CreateObservableGauge(
+				definition.Name,
+				Observe,
+				definition.Unit,
+				definition.Description);
 		}
 
 		private IEnumerable<Measurement<long>> Observe()
diff --git a/src/EventStore.Core/TransactionLog/Chunks/TransactionFileTracker.cs b/src/EventStore.Core/TransactionLog/Chunks/TransactionFileTracker.cs
index 5d0ce06128..edf07dbf69 100644
--- a/src/EventStore.Core/TransactionLog/Chunks/TransactionFileTracker.cs
+++ b/src/EventStore.Core/TransactionLog/Chunks/TransactionFileTracker.cs
@@ -3,6 +3,7 @@
 using EventStore.Core.Metrics;
 using EventStore.Core.Time;
 using EventStore.Core.TransactionLog.LogRecords;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Core.TransactionLog.Chunks;
 
@@ -31,7 +32,12 @@ public void OnRead(Instant start, ILogRecord record, ITransactionFileTracker.Sou
 		_readDistribution.Record(record);
 		_readDurationMetric.Record(
 			start,
-			new KeyValuePair<string, object>("source", source));
+			new KeyValuePair<string, object>(TrogonAttributeNames.StorageSource, source switch
+			{
+				ITransactionFileTracker.Source.ChunkCache => "chunk_cache",
+				ITransactionFileTracker.Source.FileSystem => "file_system",
+				_ => "unknown",
+			}));
 
 		if (record is not PrepareLogRecord prepare)
 		{
diff --git a/src/EventStore.Core/TransactionLog/Scavenging/ScavengeStatusTracker.cs b/src/EventStore.Core/TransactionLog/Scavenging/ScavengeStatusTracker.cs
index 04be260de6..38c4ece430 100644
--- a/src/EventStore.Core/TransactionLog/Scavenging/ScavengeStatusTracker.cs
+++ b/src/EventStore.Core/TransactionLog/Scavenging/ScavengeStatusTracker.cs
@@ -14,7 +14,15 @@ public class ScavengeStatusTracker : IScavengeStatusTracker
 
 		public ScavengeStatusTracker(StatusMetric metric)
 		{
-			_subMetric = new("Scavenge", metric);
+			_subMetric = new(
+				"Scavenge",
+				metric,
+				"Accumulation Phase",
+				"Calculation Phase",
+				"Chunk execution Phase",
+				"Chunk merging Phase",
+				"Index execution Phase",
+				"Cleaning Phase");
 		}
 
 		public IDisposable StartActivity(string name) =>
diff --git a/src/EventStore.Projections.Core.XUnit.Tests/Metrics/ProjectionMetricsTests.cs b/src/EventStore.Projections.Core.XUnit.Tests/Metrics/ProjectionMetricsTests.cs
index 238e86e1aa..65755316b1 100644
--- a/src/EventStore.Projections.Core.XUnit.Tests/Metrics/ProjectionMetricsTests.cs
+++ b/src/EventStore.Projections.Core.XUnit.Tests/Metrics/ProjectionMetricsTests.cs
@@ -1,8 +1,12 @@
 using System.Collections.Generic;
 using System.Diagnostics.Metrics;
+using System.Reflection;
+using EventStore.Common.Options;
+using EventStore.Core.Diagnostics;
 using EventStore.Projections.Core.Metrics;
 using EventStore.Projections.Core.Services;
 using EventStore.Projections.Core.Services.Management;
+using TrogonEventStore.SemanticConventions;
 using Xunit;
 
 namespace EventStore.Projections.Core.XUnit.Tests.Metrics;
@@ -31,33 +35,31 @@ public void ObserveEventsProcessed()
 	{
 		var measurements = _sut.ObserveEventsProcessed();
 		var measurement = Assert.Single(measurements);
-		AssertMeasurement(50L, ("projection", "TestProjection"))(measurement);
+		AssertMeasurement(50L, (TrogonAttributeNames.ProjectionName, "TestProjection"))(measurement);
 	}
 
-	[Fact]
-	public void ObserveRunning()
-	{
-		var measurements = _sut.ObserveRunning();
-		var measurement = Assert.Single(measurements);
-		AssertMeasurement(1L, ("projection", "TestProjection"))(measurement);
-	}
-
-	[Fact]
-	public void ObserveRunningWithCompoundStatus()
+	[Theory]
+	[InlineData(-10, 0)]
+	[InlineData(0, 0)]
+	[InlineData(75, 0.75f)]
+	[InlineData(100, 1)]
+	[InlineData(150, 1)]
+	public void ObserveProgressAsFraction(float progress, float expected)
 	{
-		_sut.OnNewStats([ProjectionWithState(ManagedProjectionState.Running, "Running/Writing results")]);
+		_sut.OnNewStats([ProjectionWithProgress(progress)]);
 
-		var measurements = _sut.ObserveRunning();
+		var measurements = _sut.ObserveProgress();
 		var measurement = Assert.Single(measurements);
-		AssertMeasurement(1L, ("projection", "TestProjection"))(measurement);
+		AssertMeasurement(expected, (TrogonAttributeNames.ProjectionName, "TestProjection"))(measurement);
 	}
 
 	[Fact]
-	public void ObserveProgress()
+	public void ObserveProgressTreatsUnknownProgressAsZero()
 	{
-		var measurements = _sut.ObserveProgress();
-		var measurement = Assert.Single(measurements);
-		AssertMeasurement(0.75f, ("projection", "TestProjection"))(measurement);
+		_sut.OnNewStats([ProjectionWithProgress(float.NaN)]);
+
+		var measurement = Assert.Single(_sut.ObserveProgress());
+		Assert.Equal(0, measurement.Value);
 	}
 
 	[Fact]
@@ -65,9 +67,15 @@ public void ObserveStatus()
 	{
 		var measurements = _sut.ObserveStatus();
 		Assert.Collection(measurements,
-			AssertMeasurement(1L, ("projection", "TestProjection"), ("status", "Running")),
-			AssertMeasurement(0L, ("projection", "TestProjection"), ("status", "Faulted")),
-			AssertMeasurement(0L, ("projection", "TestProjection"), ("status", "Stopped")));
+			AssertMeasurement(1L,
+				(TrogonAttributeNames.ProjectionName, "TestProjection"),
+				(TrogonAttributeNames.ProjectionStatus, "running")),
+			AssertMeasurement(0L,
+				(TrogonAttributeNames.ProjectionName, "TestProjection"),
+				(TrogonAttributeNames.ProjectionStatus, "faulted")),
+			AssertMeasurement(0L,
+				(TrogonAttributeNames.ProjectionName, "TestProjection"),
+				(TrogonAttributeNames.ProjectionStatus, "stopped")));
 	}
 
 	[Theory]
@@ -81,9 +89,15 @@ public void ObserveStatusWithCompoundStatus(ManagedProjectionState state, string
 
 		var measurements = _sut.ObserveStatus();
 		Assert.Collection(measurements,
-			AssertMeasurement(running, ("projection", "TestProjection"), ("status", "Running")),
-			AssertMeasurement(faulted, ("projection", "TestProjection"), ("status", "Faulted")),
-			AssertMeasurement(stopped, ("projection", "TestProjection"), ("status", "Stopped")));
+			AssertMeasurement(running,
+				(TrogonAttributeNames.ProjectionName, "TestProjection"),
+				(TrogonAttributeNames.ProjectionStatus, "running")),
+			AssertMeasurement(faulted,
+				(TrogonAttributeNames.ProjectionName, "TestProjection"),
+				(TrogonAttributeNames.ProjectionStatus, "faulted")),
+			AssertMeasurement(stopped,
+				(TrogonAttributeNames.ProjectionName, "TestProjection"),
+				(TrogonAttributeNames.ProjectionStatus, "stopped")));
 	}
 
 	[Fact]
@@ -99,9 +113,8 @@ public void ObserveStateSizes()
 
 		var measurements = _sut.ObserveStateSize();
 
-		Assert.Collection(measurements,
-			AssertMeasurement(10, ("projection", "TestProjection")),
-			AssertMeasurement(12, ("projection", "TestProjection"), ("partition", "test-partition")));
+		var measurement = Assert.Single(measurements);
+		AssertMeasurement(22L, (TrogonAttributeNames.ProjectionName, "TestProjection"))(measurement);
 	}
 
 	[Fact]
@@ -112,6 +125,53 @@ public void ObserveStateSizesWithoutStateSizes()
 		Assert.Empty(measurements);
 	}
 
+	[Fact]
+	public void ProjectionInstrumentsMatchCanonicalDefinitions()
+	{
+		var instruments = new List<Instrument>();
+		using var listener = new MeterListener
+		{
+			InstrumentPublished = (instrument, _) =>
+			{
+				if (instrument.Meter.Name == TelemetryMeterInstrumentation.ProjectionsName)
+				{
+					instruments.Add(instrument);
+				}
+			},
+		};
+		listener.Start();
+
+		var subsystem = new ProjectionsSubsystem(new ProjectionSubsystemOptions(
+			1,
+			ProjectionType.None,
+			false,
+			TimeSpan.Zero,
+			false,
+			0,
+			0));
+		var configureMetrics = typeof(ProjectionsSubsystem).GetMethod(
+			"ConfigureProjectionMetrics",
+			BindingFlags.Instance | BindingFlags.NonPublic);
+		Assert.NotNull(configureMetrics);
+		configureMetrics.Invoke(subsystem, [true]);
+
+		AssertInstrument<ObservableCounter<long>>(
+			instruments,
+			MetricDefinitions.TrogonEventstoreProjectionEventProcessedCount);
+		AssertInstrument<ObservableGauge<float>>(
+			instruments,
+			MetricDefinitions.TrogonEventstoreProjectionProgress);
+		AssertInstrument<ObservableUpDownCounter<long>>(
+			instruments,
+			MetricDefinitions.TrogonEventstoreProjectionStatus);
+		AssertInstrument<ObservableUpDownCounter<long>>(
+			instruments,
+			MetricDefinitions.TrogonEventstoreProjectionStateSize);
+		Assert.DoesNotContain(instruments, instrument =>
+			instrument.Name.Contains("projection.running", StringComparison.Ordinal) ||
+			instrument.Name.Contains("projection-running", StringComparison.Ordinal));
+	}
+
 	static Action<Measurement<T>> AssertMeasurement<T>(
 		T expectedValue, params (string, string?)[] tags) where T : struct =>
 
@@ -124,6 +184,17 @@ static Action<Measurement<T>> AssertMeasurement<T>(
 				actualMeasurement.Tags.ToArray().Select(tag => (tag.Key, tag.Value as string)));
 		};
 
+	private static void AssertInstrument<TInstrument>(
+		IEnumerable<Instrument> instruments,
+		MetricDefinition definition)
+		where TInstrument : Instrument
+	{
+		var instrument = Assert.Single(instruments, candidate => candidate.Name == definition.Name);
+		Assert.IsType<TInstrument>(instrument);
+		Assert.Equal(definition.Unit, instrument.Unit);
+		Assert.Equal(definition.Description, instrument.Description);
+	}
+
 	private static ProjectionStatistics ProjectionWithState(ManagedProjectionState state, string status) =>
 		new()
 		{
@@ -137,4 +208,11 @@ private static ProjectionStatistics ProjectionWithState(ManagedProjectionState s
 			Progress = 75,
 			EventsProcessedAfterRestart = 50,
 		};
+
+	private static ProjectionStatistics ProjectionWithProgress(float progress) =>
+		new()
+		{
+			Name = "TestProjection",
+			Progress = progress,
+		};
 }
diff --git a/src/EventStore.Projections.Core/Metrics/ProjectionTracker.cs b/src/EventStore.Projections.Core/Metrics/ProjectionTracker.cs
index 82d1b8bc0d..09c875b091 100644
--- a/src/EventStore.Projections.Core/Metrics/ProjectionTracker.cs
+++ b/src/EventStore.Projections.Core/Metrics/ProjectionTracker.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using EventStore.Projections.Core.Services;
 using EventStore.Projections.Core.Services.Management;
+using TrogonEventStore.SemanticConventions;
 
 namespace EventStore.Projections.Core.Metrics;
 
@@ -20,30 +21,17 @@ public IEnumerable<Measurement<long>> ObserveEventsProcessed() =>
 			new Measurement<long>(
 				x.EventsProcessedAfterRestart,
 				[
-					new("projection", x.Name)
+					new(TrogonAttributeNames.ProjectionName, x.Name)
 				]));
 
 	public IEnumerable<Measurement<float>> ObserveProgress() =>
 		_currentStats.Select(x =>
 			new Measurement<float>(
-				x.Progress / 100.0f,
+				NormalizeProgress(x.Progress),
 				[
-					new("projection", x.Name)
+					new(TrogonAttributeNames.ProjectionName, x.Name)
 				]));
 
-	public IEnumerable<Measurement<long>> ObserveRunning() =>
-		_currentStats.Select(x =>
-		{
-			var projectionRunning = x.LeaderStatus == ManagedProjectionState.Running
-				? 1
-				: 0;
-
-			return new Measurement<long>(
-				projectionRunning, [
-					new("projection", x.Name)
-				]);
-		});
-
 	public IEnumerable<Measurement<long>> ObserveStatus()
 	{
 		foreach (var statistics in _currentStats)
@@ -66,23 +54,23 @@ public IEnumerable<Measurement<long>> ObserveStatus()
 			}
 
 			yield return new(projectionRunning, [
-				new("projection", statistics.Name),
-				new("status", "Running"),
+				new(TrogonAttributeNames.ProjectionName, statistics.Name),
+				new(TrogonAttributeNames.ProjectionStatus, "running"),
 			]);
 
 			yield return new(projectionFaulted, [
-				new("projection", statistics.Name),
-				new("status", "Faulted"),
+				new(TrogonAttributeNames.ProjectionName, statistics.Name),
+				new(TrogonAttributeNames.ProjectionStatus, "faulted"),
 			]);
 
 			yield return new(projectionStopped, [
-				new("projection", statistics.Name),
-				new("status", "Stopped"),
+				new(TrogonAttributeNames.ProjectionName, statistics.Name),
+				new(TrogonAttributeNames.ProjectionStatus, "stopped"),
 			]);
 		}
 	}
 
-	public IEnumerable<Measurement<int>> ObserveStateSize()
+	public IEnumerable<Measurement<long>> ObserveStateSize()
 	{
 		foreach (var statistics in _currentStats)
 		{
@@ -91,19 +79,14 @@ public IEnumerable<Measurement<int>> ObserveStateSize()
 				continue;
 			}
 
-			foreach (var (partition, stateSize) in statistics.StateSizes)
-			{
-				List<KeyValuePair<string, object>> tags = [
-					new("projection", statistics.Name),
-				];
-
-				if (partition != string.Empty)
-				{
-					tags.Add(new KeyValuePair<string, object>("partition", partition));
-				}
-
-				yield return new Measurement<int>(stateSize, tags);
-			}
+			yield return new(
+				statistics.StateSizes.Values.Sum(stateSize => (long)stateSize),
+				new KeyValuePair<string, object>(TrogonAttributeNames.ProjectionName, statistics.Name));
 		}
 	}
+
+	private static float NormalizeProgress(float progress) =>
+		float.IsNaN(progress)
+			? 0
+			: float.Clamp(progress / 100.0f, 0, 1);
 }
diff --git a/src/EventStore.Projections.Core/ProjectionsSubsystem.cs b/src/EventStore.Projections.Core/ProjectionsSubsystem.cs
index 3223051522..51a20ec82d 100644
--- a/src/EventStore.Projections.Core/ProjectionsSubsystem.cs
+++ b/src/EventStore.Projections.Core/ProjectionsSubsystem.cs
@@ -20,6 +20,7 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using TrogonEventStore.SemanticConventions;
 using ILogger = Serilog.ILogger;
 
 namespace EventStore.Projections.Core;
@@ -210,11 +211,33 @@ private void ConfigureProjectionMetrics(bool isEnabled)
 		var tracker = new ProjectionTracker();
 		_projectionTracker = tracker;
 
-		projectionMeter.CreateObservableCounter("eventstore-projection-events-processed-after-restart-total", tracker.ObserveEventsProcessed);
-		projectionMeter.CreateObservableUpDownCounter("eventstore-projection-progress", tracker.ObserveProgress);
-		projectionMeter.CreateObservableUpDownCounter("eventstore-projection-running", tracker.ObserveRunning);
-		projectionMeter.CreateObservableUpDownCounter("eventstore-projection-status", tracker.ObserveStatus);
-		projectionMeter.CreateObservableUpDownCounter("eventstore-projection-state-size", tracker.ObserveStateSize);
+		var eventsProcessed = MetricDefinitions.TrogonEventstoreProjectionEventProcessedCount;
+		projectionMeter.CreateObservableCounter(
+			eventsProcessed.Name,
+			tracker.ObserveEventsProcessed,
+			eventsProcessed.Unit,
+			eventsProcessed.Description);
+
+		var progress = MetricDefinitions.TrogonEventstoreProjectionProgress;
+		projectionMeter.CreateObservableGauge(
+			progress.Name,
+			tracker.ObserveProgress,
+			progress.Unit,
+			progress.Description);
+
+		var status = MetricDefinitions.TrogonEventstoreProjectionStatus;
+		projectionMeter.CreateObservableUpDownCounter(
+			status.Name,
+			tracker.ObserveStatus,
+			status.Unit,
+			status.Description);
+
+		var stateSize = MetricDefinitions.TrogonEventstoreProjectionStateSize;
+		projectionMeter.CreateObservableUpDownCounter(
+			stateSize.Name,
+			tracker.ObserveStateSize,
+			stateSize.Unit,
+			stateSize.Description);
 	}
 
 	public void ConfigureServices(IServiceCollection services, IConfiguration configuration) =>
diff --git a/src/TrogonEventStore.SemanticConventions/Generated/AttributeNames.g.cs b/src/TrogonEventStore.SemanticConventions/Generated/AttributeNames.g.cs
index a51835e3dd..8d460a7e0d 100644
--- a/src/TrogonEventStore.SemanticConventions/Generated/AttributeNames.g.cs
+++ b/src/TrogonEventStore.SemanticConventions/Generated/AttributeNames.g.cs
@@ -4,8 +4,18 @@ namespace TrogonEventStore.SemanticConventions
 {
 	public static class AttributeNames
 	{
+		public const string DiskIoDirection = "disk.io.direction";
+		public const string HostArch = "host.arch";
+		public const string HostName = "host.name";
+		public const string ProcessCreationTime = "process.creation.time";
+		public const string ProcessExecutableName = "process.executable.name";
+		public const string ProcessPid = "process.pid";
+		public const string ProcessRuntimeName = "process.runtime.name";
+		public const string ProcessRuntimeVersion = "process.runtime.version";
 		public const string ServiceInstanceId = "service.instance.id";
 		public const string ServiceName = "service.name";
 		public const string ServiceVersion = "service.version";
+		public const string SystemFilesystemMountpoint = "system.filesystem.mountpoint";
+		public const string SystemFilesystemState = "system.filesystem.state";
 	}
 }
diff --git a/src/TrogonEventStore.SemanticConventions/Generated/MetricDefinitions.g.cs b/src/TrogonEventStore.SemanticConventions/Generated/MetricDefinitions.g.cs
new file mode 100644
index 0000000000..9f7c93097b
--- /dev/null
+++ b/src/TrogonEventStore.SemanticConventions/Generated/MetricDefinitions.g.cs
@@ -0,0 +1,267 @@
+// <auto-generated />
+
+using System;
+using System.Collections.Generic;
+
+namespace TrogonEventStore.SemanticConventions
+{
+	public static class MetricDefinitions
+	{
+		public static MetricDefinition TrogonEventstoreCacheOperationCount { get; } = new MetricDefinition(
+			"trogon.eventstore.cache.operation.count",
+			"{operation}",
+			"Number of cache lookups by result.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreCacheResourceCount { get; } = new MetricDefinition(
+			"trogon.eventstore.cache.resource.count",
+			"{entry}",
+			"Cache resource size, capacity, and count in entries.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition TrogonEventstoreCacheResourceSize { get; } = new MetricDefinition(
+			"trogon.eventstore.cache.resource.size",
+			"By",
+			"Cache resource size and capacity in bytes.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition TrogonEventstoreCheckpointPosition { get; } = new MetricDefinition(
+			"trogon.eventstore.checkpoint.position",
+			"1",
+			"Transaction log checkpoint position.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition TrogonEventstoreClusterElectionCount { get; } = new MetricDefinition(
+			"trogon.eventstore.cluster.election.count",
+			"{election}",
+			"Number of cluster elections.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreComponentStatus { get; } = new MetricDefinition(
+			"trogon.eventstore.component.status",
+			"1",
+			"Current component status represented as one-hot state series.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition TrogonEventstoreGossipExchangeDuration { get; } = new MetricDefinition(
+			"trogon.eventstore.gossip.exchange.duration",
+			"s",
+			"Duration of gossip exchanges.",
+			MetricInstrumentKind.Histogram);
+		public static MetricDefinition TrogonEventstoreGossipMessageProcessingDuration { get; } = new MetricDefinition(
+			"trogon.eventstore.gossip.message.processing.duration",
+			"s",
+			"Duration of gossip message processing.",
+			MetricInstrumentKind.Histogram);
+		public static MetricDefinition TrogonEventstoreGrpcServerCallActive { get; } = new MetricDefinition(
+			"trogon.eventstore.grpc.server.call.active",
+			"{call}",
+			"Number of active incoming gRPC calls.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition TrogonEventstoreGrpcServerCallCount { get; } = new MetricDefinition(
+			"trogon.eventstore.grpc.server.call.count",
+			"{call}",
+			"Number of incoming gRPC calls.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreGrpcServerCallDeadlineExceededCount { get; } = new MetricDefinition(
+			"trogon.eventstore.grpc.server.call.deadline_exceeded.count",
+			"{call}",
+			"Number of incoming gRPC calls that exceeded their deadline.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreGrpcServerCallDuration { get; } = new MetricDefinition(
+			"trogon.eventstore.grpc.server.call.duration",
+			"s",
+			"Duration of configured gRPC server calls.",
+			MetricInstrumentKind.Histogram);
+		public static MetricDefinition TrogonEventstoreGrpcServerCallFailureCount { get; } = new MetricDefinition(
+			"trogon.eventstore.grpc.server.call.failure.count",
+			"{call}",
+			"Number of failed incoming gRPC calls.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreGrpcServerCallUnimplementedCount { get; } = new MetricDefinition(
+			"trogon.eventstore.grpc.server.call.unimplemented.count",
+			"{call}",
+			"Number of unimplemented incoming gRPC calls.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionCheckpointCommitPosition { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.checkpoint.commit.position",
+			"1",
+			"Last checkpointed commit position for persistent subscriptions.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionCheckpointEventRevision { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.checkpoint.event.revision",
+			"1",
+			"Last checkpointed stream revision for persistent subscriptions.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionConnectionCount { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.connection.count",
+			"{connection}",
+			"Number of persistent subscription connections.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionInFlightMessageCount { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.in_flight_message.count",
+			"{message}",
+			"Number of in-flight persistent subscription messages.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionItemProcessedCount { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.item.processed.count",
+			"{item}",
+			"Number of items processed by persistent subscriptions.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionLastKnownCommitPosition { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.last_known.commit.position",
+			"1",
+			"Last known commit position for persistent subscriptions.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionLastKnownEventRevision { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.last_known.event.revision",
+			"1",
+			"Last known stream revision for persistent subscriptions.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionOldestParkedMessageAge { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.oldest_parked_message.age",
+			"s",
+			"Age of the oldest parked persistent subscription message.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionParkRequestCount { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.park_request.count",
+			"{request}",
+			"Number of persistent subscription park requests.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionParkedMessageCount { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.parked_message.count",
+			"{message}",
+			"Number of parked persistent subscription messages.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionParkedMessageReplayCount { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.parked_message.replay.count",
+			"{operation}",
+			"Number of persistent subscription parked-message replays.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstorePersistentSubscriptionParkedMessageTruncateCount { get; } = new MetricDefinition(
+			"trogon.eventstore.persistent_subscription.parked_message.truncate.count",
+			"{operation}",
+			"Number of persistent subscription parked-message truncations.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreProcessDiskOperationCount { get; } = new MetricDefinition(
+			"trogon.eventstore.process.disk.operation.count",
+			"{operation}",
+			"Number of disk operations performed by the process.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreProjectionEventProcessedCount { get; } = new MetricDefinition(
+			"trogon.eventstore.projection.event.processed.count",
+			"{event}",
+			"Number of events processed by a projection after restart.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreProjectionProgress { get; } = new MetricDefinition(
+			"trogon.eventstore.projection.progress",
+			"1",
+			"Fraction of projection processing completed.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition TrogonEventstoreProjectionStateSize { get; } = new MetricDefinition(
+			"trogon.eventstore.projection.state.size",
+			"By",
+			"Projection state size.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition TrogonEventstoreProjectionStatus { get; } = new MetricDefinition(
+			"trogon.eventstore.projection.status",
+			"1",
+			"Projection state represented as one active status series.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition TrogonEventstoreQueueBusyTime { get; } = new MetricDefinition(
+			"trogon.eventstore.queue.busy.time",
+			"s",
+			"Total time a queue has spent processing messages.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreQueueMessageCount { get; } = new MetricDefinition(
+			"trogon.eventstore.queue.message.count",
+			"{message}",
+			"Number of messages waiting in a queue.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition TrogonEventstoreQueueMessageProcessingDuration { get; } = new MetricDefinition(
+			"trogon.eventstore.queue.message.processing.duration",
+			"s",
+			"Duration of queue message processing.",
+			MetricInstrumentKind.Histogram);
+		public static MetricDefinition TrogonEventstoreQueueMessageWaitDurationMax { get; } = new MetricDefinition(
+			"trogon.eventstore.queue.message.wait.duration.max",
+			"s",
+			"Maximum time a message waited in a queue during the measurement window.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition TrogonEventstoreStorageChunkReadDistance { get; } = new MetricDefinition(
+			"trogon.eventstore.storage.chunk.read.distance",
+			"{chunk}",
+			"Logical chunk distance between a read and the writer position.",
+			MetricInstrumentKind.Histogram);
+		public static MetricDefinition TrogonEventstoreStorageEventCount { get; } = new MetricDefinition(
+			"trogon.eventstore.storage.event.count",
+			"{event}",
+			"Number of events processed by storage operations.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreStorageIo { get; } = new MetricDefinition(
+			"trogon.eventstore.storage.io",
+			"By",
+			"Bytes transferred by storage operations.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition TrogonEventstoreStorageRecordReadDuration { get; } = new MetricDefinition(
+			"trogon.eventstore.storage.record.read.duration",
+			"s",
+			"Duration of transaction file record reads.",
+			MetricInstrumentKind.Histogram);
+		public static MetricDefinition TrogonEventstoreSystemLoadAverage { get; } = new MetricDefinition(
+			"trogon.eventstore.system.load_average",
+			"1",
+			"System load average.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition TrogonEventstoreWriterFlushDurationMax { get; } = new MetricDefinition(
+			"trogon.eventstore.writer.flush.duration.max",
+			"s",
+			"Maximum writer flush duration during the measurement window.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition TrogonEventstoreWriterFlushSizeMax { get; } = new MetricDefinition(
+			"trogon.eventstore.writer.flush.size.max",
+			"By",
+			"Maximum writer flush size during the measurement window.",
+			MetricInstrumentKind.Gauge);
+
+		public static IReadOnlyList<MetricDefinition> All { get; } = Array.AsReadOnly(new[]
+		{
+			TrogonEventstoreCacheOperationCount,
+			TrogonEventstoreCacheResourceCount,
+			TrogonEventstoreCacheResourceSize,
+			TrogonEventstoreCheckpointPosition,
+			TrogonEventstoreClusterElectionCount,
+			TrogonEventstoreComponentStatus,
+			TrogonEventstoreGossipExchangeDuration,
+			TrogonEventstoreGossipMessageProcessingDuration,
+			TrogonEventstoreGrpcServerCallActive,
+			TrogonEventstoreGrpcServerCallCount,
+			TrogonEventstoreGrpcServerCallDeadlineExceededCount,
+			TrogonEventstoreGrpcServerCallDuration,
+			TrogonEventstoreGrpcServerCallFailureCount,
+			TrogonEventstoreGrpcServerCallUnimplementedCount,
+			TrogonEventstorePersistentSubscriptionCheckpointCommitPosition,
+			TrogonEventstorePersistentSubscriptionCheckpointEventRevision,
+			TrogonEventstorePersistentSubscriptionConnectionCount,
+			TrogonEventstorePersistentSubscriptionInFlightMessageCount,
+			TrogonEventstorePersistentSubscriptionItemProcessedCount,
+			TrogonEventstorePersistentSubscriptionLastKnownCommitPosition,
+			TrogonEventstorePersistentSubscriptionLastKnownEventRevision,
+			TrogonEventstorePersistentSubscriptionOldestParkedMessageAge,
+			TrogonEventstorePersistentSubscriptionParkRequestCount,
+			TrogonEventstorePersistentSubscriptionParkedMessageCount,
+			TrogonEventstorePersistentSubscriptionParkedMessageReplayCount,
+			TrogonEventstorePersistentSubscriptionParkedMessageTruncateCount,
+			TrogonEventstoreProcessDiskOperationCount,
+			TrogonEventstoreProjectionEventProcessedCount,
+			TrogonEventstoreProjectionProgress,
+			TrogonEventstoreProjectionStateSize,
+			TrogonEventstoreProjectionStatus,
+			TrogonEventstoreQueueBusyTime,
+			TrogonEventstoreQueueMessageCount,
+			TrogonEventstoreQueueMessageProcessingDuration,
+			TrogonEventstoreQueueMessageWaitDurationMax,
+			TrogonEventstoreStorageChunkReadDistance,
+			TrogonEventstoreStorageEventCount,
+			TrogonEventstoreStorageIo,
+			TrogonEventstoreStorageRecordReadDuration,
+			TrogonEventstoreSystemLoadAverage,
+			TrogonEventstoreWriterFlushDurationMax,
+			TrogonEventstoreWriterFlushSizeMax,
+		});
+	}
+}
diff --git a/src/TrogonEventStore.SemanticConventions/Generated/OpenTelemetryMetricDefinitions.g.cs b/src/TrogonEventStore.SemanticConventions/Generated/OpenTelemetryMetricDefinitions.g.cs
new file mode 100644
index 0000000000..d48e19a565
--- /dev/null
+++ b/src/TrogonEventStore.SemanticConventions/Generated/OpenTelemetryMetricDefinitions.g.cs
@@ -0,0 +1,39 @@
+// <auto-generated />
+
+using System;
+using System.Collections.Generic;
+
+namespace TrogonEventStore.SemanticConventions
+{
+	public static class OpenTelemetryMetricDefinitions
+	{
+		public static MetricDefinition ProcessDiskIo { get; } = new MetricDefinition(
+			"process.disk.io",
+			"By",
+			"Disk bytes transferred.",
+			MetricInstrumentKind.Counter);
+		public static MetricDefinition ProcessUptime { get; } = new MetricDefinition(
+			"process.uptime",
+			"s",
+			"The time the process has been running.",
+			MetricInstrumentKind.Gauge);
+		public static MetricDefinition SystemFilesystemLimit { get; } = new MetricDefinition(
+			"system.filesystem.limit",
+			"By",
+			"The total storage capacity of the filesystem.",
+			MetricInstrumentKind.UpDownCounter);
+		public static MetricDefinition SystemFilesystemUsage { get; } = new MetricDefinition(
+			"system.filesystem.usage",
+			"By",
+			"Reports a filesystem's space usage across different states.",
+			MetricInstrumentKind.UpDownCounter);
+
+		public static IReadOnlyList<MetricDefinition> All { get; } = Array.AsReadOnly(new[]
+		{
+			ProcessDiskIo,
+			ProcessUptime,
+			SystemFilesystemLimit,
+			SystemFilesystemUsage,
+		});
+	}
+}
diff --git a/src/TrogonEventStore.SemanticConventions/Generated/TrogonAttributeNames.g.cs b/src/TrogonEventStore.SemanticConventions/Generated/TrogonAttributeNames.g.cs
new file mode 100644
index 0000000000..8fa1b61f4c
--- /dev/null
+++ b/src/TrogonEventStore.SemanticConventions/Generated/TrogonAttributeNames.g.cs
@@ -0,0 +1,55 @@
+// <auto-generated />
+
+using System;
+using System.Collections.Generic;
+
+namespace TrogonEventStore.SemanticConventions
+{
+	public static class TrogonAttributeNames
+	{
+		public const string ActivityName = "trogon.eventstore.activity.name";
+		public const string ActivityOutcome = "trogon.eventstore.activity.outcome";
+		public const string CacheName = "trogon.eventstore.cache.name";
+		public const string CacheResource = "trogon.eventstore.cache.resource";
+		public const string CacheResult = "trogon.eventstore.cache.result";
+		public const string CheckpointName = "trogon.eventstore.checkpoint.name";
+		public const string CheckpointReadKind = "trogon.eventstore.checkpoint.read_kind";
+		public const string ComponentName = "trogon.eventstore.component.name";
+		public const string ComponentStatus = "trogon.eventstore.component.status";
+		public const string MeasurementWindow = "trogon.eventstore.measurement.window";
+		public const string PersistentSubscriptionGroup = "trogon.eventstore.persistent_subscription.group";
+		public const string PersistentSubscriptionReason = "trogon.eventstore.persistent_subscription.reason";
+		public const string PersistentSubscriptionStream = "trogon.eventstore.persistent_subscription.stream";
+		public const string ProjectionName = "trogon.eventstore.projection.name";
+		public const string ProjectionStatus = "trogon.eventstore.projection.status";
+		public const string QueueMessageType = "trogon.eventstore.queue.message.type";
+		public const string QueueName = "trogon.eventstore.queue.name";
+		public const string StorageActivity = "trogon.eventstore.storage.activity";
+		public const string StorageSource = "trogon.eventstore.storage.source";
+		public const string SystemLoadAveragePeriod = "trogon.eventstore.system.load_average.period";
+
+		public static IReadOnlyList<string> All { get; } = Array.AsReadOnly(new[]
+		{
+			ActivityName,
+			ActivityOutcome,
+			CacheName,
+			CacheResource,
+			CacheResult,
+			CheckpointName,
+			CheckpointReadKind,
+			ComponentName,
+			ComponentStatus,
+			MeasurementWindow,
+			PersistentSubscriptionGroup,
+			PersistentSubscriptionReason,
+			PersistentSubscriptionStream,
+			ProjectionName,
+			ProjectionStatus,
+			QueueMessageType,
+			QueueName,
+			StorageActivity,
+			StorageSource,
+			SystemLoadAveragePeriod,
+		});
+	}
+}
diff --git a/src/TrogonEventStore.SemanticConventions/MetricDefinition.cs b/src/TrogonEventStore.SemanticConventions/MetricDefinition.cs
new file mode 100644
index 0000000000..4d61c177a7
--- /dev/null
+++ b/src/TrogonEventStore.SemanticConventions/MetricDefinition.cs
@@ -0,0 +1,62 @@
+using System;
+
+namespace TrogonEventStore.SemanticConventions
+{
+	public sealed class MetricDefinition : IEquatable<MetricDefinition>
+	{
+		public MetricDefinition(
+			string name,
+			string unit,
+			string description,
+			MetricInstrumentKind instrumentKind)
+		{
+			Name = RequireValue(name, nameof(name));
+			Unit = RequireValue(unit, nameof(unit));
+			Description = RequireValue(description, nameof(description));
+			if (!Enum.IsDefined(typeof(MetricInstrumentKind), instrumentKind))
+			{
+				throw new ArgumentOutOfRangeException(nameof(instrumentKind), instrumentKind, "Unknown metric instrument kind.");
+			}
+
+			InstrumentKind = instrumentKind;
+		}
+
+		public string Name { get; }
+		public string Unit { get; }
+		public string Description { get; }
+		public MetricInstrumentKind InstrumentKind { get; }
+
+		public bool Equals(MetricDefinition other) =>
+			other is not null &&
+			StringComparer.Ordinal.Equals(Name, other.Name) &&
+			StringComparer.Ordinal.Equals(Unit, other.Unit) &&
+			StringComparer.Ordinal.Equals(Description, other.Description) &&
+			InstrumentKind == other.InstrumentKind;
+
+		public override bool Equals(object obj) => Equals(obj as MetricDefinition);
+
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				var hashCode = StringComparer.Ordinal.GetHashCode(Name);
+				hashCode = (hashCode * 397) ^ StringComparer.Ordinal.GetHashCode(Unit);
+				hashCode = (hashCode * 397) ^ StringComparer.Ordinal.GetHashCode(Description);
+				hashCode = (hashCode * 397) ^ (int)InstrumentKind;
+				return hashCode;
+			}
+		}
+
+		public override string ToString() => Name;
+
+		private static string RequireValue(string value, string parameterName)
+		{
+			if (string.IsNullOrWhiteSpace(value))
+			{
+				throw new ArgumentException("Metric metadata cannot be empty.", parameterName);
+			}
+
+			return value;
+		}
+	}
+}
diff --git a/src/TrogonEventStore.SemanticConventions/MetricInstrumentKind.cs b/src/TrogonEventStore.SemanticConventions/MetricInstrumentKind.cs
new file mode 100644
index 0000000000..5792d11569
--- /dev/null
+++ b/src/TrogonEventStore.SemanticConventions/MetricInstrumentKind.cs
@@ -0,0 +1,10 @@
+namespace TrogonEventStore.SemanticConventions
+{
+	public enum MetricInstrumentKind
+	{
+		Counter,
+		Gauge,
+		Histogram,
+		UpDownCounter,
+	}
+}
diff --git a/src/TrogonEventStore.SemanticConventions/README.md b/src/TrogonEventStore.SemanticConventions/README.md
index 31380553ac..79604349ca 100644
--- a/src/TrogonEventStore.SemanticConventions/README.md
+++ b/src/TrogonEventStore.SemanticConventions/README.md
@@ -1,5 +1,28 @@
 # TrogonEventStore Semantic Conventions
 
-This package gives TrogonEventStore components one generated source for OpenTelemetry attribute names. It has no runtime dependencies.
+This package gives TrogonEventStore components one generated source for
+OpenTelemetry attributes and built-in metric definitions. Each
+`MetricDefinition` carries the instrument name, UCUM unit, description, and
+instrument kind from the Weaver registry. `MetricDefinitions.All` provides
+every built-in definition exactly once in deterministic name order.
 
-The pinned OpenTelemetry registry version and C# templates under `otel/semconv` are the source of truth. Regenerate the committed constants with `mise run semconv:generate` and verify them with `mise run semconv:check`.
+Metric units use UCUM notation. `s` means seconds, `By` means bytes, and `1`
+marks a dimensionless value such as a ratio or logical position. Annotated
+units such as `{event}` identify counts without embedding the unit in the
+instrument name.
+
+`OpenTelemetryMetricDefinitions` provides the selected process and filesystem
+definitions from the pinned official OpenTelemetry registry. Its `All`
+collection is generated in deterministic name order alongside the custom
+catalog.
+
+`AttributeNames` contains the selected official resource attributes.
+`TrogonAttributeNames` contains every custom `trogon.eventstore.*` metric
+attribute, with deterministic `All` ordering.
+
+Instrumentation consumes `MetricDefinitions` so metric metadata cannot drift
+independently. The package has no runtime dependencies.
+
+The pinned OpenTelemetry registry version and C# templates under `otel/semconv`
+are the source of truth. Regenerate the committed constants with
+`mise run semconv:generate` and verify them with `mise run semconv:check`.
diff --git a/src/TrogonEventStore.SemanticConventions/TrogonEventStore.SemanticConventions.csproj b/src/TrogonEventStore.SemanticConventions/TrogonEventStore.SemanticConventions.csproj
index daa3e106dc..112f01af2e 100644
--- a/src/TrogonEventStore.SemanticConventions/TrogonEventStore.SemanticConventions.csproj
+++ b/src/TrogonEventStore.SemanticConventions/TrogonEventStore.SemanticConventions.csproj
@@ -10,7 +10,7 @@
 		<Authors>Straw Hat, LLC</Authors>
 		<Company>Straw Hat, LLC</Company>
 		<Copyright>Copyright Straw Hat, LLC</Copyright>
-		<Description>Shared OpenTelemetry semantic convention constants for TrogonEventStore components.</Description>
+		<Description>Shared OpenTelemetry semantic convention definitions for TrogonEventStore components.</Description>
 		<PackageProjectUrl>https://github.com/TrogonStack/TrogonEventStore</PackageProjectUrl>
 		<PackageReadmeFile>README.md</PackageReadmeFile>
 		<PackageReleaseNotes></PackageReleaseNotes>