@velajs/vela 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export type { Type, Token, InjectableOptions, ProviderOptions, } from './contain
 export { METADATA_KEYS, HttpMethod, ParamType, Scope } from './constants';
 export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, } from './http/index';
 export { Logger, LogLevel } from './services/index';
-export type { LoggerService } from './services/index';
+export type { LoggerService, ContextProvider, Writer, LoggerLevelName } from './services/index';
 export { ConfigModule, ConfigService, CONFIG_OPTIONS } from './config/index';
 export type { ConfigModuleOptions } from './config/index';
 export { HttpModule, HttpService, HTTP_MODULE_OPTIONS, HttpRequestException } from './fetch/index';

package/dist/services/index.d.ts

@@ -1,2 +1,2 @@
 export { Logger, LogLevel } from './logger';
-export type { LoggerService } from './logger';
+export type { LoggerService, ContextProvider, Writer, LoggerLevelName } from './logger';

package/dist/services/logger.d.ts

@@ -13,18 +13,46 @@ export interface LoggerService {
     debug?(message: unknown, ...optionalParams: unknown[]): void;
     verbose?(message: unknown, ...optionalParams: unknown[]): void;
 }
+export type ContextProvider = () => Record<string, unknown>;
+export type LoggerLevelName = 'LOG' | 'ERROR' | 'WARN' | 'DEBUG' | 'VERBOSE';
+export type Writer = (level: LoggerLevelName, line: string, ...rest: unknown[]) => void;
 export declare class Logger implements LoggerService {
     static level: LogLevel;
     private static globalLogger;
+    private static globalContextProviders;
+    private static globalWriter;
     private context?;
+    private instanceContextProviders;
+    private instanceWriter?;
     static setLogLevel(level: LogLevel): void;
     static overrideLogger(logger: LoggerService | false): void;
+    /** Register a context provider run on every log line from every logger. */
+    static addContextProvider(provider: ContextProvider): void;
+    /** Remove all registered global context providers. */
+    static clearContextProviders(): void;
+    /** Replace the default console writer. Useful on edge runtimes that have
+     *  a different output sink (e.g. `env.LOGS.writeDataPoint` on Workers). */
+    static setWriter(writer: Writer): void;
+    /** Restore the default console-based writer. */
+    static resetWriter(): void;
     constructor(context?: string);
     setContext(context: string): void;
+    /** Add a context provider that runs only for THIS logger instance.
+     *  Children created via extend() inherit these providers by copy. */
+    addContextProvider(provider: ContextProvider): this;
+    /** Override the writer for this logger (and any extend() children). */
+    setWriter(writer: Writer): this;
+    /** Create a child logger with a nested namespace. Context becomes
+     *  `parent:child`; instance-level providers and writers are inherited
+     *  by copy so later mutations on either logger stay isolated. */
+    extend(namespace: string): Logger;
     log(message: unknown, ...optionalParams: unknown[]): void;
     error(message: unknown, ...optionalParams: unknown[]): void;
     warn(message: unknown, ...optionalParams: unknown[]): void;
     debug(message: unknown, ...optionalParams: unknown[]): void;
     verbose(message: unknown, ...optionalParams: unknown[]): void;
+    private emit;
     private formatMessage;
+    private collectContext;
+    private formatContextObj;
 }

package/dist/services/logger.js

@@ -17,16 +17,50 @@ export var LogLevel = /*#__PURE__*/ function(LogLevel) {
     LogLevel[LogLevel["SILENT"] = 5] = "SILENT";
     return LogLevel;
 }({});
+const defaultWriter = (level, line, ...rest)=>{
+    if (level === 'ERROR') return console.error(line, ...rest);
+    if (level === 'WARN') return console.warn(line, ...rest);
+    if (level === 'DEBUG' || level === 'VERBOSE') return console.debug(line, ...rest);
+    return console.log(line, ...rest);
+};
+function formatValue(v) {
+    if (typeof v === 'string') {
+        return /[\s="\\]/.test(v) ? JSON.stringify(v) : v;
+    }
+    if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+    try {
+        return JSON.stringify(v);
+    } catch  {
+        return String(v);
+    }
+}
 export class Logger {
     static level = 2;
     static globalLogger;
+    static globalContextProviders = [];
+    static globalWriter = defaultWriter;
     context;
+    instanceContextProviders = [];
+    instanceWriter;
     static setLogLevel(level) {
         Logger.level = level;
     }
     static overrideLogger(logger) {
         Logger.globalLogger = logger;
     }
+    /** Register a context provider run on every log line from every logger. */ static addContextProvider(provider) {
+        Logger.globalContextProviders.push(provider);
+    }
+    /** Remove all registered global context providers. */ static clearContextProviders() {
+        Logger.globalContextProviders = [];
+    }
+    /** Replace the default console writer. Useful on edge runtimes that have
+   *  a different output sink (e.g. `env.LOGS.writeDataPoint` on Workers). */ static setWriter(writer) {
+        Logger.globalWriter = writer;
+    }
+    /** Restore the default console-based writer. */ static resetWriter() {
+        Logger.globalWriter = defaultWriter;
+    }
     constructor(context){
         if (context) {
             this.context = context;
@@ -35,55 +69,86 @@ export class Logger {
     setContext(context) {
         this.context = context;
     }
+    /** Add a context provider that runs only for THIS logger instance.
+   *  Children created via extend() inherit these providers by copy. */ addContextProvider(provider) {
+        this.instanceContextProviders.push(provider);
+        return this;
+    }
+    /** Override the writer for this logger (and any extend() children). */ setWriter(writer) {
+        this.instanceWriter = writer;
+        return this;
+    }
+    /** Create a child logger with a nested namespace. Context becomes
+   *  `parent:child`; instance-level providers and writers are inherited
+   *  by copy so later mutations on either logger stay isolated. */ extend(namespace) {
+        const newContext = this.context ? `${this.context}:${namespace}` : namespace;
+        const child = new Logger(newContext);
+        child.instanceContextProviders = [
+            ...this.instanceContextProviders
+        ];
+        if (this.instanceWriter) child.instanceWriter = this.instanceWriter;
+        return child;
+    }
     log(message, ...optionalParams) {
-        if (Logger.level > 2) return;
-        if (Logger.globalLogger === false) return;
-        if (Logger.globalLogger) {
-            Logger.globalLogger.log(message, ...optionalParams);
-            return;
-        }
-        console.log(this.formatMessage('LOG', message), ...optionalParams);
+        this.emit('LOG', 2, message, optionalParams);
     }
     error(message, ...optionalParams) {
-        if (Logger.level > 4) return;
-        if (Logger.globalLogger === false) return;
-        if (Logger.globalLogger) {
-            Logger.globalLogger.error(message, ...optionalParams);
-            return;
-        }
-        console.error(this.formatMessage('ERROR', message), ...optionalParams);
+        this.emit('ERROR', 4, message, optionalParams);
     }
     warn(message, ...optionalParams) {
-        if (Logger.level > 3) return;
-        if (Logger.globalLogger === false) return;
-        if (Logger.globalLogger) {
-            Logger.globalLogger.warn(message, ...optionalParams);
-            return;
-        }
-        console.warn(this.formatMessage('WARN', message), ...optionalParams);
+        this.emit('WARN', 3, message, optionalParams);
     }
     debug(message, ...optionalParams) {
-        if (Logger.level > 1) return;
-        if (Logger.globalLogger === false) return;
-        if (Logger.globalLogger) {
-            Logger.globalLogger.debug?.(message, ...optionalParams);
-            return;
-        }
-        console.debug(this.formatMessage('DEBUG', message), ...optionalParams);
+        this.emit('DEBUG', 1, message, optionalParams);
     }
     verbose(message, ...optionalParams) {
-        if (Logger.level > 0) return;
+        this.emit('VERBOSE', 0, message, optionalParams);
+    }
+    emit(levelName, levelValue, message, rest) {
+        if (Logger.level > levelValue) return;
         if (Logger.globalLogger === false) return;
         if (Logger.globalLogger) {
-            Logger.globalLogger.verbose?.(message, ...optionalParams);
+            const method = levelName.toLowerCase();
+            const fn = Logger.globalLogger[method];
+            if (fn) fn.call(Logger.globalLogger, message, ...rest);
             return;
         }
-        console.debug(this.formatMessage('VERBOSE', message), ...optionalParams);
+        const line = this.formatMessage(levelName, message);
+        const writer = this.instanceWriter ?? Logger.globalWriter;
+        writer(levelName, line, ...rest);
     }
     formatMessage(level, message) {
         const timestamp = new Date().toISOString();
         const ctx = this.context ? ` [${this.context}]` : '';
-        return `[Vela] ${timestamp} ${level}${ctx} ${message}`;
+        const contextStr = this.formatContextObj(this.collectContext());
+        return `[Vela] ${timestamp} ${level}${ctx} ${message}${contextStr}`;
+    }
+    collectContext() {
+        const result = {};
+        for (const provider of Logger.globalContextProviders){
+            try {
+                Object.assign(result, provider());
+            } catch  {
+            // Provider threw; drop its contribution and keep going.
+            }
+        }
+        for (const provider of this.instanceContextProviders){
+            try {
+                Object.assign(result, provider());
+            } catch  {
+            // Same — never let a provider break logging.
+            }
+        }
+        return result;
+    }
+    formatContextObj(obj) {
+        const parts = [];
+        for (const key of Object.keys(obj)){
+            const value = obj[key];
+            if (value === undefined || value === null) continue;
+            parts.push(`${key}=${formatValue(value)}`);
+        }
+        return parts.length > 0 ? ` ${parts.join(' ')}` : '';
     }
 }
 Logger = _ts_decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/vela",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",