@vscode/telemetry-extractor 1.9.5

package/src/lib/file-writer.ts

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * @param {string} outputFile 
+ * @param {string} contents 
+ * @returns {Promise}
+ */
+export async function writeFile(outputFile: string, contents: string) {
+    const directory = path.dirname(outputFile);
+    return mkdirp(directory).then((dir: string) => {
+        return new Promise<void>((resolve, reject) => {
+            fs.writeFile(outputFile, contents, { encoding: 'utf8' }, (err: any) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve();
+                }
+            })
+        });
+    });
+}
+
+// copied from https://github.com/Microsoft/vscode/blob/master/src/main.js#L139
+async function mkdirp(dir: string): Promise<any> {
+    return mkdir(dir)
+        .then(null, function (err: any) {
+            if (err && err.code === 'ENOENT') {
+                var parent = path.dirname(dir);
+                if (parent !== dir) { // if not arrived at root
+                    return mkdirp(parent)
+                        .then(function () {
+                            return mkdir(dir);
+                        });
+                }
+            }
+            throw err;
+        });
+}
+
+// copied from https://github.com/Microsoft/vscode/blob/master/src/main.js#L155
+async function mkdir(dir: string): Promise<any> {
+    return new Promise(function (resolve, reject) {
+        fs.mkdir(dir, function (err: any) {
+            if (err && err.code !== 'EEXIST') {
+                reject(err);
+            } else {
+                resolve(dir);
+            }
+        });
+    });
+}

package/src/lib/fragments.ts

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { ITelemetryData, ITelemetryDataPoint, IProperty, IWildcard } from './telemetry-interfaces';
+import { Property } from './common-properties';
+import { Include, Inline } from './events';
+
+
+// Fragments are retrieved as an object of objects of objects. So this just makes it easier to see the structure.
+export class Fragments implements ITelemetryData{
+    public dataPoints: Array<Fragment>;
+    constructor () {
+        this.dataPoints = [];
+    }
+}
+
+export class Fragment implements ITelemetryDataPoint {
+    public name: string;
+    public properties: Array<Property | Include |  Inline | IWildcard>;
+    constructor (name: string) {
+        this.name = name;
+        this.properties = [];
+
+    }
+}

package/src/lib/keywords.ts

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+export const wildcard = '${wildcard}';
+export const inline = '${inline}';
+export const include = '${include}';
+export const prefix = '${prefix}';
+export const classification = '${classification}';

package/src/lib/logger.ts

@@ -0,0 +1,5 @@
+export function logMessage(msg: string, silenceOutput = false) {
+    if (!silenceOutput) {
+        console.log(msg);
+    }
+}

package/src/lib/object-converter.ts

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { OutputtedDeclarations } from "./declarations";
+import { Property } from "./common-properties";
+import { Wildcard } from "./events";
+import * as keywords from './keywords';
+
+// Converts the declarations array to an object format for easy readability.
+
+export async function transformOutput(output: OutputtedDeclarations): Promise<OutputtedDeclarations> {
+    const newEvents = Object.create(null);
+    const oldEvents = output.events.dataPoints;
+    for (const event of oldEvents) {
+        newEvents[event.name] = Object.create(null);
+        //We know there won't be anymore includes or inlines because we have resolved them
+        for (const property of event.properties as Array<Property | Wildcard>) {
+            if (property instanceof Wildcard) {
+                newEvents[event.name][keywords.wildcard] = newEvents[event.name][keywords.wildcard] ? newEvents[event.name][keywords.wildcard] : [];
+                for (const entry of property.entries) {
+                    const found = newEvents[event.name][keywords.wildcard].find((e: any) => {
+                        return e[keywords.prefix] === entry.prefix.toLowerCase();
+                    });
+                    if (found) continue;
+                    const newEntry = Object.create(null);
+                    newEntry[keywords.prefix] = entry.prefix.toLowerCase();
+                    if (entry.endpoint) {
+                        newEntry[keywords.classification] = { classification: entry.classification.classification, purpose: entry.classification.purpose, endPoint: "none" };
+                    } else {
+                        newEntry[keywords.classification] = entry.classification;
+                    }
+                    newEvents[event.name][keywords.wildcard].push(newEntry);
+                }
+            } else {
+                // Handles the case where the comments can be inconsistent
+                // We want to ensure that if isMeasurement is ever flagged it gets propogated
+                if (newEvents[event.name][propetyNameChanger(property.name)]) {
+                    if (property.isMeasurement) newEvents[event.name][propetyNameChanger(property.name)]['isMeasurement'] = property.isMeasurement;
+                    continue;
+                }
+                newEvents[event.name][propetyNameChanger(property.name)] = { classification: property.classification, purpose: property.purpose };
+                if (property.expiration) {
+                    newEvents[event.name][propetyNameChanger(property.name)]['expiration'] = property.expiration;
+                }
+                if (property.owner) {
+                    newEvents[event.name][propetyNameChanger(property.name)]['owner'] = property.owner;
+                }
+                if (property.comment) {
+                    newEvents[event.name][propetyNameChanger(property.name)]['comment'] = property.comment;
+                }
+                if (property.endPoint) {
+                    newEvents[event.name][propetyNameChanger(property.name)]['endPoint'] = property.endPoint;
+                }
+                if (property.isMeasurement) {
+                    newEvents[event.name][propetyNameChanger(property.name)]['isMeasurement'] = property.isMeasurement;
+                }
+            }
+        }
+    }
+    const newCommonProperties = Object.create(null);
+    const oldCommonProperties = output.commonProperties.properties;
+    for (const property of oldCommonProperties) {
+        // Handles the case where the comments can be incosistent
+        // We want to ensure that if isMeasurement is ever flagged it gets propogated
+        if (newCommonProperties[propetyNameChanger(property.name)]) {
+            if (property.isMeasurement) newCommonProperties[propetyNameChanger(property.name)]['isMeasurement'] = property.isMeasurement;
+            continue;
+        }
+        newCommonProperties[propetyNameChanger(property.name)] = { classification: property.classification, purpose: property.purpose };
+        if (property.endPoint) {
+            newCommonProperties[propetyNameChanger(property.name)]['endPoint'] = property.endPoint;
+        }
+        if (property.isMeasurement) {
+            newCommonProperties[propetyNameChanger(property.name)]['isMeasurement'] = property.isMeasurement;
+        }
+    }
+    return { events: newEvents, commonProperties: newCommonProperties };
+}
+
+function propetyNameChanger(name: string) {
+    name = name.toLowerCase();
+    if (name.includes('<number>')) {
+        name = name.replace('<number>', '<NUMBER>');
+    }
+    return name;
+}

package/src/lib/operations.ts

@@ -0,0 +1,89 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { Fragments, Fragment } from "./fragments";
+import { Events, Event, Include, Inline, Wildcard, WildcardEntry } from "./events";
+import { Property } from "./common-properties";
+import * as keywords from './keywords';
+
+export function merge(target: Fragments | Events, source: Fragments | Events) {
+    for (const item of source.dataPoints) {
+        const found = target.dataPoints.find((f) => {
+            return f.name == item.name;
+        });
+        // We combine their properties together if the event already exists
+        if (found) {
+            found.properties = found.properties.concat(item.properties);
+        } else {
+            target.dataPoints.push(item);
+        }
+    }
+}
+
+// Searches the object for an event or fragment of the specific name 
+// If found returns, if not found creates it, places it in the array, and then returns
+export function findOrCreate(searchTarget: Events | Fragments, name: string) {
+    let found = searchTarget.dataPoints.find((item) => {
+        return item.name === name;
+    });
+    if (!found) {
+        if (searchTarget instanceof Events) {
+            found = new Event(name);
+        } else {
+            found = new Fragment(name);
+        }
+    }
+    searchTarget.dataPoints.push(found);
+    return found;
+}
+
+export function mergeWildcards(wildcard: any[], target: Event | Fragment, applyEndpoints: boolean) {
+    let wildCard = target.properties.find((item) => {
+        return item instanceof Wildcard;
+    }) as Wildcard;
+    // if we don't have a wildcard yet we make one
+    if (!wildCard) {
+        wildCard = new Wildcard();
+        target.properties.push(wildCard);
+    }
+    wildcard.forEach(w => {
+        if (applyEndpoints) {
+            wildCard.entries.push(new WildcardEntry(w[keywords.prefix], w[keywords.classification], 'none'));
+        } else {
+            wildCard.entries.push(new WildcardEntry(w[keywords.prefix], w[keywords.classification]));
+        }
+    });
+}
+
+export function populateProperties(properties: any, target: Event | Fragment, applyEndpoints = false) {
+    for (const propertyName in properties) {
+        const currentProperty = properties[propertyName];
+        if (propertyName === keywords.include) {
+            target.properties.push(new Include(currentProperty));
+        } else if (currentProperty[keywords.inline]) {
+            // We consider the property name the inline name so when we resolve we can do prop.Inline for the new properties
+            target.properties.push(new Inline(propertyName, currentProperty[keywords.inline]));
+        } else if (propertyName === keywords.wildcard) {
+            mergeWildcards(currentProperty, target, applyEndpoints);
+        } else {
+            const prop = new Property(propertyName, currentProperty.classification, currentProperty.purpose, currentProperty.expiration, currentProperty.owner, currentProperty.comment);
+            if (applyEndpoints) {
+                const endpoint = currentProperty.endpoint ? currentProperty.endpoint : 'none';
+                prop.endPoint = endpoint;
+            }
+            if (currentProperty.isMeasurement) {
+                prop.isMeasurement = currentProperty.isMeasurement;
+            }
+            target.properties.push(prop);
+        }
+    }
+}
+
+export function makeExclusionsRelativeToSource(sourceDir: string, excludedDirs: string[]) {
+    const relativeExclusions = [];
+    for (const excluded of excludedDirs) {
+        if (excluded.includes(sourceDir)) {
+            relativeExclusions.push(excluded.replace(sourceDir, ''));
+        }
+    }
+    return relativeExclusions;
+}

package/src/lib/parser.ts

@@ -0,0 +1,184 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { rgPath } from 'vscode-ripgrep';
+import * as path from 'path';
+import * as cp from 'child_process';
+import * as fs from 'fs';
+import { Fragments } from './fragments';
+import { Property, CommonProperties } from './common-properties';
+import { Events } from './events';
+import { Declarations } from './declarations';
+import { merge, findOrCreate, populateProperties, makeExclusionsRelativeToSource } from './operations';
+
+export class Parser {
+
+    private sourceDirs: string[];
+    private excludedDirs: string[];
+    private applyEndpoints: boolean;
+
+    private lowerCaseEvents: boolean;
+
+    constructor(sourceDirs: string[], excludedDirs: string[], applyEndpoints: boolean, lowerCaseEvents: boolean) {
+        this.sourceDirs = sourceDirs;
+        this.excludedDirs = excludedDirs;
+        this.applyEndpoints = applyEndpoints;
+        this.lowerCaseEvents = lowerCaseEvents;
+    }
+
+    private toRipGrepOption(dir: string) {
+        while (dir.startsWith('/')) {
+            dir = dir.substr(1);
+        }
+        return `--glob "!${dir}/**" `;
+    }
+
+    private extractComments(absoluteFilePaths: string[], commentMatcher: RegExp, collector: Function) {
+        absoluteFilePaths.forEach(absoluteFilePath => {
+            if (absoluteFilePath) {
+                const fileContents = fs.readFileSync(absoluteFilePath);
+                let match;
+                while (match = commentMatcher.exec(fileContents.toString())) {
+                    collector(absoluteFilePath, match);
+                }
+            }
+        });
+
+    }
+
+    // Converts relative paths to absolute utilizing the CWD
+    private asAbsoluteFilePaths(relativeFilePaths: string[]) {
+        return relativeFilePaths.map(r => path.resolve(r));
+    }
+
+    // Finds all files containing common telemetry properties in the given directory
+    private findFilesWithCommonProperties(sourceDir: string) {
+        const ripgrepPattern = '//\\s*__GDPR__COMMON__';
+        return this.findFiles(ripgrepPattern, sourceDir);
+    }
+
+    private findCommonProperties(sourceDir: string) {
+        const filesWithCommonProperties = this.asAbsoluteFilePaths(this.findFilesWithCommonProperties(sourceDir));
+
+        const commonPropertyMatcher = /\/\/\s*__GDPR__COMMON__(.*)$/mg;
+        const commonPropertyDeclarations = new CommonProperties();
+        this.extractComments(filesWithCommonProperties, commonPropertyMatcher, (filePath: string, match: Array<string>) => {
+            try {
+                const commonPropertyDeclaration = JSON.parse(`{ ${match[1]} }`);
+                const propertyName = Object.keys(commonPropertyDeclaration)[0];
+                const properties = commonPropertyDeclaration[propertyName];
+                // Add all the common properties to the common property object
+                const prop = new Property(propertyName, properties.classification, properties.purpose);
+                if (this.applyEndpoints) {
+                    const endpoint = properties.endPoint ? properties.endPoint : 'none';
+                    prop.endPoint = endpoint;
+                }
+                if (properties.isMeasurement) {
+                    prop.isMeasurement = properties.isMeasurement;
+                }
+                commonPropertyDeclarations.properties.push(prop);
+            } catch (error) {
+                console.error(`Common Property Declaration Error: ${error} in file ${filePath}`);
+                console.error(`Source comment:\n${match[0]}`);
+            }
+        });
+        return commonPropertyDeclarations;
+    }
+
+    // Finds all files containing event fragments in the given directory
+    private findFilesWithFragments(sourceDir: string) {
+        const ripgrepPattern = '/\*\\s*__GDPR__FRAGMENT__';
+        return this.findFiles(ripgrepPattern, sourceDir);
+    }
+
+    /// 
+    private findFragments(sourceDir: string) {
+        const filesWithFragments = this.asAbsoluteFilePaths(this.findFilesWithFragments(sourceDir));
+
+        // Using [\s\S]* instead of .* since the latter does not match when using /m option
+        const fragmentMatcher = /\/\*\s*__GDPR__FRAGMENT__([\s\S]*?)\*\//mg;
+        const fragmentDeclarations = new Fragments();
+        this.extractComments(filesWithFragments, fragmentMatcher, (filePath: string, match: Array<string>) => {
+            try {
+                const fragmentDeclaration = JSON.parse(`{ ${match[1]} }`);
+                // There's only ever one key per match
+                const fragmentName = Object.keys(fragmentDeclaration)[0];
+                // Checks to see if we have a fragment of the given name, else creates.
+                const fragment = findOrCreate(fragmentDeclarations, fragmentName);
+                const fragmentProperties = fragmentDeclaration[fragmentName];
+                populateProperties(fragmentProperties, fragment, this.applyEndpoints);
+            } catch (error) {
+                console.error(`Fragment Declaration Error: ${error} in file ${filePath}`);
+                console.error(`Source comment:\n${match[0]}`);
+            }
+        });
+        return fragmentDeclarations;
+    }
+
+    // Find all files with complete events
+    private findFilesWithEvents(sourceDir: string) {
+        const ripgrepPattern = '/\*\\s*__GDPR__\\b';
+        return this.findFiles(ripgrepPattern, sourceDir);
+    }
+
+    private findEvents(sourceDir: string) {
+        const filesWithEvents = this.asAbsoluteFilePaths(this.findFilesWithEvents(sourceDir));
+
+        // Using [\s\S]* instead of .* since the latter does not match when using /m option
+        const eventMatcher = /\/\*\s*__GDPR__\b([\s\S]*?)\*\//mg;
+        const eventDeclarations = new Events();
+        this.extractComments(filesWithEvents, eventMatcher, (filePath: string, match: Array<string>) => {
+            try {
+                const eventDeclaration = JSON.parse(`{ ${match[1]} }`);
+                let eventName = Object.keys(eventDeclaration)[0];
+                eventName = this.lowerCaseEvents ? eventName.toLowerCase() : eventName;
+                const event = findOrCreate(eventDeclarations, eventName);
+                // Get the propeties which the event possesses
+                const eventProperties = eventDeclaration[Object.keys(eventDeclaration)[0]];
+                populateProperties(eventProperties, event, this.applyEndpoints);
+            } catch (error) {
+                console.error(`Event Declaration Error: ${error} in file ${filePath}`);
+                console.error(`Source comment:\n${match[0]}`);
+            }
+        });
+        return eventDeclarations;
+    }
+
+    // Utilizes a regex to find the files containing the specific pattern
+    private findFiles(ripgrepPattern: string, sourceDir: string) {
+        const relativeExclusions = makeExclusionsRelativeToSource(sourceDir, this.excludedDirs);
+        const exclusions = relativeExclusions.length === 0 || relativeExclusions[0] === '' ? '' : relativeExclusions.map(this.toRipGrepOption).join('');
+        const cmd = `${rgPath} --files-with-matches --glob "*.ts" ${exclusions} --regexp "${ripgrepPattern}" -- ${sourceDir}`;
+        try {
+            let filePaths = cp.execSync(cmd, { encoding: 'ascii', cwd: `${sourceDir}` });
+            return filePaths.split(/(?:\r\n|\r|\n)/g).filter(path => path && path.length > 0);
+        } catch (err) {
+            // ripgrep's return code != 0 if there are no matches
+            return [];
+        }
+    }
+
+    private async parse(sourceDir: string): Promise<Declarations> {
+        const fragments = this.findFragments(sourceDir);
+        const events = this.findEvents(sourceDir);
+        const commonProperties = this.findCommonProperties(sourceDir);
+        return { fragments: fragments, events: events, commonProperties: commonProperties };
+    }
+
+    public extractDeclarations(): Promise<Declarations> {
+        return new Promise((resolve, reject) => {
+            // Find all the properties for all files
+            const promises = this.sourceDirs.map(sd => this.parse(sd));
+            // Now we must merge them into one superset of all declarations
+            Promise.all(promises).then(parseResult => {
+                const declarations = { fragments: new Fragments(), events: new Events(), commonProperties: new CommonProperties() };
+                for (const currentResult of parseResult) {
+                    merge(declarations.fragments, currentResult.fragments);
+                    merge(declarations.events, currentResult.events);
+                    // We just concatenate common properties
+                    declarations.commonProperties.properties = declarations.commonProperties.properties.concat(currentResult.commonProperties.properties);
+                }
+                return resolve(declarations);
+            });
+        });
+    }
+}

package/src/lib/save-declarations.ts

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import * as path from 'path';
+import { Parser } from './parser';
+import * as fileWriter from './file-writer';
+import { resolveDeclarations, OutputtedDeclarations } from './declarations';
+import { transformOutput } from './object-converter';
+import { Events } from './events';
+import { CommonProperties } from './common-properties';
+import { TsParser } from './ts-parser';
+import { patchDebugEvents } from './debug-patch';
+import { ParserOptions, SourceSpec } from './source-spec';
+import { logMessage } from './logger';
+
+export function writeToFile(outputDir: string, contents: object, fileName: string, emitProgressMessage: boolean) {
+    const json = JSON.stringify(contents);
+    const outputFile = path.resolve(outputDir, `${fileName}.json`);
+    logMessage(`...writing ${outputFile}`, !emitProgressMessage);
+    return fileWriter.writeFile(outputFile, json);
+}
+
+export async function getResolvedDeclaration(sourceDirs: Array<string>, excludedDirs: Array<string>, options: ParserOptions) {
+    logMessage('...extracting', options.silenceOutput);
+    const parser = new Parser(sourceDirs, excludedDirs, options.applyEndpoints, options.lowerCaseEvents);
+    let declarations = await parser.extractDeclarations();
+    declarations = resolveDeclarations(declarations, options.verbose);
+    return declarations;
+}
+
+export async function extractAndResolveDeclarations(sourceSpecs: Array<SourceSpec>): Promise<{ events: any, commonProperties: any }> {
+    try {
+        const allDeclarations: OutputtedDeclarations = { events: new Events(), commonProperties: new CommonProperties() };
+        const allTypeScriptDeclarations = Object.create(null);
+        for (const spec of sourceSpecs) {
+            const declarations = await getResolvedDeclaration(spec.sourceDirs, spec.excludedDirs, spec.parserOptions);
+            let typescriptDeclarations = Object.create(null);
+            // The parser does not know how to handle multiple source directories due to different TS configs, so we manually have to parse each source dir
+            spec.sourceDirs.forEach((dir) => {
+                Object.assign(typescriptDeclarations, new TsParser(dir, spec.excludedDirs, spec.parserOptions.applyEndpoints, spec.parserOptions.lowerCaseEvents).parseFiles());
+            });
+            if (spec.parserOptions.eventPrefix !== '') {
+                declarations.events.dataPoints = declarations.events.dataPoints.map((event) => {
+                    event.name = spec.parserOptions.eventPrefix + event.name;
+                    return event;
+                });
+                const modifiedDeclartions = Object.create(null);
+                // Modify the object keys to be prefixed with the specified prefix
+                for (const key in typescriptDeclarations) {
+                    modifiedDeclartions[spec.parserOptions.eventPrefix + key] = typescriptDeclarations[key];
+                }
+                typescriptDeclarations = modifiedDeclartions;
+            }
+            if (spec.parserOptions.patchDebugEvents) {
+                patchDebugEvents(declarations.events, spec.parserOptions.eventPrefix);
+            }
+            // We concatenate each extensions properties into a central one
+            // Throwing out fragments as they have already been used to resolve that extensions declarations
+            allDeclarations.commonProperties.properties = allDeclarations.commonProperties.properties.concat(declarations.commonProperties.properties);
+            allDeclarations.events.dataPoints = allDeclarations.events.dataPoints.concat(declarations.events.dataPoints);
+            Object.assign(allTypeScriptDeclarations, typescriptDeclarations);
+        }
+        const formattedDeclarations: any = await transformOutput(allDeclarations);
+        for (const dec in allTypeScriptDeclarations) {
+            formattedDeclarations.events[dec] = allTypeScriptDeclarations[dec];
+        }
+        return Promise.resolve(formattedDeclarations);
+    } catch (error) {
+        console.error(`Error: ${error}`);
+        return Promise.reject(error);
+    }
+}

package/src/lib/source-spec.ts

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { PathLike, readFileSync } from 'fs';
+import * as path from 'path';
+import { cwd } from 'process';
+
+
+export interface ParserOptions {
+    eventPrefix: string;
+    applyEndpoints: boolean;
+    patchDebugEvents: boolean;
+    lowerCaseEvents: boolean;
+    silenceOutput: boolean;
+    verbose: boolean;
+}
+
+export interface SourceSpec {
+    sourceDirs: string[],
+    excludedDirs: string[],
+    parserOptions: ParserOptions
+};
+
+export function convertConfigToSourceSpecs(file: PathLike): SourceSpec[] {
+    try {
+        const config = JSON.parse(readFileSync(file).toString());
+        const sourceSpecs: SourceSpec[] = [];
+        for (const key in config) {
+            const spec = config[key];
+            // Some defaults
+            spec.excludedDirs = spec.excludedDirs ? spec.excludedDirs : [];
+            spec.workingDir = spec.workingDir ? spec.workingDir : cwd();
+            spec.patchDebugEvents = spec.patchDebugEvents ? spec.patchDebugEvents : false;
+            spec.lowerCaseEvents = spec.lowerCaseEvents ? spec.lowerCaseEvents : false;
+            const parserOptions: ParserOptions = {
+                eventPrefix: spec.eventPrefix ? spec.eventPrefix : '',
+                applyEndpoints: spec.applyEndpoints,
+                patchDebugEvents: spec.patchDebugEvents,
+                lowerCaseEvents: spec.lowerCaseEvents,
+                silenceOutput: spec.silenceOuput,
+                verbose: spec.verbose
+            }
+            const sourceSpec: SourceSpec = {
+                sourceDirs: resolveDirectories(spec.sourceDirs, spec.workingDir),
+                excludedDirs: resolveDirectories(spec.excludedDirs, spec.workingDir),
+                parserOptions: parserOptions
+            }
+            sourceSpecs.push(sourceSpec);
+        }
+        return sourceSpecs;
+    } catch (err) {
+        console.error(err);
+        return [];
+    }
+}
+
+// Resolves an array of paths
+function resolveDirectories(dirs: string[], workingDir?: string): string[] {
+    if (workingDir) {
+        if (path.isAbsolute(workingDir)) {
+            return dirs.map(s => path.resolve(workingDir, s));
+        } else {
+            return dirs.map(s => path.resolve(cwd(), workingDir, s));
+        }
+    } else {
+        return dirs.map(s => path.resolve(cwd(), s));
+    }
+}

package/src/lib/telemetry-interfaces.ts

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { Wildcard } from "./events";
+
+export interface ITelemetryData{
+    dataPoints: Array<ITelemetryDataPoint>
+}
+
+export interface ITelemetryDataPoint {
+    name: string;
+    properties: Array<IProperty | IInclude | IInline | Wildcard>;
+}
+
+export interface IProperty {
+    name: string;
+    purpose: string;
+    classification: string;
+    expiration?: string;
+    owner?: string;
+    comment?: string;
+}
+
+export interface IInclude {
+    includeNames: Array<string>;
+}
+
+export interface IInline {
+    inlineName: string;
+    inlines: Array<string>;
+}
+
+export interface IWildcard {
+    entries: Array<IWildcardEntry>;
+}
+
+export interface IWildcardEntry {
+    prefix: string;
+    classification: {classification: string, purpose: string};
+    endpoint: string | undefined;
+}