@adviser/cement 0.0.0-jsr-t1 → 0.0.0-smoke-ci

package/src/logger-impl.ts

@@ -9,39 +9,38 @@ import {
   logValue,
   Serialized,
   WithLogger,
-  removeSelfRef,
+  // sanitizeSerialize,
   Sized,
   Lengthed,
   LogValue,
-  asyncLogValue,
   LevelHandler,
   LogFormatter,
   LogValueArg,
+  HttpType,
+  LogValueState,
 } from "./logger.js";
-import { WebSysAbstraction } from "./web/web-sys-abstraction.js";
-import { SysAbstraction } from "./sys-abstraction.js";
+import { BasicSysAbstraction } from "./sys-abstraction.js";
 import { Result } from "./result.js";
 import { CoerceURI, URI } from "./uri.js";
-import { runtimeFn } from "./runtime.js";
-import { ConsoleWriterStream } from "./utils/console-write-stream.js";
-import { LogWriterStream } from "./log-writer-impl.js";
-import { TxtEnDecoder, Utf8EnDecoderSingleton } from "./txt-en-decoder.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "./txt-en-decoder.js";
 import { LevelHandlerSingleton } from "./log-level-impl.js";
+import { BasicSysAbstractionFactory } from "./base-sys-abstraction.js";
+import { LogWriterStream } from "./log-writer-impl.js";
 
-function getLen(value: unknown): LogValue {
+function getLen(value: unknown, lvs: LogValueState): LogValue {
   if (Array.isArray(value)) {
-    return logValue(() => value.length);
+    return logValue(() => value.length, lvs);
   } else if (typeof value === "string") {
-    return logValue(() => value.length);
+    return logValue(() => value.length, lvs);
   } else if (typeof value === "object" && value !== null) {
     if (typeof (value as Sized).size === "number") {
-      return logValue(() => (value as Sized).size);
+      return logValue(() => (value as Sized).size, lvs);
     } else if (typeof (value as Lengthed).length === "number") {
-      return logValue(() => (value as Lengthed).length);
+      return logValue(() => (value as Lengthed).length, lvs);
     }
-    return logValue(() => Object.keys(value).length);
+    return logValue(() => Object.keys(value).length, lvs);
   }
-  return logValue(() => -1);
+  return logValue(() => -1, lvs);
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -67,7 +66,13 @@ export class JSONFormatter implements LogFormatter {
     this._space = space;
   }
   format(attr: LogSerializable): Uint8Array {
-    return this._txtEnDe.encode(JSON.stringify(attr, removeSelfRef(), this._space) + "\n");
+    let ret: string;
+    try {
+      ret = JSON.stringify(attr, null, this._space);
+    } catch (e) {
+      ret = JSON.stringify({ internal: { message: (e as Error).message, stack: (e as Error).stack } });
+    }
+    return this._txtEnDe.encode(ret + "\n");
   }
 }
 
@@ -79,26 +84,32 @@ export class YAMLFormatter implements LogFormatter {
     this._space = space;
   }
   format(attr: LogSerializable): Uint8Array {
-    return this._txtEnDe.encode("---\n" + YAML.stringify(attr, removeSelfRef(), this._space) + "\n");
+    return this._txtEnDe.encode("---\n" + YAML.stringify(attr, null, this._space) + "\n");
   }
 }
 
 export interface LoggerImplParams {
   readonly out?: WritableStream<Uint8Array>;
   readonly logWriter?: LogWriterStream;
-  readonly sys?: SysAbstraction;
+  readonly sys?: BasicSysAbstraction;
   readonly withAttributes?: LogSerializable;
   readonly levelHandler?: LevelHandler;
   readonly txtEnDe?: TxtEnDecoder;
   readonly formatter?: LogFormatter;
 }
 
+function toLogValueCtx(lvh: LevelHandler): LogValueState {
+  return {
+    ignoreAttr: lvh.ignoreAttr,
+  };
+}
+
 export class LoggerImpl implements Logger {
-  readonly _sys: SysAbstraction;
+  readonly _sys: BasicSysAbstraction;
   readonly _attributes: LogSerializable = {};
   readonly _withAttributes: LogSerializable;
   readonly _logWriter: LogWriterStream;
-  readonly _levelHandler: LevelHandler;
+  readonly levelHandler: LevelHandler;
   readonly _txtEnDe: TxtEnDecoder;
   _formatter: LogFormatter;
   // readonly _id: string = "logger-" + Math.random().toString(36)
@@ -108,12 +119,12 @@ export class LoggerImpl implements Logger {
       params = {};
     }
     if (!params.sys) {
-      this._sys = WebSysAbstraction();
+      this._sys = BasicSysAbstractionFactory();
     } else {
       this._sys = params.sys;
     }
     if (!params.txtEnDe) {
-      this._txtEnDe = Utf8EnDecoderSingleton();
+      this._txtEnDe = TxtEnDecoderSingleton();
     } else {
       this._txtEnDe = params.txtEnDe;
     }
@@ -127,18 +138,18 @@ export class LoggerImpl implements Logger {
       this._logWriter = params.logWriter;
     } else {
       if (!params.out) {
-        const rt = runtimeFn();
-        let stream: WritableStream<Uint8Array>;
-        if (rt.isBrowser) {
-          stream = new ConsoleWriterStream();
-        } else {
-          if (rt.isNodeIsh || rt.isReactNative || rt.isDeno) {
-            stream = this._sys.Stdout();
-          } else {
-            throw new Error("No output defined for runtime");
-          }
-        }
-        this._logWriter = new LogWriterStream(stream);
+        // const rt = runtimeFn();
+        // let stream: WritableStream<Uint8Array>;
+        // if (rt.isBrowser) {
+        //   stream = new ConsoleWriterStream();
+        // } else {
+        //   if (rt.isNodeIsh || rt.isReactNative || rt.isDeno || rt.isCFWorker) {
+        //     stream = this._sys.Stdout();
+        //   } else {
+        //     throw new Error("No output defined for runtime");
+        //   }
+        // }
+        this._logWriter = new LogWriterStream(this._sys.Stdout());
       } else {
         this._logWriter = new LogWriterStream(params.out);
       }
@@ -150,19 +161,29 @@ export class LoggerImpl implements Logger {
     }
     this._attributes = { ...this._withAttributes };
     if (params.levelHandler) {
-      this._levelHandler = params.levelHandler;
+      this.levelHandler = params.levelHandler;
     } else {
-      this._levelHandler = LevelHandlerSingleton();
+      this.levelHandler = LevelHandlerSingleton();
     }
     // console.log("LoggerImpl", this._id, this._attributes, this._withAttributes)
   }
+  TimerStart(key: string): Logger {
+    const now = this.levelHandler.timerStart(key);
+    this.coerceKey(key, now.toISOString());
+    return this;
+  }
+  TimerEnd(key: string): Logger {
+    const dur = this.levelHandler.timerEnd(key);
+    this.coerceKey(key, `${dur.now.toISOString()} - ${dur.duration}ms`);
+    return this;
+  }
 
   TxtEnDe(): TxtEnDecoder {
     return this._txtEnDe;
   }
 
   Attributes(): Record<string, unknown> {
-    return JSON.parse(JSON.stringify(this._attributes, removeSelfRef()));
+    return JSON.parse(JSON.stringify(this._attributes, null)) as Record<string, unknown>;
     // return Array.from(Object.entries(this._attributes)).reduce(
     //   (acc, [key, value]) => {
     //     if (value instanceof LogValue) {
@@ -175,27 +196,32 @@ export class LoggerImpl implements Logger {
   }
 
   SetExposeStack(enable?: boolean): Logger {
-    this._levelHandler.setExposeStack(enable);
+    this.levelHandler.setExposeStack(enable);
     return this;
   }
 
   EnableLevel(level: Level, ...modules: string[]): Logger {
-    this._levelHandler.enableLevel(level, ...modules);
+    this.levelHandler.enableLevel(level, ...modules);
     return this;
   }
   DisableLevel(level: Level, ...modules: string[]): Logger {
-    this._levelHandler.disableLevel(level, ...modules);
+    this.levelHandler.disableLevel(level, ...modules);
     return this;
   }
 
   Module(key: string): Logger {
-    this._attributes["module"] = logValue(key);
-    this._withAttributes["module"] = logValue(key);
+    this._attributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
+    this._withAttributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
     return this;
   }
   // if the string is "*" it will enable for all modules
   SetDebug(...modules: (string | string[])[]): Logger {
-    this._levelHandler.setDebug(...modules);
+    this.levelHandler.setDebug(...modules);
+    return this;
+  }
+
+  SetIgnoreAttribute(re?: RegExp): Logger {
+    this.levelHandler.setIgnoreAttr(re);
     return this;
   }
 
@@ -205,67 +231,127 @@ export class LoggerImpl implements Logger {
   }
 
   Timestamp(): Logger {
-    this._attributes["ts"] = logValue(() => this._sys.Time().Now().toISOString());
+    this._attributes["ts"] = logValue(() => this._sys.Time().Now().toISOString(), toLogValueCtx(this.levelHandler));
     return this;
   }
   Warn(): Logger {
-    this._attributes["level"] = logValue(Level.WARN);
+    this._attributes["level"] = logValue(Level.WARN, toLogValueCtx(this.levelHandler));
     return this;
   }
   Log(): Logger {
     return this;
   }
   Debug(): Logger {
-    this._attributes["level"] = logValue(Level.DEBUG);
+    this._attributes["level"] = logValue(Level.DEBUG, toLogValueCtx(this.levelHandler));
     return this;
   }
   Error(): Logger {
-    this._attributes["level"] = logValue(Level.ERROR);
+    this._attributes["level"] = logValue(Level.ERROR, toLogValueCtx(this.levelHandler));
     return this;
   }
   Info(): Logger {
-    this._attributes["level"] = logValue(Level.INFO);
+    this._attributes["level"] = logValue(Level.INFO, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Err(err: unknown | Result<unknown> | Error): Logger {
+  Err<T>(err: T | Result<T> | Error): Logger {
+    let key = "error";
     if (Result.Is(err)) {
       if (err.isOk()) {
-        this.Result("noerror", err);
+        key = "noerror";
+        err = err.Ok();
+      } else {
+        err = err.Err();
+      }
+    }
+    if (err instanceof Error) {
+      if (err.cause) {
+        this.coerceKey(key, {
+          message: err.message,
+          cause: err.cause,
+        });
       } else {
-        this.Result("error", err);
+        this._attributes[key] = logValue(err.message, toLogValueCtx(this.levelHandler));
       }
-    } else if (err instanceof Error) {
-      this._attributes["error"] = logValue(err.message);
-      if (this._levelHandler.isStackExposed) {
-        this._attributes["stack"] = logValue(err.stack?.split("\n").map((s) => s.trim()));
+      if (this.levelHandler.isStackExposed) {
+        this._attributes["stack"] = logValue(
+          err.stack?.split(/[\r\n]+/).map((s) => s.trim()),
+          toLogValueCtx(this.levelHandler),
+        );
       }
     } else {
-      this._attributes["error"] = logValue("" + err);
+      this.Any(key, err as LogSerializable);
     }
     return this;
   }
   WithLevel(l: Level): Logger {
-    this._attributes["level"] = logValue(l);
+    this._attributes["level"] = logValue(l, toLogValueCtx(this.levelHandler));
     return this;
   }
 
   Ref(key: string, action: { toString: () => string } | FnSerialized): Logger {
     if (typeof action === "function") {
-      this._attributes[key] = logValue(action as FnSerialized);
+      this._attributes[key] = logValue(action as FnSerialized, toLogValueCtx(this.levelHandler));
     } else if (typeof action.toString === "function") {
-      this._attributes[key] = logValue(() => action.toString());
+      this._attributes[key] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
     } else {
-      this._attributes[key] = logValue("INVALID REF");
+      this._attributes[key] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
     }
     return this;
   }
-  Bool(key: string, value: unknown): Logger {
-    this._attributes[key] = logValue(!!value);
+  Bool(key: string | Record<string, unknown>, value: unknown): Logger {
+    this.coerceKey(key, !!value);
+    // this._attributes[key] = logValue(!!value);
+    return this;
+  }
+
+  Http(...mix: (HttpType | string)[]): Logger {
+    const key: string | undefined = mix.find((x) => typeof x === "string");
+    mix = mix.filter((x) => typeof x !== "string");
+    const resErrors = mix.filter((x) => Result.Is(x) && x.isErr()) as Result<unknown, Error>[];
+    if (resErrors.length) {
+      this.Err(resErrors.map((x) => x.Err().message).join("\n"));
+      return this;
+    }
+    const req = mix
+      .map((reqOrResult) => (Result.Is(reqOrResult) ? reqOrResult.Ok() : reqOrResult))
+      .find((req) => typeof (req as Response).status !== "number") as Request | undefined;
+    const res = mix
+      .map((resOrResult) => (Result.Is(resOrResult) ? resOrResult.Ok() : resOrResult))
+      .find((res) => typeof (res as Response).status === "number") as Response | undefined;
+    let reqAndOrres: { res: Response; req: Request } | Response | Request | undefined;
+    if (res && req) {
+      reqAndOrres = { res, req };
+    } else if (!res && !req) {
+      reqAndOrres = undefined;
+    } else if (res) {
+      reqAndOrres = res;
+    } else if (req) {
+      reqAndOrres = req;
+    }
+    if (reqAndOrres) {
+      this.Any(key || "Http", reqAndOrres as unknown as LogSerializable);
+    }
     return this;
   }
+  Pair(x: Record<string, unknown>): Logger {
+    for (const key of Object.keys(x)) {
+      const value = x[key];
+      if (value instanceof LogValue) {
+        this._attributes[key] = value;
+        continue;
+      }
+      if (Result.Is(value)) {
+        this.Result(key, value);
+        continue;
+      }
+      this.Any(key, value as LogSerializable);
+    }
+    return this;
+  }
+
   Result<T>(key: string, res: Result<T, Error>): Logger {
     if (res.isOk()) {
-      this._attributes[key] = logValue(res.Ok() as Serialized);
+      this._attributes[key] = logValue(res.Ok() as Serialized, toLogValueCtx(this.levelHandler));
     } else {
       this.Err(res.Err());
     }
@@ -273,13 +359,17 @@ export class LoggerImpl implements Logger {
   }
 
   Len(value: unknown, key = "len"): Logger {
-    this._attributes[key] = getLen(value);
+    this._attributes[key] = getLen(value, toLogValueCtx(this.levelHandler));
     return this;
   }
 
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   Hash(value: unknown, key = "hash"): Logger {
-    this._attributes[key] = asyncLogValue(async () => `${getLen(value).value()}:${await hash(value)}`);
-    return this;
+    throw new Error("Not implemented");
+    // this._attributes[key] = asyncLogValue(
+    //   async () => `${getLen(value, toLogValueCtx(this.levelHandler)).value()}:${await hash(value)}`,
+    // );
+    // return this;
   }
 
   Url(url: CoerceURI, key = "url"): Logger {
@@ -287,25 +377,35 @@ export class LoggerImpl implements Logger {
     return this;
   }
 
-  Str(key: string, value?: string): Logger {
-    this._attributes[key] = logValue(value);
+  private coerceKey(key: string | Record<string, unknown>, value?: unknown): void {
+    if (typeof key === "string") {
+      this._attributes[key] = logValue(value as LogValueArg, toLogValueCtx(this.levelHandler));
+    } else {
+      this.Pair(key);
+    }
+  }
+
+  Str(key: string | Record<string, string>, value?: string): Logger {
+    this.coerceKey(key, value);
     return this;
   }
 
-  Any(key: string, value?: string | number | boolean | LogSerializable): Logger {
-    this._attributes[key] = logValue(value as LogValueArg);
+  Any(key: string | Record<string, unknown>, value?: unknown): Logger {
+    this.coerceKey(key, value);
+    //this._attributes[coerceKey(key)] = logValue(value as LogValueArg);
     return this;
   }
   Dur(key: string, nsec: number): Logger {
-    this._attributes[key] = logValue(`${nsec}ms`);
+    this._attributes[key] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
     // new Intl.DurationFormat("en", { style: "narrow" }).format(nsec);
     return this;
   }
-  Uint64(key: string, value: number): Logger {
-    this._attributes[key] = logValue(value);
+  Uint64(key: string | Record<string, number>, value?: number): Logger {
+    this.coerceKey(key, value);
+    //this._attributes[coerceKey(key)] = logValue(value);
     return this;
   }
-  Int(key: string, value: number): Logger {
+  Int(key: string | Record<string, number>, value?: number): Logger {
     return this.Uint64(key, value);
   }
 
@@ -321,7 +421,7 @@ export class LoggerImpl implements Logger {
       new LoggerImpl({
         logWriter: this._logWriter,
         sys: this._sys,
-        levelHandler: this._levelHandler,
+        levelHandler: this.levelHandler,
         formatter: this._formatter,
         withAttributes: {
           module: this._attributes["module"],
@@ -343,33 +443,53 @@ export class LoggerImpl implements Logger {
 
   Msg(...args: string[]): AsError {
     const fnError = this._resetAttributes(() => {
-      const doWrite = this._levelHandler.isEnabled(
+      const doWrite = this.levelHandler.isEnabled(
         toLogValue(this._attributes["level"])?.value(),
         toLogValue(this._attributes["module"])?.value(),
       );
-      this._attributes["msg"] = logValue(args.join(" "));
+      this._attributes["msg"] = logValue(args.join(" "), toLogValueCtx(this.levelHandler));
       const msg = this._attributes["msg"].value();
       if (typeof msg === "string" && !msg.trim().length) {
         delete this._attributes["msg"];
       }
       let fnRet = (): Uint8Array => this._formatter.format({ ...this._attributes });
       if (doWrite) {
-        const encoded = fnRet();
-        this._logWriter.write(encoded);
+        let encoded: Uint8Array;
+        try {
+          encoded = fnRet();
+          this._logWriter.write(encoded);
+        } catch (e) {
+          const where = "Logger-Impl:Msg:Write error:";
+          // eslint-disable-next-line no-console
+          console.error(where, e, this._attributes);
+          encoded = this._txtEnDe.encode(where + (e as Error).message + "\n" + (e as Error).stack + "\n");
+        }
         fnRet = (): Uint8Array => encoded;
       }
       return fnRet;
     });
+    const asError = (): Error => new Error(this._txtEnDe.decode(fnError()));
     return {
-      AsError: () => new Error(this._txtEnDe.decode(fnError())),
+      ResultError: () => Result.Err(asError()),
+      AsError: asError,
     };
   }
 }
 
 class WithLoggerBuilder implements WithLogger {
   readonly _li: LoggerImpl;
+  readonly levelHandler: LevelHandler;
   constructor(li: LoggerImpl) {
     this._li = li;
+    this.levelHandler = li.levelHandler;
+  }
+  TimerStart(key: string): WithLogger {
+    this._li.TimerStart(key);
+    return this;
+  }
+  TimerEnd(key: string): WithLogger {
+    this._li.TimerEnd(key);
+    return this;
   }
 
   TxtEnDe(): TxtEnDecoder {
@@ -386,7 +506,12 @@ class WithLoggerBuilder implements WithLogger {
   }
 
   SetExposeStack(enable?: boolean): WithLogger {
-    this._li._levelHandler.setExposeStack(enable);
+    this._li.levelHandler.setExposeStack(enable);
+    return this;
+  }
+
+  SetIgnoreAttribute(re?: RegExp): WithLogger {
+    this._li.levelHandler.setIgnoreAttr(re);
     return this;
   }
 
@@ -396,11 +521,11 @@ class WithLoggerBuilder implements WithLogger {
   }
 
   EnableLevel(level: Level, ...modules: string[]): WithLogger {
-    this._li._levelHandler.enableLevel(level, ...modules);
+    this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
   DisableLevel(level: Level, ...modules: string[]): WithLogger {
-    this._li._levelHandler.enableLevel(level, ...modules);
+    this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
 
@@ -413,7 +538,16 @@ class WithLoggerBuilder implements WithLogger {
     return this;
   }
 
-  Str(key: string, value?: string): WithLogger {
+  Http(...mix: (HttpType | string)[]): WithLogger {
+    this._li.Http(...mix);
+    return this;
+  }
+  Pair(x: Record<string, unknown>): WithLogger {
+    this._li.Pair(x);
+    return this;
+  }
+
+  Str(key: string | Record<string, string>, value?: string): WithLogger {
     this._li.Str(key, value);
     return this;
   }
@@ -432,7 +566,7 @@ class WithLoggerBuilder implements WithLogger {
     this._li.Ref(key, action);
     return this;
   }
-  Bool(key: string, value: unknown): WithLogger {
+  Bool(key: string | Record<string, unknown>, value?: unknown): WithLogger {
     this._li.Bool(key, value);
     return this;
   }
@@ -444,7 +578,7 @@ class WithLoggerBuilder implements WithLogger {
     this._li.Url(url, key);
     return this;
   }
-  Int(key: string, value: number): WithLogger {
+  Int(key: string | Record<string, number>, value?: number): WithLogger {
     this._li.Int(key, value);
     return this;
   }
@@ -483,7 +617,7 @@ class WithLoggerBuilder implements WithLogger {
     this._li.Timestamp();
     return this;
   }
-  Any(key: string, value: LogSerializable): WithLogger {
+  Any<T>(key: string | Record<string, unknown>, value?: T | LogSerializable): WithLogger {
     this._li.Any(key, value);
     return this;
   }
@@ -491,7 +625,7 @@ class WithLoggerBuilder implements WithLogger {
     this._li.Dur(key, nsec);
     return this;
   }
-  Uint64(key: string, value: number): WithLogger {
+  Uint64(key: string | Record<string, number>, value?: number): WithLogger {
     this._li.Uint64(key, value);
     return this;
   }