@microsoft/sp-diagnostics 1.23.2 → 1.24.0-beta.2

package/lib-esm/Api/ExecutionQueue.js

@@ -0,0 +1,114 @@
+class ExecutionQueue {
+    /**
+   * Determines if the added execution entries should be processed in real time.
+   * If this is set to true, a stack with entries will not be saved.
+   *
+   * When set to true, all entries on stack will be processed and future entries
+   * will be executed in real time.
+   * When set to false, future entries will be saved in the execution stack for
+   * later processing.
+   */ get shouldExecuteInRealTime() {
+        return this._shouldExecuteInRealTime;
+    }
+    set shouldExecuteInRealTime(executeInRealTime) {
+        this._shouldExecuteInRealTime = executeInRealTime;
+        if (this._shouldExecuteInRealTime) {
+            this.flush();
+        }
+    }
+    /**
+   * Registers an external handler to collection for delayed asynchronous processing.
+   * Handlers are registered once. If handler is already registered, it does nothing.
+   */ addHandler(key, handler) {
+        if (this._containsHandler(key, handler)) {
+            return;
+        }
+        this._initializeHandlerArrayForKey(key);
+        const handlers = this._handlers[key];
+        if (handlers.indexOf(handler) === -1) {
+            handlers.push(handler);
+        }
+    }
+    /**
+   * Execution Entry registration for delayed asynchronous processing.
+   */ addExecutionEntry(key, ...args) {
+        Object.freeze(args);
+        if (this._shouldExecuteInRealTime) {
+            this._processExecutionEntry(key, args);
+        } else {
+            this._executionEntries.push({
+                key: key,
+                args: args
+            });
+        }
+    }
+    /**
+   * Removes an external executionEntry handler from collection for asynchronous event logging.
+   * Logger is registered once.
+   */ removeHandler(key, handler) {
+        const index = this._handlers[key].indexOf(handler);
+        if (index > -1) {
+            this._handlers[key].splice(index, 1);
+        }
+    }
+    /**
+   * Reset function clears executionEntry handler collection for asynchronous event logging.
+   * All recorded execution entries and handlers are purged.
+   */ reset() {
+        this._handlers = {};
+        this._executionEntries = [];
+    }
+    /**
+   * Flushes all the buffered execution entries.
+   * All recorded execution entries are purged.
+   */ flush() {
+        this._processAllExecutionEntries();
+        this._executionEntries = [];
+    }
+    _containsHandler(key, handler) {
+        if (this._handlers[key] !== null && this._handlers[key] !== undefined) {
+            return this._handlers[key].indexOf(handler) > -1;
+        }
+        return false;
+    }
+    _initializeHandlerArrayForKey(key) {
+        if (this._handlers[key] === null || this._handlers[key] === undefined) {
+            this._handlers[key] = [];
+        }
+    }
+    _processAllExecutionEntries() {
+        for (const entry of this._executionEntries){
+            if (entry && this._handlers[entry.key]) {
+                try {
+                    for (const handler of this._handlers[entry.key]){
+                        handler.apply(this, entry.args);
+                    }
+                } catch (e) {
+                    // eslint-disable-next-line no-console
+                    console.error('failed to process execution entry:' + e.toString());
+                }
+            }
+        }
+    }
+    _processExecutionEntry(key, args) {
+        for(let i = 0; i < this._handlers[key].length; i++){
+            try {
+                this._handlers[key][i].apply(this, args);
+            } catch (e) {
+                // eslint-disable-next-line no-console
+                console.error('failed to process execution entry:' + e.toString());
+            }
+        }
+    }
+    constructor(){
+        this._shouldExecuteInRealTime = false;
+        this._handlers = {};
+        this._executionEntries = [];
+    }
+}
+/**
+ * ExecutionQueue allows multiple handlers to be processed in real time or deferred.
+ * @internal
+ */ export { ExecutionQueue as default };
+
+//# sourceMappingURL=./ExecutionQueue.js.map

package/lib-esm/Api/ILogData.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft. All rights reserved.
+export { };
+
+//# sourceMappingURL=./ILogData.js.map

package/lib-esm/Api/ILogEntry.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=./ILogEntry.js.map

package/lib-esm/Api/ILogErrorData.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft. All rights reserved.
+export { };
+
+//# sourceMappingURL=./ILogErrorData.js.map

package/lib-esm/Api/ILogSource.js

@@ -0,0 +1,8 @@
+// Copyright (c) Microsoft. All rights reserved.
+/**
+ * Interface defining the source a log
+ *
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./ILogSource.js.map

package/lib-esm/Api/ILogVerboseData.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft. All rights reserved.
+export { };
+
+//# sourceMappingURL=./ILogVerboseData.js.map

package/lib-esm/Api/Log/LogHandler.js

@@ -0,0 +1,37 @@
+import { LogLevel } from '../LogLevel';
+import LogEvent from '../Trace/LogEvent';
+class LogHandler {
+    verbose(source, message, scope) {
+        const event = LogEvent.log(source, message, LogLevel.Verbose, scope);
+        if (DEBUG && !DEPRECATED_UNIT_TEST) {
+            // eslint-disable-next-line no-console
+            console.log(event.toString());
+        }
+    }
+    info(source, message, scope) {
+        const event = LogEvent.log(source, message, LogLevel.Info, scope);
+        if (DEBUG && !DEPRECATED_UNIT_TEST) {
+            console.info(event.toString());
+        }
+    }
+    warn(source, message, scope) {
+        const event = LogEvent.log(source, message, LogLevel.Warning, scope);
+        if (DEBUG && !DEPRECATED_UNIT_TEST) {
+            // eslint-disable-next-line no-console
+            console.warn(event.toString());
+        }
+    }
+    error(source, error, scope) {
+        const event = LogEvent.log(source, error, LogLevel.Error, scope);
+        if (DEBUG && !DEPRECATED_UNIT_TEST) {
+            // eslint-disable-next-line no-console
+            console.error(event.toString());
+        }
+    }
+}
+/**
+ * This handler adapts the sp-core-library Log to use the internal telemetry.
+ * @internal
+ */ export { LogHandler as default };
+
+//# sourceMappingURL=./LogHandler.js.map

package/lib-esm/Api/LogEntry.js

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft. All rights reserved.
+import LogFeature from './LogFeature';
+import LogType from './LogType';
+/**
+ * Represents a Log entry
+ *
+ * @internal
+ */ class LogEntry {
+    /**
+   * convert the log entry to string
+   * @returns the serialized log entry
+   */ toString() {
+        let serializedLogProps = undefined;
+        if (this.logProperties) {
+            try {
+                serializedLogProps = JSON.stringify(this.logProperties);
+            } catch (e) {
+                // eslint-disable-next-line no-console
+                console.log('Error happens in toString():' + e);
+            }
+        }
+        return `${this.moduleName} | ${this.logFeature} | ${this.logType} | ${serializedLogProps}`;
+    }
+    /**
+   * Initializes a new instance of LogEntry
+   * @param moduleName - the name of the module
+   * @param logFeature - the name of the feature
+   * @param logType - the log type
+   * @param logProperties - optional property bag
+   */ constructor(moduleName, logFeature = LogFeature.None, logType = LogType.Trace, logProperties, isIntentional){
+        if (moduleName) {
+            this.moduleName = moduleName;
+            this.logFeature = logFeature;
+            this.logType = logType;
+            this.logProperties = logProperties;
+            this.isIntentional = isIntentional;
+        } else {
+            throw new Error('moduleName is invalid');
+        }
+    }
+}
+export default LogEntry;
+
+//# sourceMappingURL=./LogEntry.js.map

package/lib-esm/Api/LogFeature.js

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ */ class LogFeature {
+}
+LogFeature.None = 'None';
+export { LogFeature as default };
+
+//# sourceMappingURL=./LogFeature.js.map

package/lib-esm/Api/LogLevel.js

@@ -0,0 +1,20 @@
+/**
+ * LogLevel represents the level of a log event.
+ * @internal
+ */ export var LogLevel;
+(function(LogLevel) {
+    /**
+   * verbose event for debugging
+   */ LogLevel[LogLevel["Verbose"] = 1] = "Verbose";
+    /**
+   * Informational event
+   */ LogLevel[LogLevel["Info"] = 2] = "Info";
+    /**
+   * A warning
+   */ LogLevel[LogLevel["Warning"] = 3] = "Warning";
+    /**
+   * An error
+   */ LogLevel[LogLevel["Error"] = 4] = "Error";
+})(LogLevel || (LogLevel = {}));
+
+//# sourceMappingURL=./LogLevel.js.map

package/lib-esm/Api/LogManager/CircularBuffer.js

@@ -0,0 +1,83 @@
+/**
+ * @internal
+ */ class CircularBuffer {
+    get count() {
+        return this._count;
+    }
+    push(item) {
+        this._ensureNotIterating();
+        this._head++;
+        this._count++;
+        if (this._head === this._size) {
+            this._head = 0;
+        }
+        this._buffer[this._head] = item;
+    }
+    forEach(handle) {
+        if (this._count === 0) {
+            return;
+        }
+        this._isIterating = true;
+        try {
+            let current = this._tail;
+            // For-loop is prefered over while loop here to avoid possible infinite loop.
+            for(let i = 0; i < this._size; i++){
+                handle(this._buffer[current]);
+                if (current === this._head) {
+                    break;
+                }
+                current = this._getNext(current);
+            }
+        } finally{
+            this._isIterating = false;
+        }
+    }
+    removeAll() {
+        this._ensureNotIterating();
+        this._head = -1;
+        this._count = 0;
+    }
+    /**
+   * Index of the oldest item in the buffer
+   */ get _tail() {
+        if (this._isNotWrapped()) {
+            return 0;
+        }
+        return this._getNext(this._head);
+    }
+    _isNotWrapped() {
+        return this._count === this._head + 1;
+    }
+    /**
+   * The next index should be index + 1, unless it reaches
+   * the end of the buffer and needs to rewind to 0.
+   */ _getNext(index) {
+        let nextIndex = index + 1;
+        if (nextIndex === this._size) {
+            nextIndex = 0;
+        }
+        return nextIndex;
+    }
+    _ensureNotIterating() {
+        if (this._isIterating) {
+            throw new Error('Circular buffer cannot be modified during iteration');
+        }
+    }
+    constructor(size){
+        /**
+   * Index of the newest item in the buffer
+   */ this._head = -1;
+        /**
+   * The overall count of how many items have ever been added to the buffer.
+   */ this._count = 0;
+        this._isIterating = false;
+        if (size <= 0) {
+            throw new Error('Size must be positive');
+        }
+        this._size = size;
+        this._buffer = new Array(size);
+    }
+}
+export { CircularBuffer as default };
+
+//# sourceMappingURL=./CircularBuffer.js.map

package/lib-esm/Api/LogManager/LogManager.js

@@ -0,0 +1,103 @@
+import CircularBuffer from './CircularBuffer';
+class LogManager {
+    static get _maxVerboseLog() {
+        return 5000;
+    }
+    /**
+   * Event list for delayed asynchronous processing.
+   * Events are accumulated in CircularBuffer for processing later.
+   */ get events() {
+        return this._events;
+    }
+    /**
+   * Registers an external logger to logger collection for asynchronous event logging.
+   * Logger is registered once.
+   */ addHandler(handler) {
+        if (!this._containsHandler(handler)) {
+            this._handlers.push(handler);
+            this._shouldLogInRealTime.push(false);
+        }
+    }
+    /**
+   * Event logging operation for delayed asynchronous processing.
+   */ log(event) {
+        Object.freeze(event);
+        this._events.push(event);
+        this._processLogEvent(event);
+    }
+    /**
+   * Removes an external logger from logger collection for asynchronous event logging.
+   * Logger is registered once.
+   */ removeHandler(handler) {
+        const index = this._handlers.indexOf(handler);
+        if (index > -1) {
+            this._handlers.splice(index, 1);
+            this._shouldLogInRealTime.splice(index, 1);
+        }
+    }
+    /**
+   * Reset function clears logger collection for asynchronous event logging.
+   * All recorded events are purged.
+   */ reset() {
+        this._handlers = [];
+        this._shouldLogInRealTime = [];
+        this._events.removeAll();
+    }
+    /**
+   * Processes all the buffered events using the registered handler.
+   */ processAll(handler) {
+        if (this._handlers.indexOf(handler) > -1) {
+            this._processAllEvents(handler);
+        }
+    }
+    _containsHandler(handler) {
+        for (const existingHandler of this._handlers){
+            if (existingHandler === handler) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _processAllEvents(handler) {
+        this._events.forEach((event)=>{
+            if (event) {
+                try {
+                    handler(event);
+                } catch (e) {
+                    // eslint-disable-next-line no-console
+                    console.error('failed to handle event:' + e.toString());
+                }
+            }
+        });
+        this._shouldLogInRealTime[this._handlers.indexOf(handler)] = true;
+    }
+    _processLogEvent(event) {
+        for(let i = 0; i < this._handlers.length; i++){
+            if (this._shouldLogInRealTime[i] && event) {
+                try {
+                    this._handlers[i](event);
+                } catch (e) {
+                    // eslint-disable-next-line no-console
+                    console.error('failed to handle event:' + e.toString());
+                }
+            }
+        }
+    }
+    constructor(initialHandler){
+        this._shouldLogInRealTime = [];
+        this._handlers = [];
+        this._events = new CircularBuffer(LogManager._maxVerboseLog);
+        if (initialHandler) {
+            this.addHandler(initialHandler);
+        }
+    }
+}
+/**
+ * LogManager allows multiple handlers to process log events.
+ * It caches the latest 5000 log events. If a handler is just added, the
+ * handler is able to get access to the cached events and all incoming events.
+ * Dev-dashboard and potentially third-party can use it to get access to events.
+ * @internal
+ */ export { LogManager as default };
+
+//# sourceMappingURL=./LogManager.js.map

package/lib-esm/Api/LogSource.js

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft. All rights reserved.
+import { ServiceKey, Validate } from '@microsoft/sp-core-library';
+class LogSource {
+    /**
+   * Factory method to create an instance of the LogSource class
+   * @returns a reference to an instance of the LogSource class
+   */ static create(id) {
+        return new LogSource(id);
+    }
+    get id() {
+        return this._id;
+    }
+    /**
+   * @returns if the LogSource is empty.
+   */ isEmpty() {
+        return this._id.length === 0;
+    }
+    constructor(id){
+        Validate.isNotNullOrUndefined(id, 'id');
+        this._id = id;
+    }
+}
+/**
+ * Represents a Log entry
+ *
+ * @internal
+ */ export { LogSource as default };
+/** @internal */ export const logSourceServiceKey = ServiceKey.createCustom('sp-client-base:LogSource', (serviceScope)=>{
+    return LogSource.create('');
+});
+
+//# sourceMappingURL=./LogSource.js.map

package/lib-esm/Api/LogType.js

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft. All rights reserved.
+/**
+ * Represents the supported log types
+ *
+ * @internal
+ */ var LogType;
+(function(LogType) {
+    /**
+   * Trace level log. Use this for logging diagnostics
+   */ LogType[LogType["Trace"] = 1] = "Trace";
+    /**
+   * Event level log. Use this for logging usage etc
+   */ LogType[LogType["Event"] = 2] = "Event";
+    /**
+   * Use for errors
+   */ LogType[LogType["Error"] = 3] = "Error";
+})(LogType || (LogType = {}));
+export default LogType;
+
+//# sourceMappingURL=./LogType.js.map

package/lib-esm/Api/Qos/AutoAlertableQosMonitor.js

@@ -0,0 +1,74 @@
+import QosMonitor from './QosMonitor';
+/**
+ * Object members correspond to auto alerting monitors.
+ * Information about monitors: https://onedrive.visualstudio.com/WEX!/_wiki/wikis/WEX!.wiki/30583/Current-Monitors
+ *
+ * @internal
+ */ // eslint-disable-next-line @typescript-eslint/typedef
+export const AutoAlertableMonitorType = {
+    /**
+   *  If QoS drops below a static threshold of 95 for a period, a sev 4 is fired.
+   */ StaticReliabilityQos95Sev4: 'StaticReliabilityQos95Sev4',
+    /**
+   * If QoS drops below some dynamic threshold "Medium" sensitivity (as defined by Geneva)
+   * calculated from historical monitor data, a sev 4 is fired.
+   */ DynamicReliabilityQosMediumSev4: 'DynamicReliabilityQosMediumSev4',
+    /**
+   * If the number of expected errors increases past a "High" dynamic threshold sensitivity
+   * (as defined by Geneva) calculated from historical monitor data OR  QoS drops below some
+   * dynamic threshold "Medium" sensitivity, a sev 4 is fired.
+   */ DynamicReliabilityExpectedFailureHighSev4: 'DynamicReliabilityExpectedFailureHighSev4'
+};
+/**
+ * Qos logger which enforces using an existing altering monitor as determined by the
+ * AlertableMonitorType.
+ *
+ * @internal
+ */ export class AutoAlertableQosMonitor extends QosMonitor {
+    /**
+   * QoS monitor ends with success. Also writes AutoAlertableMonitorType to extraData.
+   * You will see success tag: SPPages.ScenarioName.Success
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    writeSuccess(extraData) {
+        super.writeSuccess(this._getExtraDataWithAutoAlertableFields(extraData));
+    }
+    /**
+   * QoS monitor ends with failure. Also writes AutoAlertableMonitorType to extraData.
+   * You will see failure tag: SPPages.ScenarioName.<failuretag>.Failure.
+   * <failuretag> will be filled with param tagName
+   */ writeUnexpectedFailure(tagNameSuffix = 'DefaultUnexpected', ex, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    extraData) {
+        super.writeUnexpectedFailure(tagNameSuffix, ex, this._getExtraDataWithAutoAlertableFields(extraData));
+    }
+    /*
+   * QoS monitor ends with expected failure. Also writes AutoAlertableMonitorType to extraData.
+   * You will see success tag: ModernPublish.RenderPublishPage.<failuretag>.ExpectedFailure.
+   * <failuretag> will be filled with param tagName
+   */ writeExpectedFailure(tagNameSuffix = 'DefaultExpected', ex, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    extraData) {
+        super.writeExpectedFailure(tagNameSuffix, ex, this._getExtraDataWithAutoAlertableFields(extraData));
+    }
+    /**
+   * Gets the extraData with additional auto alertable dimensions to indicate this uses the easy
+   * alerting monitors.
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _getExtraDataWithAutoAlertableFields(extraData) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const returnedExtraData = extraData ?? {};
+        returnedExtraData.autoAlertableMonitorType = AutoAlertableMonitorType[this._autoAlertableMonitorType];
+        return returnedExtraData;
+    }
+    /**
+   * Creates a QoS monitor (initializes it and logs the start event) that enforces that end events
+   * fired include the alertableMonitorType property in extraData corresponding to the
+   *
+   * @param scenarioName	- Unique name of the QoS scenario
+   * @param autoAlertableMonitorType - Correspond to existing alerting monitor that will track the events.
+   * @param copyToEngagement - Indicate whether this data should be used as Engagement as well.
+   */ constructor(scenarioName, autoAlertableMonitorType, copyToEngagement = false){
+        super(scenarioName, /* copyToCosmos */ false, /* copyToInterana */ copyToEngagement);
+        this._autoAlertableMonitorType = autoAlertableMonitorType;
+    }
+}
+
+//# sourceMappingURL=./AutoAlertableQosMonitor.js.map

package/lib-esm/Api/Qos/CustomerPromiseInterfaces/ICustomerPromiseErrorDetails.js

@@ -0,0 +1,6 @@
+/**
+ * Details about the failure Edit Mode Customer Promise records
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./ICustomerPromiseErrorDetails.js.map

package/lib-esm/Api/Qos/CustomerPromiseInterfaces/IExtraDataForCustomerPromise.js

@@ -0,0 +1,6 @@
+/**
+ * IExtraDataForCustomerPromise Interface which describes additional data to log customer promise failures from QoS.
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IExtraDataForCustomerPromise.js.map

package/lib-esm/Api/Qos/IQos.js

@@ -0,0 +1,6 @@
+/**
+ * Interface for Qos internal object
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IQos.js.map

package/lib-esm/Api/Qos/IQosEndEvent.js

@@ -0,0 +1,6 @@
+/**
+ * IQosEndEvent interface.
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IQosEndEvent.js.map

package/lib-esm/Api/Qos/IQosExtraData.js

@@ -0,0 +1,12 @@
+/**
+ * Interface for SPFx QoS extraData field.
+ * This provides schema validation through the interface to consolidate all extra data in a known set of fields.
+ *
+ * @remarks
+ * The goal of this interface is to provide a comprehensive list of extra data fields and encourage re-use, even if
+ * it's used in a different context.
+ *
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IQosExtraData.js.map

package/lib-esm/Api/Qos/IQosStartEvent.js

@@ -0,0 +1,6 @@
+/**
+ * IQosStartEvent interface.
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./IQosStartEvent.js.map