@microsoft/applicationinsights-core-js 3.0.0-beta.2303-03 → 3.0.0-beta.2303-05

package/src/JavaScriptSDK/DiagnosticLogger.ts

@@ -1,380 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-"use strict"
-import dynamicProto from "@microsoft/dynamicproto-js";
-import { dumpObj, isFunction, isUndefined } from "@nevware21/ts-utils";
-import { createDynamicConfig } from "../Config/DynamicConfig";
-import { LoggingSeverity, _InternalMessageId, _eInternalMessageId, eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
-import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
-import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
-import { getDebugExt } from "./DbgExtensionUtils";
-import { getConsole, getJSON, hasJSON } from "./EnvUtils";
-import { STR_EMPTY, STR_ERROR_TO_CONSOLE, STR_WARN_TO_CONSOLE } from "./InternalConstants";
-
-/**
- * For user non actionable traces use AI Internal prefix.
- */
-const AiNonUserActionablePrefix = "AI (Internal): ";
-
-/**
- * Prefix of the traces in portal.
- */
-const AiUserActionablePrefix = "AI: ";
-
-/**
- *  Session storage key for the prefix for the key indicating message type already logged
- */
-const AIInternalMessagePrefix = "AITR_";
-
-/**
- * Holds the current logger which will be used as the default if no logger is available
- */
-let _currentLogger: IDiagnosticLogger = null;
-
-const defaultValues = {
-    loggingLevelConsole: 0,
-    loggingLevelTelemetry: 1,
-    maxMessageLimit: 25,
-    enableDebugExceptions: false
-}
-
-function _sanitizeDiagnosticText(text: string) {
-    if (text) {
-        return "\"" + text.replace(/\"/g, STR_EMPTY) + "\"";
-    }
-
-    return STR_EMPTY;
-}
-
-function _logToConsole(func: string, message: string) {
-    let theConsole = getConsole();
-    if (!!theConsole) {
-        let logFunc = "log";
-        if (theConsole[func]) {
-            logFunc = func;
-        }
-
-        if (isFunction(theConsole[logFunc])) {
-            theConsole[logFunc](message);
-        }
-    }
-}
-
-export class _InternalLogMessage{
-    public static dataType: string = "MessageData";
-
-    public message: string;
-    public messageId: _InternalMessageId;
-
-    constructor(msgId: _InternalMessageId, msg: string, isUserAct = false, properties?: Object) {
-        let _self = this;
-
-        _self.messageId = msgId;
-        _self.message =
-            (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
-            msgId;
-
-        let strProps:string = STR_EMPTY;
-        if (hasJSON()) {
-            strProps = getJSON().stringify(properties);
-        }
-
-        const diagnosticText =
-            (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +
-            (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
-
-        _self.message += diagnosticText;
-    }
-}
-
-export function safeGetLogger(core: IAppInsightsCore, config?: IConfiguration): IDiagnosticLogger {
-    return (core || {} as any).logger || new DiagnosticLogger(config);
-}
-  
-export class DiagnosticLogger implements IDiagnosticLogger {
-    public identifier = "DiagnosticLogger";
-    
-    /**
-     * The internal logging queue
-     */
-    public queue: _InternalLogMessage[] = [];
-
-    constructor(config?: IConfiguration) {
-        /**
-         * Count of internal messages sent
-         */
-        let _messageCount: number = 0;
-
-        /**
-         * Holds information about what message types were already logged to console or sent to server.
-         */
-        let _messageLogged: { [msg: number]: boolean } = {};
-
-        let _loggingLevelConsole: number;
-        let _loggingLevelTelemetry: number;
-        let _maxInternalMessageLimit: number;
-        let _enableDebugExceptions: boolean;
-
-        dynamicProto(DiagnosticLogger, this, (_self) => {
-            _setDefaultsFromConfig(config || {});
-
-            _self.consoleLoggingLevel = () => _loggingLevelConsole;
-            
-            _self.telemetryLoggingLevel = () => _loggingLevelTelemetry;
-
-            _self.maxInternalMessageLimit = () => _maxInternalMessageLimit;
-
-            _self.enableDebugExceptions = () => _enableDebugExceptions;
-            
-            /**
-             * This method will throw exceptions in debug mode or attempt to log the error as a console warning.
-             * @param severity - {LoggingSeverity} - The severity of the log message
-             * @param message - {_InternalLogMessage} - The log message.
-             */
-            _self.throwInternal = (severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct = false) => {
-                const message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
-
-                if (_enableDebugExceptions) {
-                    throw dumpObj(message);
-                } else {
-                    // Get the logging function and fallback to warnToConsole of for some reason errorToConsole doesn't exist
-                    let logFunc = severity === eLoggingSeverity.CRITICAL ? STR_ERROR_TO_CONSOLE : STR_WARN_TO_CONSOLE;
-
-                    if (!isUndefined(message.message)) {
-                        if (isUserAct) {
-                            // check if this message type was already logged to console for this page view and if so, don't log it again
-                            const messageKey: number = +message.messageId;
-
-                            if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
-                                _self[logFunc](message.message);
-                                _messageLogged[messageKey] = true;
-                            }
-                        } else {
-                            // Only log traces if the console Logging Level is >= the throwInternal severity level
-                            if (_loggingLevelConsole >= severity) {
-                                _self[logFunc](message.message);
-                            }
-                        }
-
-                        _logInternalMessage(severity, message);
-                    } else {
-                        _debugExtMsg("throw" + (severity === eLoggingSeverity.CRITICAL ? "Critical" : "Warning"), message);
-                    }
-                }
-            }
-
-            /**
-             * This will write a warning to the console if possible
-             * @param message - {string} - The warning message
-             */
-            _self.warnToConsole = (message: string) => {
-                _logToConsole("warn", message);
-                _debugExtMsg("warning", message);
-            }
-
-            /**
-             * This will write an error to the console if possible
-             * @param message - {string} - The error message
-             */
-            _self.errorToConsole = (message: string) => {
-                _logToConsole("error", message);
-                _debugExtMsg("error", message);
-            }
-
-            /**
-             * Resets the internal message count
-             */
-            _self.resetInternalMessageCount = (): void => {
-                _messageCount = 0;
-                _messageLogged = {};
-            };
-
-            /**
-             * Logs a message to the internal queue.
-             * @param severity - {LoggingSeverity} - The severity of the log message
-             * @param message - {_InternalLogMessage} - The message to log.
-             */
-            _self.logInternalMessage = _logInternalMessage;
-
-            function _logInternalMessage(severity: LoggingSeverity, message: _InternalLogMessage): void {
-                if (_areInternalMessagesThrottled()) {
-                    return;
-                }
-
-                // check if this message type was already logged for this session and if so, don't log it again
-                let logMessage = true;
-                const messageKey = AIInternalMessagePrefix + message.messageId;
-
-                // if the session storage is not available, limit to only one message type per page view
-                if (_messageLogged[messageKey]) {
-                    logMessage = false;
-                } else {
-                    _messageLogged[messageKey] = true;
-                }
-
-                if (logMessage) {
-                    // Push the event in the internal queue
-                    if (severity <= _loggingLevelTelemetry) {
-                        _self.queue.push(message);
-                        _messageCount++;
-                        _debugExtMsg((severity === eLoggingSeverity.CRITICAL ? "error" : "warn"), message);
-                    }
-
-                    // When throttle limit reached, send a special event
-                    if (_messageCount === _maxInternalMessageLimit) {
-                        const throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
-                        const throttleMessage = new _InternalLogMessage(_eInternalMessageId.MessageLimitPerPVExceeded, throttleLimitMessage, false);
-                        _self.queue.push(throttleMessage);
-                        if (severity === eLoggingSeverity.CRITICAL) {
-                            _self.errorToConsole(throttleLimitMessage);
-                        } else {
-                            _self.warnToConsole(throttleLimitMessage);
-                        }
-                    }
-                }
-            }
-
-            function _setDefaultsFromConfig(config: IConfiguration) {
-                // make sure the config is dynamic
-                let handler = createDynamicConfig(config, defaultValues, _self);
-                handler.watch((details) => {
-                    let config = details.cfg;
-                    _loggingLevelConsole = config.loggingLevelConsole;
-                    _loggingLevelTelemetry = config.loggingLevelTelemetry;
-                    _maxInternalMessageLimit = config.maxMessageLimit;
-                    _enableDebugExceptions =  config.enableDebugExceptions;
-                });
-            }
-
-            function _areInternalMessagesThrottled(): boolean {
-                return _messageCount >= _maxInternalMessageLimit;
-            }
-
-            function _debugExtMsg(name: string, data: any) {
-                let dbgExt = getDebugExt(config || {});
-                if (dbgExt && dbgExt.diagLog) {
-                    dbgExt.diagLog(name, data);
-                }
-            }
-        });
-    }
-
-    /**
-     * When this is true the SDK will throw exceptions to aid in debugging.
-     */
-    public enableDebugExceptions(): boolean {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-        return false;
-    }
-
-    /**
-     * 0: OFF (default)
-     * 1: CRITICAL
-     * 2: >= WARNING
-     */
-    public consoleLoggingLevel(): number {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-        return 0;
-    }
-
-    /**
-     * 0: OFF
-     * 1: CRITICAL (default)
-     * 2: >= WARNING
-     */
-    public telemetryLoggingLevel(): number {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-        return 1;
-    }
-
-    /**
-     * The maximum number of internal messages allowed to be sent per page view
-     */
-    public maxInternalMessageLimit(): number {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-        return 25;
-    }
-
-    /**
-     * This method will throw exceptions in debug mode or attempt to log the error as a console warning.
-     * @param severity - {LoggingSeverity} - The severity of the log message
-     * @param message - {_InternalLogMessage} - The log message.
-     */
-    public throwInternal(severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct = false) {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-    }
-
-    /**
-     * This will write a warning to the console if possible
-     * @param message - {string} - The warning message
-     */
-    public warnToConsole(message: string) {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-    }
-
-    /**
-     * This will write an error to the console if possible
-     * @param message - {string} - The warning message
-     */
-    public errorToConsole(message: string) {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-    }
-
-    /**
-     * Resets the internal message count
-     */
-    public resetInternalMessageCount(): void {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-    }
-
-    /**
-     * Logs a message to the internal queue.
-     * @param severity - {LoggingSeverity} - The severity of the log message
-     * @param message - {_InternalLogMessage} - The message to log.
-     */
-    public logInternalMessage(severity: LoggingSeverity, message: _InternalLogMessage): void {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-    }
-
-    public update(updateState: ITelemetryUpdateState): void {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-    }
-}
-
-function _getLogger(logger: IDiagnosticLogger) {
-    return (logger || new DiagnosticLogger());
-}
-
-/**
- * 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) {
-    _getLogger(logger).throwInternal(severity, msgId, msg, properties, isUserAct);
-}
-
-/**
- * This is a helper method which will call warnToConsole on the passed logger with the provided message.
- * @param logger - The Diagnostic Logger instance to use.
- * @param message - {_InternalLogMessage} - The log message.
- */
-export function _warnToConsole(logger: IDiagnosticLogger, message: string) {
-    _getLogger(logger).warnToConsole(message);
-}
-
-/**
- * Logs a message to the internal queue.
- * @param logger - The Diagnostic Logger instance to use.
- * @param severity - {LoggingSeverity} - The severity of the log message
- * @param message - {_InternalLogMessage} - The message to log.
- */
-export function _logInternalMessage(logger: IDiagnosticLogger, severity: LoggingSeverity, message: _InternalLogMessage) {
-    _getLogger(logger).logInternalMessage(severity, message);
-}

package/src/JavaScriptSDK/EnvUtils.ts

@@ -1,312 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-"use strict";
-
-import { strShimObject, strShimPrototype, strShimUndefined } from "@microsoft/applicationinsights-shims";
-import { getDocument, getInst, getNavigator, getPerformance, hasNavigator, isString, isUndefined, strIndexOf } from "@nevware21/ts-utils";
-import { strContains } from "./HelperFuncs";
-import { STR_EMPTY } from "./InternalConstants";
-
-// TypeScript removed this interface so we need to declare the global so we can check for it's existence.
-declare var XDomainRequest: any;
-
-/**
- * This file exists to hold environment utilities that are required to check and
- * validate the current operating environment. Unless otherwise required, please
- * only use defined methods (functions) in this class so that users of these
- * functions/properties only need to include those that are used within their own modules.
- */
-
-const strDocumentMode = "documentMode";
-const strLocation = "location";
-const strConsole = "console";
-const strPerformance = "performance";
-const strJSON = "JSON";
-const strCrypto = "crypto";
-const strMsCrypto = "msCrypto";
-const strReactNative = "ReactNative";
-const strMsie = "msie";
-const strTrident = "trident/";
-const strXMLHttpRequest = "XMLHttpRequest";
-
-let _isTrident: boolean = null;
-let _navUserAgentCheck: string = null;
-let _enableMocks = false;
-let _useXDomainRequest: boolean | null = null;
-let _beaconsSupported: boolean | null = null;
-
-function _hasProperty(theClass: any, property: string) {
-    let supported = false;
-    if (theClass) {
-        try {
-            supported = property in theClass;
-            if (!supported) {
-                let proto = theClass[strShimPrototype];
-                if (proto) {
-                    supported = property in proto;
-                }
-            }
-        } catch (e) {
-            // Do Nothing
-        }
-
-        if (!supported) {
-            try {
-                let tmp = new theClass();
-                supported = !isUndefined(tmp[property]);
-            } catch (e) {
-                // Do Nothing
-            }
-        }
-    }
-
-    return supported;
-}
-
-/**
- * Enable the lookup of test mock objects if requested
- * @param enabled
- */
-export function setEnableEnvMocks(enabled: boolean) {
-    _enableMocks = enabled;
-}
-
-/**
- * Returns the global location object if it is present otherwise null.
- * This helper is used to access the location object without causing an exception
- * "Uncaught ReferenceError: location is not defined"
- */
-export function getLocation(checkForMock?: boolean): Location | null {
-    if (checkForMock && _enableMocks) {
-        let mockLocation = getInst("__mockLocation") as Location;
-        if (mockLocation) {
-            return mockLocation;
-        }
-    }
-
-    if (typeof location === strShimObject && location) {
-        return location;
-    }
-
-    return getInst(strLocation);
-}
-
-/**
- * Returns the global console object
- */
-export function getConsole(): Console | null {
-    if (typeof console !== strShimUndefined) {
-        return console;
-    }
-
-    return getInst(strConsole);
-}
-
-/**
- * Checks if JSON object is available, this is required as we support the API running without a
- * window /document (eg. Node server, electron webworkers) and if we attempt to assign a history
- * object to a local variable or pass as an argument an "Uncaught ReferenceError: JSON is not defined"
- * exception will be thrown.
- * Defined as a function to support lazy / late binding environments.
- */
-export function hasJSON(): boolean {
-    return Boolean((typeof JSON === strShimObject && JSON) || getInst(strJSON) !== null);
-}
-
-/**
- * Returns the global JSON object if it is present otherwise null.
- * This helper is used to access the JSON object without causing an exception
- * "Uncaught ReferenceError: JSON is not defined"
- */
-export function getJSON(): JSON | null {
-    if (hasJSON()) {
-        return JSON || getInst(strJSON);
-    }
-
-    return null;
-}
-
-/**
- * Returns the crypto object if it is present otherwise null.
- * This helper is used to access the crypto object from the current
- * global instance which could be window or globalThis for a web worker
- */
-export function getCrypto(): Crypto | null {
-    return getInst(strCrypto);
-}
-
-/**
- * Returns the crypto object if it is present otherwise null.
- * This helper is used to access the crypto object from the current
- * global instance which could be window or globalThis for a web worker
- */
-export function getMsCrypto(): Crypto | null {
-    return getInst(strMsCrypto);
-}
-
-/**
- * Returns whether the environment is reporting that we are running in a React Native Environment
- */
-export function isReactNative(): boolean {
-    // If running in React Native, navigator.product will be populated
-    var nav = getNavigator();
-    if (nav && nav.product) {
-        return nav.product === strReactNative;
-    }
-
-    return false;
-}
-
-/**
- * Identifies whether the current environment appears to be IE
- */
-export function isIE() {
-    let nav = getNavigator();
-    if (nav && (nav.userAgent !== _navUserAgentCheck || _isTrident === null)) {
-        // Added to support test mocking of the user agent
-        _navUserAgentCheck = nav.userAgent;
-        let userAgent = (_navUserAgentCheck || STR_EMPTY).toLowerCase();
-        _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
-    }
-
-    return _isTrident;
-}
-
-/**
- * Gets IE version returning the document emulation mode if we are running on IE, or null otherwise
- */
-export function getIEVersion(userAgentStr: string = null): number {
-    if (!userAgentStr) {
-        let navigator = getNavigator() || ({} as Navigator);
-        userAgentStr = navigator ? (navigator.userAgent || STR_EMPTY).toLowerCase() : STR_EMPTY;
-    }
-
-    var ua = (userAgentStr || STR_EMPTY).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;
-        return Math.max(parseInt(ua.split(strMsie)[1]), (doc[strDocumentMode] || 0));
-    } else if (strContains(ua, strTrident)) {
-        let tridentVer = parseInt(ua.split(strTrident)[1]);
-        if (tridentVer) {
-            return tridentVer + 4;
-        }
-    }
-
-    return null;
-}
-
-export function isSafari(userAgentStr ?: string) {
-    if (!userAgentStr || !isString(userAgentStr)) {
-        let navigator = getNavigator() || ({} as Navigator);
-        userAgentStr = navigator ? (navigator.userAgent || STR_EMPTY).toLowerCase() : STR_EMPTY;
-    }
-
-    var ua = (userAgentStr || STR_EMPTY).toLowerCase();
-    return (strIndexOf(ua, "safari") >= 0);
-}
-
-/**
- * Checks if HTML5 Beacons are supported in the current environment.
- * @returns True if supported, false otherwise.
- */
-export function isBeaconsSupported(): boolean {
-    if (_beaconsSupported === null) {
-        _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
-    }
-
-    return _beaconsSupported;
-}
-
-/**
- * Checks if the Fetch API is supported in the current environment.
- * @param withKeepAlive - [Optional] If True, check if fetch is available and it supports the keepalive feature, otherwise only check if fetch is supported
- * @returns True if supported, otherwise false
- */
-export function isFetchSupported(withKeepAlive?: boolean): boolean {
-    let isSupported = false;
-    try {
-        isSupported = !!getInst("fetch");
-        const request = getInst("Request");
-        if (isSupported && withKeepAlive && request) {
-            isSupported = _hasProperty(request, "keepalive");
-        }
-    } catch (e) {
-        // Just Swallow any failure during availability checks
-    }
-
-    return isSupported;
-}
-
-export function useXDomainRequest(): boolean | undefined {
-    if (_useXDomainRequest === null) {
-        _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
-        if (_useXDomainRequest && isXhrSupported()) {
-            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getInst(strXMLHttpRequest), "withCredentials");
-        }
-    }
-
-    return _useXDomainRequest;
-}
-
-/**
- * Checks if XMLHttpRequest is supported
- * @returns True if supported, otherwise false
- */
-export function isXhrSupported(): boolean {
-    let isSupported = false;
-    try {
-        const xmlHttpRequest = getInst(strXMLHttpRequest);
-        isSupported = !!xmlHttpRequest;
-    } catch (e) {
-        // Just Swallow any failure during availability checks
-    }
-
-    return isSupported;
-}
-
-
-function _getNamedValue(values: any, name: string) {
-    if (values) {
-        for (var i = 0; i < values.length; i++) {
-            var value = values[i] as any;
-            if (value.name) {
-                if(value.name === name) {
-                    return value;
-                }
-            }
-        }
-    }
-
-    return {};
-}
-
-/**
- * Helper function to fetch the named meta-tag from the page.
- * @param name
- */
-export function findMetaTag(name: string): any {
-    let doc = getDocument();
-    if (doc && name) {
-        // Look for a meta-tag
-        return _getNamedValue(doc.querySelectorAll("meta"), name).content;
-    }
-
-    return null;
-}
-
-/**
- * Helper function to fetch the named server timing value from the page response (first navigation event).
- * @param name
- */
-export function findNamedServerTiming(name: string): any {
-    let value: any;
-    let perf = getPerformance();
-    if (perf) {
-        // Try looking for a server-timing header
-        let navPerf = perf.getEntriesByType("navigation") || [];
-        value = _getNamedValue((navPerf.length > 0 ? navPerf[0] : {} as any).serverTiming, name).description;
-    }
-
-    return value;
-}