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

package/lib-commonjs/Api/ILogEntry.js

@@ -1,3 +1,6 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ILogEntry.js.map
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=./ILogEntry.js.map

package/lib-commonjs/Api/ILogErrorData.js

@@ -1,4 +1,7 @@
-"use strict";
 // Copyright (c) Microsoft. All rights reserved.
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ILogErrorData.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=./ILogErrorData.js.map

package/lib-commonjs/Api/ILogSource.js

@@ -1,4 +1,11 @@
-"use strict";
 // Copyright (c) Microsoft. All rights reserved.
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ILogSource.js.map
+/**
+ * Interface defining the source a log
+ *
+ * @internal
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=./ILogSource.js.map

package/lib-commonjs/Api/ILogVerboseData.js

@@ -1,4 +1,7 @@
-"use strict";
 // Copyright (c) Microsoft. All rights reserved.
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=ILogVerboseData.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=./ILogVerboseData.js.map

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

@@ -1,43 +1,44 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var LogLevel_1 = require("../LogLevel");
-var LogEvent_1 = tslib_1.__importDefault(require("../Trace/LogEvent"));
-/**
- * This handler adapts the sp-core-library Log to use the internal telemetry.
- * @internal
- */
-var LogHandler = /** @class */ (function () {
-    function LogHandler() {
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return LogHandler;
     }
-    LogHandler.prototype.verbose = function (source, message, scope) {
-        var event = LogEvent_1.default.log(source, message, LogLevel_1.LogLevel.Verbose, scope);
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _LogLevel = require("../LogLevel");
+const _LogEvent = /*#__PURE__*/ _interop_require_default._(require("../Trace/LogEvent"));
+class LogHandler {
+    verbose(source, message, scope) {
+        const event = _LogEvent.default.log(source, message, _LogLevel.LogLevel.Verbose, scope);
         if (DEBUG && !DEPRECATED_UNIT_TEST) {
             // eslint-disable-next-line no-console
             console.log(event.toString());
         }
-    };
-    LogHandler.prototype.info = function (source, message, scope) {
-        var event = LogEvent_1.default.log(source, message, LogLevel_1.LogLevel.Info, scope);
+    }
+    info(source, message, scope) {
+        const event = _LogEvent.default.log(source, message, _LogLevel.LogLevel.Info, scope);
         if (DEBUG && !DEPRECATED_UNIT_TEST) {
             console.info(event.toString());
         }
-    };
-    LogHandler.prototype.warn = function (source, message, scope) {
-        var event = LogEvent_1.default.log(source, message, LogLevel_1.LogLevel.Warning, scope);
+    }
+    warn(source, message, scope) {
+        const event = _LogEvent.default.log(source, message, _LogLevel.LogLevel.Warning, scope);
         if (DEBUG && !DEPRECATED_UNIT_TEST) {
             // eslint-disable-next-line no-console
             console.warn(event.toString());
         }
-    };
-    LogHandler.prototype.error = function (source, error, scope) {
-        var event = LogEvent_1.default.log(source, error, LogLevel_1.LogLevel.Error, scope);
+    }
+    error(source, error, scope) {
+        const event = _LogEvent.default.log(source, error, _LogLevel.LogLevel.Error, scope);
         if (DEBUG && !DEPRECATED_UNIT_TEST) {
             // eslint-disable-next-line no-console
             console.error(event.toString());
         }
-    };
-    return LogHandler;
-}());
-exports.default = LogHandler;
-//# sourceMappingURL=LogHandler.js.map
+    }
+}
+
+//# sourceMappingURL=./LogHandler.js.map

package/lib-commonjs/Api/LogEntry.js

@@ -1,54 +1,55 @@
-"use strict";
 // Copyright (c) Microsoft. All rights reserved.
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var LogFeature_1 = tslib_1.__importDefault(require("./LogFeature"));
-var LogType_1 = tslib_1.__importDefault(require("./LogType"));
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _LogFeature = /*#__PURE__*/ _interop_require_default._(require("./LogFeature"));
+const _LogType = /*#__PURE__*/ _interop_require_default._(require("./LogType"));
 /**
  * Represents a Log entry
  *
  * @internal
- */
-var LogEntry = /** @class */ (function () {
+ */ 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
-     */
-    function LogEntry(moduleName, logFeature, logType, logProperties, isIntentional) {
-        if (logFeature === void 0) { logFeature = LogFeature_1.default.None; }
-        if (logType === void 0) { logType = LogType_1.default.Trace; }
+   * 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.default.None, logType = _LogType.default.Trace, logProperties, isIntentional){
         if (moduleName) {
             this.moduleName = moduleName;
             this.logFeature = logFeature;
             this.logType = logType;
             this.logProperties = logProperties;
             this.isIntentional = isIntentional;
-        }
-        else {
+        } else {
             throw new Error('moduleName is invalid');
         }
     }
-    /**
-     * convert the log entry to string
-     * @returns the serialized log entry
-     */
-    LogEntry.prototype.toString = function () {
-        var 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 "".concat(this.moduleName, " | ").concat(this.logFeature, " | ").concat(this.logType, " | ").concat(serializedLogProps);
-    };
-    return LogEntry;
-}());
-exports.default = LogEntry;
-//# sourceMappingURL=LogEntry.js.map
+}
+const _default = LogEntry;
+
+//# sourceMappingURL=./LogEntry.js.map

package/lib-commonjs/Api/LogFeature.js

@@ -1,13 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * @internal
- */
-var LogFeature = /** @class */ (function () {
-    function LogFeature() {
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return LogFeature;
     }
-    LogFeature.None = 'None';
-    return LogFeature;
-}());
-exports.default = LogFeature;
-//# sourceMappingURL=LogFeature.js.map
+});
+class LogFeature {
+}
+LogFeature.None = 'None';
+
+//# sourceMappingURL=./LogFeature.js.map

package/lib-commonjs/Api/LogLevel.js

@@ -1,27 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogLevel = void 0;
 /**
  * LogLevel represents the level of a log event.
  * @internal
- */
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LogLevel", {
+    enumerable: true,
+    get: function() {
+        return LogLevel;
+    }
+});
 var LogLevel;
-(function (LogLevel) {
+(function(LogLevel) {
     /**
-     * verbose event for debugging
-     */
-    LogLevel[LogLevel["Verbose"] = 1] = "Verbose";
+   * verbose event for debugging
+   */ LogLevel[LogLevel["Verbose"] = 1] = "Verbose";
     /**
-     * Informational event
-     */
-    LogLevel[LogLevel["Info"] = 2] = "Info";
+   * Informational event
+   */ LogLevel[LogLevel["Info"] = 2] = "Info";
     /**
-     * A warning
-     */
-    LogLevel[LogLevel["Warning"] = 3] = "Warning";
+   * A warning
+   */ LogLevel[LogLevel["Warning"] = 3] = "Warning";
     /**
-     * An error
-     */
-    LogLevel[LogLevel["Error"] = 4] = "Error";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));
-//# sourceMappingURL=LogLevel.js.map
+   * An error
+   */ LogLevel[LogLevel["Error"] = 4] = "Error";
+})(LogLevel || (LogLevel = {}));
+
+//# sourceMappingURL=./LogLevel.js.map

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

@@ -1,33 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * @internal
- */
-var CircularBuffer = /** @class */ (function () {
-    function CircularBuffer(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);
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return CircularBuffer;
     }
-    Object.defineProperty(CircularBuffer.prototype, "count", {
-        get: function () {
-            return this._count;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    CircularBuffer.prototype.push = function (item) {
+});
+class CircularBuffer {
+    get count() {
+        return this._count;
+    }
+    push(item) {
         this._ensureNotIterating();
         this._head++;
         this._count++;
@@ -35,66 +22,71 @@ var CircularBuffer = /** @class */ (function () {
             this._head = 0;
         }
         this._buffer[this._head] = item;
-    };
-    CircularBuffer.prototype.forEach = function (handle) {
+    }
+    forEach(handle) {
         if (this._count === 0) {
             return;
         }
         this._isIterating = true;
         try {
-            var current = this._tail;
+            let current = this._tail;
             // For-loop is prefered over while loop here to avoid possible infinite loop.
-            for (var i = 0; i < this._size; i++) {
+            for(let i = 0; i < this._size; i++){
                 handle(this._buffer[current]);
                 if (current === this._head) {
-                    // The newest item has been processed. End the loop.
                     break;
                 }
                 current = this._getNext(current);
             }
-        }
-        finally {
+        } finally{
             this._isIterating = false;
         }
-    };
-    CircularBuffer.prototype.removeAll = function () {
+    }
+    removeAll() {
         this._ensureNotIterating();
         this._head = -1;
         this._count = 0;
-    };
-    Object.defineProperty(CircularBuffer.prototype, "_tail", {
-        /**
-         * Index of the oldest item in the buffer
-         */
-        get: function () {
-            if (this._isNotWrapped()) {
-                return 0;
-            }
-            return this._getNext(this._head);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    CircularBuffer.prototype._isNotWrapped = function () {
+    }
+    /**
+   * 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.
-     */
-    CircularBuffer.prototype._getNext = function (index) {
-        var nextIndex = index + 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;
-    };
-    CircularBuffer.prototype._ensureNotIterating = function () {
+    }
+    _ensureNotIterating() {
         if (this._isIterating) {
             throw new Error('Circular buffer cannot be modified during iteration');
         }
-    };
-    return CircularBuffer;
-}());
-exports.default = CircularBuffer;
-//# sourceMappingURL=CircularBuffer.js.map
+    }
+    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);
+    }
+}
+
+//# sourceMappingURL=./CircularBuffer.js.map

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

@@ -1,124 +1,107 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var CircularBuffer_1 = tslib_1.__importDefault(require("./CircularBuffer"));
-/**
- * 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
- */
-var LogManager = /** @class */ (function () {
-    function LogManager(initialHandler) {
-        this._shouldLogInRealTime = [];
-        this._handlers = [];
-        this._events = new CircularBuffer_1.default(LogManager._maxVerboseLog);
-        if (initialHandler) {
-            this.addHandler(initialHandler);
-        }
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return LogManager;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _CircularBuffer = /*#__PURE__*/ _interop_require_default._(require("./CircularBuffer"));
+class LogManager {
+    static get _maxVerboseLog() {
+        return 5000;
     }
-    Object.defineProperty(LogManager, "_maxVerboseLog", {
-        get: function () {
-            return 5000;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(LogManager.prototype, "events", {
-        /**
-         * Event list for delayed asynchronous processing.
-         * Events are accumulated in CircularBuffer for processing later.
-         */
-        get: function () {
-            return this._events;
-        },
-        enumerable: false,
-        configurable: true
-    });
     /**
-     * Registers an external logger to logger collection for asynchronous event logging.
-     * Logger is registered once.
-     */
-    LogManager.prototype.addHandler = function (handler) {
+   * 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.
-     */
-    LogManager.prototype.log = function (event) {
+   * 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.
-     */
-    LogManager.prototype.removeHandler = function (handler) {
-        var index = this._handlers.indexOf(handler);
+   * 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.
-     */
-    LogManager.prototype.reset = function () {
+   * 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.
-     */
-    LogManager.prototype.processAll = function (handler) {
+   * Processes all the buffered events using the registered handler.
+   */ processAll(handler) {
         if (this._handlers.indexOf(handler) > -1) {
             this._processAllEvents(handler);
         }
-    };
-    LogManager.prototype._containsHandler = function (handler) {
-        for (var _i = 0, _a = this._handlers; _i < _a.length; _i++) {
-            var existingHandler = _a[_i];
+    }
+    _containsHandler(handler) {
+        for (const existingHandler of this._handlers){
             if (existingHandler === handler) {
                 return true;
             }
         }
         return false;
-    };
-    LogManager.prototype._processAllEvents = function (handler) {
-        this._events.forEach(function (event) {
+    }
+    _processAllEvents(handler) {
+        this._events.forEach((event)=>{
             if (event) {
                 try {
                     handler(event);
-                }
-                catch (e) {
+                } catch (e) {
                     // eslint-disable-next-line no-console
                     console.error('failed to handle event:' + e.toString());
                 }
             }
         });
         this._shouldLogInRealTime[this._handlers.indexOf(handler)] = true;
-    };
-    LogManager.prototype._processLogEvent = function (event) {
-        for (var i = 0; i < this._handlers.length; i++) {
+    }
+    _processLogEvent(event) {
+        for(let i = 0; i < this._handlers.length; i++){
             if (this._shouldLogInRealTime[i] && event) {
                 try {
                     this._handlers[i](event);
-                }
-                catch (e) {
+                } catch (e) {
                     // eslint-disable-next-line no-console
                     console.error('failed to handle event:' + e.toString());
                 }
             }
         }
-    };
-    return LogManager;
-}());
-exports.default = LogManager;
-//# sourceMappingURL=LogManager.js.map
+    }
+    constructor(initialHandler){
+        this._shouldLogInRealTime = [];
+        this._handlers = [];
+        this._events = new _CircularBuffer.default(LogManager._maxVerboseLog);
+        if (initialHandler) {
+            this.addHandler(initialHandler);
+        }
+    }
+}
+
+//# sourceMappingURL=./LogManager.js.map