@sap-ux/telemetry 0.2.0

package/dist/base/decorator/index.d.ts

@@ -0,0 +1,23 @@
+import type { SampleRate } from '../types/sample-rate';
+import type { ParamRecordConfig } from '../utils/param-processing';
+/**
+ * Decorator used to log a telemetry event.
+ *
+ * @param evtName - Event names to filter data on backend, use EventNames predefined in Telemetry.EventName enumeration
+ * @param interceptorType - Interceptor type to apply to decorated function, use interceptorTypes predefined in Telemetry.interceptorTypes enumeration
+ * @param sampleRate - Sample rate for recorded data, use predefined sample rates in Telemetry.SampleRate enumeration
+ * @param paramsCapturingInstructions - Optional param, Should be passed when interceptor of type CAPTURE_PARAM being used. As single instance or array of instances (when multiple params should be captured or some additional sumbission data should be predefined). Allows predefine property name, value or specify paths to value to be captured (if it's element of array or nested in object)
+ * @returns function
+ */
+export declare const logTelemetry: (evtName: string, interceptorType: string, sampleRate: SampleRate, paramsCapturingInstructions: ParamRecordConfig | ParamRecordConfig[]) => Function;
+/**
+ * Decorator to log telemetry asynchronously.
+ *
+ * @param evtName - Event names to filter data on backend, use EventNames predefined in Telemetry.EventName enumeration
+ * @param interceptorType - Interceptor type to apply to decorated function, use interceptorTypes predefined in Telemetry.interceptorTypes enumeration
+ * @param sampleRate - Sample rate for recorded data, use predefined sample rates in Telemetry.SampleRate enumeration
+ * @param paramsCapturingInstructions - Optional param, Should be passed when interceptor of type CAPTURE_PARAM being used. As single instance or array of instances (when multiple params should be captured or some additional sumbission data should be predefined). Allows predefine property name, value or specify paths to value to be captured (if it's element of array or nested in object)
+ * @returns function
+ */
+export declare const logTelemetryAsync: (evtName: string, interceptorType: string, sampleRate: SampleRate, paramsCapturingInstructions: ParamRecordConfig | ParamRecordConfig[]) => Function;
+//# sourceMappingURL=index.d.ts.map

package/dist/base/decorator/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logTelemetryAsync = exports.logTelemetry = void 0;
+const config_1 = require("../interceptor/config");
+const decorCommon = (isAsync, target, descriptor, evtName, interceptorType, sampleRate, paramsCapturingInstructions) => {
+    const originalMethod = descriptor.value;
+    const interceptorTypesMap = isAsync ? config_1.asyncInterceptorTypesMapping : config_1.interceptorTypesMapping;
+    const interceptor = interceptorTypesMap.get(interceptorType);
+    descriptor.value = interceptor(target, originalMethod, evtName, sampleRate, paramsCapturingInstructions);
+};
+/**
+ * Decorator used to log a telemetry event.
+ *
+ * @param evtName - Event names to filter data on backend, use EventNames predefined in Telemetry.EventName enumeration
+ * @param interceptorType - Interceptor type to apply to decorated function, use interceptorTypes predefined in Telemetry.interceptorTypes enumeration
+ * @param sampleRate - Sample rate for recorded data, use predefined sample rates in Telemetry.SampleRate enumeration
+ * @param paramsCapturingInstructions - Optional param, Should be passed when interceptor of type CAPTURE_PARAM being used. As single instance or array of instances (when multiple params should be captured or some additional sumbission data should be predefined). Allows predefine property name, value or specify paths to value to be captured (if it's element of array or nested in object)
+ * @returns function
+ */
+const logTelemetry = (evtName, interceptorType, sampleRate, paramsCapturingInstructions) => {
+    return (target, functionName, descriptor) => {
+        decorCommon(false, target, descriptor, evtName, interceptorType, sampleRate, paramsCapturingInstructions);
+    };
+};
+exports.logTelemetry = logTelemetry;
+/**
+ * Decorator to log telemetry asynchronously.
+ *
+ * @param evtName - Event names to filter data on backend, use EventNames predefined in Telemetry.EventName enumeration
+ * @param interceptorType - Interceptor type to apply to decorated function, use interceptorTypes predefined in Telemetry.interceptorTypes enumeration
+ * @param sampleRate - Sample rate for recorded data, use predefined sample rates in Telemetry.SampleRate enumeration
+ * @param paramsCapturingInstructions - Optional param, Should be passed when interceptor of type CAPTURE_PARAM being used. As single instance or array of instances (when multiple params should be captured or some additional sumbission data should be predefined). Allows predefine property name, value or specify paths to value to be captured (if it's element of array or nested in object)
+ * @returns function
+ */
+const logTelemetryAsync = (evtName, interceptorType, sampleRate, paramsCapturingInstructions) => {
+    return (target, functionName, descriptor) => {
+        decorCommon(true, target, descriptor, evtName, interceptorType, sampleRate, paramsCapturingInstructions);
+    };
+};
+exports.logTelemetryAsync = logTelemetryAsync;
+//# sourceMappingURL=index.js.map

package/dist/base/interceptor/config.d.ts

@@ -0,0 +1,19 @@
+export declare enum InterceptorTypes {
+    /**
+     * Simple notification interceptor, reports certain event
+     * occurance and requires no data to be captured or measured.
+     */
+    NOTIFICATION = "notify",
+    /**
+     * Duration interceptor, measures and reports runtime of decorated method.
+     */
+    DURATION = "duration",
+    /**
+     * Captures specified in paramCaptureConfig parameter of decorated method.
+     */
+    CAPTURE_PARAM = "captureParam"
+}
+declare const interceptorTypesMapping: Map<any, any>;
+declare const asyncInterceptorTypesMapping: Map<any, any>;
+export { interceptorTypesMapping, asyncInterceptorTypesMapping };
+//# sourceMappingURL=config.d.ts.map

package/dist/base/interceptor/config.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncInterceptorTypesMapping = exports.interceptorTypesMapping = exports.InterceptorTypes = void 0;
+const interceptors = __importStar(require("./index"));
+var InterceptorTypes;
+(function (InterceptorTypes) {
+    /**
+     * Simple notification interceptor, reports certain event
+     * occurance and requires no data to be captured or measured.
+     */
+    InterceptorTypes["NOTIFICATION"] = "notify";
+    /**
+     * Duration interceptor, measures and reports runtime of decorated method.
+     */
+    InterceptorTypes["DURATION"] = "duration";
+    /**
+     * Captures specified in paramCaptureConfig parameter of decorated method.
+     */
+    InterceptorTypes["CAPTURE_PARAM"] = "captureParam";
+})(InterceptorTypes = exports.InterceptorTypes || (exports.InterceptorTypes = {}));
+const interceptorTypesMapping = new Map();
+exports.interceptorTypesMapping = interceptorTypesMapping;
+interceptorTypesMapping.set(InterceptorTypes.NOTIFICATION, interceptors.notify);
+interceptorTypesMapping.set(InterceptorTypes.DURATION, interceptors.duration);
+interceptorTypesMapping.set(InterceptorTypes.CAPTURE_PARAM, interceptors.captureParam);
+const asyncInterceptorTypesMapping = new Map();
+exports.asyncInterceptorTypesMapping = asyncInterceptorTypesMapping;
+asyncInterceptorTypesMapping.set(InterceptorTypes.NOTIFICATION, interceptors.notifyAsync);
+asyncInterceptorTypesMapping.set(InterceptorTypes.DURATION, interceptors.durationAsync);
+asyncInterceptorTypesMapping.set(InterceptorTypes.CAPTURE_PARAM, interceptors.captureParamAsync);
+//# sourceMappingURL=config.js.map

package/dist/base/interceptor/index.d.ts

@@ -0,0 +1,10 @@
+import type { EventName } from '../types/event-name';
+import type { SampleRate } from '../types/sample-rate';
+import type { ParamRecordConfig } from '../utils/param-processing';
+export declare const notify: (target: Record<string, object>, originalFn: Function, evtName: EventName, sampleRate: SampleRate) => Function;
+export declare const notifyAsync: (target: Record<string, object>, originalFn: Function, evtName: EventName, sampleRate: SampleRate) => Function;
+export declare const duration: (target: Record<string, object>, originalFn: Function, evtName: EventName, sampleRate: SampleRate) => Function;
+export declare const durationAsync: (target: Record<string, object>, originalFn: Function, evtName: EventName, sampleRate: SampleRate) => Function;
+export declare const captureParam: (target: Record<string, object>, originalFn: Function, evtName: EventName, sampleRate: SampleRate, instructions: ParamRecordConfig | ParamRecordConfig[]) => Function;
+export declare const captureParamAsync: (target: Record<string, object>, originalFn: Function, evtName: EventName, sampleRate: SampleRate, instructions: ParamRecordConfig | ParamRecordConfig[]) => Function;
+//# sourceMappingURL=index.d.ts.map

package/dist/base/interceptor/index.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureParamAsync = exports.captureParam = exports.durationAsync = exports.duration = exports.notifyAsync = exports.notify = void 0;
+const client_1 = require("../client");
+const api_1 = require("../performance/api");
+const param_processing_1 = require("../utils/param-processing");
+const notify = (target, originalFn, evtName, sampleRate) => {
+    return (...args) => {
+        const result = originalFn.apply(target, args);
+        const appinsightClient = client_1.ClientFactory.getTelemetryClient();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        appinsightClient.report(evtName, {}, {}, sampleRate);
+        return result;
+    };
+};
+exports.notify = notify;
+const notifyAsync = (target, originalFn, evtName, sampleRate) => {
+    return (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield originalFn.apply(target, args);
+        const appinsightClient = client_1.ClientFactory.getTelemetryClient();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        appinsightClient.report(evtName, {}, {}, sampleRate);
+        return result;
+    });
+};
+exports.notifyAsync = notifyAsync;
+const duration = (target, originalFn, evtName, sampleRate) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (...args) => {
+        const markName = api_1.PerformanceMeasurementAPI.startMark('mark');
+        const result = originalFn.apply(target, args);
+        api_1.PerformanceMeasurementAPI.endMark(markName);
+        api_1.PerformanceMeasurementAPI.measure(markName);
+        const duration = api_1.PerformanceMeasurementAPI.getMeasurementDuration(markName);
+        const appinsightClient = client_1.ClientFactory.getTelemetryClient();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        appinsightClient.report(evtName, {}, { ms: duration }, sampleRate);
+        return result;
+    };
+};
+exports.duration = duration;
+const durationAsync = (target, originalFn, evtName, sampleRate) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        const markName = api_1.PerformanceMeasurementAPI.startMark('mark');
+        const result = yield originalFn.apply(target, args);
+        api_1.PerformanceMeasurementAPI.endMark(markName);
+        api_1.PerformanceMeasurementAPI.measure(markName);
+        const duration = api_1.PerformanceMeasurementAPI.getMeasurementDuration(markName);
+        const appinsightClient = client_1.ClientFactory.getTelemetryClient();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        appinsightClient.report(evtName, {}, { ms: duration }, sampleRate);
+        return result;
+    });
+};
+exports.durationAsync = durationAsync;
+const captureParam = (target, originalFn, evtName, sampleRate, instructions) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (...args) => {
+        const result = originalFn.apply(target, args);
+        const [customDimensions, customMeasurements] = (0, param_processing_1.getParamsData)(args, instructions);
+        const appinsightClient = client_1.ClientFactory.getTelemetryClient();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        appinsightClient.report(evtName, customDimensions, customMeasurements, sampleRate);
+        return result;
+    };
+};
+exports.captureParam = captureParam;
+const captureParamAsync = (target, originalFn, evtName, sampleRate, instructions) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield originalFn.apply(target, args);
+        const [customDimensions, customMeasurements] = (0, param_processing_1.getParamsData)(args, instructions);
+        const appinsightClient = client_1.ClientFactory.getTelemetryClient();
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        appinsightClient.report(evtName, customDimensions, customMeasurements, sampleRate);
+        return result;
+    });
+};
+exports.captureParamAsync = captureParamAsync;
+//# sourceMappingURL=index.js.map

package/dist/base/performance/api.d.ts

@@ -0,0 +1,74 @@
+import type { EntriesArray } from './types';
+import { EntryType, PerformanceMeasurement } from './types';
+/**
+ *
+ */
+declare class PerformanceMeasurementAPI extends PerformanceMeasurement {
+    static initTiming: number;
+    private static now;
+    static entries: EntriesArray;
+    static initialize(): void;
+    /**
+     * Create a new Mark.
+     *
+     * @param name Name of mark
+     * @param type type of mark
+     * @param timing Timestamp when mark is created, measured in ms
+     */
+    private static mark;
+    /**
+     * Create a start mark of a measurement.
+     *
+     * @param name Name of start mark
+     * @returns Id to track a measurement
+     */
+    static startMark(name: string): string;
+    /**
+     * Set end mark of a measurement.
+     *
+     * @param name Name of end mark
+     */
+    static endMark(name: string): void;
+    /**
+     * Measure execution time lenght of a given mark name.
+     *
+     * @param markName Name of mark
+     */
+    static measure(markName: string): void;
+    /**
+     * @returns All entries
+     */
+    static getEntries(): EntriesArray;
+    /**
+     * Get Mark/Measurement by name.
+     *
+     * @param name Name of entry
+     * @returns array of marks/measurements
+     */
+    static getEntriesByName(name: string): EntriesArray;
+    /**
+     * Get Mark/Measurement by name and type.
+     *
+     * @param name Name of entry
+     * @param type EntryType
+     * @returns array of marks/measurements
+     */
+    static getEntriesByNameType(name: string, type: EntryType): EntriesArray;
+    /**
+     * Get Mark/Measurement by type.
+     *
+     * @param type EntryType
+     * @returns array of marks/measurements
+     */
+    static getEntriesByType(type: EntryType): EntriesArray;
+    /**
+     * Get duration of a measurement.
+     *
+     * @param name Name of a measurement
+     * @returns time length in ms
+     */
+    static getMeasurementDuration(name: string): number;
+    static clearEntries(): void;
+}
+export { PerformanceMeasurementAPI };
+//# sourceMappingURL=api.d.ts.map

package/dist/base/performance/api.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceMeasurementAPI = void 0;
+const entries_1 = require("./entries");
+const types_1 = require("./types");
+const performanceNow = require("performance-now");
+/**
+ *
+ */
+class PerformanceMeasurementAPI extends types_1.PerformanceMeasurement {
+    // reported time is relative to the time the current Node process has started (inferred from process.uptime())
+    static initialize() {
+        PerformanceMeasurementAPI.initTiming = PerformanceMeasurementAPI.now();
+    }
+    /**
+     * Create a new Mark.
+     *
+     * @param name Name of mark
+     * @param type type of mark
+     * @param timing Timestamp when mark is created, measured in ms
+     */
+    static mark(name, type, timing) {
+        const entry = new entries_1.Mark(name, type, timing);
+        PerformanceMeasurementAPI.entries.push(entry);
+    }
+    /**
+     * Create a start mark of a measurement.
+     *
+     * @param name Name of start mark
+     * @returns Id to track a measurement
+     */
+    static startMark(name) {
+        const timing = PerformanceMeasurementAPI.now();
+        const extendedName = name + timing;
+        PerformanceMeasurementAPI.mark(extendedName, types_1.EntryType.START_MARK, timing);
+        return extendedName;
+    }
+    /**
+     * Set end mark of a measurement.
+     *
+     * @param name Name of end mark
+     */
+    static endMark(name) {
+        const timing = PerformanceMeasurementAPI.now();
+        PerformanceMeasurementAPI.mark(name, types_1.EntryType.END_MARK, timing);
+    }
+    /**
+     * Measure execution time lenght of a given mark name.
+     *
+     * @param markName Name of mark
+     */
+    static measure(markName) {
+        const startMark = PerformanceMeasurementAPI.getEntriesByNameType(markName, types_1.EntryType.START_MARK).slice(-1)[0];
+        const endMark = PerformanceMeasurementAPI.getEntriesByNameType(markName, types_1.EntryType.END_MARK).slice(-1)[0];
+        if (!startMark && !endMark) {
+            throw new Error(`Failed to execute 'measure': mark '${markName}' doesn't exist.`);
+        }
+        else if (!startMark || !endMark) {
+            const errMarkType = startMark ? types_1.EntryType.END_MARK : types_1.EntryType.START_MARK;
+            throw new Error(`Failed to execute 'measure': mark '${markName}'of type '${errMarkType}' doesn't exist.`);
+        }
+        const startTime = startMark.getStartTime();
+        const endTime = endMark.getStartTime();
+        const duration = endTime - startTime;
+        const measurement = new entries_1.Measurement(`${markName}`, PerformanceMeasurementAPI.now(), duration);
+        PerformanceMeasurementAPI.entries.push(measurement);
+    }
+    /**
+     * @returns All entries
+     */
+    static getEntries() {
+        return PerformanceMeasurementAPI.entries;
+    }
+    /**
+     * Get Mark/Measurement by name.
+     *
+     * @param name Name of entry
+     * @returns array of marks/measurements
+     */
+    static getEntriesByName(name) {
+        return PerformanceMeasurementAPI.entries.filter((entry) => entry.name === name);
+    }
+    /**
+     * Get Mark/Measurement by name and type.
+     *
+     * @param name Name of entry
+     * @param type EntryType
+     * @returns array of marks/measurements
+     */
+    static getEntriesByNameType(name, type) {
+        return PerformanceMeasurementAPI.entries.filter((entry) => entry.name === name && entry.type === type);
+    }
+    /**
+     * Get Mark/Measurement by type.
+     *
+     * @param type EntryType
+     * @returns array of marks/measurements
+     */
+    static getEntriesByType(type) {
+        return PerformanceMeasurementAPI.entries.filter((entry) => entry.type === type);
+    }
+    /**
+     * Get duration of a measurement.
+     *
+     * @param name Name of a measurement
+     * @returns time length in ms
+     */
+    static getMeasurementDuration(name) {
+        const entry = PerformanceMeasurementAPI.getEntriesByNameType(name, types_1.EntryType.MEASUREMENT).slice(-1)[0];
+        return entry.getDurationTime();
+    }
+    static clearEntries() {
+        PerformanceMeasurementAPI.entries = [];
+    }
+}
+exports.PerformanceMeasurementAPI = PerformanceMeasurementAPI;
+PerformanceMeasurementAPI.now = performanceNow;
+PerformanceMeasurementAPI.entries = [];
+PerformanceMeasurementAPI.initialize();
+//# sourceMappingURL=api.js.map

package/dist/base/performance/entries.d.ts

@@ -0,0 +1,42 @@
+import type { Measurement as IMeasurement, Mark as IMark } from './types';
+import { EntryType } from './types';
+/**
+ * Repreeents a mark during a performance measurement.
+ */
+declare class Mark implements IMark {
+    readonly startTime: number;
+    [index: number]: string;
+    name: string;
+    type: EntryType;
+    /**
+     * @returns start time in millieseconds
+     */
+    getStartTime(): number;
+    /**
+     *
+     * @param name Name of mark
+     * @param type Mark type
+     * @param startTime start time in millieseconds
+     */
+    constructor(name: string, type: EntryType, startTime: number);
+}
+/**
+ * Measurement of execution time length
+ */
+declare class Measurement extends Mark implements IMeasurement {
+    readonly startTime: number;
+    readonly duration: number;
+    /**
+     *
+     * @param name Name of a mark
+     * @param startTime start time in millieseconds
+     * @param duration time in millieseconds
+     */
+    constructor(name: string, startTime: number, duration: number);
+    /**
+     * @returns duration in milliseconds
+     */
+    getDurationTime(): number;
+}
+export { Mark, Measurement };
+//# sourceMappingURL=entries.d.ts.map

package/dist/base/performance/entries.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Measurement = exports.Mark = void 0;
+const types_1 = require("./types");
+/**
+ * Repreeents a mark during a performance measurement.
+ */
+class Mark {
+    /**
+     * @returns start time in millieseconds
+     */
+    getStartTime() {
+        return this.startTime;
+    }
+    /**
+     *
+     * @param name Name of mark
+     * @param type Mark type
+     * @param startTime start time in millieseconds
+     */
+    constructor(name, type, startTime) {
+        this.startTime = startTime;
+        this.name = name;
+        this.startTime = startTime;
+        this.type = type;
+    }
+}
+exports.Mark = Mark;
+/**
+ * Measurement of execution time length
+ */
+class Measurement extends Mark {
+    /**
+     *
+     * @param name Name of a mark
+     * @param startTime start time in millieseconds
+     * @param duration time in millieseconds
+     */
+    constructor(name, startTime, duration) {
+        super(name, types_1.EntryType.MEASUREMENT, startTime);
+        this.startTime = startTime;
+        this.duration = duration;
+        this.duration = duration;
+    }
+    /**
+     * @returns duration in milliseconds
+     */
+    getDurationTime() {
+        return this.duration;
+    }
+}
+exports.Measurement = Measurement;
+//# sourceMappingURL=entries.js.map

package/dist/base/performance/types.d.ts

@@ -0,0 +1,35 @@
+declare enum EntryType {
+    START_MARK = "START_MARK",
+    END_MARK = "END_MARK",
+    MEASUREMENT = "MEASUREMENT"
+}
+interface Mark {
+    type: EntryType;
+    name: string;
+    startTime: number;
+    getStartTime: () => number;
+}
+interface Measurement extends Mark {
+    readonly duration: number;
+    getDurationTime: () => number;
+}
+type EntriesArray = (Mark | Measurement)[];
+/**
+ *
+ */
+declare abstract class PerformanceMeasurement {
+    static initTiming: number;
+    static enteries: EntriesArray;
+    static initialize: () => void;
+    static startMark: (name: string) => string;
+    static endMark: (name: string) => void;
+    static measure: (name: string) => void;
+    static getEntries: () => EntriesArray;
+    static getEntriesByName: (name: string) => EntriesArray;
+    static getEntriesByType: (type: EntryType) => EntriesArray;
+    static getEntriesByNameType: (name: string, type: EntryType) => EntriesArray;
+    static getMeasurementDuration: (name: string) => number;
+    static clearEntries: () => void;
+}
+export { EntryType, Mark, Measurement, EntriesArray, PerformanceMeasurement };
+//# sourceMappingURL=types.d.ts.map

package/dist/base/performance/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceMeasurement = exports.EntryType = void 0;
+var EntryType;
+(function (EntryType) {
+    EntryType["START_MARK"] = "START_MARK";
+    EntryType["END_MARK"] = "END_MARK";
+    EntryType["MEASUREMENT"] = "MEASUREMENT";
+})(EntryType || (EntryType = {}));
+exports.EntryType = EntryType;
+/**
+ *
+ */
+class PerformanceMeasurement {
+}
+exports.PerformanceMeasurement = PerformanceMeasurement;
+//# sourceMappingURL=types.js.map

package/dist/base/types/event-header.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Hierarchical event name for a telemetry event submitted to Auzre Application Insights.
+ */
+declare class EventHeader {
+    private extensionName;
+    private eventName;
+    /**
+     * Event header that is composed of two parts.
+     *
+     * @param extensionName Consumer module name
+     * @param eventName Telemetry event name
+     */
+    constructor(extensionName: string, eventName: string);
+    /**
+     * @returns Consumer module name
+     */
+    getExtensionName(): string;
+    /**
+     * @returns Event name
+     */
+    getEventName(): string;
+    /**
+     * @returns serialized string of event header
+     */
+    toString(): string;
+}
+export { EventHeader };
+//# sourceMappingURL=event-header.d.ts.map

package/dist/base/types/event-header.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventHeader = void 0;
+/**
+ * Hierarchical event name for a telemetry event submitted to Auzre Application Insights.
+ */
+class EventHeader {
+    /**
+     * Event header that is composed of two parts.
+     *
+     * @param extensionName Consumer module name
+     * @param eventName Telemetry event name
+     */
+    constructor(extensionName, eventName) {
+        this.extensionName = extensionName;
+        this.eventName = eventName;
+    }
+    /**
+     * @returns Consumer module name
+     */
+    getExtensionName() {
+        return this.extensionName;
+    }
+    /**
+     * @returns Event name
+     */
+    getEventName() {
+        return this.eventName;
+    }
+    /**
+     * @returns serialized string of event header
+     */
+    toString() {
+        return `${this.extensionName}/${this.eventName}`;
+    }
+}
+exports.EventHeader = EventHeader;
+//# sourceMappingURL=event-header.js.map

package/dist/base/types/event-name.d.ts

@@ -0,0 +1,6 @@
+export declare enum EventName {
+    Test = "test",
+    TELEMETRY_SETTINGS_INIT_FAILED = "TELEMETRY_SETTINGS_INIT_FAILED",
+    DISABLE_TELEMETRY = "DISABLE_TELEMETRY"
+}
+//# sourceMappingURL=event-name.d.ts.map