o11y 240.0.0 → 240.9.0

package/dist/modules/o11y/client/client.js

@@ -220,6 +220,14 @@ class Tracing {
 Tracing._global = utility.getGlobal();
 Tracing._isNetworkInstrumentationEnabled = false;
 
+var TimerOverride;
+(function (TimerOverride) {
+    TimerOverride[TimerOverride["none"] = 0] = "none";
+    TimerOverride[TimerOverride["start"] = 1] = "start";
+    TimerOverride[TimerOverride["stop"] = 2] = "stop";
+    TimerOverride[TimerOverride["both"] = 3] = "both";
+})(TimerOverride || (TimerOverride = {}));
+
 const timedout = 'timedout';
 const terminated = 'terminated';
 const discarded = 'discarded';
@@ -236,6 +244,7 @@ class ActivityImpl {
         this._onError = _onError;
         this._isSampled = _isSampled;
         this._errorCount = 0;
+        this._timerOverridden = TimerOverride.none;
         const { tsNow, perfNow } = utility.time();
         ActivityImpl._count += 1;
         this._id = id || utility.generateUniqueId();
@@ -284,10 +293,51 @@ class ActivityImpl {
             this._onError(error, this._getDetail(userSchemaOrText, userData));
         });
     }
-    stop(userSchemaOrText, userData) {
-        this._safety.tryCatch(() => this._stopInternal(userSchemaOrText, userData));
+    stop(userSchemaOrText, userData, options) {
+        this._safety.tryCatch(() => {
+            utility.requireArgumentIfDefined(userSchemaOrText, 'userSchemaOrText', [
+                'object',
+                'string'
+            ]);
+            utility.requireArgumentIfDefined(userData, 'userData', 'object');
+            if (options) {
+                const perfStart = options.perfStartOverride;
+                const isStartTimeDefined = utility.requireArgumentIfDefined(perfStart, 'options.perfStartOverride', 'number');
+                const perfStop = options.perfStopOverride;
+                const isStopTimeDefined = utility.requireArgumentIfDefined(perfStop, 'options.perfStopOverride', 'number');
+                if (isStartTimeDefined && perfStart < 0) {
+                    throw new Error('perfStartOverride, if defined, must be >= 0');
+                }
+                if (isStopTimeDefined &&
+                    (perfStop < 0 ||
+                        perfStop < (isStartTimeDefined ? perfStart : this._startPerfTime))) {
+                    throw new Error('perfStopOverride, if defined, must be >= 0 and >= startTime');
+                }
+            }
+            this._stopInternal(userSchemaOrText, userData, options);
+        });
     }
-    _stopInternal(userSchemaOrText, userData) {
+    _overrideTimer(perfStartTime, perfStopTime) {
+        if (perfStartTime !== undefined) {
+            this._startTimestamp = Math.round(this._startTimestamp - (this._startPerfTime - perfStartTime));
+            this._startPerfTime = perfStartTime;
+            this._setTimerOverride(TimerOverride.start);
+        }
+        if (perfStopTime !== undefined) {
+            this._stopPerfTime = perfStopTime;
+            this._setTimerOverride(TimerOverride.stop);
+        }
+    }
+    _setTimerOverride(value) {
+        if (this._timerOverridden === TimerOverride.both ||
+            this._timerOverridden === value ||
+            value === TimerOverride.none) {
+            return;
+        }
+        this._timerOverridden =
+            this._timerOverridden === TimerOverride.none ? value : TimerOverride.both;
+    }
+    _stopInternal(userSchemaOrText, userData, options) {
         const stopPerfTime = utility.perfNow();
         if (this._usePerf) {
             try {
@@ -306,7 +356,14 @@ class ActivityImpl {
         if (this.isStopped) {
             return;
         }
-        this._stopPerfTime = stopPerfTime;
+        if (options) {
+            this._overrideTimer(options.perfStartOverride, options.perfStopOverride);
+        }
+        this._stopPerfTime =
+            this._timerOverridden === TimerOverride.none ||
+                this._timerOverridden === TimerOverride.start
+                ? stopPerfTime
+                : this._stopPerfTime;
         const activityDetail = this._getDetail(userSchemaOrText, userData);
         this._onStopped(activityDetail);
     }
@@ -340,7 +397,8 @@ class ActivityImpl {
             startPerfTime: this._startPerfTime,
             stopPerfTime: this._stopPerfTime,
             errorCount: this._errorCount,
-            isSampled: this.getIsSampled()
+            isSampled: this.getIsSampled(),
+            timerOverridden: this._timerOverridden
         };
     }
     getTraceHeaders(options) {
@@ -366,6 +424,9 @@ const activity={namespace:"sf.instrumentation",name:"Activity",pbjsSchema:{"nest
 const error={namespace:"sf.instrumentation",name:"Error",pbjsSchema:{"nested":{"sf":{"nested":{"instrumentation":{"nested":{"Error":{"reserved":[[5,5],[7,7]],"fields":{"activityId":{"options":{},"id":6,"type":"string"},"stack":{"options":{},"id":3,"type":"string"},"name":{"options":{},"id":1,"type":"string"},"message":{"options":{"(meta.max_length)":200},"id":2,"type":"string"},"userPayload":{"options":{},"id":4,"type":"Payload"}}},"Payload":{"fields":{"payload":{"options":{},"id":2,"type":"bytes"},
 "schemaName":{"options":{},"id":1,"type":"string"}}}}}}}}}};
 
+const idle_detector_report={namespace:"sf.instrumentation",name:"IdleDetectorReport",pbjsSchema:{"nested":{"sf":{"nested":{"instrumentation":{"nested":{"IdleDetectorReport":{"options":{"(meta.msg.desc)":"This is used by the Idle Detector in o11y"},"fields":{"listenerCount":{"options":{},"id":3,"type":"uint32"},"busyTasks":{"options":{},"rule":"repeated","id":5,"type":"string"},"busyDurations":{"options":{},"rule":"repeated","id":6,"type":"double"},"pollableCount":{"options":{},"id":4,"type":"uint32"},
+"pollCounts":{"options":{},"rule":"repeated","id":8,"type":"double"},"logThreshold":{"options":{},"id":2,"type":"double"},"maxDuration":{"options":{},"id":1,"type":"double"},"pollables":{"options":{},"rule":"repeated","id":7,"type":"string"}}}}}}}}}};
+
 const instrumented_event={namespace:"sf.instrumentation",name:"InstrumentedEvent",pbjsSchema:{"nested":{"sf":{"nested":{"instrumentation":{"nested":{"MouseEvent":{"fields":{"cancelable":{"options":{},"id":5,"type":"bool"},"ctrlKey":{"options":{},"id":9,"type":"bool"},"type":{"options":{},"id":25,"type":"string"},"button":{"options":{},"id":3,"type":"uint32"},"offsetX":{"options":{},"id":17,"type":"uint32"},"eventPhase":{"options":{},"id":12,"type":"uint32"},"shiftKey":{"options":{},"id":23,
 "type":"bool"},"offsetY":{"options":{},"id":18,"type":"uint32"},"composed":{"options":{},"id":8,"type":"bool"},"altKey":{"options":{},"id":1,"type":"bool"},"isTrusted":{"options":{},"id":13,"type":"bool"},"buttons":{"options":{},"id":4,"type":"uint32"},"movementY":{"options":{},"id":16,"type":"uint32"},"clientY":{"options":{},"id":7,"type":"uint32"},"clientX":{"options":{},"id":6,"type":"uint32"},"movementX":{"options":{},"id":15,"type":"uint32"},"defaultPrevented":{"options":{},"id":10,"type":"bool"},
 "metaKey":{"options":{},"id":14,"type":"bool"},"timeStamp":{"options":{},"id":24,"type":"double"},"bubbles":{"options":{},"id":2,"type":"bool"},"detail":{"options":{},"id":11,"type":"int64"},"pageY":{"options":{},"id":20,"type":"uint32"},"pageX":{"options":{},"id":19,"type":"uint32"},"screenX":{"options":{},"id":21,"type":"uint32"},"screenY":{"options":{},"id":22,"type":"uint32"}}},"InstrumentedEvent":{"oneofs":{"event":{"oneof":["mouseEvent"]}},"reserved":[[4,4],"xpath",[6,6],[8,8]],"fields":{"mouseEvent":{"options":{},
@@ -539,9 +600,9 @@ class LogValidator {
                 if (fieldDataValue.length > maxItemCountAppLimit) {
                     errorCode = 7;
                 }
-                for (const arrayKey in fieldDataValue) {
-                    this.matchFieldTypes(errorInfos, [...fieldNames, arrayKey], fieldDataValue[arrayKey], protobufType, descriptor, schemaId, key);
-                }
+                fieldDataValue.forEach((value, index) => {
+                    this.matchFieldTypes(errorInfos, [...fieldNames, index.toString()], value, protobufType, descriptor, schemaId, key);
+                });
             }
             else {
                 errorCode = 1;
@@ -1406,6 +1467,7 @@ class NextgenImpl {
     constructor() {
         this._logCollectors = new Set();
         this._instruments = new Map();
+        this._seqBySchema = new Map();
         this._sequence = 0;
         this._forceDisabledLogCollectors = new Set();
         this._logCollectorFailures = new Map();
@@ -1479,18 +1541,20 @@ class NextgenImpl {
     }
     addLog(loggerName, schema, data, timestamp, rootId, pagePayload, appPayload) {
         this._sequence += 1;
-        const sequence = this._sequence;
-        const loggerAppName = this.appName;
-        const connectionType = utility.getConnectionType();
+        const schemaId = schemaUtil.getSchemaId(schema);
+        let schemaSequence = this._seqBySchema.get(schemaId) || 0;
+        schemaSequence += 1;
+        this._seqBySchema.set(schemaId, schemaSequence);
         const logMeta = {
             timestamp,
             rootId,
-            sequence,
+            sequence: this._sequence,
+            schemaSequence,
             loggerName,
             pagePayload: pagePayload ? utility.clone(pagePayload) : undefined,
             appPayload: appPayload ? utility.clone(appPayload) : undefined,
-            loggerAppName,
-            connectionType
+            loggerAppName: this.appName,
+            connectionType: utility.getConnectionType()
         };
         if (this._isBufferingEnabled) {
             this._buffer.push({ schema, data: utility.clone(data), logMeta });
@@ -1617,7 +1681,7 @@ class Index {
         return this._nextgen;
     }
     registerInstrumentedApp(name, options) {
-        if (options && options.isProduction) {
+        if (!options || options.isProduction !== false) {
             utility.markProduction();
         }
         const retVal = this._lazyNextGen.registerApp(name, options);
@@ -1669,19 +1733,35 @@ class TaskerImpl {
     }
 }
 
+const defaultLogThreshold = 300;
 class IdleDetectorImpl {
-    constructor() {
+    constructor(options) {
         this._instr = getInstrumentation('IdleDetector');
-        this._taskers = new Set();
+        this._taskers = new Map();
         this._listeners = new Set();
         this._busyCheckers = new Map();
+        this._logThreshold = defaultLogThreshold;
+        this._endedTasks = new Array();
+        this._pollableReport = new Array();
         this._timerCheckQueued = 0;
+        if (utility.requireArgumentIfDefined(options === null || options === void 0 ? void 0 : options.logThreshold, 'options.logThreshold', 'number')) {
+            this._logThreshold = options.logThreshold;
+        }
     }
     requestIdleDetectedCallback(callback) {
         utility.requireArgument(callback, 'callback', 'function');
+        if (this._listeners.size === 0) {
+            this._firstCallbackTime = utility.time().perfNow;
+        }
         this._listeners.add(callback);
         this.checkIfLoaded();
     }
+    reportTaskEnded(tasker) {
+        if (this._listeners.size) {
+            const snapshot = Object.assign({}, this._taskers.get(tasker));
+            this._endedTasks.push(snapshot);
+        }
+    }
     declareNotifierTaskSingle(name) {
         utility.requireArgument(name, 'name', 'string');
         const tasker = this.addTasker(name, 1);
@@ -1705,7 +1785,22 @@ class IdleDetectorImpl {
                 throw new Error('existingBusyCount accepts only non-negative integers');
             }
         }
-        return this.addTasker(name, existingBusyCount);
+        const tasker = this.addTasker(name, existingBusyCount);
+        const retVal = {
+            get isBusy() {
+                return tasker.isBusy;
+            },
+            add: () => {
+                if (!tasker.isBusy) {
+                    const meta = this._taskers.get(tasker);
+                    meta.start = utility.time().perfNow;
+                    meta.end = undefined;
+                }
+                tasker.add();
+            },
+            done: tasker.done.bind(tasker)
+        };
+        return retVal;
     }
     declarePollableTaskMulti(name, isBusyChecker) {
         utility.requireArgument(name, 'name', 'string');
@@ -1714,26 +1809,37 @@ class IdleDetectorImpl {
     }
     addTasker(name, existingBusyCount) {
         const tasker = new TaskerImpl(name, existingBusyCount, () => {
+            this._taskers.get(tasker).end = utility.time().perfNow;
+            this.reportTaskEnded(tasker);
             this.checkIfLoaded();
         }, () => {
-            throw new Error(`Tasker '${tasker.name}' is done too many times.`);
+            this._instr.error(`Overdone: ${tasker.name}`);
+            utility.noProdThrow(`Tasker '${tasker.name}' is done too many times.`);
+        });
+        this._taskers.set(tasker, {
+            name,
+            start: existingBusyCount > 0 ? utility.time().perfNow : undefined,
+            end: undefined
         });
-        this._taskers.add(tasker);
         return tasker;
     }
     areAllNotifiersIdle() {
-        return !Array.from(this._taskers.values()).some((t) => t.isBusy);
+        return !Array.from(this._taskers.keys()).some((t) => t.isBusy);
     }
-    areAllPollablesIdle() {
-        return !Array.from(this._busyCheckers.keys()).some((sc, index) => {
+    getFirstBusyPollable() {
+        const entry = Array.from(this._busyCheckers).find((entry) => {
+            const isBusyChecker = entry[0];
+            const name = entry[1];
             try {
-                return sc();
+                return isBusyChecker();
             }
             catch (e) {
-                this._instr.error(e, `BusyChecker #${index}`);
+                this._instr.error(e, `BusyChecker ${name}`);
+                utility.noProdThrow(e);
                 return false;
             }
         });
+        return entry ? entry[1] : undefined;
     }
     checkIfLoaded() {
         if (!this._listeners.size) {
@@ -1753,29 +1859,84 @@ class IdleDetectorImpl {
     doubleCheck() {
         this._timerCheckQueued = 0;
         if (this.areAllNotifiersIdle()) {
-            if (!this.areAllPollablesIdle()) {
+            const pollableName = this.getFirstBusyPollable();
+            if (pollableName !== undefined) {
+                this.addToPollableReport(pollableName);
                 this._timerCheckQueued = window.setTimeout(() => {
                     this.doubleCheck();
                 }, 15);
             }
             else {
+                const maxDuration = utility.time().perfNow - this._firstCallbackTime;
                 const listeners = Array.from(this._listeners.values());
                 this._listeners.clear();
-                this.notify(listeners);
+                this._firstCallbackTime = undefined;
+                const endedTasks = this._endedTasks.splice(0);
+                const pollableReport = this._pollableReport.splice(0);
+                this.notify(listeners, maxDuration, endedTasks, pollableReport);
             }
         }
     }
-    notify(listeners) {
-        const idleTimestamp = utility.time().tsNow;
+    addToPollableReport(name) {
+        const lastEntry = this._pollableReport.length
+            ? this._pollableReport[this._pollableReport.length - 1]
+            : undefined;
+        if ((lastEntry === null || lastEntry === void 0 ? void 0 : lastEntry.name) === name) {
+            lastEntry.count += 1;
+        }
+        else {
+            this._pollableReport.push({
+                name,
+                count: 1
+            });
+        }
+    }
+    notify(listeners, maxDuration, taskReport, pollableReport) {
+        if (maxDuration >= this._logThreshold) {
+            const logData = this._getReport(maxDuration, listeners.length, taskReport, pollableReport);
+            this._instr.log(idle_detector_report, logData);
+        }
+        const tsNow = utility.time().tsNow;
         for (const [index, listener] of listeners.entries()) {
             try {
-                listener(idleTimestamp);
+                listener(tsNow);
             }
             catch (e) {
                 this._instr.error(e, `Listener #${index}`);
+                utility.noProdThrow(e);
             }
         }
     }
+    getReport() {
+        const perfNow = utility.time().perfNow;
+        const maxDuration = this._firstCallbackTime > 0 ? perfNow - this._firstCallbackTime : undefined;
+        const onGoingTasks = Array.from(this._taskers.entries())
+            .filter((e) => e[0].isBusy)
+            .map((e) => ({
+            name: e[1].name,
+            start: e[1].start,
+            end: perfNow
+        }));
+        return this._getReport(maxDuration, this._listeners.size, this._endedTasks.concat(onGoingTasks), this._pollableReport);
+    }
+    _getReport(maxDuration, listenerCount, taskReport, pollableReport) {
+        const sortedTaskers = taskReport
+            .map((t) => ({
+            name: t.name,
+            duration: t.end - t.start
+        }))
+            .sort((a, b) => b.duration - a.duration);
+        return {
+            logThreshold: this._logThreshold,
+            maxDuration,
+            listenerCount,
+            pollableCount: this._busyCheckers.size,
+            busyTasks: sortedTaskers.map((t) => t.name),
+            busyDurations: sortedTaskers.map((t) => t.duration),
+            pollables: pollableReport.map((p) => p.name),
+            pollCounts: pollableReport.map((p) => p.count)
+        };
+    }
 }
 
 const bgColorMap = {
@@ -1816,7 +1977,9 @@ class ConsoleCollector {
     }
 }
 
-const idleDetector = new IdleDetectorImpl();
+const idleDetector = new IdleDetectorImpl({
+    logThreshold: 300
+});
 
 export { ConsoleCollector, getInstrumentation, idleDetector, registerInstrumentedApp, time };
 //# sourceMappingURL=client.js.map