@microsoft/sp-diagnostics 1.22.0-beta.2 → 1.22.0-beta.4

package/lib/Api/ExecutionQueue.js

@@ -0,0 +1,133 @@
+/**
+ * ExecutionQueue allows multiple handlers to be processed in real time or deferred.
+ * @internal
+ */
+var ExecutionQueue = /** @class */ (function () {
+    function ExecutionQueue() {
+        this._shouldExecuteInRealTime = false;
+        this._handlers = {};
+        this._executionEntries = [];
+    }
+    Object.defineProperty(ExecutionQueue.prototype, "shouldExecuteInRealTime", {
+        /**
+         * 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.
+         */
+        get: function () {
+            return this._shouldExecuteInRealTime;
+        },
+        /**
+         * Sets the behavior for this execution stack.
+         * 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.
+         */
+        set: function (executeInRealTime) {
+            this._shouldExecuteInRealTime = executeInRealTime;
+            if (this._shouldExecuteInRealTime) {
+                this.flush();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Registers an external handler to collection for delayed asynchronous processing.
+     * Handlers are registered once. If handler is already registered, it does nothing.
+     */
+    ExecutionQueue.prototype.addHandler = function (key, handler) {
+        if (this._containsHandler(key, handler)) {
+            return;
+        }
+        this._initializeHandlerArrayForKey(key);
+        var handlers = this._handlers[key];
+        if (handlers.indexOf(handler) === -1) {
+            handlers.push(handler);
+        }
+    };
+    /**
+     * Execution Entry registration for delayed asynchronous processing.
+     */
+    ExecutionQueue.prototype.addExecutionEntry = function (key) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        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.
+     */
+    ExecutionQueue.prototype.removeHandler = function (key, handler) {
+        var 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.
+     */
+    ExecutionQueue.prototype.reset = function () {
+        this._handlers = {};
+        this._executionEntries = [];
+    };
+    /**
+     * Flushes all the buffered execution entries.
+     * All recorded execution entries are purged.
+     */
+    ExecutionQueue.prototype.flush = function () {
+        this._processAllExecutionEntries();
+        this._executionEntries = [];
+    };
+    ExecutionQueue.prototype._containsHandler = function (key, handler) {
+        if (this._handlers[key] !== null && this._handlers[key] !== undefined) {
+            return this._handlers[key].indexOf(handler) > -1;
+        }
+        return false;
+    };
+    ExecutionQueue.prototype._initializeHandlerArrayForKey = function (key) {
+        if (this._handlers[key] === null || this._handlers[key] === undefined) {
+            this._handlers[key] = [];
+        }
+    };
+    ExecutionQueue.prototype._processAllExecutionEntries = function () {
+        for (var _i = 0, _a = this._executionEntries; _i < _a.length; _i++) {
+            var entry = _a[_i];
+            if (entry && this._handlers[entry.key]) {
+                try {
+                    for (var _b = 0, _c = this._handlers[entry.key]; _b < _c.length; _b++) {
+                        var handler = _c[_b];
+                        handler.apply(this, entry.args);
+                    }
+                }
+                catch (e) {
+                    // eslint-disable-next-line no-console
+                    console.error('failed to process execution entry:' + e.toString());
+                }
+            }
+        }
+    };
+    ExecutionQueue.prototype._processExecutionEntry = function (key, args) {
+        for (var 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());
+            }
+        }
+    };
+    return ExecutionQueue;
+}());
+export default ExecutionQueue;
+//# sourceMappingURL=ExecutionQueue.js.map

package/lib/Api/ILogData.d.ts

@@ -0,0 +1,36 @@
+import type ILogEntry from './ILogEntry';
+import type ILogSource from './ILogSource';
+import type { ServiceScope } from '@microsoft/sp-core-library';
+/**
+ * If you don't specify parameter:eventName
+ * the event name for all errors logged that way will be same "CaughtError" with
+ * appropriate prefix ("ModernPublish.CaughtError" etc.)
+ * The parameter "eventName" is there to be used from Qos.
+ * It is not encouraged to use it directly from ErrorHelper but if you do,
+ * the log will be written with custom event name of following format:
+ * <Workload>.<eventName>.<resultCode>.Failure, where resultCOde is only used
+ * in ILogErrorData.
+ *
+ *
+ * @internal
+ */
+interface ILogData {
+    /**
+     *
+     */
+    source: ILogSource;
+    /**
+     *
+     */
+    eventName?: string;
+    /**
+     *
+     */
+    serviceScope?: ServiceScope;
+    /**
+     *
+     */
+    logEntry?: ILogEntry;
+}
+export default ILogData;
+//# sourceMappingURL=ILogData.d.ts.map

package/lib/Api/ILogData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ILogData.d.ts","sourceRoot":"","sources":["../../src/Api/ILogData.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,UAAU,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,UAAU,QAAQ;IAChB;;OAEG;IACH,MAAM,EAAE,UAAU,CAAC;IAEnB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B;;OAEG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,eAAe,QAAQ,CAAC"}

package/lib/Api/ILogData.js

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

package/lib/Api/ILogEntry.d.ts

@@ -0,0 +1,29 @@
+import type LogType from './LogType';
+/**
+ * @internal
+ */
+interface ILogEntry {
+    /**
+     * Optionally log if the event indicates an intentional action or not
+     */
+    isIntentional?: boolean;
+    /**
+     * The name of the module associated with this entry
+     */
+    moduleName: string;
+    /**
+     * The feature associated with this entry
+     */
+    logFeature: string;
+    /**
+     * The log type
+     * todo: dkholo:task#356773 perform a cleanup after data format validation confirmation
+     */
+    logType: LogType;
+    /**
+     * The optional property bag
+     */
+    logProperties?: Record<string, string | undefined>;
+}
+export default ILogEntry;
+//# sourceMappingURL=ILogEntry.d.ts.map

package/lib/Api/ILogEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ILogEntry.d.ts","sourceRoot":"","sources":["../../src/Api/ILogEntry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC;;GAEG;AACH,UAAU,SAAS;IACjB;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CACpD;AAED,eAAe,SAAS,CAAC"}

package/lib/Api/ILogEntry.js

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

package/lib/Api/ILogErrorData.d.ts

@@ -0,0 +1,21 @@
+import type ILogData from './ILogData';
+/**
+ * The error parameter is the only required parameter and basically will be just converted to string and
+ * logged to Debug stream (RealibilityLogs in SLAPI).
+ * It will also be uploaded to the server immediately and not wait for next batch log upload.
+ * The parameter "resultCode" is there to be used from Qos.
+ *
+ * @internal
+ */
+interface ILogErrorData extends ILogData {
+    /**
+     * The error associated with this log data.
+     */
+    error: Error;
+    /**
+     *
+     */
+    resultCode?: string;
+}
+export default ILogErrorData;
+//# sourceMappingURL=ILogErrorData.d.ts.map

package/lib/Api/ILogErrorData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ILogErrorData.d.ts","sourceRoot":"","sources":["../../src/Api/ILogErrorData.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AAEvC;;;;;;;GAOG;AACH,UAAU,aAAc,SAAQ,QAAQ;IACtC;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAe,aAAa,CAAC"}

package/lib/Api/ILogErrorData.js

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

package/lib/Api/ILogSource.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interface defining the source a log
+ *
+ * @internal
+ */
+interface ILogSource {
+    id: string;
+}
+export default ILogSource;
+//# sourceMappingURL=ILogSource.d.ts.map

package/lib/Api/ILogSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ILogSource.d.ts","sourceRoot":"","sources":["../../src/Api/ILogSource.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,UAAU,UAAU;IAIlB,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,eAAe,UAAU,CAAC"}

package/lib/Api/ILogSource.js

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

package/lib/Api/ILogVerboseData.d.ts

@@ -0,0 +1,12 @@
+import type ILogData from './ILogData';
+/**
+ * @internal
+ */
+interface ILogVerboseData extends ILogData {
+    /**
+     * The message associated with this log data.
+     */
+    message: string;
+}
+export default ILogVerboseData;
+//# sourceMappingURL=ILogVerboseData.d.ts.map

package/lib/Api/ILogVerboseData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ILogVerboseData.d.ts","sourceRoot":"","sources":["../../src/Api/ILogVerboseData.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC;AAEvC;;GAEG;AACH,UAAU,eAAgB,SAAQ,QAAQ;IACxC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAe,eAAe,CAAC"}

package/lib/Api/ILogVerboseData.js

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

package/lib/Api/Log/LogHandler.d.ts

@@ -0,0 +1,12 @@
+import type { ILogHandler, ServiceScope } from '@microsoft/sp-core-library';
+/**
+ * This handler adapts the sp-core-library Log to use the internal telemetry.
+ * @internal
+ */
+export default class LogHandler implements ILogHandler {
+    verbose(source: string, message: string, scope: ServiceScope): void;
+    info(source: string, message: string, scope: ServiceScope): void;
+    warn(source: string, message: string, scope: ServiceScope): void;
+    error(source: string, error: Error, scope: ServiceScope): void;
+}
+//# sourceMappingURL=LogHandler.d.ts.map

package/lib/Api/Log/LogHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogHandler.d.ts","sourceRoot":"","sources":["../../../src/Api/Log/LogHandler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAI5E;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,UAAW,YAAW,WAAW;IAC7C,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI;IAQnE,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI;IAQhE,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI;IAQhE,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI;CAOtE"}

package/lib/Api/Log/LogHandler.js

@@ -0,0 +1,41 @@
+import { LogLevel } from '../LogLevel';
+import LogEvent from '../Trace/LogEvent';
+/**
+ * This handler adapts the sp-core-library Log to use the internal telemetry.
+ * @internal
+ */
+var LogHandler = /** @class */ (function () {
+    function LogHandler() {
+    }
+    LogHandler.prototype.verbose = function (source, message, scope) {
+        var event = LogEvent.log(source, message, 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.log(source, message, LogLevel.Info, scope);
+        if (DEBUG && !DEPRECATED_UNIT_TEST) {
+            // eslint-disable-next-line no-console
+            console.info(event.toString());
+        }
+    };
+    LogHandler.prototype.warn = function (source, message, scope) {
+        var event = LogEvent.log(source, message, 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.log(source, error, LogLevel.Error, scope);
+        if (DEBUG && !DEPRECATED_UNIT_TEST) {
+            // eslint-disable-next-line no-console
+            console.error(event.toString());
+        }
+    };
+    return LogHandler;
+}());
+export default LogHandler;
+//# sourceMappingURL=LogHandler.js.map

package/lib/Api/LogEntry.d.ts

@@ -0,0 +1,29 @@
+import type ILogEntry from './ILogEntry';
+import LogType from './LogType';
+/**
+ * Represents a Log entry
+ *
+ * @internal
+ */
+declare class LogEntry implements ILogEntry {
+    moduleName: string;
+    logFeature: string;
+    logType: LogType;
+    logProperties: Record<string, string | undefined> | undefined;
+    isIntentional: boolean | undefined;
+    /**
+     * 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: string, logFeature?: string, logType?: LogType, logProperties?: Record<string, string | undefined>, isIntentional?: boolean);
+    /**
+     * convert the log entry to string
+     * @returns the serialized log entry
+     */
+    toString(): string;
+}
+export default LogEntry;
+//# sourceMappingURL=LogEntry.d.ts.map

package/lib/Api/LogEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogEntry.d.ts","sourceRoot":"","sources":["../../src/Api/LogEntry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAEzC,OAAO,OAAO,MAAM,WAAW,CAAC;AAEhC;;;;GAIG;AACH,cAAM,QAAS,YAAW,SAAS;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;IAC9D,aAAa,EAAE,OAAO,GAAG,SAAS,CAAC;IAE1C;;;;;;OAMG;gBAED,UAAU,EAAE,MAAM,EAClB,UAAU,GAAE,MAAwB,EACpC,OAAO,GAAE,OAAuB,EAChC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EAClD,aAAa,CAAC,EAAE,OAAO;IAazB;;;OAGG;IACI,QAAQ,IAAI,MAAM;CAa1B;AAED,eAAe,QAAQ,CAAC"}

package/lib/Api/LogEntry.js

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft. All rights reserved.
+import LogFeature from './LogFeature';
+import LogType from './LogType';
+/**
+ * Represents a Log entry
+ *
+ * @internal
+ */
+var LogEntry = /** @class */ (function () {
+    /**
+     * 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.None; }
+        if (logType === void 0) { logType = LogType.Trace; }
+        if (moduleName) {
+            this.moduleName = moduleName;
+            this.logFeature = logFeature;
+            this.logType = logType;
+            this.logProperties = logProperties;
+            this.isIntentional = isIntentional;
+        }
+        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;
+}());
+export default LogEntry;
+//# sourceMappingURL=LogEntry.js.map

package/lib/Api/LogFeature.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ */
+export default class LogFeature {
+    static None: string;
+}
+//# sourceMappingURL=LogFeature.d.ts.map

package/lib/Api/LogFeature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogFeature.d.ts","sourceRoot":"","sources":["../../src/Api/LogFeature.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IAC7B,OAAc,IAAI,EAAE,MAAM,CAAU;CACrC"}

package/lib/Api/LogFeature.js

@@ -0,0 +1,11 @@
+/**
+ * @internal
+ */
+var LogFeature = /** @class */ (function () {
+    function LogFeature() {
+    }
+    LogFeature.None = 'None';
+    return LogFeature;
+}());
+export default LogFeature;
+//# sourceMappingURL=LogFeature.js.map

package/lib/Api/LogLevel.d.ts

@@ -0,0 +1,23 @@
+/**
+ * LogLevel represents the level of a log event.
+ * @internal
+ */
+export declare enum LogLevel {
+    /**
+     * verbose event for debugging
+     */
+    Verbose = 1,
+    /**
+     * Informational event
+     */
+    Info = 2,
+    /**
+     * A warning
+     */
+    Warning = 3,
+    /**
+     * An error
+     */
+    Error = 4
+}
+//# sourceMappingURL=LogLevel.d.ts.map

package/lib/Api/LogLevel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogLevel.d.ts","sourceRoot":"","sources":["../../src/Api/LogLevel.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,QAAQ;IAClB;;OAEG;IACH,OAAO,IAAI;IACX;;OAEG;IACH,IAAI,IAAA;IACJ;;OAEG;IACH,OAAO,IAAA;IACP;;OAEG;IACH,KAAK,IAAA;CACN"}

package/lib/Api/LogLevel.js

@@ -0,0 +1,24 @@
+/**
+ * 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/Api/LogManager/CircularBuffer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @internal
+ */
+export default class CircularBuffer<DataType> {
+    /**
+     * The size of the buffer
+     */
+    private _size;
+    /**
+     * Index of the newest item in the buffer
+     */
+    private _head;
+    /**
+     * The overall count of how many items have ever been added to the buffer.
+     */
+    private _count;
+    private _buffer;
+    private _isIterating;
+    constructor(size: number);
+    get count(): number;
+    push(item: DataType): void;
+    forEach(handle: (value: DataType) => void): void;
+    removeAll(): void;
+    /**
+     * Index of the oldest item in the buffer
+     */
+    private get _tail();
+    private _isNotWrapped;
+    /**
+     * The next index should be index + 1, unless it reaches
+     * the end of the buffer and needs to rewind to 0.
+     */
+    private _getNext;
+    private _ensureNotIterating;
+}
+//# sourceMappingURL=CircularBuffer.d.ts.map

package/lib/Api/LogManager/CircularBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CircularBuffer.d.ts","sourceRoot":"","sources":["../../../src/Api/LogManager/CircularBuffer.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc,CAAC,QAAQ;IAC1C;;OAEG;IACH,OAAO,CAAC,KAAK,CAAS;IACtB;;OAEG;IACH,OAAO,CAAC,KAAK,CAAc;IAC3B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,YAAY,CAAkB;gBAEnB,IAAI,EAAE,MAAM;IAQ/B,IAAW,KAAK,IAAI,MAAM,CAEzB;IAEM,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAU1B,OAAO,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI;IAqBhD,SAAS,IAAI,IAAI;IAMxB;;OAEG;IACH,OAAO,KAAK,KAAK,GAKhB;IAED,OAAO,CAAC,aAAa;IAIrB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAQhB,OAAO,CAAC,mBAAmB;CAK5B"}

package/lib/Api/LogManager/CircularBuffer.js

@@ -0,0 +1,98 @@
+/**
+ * @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);
+    }
+    Object.defineProperty(CircularBuffer.prototype, "count", {
+        get: function () {
+            return this._count;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    CircularBuffer.prototype.push = function (item) {
+        this._ensureNotIterating();
+        this._head++;
+        this._count++;
+        if (this._head === this._size) {
+            this._head = 0;
+        }
+        this._buffer[this._head] = item;
+    };
+    CircularBuffer.prototype.forEach = function (handle) {
+        if (this._count === 0) {
+            return;
+        }
+        this._isIterating = true;
+        try {
+            var current = this._tail;
+            // For-loop is prefered over while loop here to avoid possible infinite loop.
+            for (var 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 {
+            this._isIterating = false;
+        }
+    };
+    CircularBuffer.prototype.removeAll = function () {
+        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 () {
+        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;
+        if (nextIndex === this._size) {
+            nextIndex = 0;
+        }
+        return nextIndex;
+    };
+    CircularBuffer.prototype._ensureNotIterating = function () {
+        if (this._isIterating) {
+            throw new Error('Circular buffer cannot be modified during iteration');
+        }
+    };
+    return CircularBuffer;
+}());
+export default CircularBuffer;
+//# sourceMappingURL=CircularBuffer.js.map