@microsoft/applicationinsights-common 2.8.9-nightly.2210-05 → 2.8.9

package/dist/applicationinsights-common.api.md

@@ -6,9 +6,11 @@
 
 import { createTraceParent } from '@microsoft/applicationinsights-core-js';
 import { _eInternalMessageId } from '@microsoft/applicationinsights-core-js';
+import { eLoggingSeverity } from '@microsoft/applicationinsights-core-js';
 import { EnumValue } from '@microsoft/applicationinsights-core-js';
 import { findW3cTraceParent } from '@microsoft/applicationinsights-core-js';
 import { formatTraceParent } from '@microsoft/applicationinsights-core-js';
+import { IAppInsightsCore } from '@microsoft/applicationinsights-core-js';
 import { IChannelControls } from '@microsoft/applicationinsights-core-js';
 import { IConfiguration } from '@microsoft/applicationinsights-core-js';
 import { ICookieMgr } from '@microsoft/applicationinsights-core-js';
@@ -889,6 +891,50 @@ export interface ITelemetryTrace {
     traceState?: ITraceState;
 }
 
+// @public
+export interface IThrottleInterval {
+    dayInterval?: number;
+    maxTimesPerMonth?: number;
+    monthInterval?: number;
+}
+
+// @public
+export interface IThrottleLimit {
+    maxSendNumber?: number;
+    samplingRate?: number;
+}
+
+// @public
+export interface IThrottleLocalStorageObj {
+    count: number;
+    date: Date;
+    preTriggerDate?: Date;
+}
+
+// @public
+export interface IThrottleMgrConfig {
+    disabled?: boolean;
+    interval?: IThrottleInterval;
+    limit?: IThrottleLimit;
+    msgKey: IThrottleMsgKey;
+}
+
+// @public (undocumented)
+export const enum IThrottleMsgKey {
+    // (undocumented)
+    cdnDeprecate = 2,
+    // (undocumented)
+    default = 0,
+    // (undocumented)
+    ikeyDeprecate = 1
+}
+
+// @public
+export interface IThrottleResult {
+    isThrottled: boolean;
+    throttleNum: number;
+}
+
 export { ITraceParent }
 
 // @public (undocumented)
@@ -1201,6 +1247,25 @@ export class TelemetryItemCreator {
     static create: typeof createTelemetryItem;
 }
 
+// @public (undocumented)
+export class ThrottleMgr {
+    constructor(throttleMgr?: IThrottleMgrConfig, core?: IAppInsightsCore, namePrefix?: string);
+    // (undocumented)
+    canThrottle: () => boolean;
+    // (undocumented)
+    flush: () => boolean;
+    // (undocumented)
+    getConfig: () => IThrottleMgrConfig;
+    // (undocumented)
+    isReady: () => boolean;
+    // (undocumented)
+    isTriggered: () => boolean;
+    // (undocumented)
+    onReadyState: (isReady?: boolean) => boolean;
+    // (undocumented)
+    sendMessage: (msgID: _eInternalMessageId, message: string, severity?: eLoggingSeverity) => IThrottleResult | null;
+}
+
 // Warning: (ae-forgotten-export) The symbol "IMessageData" needs to be exported by the entry point applicationinsights-common.d.ts
 //
 // @public (undocumented)

package/dist/applicationinsights-common.d.ts

@@ -1,5 +1,5 @@
 /*
- * Microsoft Application Insights Common JavaScript Library, 2.8.9-nightly.2210-05
+ * Microsoft Application Insights Common JavaScript Library, 2.8.9
  * Copyright (c) Microsoft and contributors. All rights reserved.
  *
  * Microsoft Application Insights Team
@@ -9,9 +9,11 @@
 declare namespace ApplicationInsights {
     import { createTraceParent } from '@microsoft/applicationinsights-core-js';
     import { _eInternalMessageId } from '@microsoft/applicationinsights-core-js';
+    import { eLoggingSeverity } from '@microsoft/applicationinsights-core-js';
     import { EnumValue } from '@microsoft/applicationinsights-core-js';
     import { findW3cTraceParent } from '@microsoft/applicationinsights-core-js';
     import { formatTraceParent } from '@microsoft/applicationinsights-core-js';
+    import { IAppInsightsCore } from '@microsoft/applicationinsights-core-js';
     import { IChannelControls } from '@microsoft/applicationinsights-core-js';
     import { IConfiguration } from '@microsoft/applicationinsights-core-js';
     import { ICookieMgr } from '@microsoft/applicationinsights-core-js';
@@ -2029,6 +2031,110 @@ declare namespace ApplicationInsights {
         name?: string;
     }
 
+    /**
+     * Identifies frequency of items sent
+     * Default: send data on 28th every 3 month each year
+     */
+    interface IThrottleInterval {
+        /**
+         * Identifies month interval that items can be sent
+         * For example, if it is set to 2 and start date is in Jan, items will be sent out every two months (Jan, March, May etc.)
+         * Default: 3
+         */
+        monthInterval?: number;
+        /**
+         * Identifies days that items can be sent within a month
+         * Default: 28
+         */
+        dayInterval?: number;
+        /**
+         * Identifies max times items can be sent within a month
+         * Default: 1
+         */
+        maxTimesPerMonth?: number;
+    }
+
+    /**
+     * Identifies limit number/percentage of items sent per time
+     * If both are provided, minimum number between the two will be used
+     */
+    interface IThrottleLimit {
+        /**
+         * Identifies sampling percentage of items per time
+         * The percentage is set to 4 decimal places, for example: 1 means 0.0001%
+         * Default: 100 (0.01%)
+         */
+        samplingRate?: number;
+        /**
+         * Identifies limit number of items per time
+         * Default: 1
+         */
+        maxSendNumber?: number;
+    }
+
+    /**
+     * Identifies object for local storage
+     */
+    interface IThrottleLocalStorageObj {
+        /**
+         * Identifies start date
+         */
+        date: Date;
+        /**
+         * Identifies current count
+         */
+        count: number;
+        /**
+         * identifies previous triggered throttle date
+         */
+        preTriggerDate?: Date;
+    }
+
+    /**
+     * Identifies basic config
+     */
+    interface IThrottleMgrConfig {
+        /**
+         * Identifies message key to be used for local storage key
+         */
+        msgKey: IThrottleMsgKey;
+        /**
+         * Identifies if throttle is disabled
+         * Default: false
+         */
+        disabled?: boolean;
+        /**
+         * Identifies limit number/percentage of items sent per time
+         */
+        limit?: IThrottleLimit;
+        /**
+         * Identifies frequency of items sent
+         * Default: send data on 28th every 3 month each year
+         */
+        interval?: IThrottleInterval;
+    }
+
+    const enum IThrottleMsgKey {
+        default = 0,
+        ikeyDeprecate = 1,
+        cdnDeprecate = 2
+    }
+
+    /**
+     * Identifies throttle result
+     */
+    interface IThrottleResult {
+        /**
+         * Identifies if items are sent
+         */
+        isThrottled: boolean;
+        /**
+         * Identifies numbers of items are sent
+         * if isThrottled is false, it will be set to 0
+         */
+        throttleNum: number;
+    }
+
     export { ITraceParent }
 
     interface ITraceState {
@@ -2596,6 +2702,17 @@ declare namespace ApplicationInsights {
         static create: typeof createTelemetryItem;
     }
 
+    class ThrottleMgr {
+        canThrottle: () => boolean;
+        sendMessage: (msgID: _eInternalMessageId, message: string, severity?: eLoggingSeverity) => IThrottleResult | null;
+        getConfig: () => IThrottleMgrConfig;
+        isTriggered: () => boolean;
+        isReady: () => boolean;
+        onReadyState: (isReady?: boolean) => boolean;
+        flush: () => boolean;
+        constructor(throttleMgr?: IThrottleMgrConfig, core?: IAppInsightsCore, namePrefix?: string);
+    }
+
     class Trace implements IMessageData, ISerializable {
         static envelopeType: string;
         static dataType: string;

package/dist/applicationinsights-common.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Common, 2.8.9-nightly.2210-05
+ * Application Insights JavaScript SDK - Common, 2.8.9
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -102,6 +102,7 @@
 
     var _DYN_NAME$1 = "name";
     var _DYN_PUSH = "push";
+    var _DYN_LOGGER = "logger";
     var _DYN_LENGTH$1 = "length";
     var _DYN_MESSAGE_ID = "messageId";
     var _DYN_MESSAGE$1 = "message";
@@ -973,6 +974,9 @@
         _InternalLogMessage.dataType = "MessageData";
         return _InternalLogMessage;
     }());
+    function safeGetLogger(core, config) {
+        return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
+    }
     var DiagnosticLogger = /** @class */ (function () {
         function DiagnosticLogger(config) {
             this.identifier = "DiagnosticLogger";
@@ -1172,7 +1176,7 @@
     }
 
     var _objDefineProperty = ObjDefineProperty;
-    var version = "2.8.9-nightly.2210-05";
+    var version = '2.8.9';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _createAccessor(target, prop, value) {
@@ -1846,6 +1850,14 @@
     var _DYN_TO_STRING = "toString";
     var _DYN_REMOVE_ITEM = "removeItem";
     var _DYN_NAME = "name";
+    var _DYN_MESSAGE = "message";
+    var _DYN_COUNT = "count";
+    var _DYN_PRE_TRIGGER_DATE = "preTriggerDate";
+    var _DYN_DISABLED = "disabled";
+    var _DYN_DATE = "date";
+    var _DYN_GET_UTCDATE = "getUTCDate";
+    var _DYN_MAX_TIMES_PER_MONTH = "maxTimesPerMonth";
+    var _DYN_STRINGIFY = "stringify";
     var _DYN_PATHNAME = "pathname";
     var _DYN_CORRELATION_HEADER_E0 = "correlationHeaderExcludePatterns";
     var _DYN_INDEX_OF = "indexOf";
@@ -1854,8 +1866,6 @@
     var _DYN_PARSED_STACK = "parsedStack";
     var _DYN_PROPERTIES = "properties";
     var _DYN_MEASUREMENTS = "measurements";
-    var _DYN_STRINGIFY = "stringify";
-    var _DYN_MESSAGE = "message";
     var _DYN_SIZE_IN_BYTES = "sizeInBytes";
     var _DYN_TYPE_NAME = "typeName";
     var _DYN_SEVERITY_LEVEL = "severityLevel";
@@ -2497,6 +2507,213 @@
         };
     }
 
+    var THROTTLE_STORAGE_PREFIX = "appInsightsThrottle";
+    var ThrottleMgr = /** @class */ (function () {
+        function ThrottleMgr(throttleMgr, core, namePrefix) {
+            var _self = this;
+            var _canUseLocalStorage;
+            var _logger;
+            var _config;
+            var _localStorageName;
+            var _localStorageObj;
+            var _isTriggered;
+            var _namePrefix;
+            var _queue;
+            var _isReady = false;
+            _initConfig();
+            _self.getConfig = function () {
+                return _config;
+            };
+            _self.canThrottle = function () {
+                return _canThrottle(_config, _canUseLocalStorage, _localStorageObj);
+            };
+            _self.isTriggered = function () {
+                return _isTriggered;
+            };
+            _self.isReady = function () {
+                return _isReady;
+            };
+            _self.flush = function () {
+                try {
+                    if (_isReady && _queue[_DYN_LENGTH ] > 0) {
+                        arrForEach(_queue, function (item) {
+                            _self.sendMessage(item.msgID, item[_DYN_MESSAGE ], item.severity);
+                        });
+                        return true;
+                    }
+                }
+                catch (err) {
+                }
+                return false;
+            };
+            _self.onReadyState = function (isReady) {
+                _isReady = isNullOrUndefined(isReady) ? true : isReady;
+                return _self.flush();
+            };
+            _self.sendMessage = function (msgID, message, severity) {
+                if (_isReady) {
+                    var isSampledIn = _canSampledIn();
+                    if (!isSampledIn) {
+                        return;
+                    }
+                    var canThrottle = _canThrottle(_config, _canUseLocalStorage, _localStorageObj);
+                    var throttled = false;
+                    var number = 0;
+                    try {
+                        if (canThrottle && !_isTriggered) {
+                            number = Math.min(_config.limit.maxSendNumber, _localStorageObj[_DYN_COUNT ] + 1);
+                            _localStorageObj[_DYN_COUNT ] = 0;
+                            throttled = true;
+                            _isTriggered = true;
+                            _localStorageObj[_DYN_PRE_TRIGGER_DATE ] = new Date();
+                        }
+                        else {
+                            _isTriggered = canThrottle;
+                            _localStorageObj[_DYN_COUNT ] += 1;
+                        }
+                        _resetLocalStorage(_logger, _localStorageName, _localStorageObj);
+                        for (var i = 0; i < number; i++) {
+                            _sendMessage(msgID, _logger, message, severity);
+                        }
+                    }
+                    catch (e) {
+                    }
+                    return {
+                        isThrottled: throttled,
+                        throttleNum: number
+                    };
+                }
+                else {
+                    _queue.push({
+                        msgID: msgID,
+                        message: message,
+                        severity: severity
+                    });
+                }
+                return null;
+            };
+            function _initConfig() {
+                var _a, _b, _c, _d, _e;
+                _canUseLocalStorage = utlCanUseLocalStorage();
+                _logger = safeGetLogger(core);
+                _isTriggered = false;
+                _namePrefix = isNotNullOrUndefined(namePrefix) ? namePrefix : "";
+                _queue = [];
+                var configMgr = throttleMgr;
+                _config = {};
+                _config[_DYN_DISABLED ] = !!configMgr[_DYN_DISABLED ];
+                _config.msgKey = configMgr.msgKey;
+                var interval = {
+                    monthInterval: ((_a = configMgr.interval) === null || _a === void 0 ? void 0 : _a.monthInterval) || 3,
+                    dayInterval: ((_b = configMgr.interval) === null || _b === void 0 ? void 0 : _b.dayInterval) || 28,
+                    maxTimesPerMonth: ((_c = configMgr.interval) === null || _c === void 0 ? void 0 : _c.maxTimesPerMonth) || 1
+                };
+                _config.interval = interval;
+                var limit = {
+                    samplingRate: ((_d = configMgr.limit) === null || _d === void 0 ? void 0 : _d.samplingRate) || 100,
+                    maxSendNumber: ((_e = configMgr.limit) === null || _e === void 0 ? void 0 : _e.maxSendNumber) || 1
+                };
+                _config.limit = limit;
+                _localStorageName = _getLocalStorageName(_config.msgKey, _namePrefix);
+                if (_canUseLocalStorage && _localStorageName) {
+                    _localStorageObj = _getLocalStorageObj(utlGetLocalStorage(_logger, _localStorageName), _logger, _localStorageName);
+                }
+                if (_localStorageObj) {
+                    _isTriggered = _isTriggeredOnCurDate(_localStorageObj[_DYN_PRE_TRIGGER_DATE ]);
+                }
+            }
+            function _canThrottle(config, canUseLocalStorage, localStorageObj) {
+                if (!config[_DYN_DISABLED ] && canUseLocalStorage && isNotNullOrUndefined(localStorageObj)) {
+                    var curDate = _getThrottleDate();
+                    var date = localStorageObj[_DYN_DATE ];
+                    var interval = config.interval;
+                    var monthExpand = (curDate.getUTCFullYear() - date.getUTCFullYear()) * 12 + curDate.getUTCMonth() - date.getUTCMonth();
+                    var monthCheck = _checkInterval(interval.monthInterval, 0, monthExpand);
+                    var dayCheck = _checkInterval(interval.dayInterval, 0, curDate[_DYN_GET_UTCDATE ]()) - 1;
+                    return monthCheck >= 0 && dayCheck >= 0 && dayCheck <= config.interval[_DYN_MAX_TIMES_PER_MONTH ];
+                }
+                return false;
+            }
+            function _getLocalStorageName(msgKey, prefix) {
+                var fix = isNotNullOrUndefined(prefix) ? prefix : "";
+                if (msgKey) {
+                    return THROTTLE_STORAGE_PREFIX + fix + "-" + msgKey;
+                }
+                return null;
+            }
+            function _isTriggeredOnCurDate(preTriggerDate) {
+                try {
+                    if (preTriggerDate) {
+                        var curDate = new Date();
+                        return preTriggerDate.getUTCFullYear() === curDate.getUTCFullYear() &&
+                            preTriggerDate.getUTCMonth() === curDate.getUTCMonth() &&
+                            preTriggerDate[_DYN_GET_UTCDATE ]() === curDate[_DYN_GET_UTCDATE ]();
+                    }
+                }
+                catch (e) {
+                }
+                return false;
+            }
+            function _getLocalStorageObj(value, logger, storageName) {
+                try {
+                    var storageObj = {
+                        date: _getThrottleDate(),
+                        count: 0
+                    };
+                    if (value) {
+                        var obj = JSON.parse(value);
+                        return {
+                            date: _getThrottleDate(obj[_DYN_DATE ]) || storageObj[_DYN_DATE ],
+                            count: obj[_DYN_COUNT ] || storageObj[_DYN_COUNT ],
+                            preTriggerDate: obj.preTriggerDate ? _getThrottleDate(obj[_DYN_PRE_TRIGGER_DATE ]) : undefined
+                        };
+                    }
+                    else {
+                        _resetLocalStorage(logger, storageName, storageObj);
+                        return storageObj;
+                    }
+                }
+                catch (e) {
+                }
+                return null;
+            }
+            function _getThrottleDate(dateStr) {
+                try {
+                    if (dateStr) {
+                        var date = new Date(dateStr);
+                        if (!isNaN(date.getDate())) {
+                            return date;
+                        }
+                    }
+                    else {
+                        return new Date();
+                    }
+                }
+                catch (e) {
+                }
+                return null;
+            }
+            function _resetLocalStorage(logger, storageName, obj) {
+                try {
+                    return utlSetLocalStorage(logger, storageName, strTrim(JSON[_DYN_STRINGIFY ](obj)));
+                }
+                catch (e) {
+                }
+                return false;
+            }
+            function _checkInterval(interval, start, current) {
+                return (current >= start) && (current - start) % interval == 0 ? Math.floor((current - start) / interval) + 1 : -1;
+            }
+            function _sendMessage(msgID, logger, message, severity) {
+                _throwInternal(logger, severity || 1 , msgID, message);
+            }
+            function _canSampledIn() {
+                return randomValue(1000000) <= _config.limit.samplingRate;
+            }
+        }
+        return ThrottleMgr;
+    }());
+
     var _FIELDS_SEPARATOR = ";";
     var _FIELD_KEY_VALUE_SEPARATOR = "=";
     function parseConnectionString(connectionString) {
@@ -3059,7 +3276,7 @@
             var _self = this;
             _self.ver = 2;
             var dataPoint = new DataPoint();
-            dataPoint.count = count > 0 ? count : undefined;
+            dataPoint[_DYN_COUNT ] = count > 0 ? count : undefined;
             dataPoint.max = isNaN(max) || max === null ? undefined : max;
             dataPoint.min = isNaN(min) || min === null ? undefined : min;
             dataPoint[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
@@ -3407,6 +3624,7 @@
     exports.SampleRate = SampleRate;
     exports.SeverityLevel = SeverityLevel;
     exports.TelemetryItemCreator = TelemetryItemCreator;
+    exports.ThrottleMgr = ThrottleMgr;
     exports.Trace = Trace;
     exports.UrlHelper = UrlHelper;
     exports.Util = Util;