@microsoft/applicationinsights-core-js 3.0.0-beta.2211-01 → 3.0.0-beta.2211-04

package/src/JavaScriptSDK/AppInsightsCore.ts

@@ -4,8 +4,8 @@
 
 import dynamicProto from "@microsoft/dynamicproto-js";
 import {
-    arrAppend, arrForEach, arrIndexOf, deepExtend, dumpObj, hasDocument, isFunction, isNullOrUndefined, isPlainObject, objDeepFreeze,
-    objDefineProp, objForEachKey, objFreeze, objHasOwn, throwError
+    ITimerHandler, arrAppend, arrForEach, arrIndexOf, deepExtend, dumpObj, hasDocument, isFunction, isNullOrUndefined, isPlainObject,
+    objDeepFreeze, objDefineProp, objForEachKey, objFreeze, objHasOwn, scheduleInterval, scheduleTimeout, throwError
 } from "@nevware21/ts-utils";
 import { createDynamicConfig, onConfigChange } from "../Config/DynamicConfig";
 import { IConfigDefaults } from "../Config/IConfigDefaults";
@@ -33,10 +33,7 @@ import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPlu
 import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
 import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
 import { ILegacyUnloadHook, IUnloadHook } from "../JavaScriptSDK.Interfaces/IUnloadHook";
-import {
-    ChannelControllerPriority, IChannelController, IInternalChannelController, _IInternalChannels, createChannelControllerPlugin,
-    createChannelQueues
-} from "./ChannelController";
+import { ChannelControllerPriority } from "./Constants";
 import { createCookieMgr } from "./CookieMgr";
 import { createUniqueNamespace } from "./DataCacheHelper";
 import { getDebugListener } from "./DbgExtensionUtils";
@@ -84,9 +81,10 @@ function _createPerfManager (core: IAppInsightsCore, notificationMgr: INotificat
     return new PerfManager(notificationMgr);
 }
 
-function _validateExtensions(logger: IDiagnosticLogger, channelPriority: number, allExtensions: IPlugin[]): { all: IPlugin[]; core: ITelemetryPlugin[] } {
+function _validateExtensions(logger: IDiagnosticLogger, channelPriority: number, allExtensions: IPlugin[]): { core: IPlugin[], channels: IChannelControls[] } {
     // Concat all available extensions
     let coreExtensions: ITelemetryPlugin[] = [];
+    let channels: IChannelControls[] = [];
 
     // Check if any two extensions have the same priority, then warn to console
     // And extract the local extensions from the
@@ -111,16 +109,18 @@ function _validateExtensions(logger: IDiagnosticLogger, channelPriority: number,
             }
         }
 
-        // Split extensions to core and channelController
+        // Split extensions to core and channels
         if (!extPriority || extPriority < channelPriority) {
             // Add to core extension that will be managed by AppInsightsCore
             coreExtensions.push(ext);
+        } else {
+            channels.push(ext);
         }
     });
 
     return {
-        all: allExtensions,
-        core: coreExtensions
+        core: coreExtensions,
+        channels: channels
     };
 }
 
@@ -239,10 +239,8 @@ export class AppInsightsCore implements IAppInsightsCore {
         let _cookieManager: ICookieMgr | null;
         let _pluginChain: ITelemetryPluginChain | null;
         let _configExtensions: IPlugin[];
-        let _coreExtensions: ITelemetryPlugin[] | null;
-        let _channelControl: IChannelController | null;
         let _channelConfig: IChannelControls[][] | null | undefined;
-        let _channelQueue: _IInternalChannels[] | null;
+        let _channels: IChannelControls[] | null;
         let _isUnloading: boolean;
         let _telemetryInitializerPlugin: TelemetryInitializerPlugin;
         let _internalLogsEventName: string | null;
@@ -260,7 +258,8 @@ export class AppInsightsCore implements IAppInsightsCore {
         /**
          * Internal log poller
          */
-        let _internalLogPoller: number = 0;
+        let _internalLogPoller: ITimerHandler;
+        let _internalLogPollerListening: boolean;
 
         dynamicProto(AppInsightsCore, this, (_self) => {
 
@@ -316,22 +315,31 @@ export class AppInsightsCore implements IAppInsightsCore {
 
                 _initPluginChain(null);
 
-                if (!_channelQueue || _channelQueue.length === 0) {
+                if (!_channels || _channels.length === 0) {
                     throwError("No " + STR_CHANNELS + " available");
                 }
                 
+                if (_channels.length > 1) {
+                    let teeController = _self.getPlugin("TeeChannelController");
+                    if (!teeController || !teeController.plugin) {
+                        _throwInternal(_self.logger, eLoggingSeverity.CRITICAL, _eInternalMessageId.SenderNotInitialized, "TeeChannel required");
+                    }
+                }
+
                 _registerDelayedCfgListener(config, _cfgListeners, _self.logger);
                 _cfgListeners = null;
 
                 _isInitialized = true;
                 _self.releaseQueue();
+
+                _self.pollInternalLogs();
             };
         
-            _self.getTransmissionControls = (): IChannelControls[][] => {
-                let controls: IChannelControls[][] = [];
-                if (_channelQueue) {
-                    arrForEach(_channelQueue, (channels) => {
-                        controls.push(channels.queue);
+            _self.getChannels = (): IChannelControls[] => {
+                let controls: IChannelControls[] = [];
+                if (_channels) {
+                    arrForEach(_channels, (channel) => {
+                        controls.push(channel);
                     });
                 }
 
@@ -456,22 +464,31 @@ export class AppInsightsCore implements IAppInsightsCore {
             /**
              * Periodically check logger.queue for log messages to be flushed
              */
-            _self.pollInternalLogs = (eventName?: string): number => {
+            _self.pollInternalLogs = (eventName?: string): ITimerHandler => {
                 _internalLogsEventName = eventName || null;
 
-                _addUnloadHook(_configHandler.watch((details) => {
-                    let interval: number = details.cfg.diagnosticLogInterval;
+                function _startLogPoller(config: IConfiguration) {
+                    let interval: number = config.diagnosticLogInterval;
                     if (!interval || !(interval > 0)) {
                         interval = 10000;
                     }
 
-                    if(_internalLogPoller) {
-                        clearInterval(_internalLogPoller);
-                    }
-                    _internalLogPoller = setInterval(() => {
+                    _internalLogPoller && _internalLogPoller.cancel();
+                    _internalLogPoller = scheduleInterval(() => {
                         _flushInternalLogs();
                     }, interval) as any;
-                }));
+                }
+
+                if (!_internalLogPollerListening) {
+                    _internalLogPollerListening = true;
+                    // listen to the configuration
+                    _addUnloadHook(_configHandler.watch((details) => {
+                        _startLogPoller(details.cfg);
+                    }));
+                } else {
+                    // We are being called again, so make sure the poller is running
+                    _startLogPoller(_configHandler.cfg);
+                }
 
                 return _internalLogPoller;
             }
@@ -480,9 +497,9 @@ export class AppInsightsCore implements IAppInsightsCore {
              * Stop polling log messages from logger.queue
              */
             _self.stopPollingInternalLogs = (): void => {
-                if(_internalLogPoller) {
-                    clearInterval(_internalLogPoller);
-                    _internalLogPoller = 0;
+                if (_internalLogPoller) {
+                    _internalLogPoller.cancel();
+                    _internalLogPoller = null;
                     _flushInternalLogs();
                 }
             }
@@ -774,11 +791,9 @@ export class AppInsightsCore implements IAppInsightsCore {
                 _cfgPerfManager = null;
                 _cookieManager = null;
                 _pluginChain = null;
-                _coreExtensions = null;
                 _configExtensions = [];
-                _channelControl = null;
                 _channelConfig = null;
-                _channelQueue = null;
+                _channels = null;
                 _isUnloading = false;
                 _internalLogsEventName = null;
                 _evtNamespace = createUniqueNamespace("AIBaseCore", true);
@@ -800,50 +815,34 @@ export class AppInsightsCore implements IAppInsightsCore {
                 // Extension validation
                 let theExtensions = _validateExtensions(_self.logger, ChannelControllerPriority, _configExtensions);
             
-                _coreExtensions = theExtensions.core;
                 _pluginChain = null;
                 _pluginVersionString = null;
                 _pluginVersionStringArr = null;
     
-                // Sort the complete set of extensions by priority
-                let allExtensions = theExtensions.all;
-
-                // Initialize the Channel Queues and the channel plugins first
-                _channelQueue = objFreeze(createChannelQueues(_channelConfig, allExtensions, _self));
-                if (_channelControl) {
-                    // During add / remove of a plugin this may get called again, so don't re-add if already present
-                    // But we also want the controller as the last, so remove if already present
-                    // And reusing the existing instance, just in case an installed plugin has a reference and
-                    // is using it.
-                    let idx = arrIndexOf(allExtensions, _channelControl);
-                    if (idx !== -1) {
-                        allExtensions.splice(idx, 1);
-                    }
-
-                    idx = arrIndexOf(_coreExtensions, _channelControl);
-                    if (idx !== -1) {
-                        _coreExtensions.splice(idx, 1);
-                    }
+                // Get the primary channel queue and include as part of the normal extensions
+                _channels = (_channelConfig || [])[0] ||[];
+                
+                // Add any channels provided in the extensions and sort them
+                _channels = sortPlugins(arrAppend(_channels, theExtensions.channels));
 
-                    (_channelControl as IInternalChannelController)._setQueue(_channelQueue);
-                } else {
-                    _channelControl = createChannelControllerPlugin(_channelQueue, _self);
-                }
+                // Sort the complete set of extensions by priority
+                let allExtensions = sortPlugins(theExtensions.core);
 
                 // Add on "channelController" as the last "plugin"
-                allExtensions.push(_channelControl);
-                _coreExtensions.push(_channelControl);
+                arrAppend(allExtensions, _channels);
 
                 // Required to allow plugins to call core.getPlugin() during their own initialization
-                _extensions = sortPlugins(allExtensions);
+                _extensions = objFreeze(allExtensions);
 
-                // Initialize the controls
-                _channelControl.initialize(_configHandler.cfg, _self, allExtensions);
+                let rootCtx = _createTelCtx();
                 
-                initializePlugins(_createTelCtx(), allExtensions);
+                // Initializing the channels first
+                if (_channels && _channels.length > 0) {
+                    initializePlugins(rootCtx.createNew(_channels), allExtensions);
+                }
 
-                // Now reset the extensions to just those being managed by AppInsightsCore
-                _extensions = objFreeze(sortPlugins(_coreExtensions || [])).slice();
+                // Now initialize the normal extensions
+                initializePlugins(rootCtx, allExtensions);
 
                 if (updateState) {
                     _doUpdate(updateState);
@@ -855,16 +854,19 @@ export class AppInsightsCore implements IAppInsightsCore {
                 let thePlugin: IPlugin = null;
 
                 arrForEach(_extensions, (ext: any) => {
-                    if (ext.identifier === pluginIdentifier && ext !== _channelControl && ext !== _telemetryInitializerPlugin) {
+                    if (ext.identifier === pluginIdentifier && ext !== _telemetryInitializerPlugin) {
                         thePlugin = ext;
                         return -1;
                     }
+
+                    // TODO: Check if the extension is an extension "host" (like the TeeChannel)
+                    // So that if the extension is not found we can ask the "host" plugins for the plugin
                 });
 
-                if (!thePlugin && _channelControl) {
-                    // Check the channel Controller
-                    thePlugin = _channelControl.getChannel(pluginIdentifier);
-                }
+                // if (!thePlugin && _channelControl) {
+                //     // Check the channel Controller
+                //     thePlugin = _channelControl.getChannel(pluginIdentifier);
+                // }
 
                 if (thePlugin) {
                     theExt = {
@@ -904,9 +906,9 @@ export class AppInsightsCore implements IAppInsightsCore {
             function _getPluginChain() {
                 if (!_pluginChain) {
                     // copy the collection of extensions
-                    let extensions = (_coreExtensions || []).slice();
+                    let extensions = (_extensions || []).slice();
 
-                    // During add / remove this may get called again, so don't readd if already present
+                    // During add / remove this may get called again, so don't read if already present
                     if (arrIndexOf(extensions, _telemetryInitializerPlugin) === -1) {
                         extensions.push(_telemetryInitializerPlugin);
                     }
@@ -987,11 +989,56 @@ export class AppInsightsCore implements IAppInsightsCore {
             }
 
             function _flushChannels(isAsync?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason, cbTimeout?: number) {
-                if (_channelControl) {
-                    return _channelControl.flush(isAsync, callBack, sendReason || SendRequestReason.SdkUnload, cbTimeout);
+                // Setting waiting to one so that we don't call the callBack until we finish iterating
+                let waiting = 1;
+                let doneIterating = false;
+                let cbTimer: ITimerHandler = null;
+                cbTimeout = cbTimeout || 5000;
+
+                function doCallback() {
+                    waiting--;
+                    if (doneIterating && waiting === 0) {
+                        cbTimer && cbTimer.cancel();
+                        cbTimer = null;
+    
+                        callBack && callBack(doneIterating);
+                        callBack = null;
+                    }
+                }
+                    
+                if (_channels && _channels.length > 0) {
+                    let flushCtx = _createTelCtx().createNew(_channels);
+                    flushCtx.iterate<IChannelControls>((plugin) => {
+                        if (plugin.flush) {
+                            waiting ++;
+
+                            let handled = false;
+                            // Not all channels will call this callback for every scenario
+                            if (!plugin.flush(isAsync, () => {
+                                handled = true;
+                                doCallback();
+                            }, sendReason)) {
+                                if (!handled) {
+                                    // If any channel doesn't return true and it didn't call the callback, then we should assume that the callback
+                                    // will never be called, so use a timeout to allow the channel(s) some time to "finish" before triggering any
+                                    // followup function (such as unloading)
+                                    if (isAsync && cbTimer == null) {
+                                        cbTimer = scheduleTimeout(() => {
+                                            cbTimer = null;
+                                            doCallback();
+                                        }, cbTimeout);
+                                    } else {
+                                        doCallback();
+                                    }
+                                }
+                            }
+                        }
+                    });
                 }
 
-                callBack && callBack(false);
+                doneIterating = true;
+                doCallback();
+                
                 return true;
             }
 
@@ -1070,7 +1117,7 @@ export class AppInsightsCore implements IAppInsightsCore {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
     }
 
-    public getTransmissionControls(): IChannelControls[][] {
+    public getChannels(): IChannelControls[] {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
         return null;
     }
@@ -1140,9 +1187,9 @@ export class AppInsightsCore implements IAppInsightsCore {
     /**
      * Periodically check logger.queue for
      */
-    public pollInternalLogs(eventName?: string): number {
+    public pollInternalLogs(eventName?: string): ITimerHandler {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-        return 0;
+        return null;
     }
 
     /**

package/src/JavaScriptSDK/Constants.ts

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+export const ChannelControllerPriority = 500;

package/src/JavaScriptSDK.Interfaces/IAppInsightsCore.ts

@@ -17,6 +17,7 @@ import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
 import { IDistributedTraceContext } from "./IDistributedTraceContext";
 import { ILegacyUnloadHook, IUnloadHook } from "./IUnloadHook";
 import { WatcherFunction } from "../Config/IDynamicWatcher";
+import { ITimerHandler } from "@nevware21/ts-utils";
 
 export interface ILoadedPlugin<T extends IPlugin> {
     plugin: T;
@@ -69,9 +70,9 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
     initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
 
     /*
-    * Get transmission controls for controlling transmission behavior
+    * Get transmission channels for controlling transmission behavior
     */
-    getTransmissionControls(): IChannelControls[][];
+    getChannels(): IChannelControls[];
 
     /*
     * Core track API
@@ -115,7 +116,7 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
      */
     addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler;
 
-    pollInternalLogs?(eventName?: string): number;
+    pollInternalLogs?(eventName?: string): ITimerHandler;
 
     stopPollingInternalLogs?(): void;
 

package/src/JavaScriptSDK.Interfaces/IChannelControls.ts

@@ -15,12 +15,12 @@ export interface IChannelControls extends ITelemetryPlugin {
     /**
      * Pause sending data
      */
-    pause(): void;
+    pause?(): void;
 
     /**
      * Resume sending data
      */
-    resume(): void;
+    resume?(): void;
 
     /**
      * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
@@ -30,7 +30,7 @@ export interface IChannelControls extends ITelemetryPlugin {
      * @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: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
+    teardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
 
     /**
      * Flush to send data immediately; channel should default to sending data asynchronously
@@ -40,7 +40,7 @@ export interface IChannelControls extends ITelemetryPlugin {
      * @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?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
+    flush?(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
 }
 
 export const MinChannelPriorty: number = 100;

package/types/Config/IConfigDefaults.d.ts

@@ -2,11 +2,11 @@ import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 /**
  * The type to identify whether the default value should be applied in preference to the provided value.
  */
-export declare type IConfigCheckFn<V> = (value: V) => boolean;
+export type IConfigCheckFn<V> = (value: V) => boolean;
 /**
  * The type which identifies the function use to validate the user supplied value
  */
-export declare type IConfigSetFn<T, V> = (value: any, defValue: V, theConfig: T) => V;
+export type IConfigSetFn<T, V> = (value: any, defValue: V, theConfig: T) => V;
 /**
  * The default values with a check function
  */
@@ -37,6 +37,6 @@ export interface IConfigDefaultCheck<T, V, C extends IConfiguration = IConfigura
  * The Type definition to define default values to be applied to the config
  * The value may be either the direct value or a ConfigDefaultCheck definition
  */
-export declare type IConfigDefaults<T, C extends IConfiguration = IConfiguration> = {
+export type IConfigDefaults<T, C extends IConfiguration = IConfiguration> = {
     [key in keyof T]: T[key] | IConfigDefaultCheck<T, T[key], C>;
 };

package/types/Config/IDynamicWatcher.d.ts

@@ -21,7 +21,7 @@ export interface IWatchDetails<T extends IConfiguration> {
      */
     setDf: <C>(theConfig: C, defaultValues: IConfigDefaults<C>) => C;
 }
-export declare type WatcherFunction<T extends IConfiguration> = (details: IWatchDetails<T>) => void;
+export type WatcherFunction<T extends IConfiguration> = (details: IWatchDetails<T>) => void;
 /**
  * @internal
  */

package/types/JavaScriptSDK/AppInsightsCore.d.ts

@@ -1,3 +1,4 @@
+import { ITimerHandler } from "@nevware21/ts-utils";
 import { WatcherFunction } from "../Config/IDynamicWatcher";
 import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
 import { IAppInsightsCore, ILoadedPlugin } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
@@ -39,7 +40,7 @@ export declare class AppInsightsCore implements IAppInsightsCore {
     getWParam: () => number;
     constructor();
     initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
-    getTransmissionControls(): IChannelControls[][];
+    getChannels(): IChannelControls[];
     track(telemetryItem: ITelemetryItem): void;
     getProcessTelContext(): IProcessTelemetryContext;
     getNotifyMgr(): INotificationManager;
@@ -70,7 +71,7 @@ export declare class AppInsightsCore implements IAppInsightsCore {
     /**
      * Periodically check logger.queue for
      */
-    pollInternalLogs(eventName?: string): number;
+    pollInternalLogs(eventName?: string): ITimerHandler;
     /**
      * Periodically check logger.queue for
      */

package/types/JavaScriptSDK/Constants.d.ts

@@ -0,0 +1 @@
+export declare const ChannelControllerPriority = 500;

package/types/JavaScriptSDK/UnloadHandlerContainer.d.ts

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

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

@@ -31,4 +31,4 @@ export declare const enum eEventsDiscardedReason {
  * The EventsDiscardedReason enumeration contains a set of values that specify the reason for discarding an event.
  */
 export declare const EventsDiscardedReason: import("../JavaScriptSDK.Enums/EnumHelperFuncs").EnumValue<typeof eEventsDiscardedReason>;
-export declare type EventsDiscardedReason = number | eEventsDiscardedReason;
+export type EventsDiscardedReason = number | eEventsDiscardedReason;

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

@@ -13,7 +13,7 @@ export declare const enum eLoggingSeverity {
     WARNING = 2
 }
 export declare const LoggingSeverity: import("../JavaScriptSDK.Enums/EnumHelperFuncs").EnumValue<typeof eLoggingSeverity>;
-export declare type LoggingSeverity = number | eLoggingSeverity;
+export type LoggingSeverity = number | eLoggingSeverity;
 export declare const enum _eInternalMessageId {
     BrowserDoesNotSupportLocalStorage = 0,
     BrowserCannotReadLocalStorage = 1,
@@ -101,4 +101,4 @@ export declare const enum _eInternalMessageId {
     ConfigWatcherException = 107,
     DynamicConfigException = 108
 }
-export declare type _InternalMessageId = number | _eInternalMessageId;
+export type _InternalMessageId = number | _eInternalMessageId;

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

@@ -15,6 +15,7 @@ import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
 import { IDistributedTraceContext } from "./IDistributedTraceContext";
 import { ILegacyUnloadHook, IUnloadHook } from "./IUnloadHook";
 import { WatcherFunction } from "../Config/IDynamicWatcher";
+import { ITimerHandler } from "@nevware21/ts-utils";
 export interface ILoadedPlugin<T extends IPlugin> {
     plugin: T;
     /**
@@ -48,7 +49,7 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
      */
     isInitialized?: () => boolean;
     initialize(config: IConfiguration, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
-    getTransmissionControls(): IChannelControls[][];
+    getChannels(): IChannelControls[];
     track(telemetryItem: ITelemetryItem): void;
     /**
      * Get the current notification manager
@@ -81,7 +82,7 @@ export interface IAppInsightsCore extends IPerfManagerProvider {
      * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
      */
     addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler;
-    pollInternalLogs?(eventName?: string): number;
+    pollInternalLogs?(eventName?: string): ITimerHandler;
     stopPollingInternalLogs?(): void;
     /**
      * Return a new instance of the IProcessTelemetryContext for processing events

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

@@ -9,11 +9,11 @@ export interface IChannelControls extends ITelemetryPlugin {
     /**
      * Pause sending data
      */
-    pause(): void;
+    pause?(): void;
     /**
      * Resume sending data
      */
-    resume(): void;
+    resume?(): void;
     /**
      * 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
@@ -22,7 +22,7 @@ export interface IChannelControls extends ITelemetryPlugin {
      * @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: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
+    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
@@ -31,6 +31,6 @@ export interface IChannelControls extends ITelemetryPlugin {
      * @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?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
+    flush?(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
 }
 export declare const MinChannelPriorty: number;

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

@@ -3,7 +3,7 @@ import { IUnloadHook } from "./IUnloadHook";
  * A callback function that will be called for the wrapped instrumentation function
  * before the original function is executed.
  */
-export declare type InstrumentorHooksCallback = (funcArgs: IInstrumentCallDetails, ...orgArgs: any[]) => void;
+export type InstrumentorHooksCallback = (funcArgs: IInstrumentCallDetails, ...orgArgs: any[]) => void;
 /**
  * The callbacks to call for the instrumented function, you must provide at least the request and/or response callbacks, both are not required.
  * You must always supply the error callback

package/types/__DynamicConstants.d.ts

@@ -9,9 +9,12 @@ export declare const _DYN_ENUMERABLE = "enumerable";
 export declare const _DYN_APPLY = "apply";
 export declare const _DYN_PUSH = "push";
 export declare const _DYN_SPLICE = "splice";
+export declare const _DYN_CANCEL = "cancel";
 export declare const _DYN_INITIALIZE = "initialize";
 export declare const _DYN_IDENTIFIER = "identifier";
 export declare const _DYN_IS_INITIALIZED = "isInitialized";
+export declare const _DYN_GET_PLUGIN = "getPlugin";
+export declare const _DYN_POLL_INTERNAL_LOGS = "pollInternalLogs";
 export declare const _DYN_NAME = "name";
 export declare const _DYN_TIME = "time";
 export declare const _DYN_PROCESS_NEXT = "processNext";
@@ -22,10 +25,9 @@ export declare const _DYN_REMOVE_NOTIFICATION_2 = "removeNotificationListener";
 export declare const _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
 export declare const _DYN_ON_COMPLETE = "onComplete";
 export declare const _DYN_CALL = "call";
-export declare const _DYN_GET_PLUGIN = "getPlugin";
-export declare const _DYN_FLUSH = "flush";
 export declare const _DYN_VERSION = "version";
 export declare const _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
+export declare const _DYN_CREATE_NEW = "createNew";
 export declare const _DYN_TEARDOWN = "teardown";
 export declare const _DYN_MESSAGE_ID = "messageId";
 export declare const _DYN_MESSAGE = "message";
@@ -35,8 +37,6 @@ export declare const _DYN__DO_TEARDOWN = "_doTeardown";
 export declare const _DYN_UPDATE = "update";
 export declare const _DYN_GET_NEXT = "getNext";
 export declare const _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
-export declare const _DYN_CREATE_NEW = "createNew";
-export declare const _DYN_CONFIG = "config";
 export declare const _DYN_USER_AGENT = "userAgent";
 export declare const _DYN_SPLIT = "split";
 export declare const _DYN_NODE_TYPE = "nodeType";