@fastybird/smart-panel-backend 1.1.0-alpha.2 → 1.1.0-alpha.21

package/dist/modules/websocket/services/command-acknowledgement-trace.service.d.ts

@@ -0,0 +1,143 @@
+import { type FileHandle } from 'node:fs/promises';
+import { Socket } from 'socket.io';
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+export interface CommandAcknowledgementTraceConfig {
+    readonly schemaVersion: 1;
+    readonly runId: string;
+    readonly target: {
+        readonly deviceId: string;
+        readonly channelId: string;
+        readonly propertyId: string;
+    };
+    readonly requests: readonly [
+        {
+            readonly phase: 'trial';
+            readonly requestId: string;
+            readonly value: boolean;
+        },
+        {
+            readonly phase: 'restoration';
+            readonly requestId: string;
+            readonly value: boolean;
+        }
+    ];
+    readonly exportPath: string;
+    readonly captureDurationMs?: number;
+    readonly maxRecords?: number;
+}
+export declare const COMMAND_ACKNOWLEDGEMENT_TRACE_OPTIONS: unique symbol;
+type TraceState = 'armed' | 'recording' | 'closed' | 'invalid';
+type TracePhase = 'trial' | 'restoration';
+type TraceStage = 'socket-receipt' | 'gateway-entry' | 'handler-start' | 'handler-settled' | 'handler-skipped' | 'gateway-return' | 'gateway-throw' | 'ack-invoked' | 'ack-returned' | 'ack-threw' | 'socket-close';
+interface TraceRecord {
+    readonly sequence: number;
+    readonly monotonicMs: number;
+    readonly stage: TraceStage;
+    readonly phase: TracePhase;
+    readonly requestId: string;
+    readonly metadata?: Record<string, boolean | number | string>;
+}
+interface CommandAcknowledgementTraceSnapshot {
+    readonly schemaVersion: 1;
+    readonly snapshotSequence: number;
+    readonly snapshotMonotonicMs: number;
+    readonly configFingerprint: string;
+    readonly process: {
+        readonly id: number;
+        readonly instanceId: string;
+        readonly runtimeSourceHash: string;
+    };
+    readonly runId: string;
+    readonly target: {
+        readonly deviceId: string;
+        readonly channelId: string;
+        readonly propertyId: string;
+    };
+    readonly state: TraceState;
+    readonly cutoffReason: string | null;
+    readonly socketTraceId: string | null;
+    readonly requests: readonly {
+        readonly phase: TracePhase;
+        readonly requestId: string;
+        readonly value: boolean;
+        readonly status: 'not-observed' | 'received';
+        readonly acknowledgementCalls: number;
+    }[];
+    readonly records: readonly TraceRecord[];
+}
+interface CommandAcknowledgementTraceFileSystem {
+    lstat(path: string): Promise<unknown>;
+    open(path: string, flags: 'r' | 'wx', mode?: number): Promise<FileHandle>;
+    link(existingPath: string, newPath: string): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    rm(path: string, options: {
+        force: boolean;
+    }): Promise<void>;
+}
+export declare class CommandAcknowledgementSnapshotWriter {
+    private readonly destination;
+    private readonly onFailure;
+    private readonly fileSystem;
+    private writing;
+    private pending;
+    private ownedDestination;
+    private readonly idleWaiters;
+    constructor(destination: string, onFailure: () => void, fileSystem?: CommandAcknowledgementTraceFileSystem);
+    queue(snapshot: CommandAcknowledgementTraceSnapshot): void;
+    waitForIdle(): Promise<void>;
+    private drain;
+    private write;
+    private assertDestinationIsAbsent;
+    private syncParentDirectory;
+}
+export declare class CommandAcknowledgementTraceService implements OnModuleInit, OnModuleDestroy {
+    private readonly config;
+    private readonly runtimeSourceHash;
+    private readonly configFingerprint;
+    private readonly processInstanceId;
+    private readonly requests;
+    private readonly attachedSockets;
+    private readonly disconnectListeners;
+    private readonly writer;
+    private socketContext;
+    private state;
+    private cutoffReason;
+    private records;
+    private nextSequence;
+    private nextSnapshotSequence;
+    private timer;
+    private exportFailed;
+    constructor(options?: CommandAcknowledgementTraceConfig | null);
+    static getSourceHash(): string;
+    onModuleInit(): void;
+    onModuleDestroy(): void;
+    isEnabled(): boolean;
+    waitForExports(): Promise<void>;
+    attachSocket(socket: Socket): void;
+    recordGatewayEntry(socket: Socket, message: unknown): void;
+    recordHandlerStart(socket: Socket, message: unknown, handlerName: string): void;
+    recordHandlerSettled(socket: Socket, message: unknown, handlerName: string, outcome: 'resolved' | 'null' | 'rejected'): void;
+    recordHandlerSkipped(socket: Socket, message: unknown, handlerName: string): void;
+    recordGatewayReturn(socket: Socket, message: unknown, status: 'ok' | 'error'): void;
+    recordGatewayThrow(socket: Socket, message: unknown): void;
+    recordSocketClose(socket: Socket, reason: string): void;
+    getSnapshot(): CommandAcknowledgementTraceSnapshot | null;
+    private observeSocketPacket;
+    private wrapAcknowledgement;
+    private static createAcknowledgementWrapper;
+    private recordForGateway;
+    private findRequestFromGatewayMessage;
+    private findRequest;
+    private matchesTarget;
+    private bindSocket;
+    private isCurrentSocket;
+    private removeObservedSocketListener;
+    private startTimer;
+    private close;
+    private invalidate;
+    private record;
+    private scheduleSnapshot;
+    private createSnapshot;
+    private handleExportFailure;
+}
+export {};

package/dist/modules/websocket/services/command-acknowledgement-trace.service.js

@@ -0,0 +1,523 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var CommandAcknowledgementTraceService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandAcknowledgementTraceService = exports.CommandAcknowledgementSnapshotWriter = exports.COMMAND_ACKNOWLEDGEMENT_TRACE_OPTIONS = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_perf_hooks_1 = require("node:perf_hooks");
+const common_1 = require("@nestjs/common");
+const COMMAND_EVENT = 'command';
+const PROPERTY_SET_EVENT = 'DevicesModule.ChannelProperty.Set';
+const MAX_CONFIGURATION_BYTES = 8 * 1024;
+const MAX_CAPTURE_DURATION_MS = 30_000;
+const MAX_RECORDS = 256;
+const MAX_SNAPSHOT_BYTES = 256 * 1024;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+exports.COMMAND_ACKNOWLEDGEMENT_TRACE_OPTIONS = Symbol('COMMAND_ACKNOWLEDGEMENT_TRACE_OPTIONS');
+const commandAcknowledgementTraceFileSystem = { lstat: promises_1.lstat, link: promises_1.link, open: promises_1.open, rename: promises_1.rename, rm: promises_1.rm };
+class CommandAcknowledgementSnapshotWriter {
+    constructor(destination, onFailure, fileSystem = commandAcknowledgementTraceFileSystem) {
+        this.destination = destination;
+        this.onFailure = onFailure;
+        this.fileSystem = fileSystem;
+        this.writing = false;
+        this.pending = null;
+        this.ownedDestination = false;
+        this.idleWaiters = new Set();
+    }
+    queue(snapshot) {
+        this.pending = snapshot;
+        if (!this.writing) {
+            void this.drain();
+        }
+    }
+    async waitForIdle() {
+        if (!this.writing && this.pending === null) {
+            return;
+        }
+        await new Promise((resolve) => this.idleWaiters.add(resolve));
+    }
+    async drain() {
+        this.writing = true;
+        try {
+            while (this.pending !== null) {
+                const snapshot = this.pending;
+                this.pending = null;
+                try {
+                    await this.write(snapshot);
+                }
+                catch {
+                    this.pending = null;
+                    this.onFailure();
+                    break;
+                }
+            }
+        }
+        finally {
+            this.writing = false;
+            for (const resolve of this.idleWaiters) {
+                resolve();
+            }
+            this.idleWaiters.clear();
+        }
+    }
+    async write(snapshot) {
+        if (!this.ownedDestination) {
+            await this.assertDestinationIsAbsent();
+        }
+        const temporaryPath = (0, node_path_1.join)((0, node_path_1.dirname)(this.destination), `.${(0, node_path_1.basename)(this.destination)}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+        try {
+            const file = await this.fileSystem.open(temporaryPath, 'wx', 0o600);
+            try {
+                await file.writeFile(`${JSON.stringify(snapshot)}\n`, 'utf8');
+                await file.chmod(0o600);
+                await file.sync();
+            }
+            finally {
+                await file.close();
+            }
+            if (this.ownedDestination) {
+                await this.fileSystem.rename(temporaryPath, this.destination);
+            }
+            else {
+                await this.fileSystem.link(temporaryPath, this.destination);
+            }
+            this.ownedDestination = true;
+            await this.syncParentDirectory();
+        }
+        finally {
+            await this.fileSystem.rm(temporaryPath, { force: true }).catch(() => undefined);
+        }
+    }
+    async assertDestinationIsAbsent() {
+        try {
+            await this.fileSystem.lstat(this.destination);
+            throw new Error('The acknowledgement trace destination already exists.');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    async syncParentDirectory() {
+        const directory = await this.fileSystem.open((0, node_path_1.dirname)(this.destination), 'r');
+        try {
+            await directory.sync();
+        }
+        finally {
+            await directory.close();
+        }
+    }
+}
+exports.CommandAcknowledgementSnapshotWriter = CommandAcknowledgementSnapshotWriter;
+let CommandAcknowledgementTraceService = CommandAcknowledgementTraceService_1 = class CommandAcknowledgementTraceService {
+    constructor(options) {
+        this.runtimeSourceHash = CommandAcknowledgementTraceService_1.getSourceHash();
+        this.processInstanceId = (0, node_crypto_1.randomUUID)();
+        this.requests = new Map();
+        this.attachedSockets = new WeakSet();
+        this.disconnectListeners = new WeakMap();
+        this.socketContext = null;
+        this.state = 'armed';
+        this.cutoffReason = null;
+        this.records = [];
+        this.nextSequence = 1;
+        this.nextSnapshotSequence = 1;
+        this.timer = null;
+        this.exportFailed = false;
+        this.config = normalizeConfig(options ?? parseEnvironmentConfig());
+        this.configFingerprint = this.config === null ? null : fingerprintConfig(this.config);
+        this.writer =
+            this.config === null
+                ? null
+                : new CommandAcknowledgementSnapshotWriter(this.config.exportPath, () => this.handleExportFailure());
+        for (const request of this.config?.requests ?? []) {
+            this.requests.set(request.requestId, { ...request, seen: false, ackCalls: 0 });
+        }
+    }
+    static getSourceHash() {
+        try {
+            return (0, node_crypto_1.createHash)('sha256').update((0, node_fs_1.readFileSync)(__filename, 'utf8')).digest('hex');
+        }
+        catch {
+            return (0, node_crypto_1.createHash)('sha256').update(CommandAcknowledgementTraceService_1.toString()).digest('hex');
+        }
+    }
+    onModuleInit() {
+        this.scheduleSnapshot();
+    }
+    onModuleDestroy() {
+        if (!this.isEnabled()) {
+            return;
+        }
+        if (this.state !== 'invalid') {
+            this.close('backend-shutdown');
+        }
+        this.removeObservedSocketListener();
+    }
+    isEnabled() {
+        return this.config !== null;
+    }
+    async waitForExports() {
+        await this.writer?.waitForIdle();
+    }
+    attachSocket(socket) {
+        if (!this.isEnabled() || this.attachedSockets.has(socket)) {
+            return;
+        }
+        this.attachedSockets.add(socket);
+        if (typeof socket.use === 'function') {
+            socket.use((packet, next) => {
+                try {
+                    this.observeSocketPacket(socket, packet);
+                }
+                catch {
+                }
+                next();
+            });
+        }
+        if (typeof socket.on === 'function') {
+            const disconnectListener = (reason) => {
+                this.recordSocketClose(socket, toBoundedReason(reason));
+            };
+            socket.on('disconnect', disconnectListener);
+            this.disconnectListeners.set(socket, disconnectListener);
+        }
+    }
+    recordGatewayEntry(socket, message) {
+        this.recordForGateway(socket, message, 'gateway-entry');
+    }
+    recordHandlerStart(socket, message, handlerName) {
+        this.recordForGateway(socket, message, 'handler-start', { handler: boundedHandlerName(handlerName) });
+    }
+    recordHandlerSettled(socket, message, handlerName, outcome) {
+        this.recordForGateway(socket, message, 'handler-settled', { handler: boundedHandlerName(handlerName), outcome });
+    }
+    recordHandlerSkipped(socket, message, handlerName) {
+        this.recordForGateway(socket, message, 'handler-skipped', {
+            handler: boundedHandlerName(handlerName),
+            reason: 'authorization',
+        });
+    }
+    recordGatewayReturn(socket, message, status) {
+        this.recordForGateway(socket, message, 'gateway-return', { status });
+    }
+    recordGatewayThrow(socket, message) {
+        this.recordForGateway(socket, message, 'gateway-throw');
+    }
+    recordSocketClose(socket, reason) {
+        if (!this.isCurrentSocket(socket) || this.state === 'invalid') {
+            return;
+        }
+        for (const request of this.requests.values()) {
+            if (request.seen) {
+                this.record(request, 'socket-close', { reason });
+            }
+        }
+        this.close('socket-closed');
+        this.removeObservedSocketListener();
+    }
+    getSnapshot() {
+        return this.config === null ? null : this.createSnapshot();
+    }
+    observeSocketPacket(socket, packet) {
+        if (this.state === 'closed' || this.state === 'invalid') {
+            return;
+        }
+        if (packet[0] !== COMMAND_EVENT || !isPlainObject(packet[1])) {
+            return;
+        }
+        const message = packet[1];
+        if (!isPlainObject(message.payload)) {
+            return;
+        }
+        const request = this.findRequest(message.payload.request_id);
+        if (request === null) {
+            return;
+        }
+        if (message.event !== PROPERTY_SET_EVENT || !this.matchesTarget(request, message.payload)) {
+            this.invalidate('scope-mismatch');
+            return;
+        }
+        if (!this.bindSocket(socket)) {
+            return;
+        }
+        if (request.seen) {
+            this.invalidate('duplicate-request');
+            return;
+        }
+        request.seen = true;
+        this.record(request, 'socket-receipt');
+        this.startTimer();
+        const acknowledgement = packet.at(-1);
+        if (isAcknowledgementFunction(acknowledgement)) {
+            packet[packet.length - 1] = this.wrapAcknowledgement(request, acknowledgement);
+        }
+    }
+    wrapAcknowledgement(request, acknowledgement) {
+        return CommandAcknowledgementTraceService_1.createAcknowledgementWrapper(this, request, acknowledgement);
+    }
+    static createAcknowledgementWrapper(trace, request, acknowledgement) {
+        return function acknowledgementTraceWrapper(...args) {
+            request.ackCalls++;
+            trace.record(request, 'ack-invoked', { callCount: request.ackCalls });
+            try {
+                const result = acknowledgement.call(this, ...args);
+                trace.record(request, 'ack-returned', { callCount: request.ackCalls });
+                return result;
+            }
+            catch (error) {
+                trace.record(request, 'ack-threw', { callCount: request.ackCalls });
+                throw error;
+            }
+        };
+    }
+    recordForGateway(socket, message, stage, metadata) {
+        if (this.state === 'invalid' || !this.isCurrentSocket(socket) || !isPlainObject(message)) {
+            return;
+        }
+        const request = this.findRequestFromGatewayMessage(message);
+        if (request !== null && request.seen) {
+            this.record(request, stage, metadata);
+        }
+    }
+    findRequestFromGatewayMessage(message) {
+        if (message.event !== PROPERTY_SET_EVENT || !isPlainObject(message.payload)) {
+            return null;
+        }
+        const request = this.findRequest(message.payload.request_id);
+        return request !== null && this.matchesTarget(request, message.payload) ? request : null;
+    }
+    findRequest(value) {
+        return typeof value === 'string' ? (this.requests.get(value) ?? null) : null;
+    }
+    matchesTarget(request, payload) {
+        if (this.config === null || !isPlainObject(payload)) {
+            return false;
+        }
+        const properties = payload.properties;
+        if (!Array.isArray(properties) || properties.length !== 1 || !isPlainObject(properties[0])) {
+            return false;
+        }
+        const property = properties[0];
+        return (property.device === this.config.target.deviceId &&
+            property.channel === this.config.target.channelId &&
+            property.property === this.config.target.propertyId &&
+            property.value === request.value);
+    }
+    bindSocket(socket) {
+        if (this.socketContext === null) {
+            const disconnectListener = this.disconnectListeners.get(socket);
+            if (disconnectListener === undefined) {
+                this.invalidate('socket-listener-unavailable');
+                return false;
+            }
+            this.socketContext = { socket, socketTraceId: (0, node_crypto_1.randomUUID)(), disconnectListener };
+            return true;
+        }
+        if (this.socketContext.socket !== socket) {
+            this.invalidate('socket-mismatch');
+            return false;
+        }
+        return true;
+    }
+    isCurrentSocket(socket) {
+        return this.socketContext?.socket === socket;
+    }
+    removeObservedSocketListener() {
+        if (this.socketContext === null || typeof this.socketContext.socket.off !== 'function') {
+            return;
+        }
+        this.socketContext.socket.off('disconnect', this.socketContext.disconnectListener);
+    }
+    startTimer() {
+        if (this.timer !== null || this.config === null) {
+            return;
+        }
+        this.timer = setTimeout(() => this.close('capture-duration-elapsed'), this.config.captureDurationMs);
+        this.timer.unref();
+    }
+    close(reason) {
+        if (this.state === 'invalid' || this.state === 'closed') {
+            return;
+        }
+        this.state = 'closed';
+        this.cutoffReason = reason;
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.scheduleSnapshot();
+    }
+    invalidate(reason) {
+        if (this.state === 'invalid') {
+            return;
+        }
+        this.state = 'invalid';
+        this.cutoffReason = reason;
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.scheduleSnapshot();
+    }
+    record(request, stage, metadata) {
+        if (this.state === 'closed' || this.state === 'invalid' || this.config === null) {
+            return;
+        }
+        if (this.records.length >= this.config.maxRecords) {
+            this.invalidate('record-limit-exceeded');
+            return;
+        }
+        this.state = 'recording';
+        this.records.push(Object.freeze({
+            sequence: this.nextSequence++,
+            monotonicMs: node_perf_hooks_1.performance.now(),
+            stage,
+            phase: request.phase,
+            requestId: request.requestId,
+            metadata: metadata === undefined ? undefined : Object.freeze({ ...metadata }),
+        }));
+        this.scheduleSnapshot();
+    }
+    scheduleSnapshot() {
+        if (this.config === null || this.writer === null || this.exportFailed) {
+            return;
+        }
+        const snapshot = this.createSnapshot();
+        if (Buffer.byteLength(JSON.stringify(snapshot), 'utf8') > MAX_SNAPSHOT_BYTES) {
+            this.records = [];
+            this.invalidate('snapshot-size-exceeded');
+            return;
+        }
+        this.writer.queue(snapshot);
+    }
+    createSnapshot() {
+        if (this.config === null || this.configFingerprint === null) {
+            throw new Error('Acknowledgement tracing is disabled.');
+        }
+        return Object.freeze({
+            schemaVersion: 1,
+            snapshotSequence: this.nextSnapshotSequence++,
+            snapshotMonotonicMs: node_perf_hooks_1.performance.now(),
+            configFingerprint: this.configFingerprint,
+            process: Object.freeze({
+                id: process.pid,
+                instanceId: this.processInstanceId,
+                runtimeSourceHash: this.runtimeSourceHash,
+            }),
+            runId: this.config.runId,
+            target: Object.freeze({ ...this.config.target }),
+            state: this.state,
+            cutoffReason: this.cutoffReason,
+            socketTraceId: this.socketContext?.socketTraceId ?? null,
+            requests: Object.freeze([...this.requests.values()].map((request) => Object.freeze({
+                phase: request.phase,
+                requestId: request.requestId,
+                value: request.value,
+                status: request.seen ? 'received' : 'not-observed',
+                acknowledgementCalls: request.ackCalls,
+            }))),
+            records: Object.freeze([...this.records]),
+        });
+    }
+    handleExportFailure() {
+        if (this.exportFailed) {
+            return;
+        }
+        this.exportFailed = true;
+        this.invalidate('export-failed');
+    }
+};
+exports.CommandAcknowledgementTraceService = CommandAcknowledgementTraceService;
+exports.CommandAcknowledgementTraceService = CommandAcknowledgementTraceService = CommandAcknowledgementTraceService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(exports.COMMAND_ACKNOWLEDGEMENT_TRACE_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], CommandAcknowledgementTraceService);
+function parseEnvironmentConfig() {
+    const raw = process.env.FB_COMMAND_ACK_TRACE;
+    if (!raw || Buffer.byteLength(raw, 'utf8') > MAX_CONFIGURATION_BYTES) {
+        return null;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeConfig(config) {
+    if (config === null ||
+        !isPlainObject(config) ||
+        config.schemaVersion !== 1 ||
+        !isUuid(config.runId) ||
+        !isUuid(config.target?.deviceId) ||
+        !isUuid(config.target?.channelId) ||
+        !isUuid(config.target?.propertyId) ||
+        typeof config.exportPath !== 'string' ||
+        !(0, node_path_1.isAbsolute)(config.exportPath) ||
+        !Array.isArray(config.requests) ||
+        config.requests.length !== 2) {
+        return null;
+    }
+    const [first, second] = config.requests;
+    if (!isPlainObject(first) ||
+        !isPlainObject(second) ||
+        first.phase !== 'trial' ||
+        second.phase !== 'restoration' ||
+        !isUuid(first.requestId) ||
+        !isUuid(second.requestId) ||
+        first.requestId === second.requestId ||
+        typeof first.value !== 'boolean' ||
+        typeof second.value !== 'boolean' ||
+        first.value === second.value) {
+        return null;
+    }
+    const captureDurationMs = config.captureDurationMs ?? MAX_CAPTURE_DURATION_MS;
+    const maxRecords = config.maxRecords ?? MAX_RECORDS;
+    if (!Number.isInteger(captureDurationMs) ||
+        captureDurationMs <= 0 ||
+        captureDurationMs > MAX_CAPTURE_DURATION_MS ||
+        !Number.isInteger(maxRecords) ||
+        maxRecords <= 0 ||
+        maxRecords > MAX_RECORDS) {
+        return null;
+    }
+    return Object.freeze({ ...config, captureDurationMs, maxRecords });
+}
+function isUuid(value) {
+    return typeof value === 'string' && UUID_PATTERN.test(value);
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isAcknowledgementFunction(value) {
+    return typeof value === 'function';
+}
+function fingerprintConfig(config) {
+    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(config)).digest('hex');
+}
+function boundedHandlerName(handlerName) {
+    return handlerName.slice(0, 160);
+}
+function toBoundedReason(reason) {
+    return typeof reason === 'string' && reason.length > 0 ? reason.slice(0, 160) : 'unknown';
+}
+//# sourceMappingURL=command-acknowledgement-trace.service.js.map