@microsoft/applicationinsights-properties-js 3.0.0-beta.2209-03 → 3.0.0-beta.2210-02

package/src/Context/Session.ts

@@ -8,20 +8,23 @@ import {
     getExceptionName, isFunction, newId, safeGetCookieMgr, safeGetLogger
 } from "@microsoft/applicationinsights-core-js";
 
-const cookieNameConst = "ai_session";
+const SESSION_COOKIE_NAME = "ai_session";
+const ACQUISITION_SPAN = 86400000; // 24 hours in ms
+const RENEWAL_SPAN = 1800000; // 30 minutes in ms
+const COOKIE_UPDATE_INTERVAL = 60000 // 1 minute in ms
 
 export interface ISessionConfig {
-    sessionRenewalMs?: () => number;
-    sessionExpirationMs?: () => number;
-    namePrefix?: () => string;
-    sessionCookiePostfix?: () => string;
-    idLength?: () => number;
-    getNewId?: () => (idLength?: number) => string;
+    readonly sessionRenewalMs?: number;
+    readonly sessionExpirationMs?: number;
+    readonly namePrefix?: string;
+    readonly sessionCookiePostfix?: string;
+    readonly idLength?: number;
+    readonly getNewId?: (idLength?: number) => string;
 
     /**
      * @deprecated Avoid using this value to override the cookie manager cookie domain.
      */
-    cookieDomain?: () => string;
+    cookieDomain?: string;
 }
 
 export class Session implements ISession {
@@ -46,18 +49,16 @@ export class Session implements ISession {
 
 export class _SessionManager {
 
-    public static acquisitionSpan = 86400000; // 24 hours in ms
-    public static renewalSpan = 1800000; // 30 minutes in ms
-    public static cookieUpdateInterval = 60000 // 1 minute in ms
     public automaticSession: Session;
-    public config: ISessionConfig;
 
     constructor(config: ISessionConfig, core?: IAppInsightsCore) {
         let self = this;
-        let _storageNamePrefix: () => string;
+        let _storageNamePrefix: string;
         let _cookieUpdatedTimestamp: number;
         let _logger: IDiagnosticLogger = safeGetLogger(core);
         let _cookieManager: ICookieMgr = safeGetCookieMgr(core);
+        let _sessionExpirationMs: number;
+        let _sessionRenewalMs: number;
 
         dynamicProto(_SessionManager, self, (_self) => {
    
@@ -65,21 +66,13 @@ export class _SessionManager {
                 config = ({} as any);
             }
     
-            if (!isFunction(config.sessionExpirationMs)) {
-                config.sessionExpirationMs = () => _SessionManager.acquisitionSpan;
-            }
-    
-            if (!isFunction(config.sessionRenewalMs)) {
-                config.sessionRenewalMs = () => _SessionManager.renewalSpan;
-            }
+            _sessionExpirationMs = config.sessionExpirationMs || ACQUISITION_SPAN;
+            _sessionRenewalMs = config.sessionRenewalMs || RENEWAL_SPAN;
     
-            _self.config = config;
             // sessionCookiePostfix takes the preference if it is configured, otherwise takes namePrefix if configured.
-            const sessionCookiePostfix = (_self.config.sessionCookiePostfix && _self.config.sessionCookiePostfix()) ?
-                _self.config.sessionCookiePostfix() :
-                ((_self.config.namePrefix && _self.config.namePrefix()) ? _self.config.namePrefix() : "");
+            const sessionCookiePostfix = config.sessionCookiePostfix || config.namePrefix || "";
 
-            _storageNamePrefix = () => cookieNameConst + sessionCookiePostfix;
+            _storageNamePrefix = SESSION_COOKIE_NAME + sessionCookiePostfix;
     
             _self.automaticSession = new Session();
 
@@ -94,15 +87,12 @@ export class _SessionManager {
                     isExpired = !_initializeAutomaticSession(session, nowMs);
                 }
 
-                const sessionExpirationMs = _self.config.sessionExpirationMs();
-
-                if (!isExpired && sessionExpirationMs > 0) {
-                    const sessionRenewalMs = _self.config.sessionRenewalMs();
+                if (!isExpired && _sessionExpirationMs > 0) {
                     const timeSinceAcqMs = nowMs - session.acquisitionDate;
                     const timeSinceRenewalMs = nowMs - session.renewalDate;
-                    isExpired = timeSinceAcqMs < 0 || timeSinceRenewalMs < 0;         // expired if the acquisition or last renewal are in the future
-                    isExpired = isExpired || timeSinceAcqMs > sessionExpirationMs;    // expired if the time since acquisition is more than session Expiration
-                    isExpired = isExpired || timeSinceRenewalMs > sessionRenewalMs;   // expired if the time since last renewal is more than renewal period
+                    isExpired = timeSinceAcqMs < 0 || timeSinceRenewalMs < 0;           // expired if the acquisition or last renewal are in the future
+                    isExpired = isExpired || timeSinceAcqMs > _sessionExpirationMs;     // expired if the time since acquisition is more than session Expiration
+                    isExpired = isExpired || timeSinceRenewalMs > _sessionRenewalMs;    // expired if the time since last renewal is more than renewal period
                 }
         
                 // renew if acquisitionSpan or renewalSpan has elapsed
@@ -111,7 +101,7 @@ export class _SessionManager {
                     _renew(nowMs);
                 } else {
                     // do not update the cookie more often than cookieUpdateInterval
-                    if (!_cookieUpdatedTimestamp || nowMs - _cookieUpdatedTimestamp > _SessionManager.cookieUpdateInterval) {
+                    if (!_cookieUpdatedTimestamp || nowMs - _cookieUpdatedTimestamp > COOKIE_UPDATE_INTERVAL) {
                         _setCookie(session, nowMs);
                     }
                 }
@@ -134,7 +124,7 @@ export class _SessionManager {
              */
             function _initializeAutomaticSession(session: ISession, now: number): boolean {
                 let isValid = false;
-                const cookieValue = _cookieManager.get(_storageNamePrefix());
+                const cookieValue = _cookieManager.get(_storageNamePrefix);
                 if (cookieValue && isFunction(cookieValue.split)) {
                     isValid = _initializeAutomaticSessionWithData(session, cookieValue);
                 } else {
@@ -142,7 +132,7 @@ export class _SessionManager {
                     // This can happen if the session expired or the user actively deleted the cookie
                     // We only want to recover data if the cookie is missing from expiry. We should respect the user's wishes if the cookie was deleted actively.
                     // The User class handles this for us and deletes our local storage object if the persistent user cookie was removed.
-                    const storageValue = utlGetLocalStorage(_logger, _storageNamePrefix());
+                    const storageValue = utlGetLocalStorage(_logger, _storageNamePrefix);
                     if (storageValue) {
                         isValid = _initializeAutomaticSessionWithData(session, storageValue);
                     }
@@ -155,7 +145,7 @@ export class _SessionManager {
              * Extract id, acquisitionDate, and renewalDate from an ai_session payload string and
              * use this data to initialize automaticSession.
              *
-             * @param {string} sessionData - The string stored in an ai_session cookie or local storage backup
+             * @param sessionData - The string stored in an ai_session cookie or local storage backup
              * @returns true if values set otherwise false
              */
             function _initializeAutomaticSessionWithData(session: ISession, sessionData: string) {
@@ -197,9 +187,8 @@ export class _SessionManager {
             }
         
             function _renew(nowMs: number) {
-                let theConfig = (_self.config ||{});
-                let getNewId = (theConfig.getNewId ? theConfig.getNewId() : null) || newId;
-                _self.automaticSession.id = getNewId(theConfig.idLength ? theConfig.idLength() : 22);
+                let getNewId = config.getNewId || newId;
+                _self.automaticSession.id = getNewId(config.idLength || 22);
                 _self.automaticSession.acquisitionDate = nowMs;
         
                 _setCookie(_self.automaticSession, nowMs);
@@ -217,12 +206,11 @@ export class _SessionManager {
                 let acq = session.acquisitionDate;
                 session.renewalDate = nowMs;
 
-                let config = _self.config;
-                let renewalPeriodMs = config.sessionRenewalMs();
+                let renewalPeriodMs = _sessionRenewalMs;
 
                 // Set cookie to expire after the session expiry time passes or the session renewal deadline, whichever is sooner
                 // Expiring the cookie will cause the session to expire even if the user isn't on the page
-                const acqTimeLeftMs = (acq + config.sessionExpirationMs()) - nowMs;
+                const acqTimeLeftMs = (acq +_sessionExpirationMs) - nowMs;
                 const cookie = [session.id, acq, nowMs];
                 let maxAgeSec = 0;
         
@@ -232,12 +220,12 @@ export class _SessionManager {
                     maxAgeSec = renewalPeriodMs / 1000;
                 }
         
-                const cookieDomain = config.cookieDomain ? config.cookieDomain() : null;
+                const cookieDomain = config.cookieDomain || null;
 
                 // if sessionExpirationMs is set to 0, it means the expiry is set to 0 for this session cookie
                 // A cookie with 0 expiry in the session cookie will never expire for that browser session.  If the browser is closed the cookie expires.
                 // Depending on the browser, another instance does not inherit this cookie, however, another tab will
-                _cookieManager.set(_storageNamePrefix(), cookie.join("|"), config.sessionExpirationMs() > 0 ? maxAgeSec : null, cookieDomain);
+                _cookieManager.set(_storageNamePrefix, cookie.join("|"), _sessionExpirationMs > 0 ? maxAgeSec : null, cookieDomain);
                 _cookieUpdatedTimestamp = nowMs;
             }
         
@@ -245,7 +233,7 @@ export class _SessionManager {
                 // Keep data in local storage to retain the last session id, allowing us to cleanly end the session when it expires
                 // Browsers that don't support local storage won't be able to end sessions cleanly from the client
                 // The server will notice this and end the sessions itself, with loss of accurate session duration
-                utlSetLocalStorage(_logger, _storageNamePrefix(), [guid, acq, renewal].join("|"));
+                utlSetLocalStorage(_logger, _storageNamePrefix, [guid, acq, renewal].join("|"));
             }
         });
     }

package/src/Context/User.ts

@@ -4,9 +4,11 @@
 import dynamicProto from "@microsoft/dynamicproto-js";
 import { IUserContext, utlRemoveStorage } from "@microsoft/applicationinsights-common";
 import {
-    IAppInsightsCore, ICookieMgr, _eInternalMessageId, _throwInternal, eLoggingSeverity, newId, safeGetCookieMgr, safeGetLogger, toISOString
+    IAppInsightsCore, ICookieMgr, _eInternalMessageId, _throwInternal, eLoggingSeverity, newId, onConfigChange, safeGetCookieMgr,
+    safeGetLogger, toISOString
 } from "@microsoft/applicationinsights-core-js";
-import { ITelemetryConfig } from "../Interfaces/ITelemetryConfig";
+import { objDefineProp } from "@nevware21/ts-utils";
+import { IPropertiesConfig } from "../Interfaces/IPropertiesConfig";
 
 function _validateUserInput(id: string): boolean {
     // Validate:
@@ -30,7 +32,7 @@ export class User implements IUserContext {
     /**
      * The telemetry configuration.
      */
-    public config: ITelemetryConfig;
+    public readonly config: IPropertiesConfig;
 
     /**
      * The user ID.
@@ -67,32 +69,72 @@ export class User implements IUserContext {
      */
     public isUserCookieSet = false;
 
-    constructor(config: ITelemetryConfig, core: IAppInsightsCore) {
+    constructor(config: IPropertiesConfig, core: IAppInsightsCore) {
         let _logger = safeGetLogger(core);
         let _cookieManager: ICookieMgr = safeGetCookieMgr(core);
-        let _storageNamePrefix: () => string;
+        let _storageNamePrefix: string;
 
         dynamicProto(User, this, (_self) => {
-            _self.config = config;
-            const userCookiePostfix = (_self.config.userCookiePostfix && _self.config.userCookiePostfix()) ? _self.config.userCookiePostfix() : "";
-            _storageNamePrefix = () => User.userCookieName + userCookiePostfix;
-            
-            // get userId or create new one if none exists
-            const cookie = _cookieManager.get(_storageNamePrefix());
-            if (cookie) {
-                _self.isNewUser = false;
-                const params = cookie.split(User.cookieSeparator);
-                if (params.length > 0) {
-                    _self.id = params[0];
-                    // we already have a cookie
-                    _self.isUserCookieSet = !!_self.id;
+            // Define _self.config
+            objDefineProp(_self, "config", {
+                configurable: true,
+                enumerable: true,
+                get: () => config
+            });
+
+            onConfigChange(config, () => {
+
+                const userCookiePostfix = config.userCookiePostfix || "";
+                _storageNamePrefix = User.userCookieName + userCookiePostfix;
+    
+                // get userId or create new one if none exists
+                const cookie = _cookieManager.get(_storageNamePrefix);
+                if (cookie) {
+                    _self.isNewUser = false;
+                    const params = cookie.split(User.cookieSeparator);
+                    if (params.length > 0) {
+                        _self.id = params[0];
+                        // we already have a cookie
+                        _self.isUserCookieSet = !!_self.id;
+                    }
                 }
-            }
+
+                if (!_self.id) {
+                    _self.id = _generateNewId();
+                    const newCookie = _generateNewCookie(_self.id);
+    
+                    _setUserCookie(newCookie.join(User.cookieSeparator));
+    
+                    // If we have an config.namePrefix() + ai_session in local storage this means the user actively removed our cookies.
+                    // We should respect their wishes and clear ourselves from local storage
+                    const name = (config.namePrefix || "") + "ai_session";
+                    utlRemoveStorage(_logger, name);
+                }
+    
+                // We still take the account id from the ctor param for backward compatibility.
+                // But if the the customer set the accountId through the newer setAuthenticatedUserContext API, we will override it.
+                _self.accountId = config.accountId || undefined;
+    
+                // Get the auth user id and account id from the cookie if exists
+                // Cookie is in the pattern: <authenticatedId>|<accountId>
+                let authCookie = _cookieManager.get(User.authUserCookieName);
+                if (authCookie) {
+                    authCookie = decodeURI(authCookie);
+                    const authCookieString = authCookie.split(User.cookieSeparator);
+                    if (authCookieString[0]) {
+                        _self.authenticatedId = authCookieString[0];
+                    }
+    
+                    if (authCookieString.length > 1 && authCookieString[1]) {
+                        _self.accountId = authCookieString[1];
+                    }
+                }
+            });
 
             function _generateNewId() {
-                let theConfig = (config || {}) as ITelemetryConfig;
-                let getNewId = (theConfig.getNewId ? theConfig.getNewId() : null) || newId;
-                let id = getNewId(theConfig.idLength ? config.idLength() : 22);
+                let theConfig = (config || {}) as IPropertiesConfig;
+                let getNewId = theConfig.getNewId || newId;
+                let id = getNewId(theConfig.idLength ? config.idLength : 22);
                 return id;
             }
 
@@ -109,38 +151,7 @@ export class User implements IUserContext {
                 // set it to 365 days from now
                 // 365 * 24 * 60 * 60 = 31536000
                 const oneYear = 31536000;
-                _self.isUserCookieSet = _cookieManager.set(_storageNamePrefix(), cookie, oneYear);
-            }
-
-            if (!_self.id) {
-                _self.id = _generateNewId();
-                const newCookie = _generateNewCookie(_self.id);
-
-                _setUserCookie(newCookie.join(User.cookieSeparator));
-
-                // If we have an config.namePrefix() + ai_session in local storage this means the user actively removed our cookies.
-                // We should respect their wishes and clear ourselves from local storage
-                const name = config.namePrefix && config.namePrefix() ? config.namePrefix() + "ai_session" : "ai_session";
-                utlRemoveStorage(_logger, name);
-            }
-
-            // We still take the account id from the ctor param for backward compatibility.
-            // But if the the customer set the accountId through the newer setAuthenticatedUserContext API, we will override it.
-            _self.accountId = config.accountId ? config.accountId() : undefined;
-
-            // Get the auth user id and account id from the cookie if exists
-            // Cookie is in the pattern: <authenticatedId>|<accountId>
-            let authCookie = _cookieManager.get(User.authUserCookieName);
-            if (authCookie) {
-                authCookie = decodeURI(authCookie);
-                const authCookieString = authCookie.split(User.cookieSeparator);
-                if (authCookieString[0]) {
-                    _self.authenticatedId = authCookieString[0];
-                }
-
-                if (authCookieString.length > 1 && authCookieString[1]) {
-                    _self.accountId = authCookieString[1];
-                }
+                _self.isUserCookieSet = _cookieManager.set(_storageNamePrefix, cookie, oneYear);
             }
 
             _self.setAuthenticatedUserContext = (authenticatedUserId: string, accountId?: string, storeInCookie = false) => {
@@ -196,8 +207,8 @@ export class User implements IUserContext {
     /**
     * Sets the authenticated user id and the account id in this session.
     *
-    * @param authenticatedUserId {string} - The authenticated user id. A unique and persistent string that represents each authenticated user in the service.
-    * @param accountId {string} - An optional string to represent the account associated with the authenticated user.
+    * @param authenticatedUserId - {string} - The authenticated user id. A unique and persistent string that represents each authenticated user in the service.
+    * @param accountId - {string} - An optional string to represent the account associated with the authenticated user.
     */
     public setAuthenticatedUserContext(authenticatedUserId: string, accountId?: string, storeInCookie = false) {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging

package/src/Interfaces/IPropertiesConfig.ts

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+export interface IPropertiesConfig {
+    readonly instrumentationKey: string;
+    readonly accountId: string;
+    readonly sessionRenewalMs: number;
+    readonly samplingPercentage: number;
+    readonly sessionExpirationMs: number;
+    readonly cookieDomain: string,
+    readonly sdkExtension: string;
+    readonly isBrowserLinkTrackingEnabled: boolean;
+    readonly appId: string;
+    readonly getSessionId: string;
+    readonly namePrefix: string;
+    readonly sessionCookiePostfix: string;
+    readonly userCookiePostfix: string;
+    readonly idLength: number;
+    readonly getNewId: (idLength?: number) => string;
+}

package/src/PropertiesPlugin.ts

@@ -8,40 +8,37 @@ import {
     BreezeChannelIdentifier, IConfig, IPropertiesPlugin, PageView, PropertiesPluginIdentifier, createDistributedTraceContextFromTrace
 } from "@microsoft/applicationinsights-common";
 import {
-    BaseTelemetryPlugin, IAppInsightsCore, IConfiguration, IDistributedTraceContext, IPlugin, IProcessTelemetryContext,
+    BaseTelemetryPlugin, IAppInsightsCore, IConfigDefaults, IConfiguration, IDistributedTraceContext, IPlugin, IProcessTelemetryContext,
     IProcessTelemetryUnloadContext, ITelemetryItem, ITelemetryPluginChain, ITelemetryUnloadState, _InternalLogMessage, _eInternalMessageId,
-    _logInternalMessage, createProcessTelemetryContext, eLoggingSeverity, getNavigator, getSetValue, isNullOrUndefined, objForEachKey
+    _logInternalMessage, createProcessTelemetryContext, eLoggingSeverity, getNavigator, getSetValue, isNullOrUndefined, onConfigChange
 } from "@microsoft/applicationinsights-core-js";
+import { objDeepFreeze, objDefineProp } from "@nevware21/ts-utils";
 import { IPropTelemetryContext } from "./Interfaces/IPropTelemetryContext";
-import { ITelemetryConfig } from "./Interfaces/ITelemetryConfig";
+import { IPropertiesConfig } from "./Interfaces/IPropertiesConfig";
 import { TelemetryContext } from "./TelemetryContext";
 
-export default class PropertiesPlugin extends BaseTelemetryPlugin implements IPropertiesPlugin {
+let undefString: string;
+const nullValue: any = null;
+
+const _defaultConfig: IConfigDefaults<IPropertiesConfig> = objDeepFreeze({
+    instrumentationKey: undefString,
+    accountId: nullValue,
+    sessionRenewalMs: 30 * 60 * 1000,
+    samplingPercentage: 100,
+    sessionExpirationMs: 24 * 60 * 60 * 1000,
+    cookieDomain: nullValue,
+    sdkExtension: nullValue,
+    isBrowserLinkTrackingEnabled: false,
+    appId: nullValue,
+    getSessionId: nullValue,
+    namePrefix: undefString,
+    sessionCookiePostfix: undefString,
+    userCookiePostfix: undefString,
+    idLength: 22,
+    getNewId: nullValue
+});
 
-    public static getDefaultConfig(): ITelemetryConfig {
-        let defaultValue: string;
-        let nullValue: any = null;
-
-        const defaultConfig: ITelemetryConfig = {
-            instrumentationKey: () => defaultValue,
-            accountId: () => nullValue,
-            sessionRenewalMs: () => 30 * 60 * 1000,
-            samplingPercentage: () => 100,
-            sessionExpirationMs: () => 24 * 60 * 60 * 1000,
-            cookieDomain: () => nullValue,
-            sdkExtension: () => nullValue,
-            isBrowserLinkTrackingEnabled: () => false,
-            appId: () => nullValue,
-            getSessionId: () => nullValue,
-            namePrefix: () => defaultValue,
-            sessionCookiePostfix: () => defaultValue,
-            userCookiePostfix: () => defaultValue,
-            idLength: () => 22,
-            getNewId: () => nullValue
-        };
-        
-        return defaultConfig;
-    }
+export default class PropertiesPlugin extends BaseTelemetryPlugin implements IPropertiesPlugin {
 
     public context: IPropTelemetryContext;
 
@@ -51,14 +48,23 @@ export default class PropertiesPlugin extends BaseTelemetryPlugin implements IPr
     constructor() {
         super();
 
-        let _extensionConfig: ITelemetryConfig;
+        let _extensionConfig: IPropertiesConfig;
         let _distributedTraceCtx: IDistributedTraceContext;
         let _previousTraceCtx: IDistributedTraceContext;
+        let _context: IPropTelemetryContext;
 
         dynamicProto(PropertiesPlugin, this, (_self, _base) => {
 
             _initDefaults();
 
+            objDefineProp(_self, "context", {
+                enumerable: true,
+                configurable: true,
+                get: function() {
+                    return _context;
+                }
+            });
+
             _self.initialize = (config: IConfiguration & IConfig, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?:ITelemetryPluginChain) => {
                 _base.initialize(config, core, extensions, pluginChain);
                 _populateDefaults(config);
@@ -66,23 +72,21 @@ export default class PropertiesPlugin extends BaseTelemetryPlugin implements IPr
     
             /**
              * Add Part A fields to the event
-             * @param event The event that needs to be processed
+             * @param event - The event that needs to be processed
              */
             _self.processTelemetry = (event: ITelemetryItem, itemCtx?: IProcessTelemetryContext) => {
-                if (isNullOrUndefined(event)) {
-                    // TODO(barustum): throw an internal event once we have support for internal logging
-                } else {
+                if (!isNullOrUndefined(event)) {
                     itemCtx = _self._getTelCtx(itemCtx);
                     // If the envelope is PageView, reset the internal message count so that we can send internal telemetry for the new page.
                     if (event.name === PageView.envelopeType) {
                         itemCtx.diagLog().resetInternalMessageCount();
                     }
 
-                    let theContext: TelemetryContext = (_self.context || {}) as TelemetryContext;
+                    let theContext: TelemetryContext = (_context || {}) as TelemetryContext;
     
                     if (theContext.session) {
                         // If customer did not provide custom session id update the session manager
-                        if (typeof _self.context.session.id !== "string" && theContext.sessionManager) {
+                        if (typeof _context.session.id !== "string" && theContext.sessionManager) {
                             theContext.sessionManager.update();
                         }
                     }
@@ -120,30 +124,30 @@ export default class PropertiesPlugin extends BaseTelemetryPlugin implements IPr
                 _extensionConfig = null;
                 _distributedTraceCtx = null;
                 _previousTraceCtx = null;
+                _context = null;
             }
 
             function _populateDefaults(config: IConfiguration) {
                 let identifier = _self.identifier;
                 let core = _self.core;
 
-                let ctx = createProcessTelemetryContext(null, config, core);
-                const defaultConfig: ITelemetryConfig = PropertiesPlugin.getDefaultConfig();
-                _extensionConfig = _extensionConfig || {} as ITelemetryConfig;
-                objForEachKey(defaultConfig, (field, value) => {
-                    _extensionConfig[field] = () => ctx.getConfig(identifier, field, value());
-                });
-
-                _previousTraceCtx = core.getTraceCtx(false);
-                _self.context = new TelemetryContext(core, _extensionConfig, _previousTraceCtx);
-                _distributedTraceCtx = createDistributedTraceContextFromTrace(_self.context.telemetryTrace, _previousTraceCtx);
-                core.setTraceCtx(_distributedTraceCtx);
-                _self.context.appId = () => {
-                    let breezeChannel = core.getPlugin<IPlugin>(BreezeChannelIdentifier);
-                    return breezeChannel ? breezeChannel.plugin["_appId"] : null;
-                };
-
-                // Test hook to allow accessing the internal values -- explicitly not defined as an available property on the class
-                _self["_extConfig"] = _extensionConfig;
+                // This function will be re-called whenever any referenced configuration is changed
+                _self._addHook(onConfigChange(config, () => {
+                    let ctx = createProcessTelemetryContext(null, config, core);
+                    _extensionConfig = ctx.getExtCfg(identifier, _defaultConfig);
+    
+                    _previousTraceCtx = core.getTraceCtx(false);
+                    _context = new TelemetryContext(core, _extensionConfig, _previousTraceCtx);
+                    _distributedTraceCtx = createDistributedTraceContextFromTrace(_self.context.telemetryTrace, _previousTraceCtx);
+                    core.setTraceCtx(_distributedTraceCtx);
+                    _self.context.appId = () => {
+                        let breezeChannel = core.getPlugin<IPlugin>(BreezeChannelIdentifier);
+                        return breezeChannel ? breezeChannel.plugin["_appId"] : null;
+                    };
+
+                    // Test hook to allow accessing the internal values -- explicitly not defined as an available property on the class
+                    _self["_extConfig"] = _extensionConfig;
+                }));
             }
 
             function _processTelemetryInternal(evt: ITelemetryItem, itemCtx: IProcessTelemetryContext) {
@@ -173,7 +177,7 @@ export default class PropertiesPlugin extends BaseTelemetryPlugin implements IPr
 
     /**
      * Add Part A fields to the event
-     * @param event The event that needs to be processed
+     * @param event - The event that needs to be processed
      */
     public processTelemetry(event: ITelemetryItem, itemCtx?: IProcessTelemetryContext) {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging

package/src/TelemetryContext.ts

@@ -20,7 +20,7 @@ import { Session, _SessionManager } from "./Context/Session";
 import { TelemetryTrace } from "./Context/TelemetryTrace";
 import { User } from "./Context/User";
 import { IPropTelemetryContext } from "./Interfaces/IPropTelemetryContext";
-import { ITelemetryConfig } from "./Interfaces/ITelemetryConfig";
+import { IPropertiesConfig } from "./Interfaces/IPropertiesConfig";
 
 const strExt = "ext";
 const strTags = "tags";
@@ -31,6 +31,10 @@ function _removeEmpty(target: any, name: string) {
     }
 }
 
+function _nullResult(): string {
+    return null;
+}
+
 export class TelemetryContext implements IPropTelemetryContext {
 
     public application: IApplication; // The object describing a component tracked by this object - legacy
@@ -46,12 +50,12 @@ export class TelemetryContext implements IPropTelemetryContext {
     public appId: () => string;
     public getSessionId: () => string;
 
-    constructor(core: IAppInsightsCore, defaultConfig: ITelemetryConfig, previousTraceCtx?: IDistributedTraceContext) {
+    constructor(core: IAppInsightsCore, defaultConfig: IPropertiesConfig, previousTraceCtx?: IDistributedTraceContext) {
         let logger = core.logger
-        this.appId = () => null;
-        this.getSessionId = () => null;
 
         dynamicProto(TelemetryContext, this, (_self) => {
+            _self.appId = _nullResult;
+            _self.getSessionId = _nullResult;
             _self.application = new Application();
             _self.internal = new Internal(defaultConfig);
             if (hasWindow()) {

package/src/__DynamicConstants.ts

@@ -24,23 +24,18 @@ export const _DYN_APPLY_USER_CONTEXT = "applyUserContext";  // Count: 2
 export const _DYN_APPLY_OPERATING_SYST3 = "applyOperatingSystemContxt";  // Count: 2
 export const _DYN_APPLY_LOCATION_CONTE4 = "applyLocationContext";  // Count: 2
 export const _DYN_APPLY_INTERNAL_CONTE5 = "applyInternalContext";  // Count: 2
-export const _DYN_ACCOUNT_ID = "accountId";  // Count: 8
-export const _DYN_SDK_EXTENSION = "sdkExtension";  // Count: 4
+export const _DYN_ACCOUNT_ID = "accountId";  // Count: 7
 export const _DYN_GET_SESSION_ID = "getSessionId";  // Count: 4
-export const _DYN_NAME_PREFIX = "namePrefix";  // Count: 7
-export const _DYN_SESSION_COOKIE_POSTF6 = "sessionCookiePostfix";  // Count: 4
-export const _DYN_USER_COOKIE_POSTFIX = "userCookiePostfix";  // Count: 4
-export const _DYN_ID_LENGTH = "idLength";  // Count: 5
-export const _DYN_GET_NEW_ID = "getNewId";  // Count: 6
+export const _DYN_NAME_PREFIX = "namePrefix";  // Count: 3
+export const _DYN_SESSION_COOKIE_POSTF6 = "sessionCookiePostfix";  // Count: 2
+export const _DYN_USER_COOKIE_POSTFIX = "userCookiePostfix";  // Count: 2
+export const _DYN_ID_LENGTH = "idLength";  // Count: 4
+export const _DYN_GET_NEW_ID = "getNewId";  // Count: 3
 export const _DYN_LENGTH = "length";  // Count: 4
 export const _DYN_AUTOMATIC_SESSION = "automaticSession";  // Count: 5
 export const _DYN_AUTHENTICATED_ID = "authenticatedId";  // Count: 6
-export const _DYN_SESSION_EXPIRATION_M7 = "sessionExpirationMs";  // Count: 5
-export const _DYN_SESSION_RENEWAL_MS = "sessionRenewalMs";  // Count: 4
-export const _DYN_CONFIG = "config";  // Count: 4
 export const _DYN_ACQUISITION_DATE = "acquisitionDate";  // Count: 5
 export const _DYN_RENEWAL_DATE = "renewalDate";  // Count: 4
-export const _DYN_COOKIE_DOMAIN = "cookieDomain";  // Count: 3
 export const _DYN_JOIN = "join";  // Count: 5
 export const _DYN_COOKIE_SEPARATOR = "cookieSeparator";  // Count: 5
-export const _DYN_AUTH_USER_COOKIE_NAM8 = "authUserCookieName";  // Count: 3
+export const _DYN_AUTH_USER_COOKIE_NAM7 = "authUserCookieName";  // Count: 3

package/types/Context/Internal.d.ts

@@ -1,5 +1,5 @@
 import { IInternal } from "@microsoft/applicationinsights-common";
-import { ITelemetryConfig } from "../Interfaces/ITelemetryConfig";
+import { IPropertiesConfig } from "../Interfaces/IPropertiesConfig";
 export declare class Internal implements IInternal {
     /**
      * The SDK version used to create this telemetry item.
@@ -25,5 +25,5 @@ export declare class Internal implements IInternal {
     /**
      * Constructs a new instance of the internal telemetry data class.
      */
-    constructor(config: ITelemetryConfig);
+    constructor(config: IPropertiesConfig);
 }