@matter/protocol 0.12.0-alpha.0-20241229-9d9c99934 → 0.12.0-alpha.0-20241231-14ac774ba

package/src/interaction/InteractionMessenger.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Logger, MatterFlowError, NoResponseTimeoutError, UnexpectedDataError } from "#general";
+import { Diagnostic, Logger, MatterFlowError, NoResponseTimeoutError, UnexpectedDataError } from "#general";
 import { Specification } from "#model";
 import {
     Status,
@@ -85,22 +85,64 @@ class InteractionMessenger {
         return this.send(
             MessageType.StatusResponse,
             TlvStatusResponse.encode({ status, interactionModelRevision: Specification.INTERACTION_MODEL_REVISION }),
-            options,
+            {
+                ...options,
+                logContext: {
+                    for: options?.logContext?.for ? `I/Status-${options?.logContext?.for}` : undefined,
+                    status: `${StatusCode[status] ?? "unknown"}(${Diagnostic.hex(status)})`,
+                    ...options?.logContext,
+                },
+            },
         );
     }
 
-    async waitForSuccess(expectedProcessingTimeMs?: number) {
+    async waitForSuccess(
+        expectedMessageInfo: string,
+        options?: { expectedProcessingTimeMs?: number; timeoutMs?: number },
+    ) {
         // If the status is not Success, this would throw an Error.
-        await this.nextMessage(MessageType.StatusResponse, expectedProcessingTimeMs);
+        await this.nextMessage(MessageType.StatusResponse, options, `Success-${expectedMessageInfo}`);
+    }
+
+    async nextMessage(
+        expectedMessageType: number,
+        options?: {
+            expectedProcessingTimeMs?: number;
+            timeoutMs?: number;
+        },
+        expectedMessageInfo?: string,
+    ) {
+        return this.#nextMessage(expectedMessageType, options, expectedMessageInfo);
+    }
+
+    async anyNextMessage(
+        expectedMessageInfo: string,
+        options?: {
+            expectedProcessingTimeMs?: number;
+            timeoutMs?: number;
+        },
+    ) {
+        return this.#nextMessage(undefined, options, expectedMessageInfo);
     }
 
-    async nextMessage(expectedMessageType?: number, expectedProcessingTimeMs?: number) {
-        const message = await this.exchange.nextMessage(expectedProcessingTimeMs);
+    async #nextMessage(
+        expectedMessageType?: number,
+        options?: {
+            expectedProcessingTimeMs?: number;
+            timeoutMs?: number;
+        },
+        expectedMessageInfo?: string,
+    ) {
+        const { expectedProcessingTimeMs, timeoutMs } = options ?? {};
+        const message = await this.exchange.nextMessage({ expectedProcessingTimeMs, timeoutMs });
         const messageType = message.payloadHeader.messageType;
-        this.throwIfErrorStatusMessage(message);
+        if (expectedMessageType !== undefined && expectedMessageInfo === undefined) {
+            expectedMessageInfo = MessageType[expectedMessageType];
+        }
+        this.throwIfErrorStatusMessage(message, expectedMessageInfo);
         if (expectedMessageType !== undefined && messageType !== expectedMessageType) {
             throw new UnexpectedDataError(
-                `Received unexpected message type: ${messageType}, expected: ${expectedMessageType}`,
+                `Received unexpected message for ${expectedMessageInfo} type: ${messageType}, expected: ${expectedMessageType}`,
             );
         }
         return message;
@@ -110,7 +152,7 @@ class InteractionMessenger {
         await this.exchange.close();
     }
 
-    protected throwIfErrorStatusMessage(message: Message) {
+    protected throwIfErrorStatusMessage(message: Message, logHint?: string) {
         const {
             payloadHeader: { messageType },
             payload,
@@ -118,7 +160,8 @@ class InteractionMessenger {
 
         if (messageType !== MessageType.StatusResponse) return;
         const { status } = TlvStatusResponse.decode(payload);
-        if (status !== StatusCode.Success) throw new StatusResponseError(`Received error status: ${status}`, status);
+        if (status !== StatusCode.Success)
+            throw new StatusResponseError(`Received error status: ${status}${logHint ? ` (${logHint})` : ""}`, status);
     }
 
     getExchangeChannelName() {
@@ -193,7 +236,9 @@ export class InteractionServerMessenger extends InteractionMessenger {
                     case MessageType.TimedRequest: {
                         const timedRequest = TlvTimedRequest.decode(message.payload);
                         recipient.handleTimedRequest(this.exchange, timedRequest, message);
-                        await this.sendStatus(StatusCode.Success);
+                        await this.sendStatus(StatusCode.Success, {
+                            logContext: { for: "TimedRequest" },
+                        });
                         continueExchange = true;
                         break;
                     }
@@ -226,7 +271,7 @@ export class InteractionServerMessenger extends InteractionMessenger {
      * Handle DataReportPayload with the content of a DataReport to send, split them into multiple DataReport
      * messages and send them out based on the size.
      */
-    async sendDataReport(dataReportPayload: DataReportPayload, forFabricFilteredRead: boolean) {
+    async sendDataReport(dataReportPayload: DataReportPayload, forFabricFilteredRead: boolean, waitForAck = true) {
         const {
             subscriptionId,
             attributeReportsPayload,
@@ -255,7 +300,7 @@ export class InteractionServerMessenger extends InteractionMessenger {
             let firstAttributeAddedToReportMessage = false;
             let firstEventAddedToReportMessage = false;
             const sendAndResetReport = async () => {
-                await this.sendDataReportMessage(dataReport);
+                await this.sendDataReportMessage(dataReport, waitForAck);
                 dataReport.attributeReports = undefined;
                 dataReport.eventReports = undefined;
                 messageSize = emptyDataReportBytes.length;
@@ -321,10 +366,10 @@ export class InteractionServerMessenger extends InteractionMessenger {
             }
         }
 
-        await this.sendDataReportMessage(dataReport);
+        await this.sendDataReportMessage(dataReport, waitForAck);
     }
 
-    async sendDataReportMessage(dataReport: TypeFromSchema<typeof TlvDataReportForSend>) {
+    async sendDataReportMessage(dataReport: TypeFromSchema<typeof TlvDataReportForSend>, waitForAck = true) {
         const dataReportToSend = {
             ...dataReport,
             suppressResponse: dataReport.moreChunkedMessages ? false : dataReport.suppressResponse, // always false when moreChunkedMessages is true
@@ -337,17 +382,24 @@ export class InteractionServerMessenger extends InteractionMessenger {
                 )}`,
             );
         }
-        logger.debug(
-            `Sending DataReport chunk with ${dataReportToSend.attributeReports?.length ?? 0} attributes and ${
-                dataReportToSend.eventReports?.length ?? 0
-            } events: ${encodedMessage.length} bytes (moreChunkedMessages: ${dataReportToSend.moreChunkedMessages ?? false}, suppressResponse: ${dataReportToSend.suppressResponse})`,
-        );
+
+        const logContext = {
+            subId: dataReportToSend.subscriptionId,
+            interactionFlags: Diagnostic.asFlags({
+                suppressResponse: dataReportToSend.suppressResponse ?? false,
+                moreChunkedMessages: dataReportToSend.moreChunkedMessages ?? false,
+            }),
+            attr: dataReportToSend.attributeReports?.length,
+            ev: dataReportToSend.eventReports?.length,
+        };
 
         if (dataReportToSend.suppressResponse) {
             // We do not expect a response other than a Standalone Ack, so if we receive anything else, we throw an error
             try {
                 await this.exchange.send(MessageType.ReportData, encodedMessage, {
                     expectAckOnly: true,
+                    disableMrpLogic: !waitForAck,
+                    logContext,
                 });
             } catch (e) {
                 UnexpectedMessageError.accept(e);
@@ -356,15 +408,19 @@ export class InteractionServerMessenger extends InteractionMessenger {
                 this.throwIfErrorStatusMessage(receivedMessage);
             }
         } else {
-            await this.exchange.send(MessageType.ReportData, encodedMessage);
-            await this.waitForSuccess();
+            await this.exchange.send(MessageType.ReportData, encodedMessage, {
+                disableMrpLogic: !waitForAck,
+                logContext,
+            });
+            // We wait for a Success Message - when we don't request an Ack only wait 500ms
+            await this.waitForSuccess("DataReport", { timeoutMs: waitForAck ? undefined : 500 });
         }
     }
 }
 
 export class IncomingInteractionClientMessenger extends InteractionMessenger {
-    async waitFor(messageType: number, timeoutMs?: number) {
-        const message = await this.nextMessage(timeoutMs);
+    async waitFor(expectedMessageInfo: string, messageType: number, timeoutMs?: number) {
+        const message = await this.anyNextMessage(expectedMessageInfo, { timeoutMs });
         const {
             payloadHeader: { messageType: receivedMessageType },
         } = message;
@@ -389,11 +445,16 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
         const eventValues: TypeFromSchema<typeof TlvEventReport>[] = [];
 
         while (true) {
-            const dataReportMessage = await this.waitFor(MessageType.ReportData);
+            const dataReportMessage = await this.waitFor("DataReport", MessageType.ReportData);
             const report = TlvDataReport.decode(dataReportMessage.payload);
             if (expectedSubscriptionIds !== undefined) {
                 if (report.subscriptionId === undefined || !expectedSubscriptionIds.includes(report.subscriptionId)) {
-                    await this.sendStatus(StatusCode.InvalidSubscription, { multipleMessageInteraction: true });
+                    await this.sendStatus(StatusCode.InvalidSubscription, {
+                        multipleMessageInteraction: true,
+                        logContext: {
+                            subId: report.subscriptionId,
+                        },
+                    });
                     throw new UnexpectedDataError(
                         report.subscriptionId === undefined
                             ? "Invalid Data report without Subscription ID"
@@ -411,9 +472,15 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
                 throw new UnexpectedDataError(`Invalid subscription ID ${report.subscriptionId} received`);
             }
 
-            logger.debug(
-                `Received DataReport chunk with ${report.attributeReports?.length ?? 0} attributes and ${report.eventReports?.length ?? 0} events, suppressResponse: ${report.suppressResponse}, moreChunkedMessages: ${report.moreChunkedMessages}${report.subscriptionId !== undefined ? `, subscriptionId: ${report.subscriptionId}` : ""}`,
-            );
+            const logContext = {
+                subId: report.subscriptionId,
+                dataReportFlags: Diagnostic.asFlags({
+                    suppressResponse: report.suppressResponse,
+                    moreChunkedMessages: report.moreChunkedMessages,
+                }),
+                attr: report.attributeReports?.length,
+                ev: report.eventReports?.length,
+            };
 
             if (Array.isArray(report.attributeReports) && report.attributeReports.length > 0) {
                 attributeValues.push(...report.attributeReports);
@@ -423,11 +490,17 @@ export class IncomingInteractionClientMessenger extends InteractionMessenger {
             }
 
             if (report.moreChunkedMessages) {
-                await this.sendStatus(StatusCode.Success, { multipleMessageInteraction: true });
+                await this.sendStatus(StatusCode.Success, {
+                    multipleMessageInteraction: true,
+                    logContext,
+                });
             } else if (!report.suppressResponse) {
                 // We received the last message and need to send a final Success, but we do not need to wait for it and
                 // also don't care if it fails
-                this.sendStatus(StatusCode.Success, { multipleMessageInteraction: true }).catch(error =>
+                this.sendStatus(StatusCode.Success, {
+                    multipleMessageInteraction: true,
+                    logContext,
+                }).catch(error =>
                     logger.info("Error while sending final Success after receiving all DataReport chunks", error),
                 );
             }
@@ -619,6 +692,11 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
         await this.send(requestMessageType, requestSchema.encode(request), {
             expectAckOnly: true,
             expectedProcessingTimeMs,
+            logContext: {
+                invokeFlags: Diagnostic.asFlags({
+                    suppressResponse: true,
+                }),
+            },
         });
     }
 
@@ -634,7 +712,11 @@ export class InteractionClientMessenger extends IncomingInteractionClientMesseng
             expectAckOnly: false,
             expectedProcessingTimeMs,
         });
-        const responseMessage = await this.nextMessage(responseMessageType, expectedProcessingTimeMs);
+        const responseMessage = await this.nextMessage(
+            responseMessageType,
+            { expectedProcessingTimeMs },
+            MessageType[responseMessageType] ?? `Response-${Diagnostic.hex(responseMessageType)}`,
+        );
         return responseSchema.decode(responseMessage.payload);
     }
 }

package/src/interaction/InteractionServer.ts

@@ -955,10 +955,16 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             );
 
         if (!keepSubscriptions) {
-            logger.debug(
-                `Clear subscriptions for Subscriber node ${session.peerNodeId} because keepSubscriptions=false`,
+            const clearedCount = await this.#context.sessions.clearSubscriptionsForNode(
+                fabric.fabricIndex,
+                session.peerNodeId,
+                true,
             );
-            await this.#context.sessions.clearSubscriptionsForNode(fabric.fabricIndex, session.peerNodeId, true);
+            if (clearedCount > 0) {
+                logger.debug(
+                    `Cleared ${clearedCount} subscriptions for Subscriber node ${session.peerNodeId} because keepSubscriptions=false`,
+                );
+            }
         }
 
         if (
@@ -1072,7 +1078,11 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
             await subscription.close(); // Cleanup
             if (error instanceof StatusResponseError) {
                 logger.info(`Sending status response ${error.code} for interaction error: ${error.message}`);
-                await messenger.sendStatus(error.code);
+                await messenger.sendStatus(error.code, {
+                    logContext: {
+                        for: "I/SubscriptionSeed-Status",
+                    },
+                });
             }
             await messenger.close();
             return; // Make sure to not bubble up the exception
@@ -1092,6 +1102,12 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
                 maxInterval,
                 interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
             }),
+            {
+                logContext: {
+                    subId: subscriptionId,
+                    maxInterval,
+                },
+            },
         );
 
         // When an error occurs while sending the response, the subscription is not yet active and will be cleaned up by GC
@@ -1230,12 +1246,21 @@ export class InteractionServer implements ProtocolHandler, InteractionRecipient
                             `Send ${lastMessageProcessed ? "final " : ""}invoke response for ${invokeResponseMessage.invokeResponses} commands`,
                         );
                     }
+                    const moreChunkedMessages = lastMessageProcessed ? undefined : true;
                     await messenger.send(
                         MessageType.InvokeResponse,
                         TlvInvokeResponseForSend.encode({
                             ...invokeResponseMessage,
-                            moreChunkedMessages: lastMessageProcessed ? undefined : true,
+                            moreChunkedMessages,
                         }),
+                        {
+                            logContext: {
+                                invokeMsgFlags: Diagnostic.asFlags({
+                                    suppressResponse,
+                                    moreChunkedMessages,
+                                }),
+                            },
+                        },
                     );
                     invokeResponseMessage.invokeResponses = [];
                     messageSize = emptyInvokeResponseBytes.length;

package/src/interaction/ServerSubscription.ts

@@ -8,13 +8,13 @@ import { NumberedOccurrence } from "#events/Occurrence.js";
 import {
     InternalError,
     Logger,
+    MatterAggregateError,
     MatterError,
     MaybePromise,
     NetworkError,
     NoResponseTimeoutError,
     Time,
     Timer,
-    createPromise,
     isObject,
 } from "#general";
 import { Specification } from "#model";
@@ -151,7 +151,9 @@ export class ServerSubscription extends Subscription {
 
     #lastUpdateTimeMs = 0;
     #updateTimer: Timer;
-    readonly #sendDelayTimer = Time.getTimer("Subscription delay", 50, () => this.#triggerSendUpdate());
+    readonly #sendDelayTimer: Timer = Time.getTimer(`Subscription ${this.id} delay`, 50, () =>
+        this.#triggerSendUpdate(),
+    );
     readonly #outstandingAttributeUpdates = new Map<string, AttributePathWithValueVersion<any>>();
     readonly #outstandingEventUpdates = new Set<EventPathWithEventData<any>>();
     readonly #attributeListeners = new Map<
@@ -206,7 +208,9 @@ export class ServerSubscription extends Subscription {
         this.#maxIntervalMs = maxInterval;
         this.#sendIntervalMs = sendInterval;
 
-        this.#updateTimer = Time.getTimer("Subscription update", this.#sendIntervalMs, () => this.#prepareDataUpdate()); // will be started later
+        this.#updateTimer = Time.getTimer(`Subscription ${this.id} update`, this.#sendIntervalMs, () =>
+            this.#prepareDataUpdate(),
+        ); // will be started later
     }
 
     private determineSendingIntervals(
@@ -536,7 +540,7 @@ export class ServerSubscription extends Subscription {
         }
 
         this.#sendDelayTimer.start();
-        this.#updateTimer = Time.getTimer("Subscription update", this.#sendIntervalMs, () =>
+        this.#updateTimer = Time.getTimer(`Subscription update ${this.id}`, this.#sendIntervalMs, () =>
             this.#prepareDataUpdate(),
         ).start();
     }
@@ -547,19 +551,16 @@ export class ServerSubscription extends Subscription {
             this.sendNextUpdateImmediately = true;
             return;
         }
-        const { promise, resolver } = createPromise<void>();
-        this.#sendUpdate()
-            .then(resolver)
+        this.currentUpdatePromise = this.#sendUpdate()
             .catch(error => logger.warn("Sending subscription update failed:", error))
             .finally(() => (this.currentUpdatePromise = undefined));
-        this.currentUpdatePromise = promise;
     }
 
     /**
      * Determine all attributes that have changed since the last update and send them tout to the subscriber.
      * Important: This method MUST NOT be called directly. Use triggerSendUpdate() instead!
      */
-    async #sendUpdate() {
+    async #sendUpdate(onlyWithData = false) {
         // Get all outstanding updates, make sure the order is correct per endpoint and cluster
         const attributeUpdatesToSend = new Array<AttributePathWithValueVersion<any>>();
         const attributeUpdates: Record<string, AttributePathWithValueVersion<any>[]> = {};
@@ -580,6 +581,11 @@ export class ServerSubscription extends Subscription {
 
         const eventUpdatesToSend = Array.from(this.#outstandingEventUpdates.values());
         this.#outstandingEventUpdates.clear();
+
+        if (onlyWithData && attributeUpdatesToSend.length === 0 && eventUpdatesToSend.length === 0) {
+            return;
+        }
+
         this.#lastUpdateTimeMs = Time.nowMs();
 
         try {
@@ -629,7 +635,7 @@ export class ServerSubscription extends Subscription {
         if (this.sendNextUpdateImmediately) {
             logger.debug("Sending delayed update immediately after last one was sent.");
             this.sendNextUpdateImmediately = false;
-            await this.#sendUpdate();
+            await this.#sendUpdate(true); // Send but only if non-empty
         }
     }
 
@@ -836,7 +842,7 @@ export class ServerSubscription extends Subscription {
         this.#sendDelayTimer.stop();
         if (this.#outstandingAttributeUpdates.size > 0 || this.#outstandingEventUpdates.size > 0) {
             logger.debug(
-                `Flushing subscription ${this.id} with ${this.#outstandingAttributeUpdates.size} attributes and ${this.#outstandingEventUpdates.size} events`,
+                `Flushing subscription ${this.id} with ${this.#outstandingAttributeUpdates.size} attributes and ${this.#outstandingEventUpdates.size} events${this.isClosed ? " (for closing)" : ""}`,
             );
             this.#triggerSendUpdate();
             if (this.currentUpdatePromise) {
@@ -853,7 +859,9 @@ export class ServerSubscription extends Subscription {
         if (this.attributeUpdatePromises.size) {
             const resolvers = [...this.attributeUpdatePromises.values()];
             this.attributeUpdatePromises.clear();
-            await Promise.all(resolvers);
+            await MatterAggregateError.allSettled(resolvers, "Error receiving all outstanding attribute values").catch(
+                error => logger.error(error),
+            );
         }
         this.#updateTimer.stop();
         this.#sendDelayTimer.stop();
@@ -870,9 +878,6 @@ export class ServerSubscription extends Subscription {
         attributes: AttributePathWithValueVersion<any>[],
         events: EventPathWithEventData<any>[],
     ) {
-        logger.debug(
-            `Sending subscription update message for ID ${this.id} with ${attributes.length} attributes and ${events.length} events`,
-        );
         const exchange = this.#context.initiateExchange(this.peerAddress, INTERACTION_PROTOCOL_ID);
         if (exchange === undefined) return;
         if (attributes.length) {
@@ -896,11 +901,12 @@ export class ServerSubscription extends Subscription {
                         interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
                     },
                     this.criteria.isFabricFiltered,
+                    !this.isClosed, // Do not wait for ack when closed
                 );
             } else {
                 await messenger.sendDataReport(
                     {
-                        suppressResponse: false, // Non empty data reports always need to send response
+                        suppressResponse: false, // Non-empty data reports always need to send response
                         subscriptionId: this.id,
                         interactionModelRevision: Specification.INTERACTION_MODEL_REVISION,
                         attributeReportsPayload: attributes.map(({ path, schema, value, version, attribute }) => ({
@@ -928,6 +934,7 @@ export class ServerSubscription extends Subscription {
                         }),
                     },
                     this.criteria.isFabricFiltered,
+                    !this.isClosed, // Do not wait for ack when closed
                 );
             }
         } catch (error) {

package/src/mdns/MdnsScanner.ts

@@ -1206,27 +1206,30 @@ export class MdnsScanner implements Scanner {
     }
 
     static discoveryDataDiagnostics(data: DiscoveryData) {
-        return Diagnostic.dict({
-            SII: data.SII,
-            SAI: data.SAI,
-            SAT: data.SAT,
-            T: data.T,
-            DT: data.DT,
-            PH: data.PH,
-            ICD: data.ICD,
-            VP: data.VP,
-            DN: data.DN,
-            RI: data.RI,
-            PI: data.PI,
-        });
+        return Diagnostic.dict(
+            {
+                SII: data.SII,
+                SAI: data.SAI,
+                SAT: data.SAT,
+                T: data.T,
+                DT: data.DT,
+                PH: data.PH,
+                ICD: data.ICD,
+                VP: data.VP,
+                DN: data.DN,
+                RI: data.RI,
+                PI: data.PI,
+            },
+            true,
+        );
     }
 
     static deviceAddressDiagnostics(addresses: Map<string, MatterServerRecordWithExpire>) {
         return Array.from(addresses.values()).map(address =>
             Diagnostic.dict({
+                type: address.type,
                 ip: address.ip,
                 port: address.port,
-                type: address.type,
             }),
         );
     }

package/src/mdns/MdnsServer.ts

@@ -15,6 +15,7 @@ import {
     DnsRecordType,
     isDeepEqual,
     Logger,
+    MatterAggregateError,
     MAX_MDNS_MESSAGE_SIZE,
     Network,
     Time,
@@ -252,7 +253,7 @@ export class MdnsServer {
     }
 
     async announce(announcedNetPort?: number) {
-        await Promise.all(
+        await MatterAggregateError.allSettled(
             (await this.#getMulticastInterfacesForAnnounce()).map(async ({ name: netInterface }) => {
                 const records = await this.#records.get(netInterface);
                 for (const [portType, portTypeRecords] of records) {
@@ -263,11 +264,12 @@ export class MdnsServer {
                     await Time.sleep("MDNS delay", 20 + Math.floor(Math.random() * 100)); // as per DNS-SD spec wait 20-120ms before sending more packets
                 }
             }),
-        );
+            "Error happened when announcing MDNS messages",
+        ).catch(error => logger.error(error));
     }
 
     async expireAnnouncements(announcedNetPort?: number, type?: AnnouncementType) {
-        await Promise.all(
+        await MatterAggregateError.allSettled(
             this.#records.keys().map(async netInterface => {
                 const records = await this.#records.get(netInterface);
                 for (const [portType, portTypeRecords] of records) {
@@ -300,7 +302,8 @@ export class MdnsServer {
                     await Time.sleep("MDNS delay", 20 + Math.floor(Math.random() * 100)); // as per DNS-SD spec wait 20-120ms before sending more packets
                 }
             }),
-        );
+            "Error happened when expiring MDNS announcements",
+        ).catch(error => logger.error(error));
         await this.#records.clear();
         this.#recordLastSentAsMulticastAnswer.clear();
         this.#recordLastSentAsUnicastAnswer.clear();

package/src/mdns/MdnsService.ts

@@ -10,6 +10,7 @@ import {
     Environment,
     Environmental,
     Logger,
+    MatterAggregateError,
     MaybePromise,
     Network,
     VariableService,
@@ -92,7 +93,10 @@ export class MdnsService {
                 logger.error("Error disposing of MDNS scanner", e),
             );
 
-            await Promise.all([broadcasterDisposal, scannerDisposal]);
+            await MatterAggregateError.allSettled(
+                [broadcasterDisposal, scannerDisposal],
+                "Error disposing MDNS services",
+            ).catch(error => logger.error(error));
 
             this.#broadcaster = this.#scanner = undefined;
         });

package/src/protocol/DeviceAdvertiser.ts

@@ -208,13 +208,11 @@ export class DeviceAdvertiser {
 
     async clearBroadcasters() {
         const broadcasters = [...this.#broadcasters];
-        const closed = Promise.allSettled(broadcasters.map(b => b.close()));
+        const closed = MatterAggregateError.allSettled(
+            broadcasters.map(b => b.close()),
+            "Error closing broadcasters",
+        ).catch(error => logger.error(error));
         this.#broadcasters.clear();
-        const errors = (await closed)
-            .map(status => (status.status === "rejected" ? status.reason : undefined))
-            .filter(reason => reason !== undefined);
-        if (errors.length) {
-            throw new MatterAggregateError(errors, "Error closing broadcasters");
-        }
+        await closed;
     }
 }

package/src/protocol/ExchangeManager.ts

@@ -11,6 +11,7 @@ import {
     Environmental,
     ImplementationError,
     Logger,
+    MatterAggregateError,
     MatterError,
     MatterFlowError,
     NotImplementedError,
@@ -27,7 +28,7 @@ import { SecureSession } from "../session/SecureSession.js";
 import { Session } from "../session/Session.js";
 import { SessionManager, UNICAST_UNSECURE_SESSION_ID } from "../session/SessionManager.js";
 import { ChannelManager } from "./ChannelManager.js";
-import { MessageExchange, MessageExchangeContext } from "./MessageExchange.js";
+import { ExchangeLogContext, MessageExchange, MessageExchangeContext } from "./MessageExchange.js";
 import { DuplicateMessageError } from "./MessageReceptionState.js";
 import { ProtocolHandler } from "./ProtocolHandler.js";
 
@@ -70,8 +71,8 @@ export class MessageChannel implements Channel<Message> {
         return this.channel.maxPayloadSize;
     }
 
-    send(message: Message): Promise<void> {
-        logger.debug("Message »", MessageCodec.messageDiagnostics(message));
+    send(message: Message, logContext?: ExchangeLogContext): Promise<void> {
+        logger.debug("Message »", MessageCodec.messageDiagnostics(message, logContext));
         const packet = this.session.encode(message);
         const bytes = MessageCodec.encodePacket(packet);
         if (bytes.length > this.maxPayloadSize) {
@@ -181,10 +182,12 @@ export class ExchangeManager {
         for (const listeners of this.#listeners.keys()) {
             this.#deleteListener(listeners);
         }
-        await Promise.allSettled(this.#closers);
-        for (const exchange of this.#exchanges.values()) {
-            await exchange.destroy();
-        }
+        await MatterAggregateError.allSettled(this.#closers, "Error closing exchanges").catch(error =>
+            logger.error(error),
+        );
+        await MatterAggregateError.allSettled(this.#exchanges.values(), "Error closing exchanges").catch(error =>
+            logger.error(error),
+        );
         this.#exchanges.clear();
     }