@adviser/cement 0.2.28 → 0.2.30

package/src/test/log-write-stream.ts

@@ -0,0 +1,95 @@
+import { FanoutWriteStream } from "../utils/fanout-write-stream.js";
+import { Future } from "../future.js";
+import { TxtEnDecoder, Utf8EnDecoderSingleton } from "../txt-en-decoder.js";
+
+export class LogWriteStream implements WritableStreamDefaultWriter<Uint8Array> {
+  private readonly _bufferArr: Uint8Array[];
+
+  constructor(bufferArr: Uint8Array[]) {
+    this._bufferArr = bufferArr;
+  }
+
+  readonly _resolveClosed: Future<undefined> = new Future<undefined>();
+  readonly closed: Promise<undefined> = this._resolveClosed.asPromise();
+  readonly desiredSize: number | null = null;
+  readonly ready: Promise<undefined> = Promise.resolve(undefined);
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  abort(reason?: any): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+  async close(): Promise<void> {
+    await this.closed;
+    return Promise.resolve(undefined);
+  }
+  releaseLock(): void {
+    // do nothing
+  }
+  async write(chunk?: Uint8Array): Promise<void> {
+    if (chunk) {
+      this._bufferArr.push(chunk);
+    }
+    return Promise.resolve(undefined);
+  }
+}
+
+export class LogCollector implements WritableStream<Uint8Array> {
+  readonly locked: boolean = false;
+  private _writer?: FanoutWriteStream;
+  private readonly _pass?: WritableStreamDefaultWriter<Uint8Array>;
+  private readonly _bufferArr: Uint8Array[] = [];
+  private readonly _txtEnDe: TxtEnDecoder;
+
+  constructor(pass?: WritableStreamDefaultWriter<Uint8Array>, txtEnDe?: TxtEnDecoder) {
+    this._pass = pass;
+    this._txtEnDe = txtEnDe || Utf8EnDecoderSingleton();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  abort(reason?: Uint8Array): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+
+  async close(): Promise<void> {
+    if (this._writer) {
+      const ret = await this._writer.close();
+      this._writer = undefined;
+      return ret;
+    }
+    return Promise.resolve(undefined);
+  }
+
+  getWriter(): WritableStreamDefaultWriter<Uint8Array> {
+    if (!this._writer) {
+      const dests: WritableStreamDefaultWriter[] = [new LogWriteStream(this._bufferArr)];
+      if (this._pass) {
+        dests.push(this._pass);
+      }
+      this._writer = new FanoutWriteStream(dests);
+    }
+    return this._writer;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Logs(notJsonLine = false): any[] {
+    if (!this._writer) {
+      return [];
+    }
+    const jsonNlStr = this._txtEnDe.decode(
+      new Uint8Array(
+        (function* (res: Uint8Array[]): Generator<number, void, undefined> {
+          for (const x of res) {
+            yield* x;
+          }
+        })(this._bufferArr),
+      ),
+    );
+    if (!notJsonLine) {
+      const splitStr = jsonNlStr.split("\n");
+      const filterStr = splitStr.filter((a) => a.length);
+      const mapStr = filterStr.map((a) => JSON.parse(a));
+      return mapStr;
+    }
+    return jsonNlStr.split("\n").filter((a) => a.length);
+  }
+}

package/src/test/mock-logger.ts

@@ -0,0 +1,40 @@
+import { LevelHandlerImpl } from "../log-level-impl.js";
+import { Logger } from "../logger.js";
+import { LoggerImpl } from "../logger-impl.js";
+import { SysAbstraction } from "../sys-abstraction.js";
+import { LogCollector } from "./log-write-stream.js";
+
+export interface MockLoggerReturn {
+  readonly logger: Logger;
+  readonly logCollector: LogCollector;
+}
+
+export function MockLogger(params?: {
+  readonly sys?: SysAbstraction;
+  readonly pass?: WritableStreamDefaultWriter<Uint8Array>;
+  moduleName?: string | string[];
+  readonly disableDebug?: boolean;
+}): MockLoggerReturn {
+  const lc = new LogCollector(params?.pass);
+  let modNames = ["MockLogger"];
+  if (typeof params?.moduleName === "string") {
+    modNames = [params?.moduleName];
+  } else if (Array.isArray(params?.moduleName)) {
+    modNames = [...params.moduleName, ...modNames];
+  }
+  const logger = new LoggerImpl({
+    out: lc,
+    sys: params?.sys,
+    levelHandler: new LevelHandlerImpl(),
+  })
+    .With()
+    .Module(modNames[0])
+    .Logger();
+  if (!params?.disableDebug) {
+    logger.SetDebug(...modNames);
+  }
+  return {
+    logCollector: lc,
+    logger,
+  };
+}

package/src/time.ts

@@ -0,0 +1,20 @@
+export abstract class Time {
+  abstract Now(add?: number): Date;
+  abstract Sleep(duration: Duration): Promise<void>;
+  TimeSince(start: Date): Duration {
+    const now = this.Now();
+    return now.getTime() - start.getTime();
+  }
+}
+
+export type Duration = number;
+
+export enum TimeUnits {
+  Microsecond = 1,
+  // eslint-disable-next-line @typescript-eslint/prefer-literal-enum-member
+  Second = 1000 * Microsecond,
+  // eslint-disable-next-line @typescript-eslint/prefer-literal-enum-member
+  Minute = 60 * Second,
+  // eslint-disable-next-line @typescript-eslint/prefer-literal-enum-member
+  Hour = 60 * Minute,
+}

package/src/tracer.ts

@@ -0,0 +1,222 @@
+import type { MarkWritable } from "ts-essentials";
+import { Time } from "./time.js";
+import { Logger } from "./logger.js";
+
+export type TraceCtx = {
+  readonly spanId: string;
+  readonly time: Time;
+  readonly parent: TraceNode;
+  readonly metrics: Map<string, Metric<unknown>>;
+  readonly logger?: Logger;
+} & Record<string, unknown>;
+
+export type CleanCtx = {
+  readonly spanId: string;
+} & Record<string, unknown>;
+
+export type TraceCtxParam = {
+  readonly spanId: string;
+} & Partial<{
+  readonly time: Time;
+  readonly parent: TraceNode;
+  readonly logger: Logger;
+}> &
+  Record<string, unknown>;
+
+export class Metric<T> {
+  value?: T;
+  readonly path: string;
+
+  constructor(path: string) {
+    this.path = path;
+  }
+
+  set(value: T): void {
+    this.value = value;
+  }
+
+  add<R extends number | ArrayLike<T>>(value: R): void {
+    if (typeof value === "number") {
+      if (this.value === undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.value = 0 as any;
+      }
+      (this.value as number) = ((this.value as number) + value) as number;
+    } else if (Array.isArray(value)) {
+      if (!Array.isArray(this.value)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.value = [] as any;
+      }
+      (this.value as T[]).push(...value);
+    } else {
+      throw new Error("add only support number or array");
+    }
+  }
+}
+
+export type MetricMap = Map<string, Metric<unknown>>;
+
+export class Metrics {
+  readonly tracenode: TraceNode;
+  private readonly map: MetricMap;
+
+  readonly spanRefs: MetricMap = new Map<string, Metric<unknown>>();
+  constructor(tracenode: TraceNode) {
+    this.tracenode = tracenode;
+    this.map = tracenode.ctx.metrics;
+  }
+
+  toJSON(): Record<string, unknown> {
+    const obj: Record<string, unknown> = {};
+    for (const [key, value] of this.map) {
+      obj[key] = value.value;
+    }
+    return obj;
+  }
+
+  get<T>(ipath: string): Metric<T> {
+    const path = ipath.replace(/[/]+/g, "/").trim();
+    if (path.startsWith("/")) {
+      if (path.slice(1).length === 0) {
+        throw new Error(`Metrics path must contain value /:${path}`);
+      }
+      let metric = this.map.get(path);
+      if (!metric) {
+        metric = new Metric<T>(path);
+        this.map.set(path, metric);
+      }
+      this.spanRefs.set(path, metric);
+      return metric as Metric<T>;
+    } else if (path.includes("/")) {
+      throw new Error(`Metrics path must start with /:${path}`);
+    }
+    const rootPath = this.tracenode.getRootPath();
+    return this.get(`${rootPath}/${path}`);
+  }
+}
+
+export interface Invokaction {
+  readonly result: "success" | "error";
+  readonly start: number;
+  readonly end: number;
+  readonly metrics?: Metrics;
+}
+
+export type TraceNodeMap = Map<string, TraceNode>;
+
+export class TraceNode {
+  readonly childs: TraceNodeMap = new Map<string, TraceNode>();
+
+  readonly invokations: Invokaction[] = [];
+
+  readonly spanId: string;
+  readonly ctx: TraceCtx;
+  readonly metrics: Metrics;
+
+  static root(time: Time, logger?: Logger): TraceNode {
+    return new TraceNode({
+      spanId: "root",
+      time,
+      logger,
+      metrics: new Map(),
+      parent: undefined as unknown as TraceNode,
+    });
+  }
+
+  constructor(ctx: TraceCtx) {
+    this.spanId = ctx.spanId;
+    this.ctx = ctx;
+    this.metrics = new Metrics(this);
+  }
+
+  getRootPath(rpath: string[] = []): string {
+    if (!this.ctx.parent) {
+      return "/" + rpath.reverse().join("/");
+    }
+    return this.ctx.parent.getRootPath(rpath.concat(this.ctx.spanId));
+  }
+
+  invokes(): { ctx: CleanCtx; invokations: Invokaction[] } {
+    const cleanCtx = { ...this.ctx } as CleanCtx;
+    delete cleanCtx.parent;
+    delete cleanCtx.time;
+    delete cleanCtx.logger;
+    delete cleanCtx.metrics;
+    const spanRefs = this.metrics.toJSON.call({ map: this.metrics.spanRefs });
+    const metricsRefs = Object.keys(spanRefs).length > 0 ? { metricRefs: spanRefs } : {};
+    return {
+      ctx: cleanCtx as CleanCtx,
+      invokations: this.invokations,
+      ...metricsRefs,
+    };
+  }
+
+  ctxWith(spanId: string, logger?: Logger): TraceCtxParam {
+    const ctx = {
+      ...this.ctx,
+      spanId,
+    };
+    if (logger) {
+      ctx.logger = logger;
+    }
+    return ctx;
+  }
+
+  // <V extends () => Promise<T> | T, T>(id: string, fn: V): ReturnType<V>
+  span<V extends (trace: TraceNode) => Promise<T> | T, T>(inSpanId: string | TraceCtxParam, fn: V): ReturnType<V> {
+    let ctx: TraceCtx;
+    if (typeof inSpanId === "string") {
+      ctx = {
+        ...this.ctx,
+        spanId: inSpanId,
+        parent: this,
+      };
+    } else {
+      ctx = {
+        ...this.ctx,
+        ...inSpanId,
+        parent: this,
+      };
+    }
+    if (ctx.logger) {
+      ctx = {
+        ...ctx,
+        ...ctx.logger.Attributes(),
+      };
+    }
+    const spanId = ctx.spanId;
+    let spanTrace = this.childs.get(spanId);
+    if (!spanTrace) {
+      spanTrace = new TraceNode(ctx);
+      this.childs.set(spanId.toString(), spanTrace);
+    }
+    const invokation: MarkWritable<MarkWritable<Invokaction, "end">, "result"> = {
+      start: this.ctx.time.Now().getTime(),
+      end: 0,
+      result: "success",
+    };
+    spanTrace.invokations.push(invokation);
+    try {
+      const possiblePromise = fn(spanTrace);
+      if (possiblePromise instanceof Promise) {
+        return possiblePromise
+          .then((v) => {
+            return v;
+          })
+          .catch((e) => {
+            invokation.result = "error";
+            throw e;
+          })
+          .finally(() => {
+            invokation.end = this.ctx.time.Now().getTime();
+          }) as ReturnType<V>;
+      }
+      invokation.end = this.ctx.time.Now().getTime();
+      return possiblePromise as ReturnType<V>;
+    } catch (e) {
+      invokation.result = "error";
+      invokation.end = this.ctx.time.Now().getTime();
+      throw e;
+    }
+  }
+}

package/src/txt-en-decoder.ts

@@ -0,0 +1,21 @@
+export interface TxtEnDecoder {
+  encode(str: string): Uint8Array;
+  decode(data: Uint8Array): string;
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+export class Utf8EnDecoder implements TxtEnDecoder {
+  encode(str: string): Uint8Array {
+    return encoder.encode(str);
+  }
+  decode(data: Uint8Array): string {
+    return decoder.decode(data);
+  }
+}
+
+const utf8EnDecoder = new Utf8EnDecoder();
+export function Utf8EnDecoderSingleton(): TxtEnDecoder {
+  return utf8EnDecoder;
+}