daemon-log.ts

import { ILogger, LogLevel } from '@theia/core/lib/common/logger';

export interface DaemonLog {
    readonly time: string;
    readonly level: DaemonLog.Level;
    readonly msg: string;
}

export namespace DaemonLog {

    export interface Url {
        readonly Scheme: string;
        readonly Host: string;
        readonly Path: string;
    }

    export namespace Url {

        export function is(arg: any | undefined): arg is Url {
            return !!arg
                && typeof arg.Scheme === 'string'
                && typeof arg.Host === 'string'
                && typeof arg.Path === 'string';
        }

        export function toString(url: Url): string {
            const { Scheme, Host, Path } = url;
            return `${Scheme}://${Host}${Path}`;
        }

    }

    export interface System {
        readonly os: string;
        // readonly Resource: Resource;
    }

    export namespace System {
        export function toString(system: System): string {
            return `OS: ${system.os}`
        }
    }

    export interface Tool {
        readonly version: string;
        readonly systems: System[];
    }

    export namespace Tool {

        export function is(arg: any | undefined): arg is Tool {
            return !!arg && typeof arg.version === 'string' && 'systems' in arg;
        }

        export function toString(tool: Tool): string {
            const { version, systems } = tool;
            return `Version: ${version}${!!systems ? ` Systems: [${tool.systems.map(System.toString).join(', ')}]` : ''}`;
        }

    }

    export type Level = 'trace' | 'debug' | 'info' | 'warning' | 'error';

    export function is(arg: any | undefined): arg is DaemonLog {
        return !!arg
            && typeof arg.time === 'string'
            && typeof arg.level === 'string'
            && typeof arg.msg === 'string'
    }

    export function toLogLevel(log: DaemonLog): LogLevel {
        const { level } = log;
        switch (level) {
            case 'trace': return LogLevel.TRACE;
            case 'debug': return LogLevel.DEBUG;
            case 'info': return LogLevel.INFO;
            case 'warning': return LogLevel.WARN;
            case 'error': return LogLevel.ERROR;
            default: return LogLevel.INFO;
        }
    }

    export function log(logger: ILogger, logMessages: string): void {
        const parsed = parse(logMessages);
        for (const log of parsed) {
            const logLevel = toLogLevel(log);
            const message = toMessage(log, { omitLogLevel: true });
            logger.log(logLevel, message);
        }
    }

    function parse(toLog: string): DaemonLog[] {
        const messages = toLog.trim().split('\n');
        const result: DaemonLog[] = [];
        for (let i = 0; i < messages.length; i++) {
            try {
                const maybeDaemonLog = JSON.parse(messages[i]);
                if (DaemonLog.is(maybeDaemonLog)) {
                    result.push(maybeDaemonLog);
                    continue;
                }
            } catch { /* NOOP */ }
            result.push({
                time: new Date().toString(),
                level: 'info',
                msg: messages[i]
            });
        }
        return result;
    }

    export function toPrettyString(logMessages: string): string {
        const parsed = parse(logMessages);
        return parsed.map(log => toMessage(log)).join('\n') + '\n';
    }

    function toMessage(log: DaemonLog, options: { omitLogLevel: boolean } = { omitLogLevel: false }): string {
        const details = Object.keys(log).filter(key => key !== 'msg' && key !== 'level' && key !== 'time').map(key => toDetails(log, key)).join(', ');
        const logLevel = options.omitLogLevel ? '' : `[${log.level.toUpperCase()}] `;
        return `${logLevel}${log.msg}${!!details ? ` [${details}]` : ''}`
    }

    function toDetails(log: DaemonLog, key: string): string {
        let value = (log as any)[key];
        if (DaemonLog.Url.is(value)) {
            value = DaemonLog.Url.toString(value);
        } else if (DaemonLog.Tool.is(value)) {
            value = DaemonLog.Tool.toString(value);
        } else if (typeof value === 'object') {
            value = JSON.stringify(value).replace(/\"([^(\")"]+)\":/g, '$1:'); // Remove the quotes from the property keys.
        }
        return `${key.toLowerCase()}: ${value}`;
    }

}