@voicenter-team/opensips-js 1.0.10

package/build/helpers/webrtcmetrics/index.d.ts

@@ -0,0 +1,63 @@
+export default class WebRTCMetrics {
+    constructor(cfg: any);
+    _config: {
+        refreshEvery: number;
+        startAfter: number;
+        stopAfter: number;
+        verbose: boolean;
+        pname: string;
+        cid: string;
+        uid: string;
+        record: boolean;
+        ticket: boolean;
+    };
+    _engine: ProbesEngine;
+    /**
+     * Change log level manually
+     * @param {string} level - The level of logs. Can be one of 'TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'SILENT'
+     */
+    setupLogLevel(level: string): void;
+    /**
+     * Get the version
+     */
+    get version(): any;
+    /**
+     * Get the library name
+     */
+    get name(): any;
+    /**
+     * Get the probes
+     */
+    get probes(): any[];
+    /**
+     * Create a new probe and return it
+     * @param {RTCPeerConnection} peerConnection The RTCPeerConnection instance to monitor
+     * @param {Object} options  The option
+     * @return {Probe} The probe created
+     */
+    createProbe(peerConnection: RTCPeerConnection, options: Object): Probe;
+    /**
+     * Start all probes
+     */
+    startAllProbes(): void;
+    /**
+     * Stop all probes
+     */
+    stopAllProbes(): void;
+    /**
+     * Is running
+     */
+    get running(): boolean;
+    /**
+     * Is Idle
+     */
+    get idle(): boolean;
+    /**
+     * Experimental
+     * Remote a probe
+     * @param {Probe} probe
+     */
+    removeProbe(probe: Probe): void;
+    set onresult(arg: any);
+}
+import ProbesEngine from "./engine";

package/build/helpers/webrtcmetrics/index.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("regenerator-runtime/runtime.js");
+const log_1 = require("./utils/log");
+const config_1 = require("./utils/config");
+const engine_1 = __importDefault(require("./engine"));
+const moduleName = "interface   ";
+class WebRTCMetrics {
+    constructor(cfg) {
+        this._config = (0, config_1.getGlobalConfig)(cfg);
+        (0, log_1.info)(moduleName, `welcome to ${this._config.name} version ${this._config.version}`);
+        (0, log_1.setVerboseLog)(this._config.verbose || false);
+        this._engine = new engine_1.default(this._config);
+    }
+    /**
+     * Change log level manually
+     * @param {string} level - The level of logs. Can be one of 'TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'SILENT'
+     */
+    setupLogLevel(level) {
+        (0, log_1.setLogLevel)(level);
+    }
+    /**
+     * Get the version
+     */
+    get version() {
+        return this._config.version;
+    }
+    /**
+     * Get the library name
+     */
+    get name() {
+        return this._config.name;
+    }
+    /**
+     * Get the probes
+     */
+    get probes() {
+        return this._engine.probes;
+    }
+    /**
+     * Create a new probe and return it
+     * @param {RTCPeerConnection} peerConnection The RTCPeerConnection instance to monitor
+     * @param {Object} options  The option
+     * @return {Probe} The probe created
+     */
+    createProbe(peerConnection, options) {
+        return this._engine.addNewProbe(peerConnection, options);
+    }
+    /**
+     * Start all probes
+     */
+    startAllProbes() {
+        this._engine.start();
+    }
+    /**
+     * Stop all probes
+     */
+    stopAllProbes() {
+        this._engine.stop();
+    }
+    /**
+     * Is running
+     */
+    get running() {
+        return this._engine.isRunning;
+    }
+    /**
+     * Is Idle
+     */
+    get idle() {
+        return this._engine.isIdle;
+    }
+    /**
+     * Experimental
+     * Remote a probe
+     * @param {Probe} probe
+     */
+    removeProbe(probe) {
+        this._engine.removeExistingProbe(probe);
+    }
+    set onresult(callback) {
+        if (callback) {
+            this._engine.registerCallback("onresult", callback);
+        }
+        else {
+            this._engine.unregisterCallback("onresult");
+        }
+    }
+}
+exports.default = WebRTCMetrics;

package/build/helpers/webrtcmetrics/metrics.d.ts

@@ -0,0 +1,2 @@
+import WebRTCMetrics from './index.js';
+export default WebRTCMetrics;

package/build/helpers/webrtcmetrics/metrics.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const index_js_1 = __importDefault(require("./index.js"));
+exports.default = index_js_1.default;

package/build/helpers/webrtcmetrics/probe.d.ts

@@ -0,0 +1,76 @@
+export default class Probe {
+    constructor(cfg: any);
+    _id: any;
+    _moduleName: any;
+    _config: any;
+    _collector: Collector;
+    /**
+     * Register a callback to 'onreport'
+     * Unregister when callback is null
+     * Fired when a report is received
+     */
+    set onreport(arg: any);
+    /**
+     * Register a callback to 'onticket'
+     * Unregister when callback is null
+     * Fired when a ticket is received
+     */
+    set onticket(arg: any);
+    /**
+     * Get the id of the Probe
+     */
+    get id(): any;
+    /**
+     * Get the name of the PeerConnection
+     */
+    get pname(): any;
+    /**
+     * Get the call identifier
+     */
+    get cid(): any;
+    /**
+     * Get the user identifier
+     */
+    get uid(): any;
+    set state(arg: string);
+    /**
+     * Get the state of the analyzer
+     * Value can be 'running' or 'idle'
+     */
+    get state(): string;
+    /**
+     * Add a custom event for that probe
+     * @param {String} name The name of the event
+     * @param {String} category The category of the event. Could be any strings
+     * @param {String} description A description. Could be empty
+     * @param {Date} at Optional. The date of the event
+     */
+    addCustomEvent(name: string, category: string, description: string, at?: Date): void;
+    /**
+     * Return true if the probe is running
+     */
+    get isRunning(): boolean;
+    /**
+     * Return true if the probe is idle
+     */
+    get isIdle(): boolean;
+    /**
+     * Set the user identifier
+     */
+    updateUserId(value: any): void;
+    /**
+     * Update the call identifier
+     */
+    updateCallId(value: any): void;
+    /**
+     * Set a probe to running state
+     */
+    start(): void;
+    /**
+     * Set a probe to idle state
+     */
+    stop(forced?: boolean): void;
+    takeReferenceStats(): Promise<any>;
+    collectStats(): Promise<any>;
+}
+import Collector from "./collector";

package/build/helpers/webrtcmetrics/probe.js

@@ -0,0 +1,153 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("./utils/log");
+const collector_1 = __importDefault(require("./collector"));
+const models_1 = require("./utils/models");
+const helper_1 = require("./utils/helper");
+class Probe {
+    constructor(cfg) {
+        this._id = (cfg.pname && cfg.pname.substr(0, 12).padEnd(12, " ")) || (0, helper_1.createProbeId)();
+        this._moduleName = this._id;
+        (0, log_1.info)(this._moduleName, "probe created");
+        this._config = cfg;
+        this._collector = new collector_1.default(this._config, this._id);
+    }
+    /**
+     * Register a callback to 'onreport'
+     * Unregister when callback is null
+     * Fired when a report is received
+     */
+    set onreport(callback) {
+        if (callback) {
+            this._collector.registerCallback("onreport", callback);
+        }
+        else {
+            this._collector.unregisterCallback("onreport");
+        }
+    }
+    /**
+     * Register a callback to 'onticket'
+     * Unregister when callback is null
+     * Fired when a ticket is received
+     */
+    set onticket(callback) {
+        if (callback) {
+            this._collector.registerCallback("onticket", callback);
+        }
+        else {
+            this._collector.unregisterCallback("onticket");
+        }
+    }
+    /**
+     * Get the id of the Probe
+     */
+    get id() {
+        return this._id;
+    }
+    /**
+     * Get the name of the PeerConnection
+     */
+    get pname() {
+        return this._config.pname;
+    }
+    /**
+     * Get the call identifier
+     */
+    get cid() {
+        return this._config.cid;
+    }
+    /**
+     * Get the user identifier
+     */
+    get uid() {
+        return this._config.uid;
+    }
+    /**
+     * Get the state of the analyzer
+     * Value can be 'running' or 'idle'
+     */
+    get state() {
+        return this._collector.state;
+    }
+    set state(newState) {
+        this._collector.state = newState;
+    }
+    /**
+     * Add a custom event for that probe
+     * @param {String} name The name of the event
+     * @param {String} category The category of the event. Could be any strings
+     * @param {String} description A description. Could be empty
+     * @param {Date} at Optional. The date of the event
+     */
+    addCustomEvent(name, category, description, at = new Date().toJSON()) {
+        this._collector.addCustomEvent(at, category, name, description);
+    }
+    /**
+     * Return true if the probe is running
+     */
+    get isRunning() {
+        return this._collector.state === models_1.COLLECTOR_STATE.RUNNING;
+    }
+    /**
+     * Return true if the probe is idle
+     */
+    get isIdle() {
+        return this._collector.state === models_1.COLLECTOR_STATE.IDLE;
+    }
+    /**
+     * Set the user identifier
+     */
+    updateUserId(value) {
+        this._config.uid = value;
+        this._collector.updateConfig(this._config);
+    }
+    /**
+     * Update the call identifier
+     */
+    updateCallId(value) {
+        this._config.cid = value;
+        this._collector.updateConfig(this._config);
+    }
+    /**
+     * Set a probe to running state
+     */
+    start() {
+        if (!this.isIdle) {
+            (0, log_1.warn)(this._moduleName, "probe is already running");
+            return;
+        }
+        this._collector.start();
+    }
+    /**
+     * Set a probe to idle state
+     */
+    stop(forced = false) {
+        if (!this.isRunning) {
+            return;
+        }
+        this._collector.stop(forced);
+    }
+    takeReferenceStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._collector.takeReferenceStats();
+        });
+    }
+    collectStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (this._collector.collectStats());
+        });
+    }
+}
+exports.default = Probe;

package/build/helpers/webrtcmetrics/utils/config.d.ts

@@ -0,0 +1,12 @@
+export function getConfig(peerConnection: any, cfg: {} | undefined, globalConfig: any): any;
+export function getGlobalConfig(cfg?: {}): {
+    refreshEvery: number;
+    startAfter: number;
+    stopAfter: number;
+    verbose: boolean;
+    pname: string;
+    cid: string;
+    uid: string;
+    record: boolean;
+    ticket: boolean;
+};

package/build/helpers/webrtcmetrics/utils/config.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalConfig = exports.getConfig = void 0;
+const models_1 = require("./models");
+const log_1 = require("./log");
+const moduleName = "config      ";
+const getConfig = (peerConnection, cfg = {}, globalConfig) => {
+    const config = Object.assign(Object.assign({}, globalConfig), cfg);
+    if (!cfg.pname) {
+        (0, log_1.warn)(moduleName, `Argument [String] 'cfg.pname' for the peerConnection name or id is missing - use generated '${globalConfig.pname}'`);
+    }
+    if (!cfg.cid) {
+        (0, log_1.warn)(moduleName, `Argument [String] 'cfg.cid' for the call name or id is missing - use generated '${globalConfig.cid}'`);
+    }
+    if (!cfg.uid) {
+        (0, log_1.warn)(moduleName, `Argument [String] 'cfg.uid' for the user name or id is missing - use generated '${globalConfig.uid}'`);
+    }
+    config.pc = peerConnection;
+    return config;
+};
+exports.getConfig = getConfig;
+const getGlobalConfig = (cfg = {}) => {
+    const config = Object.assign(Object.assign({}, models_1.defaultConfig), cfg);
+    config.name = (0, models_1.getLibName)();
+    config.version = (0, models_1.getVersion)();
+    return config;
+};
+exports.getGlobalConfig = getGlobalConfig;

package/build/helpers/webrtcmetrics/utils/helper.d.ts

@@ -0,0 +1,13 @@
+export function average(nums: any): number;
+export function createProbeId(): string;
+export function createCollectorId(): string;
+export function timeout(ms: any): Promise<any>;
+export function call(fct: any, context: any, value: any): void;
+export function volatilityValuesOfReports(reports: any, key: any, subKey: any, ssrc: any): number | null;
+export function averageValuesOfReports(reports: any, key: any, subKey: any, avoidZeroValue: boolean | undefined, ssrc: any): number | null;
+export function sumValuesOfReports(reports: any, key: any, subKey: any): any;
+export function minValueOfReports(reports: any, key: any, subKey: any, ssrc: any): number | null;
+export function maxValueOfReports(reports: any, key: any, subKey: any, ssrc: any): number | null;
+export function lastOfReports(reports: any, key: any, subKey: any, ssrc: any): any;
+export function getLastReport(reports: any): any;
+export function getSSRCDataFromBunch(ssrc: any, bunch: any, direction: any): {} | null;

package/build/helpers/webrtcmetrics/utils/helper.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSSRCDataFromBunch = exports.getLastReport = exports.lastOfReports = exports.maxValueOfReports = exports.minValueOfReports = exports.sumValuesOfReports = exports.averageValuesOfReports = exports.volatilityValuesOfReports = exports.call = exports.timeout = exports.createCollectorId = exports.createProbeId = exports.average = void 0;
+//import shortUUID from "./shortUUId";
+const generate_unique_id_1 = __importDefault(require("generate-unique-id"));
+const models_1 = require("./models");
+const getValues = (reports, key, subKey, avoidZeroValue = false, ssrc) => {
+    let arr = reports.map((report) => {
+        if (!subKey) {
+            return report[key];
+        }
+        if (!ssrc) {
+            return report[key][subKey];
+        }
+        const data = report[key][ssrc];
+        if (data) {
+            return data[subKey];
+        }
+        return null;
+    });
+    // Avoid null value
+    arr = arr.filter((item) => {
+        if (avoidZeroValue) {
+            return (Number.isFinite(item) && item > 0);
+        }
+        return Number.isFinite(item);
+    });
+    if (arr.length === 0) {
+        return [];
+    }
+    return arr;
+};
+const average = (nums) => (nums.reduce((a, b) => a + b, 0) / nums.length);
+exports.average = average;
+const createProbeId = () => (`probe-${(0, generate_unique_id_1.default)()}`);
+exports.createProbeId = createProbeId;
+const createCollectorId = () => (`coltr-${(0, generate_unique_id_1.default)()}`);
+exports.createCollectorId = createCollectorId;
+const timeout = (ms) => (new Promise((resolve) => setTimeout(resolve, ms)));
+exports.timeout = timeout;
+const call = (fct, context, value) => {
+    if (!context) {
+        fct(value);
+    }
+    else {
+        fct.call(context, value);
+    }
+};
+exports.call = call;
+const volatilityValuesOfReports = (reports, key, subKey, ssrc) => {
+    const values = getValues(reports, key, subKey, true, ssrc);
+    if (values.length === 0) {
+        return null;
+    }
+    const avg = values.reduce((p, c) => p + c, 0) / values.length;
+    if (avg === 0) {
+        return null;
+    }
+    const diff = values.map((data) => (Math.abs(avg - data)));
+    const totalDiff = diff.reduce((p, c) => p + c, 0);
+    const volatility = ((totalDiff / values.length) * 100) / avg;
+    return volatility;
+};
+exports.volatilityValuesOfReports = volatilityValuesOfReports;
+const averageValuesOfReports = (reports, key, subKey, avoidZeroValue = false, ssrc) => {
+    const values = getValues(reports, key, subKey, avoidZeroValue, ssrc);
+    if (values.length === 0) {
+        return null;
+    }
+    return values.reduce((p, c) => p + c, 0) / values.length;
+};
+exports.averageValuesOfReports = averageValuesOfReports;
+const sumValuesOfReports = (reports, key, subKey) => {
+    const values = getValues(reports, key, subKey);
+    return values.reduce((p, c) => p + c, 0);
+};
+exports.sumValuesOfReports = sumValuesOfReports;
+const minValueOfReports = (reports, key, subKey, ssrc) => {
+    const values = getValues(reports, key, subKey, true, ssrc);
+    if (values.length === 0) {
+        return null;
+    }
+    return Math.min(...values);
+};
+exports.minValueOfReports = minValueOfReports;
+const maxValueOfReports = (reports, key, subKey, ssrc) => {
+    const values = getValues(reports, key, subKey, false, ssrc);
+    if (values.length === 0) {
+        return null;
+    }
+    return Math.max(...values);
+};
+exports.maxValueOfReports = maxValueOfReports;
+const lastOfReports = (reports, key, subKey, ssrc) => {
+    const lastReport = reports.slice().pop();
+    if (!lastReport) {
+        return null;
+    }
+    if (!subKey) {
+        return lastReport[key];
+    }
+    if (!ssrc) {
+        return lastReport[key][subKey];
+    }
+    const ssrcData = lastReport[key][ssrc];
+    if (ssrcData) {
+        return ssrcData[subKey];
+    }
+    return null;
+};
+exports.lastOfReports = lastOfReports;
+const getLastReport = (reports) => (reports.slice().pop());
+exports.getLastReport = getLastReport;
+const getSSRCDataFromBunch = (ssrc, bunch, direction) => {
+    if (!bunch) {
+        return null;
+    }
+    const ssrcBunch = {};
+    let audioBunch = bunch[models_1.VALUE.AUDIO][ssrc];
+    if (!audioBunch) {
+        audioBunch = direction === models_1.DIRECTION.INBOUND ? Object.assign({}, models_1.defaultAudioMetricIn) : Object.assign({}, models_1.defaultAudioMetricOut);
+    }
+    ssrcBunch[models_1.VALUE.AUDIO] = audioBunch;
+    let videoBunch = bunch[models_1.VALUE.VIDEO][ssrc];
+    if (!videoBunch) {
+        videoBunch = direction === models_1.DIRECTION.INBOUND ? Object.assign({}, models_1.defaultVideoMetricIn) : Object.assign({}, models_1.defaultVideoMetricOut);
+    }
+    ssrcBunch[models_1.VALUE.VIDEO] = videoBunch;
+    return ssrcBunch;
+};
+exports.getSSRCDataFromBunch = getSSRCDataFromBunch;

package/build/helpers/webrtcmetrics/utils/log.d.ts

@@ -0,0 +1,7 @@
+export function setVerboseLog(shouldHaveVerboseLog: any): void;
+export function setLogLevel(logLevel: any): void;
+export function debug(name: any, message: any, data: any): void;
+export function trace(name: any, message: any): void;
+export function info(name: any, message: any): void;
+export function warn(name: any, message: any): void;
+export function error(name: any, message: any): void;

package/build/helpers/webrtcmetrics/utils/log.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = exports.warn = exports.info = exports.trace = exports.debug = exports.setLogLevel = exports.setVerboseLog = void 0;
+const log = __importStar(require("loglevel"));
+const getHeader = () => `${new Date().toISOString()} | metrics`;
+const format = (header, module, message) => `${header} | ${module} | ${message}`;
+log.setDefaultLevel(log.levels.TRACE);
+const setVerboseLog = (shouldHaveVerboseLog) => {
+    log.info(format(getHeader(), "log         ", `set log level to ${shouldHaveVerboseLog ? "verbose" : "info"}`));
+    log.setLevel(shouldHaveVerboseLog ? log.levels.TRACE : log.levels.INFO);
+};
+exports.setVerboseLog = setVerboseLog;
+const setLogLevel = (logLevel) => {
+    const levels = [...Object.keys(log.levels)];
+    if (levels.includes(logLevel)) {
+        log.info(format(getHeader(), "log         ", `update log level to ${logLevel.toLowerCase()}`));
+        log.setLevel(logLevel);
+    }
+    else {
+        log.warn(format(getHeader(), "log         ", "Incorrect log level please choose one of "), levels);
+    }
+};
+exports.setLogLevel = setLogLevel;
+const debug = (name, message, data) => {
+    if (data) {
+        log.debug(format(getHeader(), name, message), data);
+    }
+    else {
+        log.debug(format(getHeader(), name, message));
+    }
+};
+exports.debug = debug;
+const trace = (name, message) => {
+    log.info(format(getHeader(), name, message));
+};
+exports.trace = trace;
+const info = (name, message) => {
+    log.info(format(getHeader(), name, message));
+};
+exports.info = info;
+const warn = (name, message) => {
+    log.warn(format(getHeader(), name, message));
+};
+exports.warn = warn;
+const error = (name, message) => {
+    log.error(format(getHeader(), name, message));
+};
+exports.error = error;