monaco-editor-core
Version:
A browser based code editor
269 lines • 9.11 kB
JavaScript
import { Emitter } from '../../../base/common/event.js';
import { hash } from '../../../base/common/hash.js';
import { Disposable } from '../../../base/common/lifecycle.js';
import { ResourceMap } from '../../../base/common/map.js';
import { joinPath } from '../../../base/common/resources.js';
import { isString } from '../../../base/common/types.js';
import { URI } from '../../../base/common/uri.js';
import { RawContextKey } from '../../contextkey/common/contextkey.js';
import { createDecorator } from '../../instantiation/common/instantiation.js';
export const ILogService = createDecorator('logService');
export const ILoggerService = createDecorator('loggerService');
export var LogLevel;
(function (LogLevel) {
LogLevel[LogLevel["Off"] = 0] = "Off";
LogLevel[LogLevel["Trace"] = 1] = "Trace";
LogLevel[LogLevel["Debug"] = 2] = "Debug";
LogLevel[LogLevel["Info"] = 3] = "Info";
LogLevel[LogLevel["Warning"] = 4] = "Warning";
LogLevel[LogLevel["Error"] = 5] = "Error";
})(LogLevel || (LogLevel = {}));
export const DEFAULT_LOG_LEVEL = LogLevel.Info;
export function canLog(loggerLevel, messageLevel) {
return loggerLevel !== LogLevel.Off && loggerLevel <= messageLevel;
}
export class AbstractLogger extends Disposable {
constructor() {
super(...arguments);
this.level = DEFAULT_LOG_LEVEL;
this._onDidChangeLogLevel = this._register(new Emitter());
}
get onDidChangeLogLevel() { return this._onDidChangeLogLevel.event; }
setLevel(level) {
if (this.level !== level) {
this.level = level;
this._onDidChangeLogLevel.fire(this.level);
}
}
getLevel() {
return this.level;
}
checkLogLevel(level) {
return canLog(this.level, level);
}
canLog(level) {
if (this._store.isDisposed) {
return false;
}
return this.checkLogLevel(level);
}
}
export class ConsoleLogger extends AbstractLogger {
constructor(logLevel = DEFAULT_LOG_LEVEL, useColors = true) {
super();
this.useColors = useColors;
this.setLevel(logLevel);
}
trace(message, ...args) {
if (this.canLog(LogLevel.Trace)) {
if (this.useColors) {
console.log('%cTRACE', 'color: #888', message, ...args);
}
else {
console.log(message, ...args);
}
}
}
debug(message, ...args) {
if (this.canLog(LogLevel.Debug)) {
if (this.useColors) {
console.log('%cDEBUG', 'background: #eee; color: #888', message, ...args);
}
else {
console.log(message, ...args);
}
}
}
info(message, ...args) {
if (this.canLog(LogLevel.Info)) {
if (this.useColors) {
console.log('%c INFO', 'color: #33f', message, ...args);
}
else {
console.log(message, ...args);
}
}
}
warn(message, ...args) {
if (this.canLog(LogLevel.Warning)) {
if (this.useColors) {
console.warn('%c WARN', 'color: #993', message, ...args);
}
else {
console.log(message, ...args);
}
}
}
error(message, ...args) {
if (this.canLog(LogLevel.Error)) {
if (this.useColors) {
console.error('%c ERR', 'color: #f33', message, ...args);
}
else {
console.error(message, ...args);
}
}
}
}
export class MultiplexLogger extends AbstractLogger {
constructor(loggers) {
super();
this.loggers = loggers;
if (loggers.length) {
this.setLevel(loggers[0].getLevel());
}
}
setLevel(level) {
for (const logger of this.loggers) {
logger.setLevel(level);
}
super.setLevel(level);
}
trace(message, ...args) {
for (const logger of this.loggers) {
logger.trace(message, ...args);
}
}
debug(message, ...args) {
for (const logger of this.loggers) {
logger.debug(message, ...args);
}
}
info(message, ...args) {
for (const logger of this.loggers) {
logger.info(message, ...args);
}
}
warn(message, ...args) {
for (const logger of this.loggers) {
logger.warn(message, ...args);
}
}
error(message, ...args) {
for (const logger of this.loggers) {
logger.error(message, ...args);
}
}
dispose() {
for (const logger of this.loggers) {
logger.dispose();
}
super.dispose();
}
}
export class AbstractLoggerService extends Disposable {
constructor(logLevel, logsHome, loggerResources) {
super();
this.logLevel = logLevel;
this.logsHome = logsHome;
this._loggers = new ResourceMap();
this._onDidChangeLoggers = this._register(new Emitter);
this._onDidChangeVisibility = this._register(new Emitter);
if (loggerResources) {
for (const loggerResource of loggerResources) {
this._loggers.set(loggerResource.resource, { logger: undefined, info: loggerResource });
}
}
}
getLoggerEntry(resourceOrId) {
if (isString(resourceOrId)) {
return [...this._loggers.values()].find(logger => logger.info.id === resourceOrId);
}
return this._loggers.get(resourceOrId);
}
createLogger(idOrResource, options) {
const resource = this.toResource(idOrResource);
const id = isString(idOrResource) ? idOrResource : (options?.id ?? hash(resource.toString()).toString(16));
let logger = this._loggers.get(resource)?.logger;
const logLevel = options?.logLevel === 'always' ? LogLevel.Trace : options?.logLevel;
if (!logger) {
logger = this.doCreateLogger(resource, logLevel ?? this.getLogLevel(resource) ?? this.logLevel, { ...options, id });
}
const loggerEntry = {
logger,
info: {
resource,
id,
logLevel,
name: options?.name,
hidden: options?.hidden,
group: options?.group,
extensionId: options?.extensionId,
when: options?.when
}
};
this.registerLogger(loggerEntry.info);
// TODO: @sandy081 Remove this once registerLogger can take ILogger
this._loggers.set(resource, loggerEntry);
return logger;
}
toResource(idOrResource) {
return isString(idOrResource) ? joinPath(this.logsHome, `${idOrResource}.log`) : idOrResource;
}
setVisibility(resourceOrId, visibility) {
const logger = this.getLoggerEntry(resourceOrId);
if (logger && visibility !== !logger.info.hidden) {
logger.info.hidden = !visibility;
this._loggers.set(logger.info.resource, logger);
this._onDidChangeVisibility.fire([logger.info.resource, visibility]);
}
}
getLogLevel(resource) {
let logLevel;
if (resource) {
logLevel = this._loggers.get(resource)?.info.logLevel;
}
return logLevel ?? this.logLevel;
}
registerLogger(resource) {
const existing = this._loggers.get(resource.resource);
if (existing) {
if (existing.info.hidden !== resource.hidden) {
this.setVisibility(resource.resource, !resource.hidden);
}
}
else {
this._loggers.set(resource.resource, { info: resource, logger: undefined });
this._onDidChangeLoggers.fire({ added: [resource], removed: [] });
}
}
dispose() {
this._loggers.forEach(logger => logger.logger?.dispose());
this._loggers.clear();
super.dispose();
}
}
export class NullLogger {
constructor() {
this.onDidChangeLogLevel = new Emitter().event;
}
setLevel(level) { }
getLevel() { return LogLevel.Info; }
trace(message, ...args) { }
debug(message, ...args) { }
info(message, ...args) { }
warn(message, ...args) { }
error(message, ...args) { }
dispose() { }
}
export class NullLoggerService extends AbstractLoggerService {
constructor() {
super(LogLevel.Off, URI.parse('log:///log'));
}
doCreateLogger(resource, logLevel, options) {
return new NullLogger();
}
}
export function LogLevelToString(logLevel) {
switch (logLevel) {
case LogLevel.Trace: return 'trace';
case LogLevel.Debug: return 'debug';
case LogLevel.Info: return 'info';
case LogLevel.Warning: return 'warn';
case LogLevel.Error: return 'error';
case LogLevel.Off: return 'off';
}
}
// Contexts
export const CONTEXT_LOG_LEVEL = new RawContextKey('logLevel', LogLevelToString(LogLevel.Info));
//# sourceMappingURL=log.js.map