@quotemedia.com/streamer 2.31.0 → 2.33.0

package/{qmci-streamer-2.31.0.js → qmci-streamer-2.33.0.js}

@@ -37,6 +37,15 @@ var Connection = function () {
         //probably means that an unhandled loop was reached
         this.maxReconnectsTotal = 3;
         this.isFirstConnection = true;
+        this.atmoCodes = {
+            1000: "Normal closure; the connection successfully completed whatever purpose for which it was created.",
+            1001: "The endpoint is going away, either because of a server failure or because the browser is navigating away from the page that opened the connection.",
+            1002: "The endpoint is terminating the connection due to a protocol error.",
+            1003: "The connection is being terminated because the endpoint received data of a type it cannot accept (for example, a text-only endpoint received binary data).",
+            1004: "The endpoint is terminating the connection because a data frame was received that is too large.",
+            1005: "Unknown: no status code was provided even though one was expected.",
+            1006: "Connection was closed abnormally (that is, with no close frame being sent)."
+        };
     }
 
     Connection.prototype.open = function open() {
@@ -136,6 +145,7 @@ var Connection = function () {
                 onClose: function onClose(response) {
                     var code = response.status;
                     var reason = response.reason || response.reasonPhrase;
+                    var atmosphereMessage = response.atmoMessage;
                     // For whatever reason, Atmosphere sets to 408 when unsubscribing (e.g., when refreshing the page)
                     if (code === 408 && response.state === "unsubscribe") {
                         code = 200;
@@ -143,10 +153,18 @@ var Connection = function () {
                     }
                     //When 501 code is sent it could mean that the server is down, therefore do not continue trying to reconnect
                     if (code === 501 || code === 401 || code === 403 || code === 452) {
-                        _this.log.info("Unable to reconnect with code: " + msg.code + ", reason: " + msg.reason);
+                        _this.log.warn("Unable to reconnect with code: " + code + ", reason: " + reason);
                         _this.reconnect = false;
                     }
-
+                    if (atmosphereMessage && atmosphereMessage.code in _this.atmoCodes) {
+                        _this.log.error("Unexpected close. Code: " + atmosphereMessage.code + " Reason: " + _this.atmoCodes[atmosphereMessage.code]);
+                        _this.events.fire("atmoError", events.error("Atmosphere error", {
+                            reason: _this.atmoCodes[atmosphereMessage.code],
+                            code: atmosphereMessage.code
+                        }));
+                        code = 410;
+                        reason = "Gone";
+                    }
                     var e = events.close({
                         url: url,
                         transport: response.transport,
@@ -164,6 +182,8 @@ var Connection = function () {
                         timesExceeded: response.timesExceeded,
                         maxExceeded: response.maxExceed
                     });
+                    _this.reconnect = false;
+                    _this.log.warn("Slow connection received, Reconnection will not be attempted.");
                     _this.log.info(e);
                     _this.events.fire("slow", e);
                 }
@@ -198,23 +218,24 @@ var Connection = function () {
         }
         this.isFirstConnection = false;
         var currentAttempts = this.maxReconnectAttempts;
-        var reopenInterval = setInterval(function () {
+        // Recursively run this until a successful open is completed
+        var reconnect = function reconnect() {
             if (currentAttempts <= 0) {
                 _this2.reconnect = false;
                 _this2.log.error("Error while reconnecting. No attempts left.");
                 //if maxattempts was reached and no connection was open, exit.
                 _this2.maxReconnectAttempts = 0;
-                clearInterval(reopenInterval);
                 return;
             }
             if (_this2.isConnectionUp || !_this2.reconnect) {
-                clearInterval(reopenInterval);
                 return;
             }
             _this2.log.info("Attempting reconnect. Attempts left: " + currentAttempts);
             _this2.reopen(currentAttempts);
             currentAttempts--;
-        }, 500);
+            setTimeout(reconnect, 500);
+        };
+        setTimeout(reconnect, 500);
     };
 
     Connection.prototype.reopen = function reopen(attempt) {
@@ -254,10 +275,6 @@ var Connection = function () {
         return this.socket == null;
     };
 
-    Connection.prototype.getConnectionUp = function getConnectionUp() {
-        return this.isConnectionUp;
-    };
-
     Connection.prototype.on = function on(event, callback) {
         return this.events.on(event, callback);
     };
@@ -536,6 +553,8 @@ var Stream = function () {
             _this.events.fire("error", err);
         }).on("reconnect", function (msg) {
             _this.reconnectSuccess(msg);
+        }).on("atmoError", function (err) {
+            _this.events.fire("atmoError", err);
         });
 
         this.requestid = new _UShortId2["default"]();
@@ -1647,13 +1666,10 @@ var Stream = function () {
     };
 
     Stream.prototype.onReconnectMessage = function onReconnectMessage(msg) {
-        if (msg.code !== 200) {
-            var event = events.error("Reconnection Failed", {
-                code: msg.code,
-                reason: msg.reason
-            });
-            this.events.fire("error", event);
-            this.doClose(event);
+        if (msg.code === 450) {
+            this.events.fire("slow", "Reconnection recieved a slow code: " + msg.code);
+            this._isSlowConnection = true;
+            this.conn.setReconnect = false;
         }
         this.events.fire("reconnectMessage", msg);
         console.log(msg);
@@ -1760,7 +1776,7 @@ var Stream = function () {
 
     Stream.prototype.performReconnect = function performReconnect(callback) {
         if (this.conn != null && this.conn.isReconnect()) {
-            if (this.conn.getConnectionUp()) {
+            if (this.conn.isConnectionUp) {
                 this.log.warn("Connection is not closed and won't try reconnect.");
                 return;
             }
@@ -2042,6 +2058,11 @@ var StreamingService = function () {
             headers['X-Stream-isReceiveLatestMissedData'] = true;
         }
 
+        var _connectionFrom = this.config.connectionFrom;
+        if (_connectionFrom != null) {
+            headers['X-Stream-connectionFrom'] = _connectionFrom;
+        }
+
         Object.assign(headers, this.config.credentials.getHeaders());
 
         var request = {
@@ -3675,7 +3696,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
                         return;
                     }
 
-                    _invokeClose(webSocketOpened);
+                    //Patched by Quotemedia
+                    _invokeClose(webSocketOpened, message);
 
                     _response.state = 'closed';
 
@@ -4998,11 +5020,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
                 }
             }
 
-            function _invokeClose(wasOpen) {
+            //Patched by Quotemedia
+            function _invokeClose(wasOpen, message) {
                 if (_response.state !== 'closed') {
                     _response.state = 'closed';
                     _response.responseBody = "";
                     _response.messages = [];
+                    _response.atmoMessage = message;
                     _response.status = !wasOpen ? 501 : 200;
                     _invokeCallback();
                 }
@@ -5920,6 +5944,7 @@ fmt.Formatter = function () {
     this.formatters[_streamerApi.messages.MessageTypeNames.data.TRADENOTIFICATION] = this._fmttradeNotification;
     this.formatters[_streamerApi.messages.MessageTypeNames.data.NEWSCMDFILTER] = this._fmtnewscmdfilter;
     this.formatters[_streamerApi.messages.MessageTypeNames.data.NEWSERROR] = this._fmtnewserror;
+    this.formatters[_streamerApi.messages.MessageTypeNames.data.DIVIDEND] = this._fmtdividend;
 };
 
 fmt.Formatter._UNKOWNTYPE = '__UNKNOWN__';
@@ -6554,6 +6579,33 @@ fmt.Formatter.prototype._fmtnewserror = function (val) {
     return s.toString();
 };
 
+fmt.Formatter.prototype._fmtdividend = function (val) {
+    var s = new fmt.StringBuilder();
+    s.append("DV");
+    s.sep();
+    s.datetime(val.occuredOn);
+    s.sep();
+    s.append(val.symbolId);
+    s.sep();
+    s.append(val.instrument);
+    s.sep();
+    s.datetime(val.declarationDate);
+    s.sep();
+    s.datetime(val.executionDate);
+    s.sep();
+    s.datetime(val.recordDate);
+    s.sep();
+    s.datetime(val.paymentDate);
+    s.sep();
+    s.append(val.amount);
+    s.sep();
+    s.append(val.frequency);
+    s.sep();
+    s.append(val.paymentType);
+
+    return s.toString();
+};
+
 fmt.Formatter.prototype._fmtheartbeat = function (val) {
     var s = new fmt.StringBuilder();
     s.append("HEARBEAT");
@@ -6733,6 +6785,8 @@ fmt.Formatter.prototype._fmtreconnectresponse = function (val) {
     s.append(val.maxEntitlementsPerSubscription);
     s.sep();
     s.sep(val.entitlements);
+    s.sep();
+    s.sep(val.exchangeEntitlements);
     return s.toString();
 };
 
@@ -6832,6 +6886,10 @@ fmt.Formatter.prototype._fmtmisseddatasent = function (val) {
     s.datetime(val.timestamp);
     s.sep();
     s.append(val.requestId);
+    s.sep();
+    s.append(val.totalDataSent);
+    s.sep();
+    s.append(val.totalDataHeld);
     return s.toString();
 };
 
@@ -12470,6 +12528,10 @@ var _streamerEvents = require("../streamer-events.js");
 
 var events = _interopRequireWildcard(_streamerEvents);
 
+var _http = require("../http.js");
+
+var _http2 = _interopRequireDefault(_http);
+
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj["default"] = obj; return newObj; } }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
@@ -12478,12 +12540,23 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 
 var StompConnection = function () {
     function StompConnection(createTransmitter, openSocket, log) {
+        var maxReconnectAttempts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 3;
+        var pingUrl = arguments[4];
+
         _classCallCheck(this, StompConnection);
 
         this.openSocket = openSocket;
         this.createTransmitter = createTransmitter;
         this.log = (0, _logging.asLogger)(log);
         this.events = new _EventSupport2["default"](this);
+        this.currentConn = '';
+        //Max number of times that the client will try to reopen per loop
+        this.maxReconnectAttempts = maxReconnectAttempts;
+        //Max number of times client will be able to try to reopen in total. Once this is reached, client will close and no reconnect will be attempted.
+        //probably means that an unhandled loop was reached
+        this.maxReconnectsTotal = 3;
+        this.isFirstConnection = true;
+        this.pingUrl = pingUrl;
     }
 
     StompConnection.prototype.open = function open() {
@@ -12495,21 +12568,70 @@ var StompConnection = function () {
             }
         };
 
-        this.transmitter = this.createTransmitter(socketProxy);
+        //Check to avoid creating unnecessary events and objects
+        if (this.isFirstConnection) {
+            this.on("reopen", function (e) {
+                var prevConn = _this.currentConn;
+                _this.currentConn = e.connectionId;
+                _this.events.fire("reconnect", events.event("Reconnection success", {
+                    previousConnectionId: prevConn,
+                    currentConnectionId: _this.currentConn
+                }));
+            });
 
-        this.transmitter.on("message", function (message) {
-            _this.events.fire("message", message);
-        });
+            this.transmitter = this.createTransmitter(socketProxy);
+            this.transmitter.on("message", function (message) {
+                _this.events.fire("message", message);
+            });
+        }
 
         this.socket = this.openSocket(function (request) {
             _this.request = request;
+            _this.reconnect = false;
             return {
+                onOpen: function onOpen(response) {
+                    if (response.command === "CONNECTED") {
+                        _this.isConnectionUp = true;
+                        var e = events.event("open", {
+                            connectionId: response.headers['user-name']
+                        });
+                        _this.log.info(e);
+                        _this.events.fire("open", e);
+                        if (!_this.isFirstConnection) {
+                            _this.maxReconnectsTotal--;
+                            _this.events.fire("reopen", e);
+                        }
+                        _this.currentConn = response.headers['user-name'];
+                    }
+                },
+                onError: function onError(response) {
+                    _this.isConnectionUp = false;
+                    _this.isServerUp(function (err, result) {
+                        if (err !== null) {
+                            _this.reconnect = false;
+                            _this.log.warn("Connection lost, Streamer Server isn't Up");
+                        } else {
+                            _this.reconnect = true;
+                            _this.log.warn('Connection lost, Streamer Server is Up');
+                        }
+                    });
+                },
+                onClose: function onClose() {
+                    _this.isConnectionUp = false;
+                },
                 onMessage: function onMessage(response) {
+                    var responseBody = JSON.parse(response.body);
+                    if (responseBody.code !== undefined) {
+                        if (responseBody.code == 401 || responseBody.code == 403) {
+                            _this.log.info("Unable to reconnect with code: " + responseBody.code + ", reason: " + responseBody.reason);
+                            _this.reconnect = false;
+                            _this.isConnectionUp = false;
+                        }
+                    }
                     _this.transmitter.onMessage(response.body);
                 }
-
             };
-        });
+        }, this.currentConn);
     };
 
     StompConnection.prototype.close = function close() {
@@ -12517,6 +12639,9 @@ var StompConnection = function () {
             try {
                 this.socket.close();
                 this.socket = null;
+                if (this.reconnect) {
+                    this.tryReopen();
+                }
             } catch (err) {
                 this.events.fire("error", events.error("Error closing", {
                     reason: err.message,
@@ -12527,6 +12652,44 @@ var StompConnection = function () {
         }
     };
 
+    StompConnection.prototype.tryReopen = function tryReopen() {
+        var _this2 = this;
+
+        if (this.isConnectionUp || this.maxReconnectsTotal <= 0) {
+            this.log.error("Connection is already open or max reconnects was reached, won't try to reconnect");
+            return;
+        }
+        this.isFirstConnection = false;
+        var currentAttempts = this.maxReconnectAttempts;
+        var reconnect = function reconnect() {
+            if (currentAttempts <= 0) {
+                _this2.reconnect = false;
+                _this2.log.error("Error while reconnecting. No attempts left.");
+                //if maxattempts was reached and no connection was open, exit.
+                _this2.maxReconnectAttempts = 0;
+                return;
+            }
+            if (_this2.isConnectionUp || !_this2.reconnect) {
+                return;
+            }
+            _this2.log.info("Attempting reconnect. Attempts left: " + currentAttempts);
+            _this2.reopen(currentAttempts);
+            currentAttempts--;
+
+            setTimeout(reconnect, 500);
+        };
+        setTimeout(reconnect, 500);
+    };
+
+    StompConnection.prototype.reopen = function reopen(attempt) {
+        try {
+            this.open();
+        } catch (exception) {
+            this.log.warn("There was an error while reopening attempt #" + attempt);
+            this.events.fire("error", exception);
+        }
+    };
+
     StompConnection.prototype.send = function send(message) {
         try {
             this.transmitter.send(message);
@@ -12539,6 +12702,14 @@ var StompConnection = function () {
         }
     };
 
+    StompConnection.prototype.isReconnect = function isReconnect() {
+        return this.request['x-Stream-isReconnect'];
+    };
+
+    StompConnection.prototype.setReconnect = function setReconnect(doReconnect) {
+        this.reconnect = doReconnect;
+    };
+
     StompConnection.prototype.setServer = function setServer(server) {
         this.request['X-Stream-Instance'] = server;
     };
@@ -12547,6 +12718,21 @@ var StompConnection = function () {
         return this.socket == null;
     };
 
+    StompConnection.prototype.isServerUp = function isServerUp(callback) {
+        (0, _http2["default"])({
+            url: this.pingUrl,
+            success: function success(result) {
+                return callback(null, result);
+            },
+            type: "GET",
+            failure: callback
+        });
+    };
+
+    StompConnection.prototype.setConnectionUp = function setConnectionUp(isConnectionUp) {
+        this.isConnectionUp = isConnectionUp;
+    };
+
     StompConnection.prototype.on = function on(event, callback) {
         return this.events.on(event, callback);
     };
@@ -12556,7 +12742,7 @@ var StompConnection = function () {
 
 exports["default"] = StompConnection;
 }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer,arguments[3],arguments[4],arguments[5],arguments[6],require("timers").setImmediate,require("timers").clearImmediate,"/lib/stomp/StompConnection.js","/lib/stomp")
-},{"../EventSupport.js":2,"../logging.js":16,"../streamer-events.js":97,"_process":119,"buffer":109,"timers":140}],94:[function(require,module,exports){
+},{"../EventSupport.js":2,"../http.js":14,"../logging.js":16,"../streamer-events.js":97,"_process":119,"buffer":109,"timers":140}],94:[function(require,module,exports){
 (function (process,global,Buffer,__argument0,__argument1,__argument2,__argument3,setImmediate,clearImmediate,__filename,__dirname){
 "use strict";
 
@@ -12617,6 +12803,8 @@ var StompStream = function () {
                 _this.pendingConnection(err);
             }
             _this.events.fire("error", err);
+        }).on("reconnect", function (msg) {
+            _this.reconnectSuccess(msg);
         });
 
         this.requestid = new _UShortId2["default"]();
@@ -12647,6 +12835,11 @@ var StompStream = function () {
         }
     };
 
+    StompStream.prototype.reconnectSuccess = function reconnectSuccess(msg) {
+        this.events.fire("reconnectSuccess", msg);
+        this.log.info("Successfull reconnection. Previous Id: " + msg.previousConnectionId + " Current Id = " + msg.currentConnectionId);
+    };
+
     StompStream.prototype.on = function on(event, listener) {
         return this.events.on(event, listener);
     };
@@ -13260,6 +13453,12 @@ var StompStream = function () {
             case _streamerApi.messages.MessageTypeNames.ctrl.OPEN_FLOW:
                 this.onOpenFlow(msg);
                 break;
+            case _streamerApi.messages.MessageTypeNames.ctrl.RECONNECT_RESPONSE:
+                this.onReconnectMessage(msg);
+                break;
+            case _streamerApi.messages.MessageTypeNames.ctrl.MISSED_DATA_SENT:
+                this.onMissedDataSent(msg);
+                break;
         }
     };
 
@@ -13719,8 +13918,18 @@ var StompStream = function () {
         }
     };
 
+    StompStream.prototype.onReconnectMessage = function onReconnectMessage(msg) {
+        if (msg.code === 450) {
+            this.events.fire("slow", "Reconnection recieved a slow code: " + msg.code);
+            this._isSlowConnection = true;
+            this.conn.setReconnect = false;
+        }
+        this.events.fire("reconnectMessage", msg);
+        console.log(msg);
+    };
+
     StompStream.prototype.onConnectResponse = function onConnectResponse(msg) {
-        if (msg.code != 200) {
+        if (msg.code !== 200) {
             var event = events.error("Connection failed", {
                 code: msg.code,
                 reason: msg.reason
@@ -13787,6 +13996,11 @@ var StompStream = function () {
         this.events.fire("resubscribeMessage", msg);
     };
 
+    StompStream.prototype.onMissedDataSent = function onMissedDataSent(msg) {
+        this.log.debug(_formatting.msgfmt.fmt(msg));
+        this.events.fire("missedDataSent", msg);
+    };
+
     StompStream.prototype.onOpenFlow = function onOpenFlow(msg) {
         this.conn.send(msg);
     };
@@ -13805,8 +14019,29 @@ var StompStream = function () {
         if (!this.isClosed()) {
             var conn = this.conn;
             this.conn = null;
-            this.events.fire("close", msg);
             conn.close();
+            this.events.fire("close", msg);
+            if (conn.isReconnect()) {
+                //Will need to reset the events since they duplicate each time it reconnects.
+                this.events = new _EventSupport2["default"]();
+                this.conn = conn;
+            }
+        }
+    };
+
+    StompStream.prototype.performReconnect = function performReconnect(callback) {
+        if (this.conn != null && this.conn.isReconnect()) {
+            if (this.conn.isConnectionUp) {
+                this.log.warn("Connection is not closed and won't try reconnect.");
+                return;
+            }
+            this.conn.setReconnect(true);
+            this.conn.tryReopen();
+            if (callback) {
+                callback();
+            }
+        } else {
+            this.log.warn("Reconnect flag is set to false");
         }
     };
 
@@ -13865,6 +14100,8 @@ var STREAMURLS = {
     "streamStomp": "/stream/connect"
 };
 
+var HEADERPARAMS = '';
+
 var StompStreamingService = function () {
     function StompStreamingService(http, stompJs, log, config) {
         var _this = this;
@@ -13875,6 +14112,7 @@ var StompStreamingService = function () {
         this.stompJs = stompJs;
         this.log = (0, _logging.asLogger)(log);
         this.config = config || {};
+        this.maxReconnectAttempts = this.config.maxReconnectAttempts;
 
         this.format = this.config.format;
         if (this.config.format === 'application/json') {
@@ -13884,33 +14122,65 @@ var StompStreamingService = function () {
         }
     }
 
-    StompStreamingService.prototype.openStompSocket = function openStompSocket(handlers) {
+    StompStreamingService.prototype.openStompSocket = function openStompSocket(handlers, connectionId) {
+        HEADERPARAMS = '';
         var headers = {
             'X-Stream-Version': _streamerApi.VERSION,
             'X-Stream-Lib': _streamerApi.LIBRARY_NAME
         };
+        this.addToHeaderParams('X-Stream-Version', _streamerApi.VERSION);
+        this.addToHeaderParams('X-Stream-Lib', _streamerApi.LIBRARY_NAME);
 
         var _conflation = this.config.conflation;
         if (_conflation != null && _conflation !== '') {
             headers['X-Stream-Conflation'] = _conflation;
+            this.addToHeaderParams('X-Stream-Conflation', _conflation);
+        }
+
+        if (connectionId != null && connectionId !== '') {
+            headers['X-Stream-Previous-Connection-Id'] = connectionId;
+            this.addToHeaderParams('X-Stream-Previous-Connection-Id', connectionId);
         }
 
         var _rejectExcessiveConnection = this.config.rejectExcessiveConnection;
         if (_rejectExcessiveConnection != null && _rejectExcessiveConnection !== '') {
             headers['X-Stream-Reject'] = _rejectExcessiveConnection;
+            this.addToHeaderParams('X-Stream-Reject', _rejectExcessiveConnection);
         }
 
         if (this.config.format === 'application/json' || this.config.format === _message.MimeTypes.QITCH) {
             headers['X-Stream-Format'] = this.format;
+            this.addToHeaderParams('X-Stream-Format', this.format);
         }
 
         if (this.config.updatesOnly === 'true') {
             headers['X-Stream-UpdatesOnly'] = true;
+            this.addToHeaderParams('X-Stream-UpdatesOnly', true);
+        }
+
+        var _isReconnect = this.config.isReconnect;
+        if (_isReconnect != null && _isReconnect !== '') {
+            headers['x-Stream-isReconnect'] = _isReconnect;
+            this.addToHeaderParams('x-Stream-isReconnect', _isReconnect);
+        }
+
+        var _alwaysReconnect = this.config.alwaysReconnect;
+        if (_alwaysReconnect != null && _alwaysReconnect !== '') {
+            headers['x-Stream-isAlwaysReopen'] = _alwaysReconnect;
+            this.addToHeaderParams('x-Stream-isAlwaysReopen', _alwaysReconnect);
+        }
+
+        if (this.config.isMissedData === 'ALL') {
+            headers['X-Stream-isReceiveAllMissedData'] = true;
+            this.addToHeaderParams('X-Stream-isReceiveAllMissedData', true);
+        } else if (this.config.isMissedData === 'LATEST') {
+            headers['X-Stream-isReceiveLatestMissedData'] = true;
+            this.addToHeaderParams('X-Stream-isReceiveLatestMissedData', true);
         }
 
         Object.assign(headers, this.config.credentials.getHeaders());
 
-        var url = this.config.url + STREAMURLS.streamStomp;
+        var url = this.config.url + STREAMURLS.streamStomp + HEADERPARAMS;
         var stompClient = this.stompJs.Stomp.client(url);
 
         var authMessage = new _streamerApi.messages.control.AuthenticationMessage();
@@ -13919,6 +14189,7 @@ var StompStreamingService = function () {
             authMessage.authorization = this.config.credentials.sid;
         } else if (this.config.credentials.wmid !== undefined && this.config.credentials.token !== undefined) {
             authMessage.authenticationMethod = "enterprise";
+            authMessage.wmid = this.config.credentials.wmid;
             authMessage.authorization = this.config.credentials.token;
         } else if (this.config.credentials.wmid !== undefined) {
             authMessage.authenticationMethod = "wmid";
@@ -13936,12 +14207,15 @@ var StompStreamingService = function () {
             authMessage.rejectExcessiveConnection = this.config.rejectExcessiveConnection;
         }
 
-        stompClient.connect({}, function (frame) {
+        stompClient.connect(headers, function (frame) {
             stompClient.subscribe('/user/queue/messages', function (responseMessage) {
                 handlers(headers).onMessage(responseMessage);
             });
 
+            handlers(headers).onOpen(frame);
             stompClient.send("/stream/message", headers, JSON.stringify(authMessage));
+        }, function (frame) {
+            handlers(headers).onError(frame);
         });
 
         return {
@@ -13949,7 +14223,9 @@ var StompStreamingService = function () {
                 stompClient.send("/stream/message", headers, msg);
             },
             close: function close() {
-                stompClient.disconnect();
+                stompClient.disconnect(function () {
+                    handlers(headers).onClose();
+                });
             }
         };
     };
@@ -13959,9 +14235,9 @@ var StompStreamingService = function () {
 
         return new _StompConnection2["default"](function (socket) {
             return _this2.createTransmitter(socket);
-        }, function (handlers) {
-            return _this2.openStompSocket(handlers);
-        }, this.logger);
+        }, function (handlers, connectionId) {
+            return _this2.openStompSocket(handlers, connectionId);
+        }, this.log, this.maxReconnectAttempts, this.config.host + STREAMURLS.ping);
     };
 
     StompStreamingService.prototype.openStompStream = function openStompStream(callback) {
@@ -13991,6 +14267,14 @@ var StompStreamingService = function () {
         });
     };
 
+    StompStreamingService.prototype.addToHeaderParams = function addToHeaderParams(header, val) {
+        if (HEADERPARAMS === '') {
+            HEADERPARAMS = HEADERPARAMS + '?' + header + '=' + val;
+        } else {
+            HEADERPARAMS = HEADERPARAMS + '&' + header + '=' + val;
+        }
+    };
+
     return StompStreamingService;
 }();
 
@@ -14009,7 +14293,7 @@ exports.__esModule = true;
  */
 
 var LIBRARY_NAME = exports.LIBRARY_NAME = "JavaScript";
-var VERSION = exports.VERSION = "2.31.0";
+var VERSION = exports.VERSION = "2.33.0";
 
 /**
  * Streamer message api namespace.
@@ -14104,7 +14388,8 @@ messages.MessageTypeNames = {
         NEWS: 'D18',
         TRADENOTIFICATION: 'D19',
         NEWSCMDFILTER: 'D20',
-        NEWSERROR: 'D21'
+        NEWSERROR: 'D21',
+        DIVIDEND: 'D22'
     }
 };
 
@@ -14621,6 +14906,12 @@ messages.control.AuthenticationMessage = function () {
      */
     this.authenticationMethod = null;
 
+    /**
+     * Auth WMID if using enterprise token auth method we need to have both wmid and authorization.
+     * @type {String}
+     */
+    this.wmid = null;
+
     /**
      * Auth token.
      * @type {String}