@observertc/observer-js 1.0.0-beta.8 → 1.0.0-beta.9

package/dist/index.js

@@ -48,6 +48,7 @@ __export(src_exports, {
   ObservedInboundTrack: () => ObservedInboundTrack,
   ObservedMediaPlayout: () => ObservedMediaPlayout,
   ObservedMediaSource: () => ObservedMediaSource,
+  ObservedMediasoupRouter: () => ObservedMediasoupRouter,
   ObservedOutboundRtp: () => ObservedOutboundRtp,
   ObservedOutboundTrack: () => ObservedOutboundTrack,
   ObservedPeerConnection: () => ObservedPeerConnection,
@@ -105,8 +106,8 @@ function createLogger(moduleName) {
     }
   }();
 }
-function setObserverLogger(logger7) {
-  mainLogger = logger7;
+function setObserverLogger(logger8) {
+  mainLogger = logger8;
 }
 
 // src/ObservedCall.ts
@@ -3053,7 +3054,7 @@ var ObservedCall = class extends import_events3.EventEmitter {
 };
 
 // src/Observer.ts
-var import_events5 = require("events");
+var import_events6 = require("events");
 
 // src/ObservedTURN.ts
 var import_events4 = require("events");
@@ -3299,9 +3300,344 @@ var MiddlewareProcessor = class {
   }
 };
 
+// src/ObservedMediasoupRouter.ts
+var import_events5 = require("events");
+var logger6 = createLogger("ObservedMediasoupRouter");
+var ObservedMediasoupRouter = class extends import_events5.EventEmitter {
+  router;
+  sample;
+  appData;
+  webrtcTransportIds = /* @__PURE__ */ new Set();
+  get attachments() {
+    return this.sample.attachments;
+  }
+  closed = false;
+  constructor(settings) {
+    super();
+    this.router = settings.router;
+    this.appData = settings.appData ?? {};
+    this.sample = {
+      routerId: this.router.id,
+      attachments: settings.attachments ?? {},
+      createdAt: Date.now(),
+      producers: [],
+      consumers: [],
+      dataProducers: [],
+      dataConsumers: [],
+      transports: []
+    };
+    this.attachRouterListeners();
+  }
+  get id() {
+    return this.router.id;
+  }
+  addTransport = (transport) => {
+    let transportType = transport.type;
+    if (!transportType) {
+      if (transport.constructor.name === "WebRtcTransport") transportType = "webrtc";
+      else if (transport.constructor.name === "PlainTransport") transportType = "plain";
+      else if (transport.constructor.name === "PipeTransport") transportType = "pipe";
+      else if (transport.constructor.name === "DirectTransport") transportType = "direct";
+    }
+    if (!transportType) return logger6.warn(`Unknown transport type for transport ${transport.id}: ${transport.constructor.name}`);
+    switch (transportType) {
+      case "webrtc":
+        return this.addWebRtcTransport(transport);
+      case "plain":
+        return this.addPlainTransport(transport);
+      case "pipe":
+        return this.addPipeTransport(transport);
+      case "direct":
+        return this.addDirectTransport(transport);
+      default:
+        return logger6.warn(`Unsupported transport type for transport ${transport.id}: ${transportType}`);
+    }
+  };
+  addWebRtcTransport(transport) {
+    const history = [];
+    const transportSample = {
+      id: transport.id,
+      type: "webrtc",
+      createdAt: Date.now(),
+      tuple: transport.iceSelectedTuple,
+      history
+    };
+    this.sample.transports.push(transportSample);
+    const onIceStateChange = (iceState) => {
+      history.push({
+        type: `icestate-changed-to-${iceState}`,
+        timestamp: Date.now()
+      });
+    };
+    const onIceSelectedTupleChange = (tuple) => {
+      transportSample.tuple = tuple;
+      history.push({
+        type: "iceselectedtuple-changed",
+        timestamp: Date.now(),
+        ...tuple
+      });
+    };
+    const onDtlsStateChange = (dtlsState) => {
+      history.push({
+        type: `dtlsstate-changed-to-${dtlsState}`,
+        timestamp: Date.now()
+      });
+      if (dtlsState === "connected" && transportSample.connectedAt === void 0) {
+        transportSample.connectedAt = Date.now();
+      }
+    };
+    const onSctpStateChange = (sctpState) => {
+      history.push({
+        type: `sctpstate-changed-to-${sctpState}`,
+        timestamp: Date.now()
+      });
+    };
+    this._attachTransportObserverListeners(transport, transportSample, () => {
+      transport.observer.off("icestatechange", onIceStateChange);
+      transport.observer.off("iceselectedtuplechange", onIceSelectedTupleChange);
+      transport.observer.off("dtlsstatechange", onDtlsStateChange);
+      transport.observer.off("sctpstatechange", onSctpStateChange);
+      this.webrtcTransportIds.delete(transport.id);
+    });
+    transport.observer.on("icestatechange", onIceStateChange);
+    transport.observer.on("iceselectedtuplechange", onIceSelectedTupleChange);
+    transport.observer.on("dtlsstatechange", onDtlsStateChange);
+    transport.observer.on("sctpstatechange", onSctpStateChange);
+    this.webrtcTransportIds.add(transport.id);
+  }
+  addPlainTransport(transport) {
+    const history = [];
+    const transportSample = {
+      id: transport.id,
+      type: "plain",
+      createdAt: Date.now(),
+      tuple: transport.tuple,
+      rtcpTuple: transport.rtcpTuple,
+      history
+    };
+    this.sample.transports.push(transportSample);
+    const onTuple = (tuple) => {
+      transportSample.tuple = tuple;
+      if (transportSample.connectedAt === void 0) transportSample.connectedAt = Date.now();
+      history.push({ type: "tuple-changed", timestamp: Date.now(), ...tuple });
+    };
+    const onRtcpTuple = (rtcpTuple) => {
+      transportSample.rtcpTuple = rtcpTuple;
+      history.push({ type: "rtcptuple-changed", timestamp: Date.now(), ...rtcpTuple });
+    };
+    const onSctpStateChange = (sctpState) => {
+      if (sctpState === "connected" && transportSample.connectedAt === void 0) {
+        transportSample.connectedAt = Date.now();
+      }
+      history.push({
+        type: `sctpstate-changed-to-${sctpState}`,
+        timestamp: Date.now()
+      });
+    };
+    this._attachTransportObserverListeners(transport, transportSample, () => {
+      transport.observer.off("tuple", onTuple);
+      transport.observer.off("rtcptuple", onRtcpTuple);
+      transport.observer.off("sctpstatechange", onSctpStateChange);
+    });
+    transport.observer.on("tuple", onTuple);
+    transport.observer.on("rtcptuple", onRtcpTuple);
+    transport.observer.on("sctpstatechange", onSctpStateChange);
+  }
+  addPipeTransport(transport) {
+    const history = [];
+    const transportSample = {
+      id: transport.id,
+      type: "pipe",
+      createdAt: Date.now(),
+      tuple: transport.tuple,
+      history
+    };
+    this.sample.transports.push(transportSample);
+    const onSctpStateChange = (sctpState) => {
+      if (sctpState === "connected" && transportSample.connectedAt === void 0) {
+        transportSample.connectedAt = Date.now();
+      }
+      history.push({
+        type: `sctpstate-changed-to-${sctpState}`,
+        timestamp: Date.now()
+      });
+    };
+    this._attachTransportObserverListeners(transport, transportSample, () => {
+      transport.observer.off("sctpstatechange", onSctpStateChange);
+    });
+    transport.observer.on("sctpstatechange", onSctpStateChange);
+  }
+  addDirectTransport(transport) {
+    const now = Date.now();
+    const transportSample = {
+      id: transport.id,
+      type: "direct",
+      createdAt: now,
+      // A DirectTransport has no network layer — it is connected the instant it exists.
+      connectedAt: now,
+      history: []
+    };
+    this.sample.transports.push(transportSample);
+    this._attachTransportObserverListeners(transport, transportSample);
+  }
+  addProducer(transport, producer) {
+    const firstCodec = producer.rtpParameters.codecs[0];
+    const codecInfo = {
+      mimeType: firstCodec?.mimeType ?? "unknown/unknown",
+      payloadType: firstCodec?.payloadType ?? 0,
+      clockRate: firstCodec?.clockRate ?? 0,
+      channels: firstCodec?.channels,
+      parameters: firstCodec?.parameters,
+      rtcpFeedback: firstCodec?.rtcpFeedback
+    };
+    const producerSample = {
+      id: producer.id,
+      createdAt: Date.now(),
+      kind: producer.kind,
+      codecInfo,
+      ssrcs: producer.rtpParameters.encodings?.map((encoding) => encoding.ssrc).filter((ssrc) => typeof ssrc === "number"),
+      rids: producer.rtpParameters.encodings?.map((encoding) => encoding.rid).filter((rid) => typeof rid === "string"),
+      history: [],
+      transportId: transport.id
+    };
+    this.sample.producers.push(producerSample);
+    const onPause = () => {
+      producerSample.history.push({
+        type: "pause",
+        timestamp: Date.now()
+      });
+    };
+    const onResume = () => {
+      producerSample.history.push({
+        type: "resume",
+        timestamp: Date.now()
+      });
+    };
+    producer.observer.once("close", () => {
+      producer.observer.off("pause", onPause);
+      producer.observer.off("resume", onResume);
+      producerSample.closedAt = Date.now();
+    });
+    producer.observer.on("pause", onPause);
+    producer.observer.on("resume", onResume);
+  }
+  addConsumer(transport, consumer) {
+    const consumerSample = {
+      id: consumer.id,
+      producerId: consumer.producerId,
+      transportId: transport.id,
+      createdAt: Date.now(),
+      kind: consumer.kind,
+      history: []
+    };
+    this.sample.consumers.push(consumerSample);
+    const onPause = () => {
+      consumerSample.history.push({
+        type: "pause",
+        timestamp: Date.now()
+      });
+    };
+    const onResume = () => {
+      consumerSample.history.push({
+        type: "resume",
+        timestamp: Date.now()
+      });
+    };
+    const onProducerPause = () => {
+      consumerSample.history.push({
+        type: "producerPaused",
+        timestamp: Date.now()
+      });
+    };
+    const onProducerResume = () => {
+      consumerSample.history.push({
+        type: "producerResumed",
+        timestamp: Date.now()
+      });
+    };
+    consumer.observer.once("close", () => {
+      consumer.observer.off("pause", onPause);
+      consumer.observer.off("resume", onResume);
+      consumer.off("producerresume", onProducerResume);
+      consumer.off("producerpause", onProducerPause);
+      consumerSample.closedAt = Date.now();
+    });
+    consumer.observer.on("pause", onPause);
+    consumer.observer.on("resume", onResume);
+    consumer.on("producerpause", onProducerPause);
+    consumer.on("producerresume", onProducerResume);
+  }
+  addDataProducer(transport, dataProducer) {
+    const dataProducerSample = {
+      id: dataProducer.id,
+      transportId: transport.id,
+      createdAt: Date.now(),
+      label: dataProducer.label,
+      protocol: dataProducer.protocol
+    };
+    this.sample.dataProducers.push(dataProducerSample);
+    dataProducer.observer.once("close", () => {
+      dataProducerSample.closedAt = Date.now();
+    });
+  }
+  addDataConsumer(transport, dataConsumer) {
+    const dataConsumerSample = {
+      id: dataConsumer.id,
+      dataProducerId: dataConsumer.dataProducerId,
+      transportId: transport.id,
+      createdAt: Date.now(),
+      label: dataConsumer.label,
+      protocol: dataConsumer.protocol
+    };
+    this.sample.dataConsumers.push(dataConsumerSample);
+    dataConsumer.observer.once("close", () => {
+      dataConsumerSample.closedAt = Date.now();
+    });
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.emit("close");
+  }
+  attachRouterListeners() {
+    this.router.observer.once("close", () => {
+      this.router.observer.off("newtransport", this.addTransport);
+      this.sample.closedAt = Date.now();
+      this.close();
+    });
+    this.router.observer.on("newtransport", this.addTransport);
+  }
+  _attachTransportObserverListeners(transport, transportSample, onClose) {
+    const onNewProducer = (producer) => {
+      this.addProducer(transport, producer);
+    };
+    const onNewConsumer = (consumer) => {
+      this.addConsumer(transport, consumer);
+    };
+    const onNewDataProducer = (dataProducer) => {
+      this.addDataProducer(transport, dataProducer);
+    };
+    const onNewDataConsumer = (dataConsumer) => {
+      this.addDataConsumer(transport, dataConsumer);
+    };
+    transport.observer.once("close", () => {
+      transport.observer.off("newproducer", onNewProducer);
+      transport.observer.off("newconsumer", onNewConsumer);
+      transport.observer.off("newdataproducer", onNewDataProducer);
+      transport.observer.off("newdataconsumer", onNewDataConsumer);
+      onClose?.();
+      transportSample.closedAt = Date.now();
+    });
+    transport.observer.on("newproducer", onNewProducer);
+    transport.observer.on("newconsumer", onNewConsumer);
+    transport.observer.on("newdataproducer", onNewDataProducer);
+    transport.observer.on("newdataconsumer", onNewDataConsumer);
+  }
+};
+
 // src/Observer.ts
-var logger6 = createLogger("Observer");
-var Observer = class extends import_events5.EventEmitter {
+var logger7 = createLogger("Observer");
+var Observer = class extends import_events6.EventEmitter {
   constructor(config = {
     updatePolicy: "update-when-all-call-updated",
     appData: {}
@@ -3325,6 +3661,7 @@ var Observer = class extends import_events5.EventEmitter {
   config;
   observedTURN = new ObservedTURN();
   observedCalls = /* @__PURE__ */ new Map();
+  observedMediasoupRouters = /* @__PURE__ */ new Map();
   updater;
   /** Ancestry base shared by all Observer-bus events originating at the observer. */
   eventScope = { observer: this };
@@ -3351,11 +3688,11 @@ var Observer = class extends import_events5.EventEmitter {
   }
   createObservedCall(settings) {
     if (this.closed) {
-      logger6.warn("Attempted to create a call (callId: %s) on a closed observer", settings.callId);
+      logger7.warn("Attempted to create a call (callId: %s) on a closed observer", settings.callId);
       return void 0;
     }
     if (this.observedCalls.has(settings.callId)) {
-      logger6.warn("Observed Call with id %s already exists; returning the existing instance", settings.callId);
+      logger7.warn("Observed Call with id %s already exists; returning the existing instance", settings.callId);
       return this.observedCalls.get(settings.callId);
     }
     const callSettings = {
@@ -3378,9 +3715,53 @@ var Observer = class extends import_events5.EventEmitter {
   getOrCreateObservedCall(settings) {
     return this.getObservedCall(settings.callId) ?? this.createObservedCall(settings);
   }
+  createObservedMediasoupRouter(settings) {
+    if (this.closed) {
+      logger7.warn("Attempted to create mediasoup router (id: %d) on a closed observer", settings.router.id);
+      return void 0;
+    }
+    if (this.observedMediasoupRouters.has(settings.router.id)) {
+      logger7.warn("Observed Mediasoup Router (id %s) already exists; returning the existing instance", settings.router.id);
+      return this.observedMediasoupRouters.get(settings.router.id);
+    }
+    const observedMediasoupRouter = new ObservedMediasoupRouter(settings);
+    const observedMediasoupRouterScope = {
+      observedMediasoupRouter,
+      observer: this
+    };
+    const directCall = settings.callId ? this.observedCalls.get(settings.callId) : void 0;
+    if (directCall) {
+      this.emit("mediasoup-router-matched-with-call", {
+        ...observedMediasoupRouterScope,
+        observedCall: directCall
+      });
+    } else if (settings.bindCallByWebRtcTransportId) {
+      const matchedCallIds = /* @__PURE__ */ new Set();
+      const onPeerConnectionAdded = ({ observedPeerConnection, observedCall }) => {
+        if (!observedMediasoupRouter.webrtcTransportIds.has(observedPeerConnection.peerConnectionId)) return;
+        if (matchedCallIds.has(observedCall.callId)) return;
+        matchedCallIds.add(observedCall.callId);
+        this.emit("mediasoup-router-matched-with-call", {
+          ...observedMediasoupRouterScope,
+          observedCall
+        });
+      };
+      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);
+    });
+    this.observedMediasoupRouters.set(observedMediasoupRouter.id, observedMediasoupRouter);
+    this.emit("mediasoup-router-added", observedMediasoupRouterScope);
+    return observedMediasoupRouter;
+  }
   close() {
     if (this.closed) {
-      return logger6.debug("Attempted to close twice");
+      return logger7.debug("Attempted to close twice");
     }
     this.closed = true;
     this.observedCalls.forEach((call) => call.close());
@@ -3393,7 +3774,7 @@ var Observer = class extends import_events5.EventEmitter {
     try {
       this.acceptMiddlewares.process({ sample, context });
     } catch (err) {
-      logger6.warn("An accept middleware threw; dropping the sample. %o", err);
+      logger7.warn("An accept middleware threw; dropping the sample. %o", err);
     }
     if (!sample.callId) {
       this._notify("sample-rejected", { ...this.eventScope, reason: "missing-callId", sample });
@@ -3449,8 +3830,8 @@ var Observer = class extends import_events5.EventEmitter {
 };
 
 // src/sinks/ClientSampleSink.ts
-var import_events6 = require("events");
-var ClientSampleSink = class extends import_events6.EventEmitter {
+var import_events7 = require("events");
+var ClientSampleSink = class extends import_events7.EventEmitter {
 };
 
 // src/sinks/JsonlFileSink.ts
@@ -3650,6 +4031,7 @@ function createP2pRemoteTrackResolverFactory() {
   ObservedInboundTrack,
   ObservedMediaPlayout,
   ObservedMediaSource,
+  ObservedMediasoupRouter,
   ObservedOutboundRtp,
   ObservedOutboundTrack,
   ObservedPeerConnection,