@observertc/observer-js 1.0.0-beta.10 → 1.0.0-beta.11

package/dist/index.mjs

@@ -2181,7 +2181,8 @@ var ObservedClient = class extends EventEmitter2 {
   // public totalNumberOfIssues = 0;
   mediaDevices = [];
   issues = [];
-  _injections = {};
+  _pendingInjections = {};
+  _activeSample;
   closeTimer;
   get numberOfPeerConnections() {
     return this.observedPeerConnections.size;
@@ -2191,11 +2192,8 @@ var ObservedClient = class extends EventEmitter2 {
   }
   close() {
     if (this.closed) return;
+    this._flushPendingInjections();
     this.closed = true;
-    this._injections.clientEvents?.forEach((clientEvent) => this._processClientEvent(clientEvent));
-    this._injections.clientIssues?.forEach((clientIssue) => this.addIssue(clientIssue));
-    this._injections.extensionStats?.forEach((extensionStat) => this.addExtensionStats(extensionStat));
-    this._injections.clientMetaItems?.forEach((clientMetaItem) => this.addMetadata(clientMetaItem));
     Array.from(this.observedPeerConnections.values()).forEach((peerConnection) => peerConnection.close());
     if (!this.leftAt) {
       this.leftAt = this.lastSampleTimestamp;
@@ -2218,7 +2216,6 @@ var ObservedClient = class extends EventEmitter2 {
       logger2.warn("Attempted to accept a sample on a closed client %s", this.clientId);
       return;
     }
-    this.sink?.write(sample);
     if (this.closeTimer) {
       clearTimeout(this.closeTimer);
       this.closeTimer = void 0;
@@ -2258,7 +2255,8 @@ var ObservedClient = class extends EventEmitter2 {
     this.usingTCP = false;
     this.currentMinRttInMs = void 0;
     this.currentMaxRttInMs = void 0;
-    this._mergeInjections(sample);
+    this._mergePendingInjections(sample);
+    this._activeSample = sample;
     const clientEventsPostBuffer = [];
     for (const clientEvent of sample.clientEvents ?? []) {
       this._processClientEvent(clientEvent, clientEventsPostBuffer);
@@ -2346,31 +2344,68 @@ var ObservedClient = class extends EventEmitter2 {
         this.close();
       }, this.settings.closeClientIfIdleForMs);
     }
+    this._activeSample = void 0;
+    try {
+      this.sink?.write(sample);
+    } catch (err) {
+      logger2.warn("ClientSampleSink.write failed for client %s: %o", this.clientId, err);
+    }
   }
   injectMetaData(metaData) {
     if (this.closed) return;
-    if (!this._injections.clientMetaItems) this._injections.clientMetaItems = [];
-    this._injections.clientMetaItems.push(metaData);
+    if (this._activeSample) {
+      if (!this._activeSample.clientMetaItems) this._activeSample.clientMetaItems = [];
+      this._activeSample.clientMetaItems.push(metaData);
+      this.addMetadata(metaData);
+      return;
+    }
+    if (!this._pendingInjections.clientMetaItems) this._pendingInjections.clientMetaItems = [];
+    this._pendingInjections.clientMetaItems.push(metaData);
   }
   injectEvent(event) {
     if (this.closed) return;
-    if (!this._injections.clientEvents) this._injections.clientEvents = [];
-    this._injections.clientEvents.push(event);
+    if (this._activeSample) {
+      if (!this._activeSample.clientEvents) this._activeSample.clientEvents = [];
+      this._activeSample.clientEvents.push(event);
+      this._processClientEvent(event);
+      return;
+    }
+    if (!this._pendingInjections.clientEvents) this._pendingInjections.clientEvents = [];
+    this._pendingInjections.clientEvents.push(event);
   }
   injectIssue(issue) {
     if (this.closed) return;
-    if (!this._injections.clientIssues) this._injections.clientIssues = [];
-    this._injections.clientIssues.push(issue);
+    if (this._activeSample) {
+      if (!this._activeSample.clientIssues) this._activeSample.clientIssues = [];
+      this._activeSample.clientIssues.push(issue);
+      this.addIssue(issue);
+      ++this.deltaNumberOfIssues;
+      return;
+    }
+    if (!this._pendingInjections.clientIssues) this._pendingInjections.clientIssues = [];
+    this._pendingInjections.clientIssues.push(issue);
   }
   injectExtensionStat(stat) {
     if (this.closed) return;
-    if (!this._injections.extensionStats) this._injections.extensionStats = [];
-    this._injections.extensionStats.push(stat);
+    if (this._activeSample) {
+      if (!this._activeSample.extensionStats) this._activeSample.extensionStats = [];
+      this._activeSample.extensionStats.push(stat);
+      this.addExtensionStats(stat);
+      return;
+    }
+    if (!this._pendingInjections.extensionStats) this._pendingInjections.extensionStats = [];
+    this._pendingInjections.extensionStats.push(stat);
   }
-  injectAttachment(key, value) {
+  injectAttachment(attachments) {
     if (this.closed) return;
-    if (!this._injections.attachments) this._injections.attachments = {};
-    this._injections.attachments[key] = value;
+    if (this._activeSample) {
+      if (!this._activeSample.attachments) this._activeSample.attachments = {};
+      Object.assign(this._activeSample.attachments, attachments);
+      this.attachments = this._activeSample.attachments;
+      return;
+    }
+    if (!this._pendingInjections.attachments) this._pendingInjections.attachments = {};
+    Object.assign(this._pendingInjections.attachments, attachments);
   }
   addMetadata(metadata) {
     if (this.closed) return;
@@ -2632,35 +2667,53 @@ var ObservedClient = class extends EventEmitter2 {
     observedPeerConnection.accept(sample, context);
     return observedPeerConnection;
   }
-  _mergeInjections(sample) {
+  _mergePendingInjections(sample) {
     if (this.closed) return sample;
-    if (this._injections.clientEvents) {
+    if (this._pendingInjections.clientEvents) {
       if (!sample.clientEvents) sample.clientEvents = [];
-      sample.clientEvents.push(...this._injections.clientEvents);
-      this._injections.clientEvents = void 0;
+      sample.clientEvents.push(...this._pendingInjections.clientEvents);
+      this._pendingInjections.clientEvents = void 0;
     }
-    if (this._injections.clientIssues) {
+    if (this._pendingInjections.clientIssues) {
       if (!sample.clientIssues) sample.clientIssues = [];
-      sample.clientIssues.push(...this._injections.clientIssues);
-      this._injections.clientIssues = void 0;
+      sample.clientIssues.push(...this._pendingInjections.clientIssues);
+      this._pendingInjections.clientIssues = void 0;
     }
-    if (this._injections.extensionStats) {
+    if (this._pendingInjections.extensionStats) {
       if (!sample.extensionStats) sample.extensionStats = [];
-      sample.extensionStats.push(...this._injections.extensionStats);
-      this._injections.extensionStats = void 0;
+      sample.extensionStats.push(...this._pendingInjections.extensionStats);
+      this._pendingInjections.extensionStats = void 0;
     }
-    if (this._injections.attachments) {
+    if (this._pendingInjections.attachments) {
       if (!sample.attachments) sample.attachments = {};
-      Object.assign(sample.attachments, this._injections.attachments);
-      this._injections.attachments = void 0;
+      Object.assign(sample.attachments, this._pendingInjections.attachments);
+      this._pendingInjections.attachments = void 0;
     }
-    if (this._injections.clientMetaItems) {
+    if (this._pendingInjections.clientMetaItems) {
       if (!sample.clientMetaItems) sample.clientMetaItems = [];
-      sample.clientMetaItems.push(...this._injections.clientMetaItems);
-      this._injections.clientMetaItems = void 0;
+      sample.clientMetaItems.push(...this._pendingInjections.clientMetaItems);
+      this._pendingInjections.clientMetaItems = void 0;
     }
     return sample;
   }
+  _flushPendingInjections() {
+    const hasPending = Boolean(
+      this._pendingInjections.clientEvents || this._pendingInjections.clientIssues || this._pendingInjections.extensionStats || this._pendingInjections.clientMetaItems || this._pendingInjections.attachments
+    );
+    if (!hasPending) return;
+    const finalSample = { timestamp: Date.now() };
+    this._mergePendingInjections(finalSample);
+    for (const clientEvent of finalSample.clientEvents ?? []) this._processClientEvent(clientEvent);
+    for (const metaData of finalSample.clientMetaItems ?? []) this.addMetadata(metaData);
+    for (const issue of finalSample.clientIssues ?? []) this.addIssue(issue);
+    for (const extensionStat of finalSample.extensionStats ?? []) this.addExtensionStats(extensionStat);
+    if (finalSample.attachments) this.attachments = { ...this.attachments, ...finalSample.attachments };
+    try {
+      this.sink?.write(finalSample);
+    } catch (err) {
+      logger2.warn("ClientSampleSink.write failed during injection flush for client %s: %o", this.clientId, err);
+    }
+  }
   /** Emit an Observer-bus event scoped to this client (or a peer connection under it). */
   _notify(type, ...args) {
     this.call.observer.emit(type, ...args);
@@ -3660,17 +3713,19 @@ var Observer = class extends EventEmitter6 {
       observedMediasoupRouter,
       observer: this
     };
-    const onPeerConnectionAdded = (observedPeerConnectionScope) => {
-      if (!observedMediasoupRouter.webrtcTransportIds.has(observedPeerConnectionScope.observedPeerConnection.peerConnectionId)) return;
-      this.emit("mediasoup-router-matched-with-peer-connection", {
-        ...observedMediasoupRouterScope,
-        ...observedPeerConnectionScope
-      });
-    };
-    const stopMatching = () => this.off("peer-connection-added", onPeerConnectionAdded);
-    this.on("peer-connection-added", onPeerConnectionAdded);
-    this.once("observer-closed", stopMatching);
-    observedMediasoupRouter.once("close", stopMatching);
+    if (settings.matchPeerConnectionByWebRtcTransportId) {
+      const onPeerConnectionAdded = (observedPeerConnectionScope) => {
+        if (!observedMediasoupRouter.webrtcTransportIds.has(observedPeerConnectionScope.observedPeerConnection.peerConnectionId)) return;
+        this.emit("mediasoup-router-matched-with-peer-connection", {
+          ...observedMediasoupRouterScope,
+          ...observedPeerConnectionScope
+        });
+      };
+      const stopMatching = () => this.off("peer-connection-added", onPeerConnectionAdded);
+      this.on("peer-connection-added", onPeerConnectionAdded);
+      this.once("observer-closed", stopMatching);
+      observedMediasoupRouter.once("close", stopMatching);
+    }
     observedMediasoupRouter.once("close", () => {
       this.observedMediasoupRouters.delete(observedMediasoupRouter.id);
       this.emit("mediasoup-router-removed", observedMediasoupRouterScope);