@delta-ai/platform 0.1.1

package/dist/log/common/log.js

@@ -0,0 +1,668 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as nls from '@delta-ai/base/nls.js';
+import { toErrorMessage } from '@delta-ai/base/common/errorMessage.js';
+import { Emitter, Event } from '@delta-ai/base/common/event.js';
+import { hash } from '@delta-ai/base/common/hash.js';
+import { Disposable, toDisposable } from '@delta-ai/base/common/lifecycle.js';
+import { ResourceMap } from '@delta-ai/base/common/map.js';
+import { isWindows } from '@delta-ai/base/common/platform.js';
+import { joinPath } from '@delta-ai/base/common/resources.js';
+import { isNumber, isString } from '@delta-ai/base/common/types.js';
+import { URI } from '@delta-ai/base/common/uri.js';
+import { RawContextKey } from '@delta-ai/platform/contextkey/common/contextkey.js';
+import { IEnvironmentService } from '../../environment/common/environment.js';
+import { createDecorator } from '@delta-ai/platform/instantiation/common/instantiation.js';
+export const ILogService = createDecorator('logService');
+export const ILoggerService = createDecorator('loggerService');
+function now() {
+    return new Date().toISOString();
+}
+export function isLogLevel(thing) {
+    return isNumber(thing);
+}
+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 function log(logger, level, message) {
+    switch (level) {
+        case LogLevel.Trace:
+            logger.trace(message);
+            break;
+        case LogLevel.Debug:
+            logger.debug(message);
+            break;
+        case LogLevel.Info:
+            logger.info(message);
+            break;
+        case LogLevel.Warning:
+            logger.warn(message);
+            break;
+        case LogLevel.Error:
+            logger.error(message);
+            break;
+        case LogLevel.Off: /* do nothing */ break;
+        default: throw new Error(`Invalid log level ${level}`);
+    }
+}
+/**
+ * Flag to enable forwarding of console.* calls to the log service in development.
+ * This is intended for the use of agents to quickly instrument the code with console.logs
+ * which will end up in the log service's file outputs.
+ */
+export const isDevConsoleLogForwardingEnabled = false;
+let isConsoleForwarding = false;
+let isLogServiceConsoleEcho = false;
+function getConsoleMethod(method) {
+    switch (method) {
+        case 'debug': return console.debug;
+        case 'error': return console.error;
+        case 'info': return console.info;
+        case 'log': return console.log;
+        case 'warn': return console.warn;
+    }
+}
+function setConsoleMethod(method, fn) {
+    switch (method) {
+        case 'debug':
+            console.debug = fn;
+            break;
+        case 'error':
+            console.error = fn;
+            break;
+        case 'info':
+            console.info = fn;
+            break;
+        case 'log':
+            console.log = fn;
+            break;
+        case 'warn':
+            console.warn = fn;
+            break;
+    }
+}
+function logToConsole(method, ...args) {
+    if (isConsoleForwarding) {
+        return;
+    }
+    isLogServiceConsoleEcho = true;
+    try {
+        getConsoleMethod(method).apply(console, args);
+    }
+    finally {
+        isLogServiceConsoleEcho = false;
+    }
+}
+export function registerDevConsoleLogForwarder(logService) {
+    const originalConsoleMethods = {
+        debug: console.debug,
+        error: console.error,
+        info: console.info,
+        log: console.log,
+        warn: console.warn
+    };
+    const forward = (method, level, args) => {
+        if (!isLogServiceConsoleEcho) {
+            isConsoleForwarding = true;
+            try {
+                log(logService, level, format(args));
+            }
+            catch {
+                // Best-effort development logging must not break normal console semantics.
+            }
+            finally {
+                isConsoleForwarding = false;
+            }
+        }
+        originalConsoleMethods[method].apply(console, args);
+    };
+    const wrappers = {
+        debug: (...args) => forward('debug', LogLevel.Debug, args),
+        error: (...args) => forward('error', LogLevel.Error, args),
+        info: (...args) => forward('info', LogLevel.Info, args),
+        log: (...args) => forward('log', LogLevel.Info, args),
+        warn: (...args) => forward('warn', LogLevel.Warning, args)
+    };
+    setConsoleMethod('debug', wrappers.debug);
+    setConsoleMethod('error', wrappers.error);
+    setConsoleMethod('info', wrappers.info);
+    setConsoleMethod('log', wrappers.log);
+    setConsoleMethod('warn', wrappers.warn);
+    return toDisposable(() => {
+        if (console.debug === wrappers.debug) {
+            console.debug = originalConsoleMethods.debug;
+        }
+        if (console.error === wrappers.error) {
+            console.error = originalConsoleMethods.error;
+        }
+        if (console.info === wrappers.info) {
+            console.info = originalConsoleMethods.info;
+        }
+        if (console.log === wrappers.log) {
+            console.log = originalConsoleMethods.log;
+        }
+        if (console.warn === wrappers.warn) {
+            console.warn = originalConsoleMethods.warn;
+        }
+    });
+}
+function format(args, verbose = false) {
+    let result = '';
+    for (let i = 0; i < args.length; i++) {
+        let a = args[i];
+        if (a instanceof Error) {
+            a = toErrorMessage(a, verbose);
+        }
+        if (typeof a === 'object') {
+            try {
+                a = JSON.stringify(a);
+            }
+            catch (e) { }
+        }
+        result += (i > 0 ? ' ' : '') + a;
+    }
+    return result;
+}
+export class AbstractLogger extends Disposable {
+    level = DEFAULT_LOG_LEVEL;
+    _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 AbstractMessageLogger extends AbstractLogger {
+    logAlways;
+    constructor(logAlways) {
+        super();
+        this.logAlways = logAlways;
+    }
+    checkLogLevel(level) {
+        return this.logAlways || super.checkLogLevel(level);
+    }
+    trace(message, ...args) {
+        if (this.canLog(LogLevel.Trace)) {
+            this.log(LogLevel.Trace, format([message, ...args], true));
+        }
+    }
+    debug(message, ...args) {
+        if (this.canLog(LogLevel.Debug)) {
+            this.log(LogLevel.Debug, format([message, ...args]));
+        }
+    }
+    info(message, ...args) {
+        if (this.canLog(LogLevel.Info)) {
+            this.log(LogLevel.Info, format([message, ...args]));
+        }
+    }
+    warn(message, ...args) {
+        if (this.canLog(LogLevel.Warning)) {
+            this.log(LogLevel.Warning, format([message, ...args]));
+        }
+    }
+    error(message, ...args) {
+        if (this.canLog(LogLevel.Error)) {
+            if (message instanceof Error) {
+                const array = Array.prototype.slice.call(arguments);
+                array[0] = message.stack;
+                this.log(LogLevel.Error, format(array));
+            }
+            else {
+                this.log(LogLevel.Error, format([message, ...args]));
+            }
+        }
+    }
+    flush() { }
+}
+export class ConsoleMainLogger extends AbstractLogger {
+    useColors;
+    constructor(logLevel = DEFAULT_LOG_LEVEL) {
+        super();
+        this.setLevel(logLevel);
+        this.useColors = !isWindows;
+    }
+    trace(message, ...args) {
+        if (this.canLog(LogLevel.Trace)) {
+            if (this.useColors) {
+                logToConsole('log', `\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
+            }
+            else {
+                logToConsole('log', `[main ${now()}]`, message, ...args);
+            }
+        }
+    }
+    debug(message, ...args) {
+        if (this.canLog(LogLevel.Debug)) {
+            if (this.useColors) {
+                logToConsole('log', `\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
+            }
+            else {
+                logToConsole('log', `[main ${now()}]`, message, ...args);
+            }
+        }
+    }
+    info(message, ...args) {
+        if (this.canLog(LogLevel.Info)) {
+            if (this.useColors) {
+                logToConsole('log', `\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
+            }
+            else {
+                logToConsole('log', `[main ${now()}]`, message, ...args);
+            }
+        }
+    }
+    warn(message, ...args) {
+        if (this.canLog(LogLevel.Warning)) {
+            if (this.useColors) {
+                logToConsole('warn', `\x1b[93m[main ${now()}]\x1b[0m`, message, ...args);
+            }
+            else {
+                logToConsole('warn', `[main ${now()}]`, message, ...args);
+            }
+        }
+    }
+    error(message, ...args) {
+        if (this.canLog(LogLevel.Error)) {
+            if (this.useColors) {
+                logToConsole('error', `\x1b[91m[main ${now()}]\x1b[0m`, message, ...args);
+            }
+            else {
+                logToConsole('error', `[main ${now()}]`, message, ...args);
+            }
+        }
+    }
+    flush() {
+        // noop
+    }
+}
+export class ConsoleLogger extends AbstractLogger {
+    useColors;
+    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) {
+                logToConsole('log', '%cTRACE', 'color: #888', message, ...args);
+            }
+            else {
+                logToConsole('log', message, ...args);
+            }
+        }
+    }
+    debug(message, ...args) {
+        if (this.canLog(LogLevel.Debug)) {
+            if (this.useColors) {
+                logToConsole('log', '%cDEBUG', 'background: #eee; color: #888', message, ...args);
+            }
+            else {
+                logToConsole('log', message, ...args);
+            }
+        }
+    }
+    info(message, ...args) {
+        if (this.canLog(LogLevel.Info)) {
+            if (this.useColors) {
+                logToConsole('log', '%c INFO', 'color: #33f', message, ...args);
+            }
+            else {
+                logToConsole('log', message, ...args);
+            }
+        }
+    }
+    warn(message, ...args) {
+        if (this.canLog(LogLevel.Warning)) {
+            if (this.useColors) {
+                logToConsole('warn', '%c WARN', 'color: #993', message, ...args);
+            }
+            else {
+                logToConsole('log', message, ...args);
+            }
+        }
+    }
+    error(message, ...args) {
+        if (this.canLog(LogLevel.Error)) {
+            if (this.useColors) {
+                logToConsole('error', '%c  ERR', 'color: #f33', message, ...args);
+            }
+            else {
+                logToConsole('error', message, ...args);
+            }
+        }
+    }
+    flush() {
+        // noop
+    }
+}
+export class AdapterLogger extends AbstractLogger {
+    adapter;
+    constructor(adapter, logLevel = DEFAULT_LOG_LEVEL) {
+        super();
+        this.adapter = adapter;
+        this.setLevel(logLevel);
+    }
+    trace(message, ...args) {
+        if (this.canLog(LogLevel.Trace)) {
+            this.adapter.log(LogLevel.Trace, [this.extractMessage(message), ...args]);
+        }
+    }
+    debug(message, ...args) {
+        if (this.canLog(LogLevel.Debug)) {
+            this.adapter.log(LogLevel.Debug, [this.extractMessage(message), ...args]);
+        }
+    }
+    info(message, ...args) {
+        if (this.canLog(LogLevel.Info)) {
+            this.adapter.log(LogLevel.Info, [this.extractMessage(message), ...args]);
+        }
+    }
+    warn(message, ...args) {
+        if (this.canLog(LogLevel.Warning)) {
+            this.adapter.log(LogLevel.Warning, [this.extractMessage(message), ...args]);
+        }
+    }
+    error(message, ...args) {
+        if (this.canLog(LogLevel.Error)) {
+            this.adapter.log(LogLevel.Error, [this.extractMessage(message), ...args]);
+        }
+    }
+    extractMessage(msg) {
+        if (typeof msg === 'string') {
+            return msg;
+        }
+        return toErrorMessage(msg, this.canLog(LogLevel.Trace));
+    }
+    flush() {
+        // noop
+    }
+}
+export class MultiplexLogger extends AbstractLogger {
+    loggers;
+    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);
+        }
+    }
+    flush() {
+        for (const logger of this.loggers) {
+            logger.flush();
+        }
+    }
+    dispose() {
+        for (const logger of this.loggers) {
+            logger.dispose();
+        }
+        super.dispose();
+    }
+}
+export class AbstractLoggerService extends Disposable {
+    logLevel;
+    logsHome;
+    _loggers = new ResourceMap();
+    _onDidChangeLoggers = this._register(new Emitter);
+    onDidChangeLoggers = this._onDidChangeLoggers.event;
+    _onDidChangeLogLevel = this._register(new Emitter);
+    onDidChangeLogLevel = this._onDidChangeLogLevel.event;
+    _onDidChangeVisibility = this._register(new Emitter);
+    onDidChangeVisibility = this._onDidChangeVisibility.event;
+    constructor(logLevel, logsHome, loggerResources) {
+        super();
+        this.logLevel = logLevel;
+        this.logsHome = logsHome;
+        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);
+    }
+    getLogger(resourceOrId) {
+        return this.getLoggerEntry(resourceOrId)?.logger;
+    }
+    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.replace(/[\\/:\*\?"<>\|]/g, '')}.log`) : idOrResource;
+    }
+    setLogLevel(arg1, arg2) {
+        if (URI.isUri(arg1)) {
+            const resource = arg1;
+            const logLevel = arg2;
+            const logger = this._loggers.get(resource);
+            if (logger && logLevel !== logger.info.logLevel) {
+                logger.info.logLevel = logLevel === this.logLevel ? undefined : logLevel;
+                logger.logger?.setLevel(logLevel);
+                this._loggers.set(logger.info.resource, logger);
+                this._onDidChangeLogLevel.fire([resource, logLevel]);
+            }
+        }
+        else {
+            this.logLevel = arg1;
+            for (const [resource, logger] of this._loggers.entries()) {
+                if (this._loggers.get(resource)?.info.logLevel === undefined) {
+                    logger.logger?.setLevel(this.logLevel);
+                }
+            }
+            this._onDidChangeLogLevel.fire(this.logLevel);
+        }
+    }
+    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: [] });
+        }
+    }
+    deregisterLogger(idOrResource) {
+        const resource = this.toResource(idOrResource);
+        const existing = this._loggers.get(resource);
+        if (existing) {
+            if (existing.logger) {
+                existing.logger.dispose();
+            }
+            this._loggers.delete(resource);
+            this._onDidChangeLoggers.fire({ added: [], removed: [existing.info] });
+        }
+    }
+    *getRegisteredLoggers() {
+        for (const entry of this._loggers.values()) {
+            yield entry.info;
+        }
+    }
+    getRegisteredLogger(resource) {
+        return this._loggers.get(resource)?.info;
+    }
+    dispose() {
+        this._loggers.forEach(logger => logger.logger?.dispose());
+        this._loggers.clear();
+        super.dispose();
+    }
+}
+export class NullLogger {
+    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) { }
+    critical(message, ...args) { }
+    dispose() { }
+    flush() { }
+}
+export class NullLogService extends NullLogger {
+}
+export class NullLoggerService extends AbstractLoggerService {
+    constructor() {
+        super(LogLevel.Off, URI.parse('log:///log'));
+    }
+    doCreateLogger(resource, logLevel, options) {
+        return new NullLogger();
+    }
+}
+export function getLogLevel(environmentService) {
+    if (environmentService.verbose) {
+        return LogLevel.Trace;
+    }
+    if (typeof environmentService.logLevel === 'string') {
+        const logLevel = parseLogLevel(environmentService.logLevel.toLowerCase());
+        if (logLevel !== undefined) {
+            return logLevel;
+        }
+    }
+    return DEFAULT_LOG_LEVEL;
+}
+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';
+    }
+}
+export function LogLevelToLocalizedString(logLevel) {
+    switch (logLevel) {
+        case LogLevel.Trace: return { original: 'Trace', value: nls.localize('trace', "Trace") };
+        case LogLevel.Debug: return { original: 'Debug', value: nls.localize('debug', "Debug") };
+        case LogLevel.Info: return { original: 'Info', value: nls.localize('info', "Info") };
+        case LogLevel.Warning: return { original: 'Warning', value: nls.localize('warn', "Warning") };
+        case LogLevel.Error: return { original: 'Error', value: nls.localize('error', "Error") };
+        case LogLevel.Off: return { original: 'Off', value: nls.localize('off', "Off") };
+    }
+}
+export function parseLogLevel(logLevel) {
+    switch (logLevel) {
+        case 'trace':
+            return LogLevel.Trace;
+        case 'debug':
+            return LogLevel.Debug;
+        case 'info':
+            return LogLevel.Info;
+        case 'warn':
+            return LogLevel.Warning;
+        case 'error':
+            return LogLevel.Error;
+        case 'critical':
+            return LogLevel.Error;
+        case 'off':
+            return LogLevel.Off;
+    }
+    return undefined;
+}
+// Contexts
+export const CONTEXT_LOG_LEVEL = new RawContextKey('logLevel', LogLevelToString(LogLevel.Info));
+//# sourceMappingURL=log.js.map