@microsoft/applicationinsights-common 2.8.0-nightly.2204-04 → 2.8.0-nightly.2204-07

package/src/Telemetry/Common/DataSanitizer.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { IDiagnosticLogger, eLoggingSeverity, _InternalMessageId, hasJSON, getJSON, objForEachKey, isObject, strTrim, _throwInternal } from "@microsoft/applicationinsights-core-js";
+import { IDiagnosticLogger, eLoggingSeverity, _eInternalMessageId, hasJSON, getJSON, objForEachKey, isObject, strTrim, _throwInternal } from "@microsoft/applicationinsights-core-js";
 
 export const enum DataSanitizerValues {
     /**
@@ -68,7 +68,7 @@ export function dataSanitizeKey(logger: IDiagnosticLogger, name: any) {
             nameTrunc = name.substring(0, DataSanitizerValues.MAX_NAME_LENGTH);
             _throwInternal(logger,
                 eLoggingSeverity.WARNING,
-                _InternalMessageId.NameTooLong,
+                _eInternalMessageId.NameTooLong,
                 "name is too long.  It has been truncated to " + DataSanitizerValues.MAX_NAME_LENGTH + " characters.",
                 { name }, true);
         }
@@ -86,7 +86,7 @@ export function dataSanitizeString(logger: IDiagnosticLogger, value: any, maxLen
             valueTrunc = value.toString().substring(0, maxLength);
             _throwInternal(logger,
                 eLoggingSeverity.WARNING,
-                _InternalMessageId.StringValueTooLong,
+                _eInternalMessageId.StringValueTooLong,
                 "string value is too long. It has been truncated to " + maxLength + " characters.",
                 { value }, true);
         }
@@ -96,7 +96,7 @@ export function dataSanitizeString(logger: IDiagnosticLogger, value: any, maxLen
 }
 
 export function dataSanitizeUrl(logger: IDiagnosticLogger, url: any) {
-    return dataSanitizeInput(logger, url, DataSanitizerValues.MAX_URL_LENGTH, _InternalMessageId.UrlTooLong);
+    return dataSanitizeInput(logger, url, DataSanitizerValues.MAX_URL_LENGTH, _eInternalMessageId.UrlTooLong);
 }
 
 export function dataSanitizeMessage(logger: IDiagnosticLogger, message: any) {
@@ -105,7 +105,7 @@ export function dataSanitizeMessage(logger: IDiagnosticLogger, message: any) {
         if (message.length > DataSanitizerValues.MAX_MESSAGE_LENGTH) {
             messageTrunc = message.substring(0, DataSanitizerValues.MAX_MESSAGE_LENGTH);
             _throwInternal(logger,
-                eLoggingSeverity.WARNING, _InternalMessageId.MessageTruncated,
+                eLoggingSeverity.WARNING, _eInternalMessageId.MessageTruncated,
                 "message is too long, it has been truncated to " + DataSanitizerValues.MAX_MESSAGE_LENGTH + " characters.",
                 { message },
                 true);
@@ -123,7 +123,7 @@ export function dataSanitizeException(logger: IDiagnosticLogger, exception: any)
         if (value.length > DataSanitizerValues.MAX_EXCEPTION_LENGTH) {
             exceptionTrunc = value.substring(0, DataSanitizerValues.MAX_EXCEPTION_LENGTH);
             _throwInternal(logger,
-                eLoggingSeverity.WARNING, _InternalMessageId.ExceptionTruncated, "exception is too long, it has been truncated to " + DataSanitizerValues.MAX_EXCEPTION_LENGTH + " characters.",
+                eLoggingSeverity.WARNING, _eInternalMessageId.ExceptionTruncated, "exception is too long, it has been truncated to " + DataSanitizerValues.MAX_EXCEPTION_LENGTH + " characters.",
                 { exception }, true);
         }
     }
@@ -140,7 +140,7 @@ export function dataSanitizeProperties(logger: IDiagnosticLogger, properties: an
                 try {
                     value = getJSON().stringify(value);
                 } catch (e) {
-                    _throwInternal(logger,eLoggingSeverity.WARNING, _InternalMessageId.CannotSerializeObjectNonSerializable, "custom property is not valid", { exception: e}, true);
+                    _throwInternal(logger,eLoggingSeverity.WARNING, _eInternalMessageId.CannotSerializeObjectNonSerializable, "custom property is not valid", { exception: e}, true);
                 }
             }
             value = dataSanitizeString(logger, value, DataSanitizerValues.MAX_PROPERTY_LENGTH);
@@ -168,10 +168,10 @@ export function dataSanitizeMeasurements(logger: IDiagnosticLogger, measurements
 }
 
 export function dataSanitizeId(logger: IDiagnosticLogger, id: string): string {
-    return id ? dataSanitizeInput(logger, id, DataSanitizerValues.MAX_ID_LENGTH, _InternalMessageId.IdTooLong).toString() : id;
+    return id ? dataSanitizeInput(logger, id, DataSanitizerValues.MAX_ID_LENGTH, _eInternalMessageId.IdTooLong).toString() : id;
 }
 
-export function dataSanitizeInput(logger: IDiagnosticLogger, input: any, maxLength: number, _msgId: _InternalMessageId) {
+export function dataSanitizeInput(logger: IDiagnosticLogger, input: any, maxLength: number, _msgId: _eInternalMessageId) {
     let inputTrunc : String;
     if (input) {
         input = strTrim(input);
@@ -248,7 +248,7 @@ export interface IDataSanitizer {
  
     sanitizeId: (logger: IDiagnosticLogger, id: string) => string;
  
-    sanitizeInput: (logger: IDiagnosticLogger, input: any, maxLength: number, _msgId: _InternalMessageId) => any;
+    sanitizeInput: (logger: IDiagnosticLogger, input: any, maxLength: number, _msgId: _eInternalMessageId) => any;
 
     padNumber: (num: number) => string;
  

package/src/Telemetry/PageViewPerformance.ts

@@ -5,7 +5,7 @@ import { IPageViewPerfData } from "../Interfaces/Contracts/IPageViewPerfData";
 import { FieldType } from "../Enums";
 import { ISerializable } from "../Interfaces/Telemetry/ISerializable";
 import { dataSanitizeMeasurements, dataSanitizeProperties, dataSanitizeString, dataSanitizeUrl } from "./Common/DataSanitizer";
-import { IDiagnosticLogger, _InternalMessageId } from "@microsoft/applicationinsights-core-js";
+import { IDiagnosticLogger } from "@microsoft/applicationinsights-core-js";
 import { IPageViewPerformanceTelemetry } from "../Interfaces/IPageViewPerformanceTelemetry";
 import { strNotSpecified } from "../Constants";
 

package/src/TelemetryItemCreator.ts

@@ -2,11 +2,64 @@
 // Licensed under the MIT License.
 
 import { dataSanitizeString } from "./Telemetry/Common/DataSanitizer";
-import { ITelemetryItem, IDiagnosticLogger, objForEachKey, isNullOrUndefined, toISOString } from "@microsoft/applicationinsights-core-js";
+import { ITelemetryItem, IDiagnosticLogger, objForEachKey, isNullOrUndefined, toISOString, throwError } from "@microsoft/applicationinsights-core-js";
 import { strNotSpecified, strIkey } from "./Constants";
 
-export class TelemetryItemCreator {
 
+/**
+ * Create a telemetry item that the 1DS channel understands
+ * @param item domain specific properties; part B
+ * @param baseType telemetry item type. ie PageViewData
+ * @param envelopeName name of the envelope. ie Microsoft.ApplicationInsights.<instrumentation key>.PageView
+ * @param customProperties user defined custom properties; part C
+ * @param systemProperties system properties that are added to the context; part A
+ * @returns ITelemetryItem that is sent to channel
+ */
+
+export function createTelemetryItem<T>(item: T,
+    baseType: string,
+    envelopeName: string,
+    logger: IDiagnosticLogger,
+    customProperties?: { [key: string]: any },
+    systemProperties?: { [key: string]: any }): ITelemetryItem {
+
+    envelopeName = dataSanitizeString(logger, envelopeName) || strNotSpecified;
+
+    if (isNullOrUndefined(item) ||
+        isNullOrUndefined(baseType) ||
+        isNullOrUndefined(envelopeName)) {
+        throwError("Input doesn't contain all required fields");
+    }
+    
+    let iKey = "";
+    if (item[strIkey]) {
+        iKey = item[strIkey];
+        delete item[strIkey];
+    }
+
+    const telemetryItem: ITelemetryItem = {
+        name: envelopeName,
+        time: toISOString(new Date()),
+        iKey: iKey, // this will be set in TelemetryContext
+        ext: systemProperties ? systemProperties : {}, // part A
+        tags: [],
+        data: {
+        },
+        baseType,
+        baseData: item // Part B
+    };
+
+    // Part C
+    if (!isNullOrUndefined(customProperties)) {
+        objForEachKey(customProperties, (prop, value) => {
+            telemetryItem.data[prop] = value;
+        });
+    }
+
+    return telemetryItem;
+}
+
+export class TelemetryItemCreator {
     /**
      * Create a telemetry item that the 1DS channel understands
      * @param item domain specific properties; part B
@@ -17,46 +70,5 @@ export class TelemetryItemCreator {
      * @returns ITelemetryItem that is sent to channel
      */
 
-    public static create<T>(item: T,
-        baseType: string,
-        envelopeName: string,
-        logger: IDiagnosticLogger,
-        customProperties?: { [key: string]: any },
-        systemProperties?: { [key: string]: any }): ITelemetryItem {
-
-        envelopeName = dataSanitizeString(logger, envelopeName) || strNotSpecified;
-
-        if (isNullOrUndefined(item) ||
-            isNullOrUndefined(baseType) ||
-            isNullOrUndefined(envelopeName)) {
-            throw Error("Input doesn't contain all required fields");
-        }
-        
-        let iKey = "";
-        if (item[strIkey]) {
-            iKey = item[strIkey];
-            delete item[strIkey];
-        }
-
-        const telemetryItem: ITelemetryItem = {
-            name: envelopeName,
-            time: toISOString(new Date()),
-            iKey: iKey, // this will be set in TelemetryContext
-            ext: systemProperties ? systemProperties : {}, // part A
-            tags: [],
-            data: {
-            },
-            baseType,
-            baseData: item // Part B
-        };
-
-        // Part C
-        if (!isNullOrUndefined(customProperties)) {
-            objForEachKey(customProperties, (prop, value) => {
-                telemetryItem.data[prop] = value;
-            });
-        }
-
-        return telemetryItem;
-    }
+     public static create = createTelemetryItem;
 }

package/src/Util.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 import {
-    _InternalMessageId, IDiagnosticLogger, IPlugin, getPerformance,
+    IDiagnosticLogger, IPlugin, getPerformance,
     getExceptionName as coreGetExceptionName, dumpObj,
     isNullOrUndefined, strTrim, random32, isArray, isError, isDate,
     newId, generateW3CId, toISOString, arrForEach, getIEVersion, attachEvent,
@@ -11,7 +11,7 @@ import {
     setCookie as coreSetCookie, deleteCookie as coreDeleteCookie,
     isBeaconsSupported
 } from "@microsoft/applicationinsights-core-js";
-import { RequestHeaders } from "./RequestResponseHeaders";
+import { eRequestHeaders, RequestHeaders } from "./RequestResponseHeaders";
 import { dataSanitizeString } from "./Telemetry/Common/DataSanitizer";
 import { ICorrelationConfig } from "./Interfaces/ICorrelationConfig";
 import { createDomEvent } from "./DomHelperFuncs";
@@ -393,7 +393,7 @@ export const CorrelationIdHelper: ICorrelationIdHelper = {
      */
     getCorrelationContext(responseHeader: string) {
         if (responseHeader) {
-            const correlationId = CorrelationIdHelper.getCorrelationContextValue(responseHeader, RequestHeaders.requestContextTargetKey);
+            const correlationId = CorrelationIdHelper.getCorrelationContextValue(responseHeader, RequestHeaders[eRequestHeaders.requestContextTargetKey]);
             if (correlationId && correlationId !== CorrelationIdHelper.correlationIdPrefix) {
                 return correlationId;
             }

package/src/W3cTraceParent.ts

@@ -0,0 +1,219 @@
+import { generateW3CId, getDocument, getPerformance, isArray, isString, strTrim } from "@microsoft/applicationinsights-core-js";
+import { ITraceParent } from "./Interfaces/ITraceParent";
+
+// using {0,16} for leading and trailing whitespace just to constrain the possible runtime of a random string
+const TRACE_PARENT_REGEX = /^([\da-f]{2})-([\da-f]{32})-([\da-f]{16})-([\da-f]{2})(-[^\s]*)?$/;
+const DEFAULT_VERSION = "00";
+const INVALID_VERSION = "ff";
+const INVALID_TRACE_ID = "00000000000000000000000000000000";
+const INVALID_SPAN_ID = "0000000000000000";
+const SAMPLED_FLAG = 0x01;
+
+function _isValid(value: string, len: number, invalidValue?: string): boolean {
+    if (value && value.length === len && value !== invalidValue) {
+        return !!value.match(/^[\da-f]*$/);
+    }
+
+    return false;
+}
+
+function _formatValue(value: string, len: number, defValue: string): string {
+    if (_isValid(value, len)) {
+        return value;
+    }
+
+    return defValue;
+}
+
+function _formatFlags(value: number): string {
+    if (isNaN(value) || value < 0 || value > 255) {
+        value = 0x01;
+    }
+
+    let result = value.toString(16);
+    while (result.length < 2) {
+        result = "0" + result;
+    }
+
+    return result;
+}
+
+function _getTraceParentValue(values: any) {
+    if (values) {
+        for (var i = 0; i < values.length; i++) {
+            var value = values[i] as any;
+            if (value.name) {
+                if(value.name === "traceparent") {
+                    return value;
+                }
+            }
+        }
+    }
+
+    return {};
+}
+
+/**
+ * Create a new ITraceParent instance using the provided values.
+ * @param traceId - The traceId to use, when invalid a new random W3C id will be generated.
+ * @param spanId - The parent/span id to use, a new random value will be generated if it is invalid.
+ * @param flags - The traceFlags to use, defaults to zero (0) if not supplied or invalid
+ * @param version - The version to used, defaults to version "01" if not supplied or invalid.
+ * @returns
+ */
+export function createTraceParent(traceId?: string, spanId?: string, flags?: number, version?: string): ITraceParent {
+
+    return {
+        version: _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
+        traceId: isValidTraceId(traceId) ? traceId : generateW3CId(),
+        spanId: isValidSpanId(spanId) ? spanId : generateW3CId().substr(0, 16),
+        traceFlags: flags >= 0 && flags <= 0xFF ? flags : 1
+    };
+}
+
+/**
+ * Attempt to parse the provided string as a W3C TraceParent header value (https://www.w3.org/TR/trace-context/#traceparent-header)
+ *
+ * @param value
+ * @returns
+ */
+export function parseTraceParent(value: string): ITraceParent {
+    if (!value) {
+        // Don't pass a null/undefined or empty string
+        return null;
+    }
+
+    if (isArray(value)) {
+        // The value may have been encoded on the page into an array so handle this automatically
+        value = value[0] || "";
+    }
+
+    if (!value || !isString(value) || value.length > 8192) {
+        // limit potential processing based on total length
+        return null;
+    }
+
+    // See https://www.w3.org/TR/trace-context/#versioning-of-traceparent
+    const match = TRACE_PARENT_REGEX.exec(strTrim(value));
+    if (!match ||                               // No match
+            match[1] === INVALID_VERSION ||     // version ff is forbidden
+            match[2] === INVALID_TRACE_ID ||    // All zeros is considered to be invalid
+            match[3] === INVALID_SPAN_ID) {     // All zeros is considered to be invalid
+        return null;
+    }
+
+    return {
+        version: match[1],
+        traceId: match[2],
+        spanId: match[3],
+        traceFlags: parseInt(match[4], 16)
+    }
+}
+
+/**
+ * Is the provided W3c Trace Id a valid string representation, it must be a 32-character string
+ * of lowercase hexadecimal characters for example, 4bf92f3577b34da6a3ce929d0e0e4736.
+ * If all characters as zero (00000000000000000000000000000000) it will be considered an invalid value.
+ * @param value - The W3c trace Id to be validated
+ * @returns true if valid otherwise false
+ */
+export function isValidTraceId(value: string): boolean {
+    return _isValid(value, 32, INVALID_TRACE_ID);
+}
+
+/**
+ * Is the provided W3c span id (aka. parent id) a valid string representation, it must be a 16-character
+ * string of lowercase hexadecimal characters, for example, 00f067aa0ba902b7.
+ * If all characters are zero (0000000000000000) this is considered an invalid value.
+ * @param value - The W3c span id to be validated
+ * @returns true if valid otherwise false
+ */
+export function isValidSpanId(value: string): boolean {
+    return _isValid(value, 16, INVALID_SPAN_ID);
+}
+
+/**
+ * Validates that the provided ITraceParent instance conforms to the currently supported specifications
+ * @param value
+ * @returns
+ */
+export function isValidTraceParent(value: ITraceParent) {
+    if (!value ||
+            !_isValid(value.version, 2, INVALID_VERSION) ||
+            !_isValid(value.traceId, 32, INVALID_TRACE_ID) ||
+            !_isValid(value.spanId, 16, INVALID_SPAN_ID) ||
+            !_isValid(_formatFlags(value.traceFlags), 2)) {
+
+        // Each known field must contain a valid value
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * Is the parsed traceParent indicating that the trace is currently sampled.
+ * @param value - The parsed traceParent value
+ * @returns
+ */
+export function isSampledFlag(value: ITraceParent) {
+    if (isValidTraceParent(value)) {
+        return (value.traceFlags & SAMPLED_FLAG) === SAMPLED_FLAG;
+    }
+
+    return false;
+}
+
+/**
+ * Format the ITraceParent value as a string using the supported and know version formats.
+ * So even if the passed traceParent is a later version the string value returned from this
+ * function will convert it to only the known version formats.
+ * This currently only supports version "00" and invalid "ff"
+ * @param value - The parsed traceParent value
+ * @returns
+ */
+export function formatTraceParent(value: ITraceParent) {
+    if (value) {
+        // Special Note: This only supports formatting as version 00, future versions should encode any known supported version
+        // So parsing a future version will populate the correct version value but reformatting will reduce it to version 00.
+        let flags = _formatFlags(value.traceFlags);
+        if (!_isValid(flags, 2)) {
+            flags = "01";
+        }
+
+        let version = value.version || DEFAULT_VERSION;
+        if (version !== "00" && version !== "ff") {
+            // Reduce version to "00"
+            version = DEFAULT_VERSION;
+        }
+
+        // Format as version 00
+        return `${version}-${_formatValue(value.traceId, 32, INVALID_TRACE_ID)}-${_formatValue(value.spanId, 16, INVALID_SPAN_ID)}-${flags}`;
+    }
+
+    return "";
+}
+
+/**
+ * Helper function to fetch the passed traceparent from the page, looking for it as a meta-tag or a Server-Timing header.
+ * @returns
+ */
+export function findW3cTraceParent(): ITraceParent {
+    let traceParent: ITraceParent;
+    let doc = getDocument();
+    if (doc) {
+        // Look for a meta-tag called "traceparent"
+        traceParent = parseTraceParent(_getTraceParentValue(doc.querySelectorAll("meta")).content);
+    }
+
+    if (!traceParent) {
+        let perf = getPerformance();
+        if (perf) {
+            // Try looking for a server-timing header
+            let navPerf = perf.getEntriesByType("navigation") || [];
+            traceParent = parseTraceParent(_getTraceParentValue((navPerf.length > 0 ? navPerf[0] : {} as any).serverTiming).description);
+        }
+    }
+
+    return traceParent;
+}

package/src/applicationinsights-common.ts

@@ -7,7 +7,7 @@ export {
 } from "./Util";
 export { parseConnectionString, ConnectionStringParser } from "./ConnectionStringParser";
 export { FieldType } from "./Enums";
-export { IRequestHeaders, RequestHeaders } from "./RequestResponseHeaders";
+export { IRequestHeaders, RequestHeaders, eRequestHeaders } from "./RequestResponseHeaders";
 export { DisabledPropertyName, ProcessLegacy, SampleRate, HttpMethod, DEFAULT_BREEZE_ENDPOINT, strNotSpecified } from "./Constants";
 export { IData as AIData } from "./Interfaces/Contracts/IData";
 export { IBase as AIBase } from "./Interfaces/Contracts/IBase";
@@ -30,7 +30,7 @@ export { IPageViewPerformanceTelemetry, IPageViewPerformanceTelemetryInternal }
 export { Trace } from "./Telemetry/Trace";
 export { PageViewPerformance } from "./Telemetry/PageViewPerformance";
 export { Data } from "./Telemetry/Common/Data";
-export { SeverityLevel } from "./Interfaces/Contracts/SeverityLevel";
+export { eSeverityLevel, SeverityLevel } from "./Interfaces/Contracts/SeverityLevel";
 export { IConfig, ConfigurationManager } from "./Interfaces/IConfig";
 export { IChannelControlsAI } from "./Interfaces/IChannelControlsAI";
 export { IContextTagKeys, ContextTagKeys } from "./Interfaces/Contracts/ContextTagKeys";
@@ -40,7 +40,7 @@ export {
     dataSanitizeException, dataSanitizeProperties, dataSanitizeMeasurements, dataSanitizeId, dataSanitizeInput,
     dsPadNumber
 } from "./Telemetry/Common/DataSanitizer";
-export { TelemetryItemCreator } from "./TelemetryItemCreator";
+export { TelemetryItemCreator, createTelemetryItem } from "./TelemetryItemCreator";
 export { ICorrelationConfig } from "./Interfaces/ICorrelationConfig";
 export { IAppInsights } from "./Interfaces/IAppInsights";
 export { IWeb } from "./Interfaces/Context/IWeb";
@@ -66,6 +66,11 @@ export {
     utlCanUseSessionStorage, utlGetSessionStorageKeys, utlGetSessionStorage, utlSetSessionStorage, utlRemoveSessionStorage
 } from "./StorageHelperFuncs";
 export { urlParseUrl, urlGetAbsoluteUrl, urlGetPathName, urlGetCompleteUrl, urlParseHost, urlParseFullHost } from "./UrlHelperFuncs";
+export { ITraceParent } from "./Interfaces/ITraceParent";
+export {
+    createTraceParent, parseTraceParent, isValidTraceId, isValidSpanId, isValidTraceParent, isSampledFlag, formatTraceParent, findW3cTraceParent
+} from "./W3cTraceParent";
+
 export const PropertiesPluginIdentifier = "AppInsightsPropertiesPlugin";
 export const BreezeChannelIdentifier = "AppInsightsChannelPlugin";
 export const AnalyticsPluginIdentifier = "ApplicationInsightsAnalytics";

package/types/Enums.d.ts

@@ -5,10 +5,7 @@ export declare const enum eStorageType {
     LocalStorage = 0,
     SessionStorage = 1
 }
-export declare const StorageType: {
-    LocalStorage: number;
-    SessionStorage: number;
-};
+export declare const StorageType: import("@microsoft/applicationinsights-core-js").EnumValue<typeof eStorageType>;
 export declare type StorageType = eStorageType | typeof StorageType;
 /**
  * Enum is used in aiDataContract to describe how fields are serialized.
@@ -34,9 +31,5 @@ export declare const enum eDistributedTracingModes {
      */
     W3C = 2
 }
-export declare const DistributedTracingModes: {
-    AI: number;
-    AI_AND_W3C: number;
-    W3C: number;
-};
+export declare const DistributedTracingModes: import("@microsoft/applicationinsights-core-js").EnumValue<typeof eDistributedTracingModes>;
 export declare type DistributedTracingModes = number | eDistributedTracingModes;

package/types/Interfaces/Contracts/SeverityLevel.d.ts

@@ -1,10 +1,15 @@
 /**
  * Defines the level of severity for the event.
  */
-export declare enum SeverityLevel {
+export declare const enum eSeverityLevel {
     Verbose = 0,
     Information = 1,
     Warning = 2,
     Error = 3,
     Critical = 4
 }
+/**
+ * Defines the level of severity for the event.
+ */
+export declare const SeverityLevel: import("@microsoft/applicationinsights-core-js").EnumValue<typeof eSeverityLevel>;
+export declare type SeverityLevel = number | eSeverityLevel;

package/types/Interfaces/IConfig.d.ts

@@ -1,4 +1,4 @@
-import { IConfiguration, ICookieMgrConfig, ICustomProperties } from "@microsoft/applicationinsights-core-js";
+import { IConfiguration, ICustomProperties } from "@microsoft/applicationinsights-core-js";
 import { DistributedTracingModes } from "../Enums";
 import { IRequestContext } from "./IRequestContext";
 /**
@@ -140,7 +140,7 @@ export interface IConfig {
      */
     enableSessionStorageBuffer?: boolean;
     /**
-     * @deprecated Use either disableCookiesUsage or specify a cookieMgrCfg with the enabled value set.
+     * @deprecated Use either disableCookiesUsage or specify a cookieCfg with the enabled value set.
      * If true, the SDK will not store or read any data from cookies. Default is false. As this field is being deprecated, when both
      * isCookieUseDisabled and disableCookiesUsage are used disableCookiesUsage will take precedent.
      * @defaultValue false
@@ -148,7 +148,7 @@ export interface IConfig {
     isCookieUseDisabled?: boolean;
     /**
      * If true, the SDK will not store or read any data from cookies. Default is false.
-     * If you have also specified a cookieMgrCfg then enabled property (if specified) will take precedent over this value.
+     * If you have also specified a cookieCfg then enabled property (if specified) will take precedent over this value.
      * @defaultValue false
      */
     disableCookiesUsage?: boolean;
@@ -162,12 +162,6 @@ export interface IConfig {
      * @defaultValue ""
      */
     cookiePath?: string;
-    /**
-     * [Optional] A Cookie Manager configuration which includes hooks to allow interception of the get, set and delete cookie
-     * operations. If this configuration is specified any specified enabled and domain properties will take precedence over the
-     * cookieDomain and disableCookiesUsage values.
-     */
-    cookieMgrCfg?: ICookieMgrConfig;
     /**
      * Default false. If false, retry on 206 (partial success), 408 (timeout), 429 (too many requests), 500 (internal server error), 503 (service unavailable), and 0 (offline, only if detected)
      * @description

package/types/Interfaces/ITraceParent.d.ts

@@ -0,0 +1,32 @@
+/**
+ * This interface represents the components of a W3C traceparent header
+ */
+export interface ITraceParent {
+    /**
+     * The version of the definition, this MUST be a string with a length of 2 and only contain lowercase
+     * hexadecimal characters. A value of 'ff' is considered to be an invalid version.
+     */
+    version: string;
+    /**
+     * This is the ID of the whole trace forest and is used to uniquely identify a distributed trace
+     * through a system. It is represented as a 32-character string of lowercase hexadecimal characters,
+     * for example, 4bf92f3577b34da6a3ce929d0e0e4736.
+     * All characters as zero (00000000000000000000000000000000) is considered an invalid value.
+     */
+    traceId: string;
+    /**
+     * This is the ID of the current request as known by the caller (in some tracing systems, this is also
+     * known as the parent-id, where a span is the execution of a client request). It is represented as an
+     * 16-character string of lowercase hexadecimal characters, for example, 00f067aa0ba902b7.
+     * All bytes as zero (0000000000000000) is considered an invalid value.
+     */
+    spanId: string;
+    /**
+     * An 8-bit value of flags that controls tracing such as sampling, trace level, etc. These flags are
+     * recommendations given by the caller rather than strict rules to follow.
+     * As this is a bit field, you cannot interpret flags by decoding the hex value and looking at the resulting
+     * number. For example, a flag 00000001 could be encoded as 01 in hex, or 09 in hex if present with the flag
+     * 00001000. A common mistake in bit fields is forgetting to mask when interpreting flags.
+     */
+    traceFlags: number;
+}

package/types/RequestResponseHeaders.d.ts

@@ -35,4 +35,34 @@ export interface IRequestHeaders {
     sdkContextHeaderAppIdRequest: string;
     requestContextHeaderLowerCase: string;
 }
-export declare const RequestHeaders: IRequestHeaders;
+export declare const enum eRequestHeaders {
+    requestContextHeader = 0,
+    requestContextTargetKey = 1,
+    requestContextAppIdFormat = 2,
+    requestIdHeader = 3,
+    traceParentHeader = 4,
+    traceStateHeader = 5,
+    sdkContextHeader = 6,
+    sdkContextHeaderAppIdRequest = 7,
+    requestContextHeaderLowerCase = 8
+}
+export declare const RequestHeaders: IRequestHeaders & {
+    requestContextHeader: "Request-Context";
+    requestContextTargetKey: "appId";
+    requestContextAppIdFormat: "appId=cid-v1:";
+    requestIdHeader: "Request-Id";
+    traceParentHeader: "traceparent";
+    traceStateHeader: "tracestate";
+    sdkContextHeader: "Sdk-Context";
+    sdkContextHeaderAppIdRequest: "appId";
+    requestContextHeaderLowerCase: "request-context";
+    0: "Request-Context";
+    1: "appId";
+    2: "appId=cid-v1:";
+    3: "Request-Id";
+    4: "traceparent";
+    5: "tracestate";
+    6: "Sdk-Context";
+    7: "appId";
+    8: "request-context";
+};

package/types/Telemetry/Common/DataSanitizer.d.ts

@@ -1,4 +1,4 @@
-import { IDiagnosticLogger, _InternalMessageId } from "@microsoft/applicationinsights-core-js";
+import { IDiagnosticLogger, _eInternalMessageId } from "@microsoft/applicationinsights-core-js";
 export declare const enum DataSanitizerValues {
     /**
      * Max length allowed for custom names.
@@ -38,7 +38,7 @@ export declare function dataSanitizeException(logger: IDiagnosticLogger, excepti
 export declare function dataSanitizeProperties(logger: IDiagnosticLogger, properties: any): any;
 export declare function dataSanitizeMeasurements(logger: IDiagnosticLogger, measurements: any): any;
 export declare function dataSanitizeId(logger: IDiagnosticLogger, id: string): string;
-export declare function dataSanitizeInput(logger: IDiagnosticLogger, input: any, maxLength: number, _msgId: _InternalMessageId): any;
+export declare function dataSanitizeInput(logger: IDiagnosticLogger, input: any, maxLength: number, _msgId: _eInternalMessageId): any;
 export declare function dsPadNumber(num: number): string;
 export interface IDataSanitizer {
     /**
@@ -78,7 +78,7 @@ export interface IDataSanitizer {
     sanitizeProperties: (logger: IDiagnosticLogger, properties: any) => any;
     sanitizeMeasurements: (logger: IDiagnosticLogger, measurements: any) => any;
     sanitizeId: (logger: IDiagnosticLogger, id: string) => string;
-    sanitizeInput: (logger: IDiagnosticLogger, input: any, maxLength: number, _msgId: _InternalMessageId) => any;
+    sanitizeInput: (logger: IDiagnosticLogger, input: any, maxLength: number, _msgId: _eInternalMessageId) => any;
     padNumber: (num: number) => string;
     /**
      * helper method to trim strings (IE8 does not implement String.prototype.trim)