@trifrost/core/esm/modules/Logger/RootLogger.js

Blazingly fast, runtime-agnostic server framework for modern edge and node environments

import { Lazy } from '../../utils/Lazy';
import { Logger } from './Logger';
import { determineDebug, determineName, determineVersion } from '../../utils/Generic';
import { ConsoleExporter } from './exporters';
export class TriFrostRootLogger {
    #debug = false;
    #exporters;
    #spanAwareExporters = [];
    #logger;
    #runtime;
    constructor(cfg) {
        this.#exporters = new Lazy(cfg.exporters);
        this.#runtime = {
            ...(typeof cfg.runtime.name === 'string' && { 'runtime.name': cfg.runtime.name }),
            ...(typeof cfg.runtime.version === 'string' && { 'runtime.version': cfg.runtime.version }),
        };
        const rootExporter = new ConsoleExporter();
        this.#logger = new Logger({
            debug: false,
            exporters: [rootExporter],
            spanAwareExporters: [],
        });
        rootExporter.init({
            'service.name': 'trifrost-root',
            'service.version': '1.0.0',
            'telemetry.sdk.name': 'trifrost',
            'telemetry.sdk.language': 'javascript',
            ...this.#runtime,
        });
    }
    debug(msg, data) {
        if (this.#debug)
            this.#logger.debug(msg, data);
    }
    info(msg, data) {
        this.#logger.info(msg, data);
    }
    log(msg, data) {
        this.#logger.log(msg, data);
    }
    warn(msg, data) {
        this.#logger.warn(msg, data);
    }
    error(msg, data) {
        this.#logger.error(msg, data);
    }
    spawn(ctx) {
        try {
            if (!this.#exporters.resolved) {
                this.#exporters.resolve(ctx);
                /* Determine debug */
                this.#debug = determineDebug(ctx.env);
                /* Determine trifrost */
                const attributes = {
                    'service.name': determineName(ctx.env),
                    'service.version': determineVersion(ctx.env),
                    'telemetry.sdk.name': 'trifrost',
                    'telemetry.sdk.language': 'javascript',
                    ...this.#runtime,
                };
                /* Set global logger debug state */
                this.#logger.setDebug(this.#debug);
                /* Add a spanAware flag on exporters */
                const exporters = this.#exporters.resolved;
                const spanAware = [];
                for (let i = 0; i < exporters.length; i++) {
                    const exp = exporters[i];
                    /* Initialize exporter */
                    exp.init(attributes);
                    /* If span aware, push exporter into span aware exporters */
                    if (typeof exp.pushSpan === 'function')
                        spanAware.push(exp);
                }
                this.#spanAwareExporters = spanAware;
            }
            return new Logger({
                debug: this.#debug,
                traceId: ctx.traceId,
                context: ctx.context,
                exporters: this.#exporters.resolved,
                spanAwareExporters: this.#spanAwareExporters,
            });
        }
        catch (err) {
            console.error(err);
            return new Logger({ debug: false, exporters: [], spanAwareExporters: [] });
        }
    }
}