src/vs/platform/log/common/log.ts
926 LOC · 570 covered · 356 uncovered · 108 ranges · 10775 concepts · 15 introducers · 5601 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
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 related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
log.ts ×72
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 * as nls from '../../../nls.js';
7
>
import { toErrorMessage } from '../../../base/common/errorMessage.js';
8
>
import { Emitter, Event } from '../../../base/common/event.js';
9
>
import { hash } from '../../../base/common/hash.js';
10
>
import { Disposable, IDisposable, toDisposable } from '../../../base/common/lifecycle.js';
11
>
import { ResourceMap } from '../../../base/common/map.js';
12
>
import { isWindows } from '../../../base/common/platform.js';
13
>
import { joinPath } from '../../../base/common/resources.js';
14
>
import { Mutable, isNumber, isString } from '../../../base/common/types.js';
15
>
import { URI } from '../../../base/common/uri.js';
16
>
import { ILocalizedString } from '../../action/common/action.js';
17
>
import { RawContextKey } from '../../contextkey/common/contextkey.js';
18
>
import { IEnvironmentService } from '../../environment/common/environment.js';
19
>
import { createDecorator } from '../../instantiation/common/instantiation.js';
20
>
21
>
export const ILogService = createDecorator<ILogService>('logService');
22
>
export const ILoggerService = createDecorator<ILoggerService>('loggerService');
23
>
24
function now(): string {
25
return new Date().toISOString();
26
}
28
>
export function isLogLevel(thing: unknown): thing is LogLevel {
29
return isNumber(thing);
30
}
32
>
export enum LogLevel {
33
>
Off,
34
>
Trace,
35
>
Debug,
36
>
Info,
37
>
Warning,
38
>
Error
39
>
}
40
>
41
>
export const DEFAULT_LOG_LEVEL: LogLevel = LogLevel.Info;
42
>
43
>
export interface ILogger extends IDisposable {
44
>
readonly onDidChangeLogLevel: Event<LogLevel>;
45
>
getLevel(): LogLevel;
46
>
setLevel(level: LogLevel): void;
47
>
48
>
trace(message: string, ...args: unknown[]): void;
49
>
debug(message: string, ...args: unknown[]): void;
50
>
info(message: string, ...args: unknown[]): void;
51
>
warn(message: string, ...args: unknown[]): void;
52
>
error(message: string | Error, ...args: unknown[]): void;
53
>
54
>
/**
55
>
* An operation to flush the contents. Can be synchronous.
56
>
*/
57
>
flush(): void;
58
>
}
59
>
60
>
export function canLog(loggerLevel: LogLevel, messageLevel: LogLevel): boolean {
62
>
}
64
>
export function log(logger: ILogger, level: LogLevel, message: string): void {
66
>
case LogLevel.Trace: logger.trace(message); break;
67
>
case LogLevel.Debug: logger.debug(message); break;
68
>
case LogLevel.Info: logger.info(message); break;
69
>
case LogLevel.Warning: logger.warn(message); break;
70
>
case LogLevel.Error: logger.error(message); break;
71
>
case LogLevel.Off: /* do nothing */ break;
72
>
default: throw new Error(`Invalid log level ${level}`);
73
>
}
74
>
}
76
>
type ConsoleMethod = 'debug' | 'error' | 'info' | 'log' | 'warn';
77
>
type ConsoleMethodFn = (...args: unknown[]) => void;
78
>
79
>
/**
80
>
* Flag to enable forwarding of console.* calls to the log service in development.
81
>
* This is intended for the use of agents to quickly instrument the code with console.logs
82
>
* which will end up in the log service's file outputs.
83
>
*/
84
>
export const isDevConsoleLogForwardingEnabled = false
85
>
// || Boolean("true") // done "weirdly" so that a lint warning prevents you from pushing this
86
>
;
87
>
88
>
let isConsoleForwarding = false;
89
>
let isLogServiceConsoleEcho = false;
90
>
91
function getConsoleMethod(method: ConsoleMethod): ConsoleMethodFn {
92
switch (method) {
93
case 'debug': return console.debug;
94
case 'error': return console.error;
95
case 'info': return console.info;
96
case 'log': return console.log;
97
case 'warn': return console.warn;
98
}
99
}
101
function setConsoleMethod(method: ConsoleMethod, fn: ConsoleMethodFn): void {
102
switch (method) {
103
case 'debug': console.debug = fn; break;
104
case 'error': console.error = fn; break;
105
case 'info': console.info = fn; break;
106
case 'log': console.log = fn; break;
107
case 'warn': console.warn = fn; break;
108
}
109
}
111
function logToConsole(method: ConsoleMethod, ...args: unknown[]): void {
112
if (isConsoleForwarding) {
113
return;
114
}
115
isLogServiceConsoleEcho = true;
116
try {
117
getConsoleMethod(method).apply(console, args);
118
} finally {
119
isLogServiceConsoleEcho = false;
120
}
121
}
123
>
export function registerDevConsoleLogForwarder(logService: ILogService): IDisposable {
124
const originalConsoleMethods: Record<ConsoleMethod, ConsoleMethodFn> = {
125
debug: console.debug,
126
error: console.error,
127
info: console.info,
128
log: console.log,
129
warn: console.warn
130
};
131
132
const forward = (method: ConsoleMethod, level: LogLevel, args: unknown[]): void => {
133
if (!isLogServiceConsoleEcho) {
134
isConsoleForwarding = true;
135
try {
136
log(logService, level, format(args));
137
} catch {
138
// Best-effort development logging must not break normal console semantics.
139
} finally {
140
isConsoleForwarding = false;
141
}
142
}
143
144
originalConsoleMethods[method].apply(console, args);
145
};
146
147
const wrappers: Record<ConsoleMethod, ConsoleMethodFn> = {
148
debug: (...args: unknown[]) => forward('debug', LogLevel.Debug, args),
149
error: (...args: unknown[]) => forward('error', LogLevel.Error, args),
150
info: (...args: unknown[]) => forward('info', LogLevel.Info, args),
151
log: (...args: unknown[]) => forward('log', LogLevel.Info, args),
152
warn: (...args: unknown[]) => forward('warn', LogLevel.Warning, args)
153
};
154
155
setConsoleMethod('debug', wrappers.debug);
156
setConsoleMethod('error', wrappers.error);
157
setConsoleMethod('info', wrappers.info);
158
setConsoleMethod('log', wrappers.log);
159
setConsoleMethod('warn', wrappers.warn);
160
161
return toDisposable(() => {
162
if (console.debug === wrappers.debug) {
163
console.debug = originalConsoleMethods.debug;
164
}
165
if (console.error === wrappers.error) {
166
console.error = originalConsoleMethods.error;
167
}
168
if (console.info === wrappers.info) {
169
console.info = originalConsoleMethods.info;
170
}
171
if (console.log === wrappers.log) {
172
console.log = originalConsoleMethods.log;
173
}
174
if (console.warn === wrappers.warn) {
175
console.warn = originalConsoleMethods.warn;
176
}
177
});
178
}
180
>
export function format(args: any, verbose: boolean = false): string {
182
>
183
>
for (let i = 0; i < args.length; i++) {
184
>
let a = args[i];
185
>
186
>
if (a instanceof Error) {
187
a = toErrorMessage(a, verbose);
188
}
190
>
if (typeof a === 'object') {
191
try {
192
a = JSON.stringify(a);
193
} catch (e) { }
194
}
196
>
result += (i > 0 ? ' ' : '') + a;
197
>
}
198
>
199
>
return result;
200
>
}
202
>
export type LoggerGroup = {
203
>
readonly id: string;
204
>
readonly name: string;
205
>
};
206
>
207
>
export interface ILogService extends ILogger {
208
>
readonly _serviceBrand: undefined;
209
>
}
210
>
211
>
export interface ILoggerOptions {
212
>
213
>
/**
214
>
* Id of the logger.
215
>
*/
216
>
id?: string;
217
>
218
>
/**
219
>
* Name of the logger.
220
>
*/
221
>
name?: string;
222
>
223
>
/**
224
>
* Do not create rotating files if max size exceeds.
225
>
*/
226
>
donotRotate?: boolean;
227
>
228
>
/**
229
>
* Do not use formatters.
230
>
*/
231
>
donotUseFormatters?: boolean;
232
>
233
>
/**
234
>
* When to log. Set to `always` to log always.
235
>
*/
236
>
logLevel?: 'always' | LogLevel;
237
>
238
>
/**
239
>
* Whether the log should be hidden from the user.
240
>
*/
241
>
hidden?: boolean;
242
>
243
>
/**
244
>
* Condition which must be true to show this logger
245
>
*/
246
>
when?: string;
247
>
248
>
/**
249
>
* Id of the extension that created this logger.
250
>
*/
251
>
extensionId?: string;
252
>
253
>
/**
254
>
* Group of the logger.
255
>
*/
256
>
group?: LoggerGroup;
257
>
}
258
>
259
>
export interface ILoggerResource {
260
>
readonly resource: URI;
261
>
readonly id: string;
262
>
readonly name?: string;
263
>
readonly logLevel?: LogLevel;
264
>
readonly hidden?: boolean;
265
>
readonly when?: string;
266
>
readonly extensionId?: string;
267
>
readonly group?: LoggerGroup;
268
>
}
269
>
270
>
export type DidChangeLoggersEvent = {
271
>
readonly added: Iterable<ILoggerResource>;
272
>
readonly removed: Iterable<ILoggerResource>;
273
>
};
274
>
275
>
export interface ILoggerService {
276
>
277
>
readonly _serviceBrand: undefined;
278
>
279
>
/**
280
>
* Creates a logger for the given resource, or gets one if it already exists.
281
>
*
282
>
* This will also register the logger with the logger service.
283
>
*/
284
>
createLogger(resource: URI, options?: ILoggerOptions): ILogger;
285
>
286
>
/**
287
>
* Creates a logger with the given id in the logs folder, or gets one if it already exists.
288
>
*
289
>
* This will also register the logger with the logger service.
290
>
*/
291
>
createLogger(id: string, options?: Omit<ILoggerOptions, 'id'>): ILogger;
292
>
293
>
/**
294
>
* Gets an existing logger, if any.
295
>
*/
296
>
getLogger(resourceOrId: URI | string): ILogger | undefined;
297
>
298
>
/**
299
>
* An event which fires when the log level of a logger has changed
300
>
*/
301
>
readonly onDidChangeLogLevel: Event<LogLevel | [URI, LogLevel]>;
302
>
303
>
/**
304
>
* Set default log level.
305
>
*/
306
>
setLogLevel(level: LogLevel): void;
307
>
308
>
/**
309
>
* Set log level for a logger.
310
>
*/
311
>
setLogLevel(resource: URI, level: LogLevel): void;
312
>
313
>
/**
314
>
* Get log level for a logger or the default log level.
315
>
*/
316
>
getLogLevel(resource?: URI): LogLevel;
317
>
318
>
/**
319
>
* An event which fires when the visibility of a logger has changed
320
>
*/
321
>
readonly onDidChangeVisibility: Event<[URI, boolean]>;
322
>
323
>
/**
324
>
* Set the visibility of a logger.
325
>
*/
326
>
setVisibility(resourceOrId: URI | string, visible: boolean): void;
327
>
328
>
/**
329
>
* An event which fires when the logger resources are changed
330
>
*/
331
>
readonly onDidChangeLoggers: Event<DidChangeLoggersEvent>;
332
>
333
>
/**
334
>
* Register a logger with the logger service.
335
>
*
336
>
* Note that this will not create a logger, but only register it.
337
>
*
338
>
* Use `createLogger` to create a logger and register it.
339
>
*
340
>
* Use it when you want to register a logger that is not created by the logger service.
341
>
*/
342
>
registerLogger(resource: ILoggerResource): void;
343
>
344
>
/**
345
>
* Deregister the logger for the given resource.
346
>
*/
347
>
deregisterLogger(idOrResource: URI | string): void;
348
>
349
>
/**
350
>
* Get all registered loggers
351
>
*/
352
>
getRegisteredLoggers(): Iterable<ILoggerResource>;
353
>
354
>
/**
355
>
* Get the registered logger for the given resource.
356
>
*/
357
>
getRegisteredLogger(resource: URI): ILoggerResource | undefined;
358
>
}
359
>
360
>
export abstract class AbstractLogger extends Disposable implements ILogger {
362
>
private level: LogLevel = DEFAULT_LOG_LEVEL;
363
>
private readonly _onDidChangeLogLevel: Emitter<LogLevel> = this._register(new Emitter<LogLevel>());
364
>
get onDidChangeLogLevel(): Event<LogLevel> { return this._onDidChangeLogLevel.event; }
log.ts ×72
365
>
366
>
setLevel(level: LogLevel): void {
369
>
this._onDidChangeLogLevel.fire(this.level);
370
>
}
373
>
getLevel(): LogLevel {
375
>
}
377
>
protected checkLogLevel(level: LogLevel): boolean {
379
>
}
381
>
protected canLog(level: LogLevel): boolean {
383
return false;
384
}
386
>
}
388
>
abstract trace(message: string, ...args: unknown[]): void;
389
>
abstract debug(message: string, ...args: unknown[]): void;
390
>
abstract info(message: string, ...args: unknown[]): void;
391
>
abstract warn(message: string, ...args: unknown[]): void;
392
>
abstract error(message: string | Error, ...args: unknown[]): void;
393
>
abstract flush(): void;
394
>
}
395
>
396
>
export abstract class AbstractMessageLogger extends AbstractLogger implements ILogger {
397
>
398
>
constructor(private readonly logAlways?: boolean) {
400
>
}
402
>
protected override checkLogLevel(level: LogLevel): boolean {
404
>
}
406
>
trace(message: string, ...args: unknown[]): void {
407
if (this.canLog(LogLevel.Trace)) {
408
this.log(LogLevel.Trace, format([message, ...args], true));
409
}
410
}
412
>
debug(message: string, ...args: unknown[]): void {
413
if (this.canLog(LogLevel.Debug)) {
414
this.log(LogLevel.Debug, format([message, ...args]));
415
}
416
}
418
>
info(message: string, ...args: unknown[]): void {
419
if (this.canLog(LogLevel.Info)) {
420
this.log(LogLevel.Info, format([message, ...args]));
421
}
422
}
424
>
warn(message: string, ...args: unknown[]): void {
425
if (this.canLog(LogLevel.Warning)) {
426
this.log(LogLevel.Warning, format([message, ...args]));
427
}
428
}
430
>
error(message: string | Error, ...args: unknown[]): void {
431
if (this.canLog(LogLevel.Error)) {
432
if (message instanceof Error) {
433
const array = Array.prototype.slice.call(arguments);
434
array[0] = message.stack;
435
this.log(LogLevel.Error, format(array));
436
} else {
437
this.log(LogLevel.Error, format([message, ...args]));
438
}
439
}
440
}
442
>
flush(): void { }
443
>
444
>
protected abstract log(level: LogLevel, message: string): void;
445
>
}
446
>
447
>
448
>
export class ConsoleMainLogger extends AbstractLogger implements ILogger {
449
>
450
>
private useColors: boolean;
451
>
452
>
constructor(logLevel: LogLevel = DEFAULT_LOG_LEVEL) {
453
super();
454
this.setLevel(logLevel);
455
this.useColors = !isWindows;
456
}
458
>
trace(message: string, ...args: unknown[]): void {
459
if (this.canLog(LogLevel.Trace)) {
460
if (this.useColors) {
461
logToConsole('log', `\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
462
} else {
463
logToConsole('log', `[main ${now()}]`, message, ...args);
464
}
465
}
466
}
468
>
debug(message: string, ...args: unknown[]): void {
469
if (this.canLog(LogLevel.Debug)) {
470
if (this.useColors) {
471
logToConsole('log', `\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
472
} else {
473
logToConsole('log', `[main ${now()}]`, message, ...args);
474
}
475
}
476
}
478
>
info(message: string, ...args: unknown[]): void {
479
if (this.canLog(LogLevel.Info)) {
480
if (this.useColors) {
481
logToConsole('log', `\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
482
} else {
483
logToConsole('log', `[main ${now()}]`, message, ...args);
484
}
485
}
486
}
488
>
warn(message: string | Error, ...args: unknown[]): void {
489
if (this.canLog(LogLevel.Warning)) {
490
if (this.useColors) {
491
logToConsole('warn', `\x1b[93m[main ${now()}]\x1b[0m`, message, ...args);
492
} else {
493
logToConsole('warn', `[main ${now()}]`, message, ...args);
494
}
495
}
496
}
498
>
error(message: string, ...args: unknown[]): void {
499
if (this.canLog(LogLevel.Error)) {
500
if (this.useColors) {
501
logToConsole('error', `\x1b[91m[main ${now()}]\x1b[0m`, message, ...args);
502
} else {
503
logToConsole('error', `[main ${now()}]`, message, ...args);
504
}
505
}
506
}
508
>
flush(): void {
509
// noop
510
}
512
>
}
513
>
514
>
export class ConsoleLogger extends AbstractLogger implements ILogger {
515
>
516
>
constructor(logLevel: LogLevel = DEFAULT_LOG_LEVEL, private readonly useColors: boolean = true) {
518
>
this.setLevel(logLevel);
519
>
}
521
>
trace(message: string, ...args: unknown[]): void {
522
if (this.canLog(LogLevel.Trace)) {
523
if (this.useColors) {
524
logToConsole('log', '%cTRACE', 'color: #888', message, ...args);
525
} else {
526
logToConsole('log', message, ...args);
527
}
528
}
529
}
531
>
debug(message: string, ...args: unknown[]): void {
532
if (this.canLog(LogLevel.Debug)) {
533
if (this.useColors) {
534
logToConsole('log', '%cDEBUG', 'background: #eee; color: #888', message, ...args);
535
} else {
536
logToConsole('log', message, ...args);
537
}
538
}
539
}
541
>
info(message: string, ...args: unknown[]): void {
542
if (this.canLog(LogLevel.Info)) {
543
if (this.useColors) {
544
logToConsole('log', '%c INFO', 'color: #33f', message, ...args);
545
} else {
546
logToConsole('log', message, ...args);
547
}
548
}
549
}
551
>
warn(message: string | Error, ...args: unknown[]): void {
552
if (this.canLog(LogLevel.Warning)) {
553
if (this.useColors) {
554
logToConsole('warn', '%c WARN', 'color: #993', message, ...args);
555
} else {
556
logToConsole('log', message, ...args);
557
}
558
}
559
}
561
>
error(message: string, ...args: unknown[]): void {
562
if (this.canLog(LogLevel.Error)) {
563
if (this.useColors) {
564
logToConsole('error', '%c ERR', 'color: #f33', message, ...args);
565
} else {
566
logToConsole('error', message, ...args);
567
}
568
}
569
}
571
>
572
>
flush(): void {
573
// noop
574
}
576
>
577
>
export class AdapterLogger extends AbstractLogger implements ILogger {
578
>
579
>
constructor(private readonly adapter: { log: (logLevel: LogLevel, args: any[]) => void }, logLevel: LogLevel = DEFAULT_LOG_LEVEL) {
580
super();
581
this.setLevel(logLevel);
582
}
584
>
trace(message: string, ...args: unknown[]): void {
585
if (this.canLog(LogLevel.Trace)) {
586
this.adapter.log(LogLevel.Trace, [this.extractMessage(message), ...args]);
587
}
588
}
590
>
debug(message: string, ...args: unknown[]): void {
591
if (this.canLog(LogLevel.Debug)) {
592
this.adapter.log(LogLevel.Debug, [this.extractMessage(message), ...args]);
593
}
594
}
596
>
info(message: string, ...args: unknown[]): void {
597
if (this.canLog(LogLevel.Info)) {
598
this.adapter.log(LogLevel.Info, [this.extractMessage(message), ...args]);
599
}
600
}
602
>
warn(message: string | Error, ...args: unknown[]): void {
603
if (this.canLog(LogLevel.Warning)) {
604
this.adapter.log(LogLevel.Warning, [this.extractMessage(message), ...args]);
605
}
606
}
608
>
error(message: string | Error, ...args: unknown[]): void {
609
if (this.canLog(LogLevel.Error)) {
610
this.adapter.log(LogLevel.Error, [this.extractMessage(message), ...args]);
611
}
612
}
614
>
private extractMessage(msg: string | Error): string {
615
if (typeof msg === 'string') {
616
return msg;
617
}
618
619
return toErrorMessage(msg, this.canLog(LogLevel.Trace));
620
}
622
>
flush(): void {
623
// noop
624
}
626
>
627
>
export class MultiplexLogger extends AbstractLogger implements ILogger {
628
>
629
>
constructor(private readonly loggers: ReadonlyArray<ILogger>) {
631
>
if (loggers.length) {
632
>
this.setLevel(loggers[0].getLevel());
633
>
}
634
>
}
636
>
override setLevel(level: LogLevel): void {
638
>
logger.setLevel(level);
639
>
}
640
>
super.setLevel(level);
641
>
}
643
>
trace(message: string, ...args: unknown[]): void {
644
for (const logger of this.loggers) {
645
logger.trace(message, ...args);
646
}
647
}
649
>
debug(message: string, ...args: unknown[]): void {
650
for (const logger of this.loggers) {
651
logger.debug(message, ...args);
652
}
653
}
655
>
info(message: string, ...args: unknown[]): void {
656
for (const logger of this.loggers) {
657
logger.info(message, ...args);
658
}
659
}
661
>
warn(message: string, ...args: unknown[]): void {
662
for (const logger of this.loggers) {
663
logger.warn(message, ...args);
664
}
665
}
667
>
error(message: string | Error, ...args: unknown[]): void {
668
for (const logger of this.loggers) {
669
logger.error(message, ...args);
670
}
671
}
673
>
flush(): void {
674
for (const logger of this.loggers) {
675
logger.flush();
676
}
677
}
679
>
override dispose(): void {
680
for (const logger of this.loggers) {
681
logger.dispose();
682
}
683
super.dispose();
684
}
686
>
687
>
type LoggerEntry = { logger: ILogger | undefined; info: Mutable<ILoggerResource> };
688
>
689
>
export abstract class AbstractLoggerService extends Disposable implements ILoggerService {
690
>
691
>
declare readonly _serviceBrand: undefined;
692
>
693
>
private readonly _loggers = new ResourceMap<LoggerEntry>();
694
>
695
>
private _onDidChangeLoggers = this._register(new Emitter<{ added: ILoggerResource[]; removed: ILoggerResource[] }>);
696
>
readonly onDidChangeLoggers = this._onDidChangeLoggers.event;
697
>
698
>
private _onDidChangeLogLevel = this._register(new Emitter<LogLevel | [URI, LogLevel]>);
699
>
readonly onDidChangeLogLevel = this._onDidChangeLogLevel.event;
700
>
701
>
private _onDidChangeVisibility = this._register(new Emitter<[URI, boolean]>);
702
>
readonly onDidChangeVisibility = this._onDidChangeVisibility.event;
703
>
704
>
constructor(
706
>
private readonly logsHome: URI,
707
>
loggerResources?: Iterable<ILoggerResource>,
708
>
) {
709
>
super();
710
>
if (loggerResources) {
711
for (const loggerResource of loggerResources) {
712
this._loggers.set(loggerResource.resource, { logger: undefined, info: loggerResource });
713
}
714
}
717
>
private getLoggerEntry(resourceOrId: URI | string): LoggerEntry | undefined {
719
>
return [...this._loggers.values()].find(logger => logger.info.id === resourceOrId);
720
>
}
721
return this._loggers.get(resourceOrId);
724
>
getLogger(resourceOrId: URI | string): ILogger | undefined {
726
>
}
728
>
createLogger(idOrResource: URI | string, options?: ILoggerOptions): ILogger {
730
>
const id = isString(idOrResource) ? idOrResource : (options?.id ?? hash(resource.toString()).toString(16));
731
>
let logger = this._loggers.get(resource)?.logger;
732
>
const logLevel = options?.logLevel === 'always' ? LogLevel.Trace : options?.logLevel;
733
>
if (!logger) {
734
>
logger = this.doCreateLogger(resource, logLevel ?? this.getLogLevel(resource) ?? this.logLevel, { ...options, id });
735
>
}
736
>
const loggerEntry: LoggerEntry = {
737
>
logger,
738
>
info: {
739
>
resource,
740
>
id,
741
>
logLevel,
742
>
name: options?.name,
743
>
hidden: options?.hidden,
744
>
group: options?.group,
745
>
extensionId: options?.extensionId,
746
>
when: options?.when
747
>
}
748
>
};
749
>
this.registerLogger(loggerEntry.info);
750
>
// TODO: @sandy081 Remove this once registerLogger can take ILogger
751
>
this._loggers.set(resource, loggerEntry);
752
>
return logger;
753
>
}
755
>
protected toResource(idOrResource: string | URI): URI {
756
>
return isString(idOrResource) ? joinPath(this.logsHome, `${idOrResource.replace(/[\\/:\*\?"<>\|]/g, '')}.log`) : idOrResource;
log.ts ×5
757
>
}
759
>
setLogLevel(logLevel: LogLevel): void;
760
>
setLogLevel(resource: URI, logLevel: LogLevel): void;
761
>
setLogLevel(arg1: any, arg2?: any): void {
762
if (URI.isUri(arg1)) {
763
const resource = arg1;
764
const logLevel = arg2;
765
const logger = this._loggers.get(resource);
766
if (logger && logLevel !== logger.info.logLevel) {
767
logger.info.logLevel = logLevel === this.logLevel ? undefined : logLevel;
768
logger.logger?.setLevel(logLevel);
769
this._loggers.set(logger.info.resource, logger);
770
this._onDidChangeLogLevel.fire([resource, logLevel]);
771
}
772
} else {
773
this.logLevel = arg1;
774
for (const [resource, logger] of this._loggers.entries()) {
775
if (this._loggers.get(resource)?.info.logLevel === undefined) {
776
logger.logger?.setLevel(this.logLevel);
777
}
778
}
779
this._onDidChangeLogLevel.fire(this.logLevel);
780
}
781
}
783
>
setVisibility(resourceOrId: URI | string, visibility: boolean): void {
784
const logger = this.getLoggerEntry(resourceOrId);
785
if (logger && visibility !== !logger.info.hidden) {
786
logger.info.hidden = !visibility;
787
this._loggers.set(logger.info.resource, logger);
788
this._onDidChangeVisibility.fire([logger.info.resource, visibility]);
789
}
790
}
792
>
getLogLevel(resource?: URI): LogLevel {
794
>
if (resource) {
796
>
}
798
>
}
800
>
registerLogger(resource: ILoggerResource): void {
802
>
if (existing) {
803
if (existing.info.hidden !== resource.hidden) {
804
this.setVisibility(resource.resource, !resource.hidden);
805
}
807
>
this._loggers.set(resource.resource, { info: resource, logger: undefined });
808
>
this._onDidChangeLoggers.fire({ added: [resource], removed: [] });
809
>
}
810
>
}
812
>
deregisterLogger(idOrResource: URI | string): void {
814
>
const existing = this._loggers.get(resource);
815
>
if (existing) {
816
if (existing.logger) {
817
existing.logger.dispose();
818
}
819
this._loggers.delete(resource);
820
this._onDidChangeLoggers.fire({ added: [], removed: [existing.info] });
821
}
824
>
*getRegisteredLoggers(): Iterable<ILoggerResource> {
825
for (const entry of this._loggers.values()) {
826
yield entry.info;
827
}
828
}
830
>
getRegisteredLogger(resource: URI): ILoggerResource | undefined {
831
return this._loggers.get(resource)?.info;
832
}
834
>
override dispose(): void {
836
>
this._loggers.clear();
837
>
super.dispose();
838
>
}
840
>
protected abstract doCreateLogger(resource: URI, logLevel: LogLevel, options?: ILoggerOptions): ILogger;
841
>
}
842
>
843
>
export class NullLogger implements ILogger {
846
>
getLevel(): LogLevel { return LogLevel.Info; }
847
>
trace(message: string, ...args: unknown[]): void { }
848
>
debug(message: string, ...args: unknown[]): void { }
849
>
info(message: string, ...args: unknown[]): void { }
850
>
warn(message: string, ...args: unknown[]): void { }
851
>
error(message: string | Error, ...args: unknown[]): void { }
852
>
critical(message: string | Error, ...args: unknown[]): void { }
853
>
dispose(): void { }
854
>
flush(): void { }
855
>
}
856
>
857
>
export class NullLogService extends NullLogger implements ILogService {
858
>
declare readonly _serviceBrand: undefined;
859
>
}
860
>
861
>
export class NullLoggerService extends AbstractLoggerService {
862
>
constructor() {
864
>
}
865
>
protected override doCreateLogger(resource: URI, logLevel: LogLevel, options?: ILoggerOptions): ILogger {
log.ts ×72
867
>
}
869
>
870
>
export function getLogLevel(environmentService: IEnvironmentService): LogLevel {
871
if (environmentService.verbose) {
872
return LogLevel.Trace;
873
}
874
if (typeof environmentService.logLevel === 'string') {
875
const logLevel = parseLogLevel(environmentService.logLevel.toLowerCase());
876
if (logLevel !== undefined) {
877
return logLevel;
878
}
879
}
880
return DEFAULT_LOG_LEVEL;
881
}
883
>
export function LogLevelToString(logLevel: LogLevel): string {
884
>
switch (logLevel) {
885
>
case LogLevel.Trace: return 'trace';
886
>
case LogLevel.Debug: return 'debug';
887
>
case LogLevel.Info: return 'info';
888
>
case LogLevel.Warning: return 'warn';
889
>
case LogLevel.Error: return 'error';
890
>
case LogLevel.Off: return 'off';
891
>
}
892
>
}
893
>
894
>
export function LogLevelToLocalizedString(logLevel: LogLevel): ILocalizedString {
895
switch (logLevel) {
896
case LogLevel.Trace: return { original: 'Trace', value: nls.localize('trace', "Trace") };
897
case LogLevel.Debug: return { original: 'Debug', value: nls.localize('debug', "Debug") };
898
case LogLevel.Info: return { original: 'Info', value: nls.localize('info', "Info") };
899
case LogLevel.Warning: return { original: 'Warning', value: nls.localize('warn', "Warning") };
900
case LogLevel.Error: return { original: 'Error', value: nls.localize('error', "Error") };
901
case LogLevel.Off: return { original: 'Off', value: nls.localize('off', "Off") };
902
}
903
}
905
>
export function parseLogLevel(logLevel: string): LogLevel | undefined {
906
switch (logLevel) {
907
case 'trace':
908
return LogLevel.Trace;
909
case 'debug':
910
return LogLevel.Debug;
911
case 'info':
912
return LogLevel.Info;
913
case 'warn':
914
return LogLevel.Warning;
915
case 'error':
916
return LogLevel.Error;
917
case 'critical':
918
return LogLevel.Error;
919
case 'off':
920
return LogLevel.Off;
921
}
922
return undefined;
923
}
925
>
// Contexts
926
>
export const CONTEXT_LOG_LEVEL = new RawContextKey<string>('logLevel', LogLevelToString(LogLevel.Info));