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

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

@@ -0,0 +1,64 @@
+import ExecutionQueue from '../ExecutionQueue';
+class QosLogger {
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new QosLogger();
+        }
+        return this._instance;
+    }
+    get shouldProcessInRealTime() {
+        return this._shouldProcessInRealTime;
+    }
+    set shouldProcessInRealTime(processInRealTime) {
+        this._shouldProcessInRealTime = processInRealTime;
+        this._deferExecutor.shouldExecuteInRealTime = processInRealTime;
+    }
+    setLogger(qosLogger) {
+        this._qosLogger = qosLogger;
+    }
+    getQosEvent(key) {
+        return this._qosEvents.get(key);
+    }
+    startQosMonitor(key, startData) {
+        if (!this._qosEvents.has(key)) {
+            this._deferExecutor.addExecutionEntry('start', key, startData);
+        }
+    }
+    writeQosEndResult(key, endData) {
+        this._deferExecutor.addExecutionEntry('end', key, endData);
+    }
+    _startMonitor(key, event) {
+        if (this._qosLogger) {
+            this._qosEvents.set(key, new this._qosLogger(event));
+        }
+    }
+    _endMonitor(key, event) {
+        const qosEvent = this._qosEvents.get(key);
+        if (qosEvent) {
+            qosEvent.end(event);
+            this._qosEvents.delete(key);
+        }
+    }
+    _initializeLogger() {
+        const startHandler = (key, e)=>{
+            this._startMonitor(key, e);
+        };
+        const endHandler = (key, e)=>{
+            this._endMonitor(key, e);
+        };
+        this._deferExecutor.addHandler('start', startHandler);
+        this._deferExecutor.addHandler('end', endHandler);
+    }
+    constructor(){
+        this._qosEvents = new Map();
+        this._deferExecutor = new ExecutionQueue();
+        this._shouldProcessInRealTime = false;
+        this._initializeLogger();
+    }
+}
+/**
+ * QosLogger allows multiple QosMonitors to be deferred processed.
+ * @internal
+ */ export { QosLogger as default };
+
+//# sourceMappingURL=./QosLogger.js.map

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

@@ -0,0 +1,258 @@
+import { _BrowserUtilities, _SPKillSwitch } from '@microsoft/sp-core-library';
+// Copyright (c) Microsoft. All rights reserved.
+import { Guid, Text, Validate } from '@microsoft/sp-core-library';
+import { getErrorMessage, getQosEndSchemaFromError, CustomError } from '@msinternal/odsp-core-bundle';
+import TraceLogger from '../Trace/TraceLogger';
+import { QosResultType } from './QosResultType';
+import QosLogger from './QosLogger';
+import EngagementLogger from '../Engagement/EngagementLogger';
+import Diagnostics from '../../Diagnostics';
+import DiagnosticsSettingsManager from '../../DiagnosticsSettingsManager';
+import { merge } from '@microsoft/sp-lodash-subset';
+const LOG_SOURCE = {
+    id: 'QosMonitor'
+};
+const QOS_MONISTOR_HAS_ENDED_ERROR_STRING = "QoS monitor '{0}' has ended with '{1}' already. Ignoring '{2}' tag.";
+const AUTHORING_SESSION_ID_KEY = 'AuthoringSessionId';
+const AUTHORING_OP_SEQUENCE_ID_KEY = 'AuthoringOpSequenceId';
+const AUTHORING_SESSION_CLIENT_COUNT = 'AuthoringSessionClientCount';
+class QosMonitor {
+    static startRealTimeProcessing() {
+        if (!QosLogger.instance.shouldProcessInRealTime) {
+            this._shouldProcessInRealTime(true);
+        }
+    }
+    /**
+   * Only used in unit tests
+   * @internal
+   */ static _shouldProcessInRealTime(processInRealTime) {
+        QosLogger.instance.shouldProcessInRealTime = processInRealTime;
+    }
+    get name() {
+        return this._scenarioName;
+    }
+    get shortEventName() {
+        return 'Qos';
+    }
+    get resultCode() {
+        return this._endResultCode;
+    }
+    get resultType() {
+        return this._endResult;
+    }
+    get extraData() {
+        return this._endExtraData;
+    }
+    set extraData(value) {
+        this._endExtraData = value;
+    }
+    get hasEnded() {
+        return this._hasEnded;
+    }
+    /**
+   * QoS monitor ends with success
+   * You will see success tag: SPPages.ScenarioName.Success
+   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    writeSuccess(extraData) {
+        this._writeQosEnd(QosResultType.Success, undefined, undefined, extraData);
+    }
+    /**
+   * QoS monitor ends with failure
+   * 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) {
+        this._writeQosEnd(QosResultType.Failure, tagNameSuffix, ex, extraData);
+    }
+    /*
+   * QoS monitor ends with expected failure
+   * 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) {
+        this._writeQosEnd(QosResultType.ExpectedFailure, tagNameSuffix, ex, extraData);
+    }
+    _writeQosEnd(resultType, tagNameSuffix, ex, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    extraData) {
+        if (this._shouldSkip(resultType)) {
+            return;
+        }
+        this._ensureCorrelationId(resultType, extraData);
+        this._endResultCode = tagNameSuffix;
+        this._endResult = resultType;
+        const errorString = !ex ? undefined : getErrorMessage(ex);
+        if (ex instanceof CustomError) {
+            const endSchema = getQosEndSchemaFromError(ex);
+            if (endSchema) {
+                endSchema.resultType = this._endResult;
+                // Make sure the extraData from `endSchema` takes priority so that
+                // extra data like correlation id from the error object is logged
+                // instead of the generic extra data from `_endExtraData`.
+                endSchema.extraData = merge({}, this._endExtraData, endSchema.extraData);
+            }
+            QosLogger.instance.writeQosEndResult(this._id, endSchema);
+        } else {
+            const endData = {
+                resultCode: this._endResultCode,
+                resultType: this._endResult,
+                error: errorString,
+                extraData: this._endExtraData
+            };
+            QosLogger.instance.writeQosEndResult(this._id, endData);
+        }
+        this._writeToEngagement();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _ensureCorrelationId(resultType, extraData) {
+        if (extraData) {
+            this._ensureEndExtraData();
+            // Instead of slower ...[spread], copy over the incoming values manually
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            Object.keys(extraData).forEach((k)=>this._endExtraData[k] = extraData[k]);
+        }
+        if (DiagnosticsSettingsManager.isInitialized && resultType !== QosResultType.Success) {
+            const capitalKey = 'CorrelationId';
+            const lowerKey = 'correlationId';
+            const correlationId = this._endExtraData && (this._endExtraData[capitalKey] || this._endExtraData[lowerKey]) || DiagnosticsSettingsManager.settings.correlationId;
+            if (correlationId) {
+                if (!this._endExtraData) {
+                    this._endExtraData = {};
+                }
+                this._endExtraData[capitalKey] = correlationId;
+            }
+        }
+        this._logHostType();
+        this._ensureAuthoringSessionId();
+    }
+    _ensureEndExtraData() {
+        if (!this._endExtraData) {
+            this._endExtraData = {};
+        }
+    }
+    /**
+   * Logs the application hosted in Teams in combination with which Teams application it was hosted on.
+   * Viva1p-TeamsNative: Viva home app loaded through Teams Desktop application, not including mobile
+   * Viva1p-TeamsWeb: Viva home app loaded through Teams Web browser, not including mobile
+   * MEEBridge-TeamsNative: VivaConnections MEEBridge app loaded through Teams mobile client.
+   * ClassHome-TeamsNative: ClassHome app loaded through Teams Desktop application, not including mobile
+   * ClassHome-TeamsWeb: ClassHome app loaded through Teams Web browser, not including mobile
+   */ _logHostType() {
+        if (DiagnosticsSettingsManager.isInitialized) {
+            const appHostType = _BrowserUtilities.getTeamsAppType();
+            // Skip logging for default SPO path for now to limit quota impact
+            if (appHostType) {
+                this._ensureEndExtraData();
+                const hostKey = 'appHostType';
+                // Unlikely, but avoid overwriting matching key value
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                if (!this._endExtraData[hostKey]) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    this._endExtraData[hostKey] = appHostType;
+                }
+            }
+        }
+    }
+    _isDebugSession() {
+        try {
+            if (!_SPKillSwitch.isActivated('761ccb86-4fa0-4f56-a05b-477bcc09bd9f' /* '08/01/2024', 'finnnavin: Let QoSMonitor run in debug, uploading is blocked at SDK-level.' */ )) {
+                return false;
+            } else {
+                return !!_BrowserUtilities.safelyAccessSessionStorage('spfx-debug');
+            }
+        } catch  {
+            // KillSwitches throw exceptions when not initialized.
+            // Currently this only happens when spfx-debug is present, so telemetry isn't being logged by the handler, and we can return false.
+            return false;
+        }
+    }
+    _shouldSkip(result) {
+        if (this._hasEnded && this._endResult !== undefined) {
+            const message = Text.format(QOS_MONISTOR_HAS_ENDED_ERROR_STRING, this.name, this._qosResultTypeValue[this._endResult], this._qosResultTypeValue[result]);
+            if (this._endResult !== result) {
+                TraceLogger.logError(LOG_SOURCE, new Error(message));
+            }
+            if (DEBUG) {
+                TraceLogger.logVerbose(LOG_SOURCE, message, 'skipEnd');
+            }
+            return true;
+        } else {
+            this._hasEnded = true;
+            return this._isDebugSession();
+        }
+    }
+    _writeToEngagement() {
+        if (this._copyToInterana) {
+            EngagementLogger.log({
+                name: this.name,
+                isIntentional: !!(this.extraData || {}).isIntentional,
+                extraData: this.extraData || {}
+            });
+        }
+        if (this._copyToCosmos) {
+            // Engagement name requires certain format. Cannot just use QOS name.
+            // Record Qos name in extra data 'qosName'
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const engagementData = {
+                name: 'Spfx.Qos.ToEngagement',
+                extraData: this.extraData || {}
+            };
+            engagementData.extraData.qosName = this.name;
+            if (this.resultType) {
+                engagementData.extraData.qosResultType = this._qosResultTypeValue[this.resultType];
+            }
+            if (this.resultCode) {
+                engagementData.extraData.qosResultCode = this.resultCode;
+            }
+            EngagementLogger.log(engagementData);
+        }
+    }
+    /**
+   * Creates a QoS monitor (initializes it and logs the start event)
+   * @param scenarioName - Unique name of the QoS scenario
+   * You will see start tag: SPPages.ScenarioName.Start
+   * @param copyToCosmos - Indicate whether this data should be used as Engagement as well, and sent to COSMOS.
+   * @param copyToInterana - Indicate whether this data should be used as Engagement as well, and sent to Interana.
+   */ constructor(scenarioName, copyToCosmos = false, copyToInterana = false){
+        this._qosResultTypeValue = {
+            [QosResultType.Success]: 'Success',
+            [QosResultType.Failure]: 'Failure',
+            [QosResultType.ExpectedFailure]: 'ExpectedFailure'
+        };
+        this._ensureAuthoringSessionId = ()=>{
+            const authoringSessionId = DiagnosticsSettingsManager.settings?.extraDiagnosticInfo?.authoringSessionId;
+            if (authoringSessionId) {
+                this._ensureEndExtraData();
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                this._endExtraData[AUTHORING_SESSION_ID_KEY] = authoringSessionId;
+                const authoringOpSequenceId = DiagnosticsSettingsManager.settings?.extraDiagnosticInfo?.authoringOpSequenceId;
+                if (authoringOpSequenceId) {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    this._endExtraData[AUTHORING_OP_SEQUENCE_ID_KEY] = authoringOpSequenceId;
+                }
+                const authoringSessionClientCount = Diagnostics.getAuthoringSessionClientCountInfo();
+                if (authoringSessionClientCount && this._endExtraData) {
+                    this._endExtraData[AUTHORING_SESSION_CLIENT_COUNT] = authoringSessionClientCount;
+                }
+            }
+        };
+        Validate.isNonemptyString(scenarioName, 'scenarioName');
+        this._id = Guid.newGuid().toString();
+        if (!this._isDebugSession()) {
+            QosLogger.instance.startQosMonitor(this._id, {
+                name: scenarioName
+            });
+        }
+        this._scenarioName = scenarioName;
+        this._hasEnded = false;
+        this._copyToCosmos = copyToCosmos;
+        this._copyToInterana = copyToInterana;
+    }
+}
+/**
+ * Qos logger
+ * This class represents the Qos monitor APIs
+ *
+ * @internal
+ */ export { QosMonitor as default };
+
+//# sourceMappingURL=./QosMonitor.js.map

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

@@ -0,0 +1,89 @@
+import QosMonitor from './QosMonitor';
+import { QosResultType } from './QosResultType';
+import _Diagnostics from '../../Diagnostics';
+import { isAppendSuffixIfBrowserIsOfflineAtLoggingTimeKsActive } from '../../common/Killswitches';
+/**
+ * Monitor which handles failures for QosMonitor and also invokes Customer Promise Handlers to record failure
+ * @internal
+ */ export class QosMonitorShareFailureWithCP extends QosMonitor {
+    /**
+   * QoS monitor ends with failure and invokes the Customer Promise handlers
+   * to log a failure
+   * @internal
+   *
+   * 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, extraData);
+        this._logCustomerPromiseFailure(ex?.message || 'DefaultErrorMessage', tagNameSuffix, QosResultType.Failure, extraData);
+    }
+    /**
+   * QoS monitor ends with expected failure and invokes the Customer Promise handlers
+   * to log an expected failure
+   * @internal
+   *
+   * 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, skipLoggingCustomerPromiseFailure = false) {
+        super.writeExpectedFailure(tagNameSuffix, ex, extraData);
+        if (!skipLoggingCustomerPromiseFailure) {
+            this._logCustomerPromiseFailure(ex?.message || 'DefaultErrorMessage', tagNameSuffix, QosResultType.ExpectedFailure, extraData);
+        }
+    }
+    /**
+   * Invokes the registered Customer Promise Handlers by using the passed in serviceKey
+   * @param errorMessage - Information to indicate which scenario failed.
+   * @param errorScenario -Additional error details describing the failure from the module.
+   * @param resultType - ResultTypeEnum used to indicate expected or unexpected failure.
+   * @param extraData - Additional information to be logged, which might include pageType and/or errorStack
+   */ _logCustomerPromiseFailure(errorMessage, errorScenario, resultType = QosResultType.Failure, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    extraData) {
+        if (this._extraDataForCustomerPromise) {
+            this._extraDataForCustomerPromise.forEach((extraHandlerInfo)=>{
+                const { logFailure, veto } = extraHandlerInfo;
+                const errorModuleName = extraHandlerInfo.errorModuleName + getAuthoringSuffix() + (!isAppendSuffixIfBrowserIsOfflineAtLoggingTimeKsActive() ? getOfflineSuffix() : '');
+                const errorDetailsForCP = {
+                    errorCode: errorModuleName,
+                    errorScenario,
+                    errorMessage,
+                    resultType,
+                    pageType: extraData?.pageType,
+                    errorStack: extraData?.errorStack,
+                    veto
+                };
+                logFailure(errorDetailsForCP);
+            });
+        }
+    }
+    /**
+   * Creates a QoS monitor and also registers the Customer promise handlers to notify in case of failures
+   * @internal
+   *
+   * @param scenarioName  - Unique name of the QoS scenario
+   * @param copyToEngagement - indicate whether this data should be used as Engagement as well.
+   * @param extraDataForCustomerPromise - Holds extra information about Customer Promise handlers to invoke
+   * and error information where failures are logged
+   */ constructor(scenarioName, copyToEngagement = false, extraDataForCustomerPromise, copyToCosmos = false){
+        super(scenarioName, /* copyToCosmos */ copyToCosmos, /* copyToInterana */ copyToEngagement);
+        this._extraDataForCustomerPromise = extraDataForCustomerPromise;
+    }
+}
+function getAuthoringSuffix() {
+    const extraDiagnosticInfo = _Diagnostics._getExtraDiagnosticInfo();
+    if (!extraDiagnosticInfo || !extraDiagnosticInfo.hasAuthoringStarted) {
+        return '';
+    } else if (!extraDiagnosticInfo.authoringSessionClientCount) {
+        return extraDiagnosticInfo.isAuthoringUsingDDS ? ` in Legacy Authoring (DDS)` : ' in Legacy Authoring (no DDS)';
+    } else if (extraDiagnosticInfo.authoringSessionClientCount > 1) {
+        return ' with Multiple Users';
+    } else {
+        return '';
+    }
+}
+function getOfflineSuffix() {
+    return window.navigator.onLine ? '' : ' (offline)';
+}
+
+//# sourceMappingURL=./QosMonitorShareFailureWithCP.js.map

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

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

package/lib-esm/Api/Trace/DefaultTraceHandler.js

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

package/lib-esm/Api/Trace/ITraceHandler.js

@@ -0,0 +1,9 @@
+/**
+ * Trace logger log data interface
+ * @internal
+ */ /**
+ * ITraceLogEvent log data interface
+ * @internal
+ */ export { };
+
+//# sourceMappingURL=./ITraceHandler.js.map

package/lib-esm/Api/Trace/ITraceLogger.js

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

package/lib-esm/Api/Trace/LogEvent.js

@@ -0,0 +1,104 @@
+import { logSourceServiceKey } from '../LogSource';
+import LogManager from '../LogManager/LogManager';
+class LogEvent {
+    /**
+   * 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, data, level, serviceScope) {
+        const event = new LogEvent(source, data, level, serviceScope);
+        LogEvent.logManager.log(event);
+        return event;
+    }
+    toString() {
+        const timedPrefix = `[${this._timestamp}][${this._prefix}]`;
+        if (this._message) {
+            return `${timedPrefix} ${this._message}`;
+        } else if (this._error) {
+            return `${timedPrefix} ${this._error.toString()}`;
+        } else {
+            return timedPrefix;
+        }
+    }
+    get timestamp() {
+        return this._timestamp;
+    }
+    get level() {
+        return this._level;
+    }
+    get prefix() {
+        return this._prefix;
+    }
+    get scope() {
+        return this._scope;
+    }
+    get source() {
+        return this._source;
+    }
+    get message() {
+        return this._message;
+    }
+    get error() {
+        return this._error;
+    }
+    get _maxSourceLength() {
+        return 30;
+    }
+    get _maxMessageLength() {
+        return 150;
+    }
+    _validate(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');
+        }
+    }
+    _setData(data) {
+        if (typeof data === 'string') {
+            this._message = data.substr(0, this._maxMessageLength);
+        } else if (data instanceof Error) {
+            this._error = data;
+        }
+    }
+    _getPrefix() {
+        let prefix = `${this._source}`;
+        if (this._scope && !this._scope.isEmpty()) {
+            prefix = `${this._scope.id.substr(0, this._maxSourceLength)}.${prefix}`;
+        }
+        return `${prefix}`;
+    }
+    _getScope(serviceScope) {
+        let parentSource;
+        if (serviceScope) {
+            serviceScope.whenFinished(()=>{
+                parentSource = serviceScope.consume(logSourceServiceKey);
+            });
+        }
+        return parentSource;
+    }
+    /**
+   * Do not call this constructor directly. Use LogEvent.log instead.
+   */ constructor(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();
+    }
+}
+/**
+   * Allows process log events.
+   */ LogEvent.logManager = new LogManager();
+/**
+ * An object that represents one log event.
+ * @internal
+ */ export { LogEvent as default };
+
+//# sourceMappingURL=./LogEvent.js.map