@travetto/log 7.0.0-rc.0 → 7.0.0-rc.2

package/README.md

@@ -39,8 +39,8 @@ import { LogFormatter, LogCommonSymbol, LogEvent } from '@travetto/log';
 @Injectable(LogCommonSymbol)
 export class SampleFormatter implements LogFormatter {
 
-  format(e: LogEvent): string {
-    return `${e.timestamp} [${e.level}]#[${e.scope ?? 'unknown'}] ${e.message ?? 'NO MESSAGE'} ${(e.args ?? []).join(' ')}`;
+  format(event: LogEvent): string {
+    return `${event.timestamp} [${event.level}]#[${event.scope ?? 'unknown'}] ${event.message ?? 'NO MESSAGE'} ${(event.args ?? []).join(' ')}`;
   }
 }
 ```
@@ -53,7 +53,7 @@ The default pattern for logging is to create a [Logger](https://github.com/trave
 **Code: Logger Shape**
 ```typescript
 export interface Logger {
-  log(ev: LogEvent): unknown;
+  log(event: LogEvent): unknown;
 }
 ```
 
@@ -98,10 +98,10 @@ import { LogEvent, Logger } from '@travetto/log';
 
 @Injectable()
 export class CustomLogger implements Logger {
-  log(ev: LogEvent): void {
+  log(event: LogEvent): void {
     const headers = new Headers();
     headers.set('Content-Type', 'application/json');
-    const body = JSON.stringify(ev);
+    const body = JSON.stringify(event);
     fetch('http://localhost:8080/log', { method: 'POST', headers, body, });
   }
 }
@@ -113,7 +113,7 @@ In addition to being able to control the entire logging experience, there are al
 **Code: Log Decorator Shape**
 ```typescript
 export interface LogDecorator {
-  decorate(ev: LogEvent): LogEvent;
+  decorate(event: LogEvent): LogEvent;
 }
 ```
 
@@ -126,12 +126,12 @@ import { LogDecorator, LogEvent } from '@travetto/log';
 
 @Injectable()
 export class CustomDecorator implements LogDecorator {
-  decorate(ev: LogEvent): LogEvent {
-    ev.args.push({
+  decorate(event: LogEvent): LogEvent {
+    event.args.push({
       memory: process.memoryUsage,
       hostname: os.hostname()
     });
-    return ev;
+    return event;
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/log",
-  "version": "7.0.0-rc.0",
+  "version": "7.0.0-rc.2",
   "description": "Logging framework that integrates at the console.log level.",
   "keywords": [
     "typescript",
@@ -23,9 +23,9 @@
     "directory": "module/log"
   },
   "dependencies": {
-    "@travetto/config": "^7.0.0-rc.0",
-    "@travetto/di": "^7.0.0-rc.0",
-    "@travetto/terminal": "^7.0.0-rc.0"
+    "@travetto/config": "^7.0.0-rc.2",
+    "@travetto/di": "^7.0.0-rc.2",
+    "@travetto/terminal": "^7.0.0-rc.2"
   },
   "travetto": {
     "displayName": "Logging"

package/src/appender/console.ts

@@ -20,7 +20,7 @@ export class ConsoleLogAppender implements LogAppender {
     this.config = config;
   }
 
-  append(ev: LogEvent, formatted: string): void {
-    console![this.config.logToLevel ? ev.level : 'log'](formatted);
+  append(event: LogEvent, formatted: string): void {
+    console![this.config.logToLevel ? event.level : 'log'](formatted);
   }
 }

package/src/appender/file.ts

@@ -27,22 +27,22 @@ export class FileLogAppenderConfig {
 @Injectable()
 export class FileLogAppender implements LogAppender {
   stream?: WriteStream;
-  appendFd?: number;
+  appendDescriptor?: number;
 
-  constructor(opts: FileLogAppenderConfig) {
-    mkdirSync(path.dirname(opts.output!), { recursive: true });
-    if (opts.writeSync) {
-      this.appendFd = openSync(opts.output!, 'a');
+  constructor(config: FileLogAppenderConfig) {
+    mkdirSync(path.dirname(config.output!), { recursive: true });
+    if (config.writeSync) {
+      this.appendDescriptor = openSync(config.output!, 'a');
     } else {
-      this.stream = createWriteStream(opts.output!, { autoClose: true, flags: 'a' });
+      this.stream = createWriteStream(config.output!, { autoClose: true, flags: 'a' });
     }
   }
 
-  append(ev: LogEvent, formatted: string): void {
+  append(event: LogEvent, formatted: string): void {
     if (this.stream) {
       this.stream.write(`${formatted}\n`);
     } else {
-      appendFileSync(this.appendFd!, `${formatted}\n`);
+      appendFileSync(this.appendDescriptor!, `${formatted}\n`);
     }
   }
 }

package/src/common.ts

@@ -39,7 +39,7 @@ export class CommonLogger implements Logger {
     this.appender ??= await DependencyRegistryIndex.getInstance(appenderCls);
   }
 
-  log(ev: LogEvent): void {
-    this.appender.append(ev, this.formatter.format(ev));
+  log(event: LogEvent): void {
+    this.appender.append(event, this.formatter.format(event));
   }
 }

package/src/formatter/google.ts

@@ -10,8 +10,8 @@ import { LogFormatUtil } from './util.ts';
  */
 @Injectable()
 export class GoogleLogFormatter implements LogFormatter {
-  format(ev: LogEvent): string {
-    const context = LogFormatUtil.getContext(ev);
+  format(event: LogEvent): string {
+    const context = LogFormatUtil.getContext(event);
 
     const extra: Record<string, unknown> = {};
     // Http request specific
@@ -28,11 +28,11 @@ export class GoogleLogFormatter implements LogFormatter {
 
     return JSON.stringify({
       context,
-      'logging.googleapis.com/sourceLocation': { file: `${ev.module}/${ev.modulePath}`, line: ev.line },
-      'logging.googleapis.com/labels': { module: ev.module, scope: ev.scope },
-      severity: ev.level,
-      message: LogFormatUtil.getLogMessage(ev),
-      timestamp: ev.timestamp,
+      'logging.googleapis.com/sourceLocation': { file: `${event.module}/${event.modulePath}`, line: event.line },
+      'logging.googleapis.com/labels': { module: event.module, scope: event.scope },
+      severity: event.level,
+      message: LogFormatUtil.getLogMessage(event),
+      timestamp: event.timestamp,
       ...extra,
     });
   }

package/src/formatter/json.ts

@@ -14,20 +14,20 @@ export class JSONLogFormatterConfig {
  */
 @Injectable()
 export class JsonLogFormatter implements LogFormatter {
-  opts: JSONLogFormatterConfig;
+  config: JSONLogFormatterConfig;
 
-  constructor(opts: JSONLogFormatterConfig) {
-    this.opts = opts;
+  constructor(config: JSONLogFormatterConfig) {
+    this.config = config;
   }
 
-  format(ev: LogEvent): string {
-    const { message: _m, args: _a, ...rest } = ev;
-    const message = LogFormatUtil.getLogMessage(ev);
-    const context = LogFormatUtil.getContext(ev);
+  format(event: LogEvent): string {
+    const { message: _m, args: _a, ...rest } = event;
+    const message = LogFormatUtil.getLogMessage(event);
+    const context = LogFormatUtil.getContext(event);
     return JSON.stringify({
       ...rest,
       ...(message ? { message } : {}),
       ...(context ? { context } : {}),
-    }, null, this.opts.jsonIndent);
+    }, null, this.config.jsonIndent);
   }
 }

package/src/formatter/line.ts

@@ -80,50 +80,50 @@ export class LineLogFormatterConfig {
 @Injectable()
 export class LineLogFormatter implements LogFormatter {
 
-  opts: LineLogFormatterConfig;
+  config: LineLogFormatterConfig;
 
-  constructor(opts: LineLogFormatterConfig) {
-    this.opts = opts;
+  constructor(config: LineLogFormatterConfig) {
+    this.config = config;
   }
 
   /**
    * Format an event into a single line
    */
-  format(ev: LogEvent): string {
+  format(event: LogEvent): string {
     const out = [];
 
-    if (this.opts.timestamp) {
-      let timestamp = ev.timestamp.toISOString();
-      if (this.opts.timestamp === 's') {
+    if (this.config.timestamp) {
+      let timestamp = event.timestamp.toISOString();
+      if (this.config.timestamp === 's') {
         timestamp = timestamp.replace(/[.]\d{3}/, '');
       }
-      if (this.opts.colorize) {
+      if (this.config.colorize) {
         timestamp = STYLES.timestamp(timestamp);
       }
       out.push(timestamp);
     }
 
-    if (this.opts.level) {
-      let level: string = ev.level;
-      if (this.opts.align) {
+    if (this.config.level) {
+      let level: string = event.level;
+      if (this.config.align) {
         level = level.padEnd(5, ' ');
       }
-      if (this.opts.colorize) {
-        level = STYLES[ev.level](level);
+      if (this.config.colorize) {
+        level = STYLES[event.level](level);
       }
       out.push(level);
     }
 
-    if (ev.modulePath && this.opts.location) {
-      const ns = `${ev.module}:${ev.modulePath}`;
-      let loc = ev.line ? `${ns}:${ev.line}` : ns;
-      if (this.opts.colorize) {
-        loc = STYLES.location(loc);
+    if (event.modulePath && this.config.location) {
+      const namespace = `${event.module}:${event.modulePath}`;
+      let location = event.line ? `${namespace}:${event.line}` : namespace;
+      if (this.config.colorize) {
+        location = STYLES.location(location);
       }
-      out.push(`[${loc}]`);
+      out.push(`[${location}]`);
     }
 
-    out.push(LogFormatUtil.getLogMessage(ev, this.opts.inspectOptions));
+    out.push(LogFormatUtil.getLogMessage(event, this.config.inspectOptions));
 
     return out.join(' ');
   }

package/src/formatter/util.ts

@@ -9,19 +9,19 @@ const INSPECT_OPTIONS = { colors: false, showHidden: false, depth: 5, breakLengt
 
 export class LogFormatUtil {
   /** Generate log context */
-  static getContext(ev: LogEvent): Record<string, unknown> | undefined {
+  static getContext(event: LogEvent): Record<string, unknown> | undefined {
     const out: Record<string, unknown> = {};
-    for (const o of ev.args ?? []) {
-      if (DataUtil.isPlainObject(o)) {
-        safeAssign(out, o);
+    for (const arg of event.args ?? []) {
+      if (DataUtil.isPlainObject(arg)) {
+        safeAssign(out, arg);
       }
     }
     return out && Object.keys(out).length > 0 ? out : undefined;
   }
 
   /** Get log message */
-  static getLogMessage(ev: LogEvent, options: InspectOptions = INSPECT_OPTIONS): string {
-    const formatted = ev.args?.map(x => typeof x === 'string' ? x : inspect(x, options)) ?? [];
-    return (ev.message ? [ev.message, ...formatted] : formatted).join(' ');
+  static getLogMessage(event: LogEvent, options: InspectOptions = INSPECT_OPTIONS): string {
+    const formatted = event.args?.map(arg => typeof arg === 'string' ? arg : inspect(arg, options)) ?? [];
+    return (event.message ? [event.message, ...formatted] : formatted).join(' ');
   }
 }

package/src/service.ts

@@ -21,7 +21,7 @@ export class LogService implements ConsoleListener {
   #decorators: LogDecorator[] = [];
 
   async postConstruct(): Promise<void> {
-    this.#listeners = await DependencyRegistryIndex.getInstances(toConcrete<Logger>(), c => c.class !== CommonLogger);
+    this.#listeners = await DependencyRegistryIndex.getInstances(toConcrete<Logger>(), candidate => candidate.class !== CommonLogger);
     if (!this.#listeners.length) {
       this.#listeners = [await DependencyRegistryIndex.getInstance(CommonLogger)];
     }
@@ -34,8 +34,8 @@ export class LogService implements ConsoleListener {
   /**
    * Endpoint for listening, endpoint registered with ConsoleManager
    */
-  log(ev: ConsoleEvent): void {
-    const args = [...ev.args];
+  log(event: ConsoleEvent): void {
+    const args = [...event.args];
     let message: string | undefined;
     if (typeof args[0] === 'string') {
       message = args[0];
@@ -43,15 +43,15 @@ export class LogService implements ConsoleListener {
     }
 
     // Allow for controlled order of event properties
-    let outEvent: LogEvent = { ...ev, message, args };
+    let outEvent: LogEvent = { ...event, message, args };
 
     // Decorate event as needed
-    for (const d of this.#decorators) {
-      outEvent = d.decorate(outEvent);
+    for (const decorators of this.#decorators) {
+      outEvent = decorators.decorate(outEvent);
     }
 
-    for (const l of this.#listeners) {
-      l.log(outEvent);
+    for (const listener of this.#listeners) {
+      listener.log(outEvent);
     }
   }
 }

package/src/types.ts

@@ -18,7 +18,7 @@ export interface LogEvent extends ConsoleEvent {
  * @concrete
  */
 export interface LogDecorator {
-  decorate(ev: LogEvent): LogEvent;
+  decorate(event: LogEvent): LogEvent;
 }
 
 /**
@@ -26,7 +26,7 @@ export interface LogDecorator {
  * @concrete
  */
 export interface LogAppender {
-  append(ev: LogEvent, formatted: string): void;
+  append(event: LogEvent, formatted: string): void;
 }
 
 /**
@@ -34,7 +34,7 @@ export interface LogAppender {
  * @concrete
  */
 export interface LogFormatter {
-  format(e: LogEvent): string;
+  format(event: LogEvent): string;
 }
 
 /**
@@ -42,5 +42,5 @@ export interface LogFormatter {
  * @concrete
  */
 export interface Logger {
-  log(ev: LogEvent): unknown;
+  log(event: LogEvent): unknown;
 }