@microsoft/applicationinsights-dependencies-js 3.4.0-nightlybeta3.2505-36 → 3.4.0-nightlybeta3.2507-23

package/types/applicationinsights-dependencies-js.namespaced.d.ts

@@ -1,5 +1,5 @@
 /*
- * Microsoft Application Insights XHR dependencies plugin, 3.4.0-nightlybeta3.2505-36
+ * Microsoft Application Insights XHR dependencies plugin, 3.4.0-nightlybeta3.2507-23
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -21,7 +21,7 @@ declare namespace ApplicationInsights {
         trackDependencyData(dependency: IDependencyTelemetry, properties?: {
             [key: string]: any;
         }): void;
-        includeCorrelationHeaders(ajaxData: ajaxRecord, input?: Request | string, init?: RequestInit, xhr?: XMLHttpRequestInstrumented): any;
+        includeCorrelationHeaders(ajaxData: IAjaxRecordData, input?: Request | string, init?: RequestInit, xhr?: XMLHttpRequestInstrumented): any;
         /**
          * Add an ajax listener which is called just prior to the request being sent and before the correlation headers are added, to allow you
          * to access the headers and modify the values used to generate the distributed tracing correlation headers.
@@ -51,62 +51,6 @@ declare namespace ApplicationInsights {
         }): void;
     }
 
-    class ajaxRecord {
-        completed: boolean;
-        requestHeadersSize: number;
-        requestHeaders: any;
-        responseReceivingDuration: number;
-        callbackDuration: number;
-        ajaxTotalDuration: number;
-        aborted: number;
-        pageUrl: string;
-        requestUrl: string;
-        requestSize: number;
-        method: string;
-        perfMark: PerformanceMark;
-        perfTiming: PerformanceResourceTiming;
-        perfAttempts?: number;
-        async?: boolean;
-        errorStatusText?: boolean;
-        status: string | number;
-        requestSentTime: number;
-        responseStartedTime: number;
-        responseFinishedTime: number;
-        callbackFinishedTime: number;
-        endTime: number;
-        xhrMonitoringState: XHRMonitoringState;
-        clientFailure: number;
-        /**
-         * The traceId to use for the dependency call
-         */
-        traceID: string;
-        /**
-         * The spanId to use for the dependency call
-         */
-        spanID: string;
-        /**
-         * The traceFlags to use for the dependency call
-         */
-        traceFlags?: number;
-        /**
-         * The trace context to use for reporting the remote dependency call
-         */
-        eventTraceCtx: ITraceCtx;
-        /**
-         * The listener assigned context values that will be passed to any dependency initializer
-         */
-        context?: {
-            [key: string]: any;
-        };
-        constructor(traceId: string, spanId: string, logger: IDiagnosticLogger, traceCtx?: IDistributedTraceContext);
-        getAbsoluteUrl(): string;
-        getPathName(): string;
-        CreateTrackItem(ajaxType: string, enableRequestHeaderTracking: boolean, getResponse: () => IAjaxRecordResponse): IDependencyTelemetry;
-        getPartAProps(): {
-            [key: string]: any;
-        };
-    }
-
     /**
      * 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
@@ -129,9 +73,12 @@ declare namespace ApplicationInsights {
          */
         processNext: (env: ITelemetryItem, itemCtx: IProcessTelemetryContext) => void;
         /**
-         * Set next extension for telemetry processing
+         * Set next extension for telemetry processing, this is now optional as plugins should use the
+         * processNext() function of the passed IProcessTelemetryContext instead. It is being kept for
+         * now for backward compatibility only.
+         * @deprecated - Use processNext() function of the passed IProcessTelemetryContext instead
          */
-        setNextPlugin: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
+        setNextPlugin?: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
         /**
          * Returns the current diagnostic logger that can be used to log issues, if no logger is currently
          * assigned a new default one will be created and returned.
@@ -244,17 +191,78 @@ declare namespace ApplicationInsights {
 
     const enum eDistributedTracingModes {
         /**
-         * (Default) Send Application Insights correlation headers
+         * Send only the legacy Application Insights correlation headers
+         *
+         * Headers Sent:
+         * - `Request-Id` (Legacy Application Insights header for older Server side SDKs)
+         *
+         * Config Decimal Value: `0` (Zero)
          */
         AI = 0,
         /**
-         * Send both W3C Trace Context headers and back-compatibility Application Insights headers
+         * (Default) Send both W3C Trace parent header and back-compatibility Application Insights headers
+         * - `Request-Id`
+         * - [`traceparent`](https://www.w3.org/TR/trace-context/#traceparent-header)
+         *
+         * Config Decimal Value: `1` (One)
          */
         AI_AND_W3C = 1,
         /**
-         * Send W3C Trace Context headers
+         * Send Only the W3C Trace parent header
+         *
+         * Headers Sent:
+         * - [`traceparent`](https://www.w3.org/TR/trace-context/#traceparent-header)
+         *
+         * Config Decimal Value: `2` (Two)
+         */
+        W3C = 2,
+        /**
+         * @internal
+         * Bitwise mask used to separate the base distributed tracing mode from the additional optional
+         * tracing modes.
+         * @since 3.4.0
          */
-        W3C = 2
+        _BaseMask = 15,
+        /**
+         * @internal
+         * Enabling this bit will send the W3C Trace State header, it is not intended to be used directly
+         * or on its own. The code may assume that if this bit is set, then the W3C Trace Context headers
+         * will also be included.
+         *
+         * Config Decimal Value: `16` (Sixteen in decimal)
+         * @since 3.4.0
+         */
+        _W3CTraceState = 16,
+        /**
+         * Send all of the W3C Trace Context headers and the W3C Trace State headers and back-compatibility
+         * Application Insights headers.
+         *
+         * Currently sent headers:
+         * - `Request-Id` (Legacy Application Insights header for older Server side SDKs)
+         * - [`traceparent`](https://www.w3.org/TR/trace-context/#traceparent-header)
+         * - [`tracestate`](https://www.w3.org/TR/trace-context/#tracestate-header)
+         *
+         * NOTE!: Additional headers may be added as part of a future update should the W3C Trace Context specification be updated
+         * to include additional headers.
+         *
+         * Config Decimal Value: `17` (Seventeen in decimal)
+         * @since 3.4.0
+         */
+        AI_AND_W3C_TRACE = 17,
+        /**
+         * Send all of the W3C Trace Context headers and the W3C Trace State headers.
+         *
+         * Currently sent headers:
+         * - [`traceparent`](https://www.w3.org/TR/trace-context/#traceparent-header)
+         * - [`tracestate`](https://www.w3.org/TR/trace-context/#tracestate-header)
+         *
+         * NOTE!: Additional headers may be added as part of a future update should the W3C Trace Context specification be updated
+         * to include additional headers.
+         *
+         * Config Decimal Value: `18` (Eighteen in decimal)
+         * @since 3.4.0
+         */
+        W3C_TRACE = 18
     }
 
     const enum _eInternalMessageId {
@@ -387,6 +395,30 @@ declare namespace ApplicationInsights {
 
     type EnumValue<E = any> = EnumCls<E>;
 
+    /**
+     * Controls how the SDK should look for trace headers (traceparent/tracestate) from the initial page load
+     * The values are bitwise OR'd together to allow for multiple values to be set at once.
+     * @since 3.4.0
+     */
+    const enum eTraceHeadersMode {
+        /**
+         * Don't look for any trace headers
+         */
+        None = 0,
+        /**
+         * Look for traceparent header/meta tag
+         */
+        TraceParent = 1,
+        /**
+         * Look for tracestate header/meta tag
+         */
+        TraceState = 2,
+        /**
+         * Look for both traceparent and tracestate headers/meta tags
+         */
+        All = 3
+    }
+
     const enum FeatureOptInMode {
         /**
          * not set, completely depends on cdn cfg
@@ -407,6 +439,157 @@ declare namespace ApplicationInsights {
      */
     type FinallyPromiseHandler = (() => void) | undefined | null;
 
+    /**
+     * Interface for ajax data passed to includeCorrelationHeaders function.
+     * Contains the public properties and methods needed for correlation header processing.
+     *
+     * @public
+     */
+    interface IAjaxRecordData {
+        /**
+         * Gets the absolute URL for the request
+         * @returns The absolute URL string or null
+         */
+        getAbsoluteUrl(): string | null;
+        /**
+         * Gets the sanitized path name for the request URL
+         * @returns The sanitized path name string or null
+         */
+        getPathName(): string | null;
+        /**
+         * The distributed trace context for the request containing trace ID, span ID, and trace flags
+         */
+        readonly traceCtx: IDistributedTraceContext;
+        /**
+         * Object containing request headers that have been set for this request
+         */
+        requestHeaders: {
+            [key: string]: string;
+        };
+        /**
+         * Indicates whether the request was aborted (0 = not aborted, 1 = aborted)
+         */
+        aborted: number;
+        /**
+         * Optional context object that can be set by dependency listeners
+         */
+        context?: {
+            [key: string]: any;
+        };
+    }
+
+    /**
+     * Internal interface that extends the public IAjaxRecordData with additional properties and methods
+     * used internally by the AJAX monitoring implementation.
+     *
+     * @internal
+     */
+    interface IAjaxRecordInternal extends IAjaxRecordData {
+        /**
+         * Indicates if the ajax call has completed
+         */
+        completed: boolean;
+        /**
+         * Size of the request headers in bytes
+         */
+        requestHeadersSize: number;
+        /**
+         * Duration of receiving the response in milliseconds
+         */
+        responseReceivingDuration: number;
+        /**
+         * Duration of the callback execution in milliseconds
+         */
+        callbackDuration: number;
+        /**
+         * Total duration of the ajax call in milliseconds
+         */
+        ajaxTotalDuration: number;
+        /**
+         * URL of the page that initiated the request
+         */
+        pageUrl: string;
+        /**
+         * The URL of the request
+         */
+        requestUrl: string;
+        /**
+         * Size of the request in bytes
+         */
+        requestSize: number;
+        /**
+         * HTTP method used for the request
+         */
+        method: string;
+        /**
+         * Performance mark associated with this request
+         */
+        perfMark: PerformanceMark;
+        /**
+         * Performance timing data from the Resource Timing API
+         */
+        perfTiming: PerformanceResourceTiming;
+        /**
+         * Number of attempts to find performance data
+         */
+        perfAttempts?: number;
+        /**
+         * Indicates if the request was made asynchronously
+         */
+        async?: boolean;
+        /**
+         * Should the Error Status text be included in the response
+         */
+        errorStatusText?: boolean;
+        /**
+         * HTTP status code of the response
+         */
+        status: string | number;
+        /**
+         * Timestamp when the request was sent
+         */
+        requestSentTime: number;
+        /**
+         * Timestamp when the first byte was received
+         */
+        responseStartedTime: number;
+        /**
+         * Timestamp when the last byte was received
+         */
+        responseFinishedTime: number;
+        /**
+         * Timestamp when the onreadystatechange callback finished
+         */
+        callbackFinishedTime: number;
+        /**
+         * Timestamp when the ajax call ended
+         */
+        endTime: number;
+        /**
+         * State tracking object for XHR monitoring
+         */
+        xhrMonitoringState: IXHRMonitoringState;
+        /**
+         * Indicates if a JavaScript exception occurred in xhr.onreadystatechange code (1 if occurred, 0 otherwise)
+         */
+        clientFailure: number;
+        /**
+         * Creates a telemetry item for tracking this ajax request
+         * @param ajaxType - Type of the ajax request
+         * @param enableRequestHeaderTracking - Whether to include request headers in telemetry
+         * @param getResponse - Function to get response data
+         * @returns Dependency telemetry item or null
+         */
+        CreateTrackItem(ajaxType: string, enableRequestHeaderTracking: boolean, getResponse: () => IAjaxRecordResponse): IDependencyTelemetry;
+        /**
+         * Gets Part A properties for telemetry
+         * @returns Object containing Part A properties or null
+         */
+        getPartAProps(): {
+            [key: string]: any;
+        };
+    }
+
     interface IAjaxRecordResponse {
         statusText: string;
         headerMap: Object;
@@ -538,7 +721,7 @@ declare namespace ApplicationInsights {
          */
         flush(isAsync?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason, cbTimeout?: number): boolean | void;
         /**
-         * Gets the current distributed trace context for this instance if available
+         * Gets the current distributed trace active context for this instance
          * @param createNew - Optional flag to create a new instance if one doesn't currently exist, defaults to true
          */
         getTraceCtx(createNew?: boolean): IDistributedTraceContext | null;
@@ -587,9 +770,12 @@ declare namespace ApplicationInsights {
          */
         getCfg: () => IConfiguration;
         /**
-         * Gets the named extension config
+         * Gets the named extension configuration
+         * @param identifier - The named extension identifier
+         * @param defaultValue - The default value(s) to return if no defined config exists
+         * @param rootOnly - If true, only the look for the configuration in the top level and not in the "extensionConfig"
          */
-        getExtCfg: <T>(identifier: string, defaultValue?: IConfigDefaults<T>) => T;
+        getExtCfg: <T>(identifier: string, defaultValue?: IConfigDefaults<T>, rootOnly?: boolean) => T;
         /**
          * Gets the named config from either the named identifier extension or core config if neither exist then the
          * default value is returned
@@ -1210,7 +1396,7 @@ declare namespace ApplicationInsights {
          * }
          * ```
          *
-         * For more details, see the [Page Unload Events documentation](https://microsoft.github.io/ApplicationInsights-JS/docs/PageUnloadEvents.html).
+         * For more details, see the [Page Unload Events documentation](https://microsoft.github.io/ApplicationInsights-JS/PageUnloadEvents.html).
          */
         disablePageUnloadEvents?: string[];
         /**
@@ -1225,7 +1411,7 @@ declare namespace ApplicationInsights {
          * }
          * ```
          *
-         * For more details, see the [Page Unload Events documentation](https://microsoft.github.io/ApplicationInsights-JS/docs/PageUnloadEvents.html).
+         * For more details, see the [Page Unload Events documentation](https://microsoft.github.io/ApplicationInsights-JS/PageUnloadEvents.html).
          */
         disablePageShowEvents?: string[];
         /**
@@ -1267,6 +1453,25 @@ declare namespace ApplicationInsights {
          * @since 3.3.2
          */
         expCfg?: IExceptionConfig;
+        /**
+         * [Optional] A flag to enable or disable the use of the field redaction for urls.
+         * @defaultValue true
+         */
+        redactUrls?: boolean;
+        /**
+         * [Optional] Additional query parameters to redact beyond the default set.
+         * Use this to specify custom parameters that contain sensitive information.
+         * These will be combined with the default parameters that are redacted.
+         * @defaultValue ["sig", "Signature", "AWSAccessKeyId", "X-Goog-Signature"]
+         * @example ["sig", "Signature", "AWSAccessKeyId", "X-Goog-Signature","auth_token", "api_key", "private_data"]
+         */
+        redactQueryParams?: string[];
+        /**
+         * [Optional] Controls if the SDK should look for the `traceparent` and/or `tracestate` values from
+         * the service timing headers or meta tags from the initial page load.
+         * @defaultValue eTraceHeadersMode.All
+         */
+        traceHdrMode?: eTraceHeadersMode;
     }
 
     interface ICookieMgr {
@@ -1377,6 +1582,180 @@ declare namespace ApplicationInsights {
         delCookie?: (name: string, cookieValue: string) => void;
     }
 
+    interface ICorrelationConfig {
+        enableCorsCorrelation: boolean;
+        /**
+         * [Optional] Domains to be excluded from correlation headers.
+         * To override or discard the default, add an array with all domains to be excluded or
+         * an empty array to the configuration.
+         *
+         * @example
+         * ```ts
+         * import { ApplicationInsights } from '@microsoft/applicationinsights-web';
+         * const appInsights = new ApplicationInsights({
+         *    config: {
+         *       connectionString: 'InstrumentationKey=YOUR_INSTRUMENTATION_KEY_GOES_HERE',
+         *       extensionConfig: {
+         *          AjaxDependencyPlugin: {
+         *              // Both arrays of strings are used to match the request URL against the
+         *              // current host and the request URL to determine if correlation headers
+         *              // The strings are converted to RegExp objects by translating
+         *              // - `.` to `\\.` (to match a literal dot)
+         *              // - `*` to `.*` (to match any character)
+         *              // - `\` to `\\` (to match a literal slash)
+         *              // All other characters are ignored and passed to the RegExp constructor
+         *              correlationHeaderExcludedDomains: ["test", "*.azure.com", "ignore.microsoft.com"],
+         *              correlationHeaderDomains: ["azure.com", "prefix.bing.com", "*.microsoft.com", "example.com"]
+         *          }
+         *       }
+         * });
+         * appInsights.loadAppInsights();
+         * appInsights.trackPageView(); // Manually call trackPageView to establish the current user/session/pageview
+         * ```
+         */
+        correlationHeaderExcludedDomains: string[];
+        /**
+         * [Optional] Domains to be included in correlation headers.
+         * To override or discard the default, add an array with all domains to be included or
+         * an empty array to the configuration.
+         *
+         * @example
+         * ```ts
+         * import { ApplicationInsights } from '@microsoft/applicationinsights-web';
+         * const appInsights = new ApplicationInsights({
+         *    config: {
+         *       connectionString: 'InstrumentationKey=YOUR_INSTRUMENTATION_KEY_GOES_HERE',
+         *       extensionConfig: {
+         *          AjaxDependencyPlugin: {
+         *              // Values MUST be RegExp objects
+         *              correlationHeaderExcludePatterns: [/*\.azure.com/, /prefix.bing.com/, /.*\.microsoft.com/, /example.com/]
+         *          }
+         *       }
+         * });
+         * appInsights.loadAppInsights();
+         * appInsights.trackPageView(); // Manually call trackPageView to establish the current user/session/pageview
+         * ```
+         */
+        correlationHeaderExcludePatterns?: RegExp[];
+        disableCorrelationHeaders: boolean;
+        /**
+         * The distributed tracing mode to use for this configuration.
+         * Defaults to AI_AND_W3C.
+         * This is used to determine which headers are sent with requests and how the
+         * telemetry is correlated across services.
+         * @default AI_AND_W3C
+         * @see {@link DistributedTracingModes}
+         */
+        distributedTracingMode: DistributedTracingModes;
+        maxAjaxCallsPerView: number;
+        disableAjaxTracking: boolean;
+        disableFetchTracking: boolean;
+        appId?: string;
+        enableRequestHeaderTracking?: boolean;
+        enableResponseHeaderTracking?: boolean;
+        enableAjaxErrorStatusText?: boolean;
+        /**
+         * Flag to enable looking up and including additional browser window.performance timings
+         * in the reported ajax (XHR and fetch) reported metrics.
+         * Defaults to false.
+         */
+        enableAjaxPerfTracking?: boolean;
+        /**
+         * The maximum number of times to look for the window.performance timings (if available), this
+         * is required as not all browsers populate the window.performance before reporting the
+         * end of the XHR request and for fetch requests this is added after its complete
+         * Defaults to 3
+         */
+        maxAjaxPerfLookupAttempts?: number;
+        /**
+         * The amount of time to wait before re-attempting to find the windows.performance timings
+         * for an ajax request, time is in milliseconds and is passed directly to setTimeout()
+         * Defaults to 25.
+         */
+        ajaxPerfLookupDelay?: number;
+        /**
+         * [Optional] Domains to be excluded from correlation headers.
+         * To override or discard the default, add an array with all domains to be excluded or
+         * an empty array to the configuration.
+         *
+         * @example
+         * ```ts
+         * import { ApplicationInsights } from '@microsoft/applicationinsights-web';
+         * const appInsights = new ApplicationInsights({
+         *    config: {
+         *       connectionString: 'InstrumentationKey=YOUR_INSTRUMENTATION_KEY_GOES_HERE',
+         *       extensionConfig: {
+         *          AjaxDependencyPlugin: {
+         *              // Both arrays of strings are used to match the request URL against the
+         *              // current host and the request URL to determine if correlation headers
+         *              // The strings are converted to RegExp objects by translating
+         *              // - `.` to `\\.` (to match a literal dot)
+         *              // - `*` to `.*` (to match any character)
+         *              // - `\` to `\\` (to match a literal slash)
+         *              // All other characters are ignored and passed to the RegExp constructor
+         *              correlationHeaderExcludedDomains: ["test", "*.azure.com", "ignore.microsoft.com"],
+         *              correlationHeaderDomains: ["azure.com", "prefix.bing.com", "*.microsoft.com", "example.com"]
+         *          }
+         *       }
+         * });
+         * appInsights.loadAppInsights();
+         * appInsights.trackPageView(); // Manually call trackPageView to establish the current user/session/pageview
+         * ```
+         */
+        correlationHeaderDomains?: string[];
+        /**
+         * [Optional] Response and request headers to be excluded from AJAX & Fetch tracking data.
+         * To override or discard the default, add an array with all headers to be excluded or
+         * an empty array to the configuration.
+         *
+         * For example: `["Authorization", "X-API-Key", "WWW-Authenticate"]`
+         *
+         * @example
+         * ```js
+         * import { ApplicationInsights } from '@microsoft/applicationinsights-web';
+         * import { AjaxPlugin } from '@microsoft/applicationinsights-dependencies-js';
+         *
+         * const dependencyPlugin = new AjaxPlugin();
+         * const appInsights = new ApplicationInsights({
+         *     config: {
+         *         connectionString: 'InstrumentationKey=YOUR_INSTRUMENTATION_KEY_GOES_HERE',
+         *         extensions: [dependencyPlugin],
+         *         extensionConfig: {
+         *             AjaxDependencyPlugin: {
+         *                 ignoreHeaders: [
+         *                     "Authorization",
+         *                     "X-API-Key",
+         *                     "WWW-Authenticate"
+         *                 ]
+         *             }
+         *         }
+         *     }
+         * });
+         * appInsights.loadAppInsights();
+         * appInsights.trackPageView(); // Manually call trackPageView to establish the current user/session/pageview
+         * ```
+         */
+        ignoreHeaders?: string[];
+        /**
+         * Provide a way to exclude specific route from automatic tracking for XMLHttpRequest or Fetch request.
+         * For an ajax / fetch request that the request url matches with the regex patterns, auto tracking is turned off.
+         * Default is undefined.
+         */
+        excludeRequestFromAutoTrackingPatterns?: string[] | RegExp[];
+        /**
+         * Provide a way to enrich dependencies logs with context at the beginning of api call.
+         * Default is undefined.
+         */
+        addRequestContext?: (requestContext?: IRequestContext) => ICustomProperties;
+        /**
+         * [Optional] Flag to indicate whether the internal looking endpoints should be automatically
+         * added to the `excludeRequestFromAutoTrackingPatterns` collection. (defaults to true).
+         * This flag exists as the provided regex is generic and may unexpectedly match a domain that
+         * should not be excluded.
+         */
+        addIntEndpoints?: boolean;
+    }
+
     interface ICustomProperties {
         [key: string]: any;
     }
@@ -1473,6 +1852,12 @@ declare namespace ApplicationInsights {
          * https://www.w3.org/TR/trace-context/#trace-flags
          */
         traceFlags?: number;
+        /**
+         * The W3C TraceState object that contains the trace state information, this is mutable and changes made to this
+         * instance will be reflected in the distributed trace context. You cannot overwrite the traceState, but you can
+         * modify the values within the traceState.
+         */
+        readonly traceState?: IW3cTraceState;
         /**
          * [Optional] Context that the application can assign that will also be passed to any dependency initializer
          */
@@ -1573,8 +1958,13 @@ declare namespace ApplicationInsights {
          */
         getName(): string;
         /**
-         * Sets the current name of the page
+         * Sets the current name of the page, also updates the name for any parent context.
+         * This is used to identify the page in the telemetry data.
+         * @remarks This function updates the current and ALL parent contexts with the new name,
+         * to just update the name of the current context, use the `pageName` property.
          * @param pageName - The name of the page
+         * @deprecated Use the `pageName` property to avoid the side effect of changing the page name of all
+         * parent contexts.
          */
         setName(pageName: string): void;
         /**
@@ -1587,6 +1977,12 @@ declare namespace ApplicationInsights {
          * Set the unique identifier for a trace. All requests / spans from the same trace share the same traceId.
          * Must be conform to the W3C TraceContext specification, in a hex representation of 16-byte array.
          * A.k.a. trace-id, TraceID or Distributed TraceID https://www.w3.org/TR/trace-context/#trace-id
+         *
+         * @remarks Sets the traceId for the current context AND all parent contexts, if you want to set the traceId
+         * for the current context only, use the `traceId` property.
+         * @param newValue - The traceId to set
+         * @deprecated Use the `traceId` property to avoid the side effect of changing the traceId of all
+         * parent contexts.
          */
         setTraceId(newValue: string): void;
         /**
@@ -1598,6 +1994,12 @@ declare namespace ApplicationInsights {
          * Self-generated 8-bytes identifier of the incoming request. Must be a hex representation of 8-byte array.
          * Also know as the parentId, used to link requests together
          * https://www.w3.org/TR/trace-context/#parent-id
+         *
+         * @remarks Sets the spanId for the current context AND all parent contexts, if you want to set the spanId for
+         * the current context only, use the `spanId` property.
+         * @param newValue - The spanId to set
+         * @deprecated Use the `spanId` property to avoid the side effect of changing the spanId of all
+         * parent contexts.
          */
         setSpanId(newValue: string): void;
         /**
@@ -1606,9 +2008,80 @@ declare namespace ApplicationInsights {
         getTraceFlags(): number | undefined;
         /**
          * https://www.w3.org/TR/trace-context/#trace-flags
+         * @remarks Sets the trace flags for the current context and ALL  parent contexts, if you want to set the trace
+         * flags for the current context only, use the `traceFlags` property.
          * @param newValue - An integer representation of the W3C TraceContext trace-flags.
+         * @deprecated Use the `traceFlags` property to avoid the side effect of changing the traceFlags of all
+         * parent contexts.
          */
         setTraceFlags(newValue?: number): void;
+        /**
+         * Returns the current name of the page
+         * @remarks This function updates the current context only, to update the name of the current and ALL parent contexts,
+         * use the `setName` method.
+         * @default undefined
+         * @since 3.4.0
+         */
+        pageName: string;
+        /**
+         * The current ID of the trace that this span belongs to. It is worldwide unique
+         * with practically sufficient probability by being made as 16 randomly
+         * generated bytes, encoded as a 32 lowercase hex characters corresponding to
+         * 128 bits.
+         * @remarks If you update this value, it will only update for the current context, not the parent context,
+         * if you need to update the current and ALL parent contexts, use the `setTraceId` method.
+         * @since 3.4.0
+         */
+        traceId: string;
+        /**
+         * The ID of the Span. It is globally unique with practically sufficient
+         * probability by being made as 8 randomly generated bytes, encoded as a 16
+         * lowercase hex characters corresponding to 64 bits.
+         * If you update this value, it will only update for the current context, not the parent context.
+         * @remarks If you update this value, it will only update for the current context, not the parent context,
+         * if you need to update the current and ALL parent contexts, use the `setSpanId` method.
+         * @since 3.4.0
+         */
+        spanId: string;
+        /**
+         * Returns true if the current context was initialized (propagated) from a remote parent.
+         * @since 3.4.0
+         * @default false
+         * @returns True if the context was propagated from a remote parent
+         */
+        readonly isRemote: boolean;
+        /**
+         * Trace flags to propagate.
+         *
+         * It is represented as 1 byte (bitmap). Bit to represent whether trace is
+         * sampled or not. When set, the least significant bit documents that the
+         * caller may have recorded trace data. A caller who does not record trace
+         * data out-of-band leaves this flag unset.
+         *
+         * see {@link eW3CTraceFlags} for valid flag values.
+         *
+         * @remarks If you update this value, it will only update for the current context, not the parent context,
+         * if you need to update the current and ALL parent contexts, use the `setTraceFlags` method.
+         * @since 3.4.0
+         */
+        traceFlags?: number;
+        /**
+         * Returns the current trace state which will be used to propgate context across different services.
+         * Updating (adding / removing keys) of the trace state will modify the current context.
+         * @remarks Unlike the OpenTelemetry {@link TraceState}, this value is a mutable object, so you can
+         * modify it directly you do not need to reassign the new value to this property.
+         * @since 3.4.0
+         */
+        readonly traceState: IW3cTraceState;
+        /**
+         * Provides access to the parent context of the current context.
+         * @remarks This is a read-only property, you cannot modify the parent context directly, you can only
+         * modify the current context. If you need to modify the parent context, you need to do it through the
+         * current context using the `setTraceId`, `setSpanId`, `setTraceFlags` and `setName` methods.
+         * @default null
+         * @since 3.4.0
+         */
+        readonly parentCtx?: IDistributedTraceContext | null;
     }
 
     /**
@@ -1697,7 +2170,7 @@ declare namespace ApplicationInsights {
     }
 
     interface IInstrumentationRequirements extends IDependenciesPlugin {
-        [_DYN_INCLUDE_CORRELATION_0]: (ajaxData: ajaxRecord, input?: Request | string, init?: RequestInit, xhr?: XMLHttpRequestInstrumented) => any;
+        [_DYN_INCLUDE_CORRELATION_0]: (ajaxData: IAjaxRecordData, input?: Request | string, init?: RequestInit, xhr?: XMLHttpRequestInstrumented) => any;
     }
 
     /**
@@ -2404,9 +2877,10 @@ declare namespace ApplicationInsights {
      */
     interface ITelemetryPlugin extends ITelemetryProcessor, IPlugin {
         /**
-         * Set next extension for telemetry processing, this is not optional as plugins should use the
+         * Set next extension for telemetry processing, this is now optional as plugins should use the
          * processNext() function of the passed IProcessTelemetryContext instead. It is being kept for
          * now for backward compatibility only.
+         * @deprecated - Use processNext() function of the passed IProcessTelemetryContext instead
          */
         setNextPlugin?: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
         /**
@@ -2669,12 +3143,6 @@ declare namespace ApplicationInsights {
         enabled: boolean;
     }
 
-    interface ITraceCtx {
-        traceId: string;
-        spanId: string;
-        traceFlags: number;
-    }
-
     /**
      * An interface which provides automatic removal during unloading of the component
      */
@@ -2694,6 +3162,76 @@ declare namespace ApplicationInsights {
         run: (logger?: IDiagnosticLogger) => void;
     }
 
+    /**
+     * Represents a mutable [W3C trace state list](https://www.w3.org/TR/trace-context/#tracestate-header), this is a
+     * list of key/value pairs that are used to pass trace state information between different tracing systems. The
+     * list is ordered and the order is important as it determines the processing order.
+     *
+     * Importantly instances of this type are mutable, change made to an instance via {@link IW3cTraceState.set} or
+     * {@link IW3cTraceState.del} will be reflected on the instance and any child instances that use it as a parent.
+     * However, any parent instance associated with an instance will not be modified by operations on that particular
+     * instance.
+     *
+     * @since 3.4.0
+     */
+    interface IW3cTraceState {
+        /**
+         * Returns a readonly array of the current keys associated with the trace state, keys are returned in the
+         * required processing order and if this instance has a parent the keys from the parent will be included
+         * unless they have been removed (deleted) from the child instance.
+         * Once created any modifications to the parent will also be reflected in the child, this is different from
+         * the OpenTelemetry implementation which creates a new instance for each call.
+         * @returns A readonly array of the current keys associated with the trace state
+         */
+        readonly keys: string[];
+        /**
+         * Check if the trace state list is empty, meaning it has no keys or values.
+         * This exists to allow for quick checks without needing to create a new array of keys.
+         * @since 3.4.0
+         * @returns true if the trace state list is empty, false otherwise
+         */
+        readonly isEmpty: boolean;
+        /**
+         * Get the value for the specified key that is associated with this instance, either directly or from the parent.
+         * @param key - The key to lookup
+         * @returns The value for the key, or undefined if not found
+         */
+        get(key: string): string | undefined;
+        /**
+         * Set the value for the specified key for this instance, returning its new location within the list.
+         * - 0 is the front of the list
+         * - -1 not set because the key/value pair is invalid
+         * If the key already exists it will be removed from its current location and added to the front of the list. And
+         * if the key was in the parent this will override the value inherited from the parent, more importantly it will
+         * not modify the parent value.
+         * @param key - The key to set
+         * @param value - The value to set
+         * @returns 0 if successful, -1 if not
+         */
+        set(key: string, value: string): number;
+        /**
+         * Delete the specified key from this instance, if the key was in the parent it will be removed (hidden) from
+         * this instance but will still be available directly from the parent.
+         * @param key - The key to delete
+         */
+        del(key: string): void;
+        /**
+         * Format the trace state list into a strings where each string can be used as a header value.
+         * This will return an empty array if the trace state list is empty.
+         * @param maxHeaders - The maximum number of entries to include in the output, once the limit is reached no more entries will be included
+         * @param maxKeys - The maximum number of keys to include in the output, once the limit is reached no more keys will be included
+         * @param maxLen - The maximum length of each header value, once the limit is reached a new header value will be created
+         * @returns An array of strings that can be used for the header values, if the trace state list is empty an empty array will be returned
+         */
+        hdrs(maxHeaders?: number, maxKeys?: number, maxLen?: number): string[];
+        /**
+         * Create a new instance of IW3cTraceState which is a child of this instance, meaning it will inherit the keys
+         * and values from this instance but any changes made to the child will not affect this instance.
+         * @returns A new instance of IW3cTraceState which is a child of this instance
+         */
+        child(): IW3cTraceState;
+    }
+
     interface IWatchDetails<T = IConfiguration> {
         /**
          * The current config object
@@ -2728,6 +3266,17 @@ declare namespace ApplicationInsights {
         rdOnly: <C, V = any>(target: C, name: string) => V;
     }
 
+    /**
+     * Interface defining the XHR monitoring state properties
+     */
+    interface IXHRMonitoringState {
+        openDone: boolean;
+        setRequestHeaderDone: boolean;
+        sendDone: boolean;
+        abortDone: boolean;
+        stateChangeAttached: boolean;
+    }
+
     const LoggingSeverity: EnumValue<typeof eLoggingSeverity>;
 
     type LoggingSeverity = number | eLoggingSeverity;
@@ -2846,15 +3395,6 @@ declare namespace ApplicationInsights {
 
     type WatcherFunction<T = IConfiguration> = (details: IWatchDetails<T>) => void;
 
-    class XHRMonitoringState {
-        openDone: boolean;
-        setRequestHeaderDone: boolean;
-        sendDone: boolean;
-        abortDone: boolean;
-        stateChangeAttached: boolean;
-        constructor();
-    }
-
     interface XMLHttpRequestData {
         /**
          * The "Shared" XHR headers, avoids causing multiple instances
@@ -2867,7 +3407,7 @@ declare namespace ApplicationInsights {
          * The individual tracking data for each AI instance
          */
         i: {
-            [key: string]: ajaxRecord;
+            [key: string]: IAjaxRecordInternal;
         };
     }