@observertc/observer-js 0.9.22-beta → 0.9.24-beta

package/src/evaluators/SetClientsCoordinateEvaluator.ts

@@ -0,0 +1,78 @@
+import { createLogger } from '../common/logger';
+import * as Models from '../models/Models';
+import ipaddr from 'ipaddr.js';
+import { EvaluatorProcess } from '..';
+
+export const logger = createLogger('SetClientsCoordinateEvaluator');
+
+export type ClientCoordinate = {
+	latitude: number;
+	longitude: number;
+};
+
+export type GetClientCoordinate = (ipAddress: string) => ClientCoordinate | undefined;
+
+export function createSetClientsCoordinateEvaluator(
+	getCoordinate: GetClientCoordinate,
+): EvaluatorProcess {
+	const process: EvaluatorProcess = async (context) => {
+
+		const clientIds = new Set<string>();
+
+		for (const observedCall of context.observedCalls.observedCalls()) {
+			for (const observedClient of observedCall.observedClients()) {
+				clientIds.add(observedClient.clientId);
+			}
+		}
+		if (clientIds.size < 1) return;
+
+		const storedClients = await context.storages.clientStorage.getAll(clientIds);
+		
+		for (const observedCall of context.observedCalls.observedCalls()) {
+			for (const observedClient of observedCall.observedClients()) {
+				const { clientId } = observedClient;
+				const storedClient = storedClients.get(clientId);
+
+				if (!storedClient || storedClient.coordinates) continue;
+				
+				let ipAddress: string | undefined;
+
+				searchForIp: for (const observedPeerConnection of observedClient.observedPeerConnections()) {
+					for (const iceLocalCandidate of observedPeerConnection.iceLocalCandidates()) {
+						if (!iceLocalCandidate.address) continue;
+
+						try {
+							const addr = ipaddr.parse(iceLocalCandidate.address);
+							
+							ipAddress = addr.toString();
+
+							break searchForIp;
+						} catch (e) {
+							logger.warn(`Failed to parse ip address: ${iceLocalCandidate.address}`, e);
+
+							continue;
+						}
+						
+					}
+				}
+
+				if (!ipAddress) continue;
+
+				try {
+					const coordinate = getCoordinate(ipAddress);
+
+					if (!coordinate) continue;
+
+					storedClient.coordinates = new Models.ClientCoordinate({
+						latitude: coordinate.latitude,
+						longitude: coordinate.longitude,
+					});
+				} catch (e) {
+					logger.warn(`Failed to get coordinate for ip address: ${ipAddress}`, e);
+				}
+			}
+		}
+	};
+	
+	return process;
+}

package/src/index.ts

@@ -23,6 +23,7 @@ export type { SfuTransportEntry } from './entries/SfuTransportEntry';
 export type { SfuInboundRtpPadEntry } from './entries/SfuInboundRtpPadEntry';
 export type { SfuOutboundRtpPadEntry } from './entries/SfuOutboundRtpPadEntry';
 export type { SfuSctpChannelEntry } from './entries/SfuSctpChannelEntry';
+export type { GetClientCoordinate, ClientCoordinate } from './evaluators/SetClientsCoordinateEvaluator';
 
 export type {
 	Samples,

package/src/middlewares/visitors/visitInboundAudioTrack.ts

@@ -92,7 +92,7 @@ export function visitInboundAudioTrack(
 			} = inboundAudioSample;
 
 			const ssrc = BigInt(sample_ssrc);
-			const videoStats = new Samples_ClientSample_InboundAudioTrack({
+			const audioStats = new Samples_ClientSample_InboundAudioTrack({
 				ssrc,
 				bytesReceived: BigInt(sample_bytesReceived ?? -1),
 				bytesSent: BigInt(sample_bytesSent ?? -1),
@@ -103,9 +103,11 @@ export function visitInboundAudioTrack(
 				...sample,
 			});
 
-			statsMap.set(ssrc, videoStats);
+			statsMap.set(ssrc, audioStats);
 		}
 	}
 	storedInboundAudioTrack.ssrc = [ ...statsMap.keys() ];
 	storedInboundAudioTrack.videoStats = Array.from(statsMap.values());
+
+	
 }

package/src/middlewares/visitors/visitInboundVideoTrack.ts

@@ -96,6 +96,7 @@ export function visitInboundVideoTrack(
 			} = inboundVideoSample;
 
 			const ssrc = BigInt(sample_ssrc);
+			// const lastVideoStats = storedInboundVideoTrack.videoStats.find((stats) => stats.ssrc === ssrc);
 			const videoStats = new Samples_ClientSample_InboundVideoTrack({
 				ssrc,
 				bytesReceived: BigInt(sample_bytesReceived ?? -1),

package/src/middlewares/visitors/visitPeerConnection.ts

@@ -80,67 +80,72 @@ export function visitPeerConnection(
 		reports.addIceCandidatePairReport(report);
 	}
 
-	if (fetchSamples) {
-		storedPeerConnection.icelocalCandidates = [];
-		for (const iceLocalCandidate of observedPeerConnection.iceLocalCandidates()) {
-			const {
-				priority,
-				...sample
-			} = iceLocalCandidate;
-
-			storedPeerConnection.icelocalCandidates.push(new Samples_ClientSample_IceLocalCandidate({
-				...sample,
-				priority: BigInt(priority ?? -1)
-			}));
-		}
+	if (!fetchSamples) return;
 
-		storedPeerConnection.iceRemoteCandidates = [];
-		for (const iceRemoteCandidate of observedPeerConnection.iceRemoteCandidates()) {
-			const {
-				priority,
-				...sample
-			} = iceRemoteCandidate;
-
-			storedPeerConnection.iceRemoteCandidates.push(new Samples_ClientSample_IceRemoteCandidate({
-				...sample,
-				priority: BigInt(priority ?? -1)
-			}));
-		}
+	// restricted area
 
-		storedPeerConnection.iceCandidatePairs = [];
-		for (const iceCandidatePair of observedPeerConnection.iceCandidatePairs()) {
-			const {
-				bytesDiscardedOnSend,
-				bytesReceived,
-				bytesSent,
-				lastPacketReceivedTimestamp,
-				lastPacketSentTimestamp,
-				...sample
-			} = iceCandidatePair;
-
-			storedPeerConnection.iceCandidatePairs.push(new Samples_ClientSample_IceCandidatePair({
-				...sample,
-				bytesDiscardedOnSend: BigInt(bytesDiscardedOnSend ?? -1),
-				bytesReceived: BigInt(bytesReceived ?? -1),
-				bytesSent: BigInt(bytesSent ?? -1),
-				lastPacketReceivedTimestamp: BigInt(lastPacketReceivedTimestamp ?? -1),
-				lastPacketSentTimestamp: BigInt(lastPacketSentTimestamp ?? -1),
-			}));
-		}
+	storedPeerConnection.icelocalCandidates = [];
+	for (const iceLocalCandidate of observedPeerConnection.iceLocalCandidates()) {
+		const {
+			priority,
+			...sample
+		} = iceLocalCandidate;
 
-		storedPeerConnection.transports = [];
-		for (const pcTransport of observedPeerConnection.transportSamples()) {
-			const {
-				bytesReceived,
-				bytesSent,
-				...sample
-			} = pcTransport;
-
-			storedPeerConnection.transports.push(new Samples_ClientSample_PeerConnectionTransport({
-				...sample,
-				bytesReceived: BigInt(bytesReceived ?? -1),
-				bytesSent: BigInt(bytesSent ?? -1),
-			}));
-		}
+		storedPeerConnection.icelocalCandidates.push(new Samples_ClientSample_IceLocalCandidate({
+			...sample,
+			priority: BigInt(priority ?? -1)
+		}));
 	}
+
+	storedPeerConnection.iceRemoteCandidates = [];
+	for (const iceRemoteCandidate of observedPeerConnection.iceRemoteCandidates()) {
+		const {
+			priority,
+			...sample
+		} = iceRemoteCandidate;
+
+		storedPeerConnection.iceRemoteCandidates.push(new Samples_ClientSample_IceRemoteCandidate({
+			...sample,
+			priority: BigInt(priority ?? -1)
+		}));
+	}
+
+	storedPeerConnection.iceCandidatePairs = [];
+	for (const iceCandidatePair of observedPeerConnection.iceCandidatePairs()) {
+		const {
+			bytesDiscardedOnSend,
+			bytesReceived,
+			bytesSent,
+			lastPacketReceivedTimestamp,
+			lastPacketSentTimestamp,
+			...sample
+		} = iceCandidatePair;
+
+		storedPeerConnection.iceCandidatePairs.push(new Samples_ClientSample_IceCandidatePair({
+			...sample,
+			bytesDiscardedOnSend: BigInt(bytesDiscardedOnSend ?? -1),
+			bytesReceived: BigInt(bytesReceived ?? -1),
+			bytesSent: BigInt(bytesSent ?? -1),
+			lastPacketReceivedTimestamp: BigInt(lastPacketReceivedTimestamp ?? -1),
+			lastPacketSentTimestamp: BigInt(lastPacketSentTimestamp ?? -1),
+		}));
+	}
+
+	storedPeerConnection.transports = [];
+	for (const pcTransport of observedPeerConnection.transportSamples()) {
+		const {
+			bytesReceived,
+			bytesSent,
+			...sample
+		} = pcTransport;
+
+		storedPeerConnection.transports.push(new Samples_ClientSample_PeerConnectionTransport({
+			...sample,
+			bytesReceived: BigInt(bytesReceived ?? -1),
+			bytesSent: BigInt(bytesSent ?? -1),
+		}));
+	}
+
+	// storedPeerConnection.stats = new Models.PeerConnectionStats({
+	// });
 }

package/src/models/Models.ts

@@ -68,6 +68,49 @@ export class Call extends Message<Call> {
   }
 }
 
+/**
+ * @generated from message org.observertc.observer.models.ClientCoordinate
+ */
+export class ClientCoordinate extends Message<ClientCoordinate> {
+  /**
+   * @generated from field: required float latitude = 1;
+   */
+  latitude?: number;
+
+  /**
+   * @generated from field: required float longitude = 2;
+   */
+  longitude?: number;
+
+  constructor(data?: PartialMessage<ClientCoordinate>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "org.observertc.observer.models.ClientCoordinate";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "latitude", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
+    { no: 2, name: "longitude", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ClientCoordinate {
+    return new ClientCoordinate().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ClientCoordinate {
+    return new ClientCoordinate().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ClientCoordinate {
+    return new ClientCoordinate().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: ClientCoordinate | PlainMessage<ClientCoordinate> | undefined, b: ClientCoordinate | PlainMessage<ClientCoordinate> | undefined): boolean {
+    return proto2.util.equals(ClientCoordinate, a, b);
+  }
+}
+
 /**
  * @generated from message org.observertc.observer.models.Client
  */
@@ -147,6 +190,19 @@ export class Client extends Message<Client> {
    */
   engine?: Samples_ClientSample_Engine;
 
+  /**
+   *  message Stats {
+   *    optional double maxRttInS = 1;
+   *    optional double minRttInS = 2;
+   *    optional string location = 3;
+   *  }
+   *
+   *  optional Stats stats = 13;
+   *
+   * @generated from field: optional org.observertc.observer.models.ClientCoordinate coordinates = 16;
+   */
+  coordinates?: ClientCoordinate;
+
   constructor(data?: PartialMessage<Client>) {
     super();
     proto2.util.initPartial(data, this);
@@ -170,6 +226,7 @@ export class Client extends Message<Client> {
     { no: 13, name: "operationSystem", kind: "message", T: Samples_ClientSample_OperationSystem, opt: true },
     { no: 14, name: "platform", kind: "message", T: Samples_ClientSample_Platform, opt: true },
     { no: 15, name: "engine", kind: "message", T: Samples_ClientSample_Engine, opt: true },
+    { no: 16, name: "coordinates", kind: "message", T: ClientCoordinate, opt: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Client {
@@ -322,6 +379,104 @@ export class PeerConnection extends Message<PeerConnection> {
   }
 }
 
+/**
+ * @generated from message org.observertc.observer.models.InboundTrackVideoStats
+ */
+export class InboundTrackVideoStats extends Message<InboundTrackVideoStats> {
+  /**
+   * @generated from field: required int32 ssrc = 1;
+   */
+  ssrc?: number;
+
+  /**
+   * @generated from field: optional float fps = 2;
+   */
+  fps?: number;
+
+  /**
+   * @generated from field: optional org.observertc.schemas.protobuf.Samples.ClientSample.InboundVideoTrack sample = 4;
+   */
+  sample?: Samples_ClientSample_InboundVideoTrack;
+
+  constructor(data?: PartialMessage<InboundTrackVideoStats>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "org.observertc.observer.models.InboundTrackVideoStats";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "ssrc", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    { no: 2, name: "fps", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
+    { no: 4, name: "sample", kind: "message", T: Samples_ClientSample_InboundVideoTrack, opt: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InboundTrackVideoStats {
+    return new InboundTrackVideoStats().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InboundTrackVideoStats {
+    return new InboundTrackVideoStats().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InboundTrackVideoStats {
+    return new InboundTrackVideoStats().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: InboundTrackVideoStats | PlainMessage<InboundTrackVideoStats> | undefined, b: InboundTrackVideoStats | PlainMessage<InboundTrackVideoStats> | undefined): boolean {
+    return proto2.util.equals(InboundTrackVideoStats, a, b);
+  }
+}
+
+/**
+ * @generated from message org.observertc.observer.models.InboundTrackStats
+ */
+export class InboundTrackStats extends Message<InboundTrackStats> {
+  /**
+   * @generated from field: optional float bitrate = 1;
+   */
+  bitrate?: number;
+
+  /**
+   * @generated from field: optional float fractionalLoss = 2;
+   */
+  fractionalLoss?: number;
+
+  /**
+   * @generated from field: optional float avgRttInS = 3;
+   */
+  avgRttInS?: number;
+
+  constructor(data?: PartialMessage<InboundTrackStats>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "org.observertc.observer.models.InboundTrackStats";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "bitrate", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
+    { no: 2, name: "fractionalLoss", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
+    { no: 3, name: "avgRttInS", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): InboundTrackStats {
+    return new InboundTrackStats().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): InboundTrackStats {
+    return new InboundTrackStats().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): InboundTrackStats {
+    return new InboundTrackStats().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: InboundTrackStats | PlainMessage<InboundTrackStats> | undefined, b: InboundTrackStats | PlainMessage<InboundTrackStats> | undefined): boolean {
+    return proto2.util.equals(InboundTrackStats, a, b);
+  }
+}
+
 /**
  * @generated from message org.observertc.observer.models.InboundTrack
  */

package/src/processes/joinClientProcess.ts

@@ -86,6 +86,9 @@ export function createJoinClientProcess(
 
 			const callEvent = createCallStartedEventReport(serviceId, roomId, callId, Number(started));
 
+			// if ((evaluatorContext?.observedCalls as ObservedCalls).getObservedCall(callId)) {
+			// 	reports.addCallEventReport(callEvent);
+			// }
 			reports.addCallEventReport(callEvent);
 			evaluatorContext?.startedCallIds.push(callId);
 		}

package/src/samples/ObservedCall.ts

@@ -4,6 +4,7 @@ export interface ObservedCall {
 	readonly serviceId: string;
 	readonly roomId: string;
 	readonly callId: string;
+	readonly createCallStartedReport?: boolean;
 	observedClients(): IterableIterator<ObservedClient>;
 	getObservedClient(clientId: string): ObservedClient | undefined;
 }
@@ -36,7 +37,7 @@ export class ObservedCallBuilder {
 			observedClients: () => observedClients.values(),
 			getObservedClient: (clientId) => observedClients.get(clientId),
 		};
-
+		
 		for (const observedClientBuilder of this._observedClientBuilders.values()) {
 			const observedClient = observedClientBuilder.build(observedCall);
 

package/src/sinks/ObserverSink.ts

@@ -282,6 +282,7 @@ export class SinkImpl implements ReportsCollector, ObserverReportsEmitter {
 
 	public emit(): number {
 		let result = 0;
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		const checkAndEmit = (eventName: keyof SinkEventsMap, reports: any[]) => {
 			if (reports.length > 0) {
 				this._emit(eventName, { reports });

package/src/sources/ObservedCallSource.ts

@@ -7,15 +7,19 @@ export type ObservedCallSourceConfig<T extends Record<string, unknown>> = {
 	readonly mediaUnitId: string;
 	readonly roomId: string;
 	readonly callId: string;
+
+	createCallStartedReport?: boolean,
 };
 
 export interface ObservedCallSource<T extends Record<string, unknown> = Record<string, unknown>> extends ObservedCallSourceConfig<T> {
 	readonly closed: boolean;
-	readonly clients: ReadonlyMap<string, ObservedClientSource>;
+	readonly clients: IterableIterator<ObservedClientSource>;
+
+	getClientSource<U extends Record<string, unknown>>(clientId: string): ObservedClientSource<U> | undefined;
 
 	createClientSource<U extends Record<string, unknown> = Record<string, unknown>>(
 		context: PartialBy<ObservedClientSourceConfig<U>, 'joined' | 'mediaUnitId' | 'serviceId' | 'callId' | 'roomId'>
-	): ObservedClientSource;
+	): ObservedClientSource<U>;
 
 	// automatically close every
 	close(): void;

package/src/sources/Sources.ts

@@ -42,12 +42,16 @@ export class Sources {
 
 	public constructor(public readonly config: SourcesConfig) {}
 
-	public getCallSource(callId: string) {
-		return this._callSources.get(callId);
+	public getCallSource<T extends Record<string, unknown> = Record<string, unknown>>(callId: string): ObservedCallSource<T> | undefined {
+		if (!this._callSources.has(callId)) return;
+		
+		return this._callSources.get(callId) as ObservedCallSource<T>;
 	}
 
-	public getSfuSource(sfuId: string) {
-		return this._sfuSources.get(sfuId);
+	public getSfuSource<T extends Record<string, unknown> = Record<string, unknown>>(sfuId: string) {
+		if (!this._sfuSources.has(sfuId)) return;
+
+		return this._sfuSources.get(sfuId) as ObservedSfuSource<T>;
 	}
 
 	public on<K extends keyof SourcesEvents>(event: K, listener: (data: SourcesEvents[K]) => void): this {
@@ -82,15 +86,22 @@ export class Sources {
 			appData,
 			serviceId,
 			mediaUnitId,
-			clients: clientSources,
+			get clients() {
+				return clientSources.values();
+			},
+
+			getClientSource: <U extends Record<string, unknown> = Record<string, unknown>>(clientId: string) => {
+				if (!clientSources.has(clientId)) return;
+				else return clientSources.get(clientId) as ObservedClientSource<U>;
+			},
 
 			createClientSource: <U extends Record<string, unknown> = Record<string, unknown>>(context: ObservedClientSourceConfig<U>) => {
 				const existingClientSource = clientSources.get(context.clientId);
 
-				if (existingClientSource) return existingClientSource;
+				if (existingClientSource) return existingClientSource as ObservedClientSource<U>;
 				
 				const { appData: clientAppData, ...clientConfig } = context;
-				const clientSource = this._createClientSource<U>({
+				const clientSource = this._createClientSource<U>(callSource, {
 					...callConfig,
 					...clientConfig,
 					appData: clientAppData,
@@ -105,7 +116,7 @@ export class Sources {
 				};
 				clientSources.set(context.clientId, clientSource);
 				
-				return clientSource;
+				return clientSource as ObservedClientSource<U>;
 			},
 			close: () => {
 				if (closed) {
@@ -129,7 +140,7 @@ export class Sources {
 		return callSource;
 	}
 
-	private _createClientSource<T extends Record<string, unknown> = Record<string, unknown>>(config: PartialBy<ObservedClientSourceConfig<T>, 'joined'>): ObservedClientSource<T> {
+	private _createClientSource<T extends Record<string, unknown> = Record<string, unknown>>(callSource: ObservedCallSource, config: PartialBy<ObservedClientSourceConfig<T>, 'joined'>): ObservedClientSource<T> {
 		let closed = false;
 		const {
 			appData,
@@ -145,9 +156,9 @@ export class Sources {
 				if (closed) {
 					throw new Error('Cannot accept ClientSample, because the ClientSource is closed');
 				}
-				const observedCallBuilder = this._observedCallsBuilder.getOrCreateObservedCallBuilder(config.callId, () => {
+				const observedCallBuilder = this._observedCallsBuilder.getOrCreateObservedCallBuilder(callSource.callId, () => {
 					return {
-						...source,
+						...callSource,
 					};
 				});
 				const observedClientBuilder = observedCallBuilder.getOrCreateObservedClientBuilder(config.clientId, () => {