@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/diagnostics/message-flow-delivery.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkMessageFlowDelivery = exports.TELEMETRY_STATE_BYTES = exports.TelemetryCounter = exports.TelemetryState = exports.TELEMETRY_WORKER_AVAILABLE = exports.MESSAGE_FLOW_PENDING_LIMIT = void 0;
+exports.openTelemetryLease = openTelemetryLease;
+exports.renewTelemetryLease = renewTelemetryLease;
+exports.messageFlowDelivery = messageFlowDelivery;
+exports.telemetryProviderFailureCount = telemetryProviderFailureCount;
+exports.retireTelemetryLease = retireTelemetryLease;
+const node_worker_threads_1 = require("node:worker_threads");
+// The process owner counts records until the worker takes them, including batches
+// already posted to its port. Only the worker decrements in-transit records.
+exports.MESSAGE_FLOW_PENDING_LIMIT = 8192;
+exports.TELEMETRY_WORKER_AVAILABLE = 'zlink.telemetry.available';
+var TelemetryState;
+(function (TelemetryState) {
+    TelemetryState[TelemetryState["Pending"] = 0] = "Pending";
+    TelemetryState[TelemetryState["Enabled"] = 1] = "Enabled";
+    TelemetryState[TelemetryState["Length"] = 2] = "Length";
+})(TelemetryState || (exports.TelemetryState = TelemetryState = {}));
+var TelemetryCounter;
+(function (TelemetryCounter) {
+    TelemetryCounter[TelemetryCounter["Overflow"] = 0] = "Overflow";
+    TelemetryCounter[TelemetryCounter["LoggerFailures"] = 1] = "LoggerFailures";
+    TelemetryCounter[TelemetryCounter["TraceFailures"] = 2] = "TraceFailures";
+    TelemetryCounter[TelemetryCounter["FallbackFailures"] = 3] = "FallbackFailures";
+    TelemetryCounter[TelemetryCounter["WorkerFailures"] = 4] = "WorkerFailures";
+    TelemetryCounter[TelemetryCounter["Length"] = 5] = "Length";
+})(TelemetryCounter || (exports.TelemetryCounter = TelemetryCounter = {}));
+exports.TELEMETRY_STATE_BYTES = Math.ceil((TelemetryState.Length * Int32Array.BYTES_PER_ELEMENT) / BigUint64Array.BYTES_PER_ELEMENT) * BigUint64Array.BYTES_PER_ELEMENT;
+function openTelemetryLease() {
+    return { retired: new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)) };
+}
+function renewTelemetryLease(lease) {
+    return lease === undefined || Atomics.load(lease.retired, 0) !== 0 ? openTelemetryLease() : lease;
+}
+let processOwner;
+function messageFlowDelivery() {
+    return (processOwner ??= new ZLinkMessageFlowDelivery());
+}
+function telemetryProviderFailureCount() {
+    return processOwner === undefined
+        ? 0
+        : Number(Atomics.load(processOwner.counters, TelemetryCounter.LoggerFailures) +
+            Atomics.load(processOwner.counters, TelemetryCounter.TraceFailures));
+}
+function retireTelemetryLease(lease) {
+    Atomics.store(lease.retired, 0, 1);
+    processOwner?.retire(lease);
+}
+class ZLinkMessageFlowDelivery {
+    sharedState = new SharedArrayBuffer(exports.TELEMETRY_STATE_BYTES + TelemetryCounter.Length * BigUint64Array.BYTES_PER_ELEMENT);
+    state = new Int32Array(this.sharedState, 0, TelemetryState.Length);
+    counters = new BigUint64Array(this.sharedState, exports.TELEMETRY_STATE_BYTES, TelemetryCounter.Length);
+    ready;
+    worker;
+    failure;
+    pending = [];
+    executing = false;
+    workerReady = false;
+    scheduled;
+    constructor() {
+        let published;
+        // A failed bootstrap leaves this incomplete. Runtime processing never waits
+        // for it, and no rejected promise can escape into the host process.
+        this.ready = new Promise((resolve) => {
+            published = resolve;
+        });
+        // NODE_OPTIONS preloads precede execArgv preloads. Keep both application
+        // lists intact and capture the public default provider before either list.
+        try {
+            const bootstrap = require.resolve('./message-flow-bootstrap').replace(/\\/g, '/');
+            this.worker = new node_worker_threads_1.Worker(require.resolve('./message-flow-worker'), {
+                workerData: this.state.buffer,
+                env: {
+                    ...process.env,
+                    NODE_OPTIONS: `--require "${bootstrap}" ${process.env.NODE_OPTIONS ?? ''}`
+                }
+            });
+            this.worker.once('error', (error) => this.workerFailed(error));
+            this.worker.once('exit', (code) => {
+                if (this.failure === undefined)
+                    this.workerFailed(new Error(`Telemetry worker exited with code ${code}.`));
+            });
+            this.worker.on('message', (message) => {
+                if (message !== exports.TELEMETRY_WORKER_AVAILABLE || this.failure !== undefined)
+                    return;
+                this.workerReady = true;
+                this.executing = false;
+                this.flush();
+                published();
+            });
+            this.worker.unref();
+        }
+        catch (error) {
+            this.workerFailed(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    workerFailed(error) {
+        if (this.failure !== undefined)
+            return;
+        this.failure = error;
+        Atomics.add(this.counters, TelemetryCounter.WorkerFailures, 1n);
+        Atomics.store(this.state, TelemetryState.Enabled, 0);
+        this.workerReady = false;
+        this.executing = false;
+        this.pending = [];
+        Atomics.store(this.state, TelemetryState.Pending, 0);
+    }
+    enabled() {
+        return Atomics.load(this.state, TelemetryState.Enabled) !== 0;
+    }
+    accepts(lease) {
+        return this.enabled() && Atomics.load(lease.retired, 0) === 0;
+    }
+    submit(lease, record) {
+        if (!this.accepts(lease))
+            return;
+        if (Atomics.load(this.state, TelemetryState.Pending) === exports.MESSAGE_FLOW_PENDING_LIMIT) {
+            Atomics.add(this.counters, TelemetryCounter.Overflow, 1n);
+            return;
+        }
+        Atomics.add(this.state, TelemetryState.Pending, 1);
+        this.pending.push({ lease: lease.retired.buffer, record });
+        if (this.workerReady && !this.executing && this.scheduled === undefined) {
+            this.scheduled = setImmediate(() => {
+                this.scheduled = undefined;
+                this.flush();
+            });
+            this.scheduled.unref();
+        }
+    }
+    retire(lease) {
+        const retained = this.pending.filter((item) => item.lease !== lease.retired.buffer);
+        Atomics.sub(this.state, TelemetryState.Pending, this.pending.length - retained.length);
+        this.pending = retained;
+    }
+    flush() {
+        if (this.worker === undefined ||
+            !this.workerReady ||
+            this.executing ||
+            this.pending.length === 0)
+            return;
+        const batch = this.pending;
+        this.pending = [];
+        this.executing = true;
+        this.worker.postMessage(batch);
+    }
+}
+exports.ZLinkMessageFlowDelivery = ZLinkMessageFlowDelivery;

package/dist/runtime/diagnostics/message-flow-record.d.ts

@@ -0,0 +1,50 @@
+import type { Attributes } from '@opentelemetry/api';
+import type { ZLinkMessageFlowLogMode } from '../../contracts';
+import { type ZLinkRuntimeMessageFlowEvent, type ZLinkRuntimeMessageFlowResult } from '../../contracts/Dispatch/ZLinkDispatchOptions';
+export declare const TELEMETRY_INSTRUMENTATION_NAME = "@zlink-systems/framework";
+export declare const MESSAGE_FLOW_EVENT_ID = "zlink.message_flow";
+export declare const DISPATCH_ERROR_EVENT_ID = "zlink.dispatch_error";
+export interface ZLinkTelemetryRecord {
+    readonly severity?: 'warning';
+    readonly eventId: typeof MESSAGE_FLOW_EVENT_ID | typeof DISPATCH_ERROR_EVENT_ID;
+    readonly timestamp: Date;
+    readonly phase?: string;
+    readonly outcome: ZLinkRuntimeMessageFlowResult;
+    readonly surface: 'node' | 'channel' | 'spot' | 'instance_spot' | 'actor' | 'stream' | 'actor_relocation' | 'classic_fanout';
+    readonly messageKind: 'request' | 'send' | 'response' | 'error' | 'control';
+    readonly reason?: string;
+    readonly action?: string;
+    readonly packetName?: string;
+    readonly channelName?: string;
+    readonly channelRouteKind?: 'route_mesh' | 'client_server';
+    readonly meshName?: string;
+    readonly topic?: string;
+    readonly correlationId?: string;
+    readonly sourceRid?: string;
+    readonly targetRid?: string;
+    readonly serverRid?: string;
+    readonly flowId?: string;
+    readonly flowOrigin?: string;
+    readonly spotId?: string;
+    readonly instanceSpotType?: string;
+    readonly activationState?: string;
+    readonly actorId?: string;
+    readonly streamSessionId?: string;
+    readonly commandId?: number;
+    readonly messageSizeBytes?: number;
+    readonly durationSeconds?: number;
+    readonly errorType?: string;
+    readonly errorMessage?: string;
+    readonly errorCauseType?: string;
+    readonly errorCauseMessage?: string;
+}
+export type MessageFlowInput = Omit<ZLinkRuntimeMessageFlowEvent, 'effectiveMode' | 'flowId' | 'flowOrigin'> & {
+    readonly severity?: 'warning';
+    readonly effectiveMode?: ZLinkMessageFlowLogMode;
+    readonly flowId?: string;
+    readonly flowOrigin?: import('../../contracts').ZLinkFlowOrigin;
+};
+export declare function toTelemetryRecord(flow: MessageFlowInput, messageSizeBytes: number | undefined, durationSeconds: number | undefined): ZLinkTelemetryRecord;
+export declare function traceAttributes(record: ZLinkTelemetryRecord): Attributes;
+export declare function structuredLogAttributes(record: ZLinkTelemetryRecord): Attributes;
+export declare function structuredLogBody(record: ZLinkTelemetryRecord): string;

package/dist/runtime/diagnostics/message-flow-record.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DISPATCH_ERROR_EVENT_ID = exports.MESSAGE_FLOW_EVENT_ID = exports.TELEMETRY_INSTRUMENTATION_NAME = void 0;
+exports.toTelemetryRecord = toTelemetryRecord;
+exports.traceAttributes = traceAttributes;
+exports.structuredLogAttributes = structuredLogAttributes;
+exports.structuredLogBody = structuredLogBody;
+const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
+const dispatch_error_details_1 = require("./dispatch-error-details");
+const flow_context_1 = require("./flow-context");
+exports.TELEMETRY_INSTRUMENTATION_NAME = '@zlink-systems/framework';
+exports.MESSAGE_FLOW_EVENT_ID = 'zlink.message_flow';
+exports.DISPATCH_ERROR_EVENT_ID = 'zlink.dispatch_error';
+function toTelemetryRecord(flow, messageSizeBytes, durationSeconds) {
+    return {
+        severity: flow.severity,
+        eventId: flow.outcome === ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error
+            ? exports.DISPATCH_ERROR_EVENT_ID
+            : exports.MESSAGE_FLOW_EVENT_ID,
+        timestamp: new Date(),
+        phase: messageFlowPhase(flow.outcome),
+        outcome: flow.result ?? messageFlowOutcome(flow.outcome),
+        surface: messageFlowSurface(flow.surface),
+        messageKind: messageFlowKind(flow.messageKind),
+        reason: flow.errorReason,
+        action: flow.errorAction,
+        packetName: flow.packetName,
+        channelName: flow.channelName,
+        channelRouteKind: flow.channelRouteKind ?? channelRouteKind(flow.surface),
+        meshName: flow.meshName,
+        topic: flow.topic,
+        correlationId: flow.correlationId,
+        sourceRid: flow.sourceRid,
+        targetRid: flow.targetRid,
+        serverRid: flow.serverRid,
+        flowId: flow.flowId,
+        flowOrigin: flow.flowOrigin === undefined ? undefined : flow_context_1.FLOW_ORIGIN_VALUES[flow.flowOrigin],
+        spotId: flow.spotId,
+        instanceSpotType: flow.instanceSpotType,
+        activationState: flow.activationState,
+        actorId: flow.actorId,
+        streamSessionId: flow.streamSessionId,
+        commandId: flow.commandId,
+        messageSizeBytes,
+        durationSeconds,
+        errorType: flow.errorType,
+        errorMessage: flow.errorMessage,
+        errorCauseType: flow.errorCauseType,
+        errorCauseMessage: boundedText(flow.errorCauseMessage)
+    };
+}
+function traceAttributes(record) {
+    const attributes = {};
+    for (const [name, value] of Object.entries(record)) {
+        if (value === undefined || name === 'timestamp' || name === 'severity')
+            continue;
+        attributes[toSnakeCase(name)] = value instanceof Date ? value.toISOString() : value;
+    }
+    return attributes;
+}
+function structuredLogAttributes(record) {
+    //  기록의 attribute 이름은 Message flow tracing 3.2가 고정한다. 로그 본문의
+    //  `zlink flow:` 축약 key(`kind`, `mesh` …)와 다른 집합이다 —
+    //  structuredLogBodyAttributes를 참고.
+    return compactAttributes({
+        event_id: record.eventId,
+        timestamp: record.timestamp.toISOString(),
+        phase: record.phase,
+        surface: record.surface,
+        message_kind: record.messageKind,
+        mesh_name: record.meshName,
+        channel_name: record.channelName,
+        channel_route_kind: record.channelRouteKind,
+        source_rid: record.sourceRid,
+        target_rid: record.targetRid,
+        server_rid: record.serverRid,
+        packet_name: record.packetName,
+        topic: record.topic,
+        spot_id: record.spotId,
+        instance_spot_type: record.instanceSpotType,
+        activation_state: record.activationState,
+        actor_id: record.actorId,
+        stream_session_id: record.streamSessionId,
+        correlation_id: record.correlationId,
+        flow_id: record.flowId,
+        flow_origin: record.flowOrigin,
+        outcome: record.outcome,
+        reason: record.reason,
+        action: record.action,
+        command_id: record.commandId,
+        error_type: record.errorType,
+        error_message: record.errorMessage,
+        error_cause_type: record.errorCauseType,
+        error_cause_message: record.errorCauseMessage,
+        message_size_bytes: record.messageSizeBytes,
+        duration_seconds: record.durationSeconds
+    });
+}
+function structuredLogBodyAttributes(record) {
+    //  `zlink flow:` 본문 전용 축약 key — Message flow tracing "Structured log 대체 표기".
+    return compactAttributes({
+        event: record.eventId,
+        phase: record.phase,
+        surface: record.surface,
+        kind: record.messageKind,
+        mesh: record.meshName,
+        channel: record.channelName,
+        channel_route: record.channelRouteKind,
+        source_rid: record.sourceRid,
+        target_rid: record.targetRid,
+        server_rid: record.serverRid,
+        packet: record.packetName,
+        topic: record.topic,
+        spot: record.spotId,
+        instance_type: record.instanceSpotType,
+        activation_state: record.activationState,
+        actor: record.actorId,
+        session: record.streamSessionId,
+        corr: record.correlationId,
+        flow: record.flowId,
+        origin: record.flowOrigin,
+        outcome: record.outcome,
+        reason: record.reason,
+        action: record.action,
+        error_type: record.errorType,
+        error_message: record.errorMessage,
+        size: record.messageSizeBytes
+    });
+}
+function structuredLogBody(record) {
+    return `zlink flow: ${Object.entries(structuredLogBodyAttributes(record))
+        .map(([key, value]) => `${key}=${String(value)}`)
+        .join(' ')}`;
+}
+function compactAttributes(values) {
+    const attributes = {};
+    for (const [key, value] of Object.entries(values)) {
+        if (value !== undefined)
+            attributes[key] = value;
+    }
+    return attributes;
+}
+function messageFlowPhase(outcome) {
+    switch (outcome) {
+        case ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Received:
+            return 'received';
+        case ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Admitted:
+            return 'admitted';
+        case ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dispatched:
+            return 'dispatched';
+        case ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Completed:
+            return 'completed';
+        case ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Replied:
+            return 'replied';
+        case ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped:
+            return 'dropped';
+        case ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent:
+            return 'sent';
+        case ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived:
+            return 'reply_received';
+        case ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Backpressured:
+            return 'backpressured';
+        case ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error:
+            return undefined;
+    }
+}
+function messageFlowOutcome(outcome) {
+    if (outcome === ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error)
+        return 'failed';
+    if (outcome === ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Backpressured)
+        return 'backpressured';
+    if (outcome === ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped)
+        return 'dropped';
+    return 'succeeded';
+}
+function messageFlowSurface(surface) {
+    switch (surface) {
+        case ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.Node:
+            return 'node';
+        case ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.Channel:
+        case ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.RouteMeshChannel:
+            return 'channel';
+        case ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.SpotRoute:
+        case ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.SpotSubscription:
+            return 'spot';
+        case ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.InstanceSpot:
+            return 'instance_spot';
+        case ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.SpotActor:
+            return 'actor';
+        case ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.StreamSession:
+            return 'stream';
+        case ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.ActorRelocation:
+            return 'actor_relocation';
+        case ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.ClassicFanout:
+            return 'classic_fanout';
+    }
+}
+function messageFlowKind(kind) {
+    switch (kind) {
+        case ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request:
+        case ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorRequest:
+            return 'request';
+        case ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send:
+        case ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorSend:
+            return 'send';
+        case ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Response:
+            return 'response';
+        case ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Error:
+            return 'error';
+        case ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Control:
+            return 'control';
+        case ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Publish:
+            throw new Error('Classic fanout publish must not create a normal message-flow record.');
+    }
+}
+function channelRouteKind(surface) {
+    if (surface === ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.RouteMeshChannel)
+        return 'route_mesh';
+    if (surface === ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.Channel)
+        return 'client_server';
+    return undefined;
+}
+function boundedText(value) {
+    return value === undefined ? undefined : value.slice(0, dispatch_error_details_1.ERROR_MESSAGE_MAX_LENGTH);
+}
+function toSnakeCase(value) {
+    return value.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}

package/dist/runtime/diagnostics/message-flow-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/diagnostics/message-flow-worker.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_worker_threads_1 = require("node:worker_threads");
+const api_1 = require("@opentelemetry/api");
+const api_logs_1 = require("@opentelemetry/api-logs");
+const message_flow_bootstrap_1 = require("./message-flow-bootstrap");
+const message_flow_delivery_1 = require("./message-flow-delivery");
+const runtime_metrics_1 = require("./runtime-metrics");
+const Metrics_1 = require("../../contracts/Eventing/Metrics");
+const message_flow_record_1 = require("./message-flow-record");
+const state = new Int32Array(node_worker_threads_1.workerData, 0, message_flow_delivery_1.TelemetryState.Length);
+const counters = new BigUint64Array(node_worker_threads_1.workerData, message_flow_delivery_1.TELEMETRY_STATE_BYTES, message_flow_delivery_1.TelemetryCounter.Length);
+let logger;
+let tracer;
+let overflow;
+const overflowAttributes = { source: 'message_flow' };
+let reportedOverflow = 0n;
+function failed(role, error) {
+    if (Atomics.add(counters, role, 1n) !== 0n ||
+        Atomics.load(counters, message_flow_delivery_1.TelemetryCounter.FallbackFailures) !== 0n)
+        return;
+    try {
+        const description = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+        process.stderr.write(`ZLink telemetry ${role === message_flow_delivery_1.TelemetryCounter.LoggerFailures ? 'logger' : 'trace'} provider failed: ${description}\n`, (error) => {
+            if (error !== undefined && error !== null)
+                Atomics.store(counters, message_flow_delivery_1.TelemetryCounter.FallbackFailures, 1n);
+        });
+    }
+    catch {
+        Atomics.store(counters, message_flow_delivery_1.TelemetryCounter.FallbackFailures, 1n);
+    }
+}
+function deliver(record) {
+    if (logger !== undefined) {
+        try {
+            const severity = record.severity === 'warning'
+                ? 'WARN'
+                : record.eventId === message_flow_record_1.DISPATCH_ERROR_EVENT_ID
+                    ? 'ERROR'
+                    : 'INFO';
+            logger.emit({
+                eventName: record.eventId,
+                timestamp: record.timestamp,
+                severityNumber: api_logs_1.SeverityNumber[severity],
+                severityText: severity,
+                body: (0, message_flow_record_1.structuredLogBody)(record),
+                attributes: (0, message_flow_record_1.structuredLogAttributes)(record)
+            });
+        }
+        catch (error) {
+            failed(message_flow_delivery_1.TelemetryCounter.LoggerFailures, error);
+        }
+    }
+    if (tracer === undefined)
+        return;
+    try {
+        const span = tracer.startSpan(record.eventId, { attributes: (0, message_flow_record_1.traceAttributes)(record) });
+        if (record.eventId === message_flow_record_1.DISPATCH_ERROR_EVENT_ID) {
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: record.reason });
+        }
+        span.end();
+    }
+    catch (error) {
+        failed(message_flow_delivery_1.TelemetryCounter.TraceFailures, error);
+    }
+}
+process.stderr.once('error', () => Atomics.store(counters, message_flow_delivery_1.TelemetryCounter.FallbackFailures, 1n));
+const hasLoggerProvider = api_logs_1.logs.getLoggerProvider() !== message_flow_bootstrap_1.initialLoggerProvider;
+if (hasLoggerProvider) {
+    try {
+        logger = api_logs_1.logs.getLogger(message_flow_record_1.TELEMETRY_INSTRUMENTATION_NAME);
+    }
+    catch (error) {
+        failed(message_flow_delivery_1.TelemetryCounter.LoggerFailures, error);
+    }
+}
+let hasTraceProvider = false;
+try {
+    const provider = api_1.trace.getTracerProvider();
+    tracer =
+        provider instanceof api_1.ProxyTracerProvider
+            ? provider.getDelegateTracer(message_flow_record_1.TELEMETRY_INSTRUMENTATION_NAME)
+            : provider.getTracer(message_flow_record_1.TELEMETRY_INSTRUMENTATION_NAME);
+    hasTraceProvider = tracer !== undefined;
+}
+catch (error) {
+    // The no-provider proxy returns undefined. A delegate throwing getTracer is
+    // still a registered provider, and its failure stays in this worker.
+    hasTraceProvider = true;
+    failed(message_flow_delivery_1.TelemetryCounter.TraceFailures, error);
+}
+// enabled() is an event filter, not a provider-registration test. In particular,
+// an ERROR-only processor may reject an unspecified-severity enabled() query.
+Atomics.store(state, message_flow_delivery_1.TelemetryState.Enabled, hasLoggerProvider || hasTraceProvider ? 1 : 0);
+node_worker_threads_1.parentPort.postMessage(message_flow_delivery_1.TELEMETRY_WORKER_AVAILABLE);
+node_worker_threads_1.parentPort.on('message', (batch) => {
+    for (const item of batch) {
+        Atomics.sub(state, message_flow_delivery_1.TelemetryState.Pending, 1);
+        if (Atomics.load(new Int32Array(item.lease), 0) === 0)
+            deliver(item.record);
+    }
+    const dropped = Atomics.load(counters, message_flow_delivery_1.TelemetryCounter.Overflow);
+    if (dropped !== reportedOverflow) {
+        try {
+            overflow ??= api_1.metrics
+                .getMeter(Metrics_1.ZLinkMeters.Framework)
+                .createCounter(runtime_metrics_1.METRIC_NAMES.ObservabilityEventsOverflow, {
+                unit: runtime_metrics_1.COUNTER_UNITS[runtime_metrics_1.METRIC_NAMES.ObservabilityEventsOverflow]
+            });
+            overflow.add(Number(dropped - reportedOverflow), overflowAttributes);
+        }
+        catch (error) {
+            failed(message_flow_delivery_1.TelemetryCounter.TraceFailures, error);
+        }
+        reportedOverflow = dropped;
+    }
+    node_worker_threads_1.parentPort.postMessage(message_flow_delivery_1.TELEMETRY_WORKER_AVAILABLE);
+});

package/dist/runtime/diagnostics/message-flow.d.ts

@@ -1,6 +1,6 @@
-import { type ZLinkDiagnosticsOptions, type ZLinkMessageFlowLogMode } from '../../contracts';
-import { ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome, type ZLinkRuntimeMessageFlowEvent, type ZLinkRuntimeMessageFlowResult } from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import type { ZLinkDispatchErrorSink } from './dispatch-error-port';
+import { type ZLinkDiagnosticsOptions, type ZLinkMessageFlowLogMode, ZLinkRuntimeMessageFlowOutcome as ZLinkMessageFlowOutcome, type ZLinkRuntimeMessageFlowResult } from '../../contracts/Dispatch/ZLinkDispatchOptions';
+import { type MessageFlowInput } from './message-flow-record';
+import { type ZLinkTelemetryLease } from './message-flow-delivery';
 export interface ZLinkMessageFlowModeCell {
     mode: ZLinkMessageFlowLogMode;
 }
@@ -8,9 +8,9 @@ export interface ZLinkDiagnosticsContext {
     readonly diagnostics: ZLinkDiagnosticsOptions;
     readonly liveMode: ZLinkMessageFlowModeCell;
     readonly sourceMeshGeneration: bigint;
+    readonly telemetryLease?: ZLinkTelemetryLease;
 }
 export declare const DEFAULT_ZLINK_DIAGNOSTICS: ZLinkDiagnosticsOptions;
-export declare const telemetryLogger: import("@opentelemetry/api-logs").Logger;
 export declare function effectiveMessageFlow(ctx: ZLinkDiagnosticsContext): ZLinkMessageFlowLogMode;
 /**
  * Message-flow tracing is on at Normal and Detailed only (04-flow-correlation
@@ -23,28 +23,21 @@ export declare function createMessageFlowModeCell(dispatch: {
 } | undefined): ZLinkMessageFlowModeCell;
 export declare function createDiagnosticsContext(dispatch: {
     diagnostics?: ZLinkDiagnosticsOptions;
-} | undefined, _providerResolver: unknown, liveMode: ZLinkMessageFlowModeCell): ZLinkDiagnosticsContext;
+} | undefined, _providerResolver: unknown, liveMode: ZLinkMessageFlowModeCell, telemetryLease?: ZLinkTelemetryLease): ZLinkDiagnosticsContext;
 export declare function flowIfEnabled(flow: ZLinkMessageFlowTracer | undefined, outcome: ZLinkMessageFlowOutcome, result?: ZLinkRuntimeMessageFlowResult, flowId?: string, sourceMeshGeneration?: bigint | string): ZLinkMessageFlowTracePoint | undefined;
 export interface ZLinkMessageFlowTracePoint {
     trace(flowInput: MessageFlowInput): void;
 }
 export declare function traceSessionBindingControlDrop(flow: ZLinkMessageFlowTracer | undefined, sourceRid: string, actorId: string, packetName: string, errorReason: 'location_unavailable' | 'stale_target', error?: unknown): void;
-type MessageFlowInput = Omit<ZLinkRuntimeMessageFlowEvent, 'effectiveMode' | 'flowId' | 'flowOrigin'> & {
-    readonly severity?: 'warning';
-    readonly effectiveMode?: ZLinkMessageFlowLogMode;
-    readonly flowId?: string;
-    readonly flowOrigin?: import('../../contracts').ZLinkFlowOrigin;
-};
 export declare class ZLinkMessageFlowTracer {
     private readonly ctx;
-    private readonly errorSink;
     private tracedEvents;
-    private providerFailures;
+    private readonly telemetryLease;
     private localSamplingSequence;
     private errorsTracePoint?;
     private normalTracePoint?;
     private detailedTracePoint?;
-    constructor(ctx: ZLinkDiagnosticsContext, errorSink: ZLinkDispatchErrorSink);
+    constructor(ctx: ZLinkDiagnosticsContext);
     enabled(outcome: ZLinkMessageFlowOutcome): boolean;
     accepts(outcome: ZLinkMessageFlowOutcome): boolean;
     begin(outcome: ZLinkMessageFlowOutcome, result?: ZLinkRuntimeMessageFlowResult, flowId?: string, sourceMeshGeneration?: bigint | string): ZLinkMessageFlowTracePoint | undefined;
@@ -56,9 +49,4 @@ export declare class ZLinkMessageFlowTracer {
     get providerFailureCount(): number;
     private sample;
     private nextSamplingSequence;
-    private publish;
-    private publishToLogger;
-    private publishToTrace;
-    private reportProviderFailure;
 }
-export {};