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

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.8.0-nightly.2204-04";
+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);
                     }
                 }
             }
@@ -164,7 +165,7 @@ export class DiagnosticLogger implements IDiagnosticLogger {
              * This will write an error to the console if possible
              * @param message {string} - The error message
              */
-             _self.errorToConsole = (message: string) => {
+            _self.errorToConsole = (message: string) => {
                 _logToConsole("error", message);
                 _debugExtMsg("error", 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);
@@ -319,3 +320,17 @@ export class DiagnosticLogger implements IDiagnosticLogger {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
     }
 }
+
+/**
+ * This is a helper method which will call throwInternal on the passed logger, will throw exceptions in
+ * debug mode or attempt to log the error as a console warning. This helper is provided mostly to better
+ * support minification as logger.throwInternal() will not compress the publish "throwInternal" used throughout
+ * the code.
+ * @param logger - The Diagnostic Logger instance to use.
+ * @param severity {LoggingSeverity} - The severity of the log message
+ * @param message {_InternalLogMessage} - The log message.
+ */
+export function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct = false) {
+    (logger || new DiagnosticLogger()).throwInternal(severity, msgId, msg, properties, isUserAct);
+}
+

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.
@@ -31,6 +32,7 @@ const strMsCrypto = "msCrypto";
 const strReactNative = "ReactNative";
 const strMsie = "msie";
 const strTrident = "trident/";
+const strXMLHttpRequest = "XMLHttpRequest";
 
 let _isTrident: boolean = null;
 let _navUserAgentCheck: string = null;
@@ -295,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));
     }
 
@@ -308,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;
@@ -331,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()) {
@@ -344,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);
 }
 
@@ -355,7 +357,7 @@ export function isSafari(userAgentStr ?: string) {
  * Checks if HTML5 Beacons are supported in the current environment.
  * @returns True if supported, false otherwise.
  */
- export function isBeaconsSupported(): boolean {
+export function isBeaconsSupported(): boolean {
     if (_beaconsSupported === null) {
         _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
     }
@@ -371,8 +373,7 @@ export function isSafari(userAgentStr ?: string) {
 export function isFetchSupported(withKeepAlive?: boolean): boolean {
     let isSupported = false;
     try {
-        const fetchApi = getGlobalInst("fetch");
-        isSupported = !!fetchApi;
+        isSupported = !!getGlobalInst("fetch");
         const request = getGlobalInst("Request");
         if (isSupported && withKeepAlive && request) {
             isSupported = _hasProperty(request, "keepalive");
@@ -386,9 +387,9 @@ export function isFetchSupported(withKeepAlive?: boolean): boolean {
 
 export function useXDomainRequest(): boolean | undefined {
     if (_useXDomainRequest === null) {
-        _useXDomainRequest = (typeof XDomainRequest !== "undefined");
+        _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
         if (_useXDomainRequest && isXhrSupported()) {
-            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getGlobalInst("XMLHttpRequest"), "withCredentials");
+            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getGlobalInst(strXMLHttpRequest), "withCredentials");
         }
     }
 
@@ -402,7 +403,7 @@ export function useXDomainRequest(): boolean | undefined {
 export function isXhrSupported(): boolean {
     let isSupported = false;
     try {
-        const xmlHttpRequest = getGlobalInst("XMLHttpRequest");
+        const xmlHttpRequest = getGlobalInst(strXMLHttpRequest);
         isSupported = !!xmlHttpRequest;
     } catch (e) {
         // Just Swallow any failure during availability checks