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

package/types/JavaScriptSDK/ProcessTelemetryContext.d.ts

@@ -2,7 +2,7 @@ import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
 import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
-import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { IProcessTelemetryContext, IProcessTelemetryUnloadContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 /**
@@ -10,8 +10,17 @@ import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger
  * @param plugins - The plugin instances that will be executed
  * @param config - The current config
  * @param core - The current core instance
+ * @param startAt - Identifies the next plugin to execute, if null there is no "next" plugin and if undefined it should assume the start of the chain
  */
 export declare function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext;
+/**
+ * Creates a new Telemetry Item context with the current config, core and plugin execution chain for handling the unloading of the chain
+ * @param plugins - The plugin instances that will be executed
+ * @param config - The current config
+ * @param core - The current core instance
+ * @param startAt - Identifies the next plugin to execute, if null there is no "next" plugin and if undefined it should assume the start of the chain
+ */
+export declare function createProcessTelemetryUnloadContext(telemetryChain: ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryUnloadContext;
 /**
  * Creates an execution chain from the array of plugins
  * @param plugins - The array of plugins that will be executed in this order
@@ -70,15 +79,15 @@ export declare class ProcessTelemetryContext implements IProcessTelemetryContext
      * @param itemCtx - This is the context for the current request, ITelemetryPlugin instances
      * can optionally use this to access the current core instance or define / pass additional information
      * to later plugins (vs appending items to the telemetry item)
+     * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
      */
-    processNext: (env: ITelemetryItem) => void;
+    processNext: (env: ITelemetryItem) => boolean | 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

package/types/JavaScriptSDK/TelemetryHelpers.d.ts

@@ -1,5 +1,13 @@
 import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
+export interface IPluginState {
+    core?: IAppInsightsCore;
+    isInitialized?: boolean;
+    tearDown?: boolean;
+    disabled?: boolean;
+}
+export declare function _getPluginState(plugin: IPlugin): IPluginState;
 /**
  * Initialize the queue of plugins
  * @param plugins - The array of plugins to initialize and setting of the next plugin

package/types/JavaScriptSDK/TelemetryInitializerPlugin.d.ts

@@ -13,11 +13,4 @@ export declare class TelemetryInitializerPlugin extends BaseTelemetryPlugin impl
      */
     addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler;
     processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
-    /**
-     * 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
-     */
-    unload(itemCtx: IProcessTelemetryContext, isAsync: boolean): void;
 }

package/types/JavaScriptSDK/UnloadHandlerContainer.d.ts

@@ -0,0 +1,11 @@
+import { IProcessTelemetryUnloadContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
+export declare type UnloadHandler = (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+export interface IUnloadHandlerContainer {
+    add: (handler: UnloadHandler) => void;
+    run: (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+}
+export declare function createUnloadHandlerContainer(): {
+    add: (handler: UnloadHandler) => void;
+    run: (unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
+};

package/types/JavaScriptSDK.Enums/LoggingEnums.d.ts

@@ -1,4 +1,4 @@
-export declare enum LoggingSeverity {
+export declare const enum eLoggingSeverity {
     /**
      * Error will be sent as internal telemetry
      */
@@ -8,6 +8,95 @@ export declare enum LoggingSeverity {
      */
     WARNING = 2
 }
+export declare const LoggingSeverity: {
+    CRITICAL: number;
+    WARNING: number;
+};
+export declare type LoggingSeverity = number | eLoggingSeverity;
+export declare const enum _eInternalMessageId {
+    BrowserDoesNotSupportLocalStorage = 0,
+    BrowserCannotReadLocalStorage = 1,
+    BrowserCannotReadSessionStorage = 2,
+    BrowserCannotWriteLocalStorage = 3,
+    BrowserCannotWriteSessionStorage = 4,
+    BrowserFailedRemovalFromLocalStorage = 5,
+    BrowserFailedRemovalFromSessionStorage = 6,
+    CannotSendEmptyTelemetry = 7,
+    ClientPerformanceMathError = 8,
+    ErrorParsingAISessionCookie = 9,
+    ErrorPVCalc = 10,
+    ExceptionWhileLoggingError = 11,
+    FailedAddingTelemetryToBuffer = 12,
+    FailedMonitorAjaxAbort = 13,
+    FailedMonitorAjaxDur = 14,
+    FailedMonitorAjaxOpen = 15,
+    FailedMonitorAjaxRSC = 16,
+    FailedMonitorAjaxSend = 17,
+    FailedMonitorAjaxGetCorrelationHeader = 18,
+    FailedToAddHandlerForOnBeforeUnload = 19,
+    FailedToSendQueuedTelemetry = 20,
+    FailedToReportDataLoss = 21,
+    FlushFailed = 22,
+    MessageLimitPerPVExceeded = 23,
+    MissingRequiredFieldSpecification = 24,
+    NavigationTimingNotSupported = 25,
+    OnError = 26,
+    SessionRenewalDateIsZero = 27,
+    SenderNotInitialized = 28,
+    StartTrackEventFailed = 29,
+    StopTrackEventFailed = 30,
+    StartTrackFailed = 31,
+    StopTrackFailed = 32,
+    TelemetrySampledAndNotSent = 33,
+    TrackEventFailed = 34,
+    TrackExceptionFailed = 35,
+    TrackMetricFailed = 36,
+    TrackPVFailed = 37,
+    TrackPVFailedCalc = 38,
+    TrackTraceFailed = 39,
+    TransmissionFailed = 40,
+    FailedToSetStorageBuffer = 41,
+    FailedToRestoreStorageBuffer = 42,
+    InvalidBackendResponse = 43,
+    FailedToFixDepricatedValues = 44,
+    InvalidDurationValue = 45,
+    TelemetryEnvelopeInvalid = 46,
+    CreateEnvelopeError = 47,
+    CannotSerializeObject = 48,
+    CannotSerializeObjectNonSerializable = 49,
+    CircularReferenceDetected = 50,
+    ClearAuthContextFailed = 51,
+    ExceptionTruncated = 52,
+    IllegalCharsInName = 53,
+    ItemNotInArray = 54,
+    MaxAjaxPerPVExceeded = 55,
+    MessageTruncated = 56,
+    NameTooLong = 57,
+    SampleRateOutOfRange = 58,
+    SetAuthContextFailed = 59,
+    SetAuthContextFailedAccountName = 60,
+    StringValueTooLong = 61,
+    StartCalledMoreThanOnce = 62,
+    StopCalledWithoutStart = 63,
+    TelemetryInitializerFailed = 64,
+    TrackArgumentsNotSpecified = 65,
+    UrlTooLong = 66,
+    SessionStorageBufferFull = 67,
+    CannotAccessCookie = 68,
+    IdTooLong = 69,
+    InvalidEvent = 70,
+    FailedMonitorAjaxSetRequestHeader = 71,
+    SendBrowserInfoOnUserInit = 72,
+    PluginException = 73,
+    NotificationException = 74,
+    SnippetScriptLoadFailure = 99,
+    InvalidInstrumentationKey = 100,
+    CannotParseAiBlobValue = 101,
+    InvalidContentBlob = 102,
+    TrackPageActionEventFailed = 103,
+    FailedAddingCustomDefinedRequestContext = 104,
+    InMemoryStorageBufferFull = 105
+}
 /**
  * Internal message ID. Please create a new one for every conceptually different message. Please keep alphabetically ordered
  */
@@ -95,4 +184,4 @@ export declare const _InternalMessageId: {
     FailedAddingCustomDefinedRequestContext: number;
     InMemoryStorageBufferFull: number;
 };
-export declare type _InternalMessageId = number | typeof _InternalMessageId;
+export declare type _InternalMessageId = number | _eInternalMessageId;

package/types/JavaScriptSDK.Enums/SendRequestReason.d.ts

@@ -30,6 +30,10 @@ export declare const enum SendRequestReason {
      * The event(s) being sent as a retry
      */
     Retry = 5,
+    /**
+     * The SDK is unloading
+     */
+    SdkUnload = 6,
     /**
      * Maximum batch size would be exceeded
      */

package/types/JavaScriptSDK.Enums/TelemetryUnloadReason.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The TelemetryUnloadReason enumeration contains the possible reasons for why a plugin is being unloaded / torndown().
+ */
+export declare const enum TelemetryUnloadReason {
+    /**
+     * Teardown has been called without any context.
+     */
+    ManualTeardown = 0,
+    /**
+     * Just this plugin is being removed
+     */
+    PluginUnload = 1,
+    /**
+     * This instance of the plugin is being removed and replaced
+     */
+    PluginReplace = 2,
+    /**
+     * The entire SDK is being unloaded
+     */
+    SdkUnload = 50
+}

package/types/JavaScriptSDK.Interfaces/IAppInsightsCore.d.ts

@@ -1,6 +1,6 @@
 import { ITelemetryItem } from "./ITelemetryItem";
 import { IChannelControls } from "./IChannelControls";
-import { IPlugin } from "./ITelemetryPlugin";
+import { IPlugin, ITelemetryPlugin } from "./ITelemetryPlugin";
 import { IConfiguration } from "./IConfiguration";
 import { INotificationManager } from "./INotificationManager";
 import { INotificationListener } from "./INotificationListener";
@@ -9,8 +9,23 @@ import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
 import { IPerfManagerProvider } from "./IPerfManager";
 import { ICookieMgr } from "./ICookieMgr";
 import { ITelemetryInitializerHandler, TelemetryInitializerFunction } from "./ITelemetryInitializers";
+import { UnloadHandler } from "../applicationinsights-core-js";
 export interface ILoadedPlugin<T extends IPlugin> {
     plugin: T;
+    /**
+     * Identifies whether the plugin is enabled and can process events. This is slightly different from isInitialized as the plugin may be initialized but disabled
+     * via the setEnabled() or it may be a shared plugin which has had it's teardown function called from another instance..
+     * @returns boolean = true if the plugin is in a state where it is operational.
+     */
+    isEnabled: () => boolean;
+    /**
+     * You can optionally enable / disable a plugin from processing events.
+     * Setting enabled to true will not necessarily cause the `isEnabled()` to also return true
+     * as the plugin must also have been successfully initialized and not had it's `teardown` method called
+     * (unless it's also been re-initialized)
+     */
+    setEnabled: (isEnabled: boolean) => void;
+    remove: (isAsync?: boolean, removeCb?: (removed?: boolean) => void) => void;
 }
 export interface IAppInsightsCore extends IPerfManagerProvider {
     config: IConfiguration;
@@ -59,9 +74,34 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
      * Return a new instance of the IProcessTelemetryContext for processing events
      */
     getProcessTelContext(): IProcessTelemetryContext;
+    /**
+     * Unload and Tear down the SDK and any initialized plugins, after calling this the SDK will be considered
+     * to be un-initialized and non-operational, re-initializing the SDK should only be attempted if the previous
+     * unload call return `true` stating that all plugins reported that they also unloaded, the recommended
+     * approach is to create a new instance and initialize that instance.
+     * This is due to possible unexpected side effects caused by plugins not supporting unload / teardown, unable
+     * to successfully remove any global references or they may just be completing the unload process asynchronously.
+     */
+    unload(isAsync?: boolean, unloadComplete?: () => void): void;
     /**
      * Find and return the (first) plugin with the specified identifier if present
      * @param pluginIdentifier
      */
     getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
+    /**
+     * Add a new plugin to the installation
+     * @param plugin - The new plugin to add
+     * @param replaceExisting - should any existing plugin be replaced
+     * @param doAsync - Should the add be performed asynchronously
+     */
+    addPlugin<T extends IPlugin = ITelemetryPlugin>(plugin: T, replaceExisting: boolean, doAsync: boolean, addCb?: (added?: boolean) => void): void;
+    /**
+     * Returns the unique event namespace that should be used when registering events
+     */
+    evtNamespace(): string;
+    /**
+     * Add a handler that will be called when the SDK is being unloaded
+     * @param handler - the handler
+     */
+    addUnloadCb(handler: UnloadHandler): void;
 }

package/types/JavaScriptSDK.Interfaces/IChannelControls.d.ts

@@ -1,5 +1,7 @@
 import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
+import { IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
 import { ITelemetryPlugin } from "./ITelemetryPlugin";
+import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
 /**
  * Provides data transmission capabilities
  */
@@ -13,9 +15,14 @@ export interface IChannelControls extends ITelemetryPlugin {
      */
     resume(): void;
     /**
-     * Tear down transmission pipeline
+     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
+     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
+     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
+     * @param unloadCtx - This is the context that should be used during unloading.
+     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
+     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
      */
-    teardown(): void;
+    teardown: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
     /**
      * Flush to send data immediately; channel should default to sending data asynchronously
      * @param async - send data asynchronously when true

package/types/JavaScriptSDK.Interfaces/IProcessTelemetryContext.d.ts

@@ -1,19 +1,16 @@
 import { IAppInsightsCore } from "./IAppInsightsCore";
-import { IDiagnosticLogger } from "./IDiagnosticLogger";
 import { IConfiguration } from "./IConfiguration";
+import { IDiagnosticLogger } from "./IDiagnosticLogger";
 import { ITelemetryItem } from "./ITelemetryItem";
 import { IPlugin, ITelemetryPlugin } from "./ITelemetryPlugin";
 import { ITelemetryPluginChain } from "./ITelemetryPluginChain";
+import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
 export declare 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
- */
-export interface IProcessTelemetryContext {
+export interface IBaseProcessingContext {
     /**
      * The current core instance for the request
      */
@@ -51,11 +48,6 @@ export interface IProcessTelemetryContext {
      * Helper to set the next plugin proxy
      */
     setNext: (nextCtx: ITelemetryPluginChain) => void;
-    /**
-     * Call back for telemetry processing before it it is sent
-     * @param env - This is the current event being reported
-     */
-    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.
@@ -63,15 +55,58 @@ export interface IProcessTelemetryContext {
      */
     iterate: <T extends ITelemetryPlugin = ITelemetryPlugin>(callback: (plugin: T) => void) => void;
     /**
-     * Create a new context using the core and config from the current instance
+     * Set the function to call when the current chain has executed all processNext or unloadNext items.
+     * @param onComplete - The onComplete to call
+     * @param that - The "this" value to use for the onComplete call, if not provided or undefined defaults to the current context
+     * @param args - Any additional arguments to pass to the onComplete function
+     */
+    onComplete: (onComplete: Function, that?: any, ...args: any[]) => void;
+    /**
+     * Create a new context using the core and config from the current instance, returns a new instance of the same type
+     * @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) => IBaseProcessingContext;
+}
+/**
+ * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
+ * between multiple AppInsights instances
+ */
+export interface IProcessTelemetryContext extends IBaseProcessingContext {
+    /**
+     * Call back for telemetry processing before it it is sent
+     * @param env - This is the current event being reported
+     * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
+     */
+    processNext: (env: ITelemetryItem) => boolean | void;
+    /**
+     * Create a new context using the core and config from the current instance, returns a new instance of the same type
      * @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;
+}
+/**
+ * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
+ * between multiple AppInsights instances
+ */
+export interface IProcessTelemetryUnloadContext extends IBaseProcessingContext {
     /**
-     * Set the function to call when the current chain has executed all processNext or unloadNext items.
+     * This Plugin has finished unloading, so unload the next one
+     * @param uploadState - The state of the unload process
+     * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
+     */
+    processNext: (unloadState: ITelemetryUnloadState) => boolean | void;
+    /**
+     * Create a new context using the core and config from the current instance, returns a new instance of the same type
+     * @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.
      */
-    onComplete: (onComplete: () => void) => void;
+    createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUnloadContext;
 }

package/types/JavaScriptSDK.Interfaces/ITelemetryPlugin.d.ts

@@ -1,12 +1,10 @@
 import { ITelemetryItem } from "./ITelemetryItem";
 import { IConfiguration } from "./IConfiguration";
 import { IAppInsightsCore } from "./IAppInsightsCore";
-import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
+import { IProcessTelemetryContext, IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
 import { ITelemetryPluginChain } from "./ITelemetryPluginChain";
-/**
- * Configuration provided to SDK core
- */
-export interface ITelemetryPlugin extends IPlugin {
+import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
+export interface ITelemetryProcessor {
     /**
      * Call back for telemetry processing before it it is sent
      * @param env - This is the current event being reported
@@ -15,6 +13,11 @@ export interface ITelemetryPlugin extends IPlugin {
      * to later plugins (vs appending items to the telemetry item)
      */
     processTelemetry: (env: ITelemetryItem, itemCtx?: IProcessTelemetryContext) => void;
+}
+/**
+ * Configuration provided to SDK core
+ */
+export interface ITelemetryPlugin extends ITelemetryProcessor, IPlugin {
     /**
      * Set next extension for telemetry processing, this is not optional as plugins should use the
      * processNext() function of the passed IProcessTelemetryContext instead. It is being kept for
@@ -42,10 +45,14 @@ export interface IPlugin {
      */
     isInitialized?: () => boolean;
     /**
-     * Tear down the plugin and remove any hooked value, the plugin should remove that it is no longer initialized and
-     * therefore can be re-initialized after being torn down.
+     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
+     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
+     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
+     * @param unloadCtx - This is the context that should be used during unloading.
+     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
+     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
      */
-    teardown?: () => void;
+    teardown?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
     /**
      * Extension name
      */

package/types/JavaScriptSDK.Interfaces/ITelemetryPluginChain.d.ts

@@ -1,10 +1,10 @@
-import { ITelemetryItem } from "./ITelemetryItem";
-import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
-import { ITelemetryPlugin } from "./ITelemetryPlugin";
+import { IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
+import { ITelemetryPlugin, ITelemetryProcessor } from "./ITelemetryPlugin";
+import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
 /**
  * Configuration provided to SDK core
  */
-export interface ITelemetryPluginChain {
+export interface ITelemetryPluginChain extends ITelemetryProcessor {
     /**
      * Returns the underlying plugin that is being proxied for the processTelemetry call
      */
@@ -14,11 +14,10 @@ export interface ITelemetryPluginChain {
      */
     getNext: () => ITelemetryPluginChain;
     /**
-     * Call back for telemetry processing before it it is sent
-     * @param env - This is the current event being reported
-     * @param itemCtx - This is the context for the current request, ITelemetryPlugin instances
-     * can optionally use this to access the current core instance or define / pass additional information
-     * to later plugins (vs appending items to the telemetry item)
+     * 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 unloadCtx - The unload context to use for this call.
+     * @param unloadState - The details of the unload operation
      */
-    processTelemetry: (env: ITelemetryItem, itemCtx: IProcessTelemetryContext) => void;
+    unload?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
 }

package/types/JavaScriptSDK.Interfaces/ITelemetryUnloadState.d.ts

@@ -0,0 +1,6 @@
+import { TelemetryUnloadReason } from "../JavaScriptSDK.Enums/TelemetryUnloadReason";
+export interface ITelemetryUnloadState {
+    reason: TelemetryUnloadReason;
+    isAsync: boolean;
+    flushComplete?: boolean;
+}

package/types/applicationinsights-core-js.d.ts

@@ -14,8 +14,9 @@ export { AppInsightsCore } from "./JavaScriptSDK/AppInsightsCore";
 export { BaseCore } from "./JavaScriptSDK/BaseCore";
 export { BaseTelemetryPlugin } from "./JavaScriptSDK/BaseTelemetryPlugin";
 export { randomValue, random32, mwcRandomSeed, mwcRandom32, newId } from "./JavaScriptSDK/RandomHelper";
-export { CoreUtils, ICoreUtils, EventHelper, IEventHelper, Undefined, addEventHandler, newGuid, perfNow, generateW3CId, disableCookies, canUseCookies, getCookie, setCookie, deleteCookie, _legacyCookieMgr, addEventListeners, addPageUnloadEventListener, addPageHideEventListener, addPageShowEventListener } from "./JavaScriptSDK/CoreUtils";
-export { isTypeof, isUndefined, isNullOrUndefined, hasOwnProperty, isObject, isFunction, attachEvent, detachEvent, normalizeJsName, objForEachKey, strEndsWith, strStartsWith, isDate, isArray, isError, isString, isNumber, isBoolean, toISOString, arrForEach, arrIndexOf, arrMap, arrReduce, strTrim, objKeys, objDefineAccessors, dateNow, getExceptionName, throwError, strContains, isSymbol, setValue, getSetValue, isNotTruthy, isTruthy, proxyAssign, createClassFromInterface, optimizeObject, isNotUndefined, isNotNullOrUndefined, objFreeze, objSeal } from "./JavaScriptSDK/HelperFuncs";
+export { CoreUtils, ICoreUtils, EventHelper, IEventHelper, Undefined, newGuid, perfNow, generateW3CId, disableCookies, canUseCookies, getCookie, setCookie, deleteCookie, _legacyCookieMgr } from "./JavaScriptSDK/CoreUtils";
+export { isTypeof, isUndefined, isNullOrUndefined, hasOwnProperty, isObject, isFunction, normalizeJsName, objForEachKey, strEndsWith, strStartsWith, isDate, isArray, isError, isString, isNumber, isBoolean, toISOString, arrForEach, arrIndexOf, arrMap, arrReduce, strTrim, objKeys, objDefineAccessors, dateNow, getExceptionName, throwError, strContains, isSymbol, setValue, getSetValue, isNotTruthy, isTruthy, proxyAssign, proxyFunctions, proxyFunctionAs, createClassFromInterface, optimizeObject, isNotUndefined, isNotNullOrUndefined, objFreeze, objSeal, createEnumStyle, objExtend } from "./JavaScriptSDK/HelperFuncs";
+export { attachEvent, detachEvent, addEventHandler, addEventListeners, addPageUnloadEventListener, addPageHideEventListener, addPageShowEventListener, removeEventHandler, removeEventListeners, removePageUnloadEventListener, removePageHideEventListener, eventOn, eventOff, mergeEvtNamespace, _IRegisteredEvents, __getRegisteredEvents } from "./JavaScriptSDK/EventHelpers";
 export { getGlobalInst, hasWindow, getWindow, hasDocument, getDocument, getCrypto, getMsCrypto, hasNavigator, getNavigator, hasHistory, getHistory, getLocation, getPerformance, hasJSON, getJSON, isReactNative, getConsole, dumpObj, isIE, getIEVersion, isSafari, setEnableEnvMocks, isBeaconsSupported, isFetchSupported, useXDomainRequest, isXhrSupported } from "./JavaScriptSDK/EnvUtils";
 export { getGlobal, objCreateFn as objCreate, strShimPrototype as strPrototype, strShimFunction as strFunction, strShimUndefined as strUndefined, strShimObject as strObject } from "@microsoft/applicationinsights-shims";
 export { NotificationManager } from "./JavaScriptSDK/NotificationManager";
@@ -26,7 +27,7 @@ export { PerfEvent, PerfManager, doPerf, getGblPerfMgr, setGblPerfMgr } from "./
 export { safeGetLogger, DiagnosticLogger, _InternalLogMessage } from "./JavaScriptSDK/DiagnosticLogger";
 export { ProcessTelemetryContext, createProcessTelemetryContext } from "./JavaScriptSDK/ProcessTelemetryContext";
 export { initializePlugins, sortPlugins } from "./JavaScriptSDK/TelemetryHelpers";
-export { _InternalMessageId, LoggingSeverity } from "./JavaScriptSDK.Enums/LoggingEnums";
+export { _InternalMessageId, _eInternalMessageId, LoggingSeverity, eLoggingSeverity } from "./JavaScriptSDK.Enums/LoggingEnums";
 export { InstrumentProto, InstrumentProtos, InstrumentFunc, InstrumentFuncs } from "./JavaScriptSDK/InstrumentHooks";
 export { ICookieMgr, ICookieMgrConfig } from "./JavaScriptSDK.Interfaces/ICookieMgr";
 export { createCookieMgr, safeGetCookieMgr, uaDisallowsSameSiteNone, areCookiesSupported } from "./JavaScriptSDK/CookieMgr";
@@ -34,3 +35,6 @@ export { strIKey, strExtensionConfig } from "./JavaScriptSDK/Constants";
 export { IDbgExtension } from "./JavaScriptSDK.Interfaces/IDbgExtension";
 export { getDebugListener, getDebugExt } from "./JavaScriptSDK/DbgExtensionUtils";
 export { TelemetryInitializerFunction, ITelemetryInitializerHandler, ITelemetryInitializerContainer } from "./JavaScriptSDK.Interfaces/ITelemetryInitializers";
+export { createUniqueNamespace } from "./JavaScriptSDK/DataCacheHelper";
+export { UnloadHandler, IUnloadHandlerContainer, createUnloadHandlerContainer } from "./JavaScriptSDK/UnloadHandlerContainer";
+export { ITelemetryUnloadState } from "./JavaScriptSDK.Interfaces/ITelemetryUnloadState";