@microsoft/1ds-core-js 3.1.6 → 3.1.10

package/src/AppInsightsCore.ts

@@ -3,7 +3,7 @@
  * @author Abhilash Panwar (abpanwar) Hector Hernandez (hectorh)
  * @copyright Microsoft 2018
  */
-import { AppInsightsCore as InternalCore, IPlugin, LoggingSeverity, ITelemetryItem, IDiagnosticLogger, INotificationManager, doPerf, arrForEach } from "@microsoft/applicationinsights-core-js";
+import { AppInsightsCore as InternalCore, IPlugin, LoggingSeverity, ITelemetryItem, IDiagnosticLogger, INotificationManager, doPerf, arrForEach, dumpObj, DiagnosticLogger } from "@microsoft/applicationinsights-core-js";
 import { IExtendedConfiguration, IExtendedTelemetryItem, IExtendedAppInsightsCore } from "./DataModels";
 import { EventLatency, _ExtendedInternalMessageId } from "./Enums";
 import { isLatency, FullVersionString, getTime } from "./Utils";
@@ -23,6 +23,11 @@ export default class AppInsightsCore extends InternalCore implements IExtendedAp
         super();
 
         dynamicProto(AppInsightsCore, this, (_self, _base) => {
+            if (!_self.logger || !_self.logger.queue) {
+                // The AI Base can inject a No-Op logger so if not defined or the No-Op, change to use a default logger so initialization errors
+                // are not dropped on the floor if one is not already defined
+                _self.logger = new DiagnosticLogger({ loggingLevelConsole: LoggingSeverity.CRITICAL });
+            }
 
             _self.initialize = (config: IExtendedConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager) => {
                 doPerf(_self, () => "AppInsightsCore.initialize", () => {
@@ -66,14 +71,20 @@ export default class AppInsightsCore extends InternalCore implements IExtendedAp
                     _self.pluginVersionString = _self.pluginVersionStringArr.join(";");
                     try {
                         _base.initialize(config, extensions, logger, notificationManager);
+
+                        _self.pollInternalLogs("InternalLog");
                     } catch (e) {
-                        _self.logger.throwInternal(
+                        let logger = _self.logger;
+                        let message = dumpObj(e);
+                        if (message.indexOf("channels") !== -1) {
+                            // Add some additional context to the underlying reported error
+                            message += "\n - Channels must be provided through config.channels only!";
+                        }
+                        logger.throwInternal(
                             LoggingSeverity.CRITICAL,
-                            _ExtendedInternalMessageId.ErrorProvidedChannels, "Channels must be provided through config.channels only"
+                            _ExtendedInternalMessageId.FailedToInitializeSDK, "SDK Initialization Failed - no telemetry will be sent: " + message
                         );
                     }
-
-                    _self.pollInternalLogs("InternalLog");
                 }, () => ({ config, extensions, logger, notificationManager }));
             };
 

package/src/BaseCore.ts

@@ -6,7 +6,7 @@
  * @author Abhilash Panwar (abpanwar) Hector Hernandez (hectorh)
  * @copyright Microsoft 2018
  */
-import { BaseCore as InternalCore, IPlugin, LoggingSeverity, ITelemetryItem, IDiagnosticLogger, INotificationManager } from "@microsoft/applicationinsights-core-js";
+import { BaseCore as InternalCore, IPlugin, LoggingSeverity, ITelemetryItem, IDiagnosticLogger, INotificationManager, dumpObj } from "@microsoft/applicationinsights-core-js";
 import { IExtendedConfiguration, IExtendedTelemetryItem, IExtendedAppInsightsCore } from "./DataModels";
 import { _ExtendedInternalMessageId } from "./Enums";
 import { FullVersionString, isDocumentObjectAvailable } from "./Utils";
@@ -23,10 +23,8 @@ export default class BaseCore extends InternalCore implements IExtendedAppInsigh
         dynamicProto(BaseCore, this, (_self, _base) => {
 
             _self.initialize = (config: IExtendedConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager) => {
-                if (config) {
-                    if (!config.endpointUrl) {
-                        config.endpointUrl = "https://browser.events.data.microsoft.com/OneCollector/1.0/";
-                    }
+                if (config && !config.endpointUrl) {
+                    config.endpointUrl = "https://browser.events.data.microsoft.com/OneCollector/1.0/";
                 }
 
                 _self.getWParam = () => {
@@ -38,7 +36,7 @@ export default class BaseCore extends InternalCore implements IExtendedAppInsigh
                 } catch (e) {
                     _self.logger.throwInternal(
                         LoggingSeverity.CRITICAL,
-                        _ExtendedInternalMessageId.ErrorProvidedChannels, "Channels must be provided through config.channels only"
+                        _ExtendedInternalMessageId.FailedToInitializeSDK, "Initialization Failed: " + dumpObj(e) + "\n - Note: Channels must be provided through config.channels only"
                     );
                 }
             };

package/src/DataModels.ts

@@ -99,11 +99,32 @@ export interface IExtendedConfiguration extends IConfiguration {
     disableEventTimings?: boolean;
 
     /**
-     * [Optional] Enables support for objects with compound keys which indirectly represent an object eg. event: { "somedata.embeddedvalue": 123 }
-     * where the "key" of the object contains a "." as part of it's name.
+     * [Optional] Enables support for objects with compound keys which indirectly represent an object where the "key" of the object contains a "." as part of it's name.
+     * @example
+     * ```typescript
+     * event: { "somedata.embeddedvalue": 123 }
+     * ```
      */
     enableCompoundKey?: boolean;
-}
+
+    // Internal note: remove these after consuming the ApplicationInsights Core version that defines these on IConfiguration
+
+    /**
+     * [Optional] An array of the page unload events that you would like to be ignored, special note there must be at least one valid unload 
+     * event hooked, if you list all or the runtime environment only supports a listed "disabled" event it will still be hooked, if required by the SDK.
+     * Unload events include "beforeunload", "unload", "visibilitychange" (with 'hidden' state) and "pagehide"
+     */
+     disablePageUnloadEvents?: string[];
+
+     /**
+      * [Optional] An array of page show events that you would like to be ignored, special note there must be at lease one valid show event
+      * hooked, if you list all or the runtime environment only supports a listed (disabled) event it will STILL be hooked, if required by the SDK.
+      * Page Show events include "pageshow" and "visibilitychange" (with 'visible' state)
+      */
+     disablePageShowEvents?: string[];
+ 
+     // End of Internal note: remove these after consuming the ApplicationInsights Core version that defines these on IConfiguration
+ }
 
 /**
  * An interface used for telemetry event timings.

package/src/Index.ts

@@ -12,7 +12,7 @@ import {
     IExtendedConfiguration, IPropertyStorageOverride,
     IEventProperty, IExtendedTelemetryItem, IExtendedAppInsightsCore, IEventTiming,
     IValueSanitizer, FieldValueSanitizerFunc, IFieldSanitizerDetails, IFieldValueSanitizerProvider,
-    FieldValueSanitizerTypes,
+    FieldValueSanitizerTypes
 } from "./DataModels";
 import AppInsightsCore from "./AppInsightsCore";
 import BaseCore from "./BaseCore";
@@ -35,8 +35,8 @@ export {
     IAppInsightsCore, IChannelControls, IPlugin, INotificationManager, NotificationManager, INotificationListener,
     IConfiguration, ITelemetryItem, ITelemetryPlugin, BaseTelemetryPlugin, IProcessTelemetryContext, ProcessTelemetryContext, ITelemetryPluginChain,
     MinChannelPriorty, EventsDiscardedReason, ICoreUtils, IDiagnosticLogger, DiagnosticLogger, LoggingSeverity, SendRequestReason,
-    IPerfEvent, IPerfManager, IPerfManagerProvider, PerfEvent, PerfManager, doPerf,
-    EventHelper,
+    IPerfEvent, IPerfManager, IPerfManagerProvider, PerfEvent, PerfManager, doPerf, ICustomProperties, Tags,
+    EventHelper, AppInsightsCore as InternalAppInsightsCore, BaseCore as InternalBaseCore, _InternalLogMessage, _InternalMessageId,
     // The HelperFuncs functions
     isTypeof, isUndefined, isNullOrUndefined, hasOwnProperty, isObject, isFunction, attachEvent, detachEvent, normalizeJsName,
     objForEachKey, strStartsWith, strEndsWith, strContains, strTrim, isDate, isArray, isError, isString, isNumber, isBoolean,
@@ -57,16 +57,18 @@ export {
     strIKey, strExtensionConfig,
     // Aliases
     toISOString as getISOString,
-    isBeaconsSupported, isFetchSupported, isXhrSupported, useXDomainRequest
+    isBeaconsSupported, isFetchSupported, isXhrSupported, useXDomainRequest,
+    addPageHideEventListener, addPageShowEventListener, addEventListeners, addPageUnloadEventListener
 } from "@microsoft/applicationinsights-core-js";
 
 export {
     isValueAssigned, isLatency, isUint8ArrayAvailable, getTenantId, sanitizeProperty,
     Version, FullVersionString, getCommonSchemaMetaData, getCookie, setCookie, deleteCookie, getCookieValue,
     extend, createGuid, isDocumentObjectAvailable, isWindowObjectAvailable,
-    addPageUnloadEventListener, addPageHideEventListener, addPageShowEventListener, setProcessTelemetryTimings, getTime,
+    setProcessTelemetryTimings, getTime,
     isArrayValid, isValueKind, getFieldValueType,
     CoreUtils, disableCookies,     // exporting the overridden version for tree-shaking
     Utils,  // Replacement for import * as Utils from "./Utils";
     isChromium,     // Replace with ai-core version once published in ai-core
+    openXhr
 } from "./Utils";

package/src/Utils.ts

@@ -4,7 +4,7 @@
  * @copyright Microsoft 2018
  * File containing utility functions.
  */
-import { getGlobal, objCreateFn, ObjHasOwnProperty, strShimObject } from "@microsoft/applicationinsights-shims";
+import { objCreateFn, strShimObject } from "@microsoft/applicationinsights-shims";
 import { IEventProperty, IExtendedTelemetryItem } from "./DataModels";
 import { EventPropertyType, _ExtendedInternalMessageId, GuidStyle, ValueKind, FieldValueSanitizerType, EventLatency } from "./Enums";
 import {
@@ -13,12 +13,16 @@ import {
     newGuid, isObject, perfNow, hasOwnProperty, addEventHandler, uaDisallowsSameSiteNone, strPrototype, objDefineAccessors,
     toISOString, strTrim, isFunction, objKeys, arrReduce, arrMap, arrIndexOf, arrForEach, strUndefined, strObject,
     areCookiesSupported, ICookieMgr,  safeGetCookieMgr, generateW3CId,
-    mwcRandom32, mwcRandomSeed, random32, randomValue, newId, isIE, dateNow, isError, isDate, isTypeof, ICoreUtils, strEndsWith, useXDomainRequest, isBeaconsSupported,
+    mwcRandom32, mwcRandomSeed, random32, randomValue, newId, isIE, dateNow, isError, isDate, isTypeof, ICoreUtils, strEndsWith, useXDomainRequest, isBeaconsSupported, addPageUnloadEventListener,
 } from "@microsoft/applicationinsights-core-js";
 
 export const Version = "#version#";
 export const FullVersionString = "1DS-Web-JS-" + Version;
 
+// Defining here so we don't need to take (import) the ApplicationInsights Common module
+const strDisabledPropertyName: string = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
+const strWithCredentials: string = "withCredentials";
+
 // If value is array just get the type for the first element
 const _fieldTypeEventPropMap = {
     [FieldValueSanitizerType.NotSet]: EventPropertyType.Unspecified,
@@ -365,60 +369,6 @@ export function isArrayValid(value: any[]): boolean {
     return value.length > 0;
 }
 
-/**
- * Listen to the pagehide and visibility changing to 'hidden' events
- * @param listener The event callback to call when a page hide event is triggered
- * @returns true - when at least one of the events was registered otherwise false
- */
-export function addPageHideEventListener(listener: any): boolean {
-
-    function _handlePageVisibility(evt) {
-        let doc = getDocument();
-        if (listener && doc && doc.visibilityState === 'hidden') {
-            listener(evt);
-        }
-    }
-
-    let pageUnloadAdded = addEventHandler("pagehide", listener);
-    return addEventHandler("visibilitychange", _handlePageVisibility) || 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
- * @returns true - when at least one of the events was registered otherwise false
- */
- export function addPageShowEventListener(listener: any): boolean {
-    
-    function _handlePageVisibility(evt) {
-        let doc = getDocument();
-        if (listener && doc && doc.visibilityState === 'visible') {
-            listener(evt);
-        }
-    }
-
-    let pageUnloadAdded = addEventHandler("pageshow", listener);
-    return addEventHandler("visibilitychange", _handlePageVisibility) || pageUnloadAdded;
-}
-
-/**
- * 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
- * @returns true - when at least one of the events was registered otherwise false
- */
-export function addPageUnloadEventListener(listener: any): 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 navigations.
-    let pageUnloadAdded = addEventHandler("beforeunload", listener);
-    pageUnloadAdded = addEventHandler("unload", listener) || pageUnloadAdded;
-    return addEventHandler("pagehide", listener) || pageUnloadAdded;
-}
-
 export function setProcessTelemetryTimings(event: ITelemetryItem, identifier: string): void {
     var evt = event as IExtendedTelemetryItem;
     evt.timings = evt.timings || {};
@@ -559,3 +509,48 @@ export const CoreUtils: ICoreUtils = {
 export function isChromium() {
     return !!getGlobalInst("chrome");
 }
+
+/**
+ * Create and open an XMLHttpRequest object
+ * @param method - The request method
+ * @param urlString - The url
+ * @param withCredentials - Option flag indicating that credentials should be sent
+ * @param disabled - Optional flag indicating that the XHR object should be marked as disabled and not tracked (default is false)
+ * @param isSync - Optional flag indicating if the instance should be a synchronous request (defaults to false)
+ * @returns A new opened XHR request
+ */
+export function openXhr(method: string, urlString: string, withCredentials?: boolean, disabled: boolean = false, isSync: boolean = false) {
+
+    function _wrapSetXhrProp(xhr: XMLHttpRequest, prop: string, value: boolean) {
+        try {
+            xhr[prop] = value;
+        } catch (e) {
+            // - Wrapping as depending on the environment setting the property may fail (non-terminally)
+        }
+    }
+
+    let xhr = new XMLHttpRequest();
+
+    if (disabled) {
+        // Tag the instance so it's not tracked (trackDependency)
+        // If the environment has locked down the XMLHttpRequest (preventExtensions and/or freeze), this would
+        // cause the request to fail and we no telemetry would be sent
+        _wrapSetXhrProp(xhr, strDisabledPropertyName, disabled);
+    }
+
+    if (withCredentials) {
+        // Some libraries require that the withCredentials flag is set "before" open and
+        // - Wrapping as IE 10 has started throwing when setting before open
+        _wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
+    }
+
+    xhr.open(method, urlString, !isSync);
+
+    if (withCredentials) {
+        // withCredentials should be set AFTER open (https://xhr.spec.whatwg.org/#the-withcredentials-attribute)
+        // And older firefox instances from 11+ will throw for sync events (current versions don't) which happens during unload processing
+        _wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
+    }
+
+    return xhr;
+}