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

package/dist/index.mjs

@@ -37,8 +37,8 @@ function createLogger(moduleName) {
     }
   }();
 }
-function setObserverLogger(logger7) {
-  mainLogger = logger7;
+function setObserverLogger(logger8) {
+  mainLogger = logger8;
 }
 
 // src/ObservedCall.ts
@@ -2811,6 +2811,8 @@ var ObservedCall = class extends EventEmitter3 {
       case "update-when-all-client-updated":
         this.updater = new OnAllClientCallUpdater(this);
         break;
+      case "none":
+        break;
     }
     this.settings = {
       closeCallIfEmptyForMs: settings.closeCallIfEmptyForMs
@@ -2983,7 +2985,7 @@ var ObservedCall = class extends EventEmitter3 {
 };
 
 // src/Observer.ts
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 
 // src/ObservedTURN.ts
 import { EventEmitter as EventEmitter4 } from "events";
@@ -3229,9 +3231,344 @@ var MiddlewareProcessor = class {
   }
 };
 
+// src/ObservedMediasoupRouter.ts
+import { EventEmitter as EventEmitter5 } from "events";
+var logger6 = createLogger("ObservedMediasoupRouter");
+var ObservedMediasoupRouter = class extends EventEmitter5 {
+  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 EventEmitter5 {
+var logger7 = createLogger("Observer");
+var Observer = class extends EventEmitter6 {
   constructor(config = {
     updatePolicy: "update-when-all-call-updated",
     appData: {}
@@ -3248,11 +3585,14 @@ var Observer = class extends EventEmitter5 {
       case "update-when-all-call-updated":
         this.updater = new OnAllCallObserverUpdater(this);
         break;
+      case "none":
+        break;
     }
   }
   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 };
@@ -3279,11 +3619,11 @@ var Observer = class extends EventEmitter5 {
   }
   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 = {
@@ -3306,9 +3646,53 @@ var Observer = class extends EventEmitter5 {
   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());
@@ -3321,7 +3705,7 @@ var Observer = class extends EventEmitter5 {
     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 });
@@ -3377,8 +3761,8 @@ var Observer = class extends EventEmitter5 {
 };
 
 // src/sinks/ClientSampleSink.ts
-import { EventEmitter as EventEmitter6 } from "events";
-var ClientSampleSink = class extends EventEmitter6 {
+import { EventEmitter as EventEmitter7 } from "events";
+var ClientSampleSink = class extends EventEmitter7 {
 };
 
 // src/sinks/JsonlFileSink.ts
@@ -3577,6 +3961,7 @@ export {
   ObservedInboundTrack,
   ObservedMediaPlayout,
   ObservedMediaSource,
+  ObservedMediasoupRouter,
   ObservedOutboundRtp,
   ObservedOutboundTrack,
   ObservedPeerConnection,