development/vscode
development/vscode
1
0
Fork 0
mirror of https://github.com/Microsoft/vscode synced 2024-09-18 01:58:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make comment and owner required by default (#156822)

Browse source
This commit is contained in:
Logan Ramos 2022-08-01 16:05:57 -04:00 committed by GitHub
parent f4433141c7
commit d32b92bd7a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
26 changed files with 95 additions and 86 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/vs/base/common/actions.ts
View file

@ -15,6 +15,7 @@ export interface ITelemetryData {
export type WorkbenchActionExecutedClassification = {
owner: 'bpasero';
comment: 'TODO @bpasero';
id: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The identifier of the action that was run.' };
from: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The name of the component the action was run from.' };
};

6
src/vs/editor/standalone/browser/standaloneServices.ts
View file

@ -46,7 +46,7 @@ import { ITelemetryInfo, ITelemetryService, TelemetryLevel } from 'vs/platform/t
import { ISingleFolderWorkspaceIdentifier, IWorkspaceIdentifier, IWorkspace, IWorkspaceContextService, IWorkspaceFolder, IWorkspaceFoldersChangeEvent, IWorkspaceFoldersWillChangeEvent, WorkbenchState, WorkspaceFolder } from 'vs/platform/workspace/common/workspace';
import { ILayoutService } from 'vs/platform/layout/browser/layoutService';
import { StandaloneServicesNLS } from 'vs/editor/common/standaloneStrings';
import { ClassifiedEvent, StrictPropertyCheck, GDPRClassification } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, StrictPropertyCheck, OmitMetadata, IGDPRProperty } from 'vs/platform/telemetry/common/gdprTypings';
import { basename } from 'vs/base/common/resources';
import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
import { ConsoleLogger, ILogService, LogService } from 'vs/platform/log/common/log';
@ -670,7 +670,7 @@ class StandaloneTelemetryService implements ITelemetryService {
return Promise.resolve(undefined);
}
publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
return this.publicLog(eventName, data as any);
}
@ -678,7 +678,7 @@ class StandaloneTelemetryService implements ITelemetryService {
return Promise.resolve(undefined);
}
publicLogError2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
return this.publicLogError(eventName, data as any);
}

19
src/vs/platform/telemetry/common/gdprTypings.ts
View file

@ -5,29 +5,28 @@
export interface IPropertyData {
classification: 'SystemMetaData' | 'CallstackOrException' | 'CustomerContent' | 'PublicNonPersonalData' | 'EndUserPseudonymizedInformation';
purpose: 'PerformanceAndHealth' | 'FeatureInsight' | 'BusinessInsight';
comment?: string;
comment: string;
expiration?: string;
endpoint?: string;
isMeasurement?: boolean;
}
export interface IGDPRProperty {
owner?: string;
comment?: string;
owner: string;
comment: string;
expiration?: string;
readonly [name: string]: IPropertyData | undefined | IGDPRProperty | string;
}
type IGDPRPropertyWithoutMetadata<T> = Omit<T, 'owner' | 'comment' | 'expiration'>;
type IGDPRPropertyWithoutMetadata = Omit<IGDPRProperty, 'owner' | 'comment' | 'expiration'>;
export type OmitMetadata<T> = Omit<T, 'owner' | 'comment' | 'expiration'>;
export type ClassifiedEvent<T extends IGDPRProperty> = {
[k in keyof IGDPRPropertyWithoutMetadata<T>]: any
export type ClassifiedEvent<T extends IGDPRPropertyWithoutMetadata> = {
[k in keyof T]: any
};
export type StrictPropertyChecker<TEvent, TClassifiedEvent, TError> = keyof TEvent extends keyof TClassifiedEvent ? keyof TClassifiedEvent extends keyof TEvent ? TEvent : TError : TError;
export type StrictPropertyChecker<TEvent, TClassification, TError> = keyof TEvent extends keyof OmitMetadata<TClassification> ? keyof OmitMetadata<TClassification> extends keyof TEvent ? TEvent : TError : TError;
export type StrictPropertyCheckError = { error: 'Type of classified event does not match event properties' };
export type StrictPropertyCheck<T extends IGDPRProperty, E> = StrictPropertyChecker<E, ClassifiedEvent<T>, StrictPropertyCheckError>;
export type GDPRClassification<T> = { [_ in keyof T]: IPropertyData | IGDPRProperty | undefined | string };
export type StrictPropertyCheck<T extends IGDPRProperty, E> = StrictPropertyChecker<E, ClassifiedEvent<OmitMetadata<T>>, StrictPropertyCheckError>;

6
src/vs/platform/telemetry/common/serverTelemetryService.ts
View file

@ -6,7 +6,7 @@
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { refineServiceDecorator } from 'vs/platform/instantiation/common/instantiation';
import { IProductService } from 'vs/platform/product/common/productService';
import { ClassifiedEvent, GDPRClassification, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ITelemetryData, ITelemetryService, TelemetryLevel } from 'vs/platform/telemetry/common/telemetry';
import { ITelemetryServiceConfig, TelemetryService } from 'vs/platform/telemetry/common/telemetryService';
import { NullTelemetryServiceShape } from 'vs/platform/telemetry/common/telemetryUtils';
@ -37,7 +37,7 @@ export class ServerTelemetryService extends TelemetryService implements IServerT
return super.publicLog(eventName, data, anonymizeFilePaths);
}
override publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>, anonymizeFilePaths?: boolean): Promise<void> {
override publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>, anonymizeFilePaths?: boolean): Promise<void> {
return this.publicLog(eventName, data as ITelemetryData | undefined, anonymizeFilePaths);
}
@ -48,7 +48,7 @@ export class ServerTelemetryService extends TelemetryService implements IServerT
return super.publicLogError(errorEventName, data);
}
override publicLogError2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>): Promise<void> {
override publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): Promise<void> {
return this.publicLogError(eventName, data as ITelemetryData | undefined);
}

6
src/vs/platform/telemetry/common/telemetry.ts
View file

@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { ClassifiedEvent, GDPRClassification, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { IObservableValue } from 'vs/base/common/observableValue';
export const ITelemetryService = createDecorator<ITelemetryService>('telemetryService');
@ -40,14 +40,14 @@ export interface ITelemetryService {
* Sends a telemetry event that has been privacy approved.
* Do not call this unless you have been given approval.
*/
publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>, anonymizeFilePaths?: boolean): Promise<void>;
publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>, anonymizeFilePaths?: boolean): Promise<void>;
/**
* @deprecated Use publicLogError2 and the typescript GDPR annotation where possible
*/
publicLogError(errorEventName: string, data?: ITelemetryData): Promise<void>;
publicLogError2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>): Promise<void>;
publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): Promise<void>;
getTelemetryInfo(): Promise<ITelemetryInfo>;

6
src/vs/platform/telemetry/common/telemetryService.ts
View file

@ -14,7 +14,7 @@ import { ConfigurationScope, Extensions, IConfigurationRegistry } from 'vs/platf
import product from 'vs/platform/product/common/product';
import { IProductService } from 'vs/platform/product/common/productService';
import { Registry } from 'vs/platform/registry/common/platform';
import { ClassifiedEvent, GDPRClassification, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ITelemetryData, ITelemetryInfo, ITelemetryService, TelemetryConfiguration, TelemetryLevel, TELEMETRY_OLD_SETTING_ID, TELEMETRY_SECTION_ID, TELEMETRY_SETTING_ID } from 'vs/platform/telemetry/common/telemetry';
import { getTelemetryLevel, ITelemetryAppender } from 'vs/platform/telemetry/common/telemetryUtils';
@ -137,7 +137,7 @@ export class TelemetryService implements ITelemetryService {
return this._log(eventName, TelemetryLevel.USAGE, data, anonymizeFilePaths);
}
publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>, anonymizeFilePaths?: boolean): Promise<any> {
publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>, anonymizeFilePaths?: boolean): Promise<any> {
return this.publicLog(eventName, data as ITelemetryData, anonymizeFilePaths);
}
@ -150,7 +150,7 @@ export class TelemetryService implements ITelemetryService {
return this._log(errorEventName, TelemetryLevel.ERROR, data, true);
}
publicLogError2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>): Promise<any> {
publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): Promise<any> {
return this.publicLogError(eventName, data as ITelemetryData);
}

6
src/vs/platform/telemetry/common/telemetryUtils.ts
View file

@ -12,7 +12,7 @@ import { ConfigurationTarget, ConfigurationTargetToString, IConfigurationService
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { IProductService } from 'vs/platform/product/common/productService';
import { verifyMicrosoftInternalDomain } from 'vs/platform/telemetry/common/commonProperties';
import { ClassifiedEvent, GDPRClassification, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ICustomEndpointTelemetryService, ITelemetryData, ITelemetryEndpoint, ITelemetryInfo, ITelemetryService, TelemetryConfiguration, TelemetryLevel, TELEMETRY_OLD_SETTING_ID, TELEMETRY_SETTING_ID } from 'vs/platform/telemetry/common/telemetry';
export class NullTelemetryServiceShape implements ITelemetryService {
@ -22,13 +22,13 @@ export class NullTelemetryServiceShape implements ITelemetryService {
publicLog(eventName: string, data?: ITelemetryData) {
return Promise.resolve(undefined);
}
publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
return this.publicLog(eventName, data as ITelemetryData);
}
publicLogError(eventName: string, data?: ITelemetryData) {
return Promise.resolve(undefined);
}
publicLogError2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
return this.publicLogError(eventName, data as ITelemetryData);
}

4
src/vs/platform/telemetry/test/browser/telemetryService.test.ts
View file

@ -11,7 +11,7 @@ import { TestConfigurationService } from 'vs/platform/configuration/test/common/
import product from 'vs/platform/product/common/product';
import { IProductService } from 'vs/platform/product/common/productService';
import ErrorTelemetry from 'vs/platform/telemetry/browser/errorTelemetry';
import { ClassifiedEvent, GDPRClassification, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ITelemetryData, TelemetryConfiguration, TelemetryLevel } from 'vs/platform/telemetry/common/telemetry';
import { ITelemetryServiceConfig, TelemetryService } from 'vs/platform/telemetry/common/telemetryService';
import { ITelemetryAppender, NullAppender } from 'vs/platform/telemetry/common/telemetryUtils';
@ -240,7 +240,7 @@ suite('TelemetryService', () => {
return p;
}
override publicLogError2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>): Promise<any> {
override publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): Promise<any> {
return this.publicLogError(eventName, data as ITelemetryData);
}
}

2
src/vs/platform/windows/electron-main/window.ts
View file

@ -610,7 +610,7 @@ export class CodeWindow extends Disposable implements ICodeWindow {
type WindowErrorClassification = {
type: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'The type of window crash to understand the nature of the crash better.' };
reason: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'The reason of the window crash to understand the nature of the crash better.' };
code: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; omment: 'The exit code of the window process to understand the nature of the crash better' };
code: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'The exit code of the window process to understand the nature of the crash better' };
owner: 'bpasero';
comment: 'Provides insight into reasons the vscode window crashes.';
};

4
src/vs/workbench/api/browser/mainThreadTelemetry.ts
View file

@ -6,7 +6,7 @@
import { Disposable } from 'vs/base/common/lifecycle';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { IProductService } from 'vs/platform/product/common/productService';
import { ClassifiedEvent, GDPRClassification, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ITelemetryService, TelemetryLevel } from 'vs/platform/telemetry/common/telemetry';
import { supportsTelemetry } from 'vs/platform/telemetry/common/telemetryUtils';
import { extHostNamedCustomer, IExtHostContext } from 'vs/workbench/services/extensions/common/extHostCustomers';
@ -51,7 +51,7 @@ export class MainThreadTelemetry extends Disposable implements MainThreadTelemet
this._telemetryService.publicLog(eventName, data);
}
$publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void {
$publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void {
this.$publicLog(eventName, data as any);
}
}

4
src/vs/workbench/api/common/extHost.protocol.ts
View file

@ -38,7 +38,7 @@ import { IMarkerData } from 'vs/platform/markers/common/markers';
import { IProgressOptions, IProgressStep } from 'vs/platform/progress/common/progress';
import * as quickInput from 'vs/platform/quickinput/common/quickInput';
import { IRemoteConnectionData, TunnelDescription } from 'vs/platform/remote/common/remoteAuthorityResolver';
import { ClassifiedEvent, GDPRClassification, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { TelemetryLevel } from 'vs/platform/telemetry/common/telemetry';
import { ICreateContributedTerminalProfileOptions, IProcessProperty, IShellLaunchConfigDto, ITerminalEnvironment, ITerminalLaunchError, ITerminalProfile, TerminalExitReason, TerminalLocation } from 'vs/platform/terminal/common/terminal';
import { ThemeColor, ThemeIcon } from 'vs/platform/theme/common/themeService';
@ -598,7 +598,7 @@ export interface MainThreadStorageShape extends IDisposable {
export interface MainThreadTelemetryShape extends IDisposable {
$publicLog(eventName: string, data?: any): void;
$publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
$publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
}
export interface MainThreadEditorInsetsShape extends IDisposable {

8
src/vs/workbench/browser/parts/editor/editorStatus.ts
View file

@ -1242,22 +1242,24 @@ export class ChangeLanguageAction extends Action {
if (resource?.scheme === Schemas.untitled) {
type SetUntitledDocumentLanguageEvent = { to: string; from: string; modelPreference: string };
type SetUntitledDocumentLanguageClassification = {
owner: 'TylerLeonhardt';
comment: 'Helps understand what the automatic language detection does for untitled files';
to: {
classification: 'SystemMetaData';
purpose: 'FeatureInsight';
owner: 'JacksonKearl';
owner: 'TylerLeonhardt';
comment: 'Help understand effectiveness of automatic language detection';
};
from: {
classification: 'SystemMetaData';
purpose: 'FeatureInsight';
owner: 'JacksonKearl';
owner: 'TylerLeonhardt';
comment: 'Help understand effectiveness of automatic language detection';
};
modelPreference: {
classification: 'SystemMetaData';
purpose: 'FeatureInsight';
owner: 'JacksonKearl';
owner: 'TylerLeonhardt';
comment: 'Help understand effectiveness of automatic language detection';
};
};

5
src/vs/workbench/contrib/extensions/browser/extensionsWorkbenchService.ts
View file

@ -46,7 +46,6 @@ import { IExtensionManifestPropertiesService } from 'vs/workbench/services/exten
import { IExtensionService, IExtensionsStatus } from 'vs/workbench/services/extensions/common/extensions';
import { ExtensionEditor } from 'vs/workbench/contrib/extensions/browser/extensionEditor';
import { isWeb, language } from 'vs/base/common/platform';
import { GDPRClassification } from 'vs/platform/telemetry/common/gdprTypings';
import { ILanguagePackService } from 'vs/platform/languagePacks/common/languagePacks';
import { ILocaleService } from 'vs/workbench/contrib/localization/common/locale';
@ -58,12 +57,12 @@ interface InstalledExtensionsEvent {
readonly extensionIds: string;
readonly count: number;
}
interface ExtensionsLoadClassification extends GDPRClassification<InstalledExtensionsEvent> {
type ExtensionsLoadClassification = {
owner: 'digitarald';
comment: 'Helps to understand which extensions are the most actively used.';
readonly extensionIds: { classification: 'PublicNonPersonalData'; purpose: 'FeatureInsight'; comment: 'The list of extension ids that are installed.' };
readonly count: { classification: 'PublicNonPersonalData'; purpose: 'FeatureInsight'; comment: 'The number of extensions that are installed.' };
}
};
export class Extension implements IExtension {

2
src/vs/workbench/contrib/format/browser/formatActionsMultiple.ts
View file

@ -272,7 +272,7 @@ function logFormatterTelemetry<T extends { extensionId?: ExtensionIdentifier }>(
comment: 'Information about resolving formatter conflicts';
mode: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Formatting mode: whole document or a range/selection' };
extensions: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The extension that got picked' };
pick: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comments: 'The possible extensions to pick' };
pick: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The possible extensions to pick' };
};
function extKey(obj: T): string {
return obj.extensionId ? ExtensionIdentifier.toKey(obj.extensionId) : 'unknown';

2
src/vs/workbench/contrib/preferences/browser/settingsEditor2.ts
View file

@ -1615,6 +1615,8 @@ export class SettingsEditor2 extends EditorPane {
'message': string;
};
type SettingsSearchErrorClassification = {
owner: 'rzhao271';
comment: 'Helps understand when settings search errors out';
'message': { 'classification': 'CallstackOrException'; 'purpose': 'FeatureInsight'; 'owner': 'rzhao271'; 'comment': 'The error message of the search error.' };
};

6
src/vs/workbench/contrib/search/test/electron-browser/textsearch.perf.integrationTest.ts
View file

@ -25,7 +25,7 @@ import { ServiceCollection } from 'vs/platform/instantiation/common/serviceColle
import { ILogService, NullLogService } from 'vs/platform/log/common/log';
import { INotificationService } from 'vs/platform/notification/common/notification';
import { TestNotificationService } from 'vs/platform/notification/test/common/testNotificationService';
import { ClassifiedEvent, GDPRClassification, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ITelemetryInfo, ITelemetryService, TelemetryLevel } from 'vs/platform/telemetry/common/telemetry';
import { TestThemeService } from 'vs/platform/theme/test/common/testThemeService';
import { IUndoRedoService } from 'vs/platform/undoRedo/common/undoRedo';
@ -207,7 +207,7 @@ class TestTelemetryService implements ITelemetryService {
return Promise.resolve();
}
public publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
public publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
return this.publicLog(eventName, data as any);
}
@ -215,7 +215,7 @@ class TestTelemetryService implements ITelemetryService {
return this.publicLog(eventName, data);
}
public publicLogError2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
public publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
return this.publicLogError(eventName, data as any);
}

4
src/vs/workbench/contrib/searchEditor/browser/searchEditorActions.ts
View file

@ -139,7 +139,7 @@ export const openNewSearchEditor =
}
}
telemetryService.publicLog2<{}, { owner: 'roblourens' }>('searchEditor/openNewSearchEditor');
telemetryService.publicLog2<{}, { owner: 'roblourens'; comment: 'TODO @roblourens' }>('searchEditor/openNewSearchEditor');
const seedSearchStringFromSelection = _args.location === 'new' || configurationService.getValue<IEditorOptions>('editor').find!.seedSearchStringFromSelection;
const args: OpenSearchEditorArgs = { query: seedSearchStringFromSelection ? selected : undefined };
@ -189,7 +189,7 @@ export const createEditorFromSearchResult =
const sortOrder = configurationService.getValue<ISearchConfigurationProperties>('search').sortOrder;
telemetryService.publicLog2<{}, { owner: 'roblourens' }>('searchEditor/createEditorFromSearchResult');
telemetryService.publicLog2<{}, { owner: 'roblourens'; comment: 'TODO @roblourens' }>('searchEditor/createEditorFromSearchResult');
const labelFormatter = (uri: URI): string => labelService.getUriLabel(uri, { relative: true });

2
src/vs/workbench/contrib/searchEditor/browser/searchEditorInput.ts
View file

@ -184,7 +184,7 @@ export class SearchEditorInput extends EditorInput {
override async saveAs(group: GroupIdentifier, options?: ITextFileSaveOptions): Promise<EditorInput | undefined> {
const path = await this.fileDialogService.pickFileToSave(await this.suggestFileName(), options?.availableFileSystems);
if (path) {
this.telemetryService.publicLog2<{}, { owner: 'roblourens' }>('searchEditor/saveSearchResults');
this.telemetryService.publicLog2<{}, { owner: 'roblourens'; comment: 'TODO @roblourens' }>('searchEditor/saveSearchResults');
const toWrite = await this.serializeForDisk();
if (await this.textFileService.create([{ resource: path, value: toWrite, options: { overwrite: true } }])) {
this.setDirty(false);

3
src/vs/workbench/contrib/telemetry/browser/telemetry.contribution.ts
View file

@ -71,6 +71,7 @@ export class TelemetryContribution extends Disposable implements IWorkbenchContr
innerWidth: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The width of the current window.' };
outerHeight: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The height of the current window with all decoration removed.' };
outerWidth: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'The width of the current window with all decoration removed.' };
owner: 'bpasero';
comment: 'The size of the window.';
};
@ -82,7 +83,7 @@ export class TelemetryContribution extends Disposable implements IWorkbenchContr
'workbench.filesToOpenOrCreate': { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'Number of files that should open or be created.' };
'workbench.filesToDiff': { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'Number of files that should be compared.' };
'workbench.filesToMerge': { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'Number of files that should be merged.' };
customKeybindingsCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true };
customKeybindingsCount: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; isMeasurement: true; comment: 'Number of custom keybindings' };
theme: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The current theme of the window.' };
language: { classification: 'SystemMetaData'; purpose: 'BusinessInsight'; comment: 'The display language of the window.' };
pinnedViewlets: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'The identifiers of views that are pinned.' };

2
src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService.ts
View file

@ -415,6 +415,8 @@ export class WalkthroughsService extends Disposable implements IWalkthroughsServ
if (sectionToOpen && this.configurationService.getValue<string>('workbench.welcomePage.walkthroughs.openOnInstall')) {
type GettingStartedAutoOpenClassification = {
owner: 'lramos15';
comment: 'When a walkthrthrough is opened upon extension installation';
id: {
classification: 'PublicNonPersonalData'; purpose: 'FeatureInsight';
owner: 'lramos15';

3
src/vs/workbench/services/accessibility/electron-sandbox/accessibilityService.ts
View file

@ -23,7 +23,8 @@ interface AccessibilityMetrics {
}
type AccessibilityMetricsClassification = {
owner: 'isidorn';
enabled: { classification: 'SystemMetaData'; purpose: 'FeatureInsight' };
comment: 'Helps gain an understanding of when accessibility features are being used';
enabled: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'Whether or not accessibility features are enabled' };
};
export class NativeAccessibilityService extends AccessibilityService implements IAccessibilityService {

5
src/vs/workbench/services/extensions/browser/extensionUrlHandler.ts
View file

@ -30,7 +30,6 @@ import { IExtensionUrlTrustService } from 'vs/platform/extensionManagement/commo
import { CancellationToken } from 'vs/base/common/cancellation';
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
import { GDPRClassification } from 'vs/platform/telemetry/common/gdprTypings';
const FIVE_MINUTES = 5 * 60 * 1000;
const THIRTY_SECONDS = 30 * 1000;
@ -81,11 +80,11 @@ export interface ExtensionUrlHandlerEvent {
readonly extensionId: string;
}
export interface ExtensionUrlHandlerClassification extends GDPRClassification<ExtensionUrlHandlerEvent> {
type ExtensionUrlHandlerClassification = {
owner: 'joaomoreno';
readonly extensionId: { classification: 'PublicNonPersonalData'; purpose: 'FeatureInsight'; comment: 'The ID of the extension that should handle the URI' };
comment: 'This is used to understand the drop funnel of extension URI handling by the OS & VS Code.';
}
};
/**
* This class handles URLs which are directed towards extensions.

61
src/vs/workbench/services/search/common/searchService.ts
View file

@ -283,17 +283,18 @@ export class SearchService extends Disposable implements ISearchService {
type CachedSearchCompleteClassifcation = {
owner: 'roblourens';
reason?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
resultCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
workspaceFolderCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
type: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
endToEndTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
sortingTime?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
cacheWasResolved: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
cacheLookupTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
cacheFilterTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
cacheEntryCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
scheme: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
comment: 'TODO @roblourens';
reason?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
resultCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
workspaceFolderCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
type: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
endToEndTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
sortingTime?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
cacheWasResolved: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
cacheLookupTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
cacheFilterTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
cacheEntryCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
scheme: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
};
type CachedSearchCompleteEvent = {
reason?: string;
@ -326,18 +327,19 @@ export class SearchService extends Disposable implements ISearchService {
type SearchCompleteClassification = {
owner: 'roblourens';
reason?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
resultCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
workspaceFolderCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
type: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
endToEndTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
sortingTime?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
fileWalkTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
directoriesWalked: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
filesWalked: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
cmdTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
cmdResultCount?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
scheme: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
comment: 'TODO @roblourens';
reason?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
resultCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
workspaceFolderCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
type: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
endToEndTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
sortingTime?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
fileWalkTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
directoriesWalked: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
filesWalked: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
cmdTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
cmdResultCount?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
scheme: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
};
type SearchCompleteEvent = {
reason?: string;
@ -384,12 +386,13 @@ export class SearchService extends Disposable implements ISearchService {
type TextSearchCompleteClassification = {
owner: 'roblourens';
reason?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
workspaceFolderCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
endToEndTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true };
scheme: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
error?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
usePCRE2: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth' };
comment: 'TODO @roblourens';
reason?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
workspaceFolderCount: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
endToEndTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'TODO @roblourens' };
scheme: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
error?: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
usePCRE2: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'TODO @roblourens' };
};
type TextSearchCompleteEvent = {
reason?: string;

6
src/vs/workbench/services/telemetry/browser/telemetryService.ts
View file

@ -11,7 +11,7 @@ import { ILoggerService } from 'vs/platform/log/common/log';
import { IProductService } from 'vs/platform/product/common/productService';
import { IStorageService } from 'vs/platform/storage/common/storage';
import { OneDataSystemWebAppender } from 'vs/platform/telemetry/browser/1dsAppender';
import { ClassifiedEvent, GDPRClassification, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from 'vs/platform/telemetry/common/gdprTypings';
import { ITelemetryData, ITelemetryInfo, ITelemetryService, TelemetryLevel } from 'vs/platform/telemetry/common/telemetry';
import { TelemetryLogAppender } from 'vs/platform/telemetry/common/telemetryLogAppender';
import { ITelemetryServiceConfig, TelemetryService as BaseTelemetryService } from 'vs/platform/telemetry/common/telemetryService';
@ -68,7 +68,7 @@ export class TelemetryService extends Disposable implements ITelemetryService {
return this.impl.publicLog(eventName, data, anonymizeFilePaths);
}
publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>, anonymizeFilePaths?: boolean) {
publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>, anonymizeFilePaths?: boolean) {
return this.publicLog(eventName, data as ITelemetryData, anonymizeFilePaths);
}
@ -76,7 +76,7 @@ export class TelemetryService extends Disposable implements ITelemetryService {
return this.impl.publicLog(errorEventName, data);
}
publicLogError2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
return this.publicLogError(eventName, data as ITelemetryData);
}

6
src/vs/workbench/services/telemetry/electron-sandbox/telemetryService.ts
View file

@ -15,7 +15,7 @@ import { IStorageService } from 'vs/platform/storage/common/storage';
import { resolveWorkbenchCommonProperties } from 'vs/workbench/services/telemetry/electron-sandbox/workbenchCommonProperties';
import { TelemetryService as BaseTelemetryService, ITelemetryServiceConfig } from 'vs/platform/telemetry/common/telemetryService';
import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
import { ClassifiedEvent, StrictPropertyCheck, GDPRClassification } from 'vs/platform/telemetry/common/gdprTypings';
import { ClassifiedEvent, StrictPropertyCheck, OmitMetadata, IGDPRProperty } from 'vs/platform/telemetry/common/gdprTypings';
import { IFileService } from 'vs/platform/files/common/files';
import { IObservableValue } from 'vs/base/common/observableValue';
@ -66,7 +66,7 @@ export class TelemetryService extends Disposable implements ITelemetryService {
return this.impl.publicLog(eventName, data, anonymizeFilePaths);
}
publicLog2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>, anonymizeFilePaths?: boolean) {
publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>, anonymizeFilePaths?: boolean) {
return this.publicLog(eventName, data as ITelemetryData, anonymizeFilePaths);
}
@ -74,7 +74,7 @@ export class TelemetryService extends Disposable implements ITelemetryService {
return this.impl.publicLogError(errorEventName, data);
}
publicLogError2<E extends ClassifiedEvent<T> = never, T extends GDPRClassification<T> = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
return this.publicLog(eventName, data as ITelemetryData);
}

2
src/vs/workbench/services/timer/browser/timerService.ts
View file

@ -534,7 +534,7 @@ export abstract class AbstractTimerService implements ITimerService {
source: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'Where this marker was generated, e.g main, renderer, extension host' };
name: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'The name of this marker (as defined in source code)' };
relativeStartTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'The duration between the previous and this marker' };
startTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comments: 'The absolute timestamp (unix time)' };
startTime: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'The absolute timestamp (unix time)' };
};
let lastMark: perf.PerformanceMark = marks[0];