@microsoft/applicationinsights-channel-js 2.8.0-nightly.2202-06 → 2.8.0-nightly.2204-06

package/src/Offline.ts

@@ -1,92 +1,104 @@
-import { getWindow, getDocument, getNavigator, isUndefined, isNullOrUndefined, attachEvent } from "@microsoft/applicationinsights-core-js";
-import dynamicProto from "@microsoft/dynamicproto-js";
+import { getWindow, getDocument, getNavigator, isUndefined, isNullOrUndefined, createUniqueNamespace, mergeEvtNamespace, eventOn, eventOff } from "@microsoft/applicationinsights-core-js";
+
+export interface IOfflineListener {
+    isOnline: () => boolean;
+    isListening: () => boolean;
+    unload: () => void;
+}
+
+function _disableEvents(target: any, evtNamespace: string | string[]) {
+    eventOff(target, null, null, evtNamespace);
+}
 
 /**
- * @description Monitors browser for offline events
- * @export default - Offline: Static instance of OfflineListener
- * @class OfflineListener
+ * Create a new OfflineListener instance to monitor browser online / offline events
+ * @param parentEvtNamespace - The parent event namespace to append to any specific events for this instance
  */
-export class OfflineListener {
-    public static Offline = new OfflineListener;
-    public isListening: boolean;
-    
-    constructor() {
-        let _window = getWindow();
-        let _document = getDocument();
-        let isListening = false;
-        let _onlineStatus: boolean = true;
-
-        dynamicProto(OfflineListener, this, (_self) => {
-            try {
-                if (_window) {
-                    if (attachEvent(_window, "online", _setOnline)) {
-                        attachEvent(_window, "offline", _setOffline);
-                        isListening = true;
-                    }
-                }
-                
-                if (_document) {
-                    // Also attach to the document.body or document
-                    let target:any = _document.body || _document;
-    
-                    if (!isUndefined(target.ononline)) {
-                        target.ononline = _setOnline;
-                        target.onoffline = _setOffline;
-                        isListening = true;
-
-                    }
-                }
+export function createOfflineListener(parentEvtNamespace?: string | string[]): IOfflineListener {
+    let _document = getDocument();
+    var _navigator = getNavigator();        // Gets the window.navigator or workerNavigator depending on the global
+    let _isListening: boolean = false;
+    let _onlineStatus: boolean = true;
+    let _evtNamespace = mergeEvtNamespace(createUniqueNamespace("OfflineListener"), parentEvtNamespace);
 
-                if (isListening) {
-                    // We are listening to events so lets set the current status rather than assuming we are online #1538
-                    var _navigator = getNavigator();        // Gets the window.navigator or workerNavigator depending on the global
-                    if (_navigator && !isNullOrUndefined(_navigator.onLine)) { // navigator.onLine is undefined in react-native
-                        _onlineStatus = _navigator.onLine;
-                    }
+    try {
+        if (_enableEvents(getWindow())) {
+            _isListening = true;
+        }
+        
+        if (_document) {
+            // Also attach to the document.body or document
+            let target:any = _document.body || _document;
+
+            if (target.ononline) {
+                if (_enableEvents(target)) {
+                    _isListening = true;
                 }
-            } catch (e) {
-    
-                // this makes react-native less angry
-                isListening = false;
             }
-    
-            _self.isListening = isListening;
-
-            _self.isOnline = (): boolean => {
-                let result = true;
-                var _navigator = getNavigator();
-                if (isListening) {
-                    result = _onlineStatus
-                } else if (_navigator && !isNullOrUndefined(_navigator.onLine)) { // navigator.onLine is undefined in react-native
-                    result = _navigator.onLine;
-                }
+        }
 
-                return result;
-            };
-        
-            _self.isOffline = (): boolean => {
-                return !_self.isOnline();
-            };
-
-            function _setOnline() {
-                _onlineStatus = true;
+        if (_isListening) {
+            // We are listening to events so lets set the current status rather than assuming we are online #1538
+            if (_navigator && !isNullOrUndefined(_navigator.onLine)) { // navigator.onLine is undefined in react-native
+                _onlineStatus = _navigator.onLine;
             }
+        }
+    } catch (e) {
+        // this makes react-native less angry
+        _isListening = false;
+    }
 
-            function _setOffline() {
-                _onlineStatus = false;
+    function _enableEvents(target: any): boolean {
+        let enabled = false;
+        if (target) {
+            enabled = eventOn(target, "online", _setOnline, _evtNamespace);
+            if (enabled) {
+                eventOn(target, "offline", _setOffline, _evtNamespace);
             }
-        });
+        }
+
+        return enabled;
     }
 
-    public isOnline(): boolean {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-        return false;
+    function _setOnline() {
+        _onlineStatus = true;
     }
 
-    public isOffline(): boolean {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-        return false;
+    function _setOffline() {
+        _onlineStatus = false;
     }
-}
 
-export const Offline = OfflineListener.Offline;
+    function _isOnline(): boolean {
+        let result = true;
+        if (_isListening) {
+            result = _onlineStatus
+        } else if (_navigator && !isNullOrUndefined(_navigator.onLine)) { // navigator.onLine is undefined in react-native
+            result = _navigator.onLine;
+        }
+
+        return result;
+    }
+
+    function _unload() {
+        let win = getWindow();
+        if (win && _isListening) {
+            _disableEvents(win, _evtNamespace);
+
+            if (_document) {
+                // Also attach to the document.body or document
+                let target:any = _document.body || _document;
+                if (!isUndefined(target.ononline)) {
+                    _disableEvents(target, _evtNamespace);
+                }
+            }
+
+            _isListening = false;
+        }
+    }
+
+    return {
+        isOnline: _isOnline,
+        isListening: () => _isListening,
+        unload: _unload
+    };
+}

package/src/SendBuffer.ts

@@ -1,5 +1,5 @@
 import { utlGetSessionStorage, utlSetSessionStorage } from "@microsoft/applicationinsights-common";
-import { IDiagnosticLogger, LoggingSeverity, _InternalMessageId, getJSON, arrForEach, isFunction, arrIndexOf, isString, dumpObj, isArray, getExceptionName } from "@microsoft/applicationinsights-core-js";
+import { IDiagnosticLogger, eLoggingSeverity, _eInternalMessageId, getJSON, arrForEach, isFunction, arrIndexOf, isString, dumpObj, isArray, getExceptionName, _throwInternal } from "@microsoft/applicationinsights-core-js";
 import { ISenderConfig } from "./Interfaces";
 import dynamicProto from "@microsoft/dynamicproto-js";
 
@@ -70,9 +70,9 @@ abstract class BaseSendBuffer {
                 if (_self.count() >= config.eventsLimitInMem()) {
                     // sent internal log only once per page view
                     if (!_bufferFullMessageSent) {
-                        logger.throwInternal(
-                            LoggingSeverity.WARNING,
-                            _InternalMessageId.InMemoryStorageBufferFull,
+                        _throwInternal(logger,
+                            eLoggingSeverity.WARNING,
+                            _eInternalMessageId.InMemoryStorageBufferFull,
                             "Maximum in-memory buffer size reached: " + _self.count(),
                             true);
                         _bufferFullMessageSent = true;
@@ -214,9 +214,9 @@ export class SessionStorageSendBuffer extends BaseSendBuffer implements ISendBuf
                 if (_self.count() >= SessionStorageSendBuffer.MAX_BUFFER_SIZE) {
                     // sent internal log only once per page view
                     if (!_bufferFullMessageSent) {
-                        logger.throwInternal(
-                            LoggingSeverity.WARNING,
-                            _InternalMessageId.SessionStorageBufferFull,
+                        _throwInternal(logger,
+                            eLoggingSeverity.WARNING,
+                            _eInternalMessageId.SessionStorageBufferFull,
                             "Maximum buffer size reached: " + _self.count(),
                             true);
                         _bufferFullMessageSent = true;
@@ -248,9 +248,9 @@ export class SessionStorageSendBuffer extends BaseSendBuffer implements ISendBuf
                     if (sentElements.length > SessionStorageSendBuffer.MAX_BUFFER_SIZE) {
                         // We send telemetry normally. If the SENT_BUFFER is too big we don't add new elements
                         // until we receive a response from the backend and the buffer has free space again (see clearSent method)
-                        logger.throwInternal(
-                            LoggingSeverity.CRITICAL,
-                            _InternalMessageId.SessionStorageBufferFull,
+                        _throwInternal(logger,
+                            eLoggingSeverity.CRITICAL,
+                            _eInternalMessageId.SessionStorageBufferFull,
                             "Sent buffer reached its maximum size: " + sentElements.length,
                             true);
         
@@ -297,8 +297,8 @@ export class SessionStorageSendBuffer extends BaseSendBuffer implements ISendBuf
                         }
                     }
                 } catch (e) {
-                    logger.throwInternal(LoggingSeverity.CRITICAL,
-                        _InternalMessageId.FailedToRestoreStorageBuffer,
+                    _throwInternal(logger, eLoggingSeverity.CRITICAL,
+                        _eInternalMessageId.FailedToRestoreStorageBuffer,
                         " storage key: " + prefixedKey + ", " + getExceptionName(e),
                         { exception: dumpObj(e) });
                 }
@@ -317,8 +317,8 @@ export class SessionStorageSendBuffer extends BaseSendBuffer implements ISendBuf
                     // telemetry is stored in the _buffer array so we won't loose any items
                     utlSetSessionStorage(logger, prefixedKey, JSON.stringify([]));
         
-                    logger.throwInternal(LoggingSeverity.WARNING,
-                        _InternalMessageId.FailedToSetStorageBuffer,
+                    _throwInternal(logger, eLoggingSeverity.WARNING,
+                        _eInternalMessageId.FailedToSetStorageBuffer,
                         " storage key: " + prefixedKey + ", " + getExceptionName(e) + ". Buffer cleared",
                         { exception: dumpObj(e) });
                 }