@zlink-systems/framework 0.26.0 → 0.27.0

package/dist/runtime/diagnostics/runtime-metrics.d.ts

@@ -1,4 +1,6 @@
-import type { ZLinkHostCapacityStatus, ZLinkMeterProvider, ZLinkMetricAttributes } from '../../contracts';
+import { type ZLinkHostCapacityStatus, type ZLinkMeterProvider, type ZLinkMetricAttributes } from '../../contracts';
+export declare const MILLISECONDS_PER_SECOND = 1000;
+export declare const NANOSECONDS_PER_SECOND = 1000000000;
 export interface ZLinkRuntimeMetricCapacity {
     readonly active: number;
     readonly reserved: number;
@@ -48,41 +50,102 @@ export interface ZLinkRuntimeMetricOperation {
 export interface ZLinkRelocationMetricOperation extends ZLinkRuntimeMetricOperation {
     recordBytes(bytes: number): void;
 }
+export declare const METRIC_NAMES: Readonly<{
+    readonly StreamConnectionsOpened: "zlink.stream.connections.opened";
+    readonly StreamConnectionsClosed: "zlink.stream.connections.closed";
+    readonly MeshNodeChannelSelectionFailures: "zlink.mesh_node.channel.selection_failures";
+    readonly MeshNodeRequestTimeouts: "zlink.mesh_node.request.timeouts";
+    readonly MeshNodeMessagesDropped: "zlink.mesh_node.messages.dropped";
+    readonly RelocationStarted: "zlink.relocation.started";
+    readonly RelocationCompleted: "zlink.relocation.completed";
+    readonly RelocationCutoverTimeout: "zlink.relocation.cutover_timeout";
+    readonly InstanceSpotActivations: "zlink.instance_spot.activations";
+    readonly InstanceSpotClaimConflicts: "zlink.instance_spot.claim.conflicts";
+    readonly InstanceSpotTakeovers: "zlink.instance_spot.takeovers";
+    readonly LocationStoreErrors: "zlink.location.store.errors";
+    readonly LocationOwnerLeaseRenewFailures: "zlink.location.owner_lease.renew.failures";
+    readonly ObservabilityEventsOverflow: "zlink.observability.events.overflow";
+    readonly HostRelocationBlocked: "zlink.host.relocation.blocked";
+    readonly HostShutdownForced: "zlink.host.shutdown.forced";
+    readonly StreamConnectionsActive: "zlink.stream.connections.active";
+    readonly SpotCount: "zlink.spot.count";
+    readonly ActorCount: "zlink.actor.count";
+    readonly MeshNodeRequestsInflight: "zlink.mesh_node.requests.inflight";
+    readonly MeshNodeRequestDuration: "zlink.mesh_node.request.duration";
+    readonly RelocationDuration: "zlink.relocation.duration";
+    readonly RelocationBytes: "zlink.relocation.bytes";
+    readonly RelocationInterruption: "zlink.relocation.interruption";
+    readonly RelocationTargetResume: "zlink.relocation.target_resume";
+    readonly RelocationRouteConvergence: "zlink.relocation.route_convergence";
+    readonly InstanceSpotActivationDuration: "zlink.instance_spot.activation.duration";
+    readonly LocationOwnerLeaseRenewLateness: "zlink.location.owner_lease.renew.lateness";
+    readonly HostRelocationDuration: "zlink.host.relocation.duration";
+    readonly HostShutdownDuration: "zlink.host.shutdown.duration";
+    readonly MeshNodePeersConfigured: "zlink.mesh_node.peers.configured";
+    readonly MeshNodePeersConnected: "zlink.mesh_node.peers.connected";
+    readonly MeshNodePeersReady: "zlink.mesh_node.peers.ready";
+    readonly MeshNodeChannelsReadyMembers: "zlink.mesh_node.channels.ready_members";
+    readonly ObjectCapacityActive: "zlink.object.capacity.active";
+    readonly ObjectCapacityReserved: "zlink.object.capacity.reserved";
+    readonly ObjectCapacityLimit: "zlink.object.capacity.limit";
+    readonly SpotTypeCapacityActive: "zlink.spot.type.capacity.active";
+    readonly SpotTypeCapacityReserved: "zlink.spot.type.capacity.reserved";
+    readonly SpotTypeCapacityLimit: "zlink.spot.type.capacity.limit";
+    readonly ObjectActivationActive: "zlink.object.activation.active";
+    readonly ObjectActivationLimit: "zlink.object.activation.limit";
+    readonly InstanceSpotPendingMessages: "zlink.instance_spot.pending.messages";
+    readonly InstanceSpotPendingBytes: "zlink.instance_spot.pending.bytes";
+    readonly HostState: "zlink.host.state";
+    readonly HostCoreHwmEffectiveBudget: "zlink.host.core_hwm.effective_budget";
+    readonly HostCoreHwmApplied: "zlink.host.core_hwm.applied";
+    readonly HostCoreHwmAccounted: "zlink.host.core_hwm.accounted";
+    readonly HostCoreHwmCompletionAccounted: "zlink.host.core_hwm.completion_accounted";
+    readonly HostCoreHwmBlockedRatio: "zlink.host.core_hwm.blocked_ratio";
+    readonly HostApplicationJobQueueLimit: "zlink.host.application_job_queue.limit";
+    readonly HostApplicationJobQueueJobs: "zlink.host.application_job_queue.jobs";
+    readonly HostApplicationJobQueueCapacityWaiters: "zlink.host.application_job_queue.capacity_waiters";
+    readonly HostApplicationJobQueuePressureState: "zlink.host.application_job_queue.pressure_state";
+    readonly HostApplicationJobQueuePauseDuration: "zlink.host.application_job_queue.pause_duration";
+    readonly HostApplicationJobQueueCapacityWaits: "zlink.host.application_job_queue.capacity_waits";
+    readonly HostApplicationJobQueueCapacityWaitDuration: "zlink.host.application_job_queue.capacity_wait_duration";
+    readonly HostApplicationJobQueuePressureTransitions: "zlink.host.application_job_queue.pressure_transitions";
+    readonly HostApplicationJobQueueFlowStateConfigFailures: "zlink.host.application_job_queue.flow_state_config_failures";
+}>;
 declare const COUNTERS: Readonly<{
-    readonly 'zlink.stream.connections.opened': "{connection}";
-    readonly 'zlink.stream.connections.closed': "{connection}";
-    readonly 'zlink.mesh_node.channel.selection_failures': "{failure}";
-    readonly 'zlink.mesh_node.request.timeouts': "{request}";
-    readonly 'zlink.mesh_node.messages.dropped': "{message}";
-    readonly 'zlink.relocation.started': "{relocation}";
-    readonly 'zlink.relocation.completed': "{relocation}";
-    readonly 'zlink.relocation.cutover_timeout': "{fallback}";
-    readonly 'zlink.instance_spot.activations': "{activation}";
-    readonly 'zlink.instance_spot.claim.conflicts': "{claim}";
-    readonly 'zlink.instance_spot.takeovers': "{takeover}";
-    readonly 'zlink.location.store.errors': "{error}";
-    readonly 'zlink.location.owner_lease.renew.failures': "{failure}";
-    readonly 'zlink.observability.events.overflow': "{event}";
-    readonly 'zlink.host.relocation.blocked': "{operation}";
-    readonly 'zlink.host.shutdown.forced': "{operation}";
+    readonly "zlink.stream.connections.opened": "{connection}";
+    readonly "zlink.stream.connections.closed": "{connection}";
+    readonly "zlink.mesh_node.channel.selection_failures": "{failure}";
+    readonly "zlink.mesh_node.request.timeouts": "{request}";
+    readonly "zlink.mesh_node.messages.dropped": "{message}";
+    readonly "zlink.relocation.started": "{relocation}";
+    readonly "zlink.relocation.completed": "{relocation}";
+    readonly "zlink.relocation.cutover_timeout": "{fallback}";
+    readonly "zlink.instance_spot.activations": "{activation}";
+    readonly "zlink.instance_spot.claim.conflicts": "{claim}";
+    readonly "zlink.instance_spot.takeovers": "{takeover}";
+    readonly "zlink.location.store.errors": "{error}";
+    readonly "zlink.location.owner_lease.renew.failures": "{failure}";
+    readonly "zlink.observability.events.overflow": "{event}";
+    readonly "zlink.host.relocation.blocked": "{operation}";
+    readonly "zlink.host.shutdown.forced": "{operation}";
 }>;
 declare const UP_DOWN_COUNTERS: Readonly<{
-    readonly 'zlink.stream.connections.active': "{connection}";
-    readonly 'zlink.spot.count': "{spot}";
-    readonly 'zlink.actor.count': "{actor}";
-    readonly 'zlink.mesh_node.requests.inflight': "{request}";
+    readonly "zlink.stream.connections.active": "{connection}";
+    readonly "zlink.spot.count": "{spot}";
+    readonly "zlink.actor.count": "{actor}";
+    readonly "zlink.mesh_node.requests.inflight": "{request}";
 }>;
 declare const HISTOGRAMS: Readonly<{
-    readonly 'zlink.mesh_node.request.duration': "s";
-    readonly 'zlink.relocation.duration': "s";
-    readonly 'zlink.relocation.bytes': "By";
-    readonly 'zlink.relocation.interruption': "s";
-    readonly 'zlink.relocation.target_resume': "s";
-    readonly 'zlink.relocation.route_convergence': "s";
-    readonly 'zlink.instance_spot.activation.duration': "s";
-    readonly 'zlink.location.owner_lease.renew.lateness': "s";
-    readonly 'zlink.host.relocation.duration': "s";
-    readonly 'zlink.host.shutdown.duration': "s";
+    readonly "zlink.mesh_node.request.duration": "s";
+    readonly "zlink.relocation.duration": "s";
+    readonly "zlink.relocation.bytes": "By";
+    readonly "zlink.relocation.interruption": "s";
+    readonly "zlink.relocation.target_resume": "s";
+    readonly "zlink.relocation.route_convergence": "s";
+    readonly "zlink.instance_spot.activation.duration": "s";
+    readonly "zlink.location.owner_lease.renew.lateness": "s";
+    readonly "zlink.host.relocation.duration": "s";
+    readonly "zlink.host.shutdown.duration": "s";
 }>;
 type CounterName = keyof typeof COUNTERS;
 type UpDownName = keyof typeof UP_DOWN_COUNTERS;

package/dist/runtime/diagnostics/runtime-metrics.js

@@ -1,76 +1,139 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkRequestMetricOperation = exports.ZLinkRuntimeMetrics = void 0;
-const contracts_1 = require("../../contracts");
+exports.ZLinkRequestMetricOperation = exports.ZLinkRuntimeMetrics = exports.METRIC_NAMES = exports.NANOSECONDS_PER_SECOND = exports.MILLISECONDS_PER_SECOND = void 0;
 const api_1 = require("@opentelemetry/api");
+const contracts_1 = require("../../contracts");
+exports.MILLISECONDS_PER_SECOND = 1000;
+exports.NANOSECONDS_PER_SECOND = 1e9;
+exports.METRIC_NAMES = Object.freeze({
+    StreamConnectionsOpened: 'zlink.stream.connections.opened',
+    StreamConnectionsClosed: 'zlink.stream.connections.closed',
+    MeshNodeChannelSelectionFailures: 'zlink.mesh_node.channel.selection_failures',
+    MeshNodeRequestTimeouts: 'zlink.mesh_node.request.timeouts',
+    MeshNodeMessagesDropped: 'zlink.mesh_node.messages.dropped',
+    RelocationStarted: 'zlink.relocation.started',
+    RelocationCompleted: 'zlink.relocation.completed',
+    RelocationCutoverTimeout: 'zlink.relocation.cutover_timeout',
+    InstanceSpotActivations: 'zlink.instance_spot.activations',
+    InstanceSpotClaimConflicts: 'zlink.instance_spot.claim.conflicts',
+    InstanceSpotTakeovers: 'zlink.instance_spot.takeovers',
+    LocationStoreErrors: 'zlink.location.store.errors',
+    LocationOwnerLeaseRenewFailures: 'zlink.location.owner_lease.renew.failures',
+    ObservabilityEventsOverflow: 'zlink.observability.events.overflow',
+    HostRelocationBlocked: 'zlink.host.relocation.blocked',
+    HostShutdownForced: 'zlink.host.shutdown.forced',
+    StreamConnectionsActive: 'zlink.stream.connections.active',
+    SpotCount: 'zlink.spot.count',
+    ActorCount: 'zlink.actor.count',
+    MeshNodeRequestsInflight: 'zlink.mesh_node.requests.inflight',
+    MeshNodeRequestDuration: 'zlink.mesh_node.request.duration',
+    RelocationDuration: 'zlink.relocation.duration',
+    RelocationBytes: 'zlink.relocation.bytes',
+    RelocationInterruption: 'zlink.relocation.interruption',
+    RelocationTargetResume: 'zlink.relocation.target_resume',
+    RelocationRouteConvergence: 'zlink.relocation.route_convergence',
+    InstanceSpotActivationDuration: 'zlink.instance_spot.activation.duration',
+    LocationOwnerLeaseRenewLateness: 'zlink.location.owner_lease.renew.lateness',
+    HostRelocationDuration: 'zlink.host.relocation.duration',
+    HostShutdownDuration: 'zlink.host.shutdown.duration',
+    MeshNodePeersConfigured: 'zlink.mesh_node.peers.configured',
+    MeshNodePeersConnected: 'zlink.mesh_node.peers.connected',
+    MeshNodePeersReady: 'zlink.mesh_node.peers.ready',
+    MeshNodeChannelsReadyMembers: 'zlink.mesh_node.channels.ready_members',
+    ObjectCapacityActive: 'zlink.object.capacity.active',
+    ObjectCapacityReserved: 'zlink.object.capacity.reserved',
+    ObjectCapacityLimit: 'zlink.object.capacity.limit',
+    SpotTypeCapacityActive: 'zlink.spot.type.capacity.active',
+    SpotTypeCapacityReserved: 'zlink.spot.type.capacity.reserved',
+    SpotTypeCapacityLimit: 'zlink.spot.type.capacity.limit',
+    ObjectActivationActive: 'zlink.object.activation.active',
+    ObjectActivationLimit: 'zlink.object.activation.limit',
+    InstanceSpotPendingMessages: 'zlink.instance_spot.pending.messages',
+    InstanceSpotPendingBytes: 'zlink.instance_spot.pending.bytes',
+    HostState: 'zlink.host.state',
+    HostCoreHwmEffectiveBudget: 'zlink.host.core_hwm.effective_budget',
+    HostCoreHwmApplied: 'zlink.host.core_hwm.applied',
+    HostCoreHwmAccounted: 'zlink.host.core_hwm.accounted',
+    HostCoreHwmCompletionAccounted: 'zlink.host.core_hwm.completion_accounted',
+    HostCoreHwmBlockedRatio: 'zlink.host.core_hwm.blocked_ratio',
+    HostApplicationJobQueueLimit: 'zlink.host.application_job_queue.limit',
+    HostApplicationJobQueueJobs: 'zlink.host.application_job_queue.jobs',
+    HostApplicationJobQueueCapacityWaiters: 'zlink.host.application_job_queue.capacity_waiters',
+    HostApplicationJobQueuePressureState: 'zlink.host.application_job_queue.pressure_state',
+    HostApplicationJobQueuePauseDuration: 'zlink.host.application_job_queue.pause_duration',
+    HostApplicationJobQueueCapacityWaits: 'zlink.host.application_job_queue.capacity_waits',
+    HostApplicationJobQueueCapacityWaitDuration: 'zlink.host.application_job_queue.capacity_wait_duration',
+    HostApplicationJobQueuePressureTransitions: 'zlink.host.application_job_queue.pressure_transitions',
+    HostApplicationJobQueueFlowStateConfigFailures: 'zlink.host.application_job_queue.flow_state_config_failures'
+});
 const COUNTERS = Object.freeze({
-    'zlink.stream.connections.opened': '{connection}',
-    'zlink.stream.connections.closed': '{connection}',
-    'zlink.mesh_node.channel.selection_failures': '{failure}',
-    'zlink.mesh_node.request.timeouts': '{request}',
-    'zlink.mesh_node.messages.dropped': '{message}',
-    'zlink.relocation.started': '{relocation}',
-    'zlink.relocation.completed': '{relocation}',
-    'zlink.relocation.cutover_timeout': '{fallback}',
-    'zlink.instance_spot.activations': '{activation}',
-    'zlink.instance_spot.claim.conflicts': '{claim}',
-    'zlink.instance_spot.takeovers': '{takeover}',
-    'zlink.location.store.errors': '{error}',
-    'zlink.location.owner_lease.renew.failures': '{failure}',
-    'zlink.observability.events.overflow': '{event}',
-    'zlink.host.relocation.blocked': '{operation}',
-    'zlink.host.shutdown.forced': '{operation}'
+    [exports.METRIC_NAMES.StreamConnectionsOpened]: '{connection}',
+    [exports.METRIC_NAMES.StreamConnectionsClosed]: '{connection}',
+    [exports.METRIC_NAMES.MeshNodeChannelSelectionFailures]: '{failure}',
+    [exports.METRIC_NAMES.MeshNodeRequestTimeouts]: '{request}',
+    [exports.METRIC_NAMES.MeshNodeMessagesDropped]: '{message}',
+    [exports.METRIC_NAMES.RelocationStarted]: '{relocation}',
+    [exports.METRIC_NAMES.RelocationCompleted]: '{relocation}',
+    [exports.METRIC_NAMES.RelocationCutoverTimeout]: '{fallback}',
+    [exports.METRIC_NAMES.InstanceSpotActivations]: '{activation}',
+    [exports.METRIC_NAMES.InstanceSpotClaimConflicts]: '{claim}',
+    [exports.METRIC_NAMES.InstanceSpotTakeovers]: '{takeover}',
+    [exports.METRIC_NAMES.LocationStoreErrors]: '{error}',
+    [exports.METRIC_NAMES.LocationOwnerLeaseRenewFailures]: '{failure}',
+    [exports.METRIC_NAMES.ObservabilityEventsOverflow]: '{event}',
+    [exports.METRIC_NAMES.HostRelocationBlocked]: '{operation}',
+    [exports.METRIC_NAMES.HostShutdownForced]: '{operation}'
 });
 const UP_DOWN_COUNTERS = Object.freeze({
-    'zlink.stream.connections.active': '{connection}',
-    'zlink.spot.count': '{spot}',
-    'zlink.actor.count': '{actor}',
-    'zlink.mesh_node.requests.inflight': '{request}'
+    [exports.METRIC_NAMES.StreamConnectionsActive]: '{connection}',
+    [exports.METRIC_NAMES.SpotCount]: '{spot}',
+    [exports.METRIC_NAMES.ActorCount]: '{actor}',
+    [exports.METRIC_NAMES.MeshNodeRequestsInflight]: '{request}'
 });
 const HISTOGRAMS = Object.freeze({
-    'zlink.mesh_node.request.duration': 's',
-    'zlink.relocation.duration': 's',
-    'zlink.relocation.bytes': 'By',
-    'zlink.relocation.interruption': 's',
-    'zlink.relocation.target_resume': 's',
-    'zlink.relocation.route_convergence': 's',
-    'zlink.instance_spot.activation.duration': 's',
-    'zlink.location.owner_lease.renew.lateness': 's',
-    'zlink.host.relocation.duration': 's',
-    'zlink.host.shutdown.duration': 's'
+    [exports.METRIC_NAMES.MeshNodeRequestDuration]: 's',
+    [exports.METRIC_NAMES.RelocationDuration]: 's',
+    [exports.METRIC_NAMES.RelocationBytes]: 'By',
+    [exports.METRIC_NAMES.RelocationInterruption]: 's',
+    [exports.METRIC_NAMES.RelocationTargetResume]: 's',
+    [exports.METRIC_NAMES.RelocationRouteConvergence]: 's',
+    [exports.METRIC_NAMES.InstanceSpotActivationDuration]: 's',
+    [exports.METRIC_NAMES.LocationOwnerLeaseRenewLateness]: 's',
+    [exports.METRIC_NAMES.HostRelocationDuration]: 's',
+    [exports.METRIC_NAMES.HostShutdownDuration]: 's'
 });
 const OBSERVABLE_GAUGES = Object.freeze({
-    'zlink.mesh_node.peers.configured': '{peer}',
-    'zlink.mesh_node.peers.connected': '{peer}',
-    'zlink.mesh_node.peers.ready': '{peer}',
-    'zlink.mesh_node.channels.ready_members': '{member}',
-    'zlink.object.capacity.active': '{object}',
-    'zlink.object.capacity.reserved': '{object}',
-    'zlink.object.capacity.limit': '{object}',
-    'zlink.spot.type.capacity.active': '{spot}',
-    'zlink.spot.type.capacity.reserved': '{spot}',
-    'zlink.spot.type.capacity.limit': '{spot}',
-    'zlink.object.activation.active': '{activation}',
-    'zlink.object.activation.limit': '{activation}',
-    'zlink.instance_spot.pending.messages': '{message}',
-    'zlink.instance_spot.pending.bytes': 'By',
-    'zlink.host.state': '{runtime}',
-    'zlink.host.core_hwm.effective_budget': 'By',
-    'zlink.host.core_hwm.applied': 'By',
-    'zlink.host.core_hwm.accounted': 'By',
-    'zlink.host.core_hwm.completion_accounted': 'By',
-    'zlink.host.core_hwm.blocked_ratio': '{ppm}',
-    'zlink.host.application_job_queue.limit': '{job}',
-    'zlink.host.application_job_queue.jobs': '{job}',
-    'zlink.host.application_job_queue.capacity_waiters': '{waiter}',
-    'zlink.host.application_job_queue.pressure_state': '{state}',
-    'zlink.host.application_job_queue.pause_duration': 's'
+    [exports.METRIC_NAMES.MeshNodePeersConfigured]: '{peer}',
+    [exports.METRIC_NAMES.MeshNodePeersConnected]: '{peer}',
+    [exports.METRIC_NAMES.MeshNodePeersReady]: '{peer}',
+    [exports.METRIC_NAMES.MeshNodeChannelsReadyMembers]: '{member}',
+    [exports.METRIC_NAMES.ObjectCapacityActive]: '{object}',
+    [exports.METRIC_NAMES.ObjectCapacityReserved]: '{object}',
+    [exports.METRIC_NAMES.ObjectCapacityLimit]: '{object}',
+    [exports.METRIC_NAMES.SpotTypeCapacityActive]: '{spot}',
+    [exports.METRIC_NAMES.SpotTypeCapacityReserved]: '{spot}',
+    [exports.METRIC_NAMES.SpotTypeCapacityLimit]: '{spot}',
+    [exports.METRIC_NAMES.ObjectActivationActive]: '{activation}',
+    [exports.METRIC_NAMES.ObjectActivationLimit]: '{activation}',
+    [exports.METRIC_NAMES.InstanceSpotPendingMessages]: '{message}',
+    [exports.METRIC_NAMES.InstanceSpotPendingBytes]: 'By',
+    [exports.METRIC_NAMES.HostState]: '{runtime}',
+    [exports.METRIC_NAMES.HostCoreHwmEffectiveBudget]: 'By',
+    [exports.METRIC_NAMES.HostCoreHwmApplied]: 'By',
+    [exports.METRIC_NAMES.HostCoreHwmAccounted]: 'By',
+    [exports.METRIC_NAMES.HostCoreHwmCompletionAccounted]: 'By',
+    [exports.METRIC_NAMES.HostCoreHwmBlockedRatio]: '{ppm}',
+    [exports.METRIC_NAMES.HostApplicationJobQueueLimit]: '{job}',
+    [exports.METRIC_NAMES.HostApplicationJobQueueJobs]: '{job}',
+    [exports.METRIC_NAMES.HostApplicationJobQueueCapacityWaiters]: '{waiter}',
+    [exports.METRIC_NAMES.HostApplicationJobQueuePressureState]: '{state}',
+    [exports.METRIC_NAMES.HostApplicationJobQueuePauseDuration]: 's'
 });
 const OBSERVABLE_COUNTERS = Object.freeze({
-    'zlink.host.application_job_queue.capacity_waits': '{wait}',
-    'zlink.host.application_job_queue.capacity_wait_duration': 's',
-    'zlink.host.application_job_queue.pressure_transitions': '{transition}',
-    'zlink.host.application_job_queue.flow_state_config_failures': '{failure}'
+    [exports.METRIC_NAMES.HostApplicationJobQueueCapacityWaits]: '{wait}',
+    [exports.METRIC_NAMES.HostApplicationJobQueueCapacityWaitDuration]: 's',
+    [exports.METRIC_NAMES.HostApplicationJobQueuePressureTransitions]: '{transition}',
+    [exports.METRIC_NAMES.HostApplicationJobQueueFlowStateConfigFailures]: '{failure}'
 });
 class MetricRegistry {
     counters = new Map();
@@ -100,10 +163,10 @@ class MetricRegistry {
         }
     }
     observe(name, result) {
-        if (name === 'zlink.host.application_job_queue.pressure_state' ||
-            name === 'zlink.host.application_job_queue.pressure_transitions' ||
-            name === 'zlink.host.application_job_queue.pause_duration' ||
-            name === 'zlink.host.application_job_queue.flow_state_config_failures') {
+        if (name === exports.METRIC_NAMES.HostApplicationJobQueuePressureState ||
+            name === exports.METRIC_NAMES.HostApplicationJobQueuePressureTransitions ||
+            name === exports.METRIC_NAMES.HostApplicationJobQueuePauseDuration ||
+            name === exports.METRIC_NAMES.HostApplicationJobQueueFlowStateConfigFailures) {
             for (const provider of this.applicationJobQueuePressures) {
                 try {
                     this.observeApplicationJobQueuePressure(name, provider(), result);
@@ -126,7 +189,7 @@ class MetricRegistry {
             }
             return;
         }
-        if (name === 'zlink.host.state') {
+        if (name === exports.METRIC_NAMES.HostState) {
             for (const provider of this.hostStates) {
                 try {
                     result.observe(1, { state: provider() });
@@ -150,70 +213,70 @@ class MetricRegistry {
         }
     }
     observeApplicationJobQueuePressure(name, snapshot, result) {
-        if (name === 'zlink.host.application_job_queue.pressure_state') {
+        if (name === exports.METRIC_NAMES.HostApplicationJobQueuePressureState) {
             result.observe(1, { state: snapshot.pressureState });
         }
-        else if (name === 'zlink.host.application_job_queue.pressure_transitions') {
+        else if (name === exports.METRIC_NAMES.HostApplicationJobQueuePressureTransitions) {
             result.observe(metricNumber(snapshot.runningTransitionCount), { state: 'running' });
             result.observe(metricNumber(snapshot.pausedTransitionCount), { state: 'paused' });
         }
-        else if (name === 'zlink.host.application_job_queue.pause_duration') {
+        else if (name === exports.METRIC_NAMES.HostApplicationJobQueuePauseDuration) {
             result.observe(nonNegative(snapshot.currentPauseDurationSeconds), { state: 'current' });
             result.observe(nonNegative(snapshot.cumulativePauseDurationSeconds), { state: 'cumulative' });
         }
-        else if (name === 'zlink.host.application_job_queue.flow_state_config_failures') {
+        else if (name === exports.METRIC_NAMES.HostApplicationJobQueueFlowStateConfigFailures) {
             result.observe(metricNumber(snapshot.flowStateConfigFailureCount));
         }
     }
     observeHostCapacity(name, snapshot, result) {
         const core = snapshot.coreHwm;
         const jobs = snapshot.applicationJobQueue;
-        if (name === 'zlink.host.core_hwm.effective_budget') {
+        if (name === exports.METRIC_NAMES.HostCoreHwmEffectiveBudget) {
             result.observe(metricNumber(core.effectiveBudgetBytes));
         }
-        else if (name === 'zlink.host.core_hwm.applied') {
+        else if (name === exports.METRIC_NAMES.HostCoreHwmApplied) {
             result.observe(metricNumber(core.totalAppliedHwmBytes));
         }
-        else if (name === 'zlink.host.core_hwm.accounted') {
+        else if (name === exports.METRIC_NAMES.HostCoreHwmAccounted) {
             result.observe(metricNumber(core.currentAccountedBytes), { state: 'current' });
             result.observe(metricNumber(core.peakAccountedBytes), { state: 'peak' });
         }
-        else if (name === 'zlink.host.core_hwm.completion_accounted') {
+        else if (name === exports.METRIC_NAMES.HostCoreHwmCompletionAccounted) {
             result.observe(metricNumber(core.completionCurrentAccountedBytes), { state: 'current' });
             result.observe(metricNumber(core.completionPeakAccountedBytes), { state: 'peak' });
         }
-        else if (name === 'zlink.host.core_hwm.blocked_ratio') {
+        else if (name === exports.METRIC_NAMES.HostCoreHwmBlockedRatio) {
             result.observe(metricNumber(core.blockedRatioPpm));
         }
-        else if (name === 'zlink.host.application_job_queue.limit') {
+        else if (name === exports.METRIC_NAMES.HostApplicationJobQueueLimit) {
             result.observe(metricNumber(jobs.effectiveMaxQueuedApplicationJobs));
         }
-        else if (name === 'zlink.host.application_job_queue.jobs') {
+        else if (name === exports.METRIC_NAMES.HostApplicationJobQueueJobs) {
             result.observe(metricNumber(jobs.reservedSupplyPermits), { state: 'reserved' });
             result.observe(metricNumber(jobs.queuedApplicationJobs), { state: 'queued' });
             result.observe(metricNumber(jobs.permitsInUse), { state: 'in_use' });
             result.observe(metricNumber(jobs.peakPermitsInUse), { state: 'peak' });
         }
-        else if (name === 'zlink.host.application_job_queue.capacity_waiters') {
+        else if (name === exports.METRIC_NAMES.HostApplicationJobQueueCapacityWaiters) {
             result.observe(metricNumber(jobs.capacityWaiters));
         }
-        else if (name === 'zlink.host.application_job_queue.capacity_waits') {
+        else if (name === exports.METRIC_NAMES.HostApplicationJobQueueCapacityWaits) {
             result.observe(metricNumber(jobs.capacityWaitCount));
         }
-        else if (name === 'zlink.host.application_job_queue.capacity_wait_duration') {
+        else if (name === exports.METRIC_NAMES.HostApplicationJobQueueCapacityWaitDuration) {
             result.observe(nonNegative(jobs.capacityWaitDurationSeconds));
         }
     }
     observeMesh(name, snapshot, result) {
         const mesh = { mesh_name: snapshot.meshName };
         const peer = { ...mesh, source: snapshot.source };
-        if (name === 'zlink.mesh_node.peers.configured')
+        if (name === exports.METRIC_NAMES.MeshNodePeersConfigured)
             result.observe(nonNegative(snapshot.configuredPeers), peer);
-        else if (name === 'zlink.mesh_node.peers.connected')
+        else if (name === exports.METRIC_NAMES.MeshNodePeersConnected)
             result.observe(nonNegative(snapshot.connectedPeers), peer);
-        else if (name === 'zlink.mesh_node.peers.ready')
+        else if (name === exports.METRIC_NAMES.MeshNodePeersReady)
             result.observe(nonNegative(snapshot.readyPeers), peer);
-        else if (name === 'zlink.mesh_node.channels.ready_members') {
+        else if (name === exports.METRIC_NAMES.MeshNodeChannelsReadyMembers) {
             for (const channel of snapshot.channels) {
                 result.observe(nonNegative(channel.readyMembers), {
                     ...mesh,
@@ -242,13 +305,13 @@ class MetricRegistry {
                 });
             }
         }
-        else if (name === 'zlink.object.activation.active') {
+        else if (name === exports.METRIC_NAMES.ObjectActivationActive) {
             result.observe(nonNegative(snapshot.activation.active), mesh);
         }
-        else if (name === 'zlink.object.activation.limit') {
+        else if (name === exports.METRIC_NAMES.ObjectActivationLimit) {
             result.observe(nonNegative(snapshot.activation.limit), mesh);
         }
-        else if (name === 'zlink.instance_spot.pending.messages') {
+        else if (name === exports.METRIC_NAMES.InstanceSpotPendingMessages) {
             for (const instance of snapshot.instanceSpots) {
                 result.observe(nonNegative(instance.pendingMessages), {
                     ...mesh,
@@ -256,7 +319,7 @@ class MetricRegistry {
                 });
             }
         }
-        else if (name === 'zlink.instance_spot.pending.bytes') {
+        else if (name === exports.METRIC_NAMES.InstanceSpotPendingBytes) {
             for (const instance of snapshot.instanceSpots) {
                 result.observe(nonNegative(instance.pendingBytes), {
                     ...mesh,
@@ -311,29 +374,29 @@ class ZLinkRuntimeMetrics {
         return new ZLinkRequestMetricOperation(this, meshName, surface);
     }
     recordLocationStoreError(operation) {
-        this.count('zlink.location.store.errors', 1, { operation });
+        this.count(exports.METRIC_NAMES.LocationStoreErrors, 1, { operation });
     }
     recordOwnerLeaseRenewFailure(scopeKind, scopeName) {
-        this.count('zlink.location.owner_lease.renew.failures', 1, {
+        this.count(exports.METRIC_NAMES.LocationOwnerLeaseRenewFailures, 1, {
             scope_kind: scopeKind,
             scope_name: scopeName
         });
     }
     recordOwnerLeaseRenewLateness(seconds, scopeKind, scopeName) {
-        this.duration('zlink.location.owner_lease.renew.lateness', seconds, {
+        this.duration(exports.METRIC_NAMES.LocationOwnerLeaseRenewLateness, seconds, {
             scope_kind: scopeKind,
             scope_name: scopeName
         });
     }
     recordChannelSelectionFailure(meshName, channelName, reason) {
-        this.count('zlink.mesh_node.channel.selection_failures', 1, {
+        this.count(exports.METRIC_NAMES.MeshNodeChannelSelectionFailures, 1, {
             mesh_name: meshName,
             channel_name: channelName,
             reason
         });
     }
     recordMessageDropped(meshName, surface, messageKind, reason) {
-        this.count('zlink.mesh_node.messages.dropped', 1, {
+        this.count(exports.METRIC_NAMES.MeshNodeMessagesDropped, 1, {
             mesh_name: meshName,
             surface,
             message_kind: messageKind,
@@ -353,8 +416,8 @@ class ZLinkRuntimeMetrics {
                     instance_spot_type: instanceSpotType,
                     outcome
                 };
-                this.count('zlink.instance_spot.activations', 1, attributes);
-                this.duration('zlink.instance_spot.activation.duration', Number(process.hrtime.bigint() - started) / 1e9, attributes);
+                this.count(exports.METRIC_NAMES.InstanceSpotActivations, 1, attributes);
+                this.duration(exports.METRIC_NAMES.InstanceSpotActivationDuration, Number(process.hrtime.bigint() - started) / exports.NANOSECONDS_PER_SECOND, attributes);
             }
         };
     }
@@ -362,32 +425,32 @@ class ZLinkRuntimeMetrics {
         const started = process.hrtime.bigint();
         const startAttributes = { mesh_name: meshName, object_kind: objectKind, policy };
         let completed = false;
-        this.count('zlink.relocation.started', 1, startAttributes);
+        this.count(exports.METRIC_NAMES.RelocationStarted, 1, startAttributes);
         return {
             recordBytes: (bytes) => {
                 if (completed || bytes < 0)
                     return;
-                this.histogram('zlink.relocation.bytes', bytes, 'By', startAttributes);
+                this.histogram(exports.METRIC_NAMES.RelocationBytes, bytes, 'By', startAttributes);
             },
             complete: (outcome) => {
                 if (completed)
                     return;
                 completed = true;
                 const terminal = { ...startAttributes, outcome };
-                this.count('zlink.relocation.completed', 1, terminal);
-                this.duration('zlink.relocation.duration', Number(process.hrtime.bigint() - started) / 1e9, terminal);
+                this.count(exports.METRIC_NAMES.RelocationCompleted, 1, terminal);
+                this.duration(exports.METRIC_NAMES.RelocationDuration, Number(process.hrtime.bigint() - started) / exports.NANOSECONDS_PER_SECOND, terminal);
             }
         };
     }
     recordInstanceSpotClaimConflict(meshName, instanceSpotType, reason) {
-        this.count('zlink.instance_spot.claim.conflicts', 1, {
+        this.count(exports.METRIC_NAMES.InstanceSpotClaimConflicts, 1, {
             mesh_name: meshName,
             instance_spot_type: instanceSpotType,
             reason
         });
     }
     recordInstanceSpotTakeover(meshName, instanceSpotType, outcome) {
-        this.count('zlink.instance_spot.takeovers', 1, {
+        this.count(exports.METRIC_NAMES.InstanceSpotTakeovers, 1, {
             mesh_name: meshName,
             instance_spot_type: instanceSpotType,
             outcome
@@ -408,17 +471,17 @@ class ZLinkRequestMetricOperation {
         this.metrics = metrics;
         this.meshName = meshName;
         this.surface = surface;
-        metrics.change('zlink.mesh_node.requests.inflight', 1, this.baseAttributes());
+        metrics.change(exports.METRIC_NAMES.MeshNodeRequestsInflight, 1, this.baseAttributes());
     }
     complete(outcome) {
         if (this.completed)
             return;
         this.completed = true;
         const attributes = this.baseAttributes();
-        this.metrics.change('zlink.mesh_node.requests.inflight', -1, attributes);
-        this.metrics.duration('zlink.mesh_node.request.duration', Number(process.hrtime.bigint() - this.started) / 1e9, { ...attributes, outcome });
+        this.metrics.change(exports.METRIC_NAMES.MeshNodeRequestsInflight, -1, attributes);
+        this.metrics.duration(exports.METRIC_NAMES.MeshNodeRequestDuration, Number(process.hrtime.bigint() - this.started) / exports.NANOSECONDS_PER_SECOND, { ...attributes, outcome });
         if (outcome === 'timed_out') {
-            this.metrics.count('zlink.mesh_node.request.timeouts', 1, attributes);
+            this.metrics.count(exports.METRIC_NAMES.MeshNodeRequestTimeouts, 1, attributes);
         }
     }
     baseAttributes() {

package/dist/runtime/diagnostics/runtime-observation-queue.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeEventQueue = exports.ZLINK_SIGNED_OBSERVATION_LOSS_MAXIMUM = exports.ZLINK_DEFAULT_TERMINAL_OBSERVATION_CAPACITY = void 0;
 exports.saturatingObservationLossIncrement = saturatingObservationLossIncrement;
+const admission_1 = require("../admission");
 exports.ZLINK_DEFAULT_TERMINAL_OBSERVATION_CAPACITY = 64;
 exports.ZLINK_SIGNED_OBSERVATION_LOSS_MAXIMUM = 9223372036854775807n;
 const DEFAULT_OBSERVATION_SOURCE = Symbol('zlink.runtime-observation.default-source');
@@ -263,7 +264,7 @@ class RuntimeEventQueue {
             this.terminalFifo.length = 0;
             this.terminalHead = 0;
         }
-        else if (this.terminalHead >= 1024 && this.terminalHead * 2 >= this.terminalFifo.length) {
+        else if ((0, admission_1.shouldCompactBackingArray)(this.terminalHead, this.terminalFifo.length)) {
             this.terminalFifo.splice(0, this.terminalHead);
             this.terminalHead = 0;
         }
@@ -304,7 +305,7 @@ class RuntimeEventQueue {
             this.waiters.length = 0;
             this.waitersHead = 0;
         }
-        else if (this.waitersHead >= 1024 && this.waitersHead * 2 >= this.waiters.length) {
+        else if ((0, admission_1.shouldCompactBackingArray)(this.waitersHead, this.waiters.length)) {
             this.waiters.splice(0, this.waitersHead);
             this.waitersHead = 0;
         }