From d9c418425b035f00c950e6a83df9470d7af80413 Mon Sep 17 00:00:00 2001
From: Elizabeth <me@liz.coffee>
Date: Mon, 2 Jun 2025 18:07:31 -0700
Subject: Use log traceable in metric traceable

---
 u/trace/itrace.ts  | 46 +++++++++++++++++++++++-----------------------
 u/trace/logger.ts  |  4 ++--
 u/trace/metrics.ts |  4 ++--
 u/trace/trace.ts   | 32 ++++++++++++++++----------------
 4 files changed, 43 insertions(+), 43 deletions(-)

(limited to 'u/trace')

diff --git a/u/trace/itrace.ts b/u/trace/itrace.ts
index ed707c5..35164b5 100644
--- a/u/trace/itrace.ts
+++ b/u/trace/itrace.ts
@@ -9,29 +9,29 @@ export interface ITrace<TraceWith> {
 }
 
 export type ITraceableTuple<T, TraceWith> = [T, BaseTraceWith | TraceWith];
-export type ITraceableMapper<T, U, TraceWith, W = ITraceable<T, TraceWith>> = (
+export type ITraceableMapper<T, _T, TraceWith, W = ITraceable<T, TraceWith>> = (
   w: W,
-) => U;
+) => _T;
 
 export interface ITraceable<T, Trace = BaseTraceWith> {
   readonly trace: ITrace<Trace>;
   get: Supplier<T>;
-  move: <U>(u: U) => ITraceable<U, Trace>;
-  map: <U>(mapper: ITraceableMapper<T, U, Trace>) => ITraceable<U, Trace>;
-  bimap: <U>(
+  move: <_T>(u: _T) => ITraceable<_T, Trace>;
+  map: <_T>(mapper: ITraceableMapper<T, _T, Trace>) => ITraceable<_T, Trace>;
+  bimap: <_T>(
     mapper: ITraceableMapper<
       T,
-      ITraceableTuple<U, Array<Trace> | Trace>,
+      ITraceableTuple<_T, Array<Trace> | Trace>,
       Trace
     >,
-  ) => ITraceable<U, Trace>;
+  ) => ITraceable<_T, Trace>;
   peek: (peek: ITraceableMapper<T, void, Trace>) => ITraceable<T, Trace>;
-  flatMap: <U>(
-    mapper: ITraceableMapper<T, ITraceable<U, Trace>, Trace>,
-  ) => ITraceable<U, Trace>;
-  flatMapAsync<U>(
-    mapper: ITraceableMapper<T, Promise<ITraceable<U, Trace>>, Trace>,
-  ): ITraceable<Promise<U>, Trace>;
+  flatMap: <_T>(
+    mapper: ITraceableMapper<T, ITraceable<_T, Trace>, Trace>,
+  ) => ITraceable<_T, Trace>;
+  flatMapAsync<_T>(
+    mapper: ITraceableMapper<T, Promise<ITraceable<_T, Trace>>, Trace>,
+  ): ITraceable<Promise<_T>, Trace>;
 }
 
 export class TraceableImpl<T, TraceWith> implements ITraceable<T, TraceWith> {
@@ -40,20 +40,20 @@ export class TraceableImpl<T, TraceWith> implements ITraceable<T, TraceWith> {
     public readonly trace: ITrace<TraceWith>,
   ) {}
 
-  public map<U>(mapper: ITraceableMapper<T, U, TraceWith>) {
+  public map<_T>(mapper: ITraceableMapper<T, _T, TraceWith>) {
     const result = mapper(this);
     return new TraceableImpl(result, this.trace);
   }
 
-  public flatMap<U>(
-    mapper: ITraceableMapper<T, ITraceable<U, TraceWith>, TraceWith>,
-  ): ITraceable<U, TraceWith> {
+  public flatMap<_T>(
+    mapper: ITraceableMapper<T, ITraceable<_T, TraceWith>, TraceWith>,
+  ): ITraceable<_T, TraceWith> {
     return mapper(this);
   }
 
-  public flatMapAsync<U>(
-    mapper: ITraceableMapper<T, Promise<ITraceable<U, TraceWith>>, TraceWith>,
-  ): ITraceable<Promise<U>, TraceWith> {
+  public flatMapAsync<_T>(
+    mapper: ITraceableMapper<T, Promise<ITraceable<_T, TraceWith>>, TraceWith>,
+  ): ITraceable<Promise<_T>, TraceWith> {
     return new TraceableImpl(
       mapper(this).then((t) => t.get()),
       this.trace,
@@ -65,14 +65,14 @@ export class TraceableImpl<T, TraceWith> implements ITraceable<T, TraceWith> {
     return this;
   }
 
-  public move<Tt>(t: Tt): ITraceable<Tt, TraceWith> {
+  public move<_T>(t: _T): ITraceable<_T, TraceWith> {
     return this.map(() => t);
   }
 
-  public bimap<U>(
+  public bimap<_T>(
     mapper: ITraceableMapper<
       T,
-      ITraceableTuple<U, Array<TraceWith> | TraceWith>,
+      ITraceableTuple<_T, Array<TraceWith> | TraceWith>,
       TraceWith
     >,
   ) {
diff --git a/u/trace/logger.ts b/u/trace/logger.ts
index 5890545..4f29839 100644
--- a/u/trace/logger.ts
+++ b/u/trace/logger.ts
@@ -95,8 +95,8 @@ export class LogTrace implements ITrace<LogTraceSupplier> {
             level: Math.max(logLevelOrder.indexOf(val), acc.level),
           };
         }
-        const prefix = [acc.line, val].join(" ");
-        return { ...acc, prefix };
+        const line = [acc.line, val].join(" ");
+        return { ...acc, line };
       },
       { line: "", level: -1 },
     );
diff --git a/u/trace/metrics.ts b/u/trace/metrics.ts
index 69322b9..822fc38 100644
--- a/u/trace/metrics.ts
+++ b/u/trace/metrics.ts
@@ -8,8 +8,8 @@ import {
 } from "@emprespresso/pengueno";
 
 export enum Unit {
-  COUNT,
-  MILLISECONDS,
+  COUNT = "COUNT",
+  MILLISECONDS = "MILLISECONDS",
 }
 
 export interface IMetric {
diff --git a/u/trace/trace.ts b/u/trace/trace.ts
index 03605c2..6cad5b0 100644
--- a/u/trace/trace.ts
+++ b/u/trace/trace.ts
@@ -1,6 +1,7 @@
 import {
   isMetricsTraceSupplier,
   type ITrace,
+  type ITraceable,
   type ITraceWith,
   LogTrace,
   type LogTraceSupplier,
@@ -12,16 +13,14 @@ import {
 
 export class LogTraceable<T> extends TraceableImpl<T, LogTraceSupplier> {
   public static LogTrace = new LogTrace();
-  static from<T>(t: T) {
+  static of<T>(t: T) {
     return new LogTraceable(t, LogTraceable.LogTrace);
   }
 }
 
 const getEmbeddedMetricConsumer =
-  (logTrace: LogTrace) => (metrics: Array<MetricValue>) =>
-    logTrace
-      .addTrace("<metrics>")
-      .trace(JSON.stringify(metrics, null, 2) + "</metrics>");
+  (logTrace: ITrace<LogTraceSupplier>) => (metrics: Array<MetricValue>) =>
+    logTrace.trace(`<metrics>${JSON.stringify(metrics, null)}</metrics>`);
 export class EmbeddedMetricsTraceable<T> extends TraceableImpl<
   T,
   MetricsTraceSupplier
@@ -30,11 +29,8 @@ export class EmbeddedMetricsTraceable<T> extends TraceableImpl<
     getEmbeddedMetricConsumer(LogTraceable.LogTrace),
   );
 
-  static from<T>(t: T) {
-    return new EmbeddedMetricsTraceable(
-      t,
-      EmbeddedMetricsTraceable.MetricsTrace,
-    );
+  static of<T>(t: T, metricsTrace = EmbeddedMetricsTraceable.MetricsTrace) {
+    return new EmbeddedMetricsTraceable(t, metricsTrace);
   }
 }
 
@@ -72,12 +68,16 @@ export class LogMetricTraceable<T> extends TraceableImpl<
   T,
   MetricsTraceSupplier | LogTraceSupplier
 > {
-  public static LogMetricTrace = new LogMetricTrace(
-    LogTraceable.LogTrace,
-    EmbeddedMetricsTraceable.MetricsTrace,
-  );
+  static ofLogTraceable<T>(t: ITraceable<T, LogTraceSupplier>) {
+    const metricsTrace = new MetricsTrace(getEmbeddedMetricConsumer(t.trace));
+    return new LogMetricTraceable(
+      t.get(),
+      new LogMetricTrace(t.trace, metricsTrace),
+    );
+  }
 
-  static from<T>(t: T) {
-    return new LogMetricTraceable(t, LogMetricTraceable.LogMetricTrace);
+  static of<T>(t: T) {
+    const logTrace = LogTraceable.of(t);
+    return LogMetricTraceable.ofLogTraceable(logTrace);
   }
 }
-- 
cgit v1.2.3-70-g09d2