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

package/lib/Api/Qos/QosResultType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QosResultType.d.ts","sourceRoot":"","sources":["../../../src/Api/Qos/QosResultType.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX;;;GAGG;AAEH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC"}

package/lib/Api/Qos/QosResultType.js

@@ -0,0 +1,11 @@
+/**
+ * Qos Result Type const object.
+ * @internal
+ */
+// eslint-disable-next-line @typescript-eslint/typedef
+export var QosResultType = {
+    Success: 0,
+    Failure: 1,
+    ExpectedFailure: 2
+};
+//# sourceMappingURL=QosResultType.js.map

package/lib/Api/Trace/DefaultTraceHandler.d.ts

@@ -0,0 +1,15 @@
+import type { ITraceHandler, ITraceLogEvent, IVerboseTraceLogEvent } from './ITraceHandler';
+/**
+ * Default implementation for the Trace logger class.
+ */
+export default class DefaultTraceHandler implements ITraceHandler {
+    /**
+     * Default implementation for log function.
+     */
+    log(traceLogEvent: ITraceLogEvent): void;
+    /**
+     * Default implementation for verbose function.
+     */
+    verbose(verboseTraceEvent: IVerboseTraceLogEvent): void;
+}
+//# sourceMappingURL=DefaultTraceHandler.d.ts.map

package/lib/Api/Trace/DefaultTraceHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultTraceHandler.d.ts","sourceRoot":"","sources":["../../../src/Api/Trace/DefaultTraceHandler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE5F;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAoB,YAAW,aAAa;IAC/D;;OAEG;IACI,GAAG,CAAC,aAAa,EAAE,cAAc,GAAG,IAAI;IAW/C;;OAEG;IACI,OAAO,CAAC,iBAAiB,EAAE,qBAAqB,GAAG,IAAI;CAM/D"}

package/lib/Api/Trace/DefaultTraceHandler.js

@@ -0,0 +1,30 @@
+/**
+ * Default implementation for the Trace logger class.
+ */
+var DefaultTraceHandler = /** @class */ (function () {
+    function DefaultTraceHandler() {
+    }
+    /**
+     * Default implementation for log function.
+     */
+    DefaultTraceHandler.prototype.log = function (traceLogEvent) {
+        if (!DEPRECATED_UNIT_TEST) {
+            // eslint-disable-next-line no-console
+            console.log("Error: ".concat(traceLogEvent.data, ", ") +
+                "Event Name: ".concat(traceLogEvent.eventName, ", ") +
+                "Result Code: ".concat(traceLogEvent.resultCode));
+        }
+    };
+    /**
+     * Default implementation for verbose function.
+     */
+    DefaultTraceHandler.prototype.verbose = function (verboseTraceEvent) {
+        if (!DEPRECATED_UNIT_TEST) {
+            // eslint-disable-next-line no-console
+            console.log("Error: ".concat(verboseTraceEvent.data, ", Event Name: ").concat(verboseTraceEvent.eventName));
+        }
+    };
+    return DefaultTraceHandler;
+}());
+export default DefaultTraceHandler;
+//# sourceMappingURL=DefaultTraceHandler.js.map

package/lib/Api/Trace/ITraceHandler.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Trace logger log data interface
+ * @internal
+ */
+export interface ITraceHandler {
+    /** Trace logging operation **/
+    log(traceEvent: ITraceLogEvent): void;
+    /** Verbose trace logging operation **/
+    verbose(traceVerboseEvent: IVerboseTraceLogEvent): void;
+}
+/**
+ * IVerboseTraceLogEvent log data interface
+ * @internal
+ */
+export interface IVerboseTraceLogEvent {
+    /** Data for the Trace Log **/
+    data: string | Error;
+    /** Event Name for the Trace Log **/
+    eventName: string;
+}
+/**
+ * ITraceLogEvent log data interface
+ * @internal
+ */
+export interface ITraceLogEvent extends IVerboseTraceLogEvent {
+    /** Result Code for the Trace Log **/
+    resultCode?: string;
+}
+//# sourceMappingURL=ITraceHandler.d.ts.map

package/lib/Api/Trace/ITraceHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITraceHandler.d.ts","sourceRoot":"","sources":["../../../src/Api/Trace/ITraceHandler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,+BAA+B;IAC/B,GAAG,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI,CAAC;IAEtC,uCAAuC;IACvC,OAAO,CAAC,iBAAiB,EAAE,qBAAqB,GAAG,IAAI,CAAC;CACzD;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,8BAA8B;IAC9B,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IAErB,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAe,SAAQ,qBAAqB;IAC3D,qCAAqC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

package/lib/Api/Trace/ITraceHandler.js

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

package/lib/Api/Trace/ITraceLogger.d.ts

@@ -0,0 +1,13 @@
+import type ILogEntry from '../ILogEntry';
+import type ILogSource from '../ILogSource';
+/**
+ * @internal
+ */
+interface ITraceLogger {
+    logError(source: ILogSource, error: Error, eventName?: string, resultCode?: string): void;
+    logVerbose(source: ILogSource, message: string, eventName?: string): void;
+    logErrorWithLogEntry(source: ILogSource, logEntry: ILogEntry, eventName?: string, resultCode?: string): void;
+    logVerboseWithLogEntry(source: ILogSource, logEntry: ILogEntry, eventName?: string): void;
+}
+export default ITraceLogger;
+//# sourceMappingURL=ITraceLogger.d.ts.map

package/lib/Api/Trace/ITraceLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITraceLogger.d.ts","sourceRoot":"","sources":["../../../src/Api/Trace/ITraceLogger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAE5C;;GAEG;AACH,UAAU,YAAY;IACpB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1F,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1E,oBAAoB,CAClB,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,SAAS,EACnB,SAAS,CAAC,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,IAAI,CAAC;IACR,sBAAsB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3F;AAED,eAAe,YAAY,CAAC"}

package/lib/Api/Trace/ITraceLogger.js

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

package/lib/Api/Trace/LogEvent.d.ts

@@ -0,0 +1,49 @@
+import type { ServiceScope } from '@microsoft/sp-core-library';
+import { type default as LogSource } from '../LogSource';
+import type { LogLevel } from '../LogLevel';
+import LogManager from '../LogManager/LogManager';
+/**
+ * An object that represents one log event.
+ * @internal
+ */
+export default class LogEvent {
+    /**
+     * Allows process log events.
+     */
+    static logManager: LogManager<LogEvent>;
+    private _timestamp;
+    private _scope;
+    private _source;
+    private _message;
+    private _error;
+    private _level;
+    private _prefix;
+    /**
+     * Use this method to log an event.
+     *
+     * @param source - source of the log event, e.g. class name of the source file
+     * @param data - data of the log event
+     * @param level - level of the log event
+     * @param serviceScope - scope of the log event, e.g. component/web part
+     */
+    static log(source: string, data: string | Error, level: LogLevel, serviceScope?: ServiceScope): LogEvent;
+    /**
+     * Do not call this constructor directly. Use LogEvent.log instead.
+     */
+    constructor(source: string, data: string | Error, level: LogLevel, serviceScope?: ServiceScope);
+    toString(): string;
+    get timestamp(): number;
+    get level(): LogLevel;
+    get prefix(): string;
+    get scope(): LogSource | undefined;
+    get source(): string;
+    get message(): string | undefined;
+    get error(): Error | undefined;
+    private get _maxSourceLength();
+    private get _maxMessageLength();
+    private _validate;
+    private _setData;
+    private _getPrefix;
+    private _getScope;
+}
+//# sourceMappingURL=LogEvent.d.ts.map

package/lib/Api/Trace/LogEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogEvent.d.ts","sourceRoot":"","sources":["../../../src/Api/Trace/LogEvent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,KAAK,OAAO,IAAI,SAAS,EAAuB,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,UAAU,MAAM,0BAA0B,CAAC;AAElD;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC3B;;OAEG;IACH,OAAc,UAAU,EAAE,UAAU,CAAC,QAAQ,CAAC,CAA8B;IAE5E,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,OAAO,CAAS;IAExB;;;;;;;OAOG;WACW,GAAG,CACf,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GAAG,KAAK,EACpB,KAAK,EAAE,QAAQ,EACf,YAAY,CAAC,EAAE,YAAY,GAC1B,QAAQ;IAMX;;OAEG;gBACgB,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,CAAC,EAAE,YAAY;IAU9F,QAAQ,IAAI,MAAM;IAWzB,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED,IAAW,KAAK,IAAI,QAAQ,CAE3B;IAED,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,IAAW,KAAK,IAAI,SAAS,GAAG,SAAS,CAExC;IAED,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,IAAW,OAAO,IAAI,MAAM,GAAG,SAAS,CAEvC;IAED,IAAW,KAAK,IAAI,KAAK,GAAG,SAAS,CAEpC;IAED,OAAO,KAAK,gBAAgB,GAE3B;IAED,OAAO,KAAK,iBAAiB,GAE5B;IAED,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,QAAQ;IAQhB,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,SAAS;CAUlB"}

package/lib/Api/Trace/LogEvent.js

@@ -0,0 +1,147 @@
+import { logSourceServiceKey } from '../LogSource';
+import LogManager from '../LogManager/LogManager';
+/**
+ * An object that represents one log event.
+ * @internal
+ */
+var LogEvent = /** @class */ (function () {
+    /**
+     * Do not call this constructor directly. Use LogEvent.log instead.
+     */
+    function LogEvent(source, data, level, serviceScope) {
+        this._validate(source, data);
+        this._timestamp = new Date().getTime();
+        this._scope = this._getScope(serviceScope);
+        this._source = source.substr(0, this._maxSourceLength);
+        this._setData(data);
+        this._level = level;
+        this._prefix = this._getPrefix();
+    }
+    /**
+     * Use this method to log an event.
+     *
+     * @param source - source of the log event, e.g. class name of the source file
+     * @param data - data of the log event
+     * @param level - level of the log event
+     * @param serviceScope - scope of the log event, e.g. component/web part
+     */
+    LogEvent.log = function (source, data, level, serviceScope) {
+        var event = new LogEvent(source, data, level, serviceScope);
+        LogEvent.logManager.log(event);
+        return event;
+    };
+    LogEvent.prototype.toString = function () {
+        var timedPrefix = "[".concat(this._timestamp, "][").concat(this._prefix, "]");
+        if (this._message) {
+            return "".concat(timedPrefix, " ").concat(this._message);
+        }
+        else if (this._error) {
+            return "".concat(timedPrefix, " ").concat(this._error.toString());
+        }
+        else {
+            return timedPrefix;
+        }
+    };
+    Object.defineProperty(LogEvent.prototype, "timestamp", {
+        get: function () {
+            return this._timestamp;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LogEvent.prototype, "level", {
+        get: function () {
+            return this._level;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LogEvent.prototype, "prefix", {
+        get: function () {
+            return this._prefix;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LogEvent.prototype, "scope", {
+        get: function () {
+            return this._scope;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LogEvent.prototype, "source", {
+        get: function () {
+            return this._source;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LogEvent.prototype, "message", {
+        get: function () {
+            return this._message;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LogEvent.prototype, "error", {
+        get: function () {
+            return this._error;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LogEvent.prototype, "_maxSourceLength", {
+        get: function () {
+            return 30;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LogEvent.prototype, "_maxMessageLength", {
+        get: function () {
+            return 150;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    LogEvent.prototype._validate = function (source, data) {
+        if (!source) {
+            throw new Error('source cannot be undefined or null for Logger');
+        }
+        if (!data) {
+            throw new Error('data cannot be undefined or null');
+        }
+    };
+    LogEvent.prototype._setData = function (data) {
+        if (typeof data === 'string') {
+            this._message = data.substr(0, this._maxMessageLength);
+        }
+        else if (data instanceof Error) {
+            this._error = data;
+        }
+    };
+    LogEvent.prototype._getPrefix = function () {
+        var prefix = "".concat(this._source);
+        if (this._scope && !this._scope.isEmpty()) {
+            prefix = "".concat(this._scope.id.substr(0, this._maxSourceLength), ".").concat(prefix);
+        }
+        return "".concat(prefix);
+    };
+    LogEvent.prototype._getScope = function (serviceScope) {
+        var parentSource;
+        if (serviceScope) {
+            serviceScope.whenFinished(function () {
+                parentSource = serviceScope.consume(logSourceServiceKey);
+            });
+        }
+        return parentSource;
+    };
+    /**
+     * Allows process log events.
+     */
+    LogEvent.logManager = new LogManager();
+    return LogEvent;
+}());
+export default LogEvent;
+//# sourceMappingURL=LogEvent.js.map

package/lib/Api/Trace/TraceLogger.d.ts

@@ -0,0 +1,102 @@
+import type ILogEntry from '../ILogEntry';
+import type ILogSource from '../ILogSource';
+import type ILogErrorData from '../ILogErrorData';
+import type ILogVerboseData from '../ILogVerboseData';
+import type { ITraceHandler, ITraceLogEvent, IVerboseTraceLogEvent } from './ITraceHandler';
+import LogManager from '../LogManager/LogManager';
+/**
+ * This is used to log traces of failed operations and debugging information.
+ * @internal
+ */
+export default class TraceLogger {
+    /**
+     * Allows process trace log events.
+     */
+    static _logManager: LogManager<ITraceLogEvent>;
+    /**
+     * Allows process verbose trace log events.
+     */
+    static _verboseLogManager: LogManager<IVerboseTraceLogEvent>;
+    private static _defaultLogger;
+    private static _shouldWriteToConsole;
+    /**
+     * Init function for the passed logger object
+     *
+     * @internal
+     */
+    static _addHandler(logger: ITraceHandler): void;
+    /**
+     * Exception logging
+     * This shoule be used whenever you want to log something that might in future help to debug failures.
+     * The error parameter is the only required one 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.
+     * If you don't specify second parameter:eventName
+     * the event name for all errors logged that way will be same "CaughtError" with
+     * appropriate prefix ("ModernPublish.CaughtError" etc.)
+     * These two parameters "eventName and resultCode" are there to be used from Qos.
+     * It is not encouraged to use them directly from ErrorHelper but if you do,
+     * the log will be written with custom event name of following format:
+     * <Workload>.<eventName>.<resultCode>.Failure, Workload is set in Telemetry settings.
+     **/
+    static logError(source: ILogSource, error: Error, eventName?: string, resultCode?: string): void;
+    /**
+     * Exception logging intended to replace to logError.
+     *
+     * @remarks
+     * Uses the `ILogErrorData` interface to prevent excessive undefined parameters
+     * when calling this function.
+     * This should be used whenever you want to log something that might in future help to
+     * debug failures.
+     * It will also be uploaded to the server immediately and not wait for next batch log upload.
+     */
+    static logErrorData(data: ILogErrorData): void;
+    /**
+     * Trace logging
+     * The idea here is that verbose logs don't get uploaded to the server unless
+     * a failure is logged using ErrorHelper.log method.
+     * There is a circular buffer that holds last 50 verbose logs from all scenarios and
+     * it is only flushed and uploaded in case a failure is logged.
+     * That way whenever you get a failure event with message you also have all supportive verbose messages
+     * you logged throughout your scenario execution (or other scenarios).
+     * And hopefully that would help you get to the bottom of what exactly went wrong.
+     * If no failure happens and your scenario succeeds, verbose logs will be just left in the buffer
+     * and most likely overriden by next scenario that logs something verbose.
+     **/
+    static logVerbose(source: ILogSource, message: string, eventName?: string): void;
+    /**
+     * Verbose logging intended to replace to logVerbose.
+     * The idea here is that verbose logs don't get uploaded to the server unless
+     * a failure is logged using ErrorHelper.log method.
+     * There is a circular buffer that holds last 50 verbose logs from all scenarios and
+     * it is only flushed and uploaded in case a failure is logged.
+     * That way whenever you get a failure event with message you also have all supportive verbose messages
+     * you logged throughout your scenario execution (or other scenarios).
+     * And hopefully that would help you get to the bottom of what exactly went wrong.
+     * If no failure happens and your scenario succeeds, verbose logs will be just left in the buffer
+     * and most likely overridden by next scenario that logs something verbose.
+     */
+    static logVerboseData(data: ILogVerboseData): void;
+    /**
+     * Exception logging With LogEntry
+     * error message should be packed into logProperties
+     * LogType should be LogType.Error and LogProperties should have `{error:errorMessage}`
+     * Do NOT add PII data!
+     **/
+    static logErrorWithLogEntry(source: ILogSource, logEntry: ILogEntry, eventName?: string, resultCode?: string): void;
+    /**
+     * Indicates if the log entries should be output to the console.
+     * This flag is set to true by default.
+     */
+    static get shouldWriteToConsole(): boolean;
+    /**
+     * Toggles console output functionality.
+     * Property can be chaged by remote caller.
+     */
+    static set shouldWriteToConsole(shouldWrite: boolean);
+    static logVerboseWithLogEntry(source: ILogSource, logEntry: ILogEntry, eventName?: string): void;
+    private static _log;
+    private static _addEventPrefix;
+    private static _writeToConsole;
+}
+//# sourceMappingURL=TraceLogger.d.ts.map

package/lib/Api/Trace/TraceLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TraceLogger.d.ts","sourceRoot":"","sources":["../../../src/Api/Trace/TraceLogger.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAG5C,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,eAAe,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE5F,OAAO,UAAU,MAAM,0BAA0B,CAAC;AAElD;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,WAAW;IAC9B;;OAEG;IACH,OAAc,WAAW,EAAE,UAAU,CAAC,cAAc,CAAC,CAAoC;IAEzF;;OAEG;IACH,OAAc,kBAAkB,EAAE,UAAU,CAAC,qBAAqB,CAAC,CACzB;IAE1C,OAAO,CAAC,MAAM,CAAC,cAAc,CAA4C;IACzE,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAkB;IAEtD;;;;OAIG;WACW,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAOtD;;;;;;;;;;;;;QAaI;WACU,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;IAKvG;;;;;;;;;OASG;WACW,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAMrD;;;;;;;;;;;QAWI;WACU,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAKvF;;;;;;;;;;;OAWG;WACW,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI;IAKzD;;;;;QAKI;WACU,oBAAoB,CAChC,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,SAAS,EACnB,SAAS,CAAC,EAAE,MAAM,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,IAAI;IAMP;;;OAGG;IACH,WAAkB,oBAAoB,IAAI,OAAO,CAEhD;IAED;;;OAGG;IACH,WAAkB,oBAAoB,CAAC,WAAW,EAAE,OAAO,EAS1D;WASa,sBAAsB,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAKvG,OAAO,CAAC,MAAM,CAAC,IAAI;IA2BnB,OAAO,CAAC,MAAM,CAAC,eAAe;IAY9B,OAAO,CAAC,MAAM,CAAC,eAAe;CAgB/B"}

package/lib/Api/Trace/TraceLogger.js

@@ -0,0 +1,197 @@
+import { Validate } from '@microsoft/sp-core-library';
+import LogEvent from './LogEvent';
+import { LogLevel } from '../LogLevel';
+import DefaultTraceHandler from './DefaultTraceHandler';
+import LogManager from '../LogManager/LogManager';
+/**
+ * This is used to log traces of failed operations and debugging information.
+ * @internal
+ */
+var TraceLogger = /** @class */ (function () {
+    function TraceLogger() {
+    }
+    /**
+     * Init function for the passed logger object
+     *
+     * @internal
+     */
+    TraceLogger._addHandler = function (logger) {
+        TraceLogger._logManager.addHandler(logger.log);
+        TraceLogger._logManager.processAll(logger.log);
+        TraceLogger._verboseLogManager.addHandler(logger.verbose);
+        TraceLogger._verboseLogManager.processAll(logger.verbose);
+    };
+    /**
+     * Exception logging
+     * This shoule be used whenever you want to log something that might in future help to debug failures.
+     * The error parameter is the only required one 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.
+     * If you don't specify second parameter:eventName
+     * the event name for all errors logged that way will be same "CaughtError" with
+     * appropriate prefix ("ModernPublish.CaughtError" etc.)
+     * These two parameters "eventName and resultCode" are there to be used from Qos.
+     * It is not encouraged to use them directly from ErrorHelper but if you do,
+     * the log will be written with custom event name of following format:
+     * <Workload>.<eventName>.<resultCode>.Failure, Workload is set in Telemetry settings.
+     **/
+    TraceLogger.logError = function (source, error, eventName, resultCode) {
+        Validate.isNotNullOrUndefined(error, 'error');
+        this._log(source, error, eventName, true, resultCode);
+    };
+    /**
+     * Exception logging intended to replace to logError.
+     *
+     * @remarks
+     * Uses the `ILogErrorData` interface to prevent excessive undefined parameters
+     * when calling this function.
+     * This should be used whenever you want to log something that might in future help to
+     * debug failures.
+     * It will also be uploaded to the server immediately and not wait for next batch log upload.
+     */
+    TraceLogger.logErrorData = function (data) {
+        Validate.isNotNullOrUndefined(data.error, 'error');
+        var errorInfo = data.logEntry ? data.logEntry.toString() : data.error;
+        this._log(data.source, errorInfo, data.eventName, true, data.resultCode, data.serviceScope);
+    };
+    /**
+     * Trace logging
+     * The idea here is that verbose logs don't get uploaded to the server unless
+     * a failure is logged using ErrorHelper.log method.
+     * There is a circular buffer that holds last 50 verbose logs from all scenarios and
+     * it is only flushed and uploaded in case a failure is logged.
+     * That way whenever you get a failure event with message you also have all supportive verbose messages
+     * you logged throughout your scenario execution (or other scenarios).
+     * And hopefully that would help you get to the bottom of what exactly went wrong.
+     * If no failure happens and your scenario succeeds, verbose logs will be just left in the buffer
+     * and most likely overriden by next scenario that logs something verbose.
+     **/
+    TraceLogger.logVerbose = function (source, message, eventName) {
+        Validate.isNonemptyString(message, 'message');
+        this._log(source, message, eventName, false, undefined);
+    };
+    /**
+     * Verbose logging intended to replace to logVerbose.
+     * The idea here is that verbose logs don't get uploaded to the server unless
+     * a failure is logged using ErrorHelper.log method.
+     * There is a circular buffer that holds last 50 verbose logs from all scenarios and
+     * it is only flushed and uploaded in case a failure is logged.
+     * That way whenever you get a failure event with message you also have all supportive verbose messages
+     * you logged throughout your scenario execution (or other scenarios).
+     * And hopefully that would help you get to the bottom of what exactly went wrong.
+     * If no failure happens and your scenario succeeds, verbose logs will be just left in the buffer
+     * and most likely overridden by next scenario that logs something verbose.
+     */
+    TraceLogger.logVerboseData = function (data) {
+        var message = data.logEntry ? data.logEntry.toString() : data.message;
+        this._log(data.source, message, data.eventName, false, undefined, data.serviceScope);
+    };
+    /**
+     * Exception logging With LogEntry
+     * error message should be packed into logProperties
+     * LogType should be LogType.Error and LogProperties should have `{error:errorMessage}`
+     * Do NOT add PII data!
+     **/
+    TraceLogger.logErrorWithLogEntry = function (source, logEntry, eventName, resultCode) {
+        Validate.isNotNullOrUndefined(source, 'source');
+        Validate.isNotNullOrUndefined(logEntry, 'logEntry');
+        this._log(source, logEntry.toString(), eventName, true, resultCode);
+    };
+    Object.defineProperty(TraceLogger, "shouldWriteToConsole", {
+        /**
+         * Indicates if the log entries should be output to the console.
+         * This flag is set to true by default.
+         */
+        get: function () {
+            return TraceLogger._shouldWriteToConsole;
+        },
+        /**
+         * Toggles console output functionality.
+         * Property can be chaged by remote caller.
+         */
+        set: function (shouldWrite) {
+            if (TraceLogger._shouldWriteToConsole && !shouldWrite) {
+                TraceLogger._logManager.removeHandler(TraceLogger._defaultLogger.log);
+                TraceLogger._verboseLogManager.removeHandler(TraceLogger._defaultLogger.verbose);
+            }
+            else if (!TraceLogger._shouldWriteToConsole && shouldWrite) {
+                TraceLogger._logManager.addHandler(TraceLogger._defaultLogger.log);
+                TraceLogger._verboseLogManager.addHandler(TraceLogger._defaultLogger.verbose);
+            }
+            TraceLogger._shouldWriteToConsole = shouldWrite;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /*
+     * Trace logging with `LogEntry`
+     * The same with above other than wrapped log into `logEntry`
+     * Trace message should be packed into `logProperties`
+     * `LogType` should be `LogType.Trace` and LogProperties should have something like `{errors:errorMessage}`
+     * Do NOT add PII data!
+     **/
+    TraceLogger.logVerboseWithLogEntry = function (source, logEntry, eventName) {
+        Validate.isNotNullOrUndefined(logEntry, 'LogEntry');
+        this._log(source, logEntry.toString(), eventName, false, undefined);
+    };
+    TraceLogger._log = function (source, data, eventName, isError, resultCode, serviceScope) {
+        var enhancedEventName = this._addEventPrefix(source, eventName);
+        var logEvent;
+        if (isError) {
+            logEvent = LogEvent.log(enhancedEventName, data, LogLevel.Error, serviceScope);
+            TraceLogger._logManager.log({ data: data, eventName: logEvent.prefix, resultCode: resultCode });
+        }
+        else {
+            logEvent = LogEvent.log(enhancedEventName, data.toString(), LogLevel.Verbose, serviceScope);
+            TraceLogger._verboseLogManager.log({ data: data, eventName: logEvent.prefix });
+        }
+        if (TraceLogger.shouldWriteToConsole || (DEBUG && !DEPRECATED_UNIT_TEST)) {
+            this._writeToConsole(logEvent, isError, resultCode);
+        }
+    };
+    /*
+     * EventName is:
+     * sourceId.eventName or sourceId if eventName is not provided.
+     */
+    TraceLogger._addEventPrefix = function (source, eventName) {
+        if (!eventName) {
+            return source.id;
+        }
+        else {
+            return "".concat(source.id, ".").concat(eventName);
+        }
+    };
+    /*
+     * The log message in console is:
+     * `[eventName]: data`.
+     */
+    TraceLogger._writeToConsole = function (logEvent, isError, resultCode) {
+        // @todo (SPPPLAT VSO#250083): This date should be a part of the logEvent.
+        var errorString = logEvent.toString();
+        if (resultCode) {
+            errorString += ". resultCode: ".concat(resultCode);
+        }
+        // Task 191596: only write to console when a condition is satisfied (e.g., a query parameter provided).
+        if (isError) {
+            // eslint-disable-next-line no-console
+            console.error(errorString);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.log(errorString);
+        }
+    };
+    /**
+     * Allows process trace log events.
+     */
+    TraceLogger._logManager = new LogManager();
+    /**
+     * Allows process verbose trace log events.
+     */
+    TraceLogger._verboseLogManager = new LogManager();
+    TraceLogger._defaultLogger = new DefaultTraceHandler();
+    TraceLogger._shouldWriteToConsole = false;
+    return TraceLogger;
+}());
+export default TraceLogger;
+//# sourceMappingURL=TraceLogger.js.map