@zlink-systems/framework 0.29.1 → 0.30.0

package/src/runtime/backend/raw-binding-port.ts

@@ -1,3 +1,10 @@
+import type { SubmitResult } from './runtime-values';
+
+export interface ZLinkRawSendSubmission {
+  readonly result: typeof SubmitResult.Ok | typeof SubmitResult.Backpressured;
+  readonly admitted: Promise<void>;
+}
+
 export interface ZLinkRawReceivedRecord {
   readonly sourceRid: string;
   readonly sourceRoute: Uint8Array;
@@ -31,7 +38,6 @@ export interface ZLinkRawSocketPort {
   unbind(endpoint: string): void;
   connect(endpoint: string): void;
   disconnect(endpoint: string): void;
-  setReceiveFlowState(state: 'running' | 'paused'): void;
   monitor(): ZLinkRawMonitorPort;
   close(): void;
 }
@@ -49,6 +55,9 @@ export interface ZLinkRawRouterRoute {
 }
 
 export interface ZLinkRawRouterPort extends ZLinkRawSocketPort {
+  setReceiveFlowState(state: 'running' | 'paused'): void;
+  /** Reports Core submit synchronously; admitted observes only pending admission. */
+  submitSend(targetRid: string, parts: readonly Uint8Array[]): ZLinkRawSendSubmission;
   disconnectRid?(routingId: string): void;
   localEndpoint(): string;
   setRoutingId(routingId: string): void;
@@ -57,7 +66,8 @@ export interface ZLinkRawRouterPort extends ZLinkRawSocketPort {
   request(
     targetRid: string,
     parts: readonly Uint8Array[],
-    timeoutMs: number
+    timeoutMs: number,
+    recordReceived?: () => void
   ): Promise<readonly Buffer[]>;
   receive(dontWait?: boolean): ZLinkRawReceivedRecord | undefined;
   /** The selected route of every RID. The socket's one route observer calls it. */

package/src/runtime/channels/channel-receive-loops.ts

@@ -359,7 +359,7 @@ export class ZLinkChannelReceiveLoop {
 
   private async acquirePermit(signal: AbortSignal): Promise<ApplicationJobQueuePermit | undefined> {
     try {
-      return await this.applicationJobQueue.acquire(signal);
+      return await this.applicationJobQueue.acquire(signal, 'remote');
     } catch (error) {
       if (this.isStopped() || signal.aborted) return undefined;
       throw error;
@@ -585,7 +585,7 @@ export class ZLinkSubscriberReceiveLoop {
 
   private async acquirePermit(signal: AbortSignal): Promise<ApplicationJobQueuePermit | undefined> {
     try {
-      return await this.applicationJobQueue.acquire(signal);
+      return await this.applicationJobQueue.acquire(signal, 'remote');
     } catch (error) {
       if (this.isStopped() || signal.aborted) return undefined;
       throw error;
@@ -795,7 +795,7 @@ export class ZLinkRouteReceiveLoop {
 
   private async acquirePermit(signal: AbortSignal): Promise<ApplicationJobQueuePermit | undefined> {
     try {
-      return await this.applicationJobQueue.acquire(signal);
+      return await this.applicationJobQueue.acquire(signal, 'remote');
     } catch (error) {
       if (this.isStopped() || signal.aborted) return undefined;
       throw error;

package/src/runtime/channels/channel-runtime-lifecycle.ts

@@ -551,13 +551,19 @@ export class ZLinkChannelRuntimeLifecycle {
         unhandled: this.options.registration.dispatch?.unhandled
       });
       const spotRouteBridge = this.createSpotRouteBridgeForRouter(channelName, router);
+      const serverPeers = this.options.sockets.clientServerServerPeersForChannel(channelName);
       const loop = new ZLinkChannelReceiveLoop(
         channelName,
         router,
         dispatcher,
         spotRouteBridge,
         (received, socket) =>
-          this.options.sockets.tryHandleClientServerControl(channelName, received, socket),
+          this.options.sockets.tryHandleClientServerControl(
+            channelName,
+            received,
+            socket,
+            serverPeers
+          ),
         this.options.adapter.createReadablePoller(router),
         this.options.applicationJobQueue,
         (error) =>

package/src/runtime/channels/channel-socket-registry.ts

@@ -1,6 +1,7 @@
 import { RuntimeDisposal } from '../disposal';
 import { UINT64_MAX } from '@zlink-systems/stream-wire';
 import { randomBytes, randomUUID } from 'node:crypto';
+import { ReceiveFlowState } from '@zlink-systems/zlink';
 import {
   ZLinkFrameworkRuntimeState,
   type RoutingId,
@@ -41,6 +42,7 @@ import { ZLinkListenerRecords } from '../foundation/listener-records';
 import { discoveryAvailabilityForRuntimeState } from '../foundation/runtime-state-projections';
 import { ServiceDiscoveryRegistry } from '../foundation/service-discovery-registry';
 import {
+  ServiceLivenessConnection,
   DEFAULT_SERVICE_PEER_TIMEOUT_MS,
   DEFAULT_SERVICE_PROBE_INTERVAL_MS
 } from '../foundation/service-liveness-registry';
@@ -101,9 +103,7 @@ interface ClientServerPhysicalConnection {
   physicalConnectionId: symbol;
   readyConnectionId?: string;
   admittedDescriptor?: ClientServerDiscoveryDescriptor;
-  nextProbeAt?: number;
-  deadlineAt?: number;
-  outstandingProbeId?: bigint;
+  liveness?: ServiceLivenessConnection;
   admissionAttempt?: symbol;
 }
 
@@ -112,6 +112,13 @@ export interface ZLinkFanoutConnectionCallbacks {
   readonly onTerminated: (reason: 'disconnect' | 'deadline' | 'protocol') => void;
 }
 
+interface ClientServerServerPeer {
+  readonly channelName: string;
+  readonly routingId: RoutingId;
+  readonly normalizedEffectiveMaxMessageBytes: number;
+  readonly liveness: ServiceLivenessConnection;
+}
+
 interface FanoutPublisherConnection {
   readonly channelName: string;
   readonly endpoint: string;
@@ -124,8 +131,6 @@ interface FanoutPublisherConnection {
   deadlineAt?: number;
 }
 
-type ReceiveFlowSocket = ZLinkBackendDealerSocket | ZLinkBackendRouterSocket;
-
 export class ZLinkChannelSocketRegistry {
   private readonly clientDealers = new Map<string, ZLinkBackendDealerSocket>();
   private readonly channelRouters = new Map<string, ZLinkBackendRouterSocket>();
@@ -155,18 +160,9 @@ export class ZLinkChannelSocketRegistry {
   >();
   private readonly clientServerPublicWeights = new Map<string, number>();
   private readonly routeMeshPublicWeights = new Map<string, number>();
-  private readonly clientServerAdmittedClients = new Map<string, Set<RoutingId>>();
   private readonly clientServerServerPeers = new Map<
     string,
-    {
-      readonly channelName: string;
-      readonly routingId: RoutingId;
-      readonly physicalConnectionId: symbol;
-      readonly normalizedEffectiveMaxMessageBytes: number;
-      nextProbeAt: number;
-      deadlineAt: number;
-      outstandingProbeId?: bigint;
-    }
+    Map<RoutingId, ClientServerServerPeer>
   >();
   private readonly disposal = new RuntimeDisposal();
   private readonly ownedResources = new Set<
@@ -226,9 +222,7 @@ export class ZLinkChannelSocketRegistry {
       ...this.publishers.values(),
       ...this.routeRouters.values()
     ];
-    for (const socket of new Set<ReceiveFlowSocket>([
-      ...this.clientDealers.values(),
-      ...clientServerConnections.map((value) => value.dealer),
+    for (const socket of new Set<ZLinkBackendRouterSocket>([
       ...this.channelRouters.values(),
       ...this.routeRouters.values()
     ]))
@@ -237,7 +231,7 @@ export class ZLinkChannelSocketRegistry {
     this.clientServerServerDescriptors.clear();
     this.clientServerPublicWeights.clear();
     this.routeMeshPublicWeights.clear();
-    this.clientServerAdmittedClients.clear();
+    for (const peers of this.clientServerServerPeers.values()) peers.clear();
     this.clientServerServerPeers.clear();
     this.clientServerMonitorHandlers.clear();
     this.fanoutMonitorHandlers.clear();
@@ -294,7 +288,6 @@ export class ZLinkChannelSocketRegistry {
 
     const dealer = this.adapter.createDealerSocket(this.context);
     this.clientDealers.set(channelName, dealer);
-    this.registerReceiveFlowSocket(dealer);
     dealer.setChannelName(channelName);
     if (channel?.routingId !== undefined && channel.routingId.length > 0) {
       dealer.setRoutingId(deriveRoutingId(channel.routingId, 'dealer'));
@@ -350,8 +343,7 @@ export class ZLinkChannelSocketRegistry {
         )
           return;
         const routingId = String(event.routingId);
-        this.clientServerServerPeers.delete(clientServerServerPeerKey(channelName, routingId));
-        this.clientServerAdmittedClients.get(channelName)?.delete(routingId);
+        this.clientServerServerPeers.get(channelName)?.delete(routingId);
       });
     }
     const endpoint = advertisedEndpoint(
@@ -450,7 +442,6 @@ export class ZLinkChannelSocketRegistry {
     )[] = [dealer];
     try {
       this.clientServerConnections.set(connectionId, connection);
-      this.registerReceiveFlowSocket(dealer);
       dealer.setChannelName(channelName);
       dealer.setRoutingId(`cs-client-${randomUUID()}`);
       applySocketConfig(dealer, {
@@ -501,7 +492,6 @@ export class ZLinkChannelSocketRegistry {
       return dealer;
     } catch (error) {
       this.clientServerConnections.delete(connectionId);
-      this.unregisterReceiveFlowSocket(dealer);
       void Promise.allSettled(
         created.map(async (resource) => {
           await resource.dispose();
@@ -561,7 +551,6 @@ export class ZLinkChannelSocketRegistry {
     } catch {
       // The socket close below releases an endpoint that is already disconnected.
     }
-    this.unregisterReceiveFlowSocket(current.dealer);
     if (current.readablePoller !== undefined) {
       current.readablePoller.dispose();
       this.ownedResources.delete(current.readablePoller);
@@ -623,9 +612,8 @@ export class ZLinkChannelSocketRegistry {
     const admitted = this.clientServerDiscovery.admitClientServer(descriptor, connectionId);
     if (admitted) {
       const now = performance.now();
-      connection.nextProbeAt = now + CLIENT_SERVER_PROBE_INTERVAL_MS;
-      connection.deadlineAt = now + CLIENT_SERVER_PEER_DEADLINE_MS;
-      connection.outstandingProbeId = undefined;
+      connection.liveness = new ServiceLivenessConnection(connectionId, now);
+      connection.dealer.receiveAdmission = connection.liveness;
       this.clientServerReadyIdentities.set(connectionId, {
         channelName: descriptor.channelName,
         serverRoutingId: descriptor.serverRoutingId,
@@ -653,9 +641,8 @@ export class ZLinkChannelSocketRegistry {
       const connection = this.clientServerConnections.get(connectionId);
       if (connection?.readyConnectionId === connectionId) {
         connection.readyConnectionId = undefined;
-        connection.deadlineAt = undefined;
-        connection.nextProbeAt = undefined;
-        connection.outstandingProbeId = undefined;
+        connection.liveness = undefined;
+        connection.dealer.receiveAdmission = undefined;
       }
     }
     this.notifyClientServerTopology(channelName);
@@ -898,6 +885,15 @@ export class ZLinkChannelSocketRegistry {
     for (const handler of this.clientServerMonitorHandlers.get(channelName) ?? []) handler();
   }
 
+  clientServerServerPeersForChannel(channelName: string): Map<RoutingId, ClientServerServerPeer> {
+    let peers = this.clientServerServerPeers.get(channelName);
+    if (peers === undefined) {
+      peers = new Map();
+      this.clientServerServerPeers.set(channelName, peers);
+    }
+    return peers;
+  }
+
   tryHandleClientServerControl(
     channelName: string,
     received: {
@@ -905,8 +901,12 @@ export class ZLinkChannelSocketRegistry {
       readonly replyToken: unknown | null;
       readonly routingId: unknown;
     },
-    router: ZLinkBackendRouterSocket
+    router: ZLinkBackendRouterSocket,
+    peers = this.clientServerServerPeersForChannel(channelName)
   ): boolean {
+    const routingId = String(received.routingId) as RoutingId;
+    const peer = peers.get(routingId);
+    peer?.liveness.recordReceived();
     if (received.parts.length === 0) return false;
     const first = received.parts[0];
     if (!isClientServerControlFrame(first.data())) return false;
@@ -924,18 +924,8 @@ export class ZLinkChannelSocketRegistry {
         received.parts.length === 1 &&
         received.replyToken === null
       ) {
-        if (
-          !this.acceptClientServerServerLivenessAck(
-            channelName,
-            String(received.routingId),
-            record.probeId
-          )
-        ) {
-          this.reportStaleClientServerLivenessAck(
-            channelName,
-            String(received.routingId),
-            record.probeId
-          );
+        if (!this.acceptClientServerServerLivenessAck(peer, record.probeId)) {
+          this.reportStaleClientServerLivenessAck(channelName, routingId, record.probeId);
         }
         return true;
       } else if (
@@ -960,7 +950,7 @@ export class ZLinkChannelSocketRegistry {
           reply = encodeClientServerAdmit(descriptor, normalizedEffectiveMaxMessageBytes);
           this.admitClientServerServerPeer(
             channelName,
-            String(received.routingId),
+            routingId,
             normalizedEffectiveMaxMessageBytes
           );
         }
@@ -971,7 +961,7 @@ export class ZLinkChannelSocketRegistry {
     if (received.replyToken !== null) {
       const message = RuntimeMessage.from(reply);
       try {
-        router.reply(received.routingId as RoutingId, received.replyToken, message);
+        router.reply(routingId, received.replyToken, message);
       } finally {
         message.close();
       }
@@ -987,34 +977,32 @@ export class ZLinkChannelSocketRegistry {
         (connection.aliases.values().next().value as string | undefined);
       if (connectionId === undefined) continue;
       this.drainClientServerControl(connectionId, connection);
-      if (connection.deadlineAt === undefined) continue;
-      if (nowMs >= connection.deadlineAt) {
+      if (connection.liveness === undefined) continue;
+      if (connection.liveness.isExpired(nowMs)) {
         this.restartClientServerAdmission(connectionId, connection);
         continue;
       }
-      if (connection.nextProbeAt === undefined || nowMs < connection.nextProbeAt) continue;
-      connection.nextProbeAt = nowMs + CLIENT_SERVER_PROBE_INTERVAL_MS;
-      const probeId = connection.outstandingProbeId ?? this.allocateClientServerProbeId();
-      connection.outstandingProbeId = probeId;
+      const probeId = connection.liveness.tryGetProbe(nowMs, () =>
+        this.allocateClientServerProbeId()
+      );
+      if (probeId === undefined) continue;
       this.requestClientServerLiveness(connectionId, connection, probeId);
     }
 
-    for (const [key, peer] of [...this.clientServerServerPeers]) {
-      if (nowMs >= peer.deadlineAt) {
-        this.clientServerServerPeers.delete(key);
-        this.clientServerAdmittedClients.get(peer.channelName)?.delete(peer.routingId);
-        try {
-          this.channelRouters.get(peer.channelName)?.disconnectPeer(peer.routingId);
-        } catch (error) {
-          this.oneWayFailureSink?.(error);
+    for (const peers of this.clientServerServerPeers.values()) {
+      for (const [routingId, peer] of peers) {
+        if (peer.liveness.isExpired(nowMs)) {
+          peers.delete(routingId);
+          try {
+            this.channelRouters.get(peer.channelName)?.disconnectPeer(peer.routingId);
+          } catch (error) {
+            this.oneWayFailureSink?.(error);
+          }
+          continue;
         }
-        continue;
+        const probeId = peer.liveness.tryGetProbe(nowMs, () => this.allocateClientServerProbeId());
+        if (probeId !== undefined) this.requestClientServerServerLiveness(peer, probeId);
       }
-      if (nowMs < peer.nextProbeAt) continue;
-      peer.nextProbeAt = nowMs + CLIENT_SERVER_PROBE_INTERVAL_MS;
-      const probeId = peer.outstandingProbeId ?? this.allocateClientServerProbeId();
-      peer.outstandingProbeId = probeId;
-      this.requestClientServerServerLiveness(peer, probeId);
     }
     this.tickFanoutLiveness(nowMs);
   }
@@ -1376,6 +1364,7 @@ export class ZLinkChannelSocketRegistry {
     connectionId: string,
     connection: ClientServerPhysicalConnection
   ): void {
+    const admission = connection.liveness;
     for (;;) {
       if (connection.readablePoller === undefined || !connection.readablePoller.wait(0)) return;
       const received = connection.dealer.recv(1);
@@ -1383,6 +1372,7 @@ export class ZLinkChannelSocketRegistry {
         connection.readablePoller.markDrained();
         return;
       }
+      admission?.recordReceived();
       try {
         if (received.parts.length !== 1 || !isClientServerControlFrame(received.parts[0]!.data())) {
           throw new ZLinkConfigurationException(
@@ -1534,24 +1524,18 @@ export class ZLinkChannelSocketRegistry {
       if (connection.readyConnectionId === connectionId) {
         connection.readyConnectionId = undefined;
       }
-      connection.deadlineAt = undefined;
-      connection.nextProbeAt = undefined;
-      connection.outstandingProbeId = undefined;
+      connection.liveness = undefined;
+      connection.dealer.receiveAdmission = undefined;
     }
     this.notifyClientServerTopology(identity.channelName);
   }
 
   private requestClientServerLiveness(
     connectionId: string,
-    connection: {
-      readonly channelName: string;
-      readonly dealer: ZLinkBackendDealerSocket;
-      readonly physicalConnectionId: symbol;
-      outstandingProbeId?: bigint;
-      deadlineAt?: number;
-    },
+    connection: ClientServerPhysicalConnection,
     probeId: bigint
   ): void {
+    const admission = connection.liveness;
     const message = RuntimeMessage.from(encodeClientServerLivenessProbe(probeId));
     void connection.dealer
       .request(message, CLIENT_SERVER_PEER_DEADLINE_MS)
@@ -1561,12 +1545,16 @@ export class ZLinkChannelSocketRegistry {
           if (
             current === undefined ||
             current.physicalConnectionId !== connection.physicalConnectionId ||
+            current.liveness !== admission ||
             parts.length !== 1
           )
             return;
           const record = decodeClientServerControl(parts[0]!.data());
           if (record.kind !== 'livenessAck') return;
-          if (current.outstandingProbeId !== probeId || record.probeId !== probeId) {
+          if (
+            admission === undefined ||
+            !admission.acknowledge(record.probeId, performance.now())
+          ) {
             this.reportStaleClientServerLivenessAck(
               connection.channelName,
               connectionId,
@@ -1574,8 +1562,6 @@ export class ZLinkChannelSocketRegistry {
             );
             return;
           }
-          current.outstandingProbeId = undefined;
-          current.deadlineAt = performance.now() + CLIENT_SERVER_PEER_DEADLINE_MS;
         } finally {
           closeMessages(parts);
         }
@@ -1589,36 +1575,20 @@ export class ZLinkChannelSocketRegistry {
     routingId: RoutingId,
     normalizedEffectiveMaxMessageBytes: number
   ): void {
-    const key = clientServerServerPeerKey(channelName, routingId);
-    const now = performance.now();
-    const peer = {
+    const peer: ClientServerServerPeer = {
       channelName,
       routingId,
-      physicalConnectionId: Symbol(key),
       normalizedEffectiveMaxMessageBytes,
-      nextProbeAt: now + CLIENT_SERVER_PROBE_INTERVAL_MS,
-      deadlineAt: now + CLIENT_SERVER_PEER_DEADLINE_MS
+      liveness: new ServiceLivenessConnection(
+        clientServerServerPeerKey(channelName, routingId),
+        performance.now()
+      )
     };
-    this.clientServerServerPeers.set(key, peer);
-    let clients = this.clientServerAdmittedClients.get(channelName);
-    if (clients === undefined) {
-      clients = new Set();
-      this.clientServerAdmittedClients.set(channelName, clients);
-    }
-    clients.add(routingId);
+    this.clientServerServerPeersForChannel(channelName).set(routingId, peer);
     this.ensureClientServerLivenessTimer();
   }
 
-  private requestClientServerServerLiveness(
-    peer: {
-      readonly channelName: string;
-      readonly routingId: RoutingId;
-      readonly physicalConnectionId: symbol;
-      outstandingProbeId?: bigint;
-      deadlineAt: number;
-    },
-    probeId: bigint
-  ): void {
+  private requestClientServerServerLiveness(peer: ClientServerServerPeer, probeId: bigint): void {
     const router = this.channelRouters.get(peer.channelName);
     if (router === undefined) return;
     const message = RuntimeMessage.from(encodeClientServerLivenessProbe(probeId));
@@ -1629,17 +1599,10 @@ export class ZLinkChannelSocketRegistry {
   }
 
   private acceptClientServerServerLivenessAck(
-    channelName: string,
-    routingId: RoutingId,
+    peer: ClientServerServerPeer | undefined,
     probeId: bigint
   ): boolean {
-    const peer = this.clientServerServerPeers.get(
-      clientServerServerPeerKey(channelName, routingId)
-    );
-    if (peer === undefined || peer.outstandingProbeId !== probeId) return false;
-    peer.outstandingProbeId = undefined;
-    peer.deadlineAt = performance.now() + CLIENT_SERVER_PEER_DEADLINE_MS;
-    return true;
+    return peer?.liveness.acknowledge(probeId, performance.now()) ?? false;
   }
 
   private reportStaleClientServerLivenessAck(
@@ -1661,23 +1624,15 @@ export class ZLinkChannelSocketRegistry {
     descriptor: ZLinkClientServerServerDescriptor
   ): void {
     const router = this.channelRouters.get(channelName);
-    const clients = this.clientServerAdmittedClients.get(channelName);
-    if (router === undefined || clients === undefined) return;
-    for (const routingId of [...clients]) {
-      const peer = this.clientServerServerPeers.get(
-        clientServerServerPeerKey(channelName, routingId)
-      );
-      if (peer === undefined) {
-        clients.delete(routingId);
-        continue;
-      }
+    const peers = this.clientServerServerPeers.get(channelName);
+    if (router === undefined || peers === undefined) return;
+    for (const [routingId, peer] of peers) {
       const message = RuntimeMessage.from(
         encodeClientServerUpdate(descriptor, peer.normalizedEffectiveMaxMessageBytes)
       );
       void router
         .send(routingId, message)
         .catch((error) => {
-          clients.delete(routingId);
           this.oneWayFailureSink?.(error);
         })
         .finally(() => message.close());
@@ -1786,15 +1741,18 @@ export class ZLinkChannelSocketRegistry {
     router.peerWeight = rawAvailabilityWeight(weight);
   }
 
-  private registerReceiveFlowSocket(socket: ReceiveFlowSocket): void {
+  private registerReceiveFlowSocket(socket: ZLinkBackendRouterSocket): void {
     this.applicationJobQueue?.registerReceiveFlowTarget(
       socket,
-      (state) => socket.setReceiveFlowState(state === 'paused' ? 1 : 0),
+      (state) =>
+        socket.setReceiveFlowState(
+          state === 'paused' ? ReceiveFlowState.PAUSED : ReceiveFlowState.RUNNING
+        ),
       this.oneWayFailureSink
     );
   }
 
-  private unregisterReceiveFlowSocket(socket: ReceiveFlowSocket): void {
+  private unregisterReceiveFlowSocket(socket: ZLinkBackendRouterSocket): void {
     this.applicationJobQueue?.unregisterReceiveFlowTarget(socket);
   }
 
@@ -1962,7 +1920,7 @@ function applyFanoutPublisherSocketOptions(
   channel: ZLinkChannelOptions
 ): void {
   publisher.noDrop = channel.noDrop ?? false;
-  publisher.sendTimeoutMs = configuredSendTimeoutMs(channel.publisher?.sendTimeoutMs);
+  publisher.sendTimeoutMs = channel.sendTimeoutMs ?? DEFAULT_SEND_TIMEOUT_MS;
 }
 
 function fanoutDiscoveryConnectionId(connectionId: string): string {
@@ -2022,7 +1980,3 @@ function applySocketConfig(
     socket.maxMessageSize = config.maxMessageSize;
   }
 }
-
-function configuredSendTimeoutMs(value: number | undefined): number {
-  return value ?? DEFAULT_SEND_TIMEOUT_MS;
-}

package/src/runtime/diagnostics/message-flow.ts

@@ -35,7 +35,7 @@ export const DEFAULT_ZLINK_DIAGNOSTICS: ZLinkDiagnosticsOptions = {
   includeMessageSizes: false
 };
 
-const telemetryLogger = openTelemetryLogs.getLogger('@zlink-systems/framework');
+export const telemetryLogger = openTelemetryLogs.getLogger('@zlink-systems/framework');
 const telemetryTracer = openTelemetryTrace.getTracer('@zlink-systems/framework');
 
 let diagnosticsGeneration = 0n;