@vscode/telemetry-extractor 1.9.5 → 1.9.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vscode/telemetry-extractor",
-  "version": "1.9.5",
+  "version": "1.9.8",
   "description": "Extracts telemetry from VS Code",
   "main": "out/index.js",
   "typings": "vscode-telemetry-extractor.d.ts",
@@ -11,7 +11,7 @@
   "scripts": {
     "test": "mocha out/tests/mocha/*.js",
     "coverage": "nyc mocha out/tests/mocha/*.js",
-    "extract-core": "node ./out/extractor.js --sourceDir src/telemetry-sources/vscode --excludedDir src/telemetry-sources/vscode/extensions --eventPrefix monacoworkbench/  --outputDir . --applyEndpoints",
+    "extract-core": "node ./out/extractor.js --sourceDir src/telemetry-sources/vscode --excludedDir src/telemetry-sources/vscode/extensions --eventPrefix monacoworkbench/  --outputDir . --applyEndpoints -f telemetry",
     "extract-core-verbose": "node ./out/extractor.js --sourceDir src/telemetry-sources/vscode --excludedDir src/telemetry-sources/vscode/extensions --eventPrefix monacoworkbench/  --outputDir . --applyEndpoints --silent --verbose",
     "compile": "tsc",
     "watch": "tsc --watch"
@@ -22,18 +22,18 @@
   "author": "lramos15",
   "license": "MIT",
   "dependencies": {
-    "command-line-args": "^5.2.0",
-    "ts-morph": "^12.2.0",
-    "vscode-ripgrep": "^1.12.1"
+    "command-line-args": "^5.2.1",
+    "ts-morph": "^15.1.0",
+    "@vscode/ripgrep": "^1.14.2"
   },
   "devDependencies": {
     "@types/command-line-args": "^5.2.0",
-    "@types/mocha": "^9.0.0",
+    "@types/mocha": "^9.1.1",
     "@types/node": "^15.12.2",
     "mocha": "^9.1.3",
     "nyc": "^15.1.0",
-    "source-map-support": "^0.5.20",
-    "ts-node": "^10.4.0",
-    "typescript": "^4.4.4"
+    "source-map-support": "^0.5.21",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.7.4"
   }
 }

package/src/cli-options.ts

@@ -21,6 +21,7 @@ export const optionDefinitions = [
     { name: 'excludedDir', alias: 'x', description: 'A subdirectory which you would like to exclude from the extraction (relative to the CWD)', type: String, multiple: true, defaultValue: [] },
     { name: 'config', alias: 'c', description: 'A JSON Configuration file containing extraction details', type: String },
     { name: 'outputDir', alias: 'o', description: 'The directory which you would like the outputted JSON file to be placed in', type: String },
+    { name: 'fileName', alias: 'f', description: 'The name of the outputted JSON file', type: String },
     { name: 'eventPrefix', alias: 'p', type: String, description: 'The string you wish to prepend to every telemetry event.', defaultValue: '' },
     { name: 'help', alias: 'h', type: Boolean, description: 'Displays the help dialog which provides more information on how to use the tool', defaultValue: false },
     { name: 'applyEndpoints', alias: 'e', type: Boolean, defaultValue: false },

package/src/extractor.ts

@@ -12,7 +12,7 @@ if (options.config) {
     const sourceSpecs = convertConfigToSourceSpecs(options.config);
     extractAndResolveDeclarations(sourceSpecs).then((declarations) => {
         if (options.outputDir) {
-            writeToFile(options.outputDir, declarations, 'config-resolved', !options.silent);
+            writeToFile(options.outputDir, declarations, options.fileName || 'config-resolved', !options.silent);
         } else {
             console.log(JSON.stringify(declarations));
         }
@@ -36,7 +36,7 @@ if (options.config) {
     };
     extractAndResolveDeclarations([sourceSpec]).then((declarations) => {
         if (options.outputDir) {
-            writeToFile(options.outputDir, declarations, 'declarations-resolved', !options.silent);
+            writeToFile(options.outputDir, declarations, options.fileName || 'declarations-resolved', !options.silent);
         } else {
             console.log(JSON.stringify(declarations));
         }

package/src/lib/events.ts

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-import { IProperty, IInclude, ITelemetryDataPoint, ITelemetryData, IInline, IWildcard, IWildcardEntry } from './telemetry-interfaces';
+import { IInclude, ITelemetryDataPoint, ITelemetryData, IInline, IWildcard, IWildcardEntry, IMetadata } from './telemetry-interfaces';
 import { Property } from './common-properties';
 
 
@@ -14,7 +14,7 @@ export class Events implements ITelemetryData {
 export class Event implements ITelemetryDataPoint {
     public name: string;
     // It gets a little more complicated here as events can have a bunch of different things
-    public properties: Array<Property | Include | Inline | Wildcard>;
+    public properties: Array<Property | Metadata | Include | Inline | Wildcard>;
     constructor (name: string) {
         this.name =  name;
         this.properties = [];
@@ -53,4 +53,19 @@ export class WildcardEntry implements IWildcardEntry {
         this.classification = classification;
         this.endpoint = endPoint;
     }
+}
+
+export class Metadata implements IMetadata {
+    public name: 'owner' | 'comment' | 'expiration';
+    public value: string;
+    constructor (name: 'owner' | 'comment' | 'expiration', value: string) {
+        this.name = name;
+        this.value = value;
+    }
+
+    simpleObject(): {[key: string]: string} {
+        const simple = Object.create(null);
+        simple[this.name] = this.value;
+        return simple;
+    }
 }

package/src/lib/fragments.ts

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

package/src/lib/object-converter.ts

@@ -2,18 +2,22 @@
 // Licensed under the MIT license.
 import { OutputtedDeclarations } from "./declarations";
 import { Property } from "./common-properties";
-import { Wildcard } from "./events";
+import { Metadata, 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> {
+    // If there's no events or common properties, we emit a null object
+    if (output.events.dataPoints.length === 0 && output.commonProperties.properties.length === 0) {
+        return Object.create(null);
+    }
     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>) {
+        for (const property of event.properties as Array<Property | Wildcard | Metadata>) {
             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) {
@@ -30,7 +34,7 @@ export async function transformOutput(output: OutputtedDeclarations): Promise<Ou
                     }
                     newEvents[event.name][keywords.wildcard].push(newEntry);
                 }
-            } else {
+            } else if (property instanceof Property) {
                 // 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)]) {
@@ -53,6 +57,9 @@ export async function transformOutput(output: OutputtedDeclarations): Promise<Ou
                 if (property.isMeasurement) {
                     newEvents[event.name][propetyNameChanger(property.name)]['isMeasurement'] = property.isMeasurement;
                 }
+            } else {
+                // Comments, expiration, and owner metadata are handled here
+                newEvents[event.name][propetyNameChanger(property.name)] = property.value;
             }
         }
     }

package/src/lib/operations.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 import { Fragments, Fragment } from "./fragments";
-import { Events, Event, Include, Inline, Wildcard, WildcardEntry } from "./events";
+import { Events, Event, Include, Inline, Wildcard, WildcardEntry, Metadata } from "./events";
 import { Property } from "./common-properties";
 import * as keywords from './keywords';
 
@@ -64,6 +64,9 @@ export function populateProperties(properties: any, target: Event | Fragment, ap
             target.properties.push(new Inline(propertyName, currentProperty[keywords.inline]));
         } else if (propertyName === keywords.wildcard) {
             mergeWildcards(currentProperty, target, applyEndpoints);
+        } else if (propertyName === 'owner' || propertyName === 'comment' || propertyName === 'expiration') {
+            // This is the special case when the property name matches one of our metadata properties
+            target.properties.push(new Metadata(propertyName, currentProperty));
         } else {
             const prop = new Property(propertyName, currentProperty.classification, currentProperty.purpose, currentProperty.expiration, currentProperty.owner, currentProperty.comment);
             if (applyEndpoints) {

package/src/lib/parser.ts

@@ -1,9 +1,10 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-import { rgPath } from 'vscode-ripgrep';
+import { rgPath } from '@vscode/ripgrep';
 import * as path from 'path';
 import * as cp from 'child_process';
 import * as fs from 'fs';
+// Not importing 'process' as tsc claims `process.exitCode` is read-only when it actually is not.
 import { Fragments } from './fragments';
 import { Property, CommonProperties } from './common-properties';
 import { Events } from './events';
@@ -79,6 +80,7 @@ export class Parser {
             } catch (error) {
                 console.error(`Common Property Declaration Error: ${error} in file ${filePath}`);
                 console.error(`Source comment:\n${match[0]}`);
+                process.exitCode = 1;
             }
         });
         return commonPropertyDeclarations;
@@ -90,7 +92,7 @@ export class Parser {
         return this.findFiles(ripgrepPattern, sourceDir);
     }
 
-    /// 
+    ///
     private findFragments(sourceDir: string) {
         const filesWithFragments = this.asAbsoluteFilePaths(this.findFilesWithFragments(sourceDir));
 
@@ -109,6 +111,7 @@ export class Parser {
             } catch (error) {
                 console.error(`Fragment Declaration Error: ${error} in file ${filePath}`);
                 console.error(`Source comment:\n${match[0]}`);
+                process.exitCode = 1;
             }
         });
         return fragmentDeclarations;
@@ -138,6 +141,7 @@ export class Parser {
             } catch (error) {
                 console.error(`Event Declaration Error: ${error} in file ${filePath}`);
                 console.error(`Source comment:\n${match[0]}`);
+                process.exitCode = 1;
             }
         });
         return eventDeclarations;
@@ -181,4 +185,4 @@ export class Parser {
             });
         });
     }
-}
+}

package/src/lib/save-declarations.ts

@@ -13,6 +13,10 @@ import { ParserOptions, SourceSpec } from './source-spec';
 import { logMessage } from './logger';
 
 export function writeToFile(outputDir: string, contents: object, fileName: string, emitProgressMessage: boolean) {
+    if (Object.keys(contents).length === 0) {
+        logMessage(`...no events found, skipping file emmision!`, !emitProgressMessage);
+        return;
+    }
     const json = JSON.stringify(contents);
     const outputFile = path.resolve(outputDir, `${fileName}.json`);
     logMessage(`...writing ${outputFile}`, !emitProgressMessage);
@@ -61,6 +65,11 @@ export async function extractAndResolveDeclarations(sourceSpecs: Array<SourceSpe
         }
         const formattedDeclarations: any = await transformOutput(allDeclarations);
         for (const dec in allTypeScriptDeclarations) {
+            // If there's typescript declarations but we returned a null object
+            // We must add the event container to the declarations object
+            if (formattedDeclarations.events === undefined) {
+                formattedDeclarations.events = Object.create(null);
+            }
             formattedDeclarations.events[dec] = allTypeScriptDeclarations[dec];
         }
         return Promise.resolve(formattedDeclarations);

package/src/lib/telemetry-interfaces.ts

@@ -8,7 +8,12 @@ export interface ITelemetryData{
 
 export interface ITelemetryDataPoint {
     name: string;
-    properties: Array<IProperty | IInclude | IInline | Wildcard>;
+    properties: Array<IProperty | IInclude | IInline | IMetadata | Wildcard>;
+}
+
+export interface IMetadata {
+    name: 'owner' | 'comment' | 'expiration';
+    value: string;
 }
 
 export interface IProperty {

package/src/lib/ts-parser.ts

@@ -4,27 +4,10 @@ import { Project, SyntaxKind, Symbol, Node, CallExpression } from "ts-morph";
 import * as fs from 'fs';
 import * as cp from 'child_process';
 import * as path from 'path';
-import { rgPath } from "vscode-ripgrep";
+import { rgPath } from "@vscode/ripgrep";
 import { makeExclusionsRelativeToSource } from "./operations";
-
-interface IGDPRProperty {
-    propName: string;
-    classification: 'SystemMetaData' | 'CallstackOrException';
-    purpose: 'PerformanceAndHealth' | 'FeatureInsight';
-    expiration?: string;
-    owner?: string;
-    comment?: string;
-    endpoint?: string;
-    isMeasurement?: boolean;
-}
-class GDPREvent {
-    public eventName: string;
-    public properties: Array<IGDPRProperty>;
-    constructor(name: string) {
-        this.eventName = name;
-        this.properties = [];
-    }
-}
+import  { Event, Metadata } from './events';
+import { Property } from "./common-properties";
 
 class NodeVisitor {
 
@@ -60,11 +43,12 @@ class NodeVisitor {
             // If we don't want endpoints skip them
             if (currentNode.getEscapedName().toLowerCase() === "endpoint" && !this.applyEndpoints) return;
 
+            const nodeName = currentNode.getEscapedName();
             // If it's a string we strip the quotes
             if (type.isStringLiteral()) {
-                this.resolved_property[currentNode.getEscapedName()] = type.getText().substring(1, type.getText().length - 1);
+                this.resolved_property[nodeName] = type.getText().substring(1, type.getText().length - 1);
             } else {
-                this.resolved_property[currentNode.getEscapedName()] = type.getText() === 'true';
+                this.resolved_property[nodeName] = type.getText() === 'true';
             }
             return;
         }
@@ -87,7 +71,26 @@ class NodeVisitor {
         this.prop_name = this.original_prop_name;
     }
 
-    public resolveProperties(currentNode: Symbol) {
+    private visitMetadataNode(currentNode: Symbol) {
+        let type = currentNode.getTypeAtLocation(this.pl_node);
+        // If we mark a property as optional then it is nullable, however we want all properties 
+        // So we want its non nullable type tl;dr this chops off the | undefined
+        if (type.isNullable()) {
+            type = type.getNonNullableType();
+        }
+        if (type.isStringLiteral()) {
+            const nodeName = currentNode.getEscapedName();
+            this.resolved_property[nodeName] = type.getText().substring(1, type.getText().length - 1);
+            if (nodeName === 'owner' || nodeName === 'comment' || nodeName === 'expiration') {
+                this.properties.push(new Metadata(nodeName, this.resolved_property[nodeName]).simpleObject());
+            }
+        }
+    }
+
+    public resolveProperties(currentNode: Symbol): Array<Property | Metadata> {
+        // It could be a complex node with nested types or a simple node with a string literal
+        // representing some kind of metadata, so we try both visitors.
+        this.visitMetadataNode(currentNode);
         this.visitNode(currentNode);
         return this.properties;
     }
@@ -163,13 +166,13 @@ export class TsParser {
                 let event_name = pl.getArguments()[0].getType().isStringLiteral() ? pl.getArguments()[0].getType().getText() : '';
                 // If we can't resolve the event_name there is no use continuing
                 if (event_name === '') {
-                    console.error('Unable to resolve event name, skipping....');
+                    console.error(`Unable to resolve event name ${pl.getFullText().trim()}, skipping....`);
                     return;
                 } else {
                     event_name = event_name.substring(1, event_name.length - 1);
                 }
                 event_name = this.lowerCaseEvents ? event_name.toLowerCase() : event_name;
-                const created_event = new GDPREvent(event_name);
+                const created_event = new Event(event_name);
                 // We want the second one because public log is in the form <Event, Classification> and we care about the classification
                 const type_properties = typeArgs[1].getType().getProperties();
                 type_properties.forEach((prop) => {

package/documentation/comment-code-annotations.md

@@ -1,197 +0,0 @@
-# Annotating your Code
-
-**NOTE**: If using Typescript we recommend annotating your telemetry events with typings as shown [here](typescript-code-annotations.md)
-
-All telemetry events we send need to be described. For each property of each event we need to know what kind of data they contain and for what reason we collect the data.
-
-Let's assume we send the following event and the timer data is dynamic, i.e. the properties of `timer` can not be known statically:
-```ts
-logEvent('E1', {
-    E1P1: 'activitybar',
-    ...f1,
-    ...f4,
-    timer: {
-        waited: 536,
-        processing: 43,
-        queued: 97,
-        elasped: 812
-    }
-});
-```
-
-The event is constructed in multiple steps, normally scattered across several files:
-```ts
-function logEvent(eventName, eventData) {
-    eventData.CP1 = getSQMUserId();
-    service.sendEvent(eventName, eventData);
-}
-
-let f1 : F1 = { F1P1 : 23 };
-
-let f2 : F2 = { F2P1 : document.getLine(1) };
-
-let f3 : F3 = { F3P1: publisher.displayName };
-
-let f4 : F4 = {
-    F4P1: extension.extensionName,
-    F4P2: {
-        ...f2,
-        ...f3
-    }
-};
-
-logEvent('E1', {
-    E1P1: 'activitybar',
-    ...f1,
-    ...f4,
-    timer: {
-        waited: 536,
-        processing: 43,
-        queued: 97,
-        elasped: 812
-    }
-});
-```
-
-In order to extract the event descriptions with simple scanners we use specific comments to describe telemetry events and their properties. We place those comments as close as possible to where the events and properties are generated. The code above would be annotated as follows:
-```ts
-// __GDPR__COMMON__ "CP1" : { "endPoint": "SqmUserId", "classification": "EndUserPseudonymizedInformation", "purpose": "BusinessInsight" }
-function logEvent(eventName, eventData) {
-    eventData.CP1 = getSQMUserId();
-    service.sendEvent(eventName, eventData);
-}
-
-/* __GDPR__FRAGMENT__
-   "F1" : {
-      "F1P1": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
-   }
- */
-let f1 : F1 = { F1P1 : 23 };
-
-/* __GDPR__FRAGMENT__
-   "F2" : {
-      "F2P1" : { "classification": "CustomerContent", "purpose": "PerformanceAndHealth" }
-   }
- */
-let f2 : F2 = { F2P1 : document.getLine(1) };
-
-/* __GDPR__FRAGMENT__
-   "F3" : {
-      "F3P1" : { "classification": "PublicPersonalData", "purpose": "FeatureInsight" }
-   }
- */
-let f3 : F3 = { F3P1: publisher.displayName };
-
-/* __GDPR__FRAGMENT__
-   "F4" : {
-      "F4P1" : { "classification": "PublicNonPersonalData", "purpose": "FeatureInsight" },
-      "F4P2": {
-          "${inline}": [
-              "${F2}",
-              "${F3}"
-            ]
-        }
-   }
- */
-let f4 : F4 = {
-    F4P1: extension.extensionName,
-    F4P2: {
-        ...f2,
-        ...f3
-    }
-};
-
-/* __GDPR__
-   "E1" : {
-      "E1P1" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-      "${include}": [
-          "${F1}",
-          "${F4}"
-        ],
-      "${wildcard}": [
-         {
-            "${prefix}": "timer.",
-            "${classification}": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
-         }
-      ]
-   }
- */
-logEvent('E1', {
-    E1P1: 'activitybar',
-    ...f1,
-    ...f4,
-    timer: {
-        waited: 536,
-        processing: 43,
-        queued: 97,
-        elasped: 812
-    }
-});
-```
-
-The GDPR comments are processed and result in the following final description of the `E1` event. Every property that starts with `timer.` -- such as `timer.waited` -- is classified as system metadata that we collect for gaining insights into how the feature is being used.
-```json
-   "E1" : {
-      "E1P1" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-      "F1P1": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
-      "F4P1" : { "classification": "PublicNonPersonalData", "purpose": "FeatureInsight" },
-      "F4P2.F2P1" : { "classification": "CustomerContent", "purpose": "PerformanceAndHealth" },
-      "F4P2.F3P1" : { "classification": "PublicPersonalData", "purpose": "FeatureInsight" },
-      "${wildcard}": [
-         {
-            "${prefix}": "timer.",
-            "${classification}": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
-         }
-      ],
-      "CP1" : { "endPoint": "SqmUserId", "classification": "EndUserPseudonymizedInformation", "purpose": "BusinessInsight" }
-   }
-```
-
-# Syntax
-All GDPR comments are tagged with one of the following tags and are otherwise well-formed `JSON`.
-- `__GDPR__` - describes the name and the properties of a telemetry event
-- `__GDPR__FRAGMENT__` - describes the name and the properties of a fragment of the data of an event, fragments are either included or inlined by other fragments or events
-- `__GDPR__COMMON__` - describes a property added to every telemetry event
-
-Each property is described with an object that looks like this:
-```ts
-{
-    endPoint?: "none" | "SqmUserId" | "SqmMachineId",
-    classification: "SystemMetaData" | "CustomerContent" | "EndUserPseudonymizedInformation" | "PublicPersonalData" | "PublicNonPersonalData" | "CallstackOrException",
-    purpose: "FeatureInsight" | "PerformanceAndHealth" | "BusinessInsight" | "SecurityAndAuditing",
-    owner: string,
-    comment: string,
-    expiration?: string,
-    isMeasurement?: Boolean
-}
-```
-
-If `endPoint` is omitted, it defaults to `none`. That's appropriate for pretty much all properties rather than a couple of common properties.
-
-The values for `classification` are mostly self-explaining. `EndUserPseudonymizedInformation` is what allows us to identify a particular user across time, although we don't know the actual identity of the user. `machineId` or `instanceId` fall in this category. `PublicPersonalData` and `PublicNonPersonalData` is information that users provide us with, for example, publisher information on the marketplace. `CustomerContent` is information the user generated such as urls of repositories or custom snippets. `CallstackOrException` is for error data like callbacks and exceptions. Everything else is `SystemMetaData`.
-
-`purpose` is usually `FeatureInsight` or `PerformanceAndHealth`. We only use `BusinessInsight` for events generated by surveys.
-
-`owner` is used to specify who is responsbile for the telemetry event. 
-
-`comment` is used to specify a reason for collecting the event. This is meant to be more descriptive than `classification` and `purpose`.
-
-`expiration` is used if you would like to dictate the max product version this telemetry event should be sent in. This allows external tools to specify which events should be removed from the codebase.
-
-`isMeasurement` is used if the property is a number. Numbers are handled differently in the telemetry system.
-
-For an event with no properties, define an empty event:
-```json
-"event" : { }
-```
-This will be classified as `SystemMetadata` with a purpose of `FeatureInsight`.
-
-## Special constructs
-#### ${include}
-If A includes B, this is equivalent to the union of A and B. Fragments are referenced using `${FragmentName}`.
-
-#### ${inline}
-If A inlines B at property P, all properties of B are added to A under the key `"P.<Name in B>"`. Fragments are referenced using `${FragmentName}`.
-
-#### ${wildcard}
-Wildcards can be used as a **temporary** workaround to describe dynamic properties that have a common prefix. In the long run all dynamic properties need to be removed and be sent as values of a static property. A wild card is an array of wildcard entries. Each entry has a `${prefix}` and a `${classification}` property. The value of `${prefix}` is a string representing the common prefix of all properties it matches. The value of `${classification}` is a property description detailed above.