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

package/dist/applicationinsights-core-js.rollup.d.ts

@@ -1,5 +1,5 @@
 /*
- * Microsoft Application Insights Core Javascript SDK, 2.8.0-beta.2203-04
+ * Microsoft Application Insights Core Javascript SDK, 2.8.0-beta.2203-07
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -24,9 +24,11 @@ import { strShimUndefined as strUndefined } from '@microsoft/applicationinsights
  * Get all of the registered events on the target object, this is primarily used for testing cleanup but may also be used by
  * applications to remove their own events
  * @param target - The EventTarget that has registered events
- * @param evtName - [Optional] The name of the event to return the registered handlers and full name (with namespaces)
+ * @param eventName - [Optional] The name of the event to return the registered handlers and full name (with namespaces)
+ * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
+ * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
  */
-export declare function __getRegisteredEvents(target: any, evtName?: string): _IRegisteredEvents[];
+export declare function __getRegisteredEvents(target: any, eventName?: string, evtNamespace?: string | string[]): _IRegisteredEvents[];
 
 /**
  * Trys to add an event handler for the specified event to the window, body and document
@@ -202,10 +204,20 @@ export declare class BaseCore implements IAppInsightsCore {
      * 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.
+     * @param isAsync - Can the unload be performed asynchronously (default)
+     * @param unloadComplete - An optional callback that will be called once the unload has completed
+     * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
      */
-    unload(isAsync?: boolean, unloadComplete?: () => void): void;
+    unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void;
     getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
-    addPlugin<T extends IPlugin = ITelemetryPlugin>(plugin: T, replaceExisting: boolean, doAsync: boolean, addCb?: (added?: boolean) => void): void;
+    /**
+     * Add a new plugin to the installation
+     * @param plugin - The new plugin to add
+     * @param replaceExisting - should any existing plugin be replaced, default is false
+     * @param doAsync - Should the add be performed asynchronously
+     * @param addCb - [Optional] callback to call after the plugin has been added
+     */
+    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
      */
@@ -215,7 +227,23 @@ export declare class BaseCore implements IAppInsightsCore {
      * @param handler - the handler
      */
     addUnloadCb(handler: UnloadHandler): void;
+    /**
+     * Flush and send any batched / cached data immediately
+     * @param async - send data asynchronously when true (defaults to 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(isAsync?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): void;
     protected releaseQueue(): void;
+    /**
+     * Hook for Core extensions to allow them to update their own configuration before updating all of the plugins.
+     * @param updateCtx - The plugin update context
+     * @param updateState - The Update State
+     * @returns boolean - True means the extension class will call updateState otherwise the Core will
+     */
+    protected _updateHook?(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
 }
 
 /**
@@ -272,6 +300,14 @@ export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
      */
     protected _doTeardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
+    /**
+     * Extension hook to allow implementations to perform some additional update operations before the BaseTelemetryPlugin finishes it's removal
+     * @param updateCtx - This is the context that should be used during updating.
+     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
+     * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async update operations.
+     * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
+     */
+    protected _doUpdate?: (updateCtx?: IProcessTelemetryUpdateContext, updateState?: ITelemetryUpdateState, asyncCallback?: () => void) => void | boolean;
     constructor();
     initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain): void;
     /**
@@ -284,6 +320,13 @@ export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      */
     teardown(unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState): void | boolean;
     abstract processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
+    /**
+     * The the plugin should re-evaluate configuration and update any cached configuration settings.
+     * @param updateCtx - This is the context that should be used during updating.
+     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
+     * @returns boolean - true if the plugin has or will call updateCtx.processNext(), this allows the plugin to perform any asynchronous operations.
+     */
+    update(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
     /**
      * Add an unload handler that will be called when the SDK is being unloaded
      * @param handler - the handler
@@ -820,8 +863,11 @@ export declare interface IAppInsightsCore extends IPerfManagerProvider {
      * 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.
+     * @param isAsync - Can the unload be performed asynchronously (default)
+     * @param unloadComplete - An optional callback that will be called once the unload has completed
+     * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
      */
-    unload(isAsync?: boolean, unloadComplete?: () => void): void;
+    unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void;
     /**
      * Find and return the (first) plugin with the specified identifier if present
      * @param pluginIdentifier
@@ -830,10 +876,11 @@ export declare interface IAppInsightsCore extends IPerfManagerProvider {
     /**
      * Add a new plugin to the installation
      * @param plugin - The new plugin to add
-     * @param replaceExisting - should any existing plugin be replaced
+     * @param replaceExisting - should any existing plugin be replaced, default is false
      * @param doAsync - Should the add be performed asynchronously
+     * @param addCb - [Optional] callback to call after the plugin has been added
      */
-    addPlugin<T extends IPlugin = ITelemetryPlugin>(plugin: T, replaceExisting: boolean, doAsync: boolean, addCb?: (added?: boolean) => void): void;
+    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
      */
@@ -843,9 +890,19 @@ export declare interface IAppInsightsCore extends IPerfManagerProvider {
      * @param handler - the handler
      */
     addUnloadCb(handler: UnloadHandler): void;
+    /**
+     * Flush and send any batched / cached data immediately
+     * @param async - send data asynchronously when true (defaults to 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
+     * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
+     * @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(isAsync?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason, cbTimeout?: number): boolean | void;
 }
 
-declare interface IBaseProcessingContext {
+export declare interface IBaseProcessingContext {
     /**
      * The current core instance for the request
      */
@@ -1510,6 +1567,11 @@ export declare interface IInstrumentHooks {
  * You must always supply the error callback
  */
 export declare interface IInstrumentHooksCallbacks {
+    /**
+     * [Optional] Namespace details (same as the namespace used for events), useful for debugging and testing to
+     * identify the source of the instrumented hooks
+     */
+    ns?: string | string[];
     /**
      * The hook callback to call before the original function is called
      */
@@ -1924,10 +1986,10 @@ export declare interface IProcessTelemetryContext extends IBaseProcessingContext
 }
 
 /**
- * The current context for the current call to processTelemetry(), used to support sharing the same plugin instance
- * between multiple AppInsights instances
+ * The current context for the current call to teardown() implementations, used to support when plugins are being removed
+ * or the SDK is being unloaded.
  */
-declare interface IProcessTelemetryUnloadContext extends IBaseProcessingContext {
+export declare interface IProcessTelemetryUnloadContext extends IBaseProcessingContext {
     /**
      * This Plugin has finished unloading, so unload the next one
      * @param uploadState - The state of the unload process
@@ -1944,6 +2006,27 @@ declare interface IProcessTelemetryUnloadContext extends IBaseProcessingContext
     createNew: (plugins?: IPlugin[] | ITelemetryPluginChain, startAt?: IPlugin) => IProcessTelemetryUnloadContext;
 }
 
+/**
+ * The current context for the current call to the plugin update() implementations, used to support the notifications
+ * for when plugins are added, removed or the configuration was changed.
+ */
+export declare interface IProcessTelemetryUpdateContext extends IBaseProcessingContext {
+    /**
+     * This Plugin has finished unloading, so unload the next one
+     * @param updateState - The update State
+     * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
+     */
+    processNext: (updateState: ITelemetryUpdateState) => 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) => IProcessTelemetryUpdateContext;
+}
+
 export declare interface _IRegisteredEvents {
     name: string;
     handler: any;
@@ -2148,6 +2231,15 @@ declare interface ITelemetryProcessor {
      * to later plugins (vs appending items to the telemetry item)
      */
     processTelemetry: (env: ITelemetryItem, itemCtx?: IProcessTelemetryContext) => void;
+    /**
+     * The the plugin should re-evaluate configuration and update any cached configuration settings or
+     * plugins. If implemented this method will be called whenever a plugin is added or removed and if
+     * the configuration has bee updated.
+     * @param updateCtx - This is the context that should be used during updating.
+     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
+     * @returns boolean - true if the plugin has or will call updateCtx.processNext(), this allows the plugin to perform any asynchronous operations.
+     */
+    update?: (updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState) => void | boolean;
 }
 
 export declare interface ITelemetryUnloadState {
@@ -2156,6 +2248,27 @@ export declare interface ITelemetryUnloadState {
     flushComplete?: boolean;
 }
 
+export declare interface ITelemetryUpdateState {
+    /**
+     * Identifies the reason for the update notification, this is a bitwise numeric value
+     */
+    reason: TelemetryUpdateReason;
+    /**
+     * If this is a configuration update this was the previous configuration that was used
+     */
+    /**
+     * If this is a configuration update is the new configuration that is being used
+     */
+    /**
+     * This holds a collection of plugins that have been added (if the reason identifies that one or more plugins have been added)
+     */
+    added?: IPlugin[];
+    /**
+     * This holds a collection of plugins that have been removed (if the reason identifies that one or more plugins have been removed)
+     */
+    removed?: IPlugin[];
+}
+
 export declare interface IUnloadHandlerContainer {
     add: (handler: UnloadHandler) => void;
     run: (itemCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
@@ -2282,7 +2395,9 @@ export declare function objDefineAccessors<T>(target: any, prop: string, getProp
  * @param obj5 - object to merge.
  * @returns The extended first object.
  */
-export declare function objExtend<T1, T2, T3, T4, T5, T6>(obj?: boolean | T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6;
+export declare function objExtend<T2, T3, T4, T5, T6>(deepExtend?: boolean, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T2 & T3 & T4 & T5 & T6;
+
+export declare function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6;
 
 /**
  * This is a helper function for the equivalent of arForEach(objKeys(target), callbackFn), this is a
@@ -2529,6 +2644,15 @@ export declare function removeEventListeners(events: string[], listener: any, ev
  */
 export declare function removePageHideEventListener(listener: any, evtNamespace?: string | string[]): void;
 
+/**
+ * Removes the pageShow event listeners added by addPageShowEventListener, because the 'visibilitychange' uses
+ * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageShowEventListener
+ * as the remove ignores the listener argument for the 'visibilitychange' event.
+ * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')
+ * @param evtNamespace - The unique namespace used when calling addPageShowEventListener
+ */
+export declare function removePageShowEventListener(listener: any, evtNamespace?: string | string[]): void;
+
 /**
  * Remove any matching 'beforeunload', 'unload' and 'pagehide' events that may have been added via addEventListener,
  * addEventListeners, addPageUnloadEventListener or addPageHideEventListener.
@@ -2676,7 +2800,7 @@ export declare type TelemetryInitializerFunction = <T extends ITelemetryItem>(it
 /**
  * The TelemetryUnloadReason enumeration contains the possible reasons for why a plugin is being unloaded / torndown().
  */
-declare const enum TelemetryUnloadReason {
+export declare const enum TelemetryUnloadReason {
     /**
      * Teardown has been called without any context.
      */
@@ -2695,8 +2819,40 @@ declare const enum TelemetryUnloadReason {
     SdkUnload = 50
 }
 
+/**
+ * The TelemetryUpdateReason enumeration contains a set of bit-wise values that specify the reason for update request.
+ */
+export declare const enum TelemetryUpdateReason {
+    /**
+     * Unknown.
+     */
+    Unknown = 0,
+    /**
+     * The configuration has ben updated or changed
+     */
+    /**
+     * One or more plugins have been added
+     */
+    PluginAdded = 16,
+    /**
+     * One or more plugins have been removed
+     */
+    PluginRemoved = 32
+}
+
 export declare function throwError(message: string): never;
 
+/**
+ * This is a helper method which will call throwInternal on the passed logger, will throw exceptions in
+ * debug mode or attempt to log the error as a console warning. This helper is provided mostly to better
+ * support minification as logger.throwInternal() will not compress the publish "throwInternal" used throughout
+ * the code.
+ * @param logger - The Diagnostic Logger instance to use.
+ * @param severity {LoggingSeverity} - The severity of the log message
+ * @param message {_InternalLogMessage} - The log message.
+ */
+export declare function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
+
 /**
  * Convert a date to I.S.O. format in IE8
  */

package/dist-esm/JavaScriptSDK/AppInsightsCore.js

@@ -1,5 +1,5 @@
 /*
- * Application Insights JavaScript SDK - Core, 2.8.0-beta.2203-04
+ * Application Insights JavaScript SDK - Core, 2.8.0-beta.2203-07
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 import { __extendsFn as __extends } from "@microsoft/applicationinsights-shims";

package/dist-esm/JavaScriptSDK/BaseCore.js

@@ -1,5 +1,5 @@
 /*
- * Application Insights JavaScript SDK - Core, 2.8.0-beta.2203-04
+ * Application Insights JavaScript SDK - Core, 2.8.0-beta.2203-07
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 
@@ -8,13 +8,13 @@
 import { __spreadArrayFn as __spreadArray } from "@microsoft/applicationinsights-shims";
 import { objCreateFn } from "@microsoft/applicationinsights-shims";
 import dynamicProto from "@microsoft/dynamicproto-js";
-import { createProcessTelemetryContext, createProcessTelemetryUnloadContext, createTelemetryProxyChain } from "./ProcessTelemetryContext";
+import { createProcessTelemetryContext, createProcessTelemetryUnloadContext, createProcessTelemetryUpdateContext, createTelemetryProxyChain } from "./ProcessTelemetryContext";
 import { initializePlugins, sortPlugins, _getPluginState } from "./TelemetryHelpers";
 import { getGblPerfMgr, PerfManager } from "./PerfManager";
 import { createCookieMgr } from "./CookieMgr";
 import { arrForEach, isNullOrUndefined, toISOString, getSetValue, setValue, throwError, isNotTruthy, isFunction, objFreeze, proxyFunctionAs, proxyFunctions } from "./HelperFuncs";
 import { strExtensionConfig, strIKey } from "./Constants";
-import { DiagnosticLogger, _InternalLogMessage } from "./DiagnosticLogger";
+import { DiagnosticLogger, _InternalLogMessage, _throwInternal } from "./DiagnosticLogger";
 import { getDebugListener } from "./DbgExtensionUtils";
 import { ChannelControllerPriority, createChannelControllerPlugin, createChannelQueues } from "./ChannelController";
 import { TelemetryInitializerPlugin } from "./TelemetryInitializerPlugin";
@@ -143,8 +143,8 @@ var BaseCore = /** @class */ (function () {
                 _configExtensions = [];
                 _configExtensions.push.apply(_configExtensions, __spreadArray(__spreadArray([], extensions, false), config.extensions, false));
                 _channelConfig = (config || {}).channels;
-                _initPluginChain(config);
-                if (_self.getTransmissionControls().length === 0) {
+                _initPluginChain(config, null);
+                if (!_channelQueue || _channelQueue.length === 0) {
                     throwError("No channels available");
                 }
                 _isInitialized = true;
@@ -295,16 +295,12 @@ var BaseCore = /** @class */ (function () {
                     // Start unloading the components, from this point onwards the SDK should be considered to be in an unstable state
                     processUnloadCtx.processNext(unloadState);
                 }
-                if (_channelControl) {
-                    _channelControl.flush(isAsync, _doUnload, 6 /* SdkUnload */, cbTimeout);
-                }
-                else {
-                    _doUnload(true);
+                if (!_flushChannels(isAsync, _doUnload, 6 /* SdkUnload */, cbTimeout)) {
+                    _doUnload(false);
                 }
             };
             _self.getPlugin = _getPlugin;
             _self.addPlugin = function (plugin, replaceExisting, isAsync, addCb) {
-                if (isAsync === void 0) { isAsync = true; }
                 if (!plugin) {
                     addCb && addCb(false);
                     _logOrThrowError(strValidationError);
@@ -316,24 +312,30 @@ var BaseCore = /** @class */ (function () {
                     _logOrThrowError("Plugin [" + plugin.identifier + "] is already loaded!");
                     return;
                 }
+                var updateState = {
+                    reason: 16 /* PluginAdded */
+                };
                 function _addPlugin(removed) {
                     _configExtensions.push(plugin);
+                    updateState.added = [plugin];
                     // Re-Initialize the plugin chain
-                    _initPluginChain(_self.config);
+                    _initPluginChain(_self.config, updateState);
                     addCb && addCb(true);
                 }
                 if (existingPlugin) {
-                    var removedPlugins = [existingPlugin.plugin];
+                    var removedPlugins_1 = [existingPlugin.plugin];
                     var unloadState = {
                         reason: 2 /* PluginReplace */,
                         isAsync: isAsync
                     };
-                    _removePlugins(removedPlugins, unloadState, function (removed) {
+                    _removePlugins(removedPlugins_1, unloadState, function (removed) {
                         if (!removed) {
                             // Previous plugin was successfully removed or was not installed
                             addCb && addCb(false);
                         }
                         else {
+                            updateState.removed = removedPlugins_1;
+                            updateState.reason |= 32 /* PluginRemoved */;
                             _addPlugin(true);
                         }
                     });
@@ -345,6 +347,7 @@ var BaseCore = /** @class */ (function () {
             _self.evtNamespace = function () {
                 return _evtNamespace;
             };
+            _self.flush = _flushChannels;
             // Create the addUnloadCb
             proxyFunctionAs(_self, "addUnloadCb", function () { return _unloadHandlers; }, "add");
             function _initDefaults() {
@@ -374,7 +377,7 @@ var BaseCore = /** @class */ (function () {
                 return createProcessTelemetryContext(_getPluginChain(), _self.config, _self);
             }
             // Initialize or Re-initialize the plugins
-            function _initPluginChain(config) {
+            function _initPluginChain(config, updateState) {
                 // Extension validation
                 var theExtensions = _validateExtensions(_self.logger, ChannelControllerPriority, _configExtensions);
                 _coreExtensions = theExtensions.core;
@@ -411,6 +414,9 @@ var BaseCore = /** @class */ (function () {
                 initializePlugins(_createTelCtx(), allExtensions);
                 // Now reset the extensions to just those being managed by Basecore
                 _self._extensions = objFreeze(sortPlugins(_coreExtensions || [])).slice();
+                if (updateState) {
+                    _doUpdate(updateState);
+                }
             }
             function _getPlugin(pluginIdentifier) {
                 var theExt = null;
@@ -445,7 +451,10 @@ var BaseCore = /** @class */ (function () {
                             _removePlugins(pluginsToRemove, unloadState, function (removed) {
                                 if (removed) {
                                     // Re-Initialize the plugin chain
-                                    _initPluginChain(_self.config);
+                                    _initPluginChain(_self.config, {
+                                        reason: 32 /* PluginRemoved */,
+                                        removed: pluginsToRemove
+                                    });
                                 }
                                 removeCb && removeCb(removed);
                             });
@@ -524,6 +533,13 @@ var BaseCore = /** @class */ (function () {
                     queue.length = 0;
                 }
             }
+            function _flushChannels(isAsync, callBack, sendReason, cbTimeout) {
+                if (_channelControl) {
+                    return _channelControl.flush(isAsync, callBack, sendReason || 6 /* SdkUnload */, cbTimeout);
+                }
+                callBack && callBack(false);
+                return true;
+            }
             function _initDebugListener(config) {
                 if (config.disableDbgExt === true && _debugListener) {
                     // Remove any previously loaded debug listener
@@ -549,11 +565,17 @@ var BaseCore = /** @class */ (function () {
                 var extConfig = getSetValue(config, strExtensionConfig);
                 extConfig.NotificationManager = _notificationManager;
             }
+            function _doUpdate(updateState) {
+                var updateCtx = createProcessTelemetryUpdateContext(_getPluginChain(), _self.config, _self);
+                if (!_self._updateHook || _self._updateHook(updateCtx, updateState) !== true) {
+                    updateCtx.processNext(updateState);
+                }
+            }
             function _logOrThrowError(message) {
                 var logger = _self.logger;
                 if (logger) {
                     // there should always be a logger
-                    logger.throwInternal(2 /* WARNING */, 73 /* PluginException */, message);
+                    _throwInternal(logger, 2 /* WARNING */, 73 /* PluginException */, message);
                 }
                 else {
                     throwError(message);
@@ -581,7 +603,9 @@ var BaseCore = /** @class */ (function () {
 // Removed Stub for BaseCore.prototype.addPlugin.
 // Removed Stub for BaseCore.prototype.evtNamespace.
 // Removed Stub for BaseCore.prototype.addUnloadCb.
+// Removed Stub for BaseCore.prototype.flush.
 // Removed Stub for BaseCore.prototype.releaseQueue.
+// Removed Stub for BaseCore.prototype._updateHook.
     return BaseCore;
 }());
 export { BaseCore };