@microsoft/applicationinsights-core-js 3.0.0-beta.2210-01 → 3.0.0-beta.2210-03

package/src/JavaScriptSDK/BaseTelemetryPlugin.ts

@@ -3,13 +3,15 @@
 "use strict";
 
 import dynamicProto from "@microsoft/dynamicproto-js";
-import { arrForEach, isArray, isFunction, isNullOrUndefined } from "@nevware21/ts-utils";
+import { arrAppend, arrForEach, dumpObj, isFunction } from "@nevware21/ts-utils";
+import { createDynamicConfig } from "../Config/DynamicConfig";
+import { IConfigDefaults } from "../Config/IConfigDefaults";
+import { _eInternalMessageId, eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
 import { TelemetryUnloadReason } from "../JavaScriptSDK.Enums/TelemetryUnloadReason";
 import { TelemetryUpdateReason } from "../JavaScriptSDK.Enums/TelemetryUpdateReason";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
-import { IInstrumentHook } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
 import {
     IProcessTelemetryContext, IProcessTelemetryUnloadContext, IProcessTelemetryUpdateContext
 } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
@@ -18,7 +20,9 @@ import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetr
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
 import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
 import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
-import { proxyFunctionAs, setValue } from "./HelperFuncs";
+import { ILegacyUnloadHook, IUnloadHook } from "../JavaScriptSDK.Interfaces/IUnloadHook";
+import { _throwInternal } from "./DiagnosticLogger";
+import { isNotNullOrUndefined, proxyFunctionAs } from "./HelperFuncs";
 import { STR_EXTENSION_CONFIG } from "./InternalConstants";
 import {
     createProcessTelemetryContext, createProcessTelemetryUnloadContext, createProcessTelemetryUpdateContext
@@ -27,6 +31,11 @@ import { IUnloadHandlerContainer, UnloadHandler, createUnloadHandlerContainer }
 
 let strGetPlugin = "getPlugin";
 
+const defaultValues: IConfigDefaults<IConfiguration> = {
+    [STR_EXTENSION_CONFIG]: { isVal: isNotNullOrUndefined, v: []}
+};
+
+
 /**
  * BaseTelemetryPlugin provides a basic implementation of the ITelemetryPlugin interface so that plugins
  * can avoid implementation the same set of boiler plate code as well as provide a base
@@ -109,7 +118,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
         let _rootCtx: IProcessTelemetryContext; // Used as the root context, holding the current config and initialized core
         let _nextPlugin: ITelemetryPlugin | ITelemetryPluginChain; // Used for backward compatibility where plugins don't call the main pipeline
         let _unloadHandlerContainer: IUnloadHandlerContainer;
-        let _hooks: IInstrumentHook[];
+        let _hooks: Array<ILegacyUnloadHook| IUnloadHook>;
 
         _initDefaults();
 
@@ -146,9 +155,14 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
                         let oldHooks = _hooks;
                         _hooks = [];
 
-                        // Remove all instrumentation hooks
+                        // Remove all registered unload hooks
                         arrForEach(oldHooks, (fn) => {
-                            fn.rm();
+                            // allow either rm or remove callback function
+                            try{
+                                ((fn as IUnloadHook).rm || (fn as ILegacyUnloadHook).remove).call(fn);
+                            } catch (e) {
+                                _throwInternal(theUnloadCtx.diagLog(), eLoggingSeverity.WARNING, _eInternalMessageId.PluginException, "Unloading:" + dumpObj(e));
+                            }
                         });
 
                         if (result === true) {
@@ -201,13 +215,9 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
                 return result;
             };
         
-            _self._addHook = (hooks: IInstrumentHook | IInstrumentHook[]) => {
+            _self._addHook = (hooks: IUnloadHook | IUnloadHook[] | ILegacyUnloadHook | ILegacyUnloadHook[]) => {
                 if (hooks) {
-                    if (isArray(hooks)) {
-                        _hooks = _hooks.concat(hooks);
-                    } else {
-                        _hooks.push(hooks);
-                    }
+                    arrAppend(_hooks, hooks);
                 }
             };
 
@@ -267,10 +277,8 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
         }
 
         function _setDefaults(config: IConfiguration, core: IAppInsightsCore, pluginChain: ITelemetryPluginChain) {
-            if (config) {
-                // Make sure the extensionConfig exists
-                setValue(config, STR_EXTENSION_CONFIG, [], null, isNullOrUndefined);
-            }
+            // Make sure the extensionConfig exists and the config is dynamic
+            createDynamicConfig(config, defaultValues, core.logger);
     
             if (!pluginChain && core) {
                 // Get the first plugin from the core
@@ -339,7 +347,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      * Add this hook so that it is automatically removed during unloading
      * @param hooks - The single hook or an array of IInstrumentHook objects
      */
-    protected _addHook(hooks: IInstrumentHook | IInstrumentHook[]): void {
+    protected _addHook(hooks: IUnloadHook | IUnloadHook[] | ILegacyUnloadHook | ILegacyUnloadHook[]): void {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
     }
 }

package/src/JavaScriptSDK/CookieMgr.ts

@@ -1,9 +1,12 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 import {
-    arrForEach, dumpObj, getDocument, getNavigator, isArray, isFunction, isNullOrUndefined, isString, isTruthy, isUndefined, objForEachKey,
-    strEndsWith, strTrim
+    arrForEach, dumpObj, getDocument, getNavigator, isArray, isFunction, isNullOrUndefined, isString, isTruthy, isUndefined, objDeepFreeze,
+    objForEachKey, strEndsWith, strTrim
 } from "@nevware21/ts-utils";
+import { applyDefaults } from "../Config/ConfigDefaults";
+import { createDynamicConfig, onConfigChange } from "../Config/DynamicConfig";
+import { IConfigDefaults } from "../Config/IConfigDefaults";
 import { _eInternalMessageId, eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
@@ -12,13 +15,12 @@ import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger
 import { _throwInternal } from "./DiagnosticLogger";
 import { getLocation, isIE } from "./EnvUtils";
 import { dateNow, getExceptionName, isNotNullOrUndefined, setValue, strContains } from "./HelperFuncs";
-import { STR_EMPTY } from "./InternalConstants";
+import { STR_DOMAIN, STR_EMPTY, STR_PATH, UNDEFINED_VALUE } from "./InternalConstants";
 
 const strToGMTString = "toGMTString";
 const strToUTCString = "toUTCString";
 const strCookie = "cookie";
 const strExpires = "expires";
-const strEnabled = "enabled";
 const strIsCookieUseDisabled = "isCookieUseDisabled";
 const strDisableCookiesUsage = "disableCookiesUsage";
 const strConfigCookieMgr = "_ckMgr";
@@ -30,6 +32,29 @@ let _doc = getDocument();
 let _cookieCache = {};
 let _globalCookieConfig = {};
 
+// `isCookieUseDisabled` is deprecated, so explicitly casting as a key of IConfiguration to avoid typing error
+// when both isCookieUseDisabled and disableCookiesUsage are used disableCookiesUsage will take precedent, which is
+// why its listed first
+
+const defaultConfig: IConfigDefaults<ICookieMgrConfig> = objDeepFreeze({
+    [STR_DOMAIN]: { fb: "cookieDomain", dfVal: isNotNullOrUndefined },
+    path: { fb: "cookiePath", dfVal: isNotNullOrUndefined },
+    enabled: UNDEFINED_VALUE
+});
+
+/**
+ * Set the supported dynamic config values as undefined (or an empty object) so that
+ * any listeners will be informed of any changes.
+ * Explicitly NOT including the deprecated `isCookieUseDisabled` as we don't want to support
+ * the v1 deprecated field as dynamic for updates
+ */
+const rootDefaultConfig = {
+    cookieCfg: {},
+    cookieDomain: UNDEFINED_VALUE,
+    cookiePath: UNDEFINED_VALUE,
+    [strDisableCookiesUsage]: UNDEFINED_VALUE
+};
+
 /**
  * @ignore
  * DO NOT USE or export from the module, this is exposed as public to support backward compatibility of previous static utility methods only.
@@ -39,7 +64,7 @@ let _globalCookieConfig = {};
  * Example, if you are using a shared component that is also using Application Insights you will affect their cookie handling.
  * @param logger - The DiagnosticLogger to use for reporting errors.
  */
-export function _gblCookieMgr(config?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr {
+function _gblCookieMgr(config?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr {
     // Stash the global instance against the BaseCookieMgr class
     let inst = createCookieMgr[strConfigCookieMgr] || _globalCookieConfig[strConfigCookieMgr];
     if (!inst) {
@@ -60,28 +85,6 @@ function _isMgrEnabled(cookieMgr: ICookieMgr) {
     return true;
 }
 
-function _createCookieMgrConfig(rootConfig: IConfiguration): ICookieMgrConfig {
-    let cookieMgrCfg = rootConfig.cookieCfg = rootConfig.cookieCfg || {};
-
-    // Sets the values from the root config if not already present on the cookieMgrCfg
-    setValue(cookieMgrCfg, "domain", rootConfig.cookieDomain, isNotNullOrUndefined, isNullOrUndefined);
-    setValue(cookieMgrCfg, "path", rootConfig.cookiePath || "/", null, isNullOrUndefined);
-    if (isNullOrUndefined(cookieMgrCfg[strEnabled])) {
-        // Set the enabled from the provided setting or the legacy root values
-        let cookieEnabled: boolean;
-        if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {
-            cookieEnabled = !rootConfig[strIsCookieUseDisabled];
-        }
-        if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
-            cookieEnabled = !rootConfig[strDisableCookiesUsage];
-        }
-
-        cookieMgrCfg[strEnabled] = cookieEnabled;
-    }
-
-    return cookieMgrCfg;
-}
-
 function _isIgnoredCookie(cookieMgrCfg: ICookieMgrConfig, name: string) {
     if (name && cookieMgrCfg && isArray(cookieMgrCfg.ignoreCookies)) {
         return cookieMgrCfg.ignoreCookies.indexOf(name) !== -1;
@@ -114,7 +117,7 @@ export function safeGetCookieMgr(core: IAppInsightsCore, config?: IConfiguration
         cookieMgr = core.getCookieMgr();
     } else if (config) {
         let cookieCfg = config.cookieCfg;
-        if (cookieCfg[strConfigCookieMgr]) {
+        if (cookieCfg && cookieCfg[strConfigCookieMgr]) {
             cookieMgr = cookieCfg[strConfigCookieMgr];
         } else {
             cookieMgr = createCookieMgr(config);
@@ -130,12 +133,56 @@ export function safeGetCookieMgr(core: IAppInsightsCore, config?: IConfiguration
 }
 
 export function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr {
-    let cookieMgrConfig = _createCookieMgrConfig(rootConfig || _globalCookieConfig);
+    let cookieMgrConfig: ICookieMgrConfig;
+    let _path: string;
+    let _domain: string;
 
-    let _path = cookieMgrConfig.path || "/";
-    let _domain = cookieMgrConfig.domain;
     // Explicitly checking against false, so that setting to undefined will === true
-    let _enabled = cookieMgrConfig[strEnabled] !== false;
+    let _enabled: boolean;
+    let _getCookieFn: (name: string) => string;
+    let _setCookieFn: (name: string, cookieValue: string) => void;
+    let _delCookieFn: (name: string, cookieValue: string) => void;
+
+    // Make sure the root config is dynamic as it may be the global config
+    rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger).cfg;
+
+    // Will get recalled if the referenced configuration is changed
+    onConfigChange(rootConfig, (details) => {
+
+        // Make sure the root config has all of the the defaults to the root config to ensure they are dynamic
+        applyDefaults(details.cfg, rootDefaultConfig);
+
+        // Create and apply the defaults to the cookieCfg element
+        cookieMgrConfig = applyDefaults(details.cfg.cookieCfg, defaultConfig);
+        let isEnabled = cookieMgrConfig.enabled;
+        if (isNullOrUndefined(isEnabled)) {
+            // Set the enabled from the provided setting or the legacy root values
+            let cookieEnabled: boolean;
+
+            // This field is deprecated and dynamic updates will not be fully supported
+            if (!isUndefined(rootConfig[strIsCookieUseDisabled])) {
+                cookieEnabled = !rootConfig[strIsCookieUseDisabled];
+            }
+
+            // If this value is defined it takes precedent over the above
+            if (!isUndefined(rootConfig[strDisableCookiesUsage])) {
+                cookieEnabled = !rootConfig[strDisableCookiesUsage];
+            }
+
+            // Not setting the cookieMgrConfig.enabled as that will update (set) the global dynamic config
+            // So future "updates" then may not be as expected
+            isEnabled = cookieEnabled;
+        }
+
+        _path = cookieMgrConfig.path || "/";
+        _domain = cookieMgrConfig.domain;
+        // Explicitly checking against false, so that setting to undefined will === true
+        _enabled = isEnabled !== false;
+
+        _getCookieFn = cookieMgrConfig.getCookie || _getCookieValue;
+        _setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
+        _delCookieFn = cookieMgrConfig.delCookie || _setCookieValue;
+    }, logger);
 
     let cookieMgr: ICookieMgr = {
         isEnabled: () => {
@@ -167,7 +214,7 @@ export function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosti
                 }
 
                 // Only update domain if not already present (isUndefined) and the value is truthy (not null, undefined or empty string)
-                setValue(values, "domain",  domain || _domain, isTruthy, isUndefined);
+                setValue(values, STR_DOMAIN,  domain || _domain, isTruthy, isUndefined);
             
                 if (!isNullOrUndefined(maxAgeSec)) {
                     const _isIE = isIE();
@@ -206,10 +253,10 @@ export function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosti
                     }
                 }
             
-                setValue(values, "path", path || _path, null, isUndefined);
+                setValue(values, STR_PATH, path || _path, null, isUndefined);
             
-                let setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
-                setCookieFn(name, _formatCookieValue(theValue, values));
+                //let setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
+                _setCookieFn(name, _formatCookieValue(theValue, values));
                 result = true;
             }
 
@@ -218,7 +265,7 @@ export function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosti
         get: (name: string): string => {
             let value = STR_EMPTY
             if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
-                value = (cookieMgrConfig.getCookie || _getCookieValue)(name);
+                value = _getCookieFn(name);
             }
 
             return value;
@@ -237,7 +284,7 @@ export function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosti
             if (areCookiesSupported(logger)) {
                 // Setting the expiration date in the past immediately removes the cookie
                 let values = {
-                    ["path"]: path ? path : "/",
+                    [STR_PATH]: path ? path : "/",
                     [strExpires]: "Thu, 01 Jan 1970 00:00:01 GMT"
                 }
 
@@ -246,8 +293,8 @@ export function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosti
                     values["max-age"] = "0"
                 }
 
-                let delCookie = cookieMgrConfig.delCookie || _setCookieValue;
-                delCookie(name, _formatCookieValue(STR_EMPTY, values));
+                // let delCookie = cookieMgrConfig.delCookie || _setCookieValue;
+                _delCookieFn(name, _formatCookieValue(STR_EMPTY, values));
                 result = true;
             }
 
@@ -258,7 +305,7 @@ export function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosti
     // Associated this cookie manager with the config
     cookieMgr[strConfigCookieMgr] = cookieMgr;
     
-    return cookieMgr
+    return cookieMgr;
 }
 
 /*

package/src/JavaScriptSDK/CoreUtils.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 "use strict";
 import { strShimUndefined } from "@microsoft/applicationinsights-shims";
+import { strSubstr, strSubstring } from "@nevware21/ts-utils";
 import { getPerformance } from "./EnvUtils";
 import { dateNow } from "./HelperFuncs";
 import { STR_EMPTY } from "./InternalConstants";
@@ -13,7 +14,7 @@ export const Undefined = strShimUndefined;
 export function newGuid(): string {
     const uuid = generateW3CId();
 
-    return uuid.substring(0, 8) + "-" + uuid.substring(8, 12) + "-" + uuid.substring(12, 16) + "-" + uuid.substring(16, 20) + "-" + uuid.substring(20);
+    return strSubstring(uuid, 0, 8) + "-" + strSubstring(uuid, 8, 12) + "-" + strSubstring(uuid, 12, 16) + "-" + strSubstring(uuid, 16, 20) + "-" + strSubstring(uuid, 20);
 }
 
 /**
@@ -39,7 +40,7 @@ export function strEndsWith(value: string, search: string) {
     if (value && search) {
         let len = value.length;
         let start = len - search.length;
-        return value.substring(start >= 0 ? start : 0, len) === search;
+        return strSubstring(value, start >= 0 ? start : 0, len) === search;
     }
 
     return false;
@@ -68,5 +69,5 @@ export function generateW3CId(): string {
 
     // "Set the two most significant bits (bits 6 and 7) of the clock_seq_hi_and_reserved to zero and one, respectively"
     const clockSequenceHi = hexValues[8 + (random32() & 0x03) | 0];
-    return oct.substr(0, 8) + oct.substr(9, 4) + "4" + oct.substr(13, 3) + clockSequenceHi + oct.substr(16, 3) + oct.substr(19, 12);
+    return strSubstr(oct, 0, 8) + strSubstr(oct, 9, 4) + "4" + strSubstr(oct, 13, 3) + clockSequenceHi +strSubstr(oct, 16, 3) + strSubstr(oct, 19, 12);
 }

package/src/JavaScriptSDK/DiagnosticLogger.ts

@@ -3,13 +3,14 @@
 "use strict"
 import dynamicProto from "@microsoft/dynamicproto-js";
 import { dumpObj, isFunction, isUndefined } from "@nevware21/ts-utils";
+import { createDynamicConfig } from "../Config/DynamicConfig";
 import { LoggingSeverity, _InternalMessageId, _eInternalMessageId, eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
+import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
 import { getDebugExt } from "./DbgExtensionUtils";
 import { getConsole, getJSON, hasJSON } from "./EnvUtils";
-import { getCfgValue } from "./HelperFuncs";
 import { STR_EMPTY, STR_ERROR_TO_CONSOLE, STR_WARN_TO_CONSOLE } from "./InternalConstants";
 
 /**
@@ -27,6 +28,18 @@ const AiUserActionablePrefix = "AI: ";
  */
 const AIInternalMessagePrefix = "AITR_";
 
+/**
+ * Holds the current logger which will be used as the default if no logger is available
+ */
+let _currentLogger: IDiagnosticLogger = null;
+
+const defaultValues = {
+    loggingLevelConsole: 0,
+    loggingLevelTelemetry: 1,
+    maxMessageLimit: 25,
+    enableDebugExceptions: false
+}
+
 function _sanitizeDiagnosticText(text: string) {
     if (text) {
         return "\"" + text.replace(/\"/g, STR_EMPTY) + "\"";
@@ -117,8 +130,8 @@ export class DiagnosticLogger implements IDiagnosticLogger {
             
             /**
              * This method will throw exceptions in debug mode or attempt to log the error as a console warning.
-             * @param severity {LoggingSeverity} - The severity of the log message
-             * @param message {_InternalLogMessage} - The log message.
+             * @param severity - {LoggingSeverity} - The severity of the log message
+             * @param message - {_InternalLogMessage} - The log message.
              */
             _self.throwInternal = (severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct = false) => {
                 const message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
@@ -154,7 +167,7 @@ export class DiagnosticLogger implements IDiagnosticLogger {
 
             /**
              * This will write a warning to the console if possible
-             * @param message {string} - The warning message
+             * @param message - {string} - The warning message
              */
             _self.warnToConsole = (message: string) => {
                 _logToConsole("warn", message);
@@ -163,7 +176,7 @@ export class DiagnosticLogger implements IDiagnosticLogger {
 
             /**
              * This will write an error to the console if possible
-             * @param message {string} - The error message
+             * @param message - {string} - The error message
              */
             _self.errorToConsole = (message: string) => {
                 _logToConsole("error", message);
@@ -180,11 +193,11 @@ export class DiagnosticLogger implements IDiagnosticLogger {
 
             /**
              * Logs a message to the internal queue.
-             * @param severity {LoggingSeverity} - The severity of the log message
-             * @param message {_InternalLogMessage} - The message to log.
+             * @param severity - {LoggingSeverity} - The severity of the log message
+             * @param message - {_InternalLogMessage} - The message to log.
              */
             _self.logInternalMessage = _logInternalMessage;
-            
+
             function _logInternalMessage(severity: LoggingSeverity, message: _InternalLogMessage): void {
                 if (_areInternalMessagesThrottled()) {
                     return;
@@ -224,10 +237,15 @@ export class DiagnosticLogger implements IDiagnosticLogger {
             }
 
             function _setDefaultsFromConfig(config: IConfiguration) {
-                _loggingLevelConsole = getCfgValue(config.loggingLevelConsole, 0);
-                _loggingLevelTelemetry = getCfgValue(config.loggingLevelTelemetry, 1)
-                _maxInternalMessageLimit = getCfgValue(config.maxMessageLimit, 25);
-                _enableDebugExceptions =  getCfgValue(config.enableDebugExceptions, false);
+                // make sure the config is dynamic
+                let handler = createDynamicConfig(config, defaultValues, _self);
+                handler.watch((details) => {
+                    let config = details.cfg;
+                    _loggingLevelConsole = config.loggingLevelConsole;
+                    _loggingLevelTelemetry = config.loggingLevelTelemetry;
+                    _maxInternalMessageLimit = config.maxMessageLimit;
+                    _enableDebugExceptions =  config.enableDebugExceptions;
+                });
             }
 
             function _areInternalMessagesThrottled(): boolean {
@@ -281,8 +299,8 @@ export class DiagnosticLogger implements IDiagnosticLogger {
 
     /**
      * This method will throw exceptions in debug mode or attempt to log the error as a console warning.
-     * @param severity {LoggingSeverity} - The severity of the log message
-     * @param message {_InternalLogMessage} - The log message.
+     * @param severity - {LoggingSeverity} - The severity of the log message
+     * @param message - {_InternalLogMessage} - The log message.
      */
     public throwInternal(severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct = false) {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
@@ -290,7 +308,7 @@ export class DiagnosticLogger implements IDiagnosticLogger {
 
     /**
      * This will write a warning to the console if possible
-     * @param message {string} - The warning message
+     * @param message - {string} - The warning message
      */
     public warnToConsole(message: string) {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
@@ -298,7 +316,7 @@ export class DiagnosticLogger implements IDiagnosticLogger {
 
     /**
      * This will write an error to the console if possible
-     * @param message {string} - The warning message
+     * @param message - {string} - The warning message
      */
     public errorToConsole(message: string) {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
@@ -313,12 +331,16 @@ export class DiagnosticLogger implements IDiagnosticLogger {
 
     /**
      * Logs a message to the internal queue.
-     * @param severity {LoggingSeverity} - The severity of the log message
-     * @param message {_InternalLogMessage} - The message to log.
+     * @param severity - {LoggingSeverity} - The severity of the log message
+     * @param message - {_InternalLogMessage} - The message to log.
      */
     public logInternalMessage(severity: LoggingSeverity, message: _InternalLogMessage): void {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
     }
+
+    public update(updateState: ITelemetryUpdateState): void {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+    }
 }
 
 function _getLogger(logger: IDiagnosticLogger) {
@@ -331,8 +353,8 @@ function _getLogger(logger: IDiagnosticLogger) {
  * 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.
+ * @param severity - {LoggingSeverity} - The severity of the log message
+ * @param message - {_InternalLogMessage} - The log message.
  */
 export function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct = false) {
     _getLogger(logger).throwInternal(severity, msgId, msg, properties, isUserAct);
@@ -341,7 +363,7 @@ export function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSever
 /**
  * This is a helper method which will call warnToConsole on the passed logger with the provided message.
  * @param logger - The Diagnostic Logger instance to use.
- * @param message {_InternalLogMessage} - The log message.
+ * @param message - {_InternalLogMessage} - The log message.
  */
 export function _warnToConsole(logger: IDiagnosticLogger, message: string) {
     _getLogger(logger).warnToConsole(message);
@@ -350,8 +372,8 @@ export function _warnToConsole(logger: IDiagnosticLogger, message: string) {
 /**
  * Logs a message to the internal queue.
  * @param logger - The Diagnostic Logger instance to use.
- * @param severity {LoggingSeverity} - The severity of the log message
- * @param message {_InternalLogMessage} - The message to log.
+ * @param severity - {LoggingSeverity} - The severity of the log message
+ * @param message - {_InternalLogMessage} - The message to log.
  */
 export function _logInternalMessage(logger: IDiagnosticLogger, severity: LoggingSeverity, message: _InternalLogMessage) {
     _getLogger(logger).logInternalMessage(severity, message);