@microsoft/applicationinsights-core-js 2.8.0-beta.2203-01 → 2.8.0-beta.2203-02

package/src/JavaScriptSDK/CoreUtils.ts

@@ -6,158 +6,21 @@ import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { _gblCookieMgr } from "./CookieMgr";
-import { getWindow, getDocument, getPerformance, isIE }  from "./EnvUtils";
+import { getPerformance, isIE }  from "./EnvUtils";
 import {
-    arrForEach, arrIndexOf, arrMap, arrReduce, attachEvent, dateNow, detachEvent, hasOwnProperty,
+    arrForEach, arrIndexOf, arrMap, arrReduce, dateNow, hasOwnProperty,
     isArray, isBoolean, isDate, isError, isFunction, isNullOrUndefined, isNumber, isObject, isString, isTypeof,
     isUndefined, objDefineAccessors, objKeys, strTrim, toISOString
 } from "./HelperFuncs";
+import { addEventHandler, attachEvent, detachEvent } from "./EventHelpers";
 import { randomValue, random32, mwcRandomSeed, mwcRandom32, newId } from "./RandomHelper";
-
-const strVisibilityChangeEvt: string = "visibilitychange";
-const strPageHide: string = "pagehide";
-const strPageShow: string = "pageshow";
+import { strEmpty } from "./InternalConstants";
 
 let _cookieMgrs: ICookieMgr[] = null;
 let _canUseCookies: boolean;    // legacy supported config
 
 // Added to help with minfication
 export const Undefined = strShimUndefined;
-
-/**
- * Trys to add an event handler for the specified event to the window, body and document
- * @param eventName {string} - The name of the event
- * @param callback {any} - The callback function that needs to be executed for the given event
- * @return {boolean} - true if the handler was successfully added
- */
-export function addEventHandler(eventName: string, callback: any): boolean {
-    let result = false;
-    let w = getWindow();
-    if (w) {
-        result = attachEvent(w, eventName, callback);
-        result = attachEvent(w["body"], eventName, callback) || result;
-    }
-
-    let doc = getDocument();
-    if (doc) {
-        result = attachEvent(doc, eventName, callback) || result;
-    }
-
-    return result;
-}
-
-/**
- * Bind the listener to the array of events
- * @param events An string array of event names to bind the listener to
- * @param listener The event callback to call when the event is triggered
- * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
- * @returns true - when at least one of the events was registered otherwise false
- */
- export function addEventListeners(events: string[], listener: any, excludeEvents?: string[]): boolean {
-    let added = false;
-
-    if (listener && events && isArray(events)) {
-        let excluded: string[] = [];
-        arrForEach(events, (name) => {
-            if (isString(name)) {
-                if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
-                    added = addEventHandler(name, listener) || added;
-                } else {
-                    excluded.push(name);
-                }
-            }
-        });
-
-        if (!added && excluded.length > 0) {
-            // Failed to add any listeners and we excluded some, so just attempt to add the excluded events
-            added = addEventListeners(excluded, listener);
-        }
-    }
-
-    return added;
-}
-
-/**
- * Listen to the 'beforeunload', 'unload' and 'pagehide' events which indicates a page unload is occurring,
- * this does NOT listen to the 'visibilitychange' event as while it does indicate that the page is being hidden
- * it does not *necessarily* mean that the page is being completely unloaded, it can mean that the user is
- * just navigating to a different Tab and may come back (without unloading the page). As such you may also
- * need to listen to the 'addPageHideEventListener' and 'addPageShowEventListener' events.
- * @param listener - The event callback to call when a page unload event is triggered
- * @param excludeEvents - [Optional] An array of events that should not be hooked, unless no other events can be.
- * @returns true - when at least one of the events was registered otherwise false
- */
-export function addPageUnloadEventListener(listener: any, excludeEvents?: string[]): boolean {
-    // Hook the unload event for the document, window and body to ensure that the client events are flushed to the server
-    // As just hooking the window does not always fire (on chrome) for page navigation's.
-    return addEventListeners(["beforeunload", "unload", "pagehide"], listener, excludeEvents);
-}
-
-/**
- * Listen to the pagehide and visibility changing to 'hidden' events
- * @param listener - The event callback to call when a page hide event is triggered
- * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
- * Suggestion: pass as true if you are also calling addPageUnloadEventListener as that also hooks pagehide
- * @returns true - when at least one of the events was registered otherwise false
- */
- export function addPageHideEventListener(listener: any, excludeEvents?: string[]): boolean {
-
-    function _handlePageVisibility(evt: any) {
-        let doc = getDocument();
-        if (listener && doc && doc.visibilityState === "hidden") {
-            listener(evt);
-        }
-    }
-
-    let pageUnloadAdded = false;
-    if (!excludeEvents || arrIndexOf(excludeEvents, strPageHide) === -1) {
-        pageUnloadAdded = addEventHandler(strPageHide, listener);
-    }
-
-    if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
-        pageUnloadAdded = addEventHandler(strVisibilityChangeEvt, _handlePageVisibility) || pageUnloadAdded;
-    }
-
-    if (!pageUnloadAdded && excludeEvents) {
-        // Failed to add any listeners and we where requested to exclude some, so just call again without excluding anything
-        pageUnloadAdded = addPageHideEventListener(listener);
-    }
-
-    return pageUnloadAdded;
-}
-
-/**
- * Listen to the pageshow and visibility changing to 'visible' events
- * @param listener - The event callback to call when a page is show event is triggered
- * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
- * @returns true - when at least one of the events was registered otherwise false
- */
- export function addPageShowEventListener(listener: any, excludeEvents?: string[]): boolean {
-
-    function _handlePageVisibility(evt: any) {
-        let doc = getDocument();
-        if (listener && doc && doc.visibilityState === "visible") {
-            listener(evt);
-        }
-    }
-
-    let pageShowAdded = false;
-    if (!excludeEvents || arrIndexOf(excludeEvents, strPageShow) === -1) {
-        pageShowAdded = addEventHandler(strPageShow, listener);
-    }
-
-    if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
-        pageShowAdded = addEventHandler(strVisibilityChangeEvt, _handlePageVisibility) || pageShowAdded;
-    }
-
-    if (!pageShowAdded && excludeEvents) {
-        // Failed to add any listeners and we where requested to exclude some, so just call again without excluding anything
-        pageShowAdded = addPageShowEventListener(listener);
-    }
-
-    return pageShowAdded;
-}
-
 export function newGuid(): string {
     function randomHexDigit() {
         return randomValue(15); // Get a random value from 0..15
@@ -205,7 +68,7 @@ export function generateW3CId(): string {
     const hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
 
     // rfc4122 version 4 UUID without dashes and with lowercase letters
-    let oct = "", tmp;
+    let oct = strEmpty, tmp;
     for (let a = 0; a < 4; a++) {
         tmp = random32();
         oct +=
@@ -380,7 +243,7 @@ export interface ICoreUtils {
      * @param callback {any} - The callback function that needs to be executed for the given event
      * @return {boolean} - true if the handler was successfully added
      */
-    addEventHandler: (eventName: string, callback: any) => boolean;
+    addEventHandler: (eventName: string, callback: any, evtNamespace?: string | string[]) => boolean;
 
     /**
      * Return the current time via the Date now() function (if available) and falls back to (new Date()).getTime() if now() is unavailable (IE8 or less)

package/src/JavaScriptSDK/DataCacheHelper.ts

@@ -0,0 +1,106 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { ObjDefineProperty } from "@microsoft/applicationinsights-shims";
+import { normalizeJsName } from "./HelperFuncs";
+import { newId } from "./RandomHelper";
+
+const _objDefineProperty = ObjDefineProperty;
+
+const version = "2.7.3";
+let instanceName = "." + newId(6);
+let _dataUid = 0;
+
+export interface IDataCache {
+    id: string;
+    accept: (target: any) => boolean,
+    get: <T>(target: any, name: string, defValue?: T, addDefault?: boolean) => T;
+    kill: (target: any, name: string) => void;
+}
+
+function _createAccessor<T>(target: any, prop: string, value: T): boolean {
+    if (_objDefineProperty) {
+        try {
+            _objDefineProperty(target, prop, {
+                value: value,
+                enumerable: false,
+                configurable: true
+            });
+            return true;
+        } catch (e) {
+            // IE8 Defines a defineProperty on Object but it's only supported for DOM elements so it will throw
+            // We will just ignore this here.
+        }
+    }
+
+    return false;
+}
+
+// Accepts only:
+//  - Node
+//    - Node.ELEMENT_NODE
+//    - Node.DOCUMENT_NODE
+//  - Object
+//    - Any
+function _canAcceptData(target: any) {
+    return target.nodeType === 1 || target.nodeType === 9 || !( +target.nodeType );
+}
+
+function _getCache(data: IDataCache, target: Node) {
+    let theCache = target[data.id];
+    if (!theCache) {
+        theCache = {};
+
+        try {
+            if (_canAcceptData(target)) {
+                if (!_createAccessor(target, data.id, theCache)) {
+                    // Environment doesn't support accessor, so just use direct assignment
+                    target[data.id] = theCache;
+                }
+            }
+        } catch (e) {
+            // Not all environments allow extending all objects, so just ignore the cache in those cases
+        }
+    }
+
+    return theCache;
+}
+
+export function createUniqueNamespace(name: string, includeVersion: boolean = false): string {
+    return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : "") + instanceName);
+}
+
+export function createElmNodeData(name?: string) {
+
+    let data = {
+        id: createUniqueNamespace("_aiData-" + (name || "") + "." + version),
+        accept: function (target: any) {
+            return _canAcceptData(target);
+        },
+        get: function <T>(target: any, name: string, defValue?: T, addDefault?: boolean): T {
+            let theCache = target[data.id];
+            if (!theCache) {
+                if (addDefault) {
+                    // Side effect is adds the cache
+                    theCache = _getCache(data, target);
+                    theCache[normalizeJsName(name)] = defValue;
+                }
+
+                return defValue;
+            }
+
+            return theCache[normalizeJsName(name)];
+        },
+        kill: function(target: any, name: string) {
+            if (target && target[name]) {
+                try {
+                    delete target[name];
+                } catch (e) {
+                    // Just cleaning up, so if this fails -- ignore
+                }
+            }
+        }
+    };
+
+    return data;
+}

package/src/JavaScriptSDK/DiagnosticLogger.ts

@@ -2,13 +2,14 @@
 // Licensed under the MIT License.
 "use strict"
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration"
-import { _InternalMessageId, LoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
+import { _InternalMessageId, _eInternalMessageId, LoggingSeverity, eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { hasJSON, getJSON, getConsole } from "./EnvUtils";
 import dynamicProto from "@microsoft/dynamicproto-js";
 import { isFunction, isNullOrUndefined, isUndefined } from "./HelperFuncs";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { getDebugExt } from "./DbgExtensionUtils";
+import { strEmpty } from "./InternalConstants";
 
 /**
  * For user non actionable traces use AI Internal prefix.
@@ -30,10 +31,10 @@ const strWarnToConsole = "warnToConsole";
 
 function _sanitizeDiagnosticText(text: string) {
     if (text) {
-        return "\"" + text.replace(/\"/g, "") + "\"";
+        return "\"" + text.replace(/\"/g, strEmpty) + "\"";
     }
 
-    return "";
+    return strEmpty;
 }
 
 function _logToConsole(func: string, message: string) {
@@ -64,14 +65,14 @@ export class _InternalLogMessage{
             (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
             msgId;
 
-        let strProps:string = "";
+        let strProps:string = strEmpty;
         if (hasJSON()) {
             strProps = getJSON().stringify(properties);
         }
 
         const diagnosticText =
-            (msg ? " message:" + _sanitizeDiagnosticText(msg) : "") +
-            (properties ? " props:" + _sanitizeDiagnosticText(strProps) : "");
+            (msg ? " message:" + _sanitizeDiagnosticText(msg) : strEmpty) +
+            (properties ? " props:" + _sanitizeDiagnosticText(strProps) : strEmpty);
 
         _self.message += diagnosticText;
     }
@@ -125,7 +126,7 @@ export class DiagnosticLogger implements IDiagnosticLogger {
                     throw message;
                 } else {
                     // Get the logging function and fallback to warnToConsole of for some reason errorToConsole doesn't exist
-                    let logFunc = severity === LoggingSeverity.CRITICAL ? strErrorToConsole : strWarnToConsole;
+                    let logFunc = severity === eLoggingSeverity.CRITICAL ? strErrorToConsole : strWarnToConsole;
 
                     if (!isUndefined(message.message)) {
                         const logLevel = _self.consoleLoggingLevel();
@@ -146,7 +147,7 @@ export class DiagnosticLogger implements IDiagnosticLogger {
 
                         _self.logInternalMessage(severity, message);
                     } else {
-                        _debugExtMsg("throw" + (severity === LoggingSeverity.CRITICAL ? "Critical" : "Warning"), message);
+                        _debugExtMsg("throw" + (severity === eLoggingSeverity.CRITICAL ? "Critical" : "Warning"), message);
                     }
                 }
             }
@@ -203,15 +204,15 @@ export class DiagnosticLogger implements IDiagnosticLogger {
                     if (severity <= _self.telemetryLoggingLevel()) {
                         _self.queue.push(message);
                         _messageCount++;
-                        _debugExtMsg((severity === LoggingSeverity.CRITICAL ? "error" : "warn"), message);
+                        _debugExtMsg((severity === eLoggingSeverity.CRITICAL ? "error" : "warn"), message);
                     }
 
                     // When throttle limit reached, send a special event
                     if (_messageCount === _self.maxInternalMessageLimit()) {
                         const throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
-                        const throttleMessage = new _InternalLogMessage(_InternalMessageId.MessageLimitPerPVExceeded, throttleLimitMessage, false);
+                        const throttleMessage = new _InternalLogMessage(_eInternalMessageId.MessageLimitPerPVExceeded, throttleLimitMessage, false);
                         _self.queue.push(throttleMessage);
-                        if (severity === LoggingSeverity.CRITICAL) {
+                        if (severity === eLoggingSeverity.CRITICAL) {
                             _self.errorToConsole(throttleLimitMessage);
                         } else {
                             _self.warnToConsole(throttleLimitMessage);

package/src/JavaScriptSDK/EnvUtils.ts

@@ -5,6 +5,7 @@
 import {
     getGlobal, strShimUndefined, strShimObject, strShimPrototype
 } from "@microsoft/applicationinsights-shims";
+import { strEmpty } from "./InternalConstants";
 import { isString, isUndefined, strContains } from "./HelperFuncs";
 
 // TypeScript removed this interface so we need to declare the global so we can check for it's existence.
@@ -296,7 +297,7 @@ export function isIE() {
     if (nav && (nav.userAgent !== _navUserAgentCheck || _isTrident === null)) {
         // Added to support test mocking of the user agent
         _navUserAgentCheck = nav.userAgent;
-        let userAgent = (_navUserAgentCheck || "").toLowerCase();
+        let userAgent = (_navUserAgentCheck || strEmpty).toLowerCase();
         _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
     }
 
@@ -309,10 +310,10 @@ export function isIE() {
 export function getIEVersion(userAgentStr: string = null): number {
     if (!userAgentStr) {
         let navigator = getNavigator() || ({} as Navigator);
-        userAgentStr = navigator ? (navigator.userAgent || "").toLowerCase() : "";
+        userAgentStr = navigator ? (navigator.userAgent || strEmpty).toLowerCase() : strEmpty;
     }
 
-    var ua = (userAgentStr || "").toLowerCase();
+    var ua = (userAgentStr || strEmpty).toLowerCase();
     // Also check for documentMode in case X-UA-Compatible meta tag was included in HTML.
     if (strContains(ua, strMsie)) {
         let doc = getDocument() || {} as Document;
@@ -332,7 +333,7 @@ export function getIEVersion(userAgentStr: string = null): number {
  */
 export function dumpObj(object: any): string {
     const objectTypeDump: string = Object[strShimPrototype].toString.call(object);
-    let propertyValueDump: string = "";
+    let propertyValueDump: string = strEmpty;
     if (objectTypeDump === "[object Error]") {
         propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
     } else if (hasJSON()) {
@@ -345,10 +346,10 @@ export function dumpObj(object: any): string {
 export function isSafari(userAgentStr ?: string) {
     if (!userAgentStr || !isString(userAgentStr)) {
         let navigator = getNavigator() || ({} as Navigator);
-        userAgentStr = navigator ? (navigator.userAgent || "").toLowerCase() : "";
+        userAgentStr = navigator ? (navigator.userAgent || strEmpty).toLowerCase() : strEmpty;
     }
 
-    var ua = (userAgentStr || "").toLowerCase();
+    var ua = (userAgentStr || strEmpty).toLowerCase();
     return (ua.indexOf("safari") >= 0);
 }