@adviser/cement 0.2.28 → 0.2.29

package/src/tracer.test.ts

@@ -0,0 +1,314 @@
+import { Time } from "./time.js";
+import { WebSysAbstraction } from "./web/index.js";
+import { TimeMode } from "./sys-abstraction.js";
+import { TraceNode } from "./tracer.js";
+import { MockLogger } from "./test/mock-logger.js";
+
+describe("trace", () => {
+  let time: Time;
+  let refTime: Time;
+  let trace: TraceNode;
+  const logger = MockLogger().logger.With().Module("trace").Str("value", "important").Logger();
+  beforeEach(() => {
+    time = WebSysAbstraction({ TimeMode: TimeMode.STEP }).Time();
+    trace = TraceNode.root(time, logger);
+    refTime = WebSysAbstraction({ TimeMode: TimeMode.STEP }).Time();
+  });
+  it("a simple trace", () => {
+    expect(
+      trace.span("test", (trace) => {
+        const r1 = trace.span("test.1", () => {
+          return 1;
+        }) as number;
+        const r2 = trace.span("test.2", () => {
+          return 1;
+        }) as number;
+        return r1 + r2;
+      }),
+    ).toBe(2);
+    const childs = Array.from(trace.childs.values());
+    expect(childs.map((v) => v.invokes())).toEqual([
+      {
+        ctx: {
+          module: "trace",
+          spanId: "test",
+          value: "important",
+        },
+        invokations: [
+          {
+            start: refTime.Now().getTime(),
+            result: "success",
+            end: refTime.Now(5).getTime(),
+          },
+        ],
+      },
+    ]);
+    const layered = Array.from(trace.childs.get("test")?.childs.values() || []);
+    refTime = WebSysAbstraction({ TimeMode: TimeMode.STEP }).Time();
+    expect(layered.map((v) => v.invokes())).toEqual([
+      {
+        ctx: {
+          module: "trace",
+          spanId: "test.1",
+          value: "important",
+        },
+        invokations: [
+          {
+            start: refTime.Now(2).getTime(),
+            result: "success",
+            end: refTime.Now().getTime(),
+          },
+        ],
+      },
+      {
+        ctx: {
+          module: "trace",
+          spanId: "test.2",
+          value: "important",
+        },
+        invokations: [
+          {
+            start: refTime.Now().getTime(),
+            result: "success",
+            end: refTime.Now(1).getTime(),
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("a async simple trace", async () => {
+    const log = trace.ctx.logger?.With().Str("value", "test").Logger();
+    const ret = await trace.span(trace.ctxWith("test", log), async (trace) => {
+      const r1 = trace.span(trace.ctxWith("test.1"), () => 1) as number;
+      const log2 = trace.ctx.logger?.With().Module("xxx").Str("r2", "test.2").Logger();
+      const r2 = (await trace.span(trace.ctxWith("test.2", log2), async () => {
+        time.Now();
+        await new Promise<void>((resolve) =>
+          setTimeout(() => {
+            time.Now();
+            time.Now();
+            resolve();
+          }, 100),
+        );
+        return 1;
+      })) as number;
+      return r1 + r2;
+    });
+    expect(ret).toBe(2);
+    const childs = Array.from(trace.childs.values());
+    const exp = childs.map((v) => v.invokes());
+    expect(exp).toEqual([
+      {
+        ctx: {
+          module: "trace",
+          spanId: "test",
+          value: "test",
+        },
+        invokations: [
+          {
+            start: refTime.Now().getTime(),
+            result: "success",
+            end: refTime.Now(8).getTime(),
+          },
+        ],
+      },
+    ]);
+    const layered = Array.from(trace.childs.get("test")?.childs.values() || []);
+    expect(layered.map((v) => v.invokes())).toEqual([
+      {
+        ctx: {
+          module: "trace",
+          spanId: "test.1",
+          value: "test",
+        },
+        invokations: [
+          {
+            result: "success",
+            start: refTime.Now(-2).getTime(),
+            end: refTime.Now().getTime(),
+          },
+        ],
+      },
+      {
+        ctx: {
+          module: "xxx",
+          r2: "test.2",
+          spanId: "test.2",
+          value: "test",
+        },
+        invokations: [
+          {
+            start: refTime.Now().getTime(),
+            end: refTime.Now(4).getTime(),
+            result: "success",
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("a async exception trace", async () => {
+    const ret = await trace.span("test", async (trace) => {
+      let r1 = 0;
+      let r2 = 0;
+      for (let i = 0; i < 3; i++) {
+        try {
+          r1 += trace.span("test.1", (trace) => {
+            if (i % 2) {
+              throw new Error("test.1");
+            }
+            trace.metrics.get("i.1").add([i]);
+            return 1;
+          }) as number;
+        } catch (e) {
+          if (i % 2) {
+            expect((e as Error).message).toEqual("test.1");
+          } else {
+            assert(false, "should not happen");
+          }
+        }
+        try {
+          r2 += await trace.span("test.2", async (trace) => {
+            time.Now();
+            await new Promise<void>((resolve, reject) =>
+              setTimeout(() => {
+                time.Now();
+                time.Now();
+                if (i % 2) {
+                  trace.metrics.get("i.2").add(i);
+                  resolve();
+                } else {
+                  reject("test.2");
+                }
+              }, 10),
+            );
+            return 1;
+          });
+        } catch (e) {
+          if (i % 2) {
+            assert(false, "should not happen");
+          } else {
+            expect(e).toEqual("test.2");
+          }
+        }
+      }
+      return r1 + r2;
+    });
+    expect(ret).toBe(3);
+    expect(trace.metrics.toJSON()).toEqual({
+      "/test/test.1/i.1": [0, 2],
+      "/test/test.2/i.2": 1,
+    });
+    const childs = Array.from(trace.childs.values());
+    const exp = childs.map((v) => v.invokes());
+    expect(exp).toEqual([
+      {
+        ctx: {
+          module: "trace",
+          spanId: "test",
+          value: "important",
+        },
+        invokations: [
+          {
+            start: refTime.Now(1).getTime(),
+            end: refTime.Now(22).getTime(),
+            result: "success",
+          },
+        ],
+      },
+    ]);
+    const layered = Array.from(trace.childs.get("test")?.childs.values() || []);
+    expect(layered.map((v) => v.invokes())).toEqual([
+      {
+        ctx: {
+          module: "trace",
+          spanId: "test.1",
+          value: "important",
+        },
+        invokations: [
+          {
+            start: refTime.Now(-2).getTime(),
+            end: refTime.Now().getTime(),
+            result: "success",
+          },
+          {
+            start: refTime.Now(-9).getTime(),
+            end: refTime.Now().getTime(),
+            result: "error",
+          },
+          {
+            start: refTime.Now(-16).getTime(),
+            end: refTime.Now().getTime(),
+            result: "success",
+          },
+        ],
+        metricRefs: {
+          "/test/test.1/i.1": [0, 2],
+        },
+      },
+      {
+        ctx: {
+          module: "trace",
+          spanId: "test.2",
+          value: "important",
+        },
+        invokations: [
+          {
+            start: refTime.Now(-4).getTime(),
+            end: refTime.Now(4).getTime(),
+            result: "error",
+          },
+          {
+            start: refTime.Now(-11).getTime(),
+            end: refTime.Now(4).getTime(),
+            result: "success",
+          },
+          {
+            start: refTime.Now(-18).getTime(),
+            end: refTime.Now(4).getTime(),
+            result: "error",
+          },
+        ],
+        metricRefs: {
+          "/test/test.2/i.2": 1,
+        },
+      },
+    ]);
+  });
+});
+
+describe("metrics", () => {
+  let time: Time;
+  let trace: TraceNode;
+  // const logger = MockLogger().logger.With().Module("trace").Str("value", "important").Logger()
+  beforeEach(() => {
+    time = WebSysAbstraction({ TimeMode: TimeMode.STEP }).Time();
+    trace = TraceNode.root(time);
+  });
+
+  it("a simple metrics", () => {
+    ["/test", "test", "/test/wurst", "bla"].forEach((path) => {
+      const abs = path.startsWith("/") ? path : "/" + path;
+      expect(trace.metrics.get(path).path).toBe(abs);
+      expect(trace.metrics.get(path).value).toBeFalsy();
+      trace.metrics.get(path).add(4711);
+      expect(trace.metrics.get(path).value).toBe(4711);
+      trace.metrics.get(path).set(undefined);
+    });
+  });
+  it("create metrics path", () => {
+    trace.span("test", (trace) => {
+      trace.span("test.1", (trace) => {
+        trace.metrics.get("m1.1").add(1);
+        trace.metrics.get("/test/test.1/m1.1").add(1);
+        expect(trace.metrics.get("m1.1").path).toBe("/test/test.1/m1.1");
+        expect(trace.metrics.get("m1.1").value).toBe(2);
+      });
+    });
+  });
+  it("typed span promise or literal", async () => {
+    expect(trace.span("test", () => "1")).toBe("1");
+    expect(await trace.span("test", async () => 1)).toBe(1);
+  });
+});

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;
+}

package/src/uri.test.ts

@@ -0,0 +1,155 @@
+import { BuildURI, MutableURL, URI } from "@adviser/cement";
+
+describe("BuildURI", () => {
+  let uri: BuildURI;
+  beforeEach(() => {
+    uri = BuildURI.from(new MutableURL("http://example.com"));
+    uri.hostname("example");
+    uri.setParam("key", "value");
+  });
+
+  it("toString", () => {
+    expect(uri.toString()).toBe("http://example/?key=value");
+  });
+
+  it("build", () => {
+    expect(uri.URI().toString()).toBe("http://example/?key=value");
+  });
+
+  it("defParam", () => {
+    uri.defParam("key", "value2");
+    uri.defParam("key2", "value2");
+    expect(uri.toString()).toBe("http://example/?key=value&key2=value2");
+  });
+
+  it("searchParams sorted in toString", () => {
+    uri.setParam("z", "value");
+    uri.setParam("a", "value");
+    uri.setParam("m", "value");
+    expect(uri.toString()).toBe("http://example/?a=value&key=value&m=value&z=value");
+  });
+});
+
+describe("URI", () => {
+  // static from(strURLUri: string | URL | URI | NullOrUndef, defaultProtocol = "file:"): URI {
+  it("from str with default", () => {
+    const uri = URI.from("/example/wurst");
+    expect(uri.toString()).toBe("file:///example/wurst");
+  });
+  // it("from str defect", () => {
+  //   expect(URI.from("doof:meno")).toBe(null);
+  // })
+  it("from URL str", () => {
+    expect(URI.from("bla://example/com?key=value").toString()).toBe("bla://example/com?key=value");
+  });
+  it("from URL", () => {
+    expect(URI.from(new MutableURL("blix://example.com?key=value")).toString()).toBe("blix://example.com?key=value");
+  });
+  it("from URI", () => {
+    expect(URI.from(URI.from("blix://example.com?key=value")).toString()).toBe("blix://example.com?key=value");
+  });
+  it("from undef", () => {
+    expect(URI.from(null).toString()).toBe("file:///");
+  });
+
+  it("build", () => {
+    expect(URI.from("blix://example.com?key=value").build().toString()).toBe("blix://example.com?key=value");
+  });
+
+  it("clone", () => {
+    expect(URI.from("blix://example.com?key=value").clone().toString()).toBe("blix://example.com?key=value");
+  });
+
+  it("asURL", () => {
+    expect(URI.from("blix://example.com?key=value").asURL().toString()).toBe("blix://example.com?key=value");
+  });
+
+  it("toString", () => {
+    expect(URI.from("blix://example.com?key=value").toString()).toBe("blix://example.com?key=value");
+  });
+
+  it("searchParams sorted in toString", () => {
+    expect(URI.from("blix://example.com?z=value&a=value&m=value").toString()).toBe("blix://example.com?a=value&m=value&z=value");
+  });
+  it("searchParams sorted in asURL", () => {
+    expect(URI.from("blix://example.com?z=value&a=value&m=value").asURL().toString()).toBe(
+      "blix://example.com?a=value&m=value&z=value",
+    );
+  });
+
+  it("merge", () => {
+    expect(URI.merge("blix://example.com?key=value&into=4", "murk://bla/com?key=from&z=value").toString()).toBe(
+      "murk://bla/com?into=4&key=from&z=value",
+    );
+  });
+
+  it("merge empty", () => {
+    expect(URI.merge("blix://example/com?key=value&into=4", "murk://?key=from&z=value").toString()).toBe(
+      "murk://example/com?into=4&key=from&z=value",
+    );
+  });
+
+  it("firefox file relative into", () => {
+    expect(URI.from("file://./dist/tests/key.bag").toString()).toBe("file://./dist/tests/key.bag");
+  });
+
+  it("from empty", () => {
+    expect(URI.merge(`file://./dist/tests/key.bag`, "").toString()).toBe("file://./dist/tests/key.bag");
+  });
+
+  it("merge thing about", () => {
+    const result = URI.merge("./dist/what?byKey=4444", "murk://bla.com?key=from&z=value");
+    expect(result.toString()).toBe("murk://bla.com?byKey=4444&key=from&z=value");
+  });
+
+  it("isURI real", () => {
+    expect(URI.is(URI.from())).toBe(true);
+  });
+  it("isURI fake", () => {
+    expect(
+      URI.is({
+        asURL: () => new URL("http://example.com"),
+        hasParam: () => false,
+        getParam: () => "",
+      }),
+    ).toBe(true);
+  });
+
+  it("safari has a different pathname behavior", () => {
+    // chrome -> new URL("indexdb://fp/?name=test&store=meta").pathname -> //fp/
+    // safari -> new URL("indexdb://fp/?name=test&store=meta").pathname -> /
+    const uri = URI.from("indexdb://fp/?name=test&store=meta");
+    expect(uri.pathname).toBe("fp/");
+  });
+
+  it("passing URL to fetch", async () => {
+    const uri = URI.from("https://jsonplaceholder.typicode.com/todos/1");
+    const res = await fetch(uri.asURL());
+    expect(res.status).toBeGreaterThan(199);
+  });
+
+  it("MutableURL is instance of URL", () => {
+    expect(new MutableURL("http://example.com") instanceof URL).toBe(true);
+  });
+
+  it("file url", () => {
+    const uri = URI.from("file://fp?storagekey=zTvTPEPQRWij8rfb3FrFqBm");
+    expect(uri.pathname).toBe("fp");
+  });
+
+  it("unregistered protocol with hostPart", () => {
+    const withoutHostpart = URI.from("indexdb://fp:bla/test/?name=test&store=meta");
+    expect(() => withoutHostpart.hostname).toThrowError('you can use hostname only if protocol is ["http","https","ws","wss"]');
+  });
+
+  it("register protocol with hostPart", () => {
+    const unreg = URI.protocolHasHostpart("indexdb:");
+    const withHostpart = URI.from("indexdb://fp1:88/test/wurst?name=test&store=meta");
+    expect(withHostpart.host).toBe("fp1:88");
+    expect(withHostpart.pathname).toBe("/test/wurst");
+    const withHostpartNoPath = URI.from("indexdb://fp2:88?name=test&store=meta");
+    expect(withHostpartNoPath.host).toBe("fp2:88");
+    expect(withHostpartNoPath.pathname).toBe("/");
+    unreg();
+  });
+});