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

package/src/JavaScriptSDK/TelemetryInitializerPlugin.ts

@@ -0,0 +1,119 @@
+// // Copyright (c) Microsoft Corporation. All rights reserved.
+// // Licensed under the MIT License.
+
+import dynamicProto from "@microsoft/dynamicproto-js";
+import { LoggingSeverity, _InternalMessageId } from "../JavaScriptSDK.Enums/LoggingEnums";
+import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { ITelemetryInitializerContainer, ITelemetryInitializerHandler, TelemetryInitializerFunction } from "../JavaScriptSDK.Interfaces/ITelemetryInitializers";
+import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
+import { BaseTelemetryPlugin } from "./BaseTelemetryPlugin";
+import { dumpObj } from "./EnvUtils";
+import { arrForEach, getExceptionName } from "./HelperFuncs";
+
+interface _IInternalTelemetryInitializerHandler {
+    id: number;
+    fn: TelemetryInitializerFunction;
+}
+
+export class TelemetryInitializerPlugin extends BaseTelemetryPlugin implements ITelemetryInitializerContainer {
+
+    public identifier: string = "TelemetryInitializerPlugin";
+    priority: number = 199;
+
+    constructor() {
+        super();
+
+        // NOTE!: DON'T set default values here, instead set them in the _initDefaults() function as it is also called during teardown()
+        let _id: number;
+        let _initializers: _IInternalTelemetryInitializerHandler[];
+
+        _initDefaults();
+
+        dynamicProto(TelemetryInitializerPlugin, this, (_self, _base) => {
+
+            _self.addTelemetryInitializer = (telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler => {
+                let theInitializer = {
+                    id: _id++,
+                    fn: telemetryInitializer
+                };
+
+                _initializers.push(theInitializer);
+
+                let handler: ITelemetryInitializerHandler = {
+                    remove: () => {
+                        arrForEach(_initializers, (initializer, idx) => {
+                            if (initializer.id === theInitializer.id) {
+                                _initializers.splice(idx, 1);
+                                return -1;
+                            }
+                        });
+                    }
+                }
+    
+                return handler;
+            }
+
+            _self.processTelemetry = (item: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void => {
+                var doNotSendItem = false;
+                var telemetryInitializersCount = _initializers.length;
+                for (var i = 0; i < telemetryInitializersCount; ++i) {
+                    var telemetryInitializer = _initializers[i];
+                    if (telemetryInitializer) {
+                        try {
+                            if (telemetryInitializer.fn.apply(null, [item]) === false) {
+                                doNotSendItem = true;
+                                break;
+                            }
+                        } catch (e) {
+                            // log error but dont stop executing rest of the telemetry initializers
+                            // doNotSendItem = true;
+                            itemCtx.diagLog().throwInternal(
+                                LoggingSeverity.CRITICAL,
+                                _InternalMessageId.TelemetryInitializerFailed,
+                                "One of telemetry initializers failed, telemetry item will not be sent: " + getExceptionName(e),
+                                { exception: dumpObj(e) }, true);
+                        }
+                    }
+                }
+
+                if (!doNotSendItem) {
+                    _self.processNext(item, itemCtx);
+                }
+            };
+
+            _self.unload = (itemCtx: IProcessTelemetryContext, isAsync: boolean): void => {
+                _base.unload(itemCtx, isAsync);
+                _initDefaults();
+            };
+        });
+
+        function _initDefaults() {
+            _id = 0;
+            _initializers = [];
+        }
+    }
+
+    /**
+     * Add a telemetry processor to decorate or drop telemetry events.
+     * @param telemetryInitializer - The Telemetry Initializer function
+     * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
+     */
+    public addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+        return null;
+    }
+
+    public processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+    }
+
+    /**
+     * This plugin is being unloaded and should remove any hooked events and cleanup any global/scoped values, after this
+     * call the plugin will be removed from the telemetry processing chain and will no longer receive any events..
+     * @param itemCtx - This is the context that should be used during unloading if required to flush any cached events.
+     * @param isAsync - Should the plugin attempt to unload synchronously or can it complete asynchronously
+     */
+     public unload(itemCtx: IProcessTelemetryContext, isAsync: boolean): void {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+    }
+}

package/src/JavaScriptSDK.Interfaces/IAppInsightsCore.ts

@@ -10,8 +10,11 @@ import { IDiagnosticLogger } from "./IDiagnosticLogger";
 import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
 import { IPerfManagerProvider } from "./IPerfManager";
 import { ICookieMgr } from "./ICookieMgr";
+import { ITelemetryInitializerHandler, TelemetryInitializerFunction } from "./ITelemetryInitializers";
 
-"use strict";
+export interface ILoadedPlugin<T extends IPlugin> {
+    plugin: T;
+}
 
 export interface IAppInsightsCore extends IPerfManagerProvider {
 
@@ -72,6 +75,13 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
      */
     removeNotificationListener?(listener: INotificationListener): void;
 
+    /**
+     * Add a telemetry processor to decorate or drop telemetry events.
+     * @param telemetryInitializer - The Telemetry Initializer function
+     * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
+     */
+    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
+
     pollInternalLogs?(eventName?: string): number;
 
     stopPollingInternalLogs?(): void;
@@ -80,4 +90,10 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
      * Return a new instance of the IProcessTelemetryContext for processing events
      */
     getProcessTelContext() : IProcessTelemetryContext;
+
+    /**
+     * Find and return the (first) plugin with the specified identifier if present
+     * @param pluginIdentifier
+     */
+    getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
 }

package/src/JavaScriptSDK.Interfaces/IChannelControls.ts

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
+import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
 import { ITelemetryPlugin } from "./ITelemetryPlugin";
 
 "use strict";
@@ -26,10 +27,13 @@ export interface IChannelControls extends ITelemetryPlugin {
 
     /**
      * Flush to send data immediately; channel should default to sending data asynchronously
-     * @param async: send data asynchronously when true
-     * @param callBack: if specified, notify caller when send is complete
+     * @param async - send data asynchronously when true
+     * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.
+     * If the caller doesn't return true the caller should assume that it may never be called.
+     * @param sendReason - specify the reason that you are calling "flush" defaults to ManualFlush (1) if not specified
+     * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called
      */
-    flush(async: boolean, callBack?: () => void): void;
+    flush(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
 }
 
 export const MinChannelPriorty: number = 100;

package/src/JavaScriptSDK.Interfaces/IInstrumentHooks.ts

@@ -85,4 +85,9 @@ export interface IInstrumentCallDetails {
      * The error (exception) which occurred while executing the original method
      */
     err?: Error;
+
+    /**
+     * The Event object from (window.event) at the start of the original call
+     */
+    evt?: Event;
 }

package/src/JavaScriptSDK.Interfaces/IProcessTelemetryContext.ts

@@ -6,9 +6,15 @@ import { IAppInsightsCore } from "./IAppInsightsCore";
 import { IDiagnosticLogger } from "./IDiagnosticLogger";
 import { IConfiguration } from "./IConfiguration";
 import { ITelemetryItem } from "./ITelemetryItem";
-import { IPlugin } from "./ITelemetryPlugin";
+import { IPlugin, ITelemetryPlugin } from "./ITelemetryPlugin";
 import { ITelemetryPluginChain } from "./ITelemetryPluginChain";
 
+export const enum GetExtCfgMergeType {
+    None = 0,
+    MergeDefaultOnly = 1,
+    MergeDefaultFromRootOrDefault = 2,
+}
+
 /**
  * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
  * between multiple AppInsights instances
@@ -27,12 +33,12 @@ export interface IProcessTelemetryContext {
     /**
      * Gets the current core config instance
      */
-    getCfg: ()=> IConfiguration;
+    getCfg: () => IConfiguration;
 
     /**
      * Gets the named extension config
      */
-    getExtCfg: <T>(identifier: string, defaultValue?:T|any) => T;
+    getExtCfg: <T>(identifier: string, defaultValue?: T | any, mergeDefault?: GetExtCfgMergeType) => T;
 
     /**
      * Gets the named config from either the named identifier extension or core config if neither exist then the
@@ -41,7 +47,7 @@ export interface IProcessTelemetryContext {
      * @param field The config field name
      * @param defaultValue The default value to return if no defined config exists
      */
-    getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean) => number | string | boolean;
+    getConfig: (identifier: string, field: string, defaultValue?: number | string | boolean | string[] | RegExp[] | Function) => number | string | boolean | string[] | RegExp[] | Function;
 
     /**
      * Helper to allow plugins to check and possibly shortcut executing code only
@@ -57,7 +63,7 @@ export interface IProcessTelemetryContext {
     /**
      * Helper to set the next plugin proxy
      */
-    setNext: (nextCtx:ITelemetryPluginChain) => void;
+    setNext: (nextCtx: ITelemetryPluginChain) => void;
 
     /**
      * Call back for telemetry processing before it it is sent
@@ -65,6 +71,13 @@ export interface IProcessTelemetryContext {
      */
     processNext: (env: ITelemetryItem) => void;
 
+    /**
+     * Synchronously iterate over the context chain running the callback for each plugin, once
+     * every plugin has been executed via the callback, any associated onComplete will be called.
+     * @param callback - The function call for each plugin in the context chain
+     */
+    iterate: <T extends ITelemetryPlugin = ITelemetryPlugin>(callback: (plugin: T) => void) => void;
+
     /**
      * Create a new context using the core and config from the current instance
      * @param plugins - The execution order to process the plugins, if null or not supplied
@@ -73,4 +86,9 @@ export interface IProcessTelemetryContext {
      *                  order then the next plugin will be NOT set.
      */
     createNew: (plugins?:IPlugin[]|ITelemetryPluginChain, startAt?:IPlugin) => IProcessTelemetryContext;
+
+    /**
+     * Set the function to call when the current chain has executed all processNext or unloadNext items.
+     */
+    onComplete: (onComplete: () => void) => void;
 }

package/src/JavaScriptSDK.Interfaces/ITelemetryInitializers.ts

@@ -0,0 +1,16 @@
+import { ITelemetryItem } from "./ITelemetryItem";
+
+export declare type TelemetryInitializerFunction = <T extends ITelemetryItem>(item: T) => boolean | void;
+
+export interface ITelemetryInitializerHandler {
+    remove(): void;
+}
+
+export interface ITelemetryInitializerContainer {
+    /**
+     * Add a telemetry processor to decorate or drop telemetry events.
+     * @param telemetryInitializer - The Telemetry Initializer function
+     * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
+     */
+    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
+}

package/src/JavaScriptSDK.Interfaces/ITelemetryPlugin.ts

@@ -43,7 +43,7 @@ export interface IPlugin {
      * @param pluginChain - [Optional] specifies the current plugin chain which identifies the
      * set of plugins and the order they should be executed for the current request.
      */
-    initialize: (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?:ITelemetryPluginChain) => void;
+    initialize: (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain) => void;
     
     /**
      * Returns a value that indicates whether the plugin has already been previously initialized.

package/types/JavaScriptSDK/AppInsightsCore.d.ts

@@ -3,31 +3,10 @@ import { BaseCore } from "./BaseCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotificationListener";
 import { INotificationManager } from "../JavaScriptSDK.Interfaces/INotificationManager";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 export declare class AppInsightsCore extends BaseCore implements IAppInsightsCore {
     constructor();
     initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
     track(telemetryItem: ITelemetryItem): void;
-    /**
-     * Adds a notification listener. The SDK calls methods on the listener when an appropriate notification is raised.
-     * The added plugins must raise notifications. If the plugins do not implement the notifications, then no methods will be
-     * called.
-     * @param {INotificationListener} listener - An INotificationListener object.
-     */
-    addNotificationListener(listener: INotificationListener): void;
-    /**
-     * Removes all instances of the listener.
-     * @param {INotificationListener} listener - INotificationListener to remove.
-     */
-    removeNotificationListener(listener: INotificationListener): void;
-    /**
-     * Periodically check logger.queue for
-     */
-    pollInternalLogs(eventName?: string): number;
-    /**
-     * Periodically check logger.queue for
-     */
-    stopPollingInternalLogs(): void;
 }

package/types/JavaScriptSDK/BaseCore.d.ts

@@ -1,13 +1,15 @@
-import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
+import { IAppInsightsCore, ILoadedPlugin } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { IChannelControls } from "../JavaScriptSDK.Interfaces/IChannelControls";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
 import { INotificationManager } from "../JavaScriptSDK.Interfaces/INotificationManager";
+import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotificationListener";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { IPerfManager } from "../JavaScriptSDK.Interfaces/IPerfManager";
 import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
+import { ITelemetryInitializerHandler, TelemetryInitializerFunction } from "../JavaScriptSDK.Interfaces/ITelemetryInitializers";
 export declare class BaseCore implements IAppInsightsCore {
     static defaultConfig: IConfiguration;
     config: IConfiguration;
@@ -20,6 +22,18 @@ export declare class BaseCore implements IAppInsightsCore {
     track(telemetryItem: ITelemetryItem): void;
     getProcessTelContext(): IProcessTelemetryContext;
     getNotifyMgr(): INotificationManager;
+    /**
+     * Adds a notification listener. The SDK calls methods on the listener when an appropriate notification is raised.
+     * The added plugins must raise notifications. If the plugins do not implement the notifications, then no methods will be
+     * called.
+     * @param {INotificationListener} listener - An INotificationListener object.
+     */
+    addNotificationListener(listener: INotificationListener): void;
+    /**
+     * Removes all instances of the listener.
+     * @param {INotificationListener} listener - INotificationListener to remove.
+     */
+    removeNotificationListener(listener: INotificationListener): void;
     /**
      * Get the current cookie manager for this instance
      */
@@ -32,5 +46,20 @@ export declare class BaseCore implements IAppInsightsCore {
     getPerfMgr(): IPerfManager;
     setPerfMgr(perfMgr: IPerfManager): void;
     eventCnt(): number;
+    /**
+     * Periodically check logger.queue for
+     */
+    pollInternalLogs(eventName?: string): number;
+    /**
+     * Periodically check logger.queue for
+     */
+    stopPollingInternalLogs(): void;
+    /**
+     * Add a telemetry processor to decorate or drop telemetry events.
+     * @param telemetryInitializer - The Telemetry Initializer function
+     * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
+     */
+    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
+    getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
     protected releaseQueue(): void;
 }

package/types/JavaScriptSDK/BaseTelemetryPlugin.d.ts

@@ -5,12 +5,20 @@ 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 { IInstrumentHook } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
 /**
  * BaseTelemetryPlugin provides a basic implementation of the ITelemetryPlugin interface so that plugins
  * can avoid implementation the same set of boiler plate code as well as provide a base
  * implementation so that new default implementations can be added without breaking all plugins.
  */
 export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
+    identifier: string;
+    version?: string;
+    /**
+     * Holds the core instance that was used during initialization
+     */
+    core: IAppInsightsCore;
+    priority: number;
     /**
      * Call back for telemetry processing before it it is sent
      * @param env - This is the current event being reported
@@ -32,13 +40,6 @@ export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      * Returns whether the plugin has been initialized
      */
     isInitialized: () => boolean;
-    identifier: string;
-    version?: string;
-    /**
-     * Holds the core instance that was used during initialization
-     */
-    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
@@ -50,11 +51,12 @@ export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      * Internal helper to allow setting of the internal initialized setting for inherited instances and unit testing
      */
     protected setInitialized: (isInitialized: boolean) => void;
-    /**
-     * Internal helper to initialize the instance
-     */
-    private _baseTelInit;
     constructor();
     initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain): void;
     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;
 }

package/types/JavaScriptSDK/ChannelController.d.ts

@@ -1,21 +1,16 @@
+import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IChannelControls } from "../JavaScriptSDK.Interfaces/IChannelControls";
-import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
+import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
+import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
-import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
-import { BaseTelemetryPlugin } from "./BaseTelemetryPlugin";
-export declare class ChannelController extends BaseTelemetryPlugin {
-    identifier: string;
-    priority: number;
-    setNextPlugin: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
-    constructor();
-    processTelemetry(item: ITelemetryItem, itemCtx: IProcessTelemetryContext): void;
-    getChannelControls(): IChannelControls[][];
-    initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[]): void;
-    /**
-     * Static constructor, attempt to create accessors
-     */
-    private static _staticInit;
+export declare const ChannelControllerPriority = 500;
+export interface IChannelController extends IChannelControls {
+    flush(isAsync: boolean, callBack: (flushComplete?: boolean) => void, sendReason: SendRequestReason, cbTimeout?: number): void;
+}
+export interface _IInternalChannels {
+    queue: IChannelControls[];
+    chain: ITelemetryPluginChain;
 }
+export declare function createChannelControllerPlugin(channelQueue: _IInternalChannels[], core: IAppInsightsCore): IChannelController;
+export declare function createChannelQueues(channels: IChannelControls[][], extensions: IPlugin[], config: IConfiguration, core: IAppInsightsCore): _IInternalChannels[];

package/types/JavaScriptSDK/CoreUtils.d.ts

@@ -49,12 +49,6 @@ export declare function newGuid(): string;
  * https://caniuse.com/#search=performance.now
  */
 export declare function perfNow(): number;
-/**
- * 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 declare function newId(maxLength?: number): string;
 /**
  * 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/types/JavaScriptSDK/HelperFuncs.d.ts

@@ -43,7 +43,7 @@ export declare function normalizeJsName(name: string): string;
  * @param target The target object to find and process the keys
  * @param callbackfn The function to call with the details
  */
-export declare function objForEachKey(target: any, callbackfn: (name: string, value: any) => void): void;
+export declare function objForEachKey<T = any>(target: T, callbackfn: (name: string, value: T[keyof T]) => void): void;
 /**
  * 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.
@@ -83,7 +83,8 @@ export declare function strContains(value: string, search: string): boolean;
  */
 export declare function isDate(obj: any): obj is Date;
 /**
- * Check if an object is of type Array
+ * Check if an object is of type Array with optional generic T, the generic type is not validated
+ * and exists to help with TypeScript validation only.
  */
 export declare let isArray: <T = any>(obj: any) => obj is Array<T>;
 /**
@@ -136,7 +137,7 @@ export declare function _toISOStringPoly(date: Date): string;
  * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. It can return -1 to break out of the loop
  * @param thisArg  [Optional] An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
  */
-export declare function arrForEach<T>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => void | number, thisArg?: any): void;
+export declare function arrForEach<T = any>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => void | number, thisArg?: any): void;
 /**
  * Returns the index of the first occurrence of a value in an array. This helper exists to avoid adding a polyfil for older browsers
  * that do not define Array.prototype.xxxx (eg. ES3 only, IE8) just in case any page checks for presence/absence of the prototype
@@ -232,9 +233,17 @@ export declare function throwError(message: string): never;
  * @param target - The target object to be assigned with the source properties and functions
  * @param source - The source object which will be assigned / called by setting / calling the targets proxies
  * @param chkSet - An optional callback to determine whether a specific property/function should be proxied
- * @memberof Initialization
  */
-export declare function proxyAssign(target: any, source: any, chkSet?: (name: string, isFunc?: boolean, source?: any, target?: any) => boolean): any;
+export declare function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string, isFunc?: boolean, source?: S, target?: T) => boolean): T;
+export declare function proxyFunctionAs<T, S>(target: T, name: string, source: S | (() => S), theFunc: (keyof S), overwriteTarget?: boolean): void;
+/**
+ * Creates proxy functions on the target which internally will call the source version with all arguments passed to the target method.
+ *
+ * @param target - The target object to be assigned with the source properties and functions
+ * @param source - The source object which will be assigned / called by setting / calling the targets proxies
+ * @param functionsToProxy - An array of function names that will be proxied on the target
+ */
+export declare function proxyFunctions<T, S>(target: T, source: S | (() => S), functionsToProxy: (keyof S)[], overwriteTarget?: boolean): T;
 /**
  * Simpler helper to create a dynamic class that implements the interface and populates the values with the defaults.
  * Only instance properties (hasOwnProperty) values are copied from the defaults to the new instance

package/types/JavaScriptSDK/ProcessTelemetryContext.d.ts

@@ -1,10 +1,41 @@
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
-import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
+import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
+import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
+/**
+ * Creates a new Telemetry Item context with the current config, core and plugin execution chain
+ * @param plugins - The plugin instances that will be executed
+ * @param config - The current config
+ * @param core - The current core instance
+ */
+export declare function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext;
+/**
+ * Creates an execution chain from the array of plugins
+ * @param plugins - The array of plugins that will be executed in this order
+ * @param defItemCtx - The default execution context to use when no telemetry context is passed to processTelemetry(), this
+ * should be for legacy plugins only. Currently, only used for passing the current core instance and to provide better error
+ * reporting (hasRun) when errors occur.
+ */
+export declare function createTelemetryProxyChain(plugins: IPlugin[], config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): ITelemetryPluginChain;
+/**
+ * Create the processing telemetry proxy instance, the proxy is used to abstract the current plugin to allow monitoring and
+ * execution plugins while passing around the dynamic execution state (IProcessTelemetryContext), the proxy instance no longer
+ * contains any execution state and can be reused between requests (this was not the case for 2.7.2 and earlier with the
+ * TelemetryPluginChain class).
+ * @param plugin - The plugin instance to proxy
+ * @param config - The default execution context to use when no telemetry context is passed to processTelemetry(), this
+ * should be for legacy plugins only. Currently, only used for passing the current core instance and to provide better error
+ * reporting (hasRun) when errors occur.
+ * @returns
+ */
+export declare function createTelemetryPluginProxy(plugin: ITelemetryPlugin, config: IConfiguration, core: IAppInsightsCore): ITelemetryPluginChain;
+/**
+ * This class will be removed!
+ * @deprecated use createProcessTelemetryContext() instead
+ */
 export declare class ProcessTelemetryContext implements IProcessTelemetryContext {
     /**
      * Gets the current core config instance
@@ -41,15 +72,30 @@ export declare class ProcessTelemetryContext implements IProcessTelemetryContext
      * to later plugins (vs appending items to the telemetry item)
      */
     processNext: (env: ITelemetryItem) => void;
+    /**
+     * Synchronously iterate over the context chain running the callback for each plugin, once
+     * every plugin has been executed via the callback, any associated onComplete will be called.
+     * @param callback - The function call for each plugin in the context chain
+     */
+    iterate: <T extends ITelemetryPlugin = ITelemetryPlugin>(callback: (plugin: T) => void) => void;
+    /**
     /**
      * Create a new context using the core and config from the current instance
+     * @param plugins - The execution order to process the plugins, if null or not supplied
+     *                  then the current execution order will be copied.
+     * @param startAt - The plugin to start processing from, if missing from the execution
+     *                  order then the next plugin will be NOT set.
      */
     createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryContext;
+    /**
+     * Set the function to call when the current chain has executed all processNext or unloadNext items.
+     */
+    onComplete: (onComplete: () => void) => void;
     /**
      * Creates a new Telemetry Item context with the current config, core and plugin execution chain
      * @param plugins - The plugin instances that will be executed
      * @param config - The current config
      * @param core - The current core instance
      */
-    constructor(plugins: IPlugin[] | ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin);
+    constructor(pluginChain: ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin);
 }

package/types/JavaScriptSDK/RandomHelper.d.ts

@@ -21,3 +21,9 @@ export declare function mwcRandomSeed(value?: number): void;
  * @param signed - True to return a signed 32-bit number (-0x80000000..0x7FFFFFFF) otherwise an unsigned one (0x000000..0xFFFFFFFF)
  */
 export declare function mwcRandom32(signed?: boolean): number;
+/**
+ * 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 declare function newId(maxLength?: number): string;

package/types/JavaScriptSDK/TelemetryHelpers.d.ts

@@ -1,5 +1,5 @@
 import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
-import { ProcessTelemetryContext } from "./ProcessTelemetryContext";
+import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 /**
  * Initialize the queue of plugins
  * @param plugins - The array of plugins to initialize and setting of the next plugin
@@ -7,5 +7,5 @@ import { ProcessTelemetryContext } from "./ProcessTelemetryContext";
  * @param core THe current core instance
  * @param extensions The extensions
  */
-export declare function initializePlugins(processContext: ProcessTelemetryContext, extensions: IPlugin[]): void;
-export declare function sortPlugins(plugins: IPlugin[]): IPlugin[];
+export declare function initializePlugins(processContext: IProcessTelemetryContext, extensions: IPlugin[]): void;
+export declare function sortPlugins<T = IPlugin>(plugins: T[]): T[];