@nebius/js-sdk 0.1.0

package/dist/cjs/runtime/util/logging.js

@@ -0,0 +1,865 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.noopHandler = exports.JsonHandler = exports.PrettyHandler = exports.ConsoleHandler = exports.FileWrapper = exports.Level = exports.custom = exports.customJson = void 0;
+exports.inspectJson = inspectJson;
+exports.parseLevel = parseLevel;
+exports.deprecatedWarn = deprecatedWarn;
+exports.setDeprecatedWarningLogger = setDeprecatedWarningLogger;
+exports.defaultHandler = defaultHandler;
+exports.resolveLogger = resolveLogger;
+const util_1 = require("util");
+const path_1 = require("./path");
+// Symbol used to allow objects to provide a JSON-safe representation for
+// logging. Works similar to util.inspect.custom but is used for JSON
+// serialization of log argument values. If `argJson` is absent but
+// `util.inspect.custom` is present on an object, we fall back to using it
+// for safety reasons.
+exports.customJson = Symbol('customJson');
+exports.custom = util_1.inspect.custom;
+const selfDebug = process?.env?.NEBIUS_LOGGING_SELF_DEBUG === 'true';
+const dbg = selfDebug
+    ? (msg, ...args) => console.debug(msg, ...args)
+    : () => { };
+var Level;
+(function (Level) {
+    Level[Level["TRACE"] = 10] = "TRACE";
+    Level[Level["DEBUG"] = 20] = "DEBUG";
+    Level[Level["INFO"] = 30] = "INFO";
+    Level[Level["WARN"] = 40] = "WARN";
+    Level[Level["ERROR"] = 50] = "ERROR";
+    Level[Level["NONE"] = 100] = "NONE";
+})(Level || (exports.Level = Level = {}));
+function cleanTrace(trace, skip) {
+    const lines = trace.split('\n').slice(1 + skip); // first line is "Error name: message"
+    if (lines.length <= skip) {
+        return '';
+    }
+    const ret = [];
+    for (const line of lines) {
+        let trimmed = line.trim();
+        if (trimmed.startsWith('at ')) {
+            trimmed = trimmed.substring(3);
+        }
+        ret.push(trimmed);
+    }
+    return ret.join('\n');
+}
+function getTrace(skip = 2) {
+    const err = new Error();
+    if (!err.stack) {
+        return '';
+    }
+    return cleanTrace(err.stack, skip);
+}
+// Exported helper to produce a JSON-safe representation of a value. This
+// mirrors the logic previously embedded inside JsonHandler.serializeValue so
+// callers (for example implementations of [customJson]) can call it
+// recursively.
+function inspectJson(val) {
+    // Primitives pass-through
+    if (val === null)
+        return null;
+    const t = typeof val;
+    if (t === 'string' || t === 'number' || t === 'boolean')
+        return val;
+    if (t === 'undefined')
+        return undefined;
+    // If object has customJson or util.inspect.custom, prefer customJson then
+    // fallback to inspect.custom
+    try {
+        const anyVal = val;
+        const customFn = anyVal?.[exports.customJson] ?? anyVal?.[exports.custom];
+        if (customFn !== undefined) {
+            if (typeof customFn === 'function') {
+                // allow custom serializer to return anything JSON-serializable
+                return customFn.call(anyVal);
+            }
+            return customFn;
+        }
+    }
+    catch (e) {
+        dbg('inspectJson: custom serializer threw error', e);
+    }
+    // Safe JSON serialization with circular refs handled
+    try {
+        const seen = new WeakSet();
+        const cloned = (function clone(v) {
+            if (v === null)
+                return null;
+            const vt = typeof v;
+            // Allow nested values to provide custom JSON representation via
+            // customJson or util.inspect.custom
+            try {
+                const maybeAny = v;
+                const nestedCustom = maybeAny?.[exports.customJson] ?? maybeAny?.[exports.custom];
+                if (nestedCustom !== undefined) {
+                    if (typeof nestedCustom === 'function')
+                        return nestedCustom.call(maybeAny);
+                    return nestedCustom;
+                }
+            }
+            catch (e) {
+                dbg('inspectJson: nested custom serializer threw error', e);
+            }
+            if (vt === 'string' || vt === 'number' || vt === 'boolean' || vt === 'undefined')
+                return v;
+            if (vt === 'function')
+                return `[Function:${v.name || 'anonymous'}]`;
+            if (vt === 'symbol')
+                return String(v);
+            if (Array.isArray(v)) {
+                const arr = v;
+                if (seen.has(arr))
+                    return '[Circular]';
+                seen.add(arr);
+                return arr.map(clone);
+            }
+            if (v instanceof Date)
+                return v.toISOString();
+            if (v instanceof Error)
+                return { name: v.name, message: v.message, stack: v.stack };
+            if (vt === 'object') {
+                const obj = v;
+                if (seen.has(obj))
+                    return '[Circular]';
+                seen.add(obj);
+                const o = {};
+                for (const k of Object.keys(obj)) {
+                    try {
+                        o[k] = clone(obj[k]);
+                    }
+                    catch {
+                        o[k] = '[Unserializable]';
+                    }
+                }
+                return o;
+            }
+            return String(v);
+        })(val);
+        return cloned;
+    }
+    catch (e) {
+        // As a last resort use inspect output
+        try {
+            return (0, util_1.inspect)(val, { depth: 2 });
+        }
+        catch {
+            return String(val);
+        }
+    }
+}
+class ConsoleLikeWrapper {
+    output;
+    constructor(output) {
+        this.output = output;
+    }
+    error(message, ...optionalParams) {
+        this.output(`${message}`);
+        for (const p of optionalParams) {
+            this.output(` ${(0, util_1.inspect)(p)}`);
+        }
+        this.output('\n');
+    }
+}
+class FileWrapper {
+    fs;
+    stream;
+    constructor(filePath) {
+        const resolved = (0, path_1.resolveHomeDir)(filePath);
+        this.fs = require('fs');
+        this.stream = this.fs.createWriteStream(resolved, { flags: 'a' });
+    }
+    error(message, ...optionalParams) {
+        this.stream.write(`${message}`);
+        for (const p of optionalParams) {
+            this.stream.write(` ${(0, util_1.inspect)(p)}`);
+        }
+        this.stream.write('\n');
+    }
+}
+exports.FileWrapper = FileWrapper;
+function outputToConsoleLike(output) {
+    if (typeof output === 'function') {
+        return new ConsoleLikeWrapper(output);
+    }
+    else if (typeof output === 'string') {
+        return new FileWrapper(output);
+    }
+    else if (output === undefined) {
+        return console;
+    }
+    return output;
+}
+class ConsoleHandler {
+    consoleLike;
+    level;
+    filters;
+    format;
+    argFormat = (key, value) => `${key}=${value}`;
+    argDelimiter = ', ';
+    alwaysAddTrace = false;
+    constructor(opts) {
+        this.alwaysAddTrace = !!opts?.alwaysAddTrace;
+        this.consoleLike = outputToConsoleLike(opts?.output);
+        this.level = opts?.level ?? Level.INFO;
+        this.filters = opts?.filters ?? /.*/;
+        this.argFormat = opts?.argFormat ?? ((key, value) => `${key}=${value}`);
+        this.argDelimiter = opts?.argDelimiter ?? ', ';
+        const makeFormatterFromTemplate = (template) => ({ name, level, time, message, args, trace, }) => template.replace(/\{(.*?)(name|level|time|message|args|trace)\}/g, (_, prefix, key) => {
+            const replacements = {
+                name,
+                level: Level[level] ?? String(level),
+                time: time.toISOString(),
+                message,
+                args: args ?? '',
+                trace: trace ?? '',
+            };
+            return (replacements[key] ? (prefix ?? '') : '') + (replacements[key] ?? '');
+        });
+        if (typeof opts?.format === 'string') {
+            this.format = makeFormatterFromTemplate(opts.format);
+        }
+        else if (typeof opts?.format === 'function') {
+            this.format = opts.format;
+        }
+        else {
+            this.format = makeFormatterFromTemplate('{time} [{level}] {name}: {message}{ args}{\ntrace}');
+        }
+    }
+    [exports.custom]() {
+        return `ConsoleHandler(level=${Level[this.level]})`;
+    }
+    [exports.customJson]() {
+        return {
+            $type: 'ConsoleHandler',
+            level: Level[this.level],
+        };
+    }
+    matchFilters(name, level) {
+        const fs = Array.isArray(this.filters) ? this.filters : [this.filters];
+        for (const f of fs) {
+            if (typeof f === 'string') {
+                if (name.includes(f))
+                    return true;
+            }
+            else if (f instanceof RegExp) {
+                if (f.test(name))
+                    return true;
+            }
+            else if (typeof f === 'function') {
+                try {
+                    if (f(name, level))
+                        return true;
+                }
+                catch (e) {
+                    dbg('ConsoleHandler.matchFilters: filter threw error', e);
+                }
+            }
+        }
+        return false;
+    }
+    argString(args) {
+        const ret = [];
+        for (const key in args) {
+            if (Object.prototype.hasOwnProperty.call(args, key)) {
+                const val = args[key];
+                const valStr = (0, util_1.inspect)(val, { depth: 5 });
+                ret.push(this.argFormat(key, valStr));
+            }
+        }
+        return ret.join(this.argDelimiter);
+    }
+    log(level, message, args, name, traceLevel = 3) {
+        if (level < this.level)
+            return;
+        if (!this.matchFilters(name, level))
+            return;
+        if (this.alwaysAddTrace && traceLevel < 0) {
+            traceLevel = 3;
+        }
+        const trace = traceLevel >= 0 ? getTrace(traceLevel) : undefined;
+        const out = this.format({
+            name,
+            level,
+            time: new Date(),
+            message,
+            args: this.argString(args),
+            trace,
+        });
+        try {
+            this.consoleLike.error(out);
+        }
+        catch (e) {
+            dbg('ConsoleHandler.log: consoleLike.error threw error', e, {
+                level,
+                message,
+                args,
+                name,
+                traceLevel,
+            });
+        }
+    }
+}
+exports.ConsoleHandler = ConsoleHandler;
+class PrettyHandler {
+    consoleLike;
+    level;
+    filters;
+    argFormat = (key, value) => `${key}=${value}`;
+    argDelimiter = ', ';
+    useColors;
+    alwaysAddTrace = false;
+    constructor(opts) {
+        this.alwaysAddTrace = !!opts?.alwaysAddTrace;
+        this.consoleLike = outputToConsoleLike(opts?.output);
+        this.level = opts?.level ?? Level.INFO;
+        this.filters = opts?.filters ?? /.*/;
+        this.argFormat = opts?.argFormat ?? ((key, value) => `${key}=${value}`);
+        this.argDelimiter = opts?.argDelimiter ?? ', ';
+        this.useColors = opts?.colors ?? true;
+    }
+    [exports.custom]() {
+        return `PrettyHandler(level=${Level[this.level]})`;
+    }
+    [exports.customJson]() {
+        return {
+            $type: 'PrettyHandler',
+            level: Level[this.level],
+        };
+    }
+    matchFilters(name, level) {
+        const fs = Array.isArray(this.filters) ? this.filters : [this.filters];
+        for (const f of fs) {
+            if (typeof f === 'string') {
+                if (name.includes(f))
+                    return true;
+            }
+            else if (f instanceof RegExp) {
+                if (f.test(name))
+                    return true;
+            }
+            else if (typeof f === 'function') {
+                try {
+                    if (f(name, level))
+                        return true;
+                }
+                catch (e) {
+                    dbg('PrettyHandler.matchFilters: filter threw error', e);
+                }
+            }
+        }
+        return false;
+    }
+    colorize(text, code) {
+        if (!this.useColors)
+            return text;
+        const reset = '\x1b[0m';
+        return `${code}${text}${reset}`;
+    }
+    levelColor(level) {
+        // TRACE grey, DEBUG cyan, INFO green, WARN yellow, ERROR red
+        switch (level) {
+            case Level.TRACE:
+                return '\x1b[90m';
+            case Level.DEBUG:
+                return '\x1b[36m';
+            case Level.INFO:
+                return '\x1b[32m';
+            case Level.WARN:
+                return '\x1b[33m';
+            case Level.ERROR:
+                return '\x1b[31m';
+            default:
+                return '\x1b[37m';
+        }
+    }
+    formatArgs(args) {
+        const parts = [];
+        for (const key in args) {
+            if (Object.prototype.hasOwnProperty.call(args, key)) {
+                const val = args[key];
+                // Special-case Errors to show their message in red
+                let valStr;
+                let valueColor = '\x1b[37m'; // default white
+                try {
+                    if (val instanceof Error) {
+                        valStr = `${val.name}: ${val.message}`;
+                        valueColor = '\x1b[31m'; // red for errors
+                        if (val.stack) {
+                            valStr += `\n${this.colorize(cleanTrace(val.stack, val.message.split('\n').length - 1), '\x1b[90m')}`;
+                        }
+                    }
+                    else {
+                        valStr = (0, util_1.inspect)(val, { depth: 5 });
+                        // primitives & Date -> teal (use cyan ANSI as teal approximation)
+                        const vt = typeof val;
+                        const isPrimitiveOrDate = val === null ||
+                            vt === 'number' ||
+                            vt === 'boolean' ||
+                            vt === 'undefined' ||
+                            val instanceof Date;
+                        valueColor = isPrimitiveOrDate ? '\x1b[36m' : '\x1b[37m';
+                    }
+                }
+                catch (e) {
+                    valStr = String(val);
+                }
+                // keys grey, values colored based on type
+                const k = this.colorize(key, '\x1b[90m');
+                const v = this.colorize(valStr, valueColor);
+                parts.push(this.argFormat(k, v));
+            }
+        }
+        return parts.join(this.argDelimiter);
+    }
+    log(level, message, args, name, traceLevel) {
+        if (level < this.level)
+            return;
+        if (!this.matchFilters(name, level))
+            return;
+        if (this.alwaysAddTrace && traceLevel < 0) {
+            traceLevel = 3;
+        }
+        const timeStr = new Date().toISOString();
+        const levelStr = Level[level] ?? String(level);
+        const timeColored = this.colorize(timeStr, '\x1b[34m'); // blue
+        const levelColored = this.colorize(levelStr, this.levelColor(level));
+        const nameStr = name;
+        // Errors: message red, otherwise keep message yellow
+        const messageColored = this.colorize(message, level >= Level.ERROR ? '\x1b[31m' : level >= Level.WARN ? '\x1b[33m' : '\x1b[37m'); // red for ERROR, yellow for WARN, white otherwise
+        const argStr = Object.keys(args).length ? ` ${this.formatArgs(args)}` : '';
+        const trace = traceLevel >= 0 ? getTrace(traceLevel) : undefined;
+        const traceStr = trace ? `\n${this.colorize(trace, '\x1b[90m')}` : '';
+        const out = `${timeColored} [${levelColored}] ${nameStr}: ${messageColored}${argStr}${traceStr}`;
+        try {
+            this.consoleLike.error(out);
+        }
+        catch (e) {
+            dbg('PrettyHandler.log: consoleLike.error threw error', e, {
+                level,
+                message,
+                args,
+                name,
+                traceLevel,
+            });
+        }
+    }
+}
+exports.PrettyHandler = PrettyHandler;
+class JsonHandler {
+    consoleLike;
+    level;
+    filters;
+    alwaysAddTrace = false;
+    constructor(opts) {
+        this.alwaysAddTrace = !!opts?.alwaysAddTrace;
+        this.consoleLike = outputToConsoleLike(opts?.output);
+        this.level = opts?.level ?? Level.INFO;
+        this.filters = opts?.filters ?? /.*/;
+    }
+    [exports.custom]() {
+        return `JsonHandler(level=${Level[this.level]})`;
+    }
+    [exports.customJson]() {
+        return {
+            $type: 'JsonHandler',
+            level: Level[this.level],
+        };
+    }
+    matchFilters(name, level) {
+        const fs = Array.isArray(this.filters) ? this.filters : [this.filters];
+        for (const f of fs) {
+            if (typeof f === 'string') {
+                if (name.includes(f))
+                    return true;
+            }
+            else if (f instanceof RegExp) {
+                if (f.test(name))
+                    return true;
+            }
+            else if (typeof f === 'function') {
+                try {
+                    if (f(name, level))
+                        return true;
+                }
+                catch (e) {
+                    dbg('JsonHandler.matchFilters: filter threw error', e);
+                }
+            }
+        }
+        return false;
+    }
+    serializeValue(val) {
+        return inspectJson(val);
+    }
+    log(level, message, args, name, traceLevel = 3) {
+        if (level < this.level)
+            return;
+        if (!this.matchFilters(name, level))
+            return;
+        if (this.alwaysAddTrace && traceLevel < 0) {
+            traceLevel = 3;
+        }
+        const time = new Date();
+        const trace = traceLevel >= 0 ? getTrace(traceLevel) : undefined;
+        const serializedArgs = {};
+        for (const key in args) {
+            if (Object.prototype.hasOwnProperty.call(args, key)) {
+                serializedArgs[key] = this.serializeValue(args[key]);
+            }
+        }
+        const outObj = {
+            ...serializedArgs,
+            time: time.toISOString(),
+            level: Level[level] ?? String(level),
+            name,
+            message,
+        };
+        if (trace)
+            outObj.trace = trace;
+        try {
+            this.consoleLike.error(JSON.stringify(outObj));
+        }
+        catch (e) {
+            dbg('JsonHandler.log: consoleLike.error threw error', e, {
+                level,
+                message,
+                args,
+                traceLevel,
+            });
+        }
+    }
+}
+exports.JsonHandler = JsonHandler;
+function parseLevel(v) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v === 'number') {
+        switch (v) {
+            case Level.TRACE:
+            case Level.DEBUG:
+            case Level.INFO:
+            case Level.WARN:
+            case Level.ERROR:
+            case Level.NONE:
+                return v;
+            default:
+                return undefined;
+        }
+    }
+    const s = String(v).trim().toUpperCase();
+    if (s === '')
+        return undefined;
+    // numeric string
+    if (/^\d+$/.test(s)) {
+        const n = parseInt(s, 10);
+        return parseLevel(n);
+    }
+    switch (s) {
+        case 'TRACE':
+            return Level.TRACE;
+        case 'DEBUG':
+            return Level.DEBUG;
+        case 'INFO':
+            return Level.INFO;
+        case 'WARN':
+        case 'WARNING':
+            return Level.WARN;
+        case 'ERROR':
+            return Level.ERROR;
+        case 'NONE':
+        case 'OFF':
+            return Level.NONE;
+        default:
+            return undefined;
+    }
+}
+let deprecatedWarningLogger = null;
+function deprecatedWarn(message, type, fullName, date) {
+    try {
+        if (!deprecatedWarningLogger) {
+            let fullMsg = `[DEPRECATED] `;
+            if (type)
+                fullMsg += `${type} `;
+            if (fullName)
+                fullMsg += `${fullName}: `;
+            fullMsg += 'Deprecated';
+            if (date)
+                fullMsg += `, will be removed on: ${date}`;
+            fullMsg += `: ${message}.`;
+            return console.warn(fullMsg);
+        }
+        const args = {};
+        if (type)
+            args['type'] = type;
+        if (fullName)
+            args['full name'] = fullName;
+        if (date)
+            args['will be removed on'] = date;
+        deprecatedWarningLogger.warn(`Deprecated: ${message}.`, args);
+    }
+    catch (e) {
+        dbg('deprecatedWarn: error logging deprecation warning', e, {
+            message,
+            type,
+            fullName,
+            date,
+        });
+    }
+}
+function setDeprecatedWarningLogger(logger) {
+    dbg('setDeprecatedWarningLogger: called');
+    deprecatedWarningLogger = logger.detached('nebius.deprecated');
+}
+function defaultHandler(opts) {
+    dbg('defaultHandler: called', { opts });
+    // Detect if stderr is a TTY and supports colors. Respect NO_COLOR and FORCE_COLOR env vars.
+    const env = typeof process !== 'undefined' && process.env ? process.env : {};
+    const forceColor = env.FORCE_COLOR;
+    const noColor = env.NO_COLOR;
+    const isTTY = typeof process !== 'undefined' &&
+        process.stderr &&
+        process.stderr.isTTY;
+    const useJson = typeof opts?.useJson === 'boolean' ? opts.useJson : process?.env?.NEBIUS_LOG_JSON === 'true';
+    dbg('defaultHandler: useJson resolved', { useJson, optsUseJson: opts?.useJson });
+    let output = opts?.output;
+    if (output === undefined) {
+        if (process?.env?.NEBIUS_LOG_OUTPUT === 'stderr') {
+            output = (x) => process.stderr.write(x);
+            dbg('defaultHandler: output set to stderr due to NEBIUS_LOG_OUTPUT=stderr');
+        }
+        else if (process?.env?.NEBIUS_LOG_OUTPUT === 'stdout') {
+            output = (x) => process.stdout.write(x);
+            dbg('defaultHandler: output set to stdout due to NEBIUS_LOG_OUTPUT=stdout');
+        }
+        else if (process?.env?.NEBIUS_LOG_OUTPUT === 'console') {
+            output = console;
+            dbg('defaultHandler: output set to console due to NEBIUS_LOG_OUTPUT=console');
+        }
+        else if (process?.env?.NEBIUS_LOG_OUTPUT === 'none') {
+            output = () => { };
+            dbg('defaultHandler: output set to no-op due to NEBIUS_LOG_OUTPUT=none');
+        }
+        else if (process?.env?.NEBIUS_LOG_OUTPUT) {
+            output = process.env.NEBIUS_LOG_OUTPUT;
+            dbg('defaultHandler: output set to file due to NEBIUS_LOG_OUTPUT=<file_path>', {
+                output,
+            });
+        }
+    }
+    else {
+        dbg('defaultHandler: output provided in options', { output });
+    }
+    const detectedColored = !!forceColor ? forceColor !== '0' : !noColor && !!isTTY;
+    const colored = opts?.colored !== undefined ? opts.colored : detectedColored;
+    dbg('defaultHandler: color detection', { forceColor, noColor, isTTY, detectedColored, colored });
+    // Resolve levels from env variables. NEBIUS_LOG sets global level. NEBIUS_LOG_<NAME> sets per-name filter levels.
+    const globalFromEnv = parseLevel(env.NEBIUS_LOG);
+    const baseLevel = opts?.level ?? globalFromEnv ?? Level.INFO;
+    dbg('defaultHandler: base level resolved', { baseLevel, globalFromEnv, optsLevel: opts?.level });
+    const envAlwaysAddTrace = env.NEBIUS_LOG_ALWAYS_ADD_TRACE === 'true';
+    const alwaysAddTrace = opts?.alwaysAddTrace !== undefined ? opts.alwaysAddTrace : envAlwaysAddTrace;
+    dbg('defaultHandler: alwaysAddTrace resolved', { alwaysAddTrace, envAlwaysAddTrace, opts });
+    const envFilters = [];
+    const envFiltersMap = new Map();
+    for (const k of Object.keys(env)) {
+        const m = k.match(/^NEBIUS_LOG_(.+)$/);
+        if (!m)
+            continue;
+        const name = m[1];
+        const val = env[k];
+        const lvl = parseLevel(val);
+        if (lvl === undefined)
+            continue;
+        // add filter: include logs for names that contain this name and meet level threshold
+        envFilters.push((n, l) => n.includes(name) && l >= lvl);
+        envFiltersMap.set(name, lvl);
+    }
+    // combine provided filters with env filters
+    let combinedFilters;
+    if (opts?.filters !== undefined) {
+        dbg('defaultHandler: using filters from options and env filters', { envFiltersMap });
+        // if caller supplied filters, combine with env filters
+        const baseFilters = opts.filters;
+        combinedFilters = Array.isArray(baseFilters) ? [...baseFilters] : [baseFilters];
+        combinedFilters.push(...envFilters);
+    }
+    else if (envFilters.length > 0) {
+        dbg('defaultHandler: using only env filters', envFiltersMap);
+        // if caller didn't supply filters but env defines some, use only env filters
+        combinedFilters = [...envFilters];
+    }
+    else {
+        dbg('defaultHandler: no filters defined, using match-all');
+        // neither caller nor env supplied filters -> default to match all
+        combinedFilters = [/./];
+    }
+    let ret;
+    if (useJson) {
+        ret = new JsonHandler({
+            output,
+            level: baseLevel,
+            filters: combinedFilters,
+            alwaysAddTrace,
+        });
+    }
+    else if (colored) {
+        ret = new PrettyHandler({
+            output,
+            level: baseLevel,
+            filters: combinedFilters,
+            colors: true,
+            alwaysAddTrace,
+        });
+    }
+    else {
+        ret = new ConsoleHandler({
+            output,
+            level: baseLevel,
+            filters: combinedFilters,
+            alwaysAddTrace,
+        });
+    }
+    if (!deprecatedWarningLogger) {
+        setDeprecatedWarningLogger(new Logger(ret));
+    }
+    return ret;
+}
+function loggerChain(handler, names) {
+    let ret = new Logger(handler, names[0]);
+    for (let i = 1; i < names.length; i++) {
+        ret = ret.child(names[i]);
+    }
+    return ret;
+}
+function resolveLogger(spec, defaultName = ['nebius.default'], opts) {
+    dbg('resolveLogger: called', { spec, defaultName, opts });
+    if (typeof defaultName === 'string') {
+        defaultName = defaultName.split('.').filter((x) => x.length > 0);
+    }
+    // If already a Logger, return it
+    if (spec && typeof spec.getHandler === 'function') {
+        dbg('resolveLogger: spec is already a Logger');
+        return spec;
+    }
+    // If it's a Handler, wrap in a Logger
+    if (spec && typeof spec.log === 'function') {
+        dbg('resolveLogger: spec is a Handler');
+        return loggerChain(spec, defaultName);
+    }
+    // If string/number treat as level
+    if (typeof spec === 'string' || typeof spec === 'number') {
+        dbg('resolveLogger: spec is a level string/number');
+        const lvl = parseLevel(spec);
+        const handler = defaultHandler({
+            output: opts?.output,
+            level: lvl ?? opts?.level,
+            filters: opts?.filters,
+            colored: opts?.colored,
+            alwaysAddTrace: opts?.alwaysAddTrace,
+            useJson: opts?.useJson,
+        });
+        return loggerChain(handler, defaultName);
+    }
+    dbg('resolveLogger: spec is empty or unrecognized');
+    // Fallback to default handler
+    const handler = defaultHandler({
+        output: opts?.output,
+        level: opts?.level,
+        filters: opts?.filters,
+        colored: opts?.colored,
+        alwaysAddTrace: opts?.alwaysAddTrace,
+        useJson: opts?.useJson,
+    });
+    return loggerChain(handler, defaultName);
+}
+class NoopHandler {
+    log(_level, _message, _args, _name, _traceLevel) {
+        // no-op
+    }
+}
+exports.noopHandler = new NoopHandler();
+class Logger {
+    handler;
+    name;
+    withFieldsArg;
+    parent;
+    traceByDefault;
+    constructor(handler = exports.noopHandler, name = 'default', withFieldsArg = {}, parent, traceByDefault = false) {
+        this.handler = handler;
+        this.name = name;
+        this.withFieldsArg = withFieldsArg;
+        this.parent = parent;
+        this.traceByDefault = traceByDefault;
+    }
+    [exports.custom]() {
+        return `Logger(name=${this.name}, handler=${(0, util_1.inspect)(this.handler)})`;
+    }
+    [exports.customJson]() {
+        return {
+            $type: 'Logger',
+            name: this.name,
+            handler: inspectJson(this.handler),
+        };
+    }
+    get getName() {
+        return this.name;
+    }
+    info(message, args, withTrace) {
+        this._log(Level.INFO, message, args ?? {}, withTrace);
+    }
+    warn(message, args, withTrace) {
+        this._log(Level.WARN, message, args ?? {}, withTrace);
+    }
+    error(message, args, withTrace) {
+        this._log(Level.ERROR, message, args ?? {}, withTrace);
+    }
+    debug(message, args, withTrace) {
+        this._log(Level.DEBUG, message, args ?? {}, withTrace);
+    }
+    trace(message, args, withTrace) {
+        this._log(Level.TRACE, message, args ?? {}, withTrace);
+    }
+    _log(level, message, args, withTrace) {
+        try {
+            if (withTrace === undefined) {
+                withTrace = this.traceByDefault;
+            }
+            this.handler.log(level, message, { ...this.withFieldsArg, ...args }, this.name, withTrace ? 3 : -1);
+        }
+        catch (e) {
+            dbg('Logger._log: handler.log threw error', e, { level, message, args, withTrace });
+        }
+    }
+    log(level, message, args, withTrace) {
+        this._log(level, message, args ?? {}, !!withTrace);
+    }
+    withFields(fields, traceByDefault) {
+        // withFields is sort of the same logger, so keep the same traceByDefault
+        return new Logger(this.handler, this.name, { ...this.withFieldsArg, ...fields }, this.parent, traceByDefault !== undefined ? traceByDefault : this.traceByDefault);
+    }
+    detached(name, additionalArguments = {}, traceByDefault = false) {
+        return new Logger(this.handler, name, additionalArguments, this, traceByDefault);
+    }
+    child(suffix, additionalArguments = {}, traceByDefault = false) {
+        return new Logger(this.handler, `${this.name}.${suffix}`, { ...this.withFieldsArg, ...additionalArguments }, this, traceByDefault);
+    }
+    sibling(siblingName, additionalArguments = {}, traceByDefault = false) {
+        if (!this.parent) {
+            return new Logger(this.handler, siblingName, {
+                ...this.withFieldsArg,
+                ...additionalArguments,
+            }, undefined, traceByDefault);
+        }
+        const baseName = this.parent.name;
+        return new Logger(this.handler, `${baseName}.${siblingName}`, {
+            ...this.withFieldsArg,
+            ...additionalArguments,
+        }, this.parent, traceByDefault);
+    }
+    get getHandler() {
+        return this.handler;
+    }
+}
+exports.Logger = Logger;
+//# sourceMappingURL=logging.js.map