genesys-cloud-streaming-client 17.0.2-develop.85 → 17.0.2-develop.88

package/dist/cjs/client.d.ts

@@ -24,6 +24,8 @@ export declare class Client extends EventEmitter {
     private extensions;
     private connectionManager;
     private channelReuses;
+    private backoffReductionTimer;
+    private hasMadeInitialAttempt;
     private boundStanzaDisconnect?;
     private boundStanzaNoLongerSubscribed?;
     private boundStanzaDuplicateId?;
@@ -45,6 +47,11 @@ export declare class Client extends EventEmitter {
     private handleNoLongerSubscribed;
     private handleDuplicateId;
     disconnect(): Promise<any>;
+    private getConnectionData;
+    private setConnectionData;
+    private increaseBackoff;
+    private decreaseBackoff;
+    private getStartingDelay;
     connect(connectOpts?: StreamingClientConnectOptions): Promise<void>;
     private backoffConnectRetryHandler;
     private makeConnectionAttempt;

package/dist/cjs/client.js

@@ -26,6 +26,9 @@ const STANZA_DISCONNECTED = 'stanzaDisconnected';
 const NO_LONGER_SUBSCRIBED = 'notify:no_longer_subscribed';
 const DUPLICATE_ID = 'notify:duplicate_id';
 const MAX_CHANNEL_REUSES = 10;
+const SESSION_STORE_KEY = 'sc_connectionData';
+const BACKOFF_DECREASE_DELAY_MULTIPLIER = 5;
+const INITIAL_DELAY = 2000;
 class Client extends events_1.default {
     constructor(options) {
         super();
@@ -37,6 +40,7 @@ class Client extends events_1.default {
         this.autoReconnect = true;
         this.extensions = [];
         this.channelReuses = 0;
+        this.hasMadeInitialAttempt = false;
         this.http = new http_client_1.HttpClient();
         this.reconnectOnNoLongerSubscribed = options.reconnectOnNoLongerSubscribed !== false;
         this.config = {
@@ -213,6 +217,64 @@ class Client extends events_1.default {
                 .then(resolve);
         }, 5000, 'disconnecting streaming service');
     }
+    getConnectionData() {
+        const connectionDataStr = sessionStorage.getItem(SESSION_STORE_KEY);
+        const defaultValue = {
+            currentDelayMs: 0,
+        };
+        if (connectionDataStr) {
+            try {
+                return JSON.parse(connectionDataStr);
+            }
+            catch (e) {
+                this.logger.warn('failed to parse streaming client connection data');
+                return defaultValue;
+            }
+        }
+        return defaultValue;
+    }
+    setConnectionData(data) {
+        sessionStorage.setItem(SESSION_STORE_KEY, JSON.stringify(data));
+    }
+    increaseBackoff() {
+        const connectionData = this.getConnectionData();
+        const currentDelay = Math.max(connectionData.currentDelayMs * 2, INITIAL_DELAY);
+        this.setConnectionData({
+            currentDelayMs: currentDelay,
+            delayMsAfterNextReduction: currentDelay / 2,
+            nextDelayReductionTime: new Date().getTime() + (currentDelay * BACKOFF_DECREASE_DELAY_MULTIPLIER),
+            timeOfTotalReset: new Date().getTime() + 1000 * 60 * 60 // one hour in the future
+        });
+    }
+    decreaseBackoff(newAmountMs) {
+        const data = this.getConnectionData();
+        const msUntilNextReduction = newAmountMs * BACKOFF_DECREASE_DELAY_MULTIPLIER;
+        const newConnectionData = {
+            currentDelayMs: newAmountMs,
+            delayMsAfterNextReduction: newAmountMs / 2,
+            nextDelayReductionTime: new Date().getTime() + (msUntilNextReduction),
+            timeOfTotalReset: data.timeOfTotalReset
+        };
+        // if we are past the total reset time, do that instead
+        if (data.timeOfTotalReset && data.timeOfTotalReset < new Date().getTime() || newAmountMs < INITIAL_DELAY) {
+            this.logger.debug('decreaseBackoff() called, but timeOfTotalReset has elasped or next delay is below 2s. Resetting backoff');
+            return this.setConnectionData({
+                currentDelayMs: 0
+            });
+        }
+        this.setConnectionData(newConnectionData);
+        clearTimeout(this.backoffReductionTimer);
+        this.logger.debug('Setting timer for next backoff reduction since we haven\'t reached total reset', { msUntilReduction: msUntilNextReduction, delayMsAfterNextReduction: newConnectionData.delayMsAfterNextReduction });
+        this.backoffReductionTimer = setTimeout(() => this.decreaseBackoff(newConnectionData.delayMsAfterNextReduction), msUntilNextReduction);
+    }
+    getStartingDelay(connectionData, maxDelay) {
+        // we don't want the delay to ever be less than 2 seconds
+        const minDelay = Math.max(connectionData.currentDelayMs, INITIAL_DELAY);
+        if (connectionData.timeOfTotalReset && connectionData.timeOfTotalReset < new Date().getTime()) {
+            return INITIAL_DELAY;
+        }
+        return Math.min(minDelay, maxDelay);
+    }
     async connect(connectOpts) {
         var _a;
         if (this.connecting) {
@@ -227,13 +289,29 @@ class Client extends events_1.default {
             // this maintains the previous functionality
             maxAttempts = Infinity;
         }
+        clearTimeout(this.backoffReductionTimer);
+        const connectionData = this.getConnectionData();
+        const startingDelay = this.getStartingDelay(connectionData, maxDelay);
+        const delayFirstAttempt = this.hasMadeInitialAttempt;
+        this.hasMadeInitialAttempt = true;
         try {
-            await exponential_backoff_1.backOff(() => this.makeConnectionAttempt(), {
-                jitter: 'full',
+            await exponential_backoff_1.backOff(async () => {
+                const connectionData = this.getConnectionData();
+                await this.makeConnectionAttempt();
+                if (connectionData.nextDelayReductionTime) {
+                    const msUntilReduction = connectionData.nextDelayReductionTime - new Date().getTime();
+                    this.logger.debug('Setting timer for next backoff reduction', { msUntilReduction, delayMsAfterNextReduction: connectionData.delayMsAfterNextReduction });
+                    this.backoffReductionTimer = setTimeout(() => this.decreaseBackoff(connectionData.delayMsAfterNextReduction || 0), msUntilReduction);
+                }
+            }, {
+                jitter: 'none',
                 maxDelay,
                 numOfAttempts: maxAttempts,
-                startingDelay: 2000,
-                retry: this.backoffConnectRetryHandler.bind(this, { maxConnectionAttempts: maxAttempts })
+                startingDelay,
+                delayFirstAttempt,
+                retry: this.backoffConnectRetryHandler.bind(this, {
+                    maxConnectionAttempts: maxAttempts,
+                }),
             });
         }
         catch (err) {
@@ -317,14 +395,13 @@ class Client extends events_1.default {
                 let retryDelay = parseInt(retryAfter, 10) * 1000;
                 additionalErrorDetails.retryDelay = retryDelay;
                 this.logger.error('Failed streaming client connection attempt, respecting retry-after header and will retry afterwards.', additionalErrorDetails, { skipServer: err instanceof offline_error_1.default });
-                await new Promise((resolve) => {
-                    setTimeout(resolve, retryDelay);
-                });
+                await utils_1.delay(retryDelay);
                 this.logger.debug('finished waiting for retry-after');
                 return true;
             }
         }
         this.logger.error('Failed streaming client connection attempt, retrying', additionalErrorDetails, { skipServer: err instanceof offline_error_1.default });
+        this.increaseBackoff();
         return true;
     }
     async makeConnectionAttempt() {
@@ -373,7 +450,7 @@ class Client extends events_1.default {
         }
         if (!this.hardReconnectRequired) {
             this.channelReuses++;
-            if (this.channelReuses > MAX_CHANNEL_REUSES) {
+            if (this.channelReuses >= MAX_CHANNEL_REUSES) {
                 this.logger.warn('Forcing a hard reconnect due to max channel reuses', { channelId: this.config.channelId, channelReuses: this.channelReuses });
                 this.channelReuses = 0;
                 this.hardReconnectRequired = true;

package/dist/cjs/types/interfaces.d.ts

@@ -247,3 +247,9 @@ export declare type MediaStat = InsightAction<{
     elapsedMsFromInitialRequest?: number;
 }>;
 export declare type NRProxyStat = FirstAlertingConversationStat | MediaStat;
+export declare type SCConnectionData = {
+    currentDelayMs: number;
+    delayMsAfterNextReduction?: number;
+    nextDelayReductionTime?: number;
+    timeOfTotalReset?: number;
+};

package/dist/cjs/utils.d.ts

@@ -1,4 +1,5 @@
 export declare function timeoutPromise(fn: Function, timeoutMs: number, msg: string, details?: any): Promise<any>;
+export declare function delay(ms: number): Promise<void>;
 export declare function splitIntoIndividualTopics(topicString: string): string[];
 export declare const isAcdJid: (jid: string) => boolean;
 export declare const isScreenRecordingJid: (jid: string) => boolean;

package/dist/cjs/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculatePayloadSize = exports.parseJwt = exports.retryPromise = exports.isVideoJid = exports.isSoftphoneJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.timeoutPromise = void 0;
+exports.calculatePayloadSize = exports.parseJwt = exports.retryPromise = exports.isVideoJid = exports.isSoftphoneJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.delay = exports.timeoutPromise = void 0;
 const uuid_1 = require("uuid");
 const timeout_error_1 = require("./types/timeout-error");
 /* istanbul ignore next */
@@ -19,6 +19,12 @@ function timeoutPromise(fn, timeoutMs, msg, details) {
     });
 }
 exports.timeoutPromise = timeoutPromise;
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+exports.delay = delay;
 function splitIntoIndividualTopics(topicString) {
     const topics = [];
     if (topicString.includes('?')) {
@@ -38,11 +44,11 @@ function splitIntoIndividualTopics(topicString) {
 }
 exports.splitIntoIndividualTopics = splitIntoIndividualTopics;
 const isAcdJid = function (jid) {
-    return jid.startsWith('acd-');
+    return jid.startsWith('acd-') && !exports.isSoftphoneJid(jid);
 };
 exports.isAcdJid = isAcdJid;
 const isScreenRecordingJid = function (jid) {
-    return jid.startsWith('screenrecording-');
+    return jid.startsWith('screenrecording-') && !exports.isSoftphoneJid(jid);
 };
 exports.isScreenRecordingJid = isScreenRecordingJid;
 const isSoftphoneJid = function (jid) {

package/dist/deploy-info.json

@@ -17,6 +17,6 @@
       "file": "v17/streaming-client.browser.js"
     }
   ],
-  "build": "85",
-  "buildDate": "2024-02-14T00:16:33.645243Z"
+  "build": "88",
+  "buildDate": "2024-02-16T18:31:18.700405Z"
 }

package/dist/es/client.d.ts

@@ -24,6 +24,8 @@ export declare class Client extends EventEmitter {
     private extensions;
     private connectionManager;
     private channelReuses;
+    private backoffReductionTimer;
+    private hasMadeInitialAttempt;
     private boundStanzaDisconnect?;
     private boundStanzaNoLongerSubscribed?;
     private boundStanzaDuplicateId?;
@@ -45,6 +47,11 @@ export declare class Client extends EventEmitter {
     private handleNoLongerSubscribed;
     private handleDuplicateId;
     disconnect(): Promise<any>;
+    private getConnectionData;
+    private setConnectionData;
+    private increaseBackoff;
+    private decreaseBackoff;
+    private getStartingDelay;
     connect(connectOpts?: StreamingClientConnectOptions): Promise<void>;
     private backoffConnectRetryHandler;
     private makeConnectionAttempt;

package/dist/es/client.js

@@ -6,7 +6,7 @@ import './polyfills';
 import { Notifications } from './notifications';
 import { WebrtcExtension } from './webrtc';
 import { Ping } from './ping';
-import { parseJwt, timeoutPromise } from './utils';
+import { delay, parseJwt, timeoutPromise } from './utils';
 import { HttpClient } from './http-client';
 import EventEmitter from 'events';
 import { ConnectionManager } from './connection-manager';
@@ -24,6 +24,9 @@ const STANZA_DISCONNECTED = 'stanzaDisconnected';
 const NO_LONGER_SUBSCRIBED = 'notify:no_longer_subscribed';
 const DUPLICATE_ID = 'notify:duplicate_id';
 const MAX_CHANNEL_REUSES = 10;
+const SESSION_STORE_KEY = 'sc_connectionData';
+const BACKOFF_DECREASE_DELAY_MULTIPLIER = 5;
+const INITIAL_DELAY = 2000;
 export class Client extends EventEmitter {
     constructor(options) {
         super();
@@ -35,6 +38,7 @@ export class Client extends EventEmitter {
         this.autoReconnect = true;
         this.extensions = [];
         this.channelReuses = 0;
+        this.hasMadeInitialAttempt = false;
         this.http = new HttpClient();
         this.reconnectOnNoLongerSubscribed = options.reconnectOnNoLongerSubscribed !== false;
         this.config = {
@@ -215,6 +219,64 @@ export class Client extends EventEmitter {
             }, 5000, 'disconnecting streaming service');
         });
     }
+    getConnectionData() {
+        const connectionDataStr = sessionStorage.getItem(SESSION_STORE_KEY);
+        const defaultValue = {
+            currentDelayMs: 0,
+        };
+        if (connectionDataStr) {
+            try {
+                return JSON.parse(connectionDataStr);
+            }
+            catch (e) {
+                this.logger.warn('failed to parse streaming client connection data');
+                return defaultValue;
+            }
+        }
+        return defaultValue;
+    }
+    setConnectionData(data) {
+        sessionStorage.setItem(SESSION_STORE_KEY, JSON.stringify(data));
+    }
+    increaseBackoff() {
+        const connectionData = this.getConnectionData();
+        const currentDelay = Math.max(connectionData.currentDelayMs * 2, INITIAL_DELAY);
+        this.setConnectionData({
+            currentDelayMs: currentDelay,
+            delayMsAfterNextReduction: currentDelay / 2,
+            nextDelayReductionTime: new Date().getTime() + (currentDelay * BACKOFF_DECREASE_DELAY_MULTIPLIER),
+            timeOfTotalReset: new Date().getTime() + 1000 * 60 * 60 // one hour in the future
+        });
+    }
+    decreaseBackoff(newAmountMs) {
+        const data = this.getConnectionData();
+        const msUntilNextReduction = newAmountMs * BACKOFF_DECREASE_DELAY_MULTIPLIER;
+        const newConnectionData = {
+            currentDelayMs: newAmountMs,
+            delayMsAfterNextReduction: newAmountMs / 2,
+            nextDelayReductionTime: new Date().getTime() + (msUntilNextReduction),
+            timeOfTotalReset: data.timeOfTotalReset
+        };
+        // if we are past the total reset time, do that instead
+        if (data.timeOfTotalReset && data.timeOfTotalReset < new Date().getTime() || newAmountMs < INITIAL_DELAY) {
+            this.logger.debug('decreaseBackoff() called, but timeOfTotalReset has elasped or next delay is below 2s. Resetting backoff');
+            return this.setConnectionData({
+                currentDelayMs: 0
+            });
+        }
+        this.setConnectionData(newConnectionData);
+        clearTimeout(this.backoffReductionTimer);
+        this.logger.debug('Setting timer for next backoff reduction since we haven\'t reached total reset', { msUntilReduction: msUntilNextReduction, delayMsAfterNextReduction: newConnectionData.delayMsAfterNextReduction });
+        this.backoffReductionTimer = setTimeout(() => this.decreaseBackoff(newConnectionData.delayMsAfterNextReduction), msUntilNextReduction);
+    }
+    getStartingDelay(connectionData, maxDelay) {
+        // we don't want the delay to ever be less than 2 seconds
+        const minDelay = Math.max(connectionData.currentDelayMs, INITIAL_DELAY);
+        if (connectionData.timeOfTotalReset && connectionData.timeOfTotalReset < new Date().getTime()) {
+            return INITIAL_DELAY;
+        }
+        return Math.min(minDelay, maxDelay);
+    }
     connect(connectOpts) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -230,13 +292,29 @@ export class Client extends EventEmitter {
                 // this maintains the previous functionality
                 maxAttempts = Infinity;
             }
+            clearTimeout(this.backoffReductionTimer);
+            const connectionData = this.getConnectionData();
+            const startingDelay = this.getStartingDelay(connectionData, maxDelay);
+            const delayFirstAttempt = this.hasMadeInitialAttempt;
+            this.hasMadeInitialAttempt = true;
             try {
-                yield backOff(() => this.makeConnectionAttempt(), {
-                    jitter: 'full',
+                yield backOff(() => __awaiter(this, void 0, void 0, function* () {
+                    const connectionData = this.getConnectionData();
+                    yield this.makeConnectionAttempt();
+                    if (connectionData.nextDelayReductionTime) {
+                        const msUntilReduction = connectionData.nextDelayReductionTime - new Date().getTime();
+                        this.logger.debug('Setting timer for next backoff reduction', { msUntilReduction, delayMsAfterNextReduction: connectionData.delayMsAfterNextReduction });
+                        this.backoffReductionTimer = setTimeout(() => this.decreaseBackoff(connectionData.delayMsAfterNextReduction || 0), msUntilReduction);
+                    }
+                }), {
+                    jitter: 'none',
                     maxDelay,
                     numOfAttempts: maxAttempts,
-                    startingDelay: 2000,
-                    retry: this.backoffConnectRetryHandler.bind(this, { maxConnectionAttempts: maxAttempts })
+                    startingDelay,
+                    delayFirstAttempt,
+                    retry: this.backoffConnectRetryHandler.bind(this, {
+                        maxConnectionAttempts: maxAttempts,
+                    }),
                 });
             }
             catch (err) {
@@ -322,14 +400,13 @@ export class Client extends EventEmitter {
                     let retryDelay = parseInt(retryAfter, 10) * 1000;
                     additionalErrorDetails.retryDelay = retryDelay;
                     this.logger.error('Failed streaming client connection attempt, respecting retry-after header and will retry afterwards.', additionalErrorDetails, { skipServer: err instanceof OfflineError });
-                    yield new Promise((resolve) => {
-                        setTimeout(resolve, retryDelay);
-                    });
+                    yield delay(retryDelay);
                     this.logger.debug('finished waiting for retry-after');
                     return true;
                 }
             }
             this.logger.error('Failed streaming client connection attempt, retrying', additionalErrorDetails, { skipServer: err instanceof OfflineError });
+            this.increaseBackoff();
             return true;
         });
     }
@@ -382,7 +459,7 @@ export class Client extends EventEmitter {
             }
             if (!this.hardReconnectRequired) {
                 this.channelReuses++;
-                if (this.channelReuses > MAX_CHANNEL_REUSES) {
+                if (this.channelReuses >= MAX_CHANNEL_REUSES) {
                     this.logger.warn('Forcing a hard reconnect due to max channel reuses', { channelId: this.config.channelId, channelReuses: this.channelReuses });
                     this.channelReuses = 0;
                     this.hardReconnectRequired = true;