@microsoft/applicationinsights-core-js 2.7.4-nightly.2202-07 → 2.8.0-beta.2202-06

package/src/JavaScriptSDK/BaseTelemetryPlugin.ts

@@ -3,6 +3,7 @@
 
 "use strict";
 
+import dynamicProto from "@microsoft/dynamicproto-js";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore"
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
@@ -10,9 +11,10 @@ import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetr
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
 import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
-import { ProcessTelemetryContext } from "./ProcessTelemetryContext";
-import { isFunction, isNullOrUndefined, setValue } from "./HelperFuncs";
+import { createProcessTelemetryContext } from "./ProcessTelemetryContext";
+import { isArray, isFunction, isNullOrUndefined, setValue } from "./HelperFuncs";
 import { strExtensionConfig } from "./Constants";
+import { IInstrumentHook } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
 
 let strGetPlugin = "getPlugin";
 
@@ -22,6 +24,16 @@ let strGetPlugin = "getPlugin";
  * implementation so that new default implementations can be added without breaking all plugins.
  */
 export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
+    
+    public identifier: string;
+    public version?: string;
+
+    /**
+     * Holds the core instance that was used during initialization
+     */
+    public core: IAppInsightsCore;
+
+    priority: number;
 
     /**
      * Call back for telemetry processing before it it is sent
@@ -35,7 +47,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
     /**
      * Set next extension for telemetry processing
      */
-    public setNextPlugin: (next: ITelemetryPlugin|ITelemetryPluginChain) => void;
+    public setNextPlugin: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
 
     /**
      * Returns the current diagnostic logger that can be used to log issues, if no logger is currently
@@ -48,16 +60,6 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      */
     public isInitialized: () => boolean;
 
-    public identifier: string;
-    public version?: string;
-
-    /**
-     * Holds the core instance that was used during initialization
-     */
-    public core: IAppInsightsCore;
-
-    priority: number;
-
     /**
      * Helper to return the current IProcessTelemetryContext, if the passed argument exists this just
      * returns that value (helps with minification for callers), otherwise it will return the configured
@@ -71,21 +73,39 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      */
     protected setInitialized: (isInitialized: boolean) => void;
 
-    /**
-     * Internal helper to initialize the instance
-     */
-    private _baseTelInit: (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?:ITelemetryPluginChain) => void;
-
     constructor() {
-        let _self = this;
-        let _isinitialized = false;
-        let _rootCtx: IProcessTelemetryContext = null; // Used as the root context, holding the current config and initialized core
-        let _nextPlugin:ITelemetryPlugin|ITelemetryPluginChain = null; // Used for backward compatibility where plugins don't call the main pipeline
+        let _self = this;           // Setting _self here as it's used outside of the dynamicProto as well
 
-        _self.core = null;
+        // NOTE!: DON'T set default values here, instead set them in the _initDefaults() function as it is also called during teardown()
+        let _isinitialized: boolean;
+        let _rootCtx: IProcessTelemetryContext; // Used as the root context, holding the current config and initialized core
+        let _nextPlugin: ITelemetryPlugin | ITelemetryPluginChain; // Used for backward compatibility where plugins don't call the main pipeline
+        let _hooks: IInstrumentHook[];
+
+        _initDefaults();
+
+        dynamicProto(BaseTelemetryPlugin, _self, (_self) => {
+
+            _self.initialize = (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?:ITelemetryPluginChain): void => {
+                _setDefaults(config, core, pluginChain);
+                _isinitialized = true;
+            }
+        
+            _self._addHook = (hooks: IInstrumentHook | IInstrumentHook[]) => {
+                if (hooks) {
+                    if (isArray(hooks)) {
+                        _hooks = _hooks.concat(hooks);
+                    } else {
+                        _hooks.push(hooks);
+                    }
+                }
+            };
+        });
+
+        // These are added after the dynamicProto so that are not moved to the prototype
 
         _self.diagLog = (itemCtx:IProcessTelemetryContext): IDiagnosticLogger => {
-            return _self._getTelCtx(itemCtx).diagLog();
+            return _getTelCtx(itemCtx).diagLog();
         }
 
         _self.isInitialized = () => {
@@ -101,7 +121,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
         // should use processNext() function. If you require access to the plugin use the
         // IProcessTelemetryContext.getNext().getPlugin() while in the pipeline, Note getNext() may return null.
 
-        _self.setNextPlugin = (next: ITelemetryPlugin|ITelemetryPluginChain) => {
+        _self.setNextPlugin = (next: ITelemetryPlugin | ITelemetryPluginChain) => {
             _nextPlugin = next;
         };
 
@@ -116,10 +136,12 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
             }
         };
 
-        _self._getTelCtx = (currentCtx:IProcessTelemetryContext = null) => {
+        _self._getTelCtx = _getTelCtx;
+        
+        function _getTelCtx(currentCtx:IProcessTelemetryContext = null) {
             let itemCtx:IProcessTelemetryContext = currentCtx;
             if (!itemCtx) {
-                let rootCtx = _rootCtx || new ProcessTelemetryContext(null, {}, _self.core);
+                let rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self.core);
                 // tslint:disable-next-line: prefer-conditional-expression
                 if (_nextPlugin && _nextPlugin[strGetPlugin]) {
                     // Looks like a chain object
@@ -132,7 +154,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
             return itemCtx;
         }
 
-        _self._baseTelInit = (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?:ITelemetryPluginChain) => {
+        function _setDefaults(config: IConfiguration, core: IAppInsightsCore, pluginChain: ITelemetryPluginChain) {
             if (config) {
                 // Make sure the extensionConfig exists
                 setValue(config, strExtensionConfig, [], null, isNullOrUndefined);
@@ -143,7 +165,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
                 pluginChain = core.getProcessTelContext().getNext();
             }
     
-            let nextPlugin:IPlugin = _nextPlugin as IPlugin;
+            let nextPlugin: IPlugin = _nextPlugin as IPlugin;
             if (_nextPlugin && _nextPlugin[strGetPlugin]) {
                 // If it looks like a proxy/chain then get the plugin
                 nextPlugin = _nextPlugin[strGetPlugin]();
@@ -151,14 +173,29 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
 
             // Support legacy plugins where core was defined as a property
             _self.core = core;
-            _rootCtx = new ProcessTelemetryContext(pluginChain, config, core, nextPlugin);
-            _isinitialized = true;
+            _rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
+        }
+
+        function _initDefaults() {
+            _isinitialized = false;
+            _self.core = null;
+            _rootCtx = null;
+            _nextPlugin = null;
+            _hooks = [];
         }
     }
 
     public initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?:ITelemetryPluginChain): void {
-        this._baseTelInit(config, core, extensions, pluginChain);
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
     }
 
     public abstract processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
+
+    /**
+     * Add this hook so that it is automatically removed during unloading
+     * @param hooks - The single hook or an array of IInstrumentHook objects
+     */
+    protected _addHook(hooks: IInstrumentHook | IInstrumentHook[]): void {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+    }
 }

package/src/JavaScriptSDK/ChannelController.ts

@@ -1,135 +1,207 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-"use strict";
+// // Licensed under the MIT License.
 
-import dynamicProto from "@microsoft/dynamicproto-js";
-import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore"
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
+import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
+import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IChannelControls } from "../JavaScriptSDK.Interfaces/IChannelControls";
-import { IPlugin, ITelemetryPlugin  } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
-import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
-import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
+import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
-import { _InternalLogMessage } from "./DiagnosticLogger";
-import { BaseTelemetryPlugin } from "./BaseTelemetryPlugin";
-import { ProcessTelemetryContext } from "./ProcessTelemetryContext";
+import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
+import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
+import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
+import { arrForEach, isArray, objFreeze, throwError } from "./HelperFuncs";
+import { createProcessTelemetryContext, createTelemetryProxyChain } from "./ProcessTelemetryContext";
 import { initializePlugins } from "./TelemetryHelpers";
-import { arrForEach, objDefineAccessors, throwError } from "./HelperFuncs";
 
-const ChannelControllerPriority = 500;
-const ChannelValidationMessage = "Channel has invalid priority";
+export const ChannelControllerPriority = 500;
+const ChannelValidationMessage = "Channel has invalid priority - ";
 
-export class ChannelController extends BaseTelemetryPlugin {
+export interface IChannelController extends IChannelControls {
+    flush(isAsync: boolean, callBack: (flushComplete?: boolean) => void, sendReason: SendRequestReason, cbTimeout?: number): void
+}
+
+export interface _IInternalChannels {
+    queue: IChannelControls[];
+    chain: ITelemetryPluginChain;
+}
+
+function _addChannelQueue(channelQueue: _IInternalChannels[], queue: IChannelControls[], config: IConfiguration, core: IAppInsightsCore) {
+    if (queue && isArray(queue) && queue.length > 0) {
+        queue = queue.sort((a, b) => { // sort based on priority within each queue
+            return a.priority - b.priority;
+        });
+
+        arrForEach(queue, queueItem => {
+            if (queueItem.priority < ChannelControllerPriority) {
+                throwError(ChannelValidationMessage + queueItem.identifier);
+            }
+        });
 
-    identifier: string = "ChannelControllerPlugin";
-    priority: number = ChannelControllerPriority; // in reserved range 100 to 200
+        channelQueue.push({
+            queue: objFreeze(queue),
+            chain: createTelemetryProxyChain(queue, config, core)
+        });
+    }
+}
 
-    public setNextPlugin: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
+export function createChannelControllerPlugin(channelQueue: _IInternalChannels[], core: IAppInsightsCore): IChannelController {
 
-    constructor() {
-        super();
-        let _channelQueue: IChannelControls[][];
+    function _getTelCtx(itemCtx: IProcessTelemetryContext) {
+        if (!itemCtx) {
+            // For some reason the previous plugin didn't pass down the itemCtx (perhaps an old plugin)
+            itemCtx = createProcessTelemetryContext(null, core.config, core, null)
+        }
 
-        dynamicProto(ChannelController, this, (_self, _base) => {
-            _self.setNextPlugin = (next: ITelemetryPlugin | ITelemetryPluginChain) => {
-                // The Channel controller is last in pipeline
-            };
+        return itemCtx;
+    }
 
-            _self.processTelemetry = (item: ITelemetryItem, itemCtx: IProcessTelemetryContext) => {
-                if (_channelQueue) {
-                    arrForEach(_channelQueue, queues => {
-                        // pass on to first item in queue
-                        if (queues.length > 0) {
-                            // Copying the item context as we could have mutiple chains that are executing asynchronously
-                            // and calling _getDefTelCtx as it's possible that the caller doesn't pass any context
-                            let chainCtx = this._getTelCtx(itemCtx).createNew(queues);
-                            chainCtx.processNext(item);
+    function _processChannelQueue(itemCtx: IProcessTelemetryContext, processFn: (chainCtx: IProcessTelemetryContext) => void, onComplete?: () => void) {
+        if (channelQueue && channelQueue.length > 0) {
+            let waiting = channelQueue.length;
+            arrForEach(channelQueue, (channels) => {
+                // pass on to first item in queue
+                if (channels && channels.queue.length > 0) {
+                    let channelChain = channels.chain;
+                    let chainCtx = _getTelCtx(itemCtx).createNew(channelChain);
+                    chainCtx.onComplete(() => {
+                        waiting --;
+
+                        if (waiting === 0) {
+                            onComplete && onComplete();
+                            onComplete = null;
                         }
                     });
-                }
-            };
-
-            _self.getChannelControls = (): IChannelControls[][] => {
-                return _channelQueue;
-            };
-                
-            _self.initialize = (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[]) => {
-                if (_self.isInitialized()) {
-                    // already initialized
-                    return;
-                }
 
-                _base.initialize(config, core, extensions);
+                    // Cause this chain to start processing
+                    processFn(chainCtx);
+                } else {
+                    waiting --;
+                }
+            });
 
-                _createChannelQueues((config||{}).channels, extensions);
-        
-                // Initialize the Queues
-                arrForEach(_channelQueue, queue => initializePlugins(new ProcessTelemetryContext(queue, config, core), extensions));
+            if (waiting === 0) {
+                onComplete && onComplete();
             }
-        });
+        } else {
+            onComplete && onComplete();
+        }
+    }
 
-        function _checkQueuePriority(queue:IChannelControls[]) {
-            arrForEach(queue, queueItem => {
-                if (queueItem.priority < ChannelControllerPriority) {
-                    throwError(ChannelValidationMessage + queueItem.identifier);
+    let isInitialized = false;
+    let channelController: IChannelController = {
+        identifier: "ChannelControllerPlugin",
+        priority: ChannelControllerPriority,
+        initialize: (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain) => {
+            isInitialized = true;
+            arrForEach(channelQueue, (channels) => {
+                if (channels && channels.queue.length > 0) {
+                    initializePlugins(createProcessTelemetryContext(channels.chain, config, core), extensions);
                 }
             });
-        }
-        
-        function _addChannelQueue(queue:IChannelControls[]) {
-            if (queue && queue.length > 0) {
-                queue = queue.sort((a, b) => { // sort based on priority within each queue
-                    return a.priority - b.priority;
+        },
+        isInitialized: () => { return isInitialized },
+        processTelemetry: (item: ITelemetryItem, itemCtx: IProcessTelemetryContext) => {
+            _processChannelQueue(itemCtx, (chainCtx: IProcessTelemetryContext) => {
+                chainCtx.processNext(item);
+            }, () => {
+                itemCtx.processNext(item);
+            });
+        },
+        pause: () => {
+            _processChannelQueue(null, (chainCtx: IProcessTelemetryContext) => {
+                chainCtx.iterate<IChannelControls>((plugin) => {
+                    plugin.pause && plugin.pause();
                 });
-        
-                _checkQueuePriority(queue);
-                _channelQueue.push(queue);
-            }
-        }
-        
-        function _createChannelQueues(channels:IChannelControls[][], extensions: IPlugin[]) {
-            _channelQueue = [];
-        
-            if (channels) {
-                // Add and sort the configuration channel queues
-                arrForEach(channels, queue => _addChannelQueue(queue));
+            });
+        },
+        resume: () => {
+            _processChannelQueue(null, (chainCtx: IProcessTelemetryContext) => {
+                chainCtx.iterate<IChannelControls>((plugin) => {
+                    plugin.resume && plugin.resume();
+                });
+            });
+        },
+        teardown: () => {
+            _processChannelQueue(null, (chainCtx: IProcessTelemetryContext) => {
+                chainCtx.iterate<IChannelControls>((plugin) => {
+                    plugin.teardown && plugin.teardown();
+                });
+            });
+        },
+        flush: (isAsync: boolean, callBack: (flushComplete?: boolean) => void, sendReason: SendRequestReason, cbTimeout?: number) => {
+            let doneIterating = false;
+            let waiting = 0;
+            let cbTimer: any = null;
+
+            cbTimeout = cbTimeout || 5000;
+
+            function doCallback() {
+                if (doneIterating && waiting === 0) {
+                    if (cbTimer) {
+                        clearTimeout(cbTimer);
+                        cbTimer = null;
+                    }
+
+                    callBack && callBack(doneIterating);
+                    callBack = null;
+                }
             }
-        
-            if (extensions) {
-                // Create a new channel queue for any extensions with a priority > the ChannelControllerPriority
-                let extensionQueue:IChannelControls[] = [];
-                arrForEach(extensions as IChannelControls[], plugin => {
-                    if (plugin.priority > ChannelControllerPriority) {
-                        extensionQueue.push(plugin);
+
+            // Setting waiting to one so that we don't call the callBack until we finish iterating
+            waiting  = 1;
+            _processChannelQueue(null, (chainCtx: IProcessTelemetryContext) => {
+                chainCtx.iterate<IChannelControls>((plugin) => {
+                    if (plugin.flush) {
+                        waiting ++;
+
+                        // Not all channels will call this callback for every scenario
+                        if (!plugin.flush(isAsync, () => {
+                            waiting--;
+                            doCallback();
+                        }, sendReason)) {
+                            // If any channel doesn't return true we should assume that the callback will never be called, so use a timeout
+                            // to allow the channel some time to "finish" before triggering any followup function (such as unloading)
+                            if (cbTimer == null) {
+                                cbTimer = setTimeout(() => {
+                                    cbTimer = null;
+                                    callBack && callBack(false);
+                                    // Make sure we don't call the callback more than once
+                                    callBack = null;
+                                }, cbTimeout);
+                            }
+                        }
                     }
                 });
-            
-                _addChannelQueue(extensionQueue);
-            }
+            }, () => {
+                waiting--;
+                doneIterating = true;
+                doCallback();
+            });
         }
-    }
+    };
 
-    public processTelemetry(item: ITelemetryItem, itemCtx: IProcessTelemetryContext) {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-    }
+    return channelController;
+}
+
+export function createChannelQueues(channels: IChannelControls[][], extensions: IPlugin[], config: IConfiguration, core: IAppInsightsCore) {
+    let channelQueue: _IInternalChannels[] = [];
 
-    public getChannelControls(): IChannelControls[][] {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-        return null;
+    if (channels) {
+        // Add and sort the configuration channel queues
+        arrForEach(channels, queue => _addChannelQueue(channelQueue, queue, config, core));
     }
 
-    public initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[]) {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+    if (extensions) {
+        // Create a new channel queue for any extensions with a priority > the ChannelControllerPriority
+        let extensionQueue: IChannelControls[] = [];
+        arrForEach(extensions as IChannelControls[], plugin => {
+            if (plugin.priority > ChannelControllerPriority) {
+                extensionQueue.push(plugin);
+            }
+        });
+    
+        _addChannelQueue(channelQueue, extensionQueue, config, core);
     }
 
-    /**
-     * Static constructor, attempt to create accessors
-     */
-    // tslint:disable-next-line
-    private static _staticInit = (() => {
-        let proto = ChannelController.prototype;
-        // Dynamically create get/set property accessors
-        objDefineAccessors(proto, "ChannelControls", proto.getChannelControls);
-        objDefineAccessors(proto, "channelQueue", proto.getChannelControls);
-    })();
+    return channelQueue;
 }

package/src/JavaScriptSDK/CoreUtils.ts

@@ -12,7 +12,7 @@ import {
     isArray, isBoolean, isDate, isError, isFunction, isNullOrUndefined, isNumber, isObject, isString, isTypeof,
     isUndefined, objDefineAccessors, objKeys, strTrim, toISOString
 } from "./HelperFuncs";
-import { randomValue, random32, mwcRandomSeed, mwcRandom32 } from "./RandomHelper";
+import { randomValue, random32, mwcRandomSeed, mwcRandom32, newId } from "./RandomHelper";
 
 const strVisibilityChangeEvt: string = "visibilitychange";
 const strPageHide: string = "pagehide";
@@ -182,33 +182,6 @@ export function perfNow(): number {
     return dateNow();
 }
 
-/**
- * Generate random base64 id string.
- * The default length is 22 which is 132-bits so almost the same as a GUID but as base64 (the previous default was 5)
- * @param maxLength - Optional value to specify the length of the id to be generated, defaults to 22
- */
-export function newId(maxLength = 22): string {
-    const base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-    // Start with an initial random number, consuming the value in reverse byte order
-    let number = random32() >>> 0;  // Make sure it's a +ve number
-    let chars = 0;
-    let result = "";
-    while (result.length < maxLength) {
-        chars ++;
-        result += base64chars.charAt(number & 0x3F);
-        number >>>= 6;              // Zero fill with right shift
-        if (chars === 5) {
-            // 5 base64 characters === 30 bits so we don't have enough bits for another base64 char
-            // So add on another 30 bits and make sure it's +ve
-            number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
-            chars = 0;      // We need to reset the number every 5 chars (30 bits)
-        }
-    }
-
-    return result;
-}
-
 /**
  * The strEndsWith() method determines whether a string ends with the characters of a specified string, returning true or false as appropriate.
  * @param value - The value to check whether it ends with the search value.

package/src/JavaScriptSDK/EnvUtils.ts

@@ -31,6 +31,7 @@ const strMsCrypto = "msCrypto";
 const strReactNative = "ReactNative";
 const strMsie = "msie";
 const strTrident = "trident/";
+const strXMLHttpRequest = "XMLHttpRequest";
 
 let _isTrident: boolean = null;
 let _navUserAgentCheck: string = null;
@@ -371,8 +372,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 +386,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 +402,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