agentHostTelemetryService.ts ×29

Frontier kind: Code frontier

unlabeled · c_d70ba9dec996

685 tests · 17579 LOC · 87 files · introduces 0 tests · 335 LOC · 3 files

Introduces — evidence that enters the hierarchy at this concept

Code
47 ranges335 lines · 3 files
Tests
0 tests

Contains — complete concept membership

All code (extent)
2087 ranges17579 lines · 87 files · Browse complete extent
All tests (intent)
685 testsBrowse complete intent

Neighbourhood graph

The orange circle is the focus. Violet and green circles are every ancestor and descendant, broader and narrower, at any distance; blue squares and pink diamonds are the introduced files and exact introduced tests of every visible concept, not only the focus's. Arrows point from broader to narrower concepts and bridge only concepts omitted from this view. Undirected links show source or test introduction. Concept and file size follows LOC; exact test nodes use test-count units.

Introduced files, introduced tests, and structurally relevant concept specialization

In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the native relationship evidence on this page.

Graph controls are ready.

Interactive rendering requires JavaScript and WebGL. Use the native relationship evidence on this page while the interactive map is unavailable.

Native relationship evidence

Every exact file and test below is linked only from the concept that introduces it.

Introduced tests

Every collected test enters the hierarchy at exactly one concept.

No tests are introduced at this concept. Its intent tests are introduced by other concepts.

Introduced code

Every collected source range enters the hierarchy at exactly one concept.

3 files ranked by introduced lines: 335 introduced LOC across 47 ranges. Expand a file to inspect source; the > gutter marks introduced lines.

src/vs/platform/telemetry/common/telemetryService.ts 218 introduced LOC · 17 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- telemetryService.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { DisposableStore } from '../../../base/common/lifecycle.js';
7 > import { mixin } from '../../../base/common/objects.js';
8 > import { isWeb } from '../../../base/common/platform.js';
9 > import { PolicyCategory } from '../../../base/common/policy.js';
10 > import { escapeRegExpCharacters } from '../../../base/common/strings.js';
11 > import { localize } from '../../../nls.js';
12 > import { IConfigurationService } from '../../configuration/common/configuration.js';
13 > import { ConfigurationScope, Extensions, IConfigurationRegistry } from '../../configuration/common/configurationRegistry.js';
14 > import { IMeteredConnectionService } from '../../meteredConnection/common/meteredConnection.js';
15 > import product from '../../product/common/product.js';
16 > import { IProductService } from '../../product/common/productService.js';
17 > import { Registry } from '../../registry/common/platform.js';
18 > import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from './gdprTypings.js';
19 > import { ITelemetryData, ITelemetryService, TelemetryConfiguration, TelemetryLevel, TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_OLD_SETTING_ID, TELEMETRY_SECTION_ID, TELEMETRY_SETTING_ID, ICommonProperties } from './telemetry.js';
20 > import { cleanData, getTelemetryLevel, ITelemetryAppender, TelemetryTrustedValue } from './telemetryUtils.js';
21 >
22 > export interface ITelemetryServiceConfig {
23 > appenders: ITelemetryAppender[];
24 > sendErrorTelemetry?: boolean;
25 > commonProperties?: ICommonProperties;
26 > piiPaths?: string[];
27 > /**
28 > * If true, telemetry events will be buffered until setExperimentProperty is called
29 > * (up to 10 seconds) to ensure experiment context is attached to all events.
30 > */
31 > waitForExperimentProperties?: boolean;
32 > /**
33 > * If provided, telemetry events will be dropped when the connection is metered.
34 > */
35 > meteredConnectionService?: IMeteredConnectionService;
36 > }
37 >
38 > interface IPendingEvent {
39 > eventName: string;
40 > eventLevel: TelemetryLevel;
41 > data: ITelemetryData | undefined;
42 > }
43 >
44 > export class TelemetryService implements ITelemetryService {
45 >
46 > static readonly IDLE_START_EVENT_NAME = 'UserIdleStart';
47 > static readonly IDLE_STOP_EVENT_NAME = 'UserIdleStop';
48 >
49 > private static readonly BUFFER_FLUSH_TIMEOUT = 10000; // 10 seconds
50 > private static readonly MAX_BUFFER_SIZE = 1000;
51 >
52 > declare readonly _serviceBrand: undefined;
53 >
54 > readonly sessionId: string;
55 > readonly machineId: string;
56 > readonly sqmId: string;
57 > readonly devDeviceId: string;
58 > readonly firstSessionDate: string;
59 > readonly msftInternal: boolean | undefined;
60 >
61 > private _appenders: ITelemetryAppender[];
62 > private _commonProperties: ICommonProperties;
63 > private _experimentProperties: { [name: string]: string | TelemetryTrustedValue<string> } = {};
64 > private _piiPaths: string[];
65 > private _telemetryLevel: TelemetryLevel;
66 > private _sendErrorTelemetry: boolean;
67 >
68 > private readonly _meteredConnectionService: IMeteredConnectionService | undefined;
69 >
70 > private _pendingEvents: IPendingEvent[] = [];
71 > private _isExperimentPropertySet = false;
72 > private _flushTimeout: ReturnType<typeof setTimeout> | undefined;
73 >
74 > private readonly _disposables = new DisposableStore();
75 > private _cleanupPatterns: RegExp[] = [];
76 >
77 > constructor(
78 config: ITelemetryServiceConfig,
79 @IConfigurationService private _configurationService: IConfigurationService,
126 }
127 }
129 > setExperimentProperty(name: string, value: string): void {
130 this._experimentProperties[name] = new TelemetryTrustedValue(value);
131
135 }
136 }
138 > setCommonProperty(name: string, value: string | boolean): void {
139 this._commonProperties[name] = value;
140 }
142 > private _flushPendingEvents(): void {
143 if (this._isExperimentPropertySet) {
144 return;
158 this._pendingEvents = [];
159 }
161 > private _updateTelemetryLevel(): void {
162 let level = getTelemetryLevel(this._configurationService);
163 const collectableTelemetry = this._productService.enabledTelemetryLevels;
172 this._telemetryLevel = level;
173 }
175 > get sendErrorTelemetry(): boolean {
176 return this._sendErrorTelemetry;
177 }
179 > get telemetryLevel(): TelemetryLevel {
180 return this._telemetryLevel;
181 }
183 > dispose(): void {
184 // Flush any remaining pending events before disposing
185 this._flushPendingEvents();
186 this._disposables.dispose();
187 }
189 > private _log(eventName: string, eventLevel: TelemetryLevel, data?: ITelemetryData) {
190 // don't send events when the user is optout
191 if (this._telemetryLevel < eventLevel) {
208 this._doLog(eventName, eventLevel, data);
209 }
211 > private _doLog(eventName: string, eventLevel: TelemetryLevel, data?: ITelemetryData) {
212 // add experiment properties
213 data = mixin(data, this._experimentProperties);
227 this._appenders.forEach(a => a.log(eventName, data ?? {}));
228 }
230 > publicLog(eventName: string, data?: ITelemetryData) {
231 this._log(eventName, TelemetryLevel.USAGE, data);
232 }
234 > publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
235 this.publicLog(eventName, data as ITelemetryData);
236 }
238 > publicLogError(errorEventName: string, data?: ITelemetryData) {
239 if (!this._sendErrorTelemetry) {
240 return;
244 this._log(errorEventName, TelemetryLevel.ERROR, data);
245 }
247 > publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>) {
248 this.publicLogError(eventName, data as ITelemetryData);
249 }
251 >
252 > function getTelemetryLevelSettingDescription(): string {
253 > const telemetryText = localize('telemetry.telemetryLevelMd', "Controls {0} telemetry, first-party extension telemetry, and participating third-party extension telemetry. Some third party extensions might not respect this setting. Consult the specific extension's documentation to be sure. Telemetry helps us better understand how {0} is performing, where improvements need to be made, and how features are being used.", product.nameLong);
254 > const externalLinksStatement = !product.privacyStatementUrl ?
255 > localize("telemetry.docsStatement", "Read more about the [data we collect]({0}).", 'https://aka.ms/vscode-telemetry') :
256 localize("telemetry.docsAndPrivacyStatement", "Read more about the [data we collect]({0}) and our [privacy statement]({1}).", 'https://aka.ms/vscode-telemetry', product.privacyStatementUrl);
257 > const restartString = !isWeb ? localize('telemetry.restart', 'A full restart of the application is necessary for crash reporting changes to take effect.') : ''; telemetryService.ts
258 >
259 > const crashReportsHeader = localize('telemetry.crashReports', "Crash Reports");
260 > const errorsHeader = localize('telemetry.errors', "Error Telemetry");
261 > const usageHeader = localize('telemetry.usage', "Usage Data");
262 >
263 > const telemetryTableDescription = localize('telemetry.telemetryLevel.tableDescription', "The following table outlines the data sent with each setting:");
264 > const telemetryTable = `
265 > | | ${crashReportsHeader} | ${errorsHeader} | ${usageHeader} |
266 > |:------|:-------------:|:---------------:|:----------:|
267 > | all | ✓ | ✓ | ✓ |
268 > | error | ✓ | ✓ | - |
269 > | crash | ✓ | - | - |
270 > | off | - | - | - |
271 > `;
272 >
273 > const deprecatedSettingNote = localize('telemetry.telemetryLevel.deprecated', "****Note:*** If this setting is 'off', no telemetry will be sent regardless of other telemetry settings. If this setting is set to anything except 'off' and telemetry is disabled with deprecated settings, no telemetry will be sent.*");
274 > const telemetryDescription = `
275 > ${telemetryText} ${externalLinksStatement} ${restartString}
276 >
277 > &nbsp;
278 >
279 > ${telemetryTableDescription}
280 > ${telemetryTable}
281 >
282 > &nbsp;
283 >
284 > ${deprecatedSettingNote}
285 > `;
286 >
287 > return telemetryDescription;
288 > }
289 >
290 > const configurationRegistry = Registry.as<IConfigurationRegistry>(Extensions.Configuration);
291 > configurationRegistry.registerConfiguration({
292 > 'id': TELEMETRY_SECTION_ID,
293 > 'order': 1,
294 > 'type': 'object',
295 > 'title': localize('telemetryConfigurationTitle', "Telemetry"),
296 > 'properties': {
297 > [TELEMETRY_SETTING_ID]: {
298 > 'type': 'string',
299 > 'enum': [TelemetryConfiguration.ON, TelemetryConfiguration.ERROR, TelemetryConfiguration.CRASH, TelemetryConfiguration.OFF],
300 > 'enumDescriptions': [
301 > localize('telemetry.telemetryLevel.default', "Sends usage data, errors, and crash reports."),
302 > localize('telemetry.telemetryLevel.error', "Sends general error telemetry and crash reports."),
303 > localize('telemetry.telemetryLevel.crash', "Sends OS level crash reports."),
304 > localize('telemetry.telemetryLevel.off', "Disables all product telemetry.")
305 > ],
306 > 'markdownDescription': getTelemetryLevelSettingDescription(),
307 > 'default': TelemetryConfiguration.ON,
308 > 'restricted': true,
309 > 'scope': ConfigurationScope.APPLICATION,
310 > 'tags': ['usesOnlineServices', 'telemetry'],
311 > 'policy': {
312 > name: 'TelemetryLevel',
313 > category: PolicyCategory.Telemetry,
314 > minimumVersion: '1.99',
315 > localization: {
316 > description: {
317 > key: 'telemetry.telemetryLevel.policyDescription',
318 > value: localize('telemetry.telemetryLevel.policyDescription', "Controls the level of telemetry."),
319 > },
320 > enumDescriptions: [
321 > {
322 > key: 'telemetry.telemetryLevel.default',
323 > value: localize('telemetry.telemetryLevel.default', "Sends usage data, errors, and crash reports."),
324 > },
325 > {
326 > key: 'telemetry.telemetryLevel.error',
327 > value: localize('telemetry.telemetryLevel.error', "Sends general error telemetry and crash reports."),
328 > },
329 > {
330 > key: 'telemetry.telemetryLevel.crash',
331 > value: localize('telemetry.telemetryLevel.crash', "Sends OS level crash reports."),
332 > },
333 > {
334 > key: 'telemetry.telemetryLevel.off',
335 > value: localize('telemetry.telemetryLevel.off', "Disables all product telemetry."),
336 > }
337 > ]
338 > }
339 > }
340 > },
341 > 'telemetry.feedback.enabled': {
342 > type: 'boolean',
343 > default: true,
344 > description: localize('telemetry.feedback.enabled', "Enable feedback mechanisms such as the issue reporter, surveys, and other feedback options."),
345 > policy: {
346 > name: 'EnableFeedback',
347 > category: PolicyCategory.Telemetry,
348 > minimumVersion: '1.99',
349 > localization: { description: { key: 'telemetry.feedback.enabled', value: localize('telemetry.feedback.enabled', "Enable feedback mechanisms such as the issue reporter, surveys, and other feedback options.") } },
350 > }
351 > },
352 > // Deprecated telemetry setting
353 > [TELEMETRY_OLD_SETTING_ID]: {
354 > 'type': 'boolean',
355 > 'markdownDescription':
356 > !product.privacyStatementUrl ?
357 > localize('telemetry.enableTelemetry', "Enable diagnostic data to be collected. This helps us to better understand how {0} is performing and where improvements need to be made.", product.nameLong) :
358 localize('telemetry.enableTelemetryMd', "Enable diagnostic data to be collected. This helps us to better understand how {0} is performing and where improvements need to be made. [Read more]({1}) about what we collect and our privacy statement.", product.nameLong, product.privacyStatementUrl),
359 > 'default': true, telemetryService.ts
360 > 'restricted': true,
361 > 'markdownDeprecationMessage': localize('enableTelemetryDeprecated', "If this setting is false, no telemetry will be sent regardless of the new setting's value. Deprecated in favor of the {0} setting.", `\`#${TELEMETRY_SETTING_ID}#\``),
362 > 'scope': ConfigurationScope.APPLICATION,
363 > 'tags': ['usesOnlineServices', 'telemetry']
364 > }
365 > },
366 > });
src/vs/platform/agentHost/node/agentHostTelemetryService.ts 114 introduced LOC · 29 ranges

Open complete file

1 > /*--------------------------------------------------------------------------------------------- agentHostTelemetryService.ts
2 > * Copyright (c) Microsoft Corporation. All rights reserved.
3 > * Licensed under the MIT License. See License.txt in the project root for license information.
4 > *--------------------------------------------------------------------------------------------*/
5 >
6 > import { hostname, release } from 'os';
7 > import { Disposable, isDisposable, toDisposable, type DisposableStore } from '../../../base/common/lifecycle.js';
8 > import { joinPath } from '../../../base/common/resources.js';
9 > import { URI } from '../../../base/common/uri.js';
10 > import { getDevDeviceId, getMachineId, getSqmMachineId } from '../../../base/node/id.js';
11 > import { ConfigurationService } from '../../configuration/common/configurationService.js';
12 > import { INativeEnvironmentService } from '../../environment/common/environment.js';
13 > import { IFileService } from '../../files/common/files.js';
14 > import { ILogService, ILoggerService } from '../../log/common/log.js';
15 > import { NullPolicyService } from '../../policy/common/policy.js';
16 > import { IProductService } from '../../product/common/productService.js';
17 > import { IRequestService } from '../../request/common/request.js';
18 > import { OneDataSystemAppender } from '../../telemetry/node/1dsAppender.js';
19 > import { resolveCommonProperties } from '../../telemetry/common/commonProperties.js';
20 > import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from '../../telemetry/common/gdprTypings.js';
21 > import { ITelemetryData, ITelemetryService, TelemetryLevel } from '../../telemetry/common/telemetry.js';
22 > import { TelemetryLogAppender } from '../../telemetry/common/telemetryLogAppender.js';
23 > import { TelemetryService } from '../../telemetry/common/telemetryService.js';
24 > import { getPiiPathsFromEnvironment, isInternalTelemetry, isLoggingOnly, NullTelemetryService, supportsTelemetry, type ITelemetryAppender } from '../../telemetry/common/telemetryUtils.js';
25 > import { AgentHostTelemetryLevelConfigKey, agentHostConfigValueToTelemetryLevel } from '../common/agentHostSchema.js';
26 > import { AgentHostDevDeviceIdEnvKey, AgentHostMachineIdEnvKey, AgentHostSqmIdEnvKey } from '../common/agentHostTelemetryEnv.js';
27 > import { AgentHostRestrictedTelemetrySender, IAgentHostRestrictedTelemetry, IAgentHostInternalTelemetryContext, IAgentHostRestrictedTelemetryContext, TelemetryMeasurements, TelemetryProps } from './agentHostRestrictedTelemetry.js';
28 > import { AgentHostInternalTelemetrySender } from './agentHostMicrosoftTelemetry.js';
29 >
30 > export interface IAgentHostTelemetryServiceOptions {
31 > readonly environmentService: INativeEnvironmentService;
32 > readonly productService: IProductService;
33 > readonly fileService: IFileService;
34 > readonly loggerService: ILoggerService | undefined;
35 > readonly logService: ILogService;
36 > readonly disposables: DisposableStore;
37 > readonly disableTelemetry?: boolean;
38 > readonly fetchFn?: typeof globalThis.fetch;
39 > readonly requestService?: IRequestService;
40 > }
41 >
42 > export interface IAgentHostTelemetryService extends ITelemetryService, IAgentHostRestrictedTelemetry {
43 > updateTelemetryLevel(telemetryLevel: TelemetryLevel): void;
44 > }
45 >
46 > export class AgentHostTelemetryService extends Disposable implements IAgentHostTelemetryService {
47 > declare readonly _serviceBrand: undefined;
48 >
49 > private _telemetryLevel = TelemetryLevel.USAGE;
50 >
51 > /**
52 > * Whether the current Copilot token opts into enhanced/restricted telemetry (`rt=1`). Defaults
53 > * to `false` so nothing restricted is sent until an authenticated token confirms the opt-in,
54 > * keeping public users off the enhanced pipeline the way the Copilot extension does.
55 > */
56 > private _restrictedTelemetryEnabled = false;
57 > private _internalTelemetryEnabled = false;
58 >
59 > constructor(
60 private readonly _delegate: ITelemetryService,
61 private readonly _restricted?: IAgentHostRestrictedTelemetry,
66 }
67 }
69 > get telemetryLevel(): TelemetryLevel {
70 return Math.min(this._delegate.telemetryLevel, this._telemetryLevel);
71 }
73 > get sendErrorTelemetry(): boolean {
74 return this.telemetryLevel >= TelemetryLevel.ERROR && this._delegate.sendErrorTelemetry;
75 }
77 > get sessionId(): string {
78 return this._delegate.sessionId;
79 }
81 > get machineId(): string {
82 return this._delegate.machineId;
83 }
85 > get sqmId(): string {
86 return this._delegate.sqmId;
87 }
89 > get devDeviceId(): string {
90 return this._delegate.devDeviceId;
91 }
93 > get firstSessionDate(): string {
94 return this._delegate.firstSessionDate;
95 }
97 > get msftInternal(): boolean | undefined {
98 return this._delegate.msftInternal;
99 }
101 > publicLog(eventName: string, data?: ITelemetryData): void {
102 if (this.telemetryLevel < TelemetryLevel.USAGE) {
103 return;
105 this._delegate.publicLog(eventName, data);
106 }
108 > publicLogError(eventName: string, data?: ITelemetryData): void {
109 if (this.telemetryLevel < TelemetryLevel.ERROR) {
110 return;
112 this._delegate.publicLogError(eventName, data);
113 }
115 > publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void {
116 if (this.telemetryLevel < TelemetryLevel.USAGE) {
117 return;
119 this._delegate.publicLog2(eventName, data);
120 }
122 > publicLogError2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void {
123 if (this.telemetryLevel < TelemetryLevel.ERROR) {
124 return;
126 this._delegate.publicLogError2(eventName, data);
127 }
129 > sendGHTelemetryEvent(eventName: string, properties?: TelemetryProps, measurements?: TelemetryMeasurements): void {
130 if (this.telemetryLevel < TelemetryLevel.USAGE) {
131 return;
133 this._restricted?.sendGHTelemetryEvent(eventName, properties, measurements);
134 }
136 > sendEnhancedGHTelemetryEvent(eventName: string, properties?: TelemetryProps, measurements?: TelemetryMeasurements): void {
137 if (this.telemetryLevel < TelemetryLevel.USAGE || !this._restrictedTelemetryEnabled) {
138 return;
140 this._restricted?.sendEnhancedGHTelemetryEvent(eventName, properties, measurements);
141 }
143 > sendEnhancedGHTelemetryEventForContext(context: IAgentHostRestrictedTelemetryContext, eventName: string, properties?: TelemetryProps, measurements?: TelemetryMeasurements): void {
144 if (this.telemetryLevel < TelemetryLevel.USAGE || !context.restrictedTelemetryEnabled) {
145 return;
147 this._restricted?.sendEnhancedGHTelemetryEventForContext(context, eventName, properties, measurements);
148 }
150 > sendInternalMSFTTelemetryEvent(eventName: string, properties?: TelemetryProps, measurements?: TelemetryMeasurements): void {
151 if (this.telemetryLevel < TelemetryLevel.USAGE || !this._internalTelemetryEnabled) {
152 return;
154 this._restricted?.sendInternalMSFTTelemetryEvent(eventName, properties, measurements);
155 }
157 > sendInternalMSFTTelemetryEventForContext(context: IAgentHostInternalTelemetryContext, eventName: string, properties?: TelemetryProps, measurements?: TelemetryMeasurements): void {
158 if (this.telemetryLevel < TelemetryLevel.USAGE || !context.isInternal) {
159 return;
161 this._restricted?.sendInternalMSFTTelemetryEventForContext(context, eventName, properties, measurements);
162 }
164 > setCopilotTrackingId(trackingId: string | undefined): void {
165 this._restricted?.setCopilotTrackingId(trackingId);
166 }
168 > setRestrictedTelemetryEndpoint(endpointUrl: string | undefined): void {
169 this._restricted?.setRestrictedTelemetryEndpoint(endpointUrl);
170 }
172 > setRestrictedTelemetryEnabled(enabled: boolean): void {
173 this._restrictedTelemetryEnabled = enabled;
174 // Mirror onto the sender so the restricted-table writer enforces the same `rt` gate
176 this._restricted?.setRestrictedTelemetryEnabled(enabled);
177 }
179 > setInternalTelemetryContext(context: IAgentHostInternalTelemetryContext | undefined): void {
180 this._internalTelemetryEnabled = context?.isInternal === true;
181 this._restricted?.setInternalTelemetryContext(context);
182 }
184 > setExperimentProperty(name: string, value: string): void {
185 this._delegate.setExperimentProperty(name, value);
186 }
188 > setCommonProperty(name: string, value: string | boolean): void {
189 this._delegate.setCommonProperty(name, value);
190 }
192 > updateTelemetryLevel(telemetryLevel: TelemetryLevel): void {
193 this._telemetryLevel = Math.min(this._telemetryLevel, telemetryLevel);
194 }
196 >
197 > export function updateAgentHostTelemetryLevelFromConfig(telemetryService: ITelemetryService, config: Record<string, unknown> | undefined): void {
198 const telemetryLevel = config?.[AgentHostTelemetryLevelConfigKey];
199 const telemetryLevelValue = agentHostConfigValueToTelemetryLevel(telemetryLevel);
203 telemetryService.updateTelemetryLevel(telemetryLevelValue);
204 }
206 > export function isAgentHostTelemetryService(telemetryService: ITelemetryService): telemetryService is IAgentHostTelemetryService {
207 return typeof (telemetryService as IAgentHostTelemetryService).updateTelemetryLevel === 'function';
208 }
210 async function resolveCopilotExtensionVersion(environmentService: INativeEnvironmentService, fileService: IFileService, logService: ILogService): Promise<string | undefined> {
211 if (!environmentService.builtinExtensionsPath) {
220 }
221 }
223 export async function createAgentHostTelemetryService(options: IAgentHostTelemetryServiceOptions): Promise<IAgentHostTelemetryService> {
224 const { environmentService, productService, fileService, loggerService, logService, disposables } = options;
src/vs/platform/configuration/common/configurationRegistry.ts 3 introduced LOC · 1 range

Open complete file

790 this.configurationProperties[key] = properties[key];
791 if (!properties[key].deprecationMessage && properties[key].markdownDeprecationMessage) {
792 > // If not set, default deprecationMessage to the markdown source configurationRegistry.ts
793 > properties[key].deprecationMessage = properties[key].markdownDeprecationMessage;
794 > }
795 }
796