genesys-cloud-streaming-client 13.5.0-develop.6 → 14.0.1-develop.9

package/dist/es/client.js

@@ -59,7 +59,7 @@ export class Client {
     constructor(options) {
         this.connected = false;
         this.connecting = false;
-        this.autoReconnect = true;
+        this.autoReconnect = false;
         this.hardReconnectCount = 0;
         this.reconnectLeakTime = 1000 * 60 * 10; // 10 minutes
         this.deadChannels = [];
@@ -116,8 +116,9 @@ export class Client {
         this.on('connected', (event) => __awaiter(this, void 0, void 0, function* () {
             this.streamId = event.resource;
             this._ping.start();
-            this.connected = true;
             this._reconnector.stop();
+            this.autoReconnect = true;
+            this.connected = true;
             this.connecting = false;
         }));
         // remapped session:end
@@ -235,6 +236,7 @@ export class Client {
     }
     disconnect() {
         this.logger.info('streamingClient.disconnect was called');
+        this.stopServerLogging();
         return timeoutPromise(resolve => {
             this._stanzaio.once('disconnected', resolve);
             this.autoReconnect = false;
@@ -253,19 +255,11 @@ export class Client {
         }, 10 * 1000, 'reconnecting streaming service');
     }
     connect() {
+        this.startServerLogging();
         this.logger.info('streamingClient.connect was called');
         this.connecting = true;
         if (this.config.jwt) {
-            return timeoutPromise(resolve => {
-                this.once('connected', resolve);
-                const options = stanzaOptionsJwt(this.config);
-                this._stanzaio.updateConfig(options);
-                this._stanzaio.connect();
-            }, 10 * 1000, 'connecting to streaming service with jwt')
-                .catch((err) => {
-                this.connecting = false;
-                return Promise.reject(err);
-            });
+            return this._connectStanza();
         }
         let jidPromise;
         if (this.config.jid) {
@@ -279,7 +273,7 @@ export class Client {
                 logger: this.logger
             };
             jidPromise = this.http.requestApiWithRetry('users/me', opts).promise
-                .then(res => res.body.chat.jabberId);
+                .then(res => res.data.chat.jabberId);
         }
         const opts = {
             method: 'post',
@@ -288,24 +282,64 @@ export class Client {
             logger: this.logger
         };
         const channelPromise = this.http.requestApiWithRetry('notifications/channels?connectionType=streaming', opts).promise
-            .then(res => res.body.id);
+            .then(res => res.data.id);
         return Promise.all([jidPromise, channelPromise])
             .then(([jid, channelId]) => {
             this.config.jid = jid;
             this.config.channelId = channelId;
-            this.autoReconnect = true;
-            return timeoutPromise(resolve => {
+            return this._connectStanza();
+        });
+    }
+    _connectStanza() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const guestConnection = !!this.config.jwt;
+            const timeoutMsg = 'connecting to streaming service';
+            const options = guestConnection ? stanzaOptionsJwt(this.config) : stanzaioOptions(this.config);
+            const timeoutDetails = guestConnection
+                ? { usingJwt: true }
+                : { channelId: this.config.channelId, jidResource: this.config.jidResource };
+            /* if we already have a WS, we need to wait for the 2nd disconnect */
+            let skipDisconnectEvent = !!this._stanzaio.transport;
+            let rejectCallback;
+            return timeoutPromise((resolve, reject) => {
+                rejectCallback = () => {
+                    if (skipDisconnectEvent) {
+                        this.logger.debug('received a --transport-disconnected event from existing WS. Not rejecting new attempt to connect WS.');
+                        skipDisconnectEvent = false;
+                    }
+                    else {
+                        this.logger.debug('received a --transport-disconnected event while attempting to connect new WS. rejecting new attempt to connect WS.');
+                        reject(new Error('unexpected disconnect from the WebSocket connecting streaming service'));
+                    }
+                };
+                /* if stanza runs into an error, we want to reject right away. There is no reason to wait for our timeout */
+                this._stanzaio.on('--transport-disconnected', rejectCallback);
                 this.once('connected', resolve);
-                const options = stanzaioOptions(this.config);
                 this._stanzaio.updateConfig(options);
                 this._stanzaio.connect();
-            }, 10 * 1000, 'connecting to streaming service', { jid, channelId });
-        })
-            .catch((err) => {
-            this.connecting = false;
-            return Promise.reject(err);
+            }, 10 * 1000, timeoutMsg, timeoutDetails)
+                .catch((err) => {
+                this.connecting = false;
+                /* if _we_ timed out but stanza is still trying to connect, we need to stop stanza's WS */
+                if (err.message === `Timeout: ${timeoutMsg}` && this._stanzaio.transport) {
+                    this._stanzaio.disconnect();
+                    this.logger.debug('timing out WS connect(), calling through to stanza to disconnect');
+                }
+                throw err;
+            }).finally(() => {
+                this._stanzaio.off('--transport-disconnected', rejectCallback);
+            });
         });
     }
+    stopServerLogging() {
+        /* flush all pending logs and webrtc stats – then turn off the logger */
+        this.logger.sendAllLogsInstantly();
+        this.logger.stopServerLogging();
+        this._webrtcSessions.flushStats();
+    }
+    startServerLogging() {
+        this.logger.startServerLogging();
+    }
     setAccessToken(token) {
         this.config.authToken = token;
         this.logger.setAccessToken(token);
@@ -317,6 +351,6 @@ export class Client {
         extensions[namespace] = extension;
     }
     static get version() {
-        return '13.5.0';
+        return '14.0.1';
     }
 }

package/dist/es/http-client.js

@@ -1,6 +1,6 @@
-import request from 'superagent';
-import reqlogger from './request-logger';
+import axios, { AxiosError } from 'axios';
 import { retryPromise } from './utils';
+const correlationIdHeaderName = 'inin-correlation-id';
 export class HttpClient {
     constructor() {
         this._httpRetryingRequests = new Map();
@@ -13,14 +13,56 @@ export class HttpClient {
         return retry;
     }
     requestApi(path, opts) {
-        let response = request[opts.method](this._buildUri(opts.host, path, opts.version))
-            .use(reqlogger.bind(this, opts.logger, opts.data))
-            .type(opts.contentType || 'json');
+        const logger = opts.logger || console;
+        const start = new Date().getTime();
+        const url = this._buildUri(opts.host, path, opts.version);
+        const params = {
+            method: opts.method,
+            url,
+            headers: {
+                'content-type': opts.contentType || 'application/json',
+                // we may not need this
+                'accept-encoding': 'gzip, deflate'
+            }
+        };
         // default to include auth header
         if (!opts.noAuthHeader) {
-            response.set('Authorization', `Bearer ${opts.authToken}`);
+            params.headers['Authorization'] = `Bearer ${opts.authToken}`;
         }
-        return response.send(opts.data); // trigger request
+        const handleResponse = function (res) {
+            var _a;
+            let now = new Date().getTime();
+            let elapsed = (now - start) + 'ms';
+            if (res instanceof AxiosError) {
+                /* istanbul ignore next */
+                const response = res.response || {};
+                let status = response.status;
+                let correlationId = (_a = response.headers) === null || _a === void 0 ? void 0 : _a[correlationIdHeaderName];
+                let body = response.data;
+                logger.debug(`request error: ${params.url}`, {
+                    message: res.message,
+                    now,
+                    elapsed,
+                    status,
+                    correlationId,
+                    body
+                }, true);
+                return Promise.reject(res);
+            }
+            let status = res.status;
+            let correlationId = res.headers[correlationIdHeaderName];
+            let body = JSON.stringify(res.data);
+            logger.debug(`response: ${opts.method.toUpperCase()} ${params.url}`, {
+                now,
+                status,
+                elapsed,
+                correlationId,
+                body
+            }, true);
+            return Promise.resolve(res);
+        };
+        return axios(params)
+            .then(handleResponse.bind(this), handleResponse.bind(this));
     }
     stopAllRetries() {
         Array.from(this._httpRetryingRequests.keys())
@@ -30,7 +72,7 @@ export class HttpClient {
         const value = this._httpRetryingRequests.get(retryId);
         if (value) {
             /* if the promise has already completed, this will do nothing. Still need to remove it from the map */
-            value.cancel(new Error('Retry request cancelled'));
+            value.reject(new Error('Retry request cancelled'));
             this._httpRetryingRequests.delete(retryId);
         }
         return true;