Enable SDK Stats and route to the SDK Stats ingestion endpoint

.aiAutoMinify.json

@@ -22,7 +22,6 @@
                 "eLoggingSeverity",
                 "_eInternalMessageId",
                 "SendRequestReason",
-                "eStatsType",
                 "TelemetryUnloadReason",
                 "TelemetryUpdateReason",
                 "eTraceHeadersMode",

AISKU/Tests/Manual/testVersionConflict.html

@@ -20,7 +20,7 @@
     // onInit: null, // Once the application insights instance has loaded and initialized this callback function will be called with 1 argument -- the sdk instance (DO NOT ADD anything to the sdk.queue -- As they won't get called)
     sri: true, // Custom optional value to specify whether fetching the snippet from integrity file and do integrity check 
     cfg: { // Application Insights Configuration
-        disableStatsBeat: false,
+        disableInternalSdkStats: false,
         connectionString: "YOUR_INSTRUMENTATION_KEY",
     }
 });

AISKU/Tests/Unit/src/AISKUSize.Tests.ts

@@ -54,10 +54,10 @@ function _checkSize(checkType: string, maxSize: number, size: number, isNightly:
 }
 
 export class AISKUSizeCheck extends AITestClass {
-    private readonly MAX_RAW_SIZE = 177;
-    private readonly MAX_BUNDLE_SIZE = 177;
-    private readonly MAX_RAW_DEFLATE_SIZE = 71;
-    private readonly MAX_BUNDLE_DEFLATE_SIZE = 71;
+    private readonly MAX_RAW_SIZE = 181;
+    private readonly MAX_BUNDLE_SIZE = 183;
+    private readonly MAX_RAW_DEFLATE_SIZE = 74;
+    private readonly MAX_BUNDLE_DEFLATE_SIZE = 74;
     private readonly rawFilePath = "../dist/es5/applicationinsights-web.min.js";
     // Automatically updated by version scripts
     private readonly currentVer = "3.4.4";

AISKU/Tests/Unit/src/SdkStatsFeature.tests.ts

@@ -1,6 +1,8 @@
 import { ApplicationInsights, IConfig, IConfiguration } from '../../../src/applicationinsights-web';
 import { AITestClass, Assert } from '@microsoft/ai-test-framework';
-import { FeatureOptInMode, ISdkStatsNotifCbk, onConfigChange } from '@microsoft/applicationinsights-core-js';
+import {
+    _eInternalMessageId, FeatureOptInMode, ISdkStatsNotifCbk, onConfigChange, STATS_SDK_FEATURE
+} from '@microsoft/applicationinsights-core-js';
 import { AppInsightsSku } from '../../../src/AISku';
 import { ICfgSyncMode } from '@microsoft/applicationinsights-cfgsync-js';
 
@@ -37,9 +39,12 @@ export class SdkStatsFeatureTests extends AITestClass {
     public registerTests() {
         this._testSdkStatsEnabledByDefault();
         this._testSdkStatsDisabledViaFeatureOptIn();
+        this._testCustomerSdkStatsIgnoresInternalThrottle();
         this._testSdkStatsDynamicEnableDisable();
         this._testSdkStatsConfigDefaults();
         this._testSdkStatsDynamicConfigChanges();
+        this._testInternalSdkStatsDynamicConfigInitialization();
+        this._testSnippetSdkVersion();
     }
 
     private _createAi(configOverrides?: Partial<IConfiguration & IConfig>): AppInsightsSku {
@@ -132,6 +137,34 @@ export class SdkStatsFeatureTests extends AITestClass {
         });
     }
 
+    private _testCustomerSdkStatsIgnoresInternalThrottle() {
+        this.testCase({
+            name: "SdkStatsFeature: dedicated SDK Stats throttle does not disable customer SDK Stats",
+            useFakeTimers: true,
+            test: () => {
+                let ai = this._createAi({
+                    throttleMgrCfg: {
+                        [STATS_SDK_FEATURE]: {
+                            disabled: false,
+                            limit: {
+                                samplingRate: 0
+                            }
+                        }
+                    }
+                });
+                this.clock.tick(1);
+
+                Assert.ok(this._findSdkStatsListener(ai),
+                    "Customer SDK Stats should remain enabled when dedicated SDK Stats are throttled");
+                Assert.ok(ai["core"].getSdkStats({
+                    cKey: TestInstrumentationKey,
+                    endpoint: "https://example.endpoint.com",
+                    sdkVer: "1.0.0"
+                }), "The throttle should apply to SDK Stats operations without disabling the manager");
+            }
+        });
+    }
+
     private _testSdkStatsDynamicEnableDisable() {
         this.testCase({
             name: "SdkStatsFeature: disabling SdkStats feature dynamically removes the listener",
@@ -220,6 +253,11 @@ export class SdkStatsFeatureTests extends AITestClass {
                 let config = ai.config;
                 Assert.ok(config.sdkStats, "sdkStats config should exist after initialization");
                 Assert.equal(900000, config.sdkStats!.int, "int should default to 900000 (15 minutes)");
+                Assert.equal(100, config.throttleMgrCfg![STATS_SDK_FEATURE].limit!.samplingRate,
+                    "Dedicated SDK Stats throttle should use the legacy default sampling rate");
+                Assert.equal(92 * 24 * 60 * 60 * 1000 / config.sdkStats!.int,
+                    config.throttleMgrCfg![STATS_SDK_FEATURE].limit!.maxSendNumber,
+                    "Dedicated SDK Stats throttle should cover 15-minute intervals across the longest three-month window");
             }
         });
 
@@ -230,13 +268,27 @@ export class SdkStatsFeatureTests extends AITestClass {
                 let ai = this._createAi({
                     sdkStats: {
                         int: 60000
+                    },
+                    throttleMgrCfg: {
+                        [STATS_SDK_FEATURE]: {
+                            limit: {
+                                maxSendNumber: 48
+                            }
+                        }
                     }
                 });
                 this.clock.tick(1);
 
                 let config = ai.config;
                 Assert.ok(config.sdkStats, "sdkStats config should exist");
                 Assert.equal(60000, config.sdkStats!.int, "User-provided int should be preserved");
+                Assert.equal(48, config.throttleMgrCfg![STATS_SDK_FEATURE].limit!.maxSendNumber,
+                    "User-provided maxSendNumber should be preserved");
+
+                config.throttleMgrCfg![STATS_SDK_FEATURE].limit!.maxSendNumber = 192;
+                this.clock.tick(1);
+                Assert.equal(192, config.throttleMgrCfg![STATS_SDK_FEATURE].limit!.maxSendNumber,
+                    "maxSendNumber should support runtime updates");
             }
         });
     }
@@ -303,4 +355,113 @@ export class SdkStatsFeatureTests extends AITestClass {
             }
         });
     }
+
+    private _testInternalSdkStatsDynamicConfigInitialization() {
+        this.testCase({
+            name: "SdkStatsFeature: internal SDK Stats initializes when dynamic configuration arrives after loadAppInsights",
+            useFakeTimers: true,
+            useFakeServer: true,
+            test: () => {
+                const cfgUrl = "https://tst-data.stats.monitor.azure.com/cfg/v1.json";
+                const statsHost = "tst-data.stats.monitor.azure.com";
+                const statsIKey = "000e0000-e000-0000-a000-000000000000";
+                const state = {
+                    cKey: TestInstrumentationKey,
+                    endpoint: "https://dynamic-config.example.com/v2/track",
+                    sdkVer: "1.0.0"
+                };
+                const storageKey = state.cKey + ":" + state.endpoint;
+                sessionStorage.removeItem(storageKey);
+                this.onDone(() => sessionStorage.removeItem(storageKey));
+                this.hookSendBeacon(() => {});
+                this.hookFetch((resolve) => resolve(new Response("{}", { status: 200 })));
+                let xhrSendSpy = this.sandbox.spy(XMLHttpRequest.prototype, "send");
+
+                let ai = this._createAi();
+                this.clock.tick(1);
+
+                Assert.ok(ai.config.stats, "loadAppInsights should seed the dynamic stats configuration");
+                Assert.equal(undefined, ai.config.stats.cfgUrl, "The SDK Stats config URL should not be supplied initially");
+                Assert.equal(undefined, ai.config.stats.iKey, "The SDK Stats instrumentation key should not be supplied initially");
+                let stats = ai.core.getSdkStats(state);
+                Assert.ok(stats && stats.enabled, "loadAppInsights should initialize the internal SDK Stats manager");
+                stats.countException(state.endpoint, "NetworkError");
+                this.clock.tick(1000);
+                Assert.equal(0, this.activeXhrRequests.length, "SDK Stats should not send before configuration arrives");
+
+                let fetchedUrls: string[] = [];
+                ai.updateCfg({
+                    stats: {
+                        shrtInt: 1,
+                        cfgUrl: cfgUrl,
+                        iKey: statsIKey,
+                        overrideCfgFn: (url, oncomplete) => {
+                            fetchedUrls.push(url);
+                            oncomplete({ enabled: true, url: statsHost });
+                        }
+                    },
+                    throttleMgrCfg: {
+                        [_eInternalMessageId.DefaultThrottleMsgKey]: { disabled: false },
+                        [STATS_SDK_FEATURE]: {
+                            limit: { samplingRate: 1000000 },
+                            interval: { dayInterval: 1 }
+                        }
+                    }
+                });
+                this.clock.tick(1002);
+
+                Assert.deepEqual([cfgUrl], fetchedUrls,
+                    "The existing manager should use the dynamically supplied config fetcher and URL");
+                Assert.strictEqual(stats, ai.core.getSdkStats(state),
+                    "Configuration should initialize sending without replacing the stats instance");
+                let requests = this.activeXhrRequests;
+                Assert.equal(1, requests.length, "The isolated SDK Stats sender should send the buffered counter");
+                Assert.equal("https://" + statsHost + "/v2/track", requests[0].url, "SDK Stats should use the remote-configured endpoint");
+                let payload = JSON.parse(xhrSendSpy.firstCall.args[0]);
+                Assert.equal(statsIKey, payload[0].iKey, "SDK Stats should use the dynamically supplied instrumentation key");
+                Assert.equal("exception", payload[0].data.baseData.metrics[0].name, "The buffered exception should be reported");
+                Assert.equal(1, payload[0].data.baseData.metrics[0].value, "The buffered exception count should be preserved");
+                requests[0].respond(200, {}, "");
+
+                ai.config.featureOptIn = {
+                    [STATS_SDK_FEATURE]: { mode: FeatureOptInMode.disable }
+                };
+                this.clock.tick(1);
+                Assert.equal(null, ai.core.getSdkStats(state),
+                    "Disabling the internal feature dynamically should remove its stats instance");
+                Assert.equal(false, stats.enabled, "The previous stats instance should be stopped");
+
+                ai.config.featureOptIn[STATS_SDK_FEATURE].mode = FeatureOptInMode.enable;
+                this.clock.tick(1);
+                let reenabledStats = ai.core.getSdkStats(state);
+                Assert.ok(reenabledStats && reenabledStats.enabled, "Re-enabling the internal feature should initialize stats again");
+            }
+        });
+    }
+
+    private _testSnippetSdkVersion() {
+        this.testCase({
+            name: "SdkStatsFeature: snippet version is included in the SDK Stats version",
+            useFakeTimers: true,
+            test: () => {
+                let config = {
+                    connectionString: TestConnectionString,
+                    stats: {},
+                    extensionConfig: {
+                        ["AppInsightsCfgSyncPlugin"]: {
+                            syncMode: ICfgSyncMode.Receive,
+                            cfgUrl: ""
+                        }
+                    }
+                } as IConfiguration & IConfig;
+                let ai = new AppInsightsSku({ config: config, sv: "6", queue: [] } as any);
+                ai.loadAppInsights();
+                this._ai = ai;
+                this.clock.tick(1);
+
+                Assert.equal("6", ai.config.stats.snp, "SDK Stats config should contain snippet version 6");
+            }
+        });
+    }
+
 }

AISKU/src/AISku.ts

@@ -13,12 +13,12 @@ import {
     IMetricTelemetry, INotificationManager, IOTelApi, IOTelSpanOptions, IPageViewPerformanceTelemetry, IPageViewTelemetry, IPlugin,
     IReadableSpan, IRequestHeaders, ISdkStatsNotifCbk, ISpanScope, ITelemetryContext as Common_ITelemetryContext,
     ITelemetryInitializerHandler, ITelemetryItem, ITelemetryPlugin, ITelemetryUnloadState, IThrottleInterval, IThrottleLimit,
-    IThrottleMgrConfig, ITraceApi, ITraceProvider, ITraceTelemetry, IUnloadHook, OTelTimeInput, PropertiesPluginIdentifier, ThrottleMgr,
-    UnloadHandler, WatcherFunction, _eInternalMessageId, _throwInternal, addPageHideEventListener, addPageUnloadEventListener, cfgDfMerge,
-    cfgDfValidate, createDynamicConfig, createOTelApi, createProcessTelemetryContext, createSdkStatsNotifCbk, createTraceProvider,
-    createUniqueNamespace, doPerf, eLoggingSeverity, hasDocument, hasWindow, isArray, isFeatureEnabled, isFunction, isNullOrUndefined,
-    isReactNative, isString, mergeEvtNamespace, onConfigChange, parseConnectionString, proxyAssign, proxyFunctions,
-    removePageHideEventListener, removePageUnloadEventListener, useSpan
+    IThrottleMgrConfig, ITraceApi, ITraceProvider, ITraceTelemetry, IUnloadHook, OTelTimeInput, PropertiesPluginIdentifier,
+    STATS_SDK_FEATURE, ThrottleMgr, UnloadHandler, WatcherFunction, _eInternalMessageId, _throwInternal, addPageHideEventListener,
+    addPageUnloadEventListener, cfgDfMerge, cfgDfValidate, createDynamicConfig, createOTelApi, createProcessTelemetryContext,
+    createSdkStatsNotifCbk, createStatsMgr, createTraceProvider, createUniqueNamespace, doPerf, eLoggingSeverity, hasDocument, hasWindow,
+    isArray, isFeatureEnabled, isFunction, isNullOrUndefined, isReactNative, isString, mergeEvtNamespace, onConfigChange,
+    parseConnectionString, proxyAssign, proxyFunctions, removePageHideEventListener, removePageUnloadEventListener, useSpan
 } from "@microsoft/applicationinsights-core-js";
 import {
     AjaxPlugin as DependenciesPlugin, DependencyInitializerFunction, DependencyListenerFunction, IDependencyInitializerHandler,
@@ -84,6 +84,14 @@ const default_throttle_config = {
     interval: cfgDfMerge<IThrottleInterval>(default_interval)
 } as IThrottleMgrConfig;
 
+const sdk_stats_throttle_config = {
+    disabled: false,
+    limit: cfgDfMerge<IThrottleLimit>({
+        samplingRate: 100,
+        maxSendNumber: 8832 // Longest three-month window: 92 days * 24 hours * 4 reports per hour
+    })
+} as IThrottleMgrConfig;
+
 // We need to include all properties that we only reference that we want to be dynamically updatable here
 // So they are converted even when not specified in the passed configuration
 const defaultConfigValues: IConfigDefaults<IConfiguration & IConfig> = {
@@ -102,12 +110,13 @@ const defaultConfigValues: IConfigDefaults<IConfiguration & IConfig> = {
     sdkStats: cfgDfMerge({
         int: 900000
     }),
-    throttleMgrCfg: cfgDfMerge<{[key:number]: IThrottleMgrConfig}>(
+    throttleMgrCfg: cfgDfMerge<{[key: string]: IThrottleMgrConfig}>(
         {
             [_eInternalMessageId.DefaultThrottleMsgKey]:cfgDfMerge<IThrottleMgrConfig>(default_throttle_config),
             [_eInternalMessageId.InstrumentationKeyDeprecation]:cfgDfMerge<IThrottleMgrConfig>(default_throttle_config),
             [_eInternalMessageId.SdkLdrUpdate]:cfgDfMerge<IThrottleMgrConfig>(default_throttle_config),
-            [_eInternalMessageId.CdnDeprecation]:cfgDfMerge<IThrottleMgrConfig>(default_throttle_config)
+            [_eInternalMessageId.CdnDeprecation]:cfgDfMerge<IThrottleMgrConfig>(default_throttle_config),
+            [STATS_SDK_FEATURE]: cfgDfMerge<IThrottleMgrConfig>(sdk_stats_throttle_config)
         }
     ),
     extensionConfig: cfgDfMerge<{[key: string]: any}>({
@@ -398,21 +407,46 @@ export class AppInsightsSku implements IApplicationInsights<IConfiguration & ICo
                     // initialize core
                     _core.initialize(_config, [ _sender, properties, dependencies, _analyticsPlugin, _cfgSyncPlugin], logger, notificationManager);
 
+                    if (!_throttleMgr){
+                        _throttleMgr = new ThrottleMgr(_core);
+                    }
+
+                    // Enable SDK Stats collection. The manager reads its configuration directly from the
+                    // single global config (config.stats) and gates itself behind the SDK Stats feature
+                    // flag, routing the resulting events to the distro-owned SDK Stats ingestion endpoint.
+                    // The config url and iKey are supplied by config.stats, until both are present no
+                    // SDK Stats are sent. Opt-out via featureOptIn "sdkStats".
+                    let statsMgr = createStatsMgr();
+                    _core.setStatsMgr(statsMgr);
+                    _core.addUnloadHook(statsMgr.init<IConfiguration & IConfig>(_core, (statsConfig) => {
+                        try {
+                            let statsCore = new AppInsightsCore();
+                            (statsConfig as IConfiguration & IConfig).maxBatchInterval = 1;
+                            statsCore.initialize(statsConfig as IConfiguration & IConfig, [new Sender()]);
+                            return statsCore;
+                        } catch (e) {
+                            _throwInternal(_core.logger, eLoggingSeverity.WARNING,
+                                _eInternalMessageId.InternalSdkStatsManagerException, "Failed to create SDK Stats core");
+                            return null;
+                        }
+                    }, STATS_SDK_FEATURE, _throttleMgr.useFeature));
+
                     // Initialize the initial OTel API
                     _otelApi = _initOTel(_self, "aisku", _onEnd, _onException);
 
                     objDefine(_self, "context", {
                         g: () => properties.context
                     });
 
-                    if (!_throttleMgr){
-                        _throttleMgr = new ThrottleMgr(_core);
-                    }
                     let sdkSrc = _findSdkSourceFile();
                     if (sdkSrc && _self.context) {
                         _self.context.internal.sdkSrc = sdkSrc;
                     }
                     _updateSnippetProperties(_self.snippet);
+
+                    if (_config.stats) {
+                        _config.stats.snp = _snippetVersion;
+                    }
 
                     // Empty queue of all api calls logged prior to sdk download
                     _self.emptyQueue();