1 files changed, 29 insertions, 26 deletions

diff --git a/server/job/run_activity.ts b/server/job/run_activity.ts
index 9f25cf8..22bc4c7 100644
--- a/server/job/run_activity.ts
+++ b/server/job/run_activity.ts
@@ -7,7 +7,9 @@ import {
     jsonModel,
     JsonResponse,
     LogLevel,
+    LogMetricTraceSupplier,
     Metric,
+    MetricsTraceSupplier,
     PenguenoError,
     type PenguenoRequest,
     type ServerTrace,
@@ -15,39 +17,35 @@ import {
     validateExecutionEntries,
 } from '@emprespresso/pengueno';
 import { isJob, type Job } from '@emprespresso/ci_model';
-import { IJobQueuer } from './queue';
+import { IJobQueuer } from './queue.js';
 
-const wellFormedJobMetric = Metric.fromName('Job.WellFormed');
+const wellFormedJobMetric = Metric.fromName('Job.WellFormed').asResult();
 
 const jobJsonTransformer = (j: ITraceable<unknown, ServerTrace>): IEither<PenguenoError, Job> =>
     j
-        .bimap(TraceUtil.withMetricTrace(wellFormedJobMetric))
+        .flatMap(TraceUtil.withMetricTrace(wellFormedJobMetric))
         .map((tJson): IEither<PenguenoError, Job> => {
             const tJob = tJson.get();
             if (!isJob(tJob) || !validateExecutionEntries(tJob)) {
                 const err = 'seems like a pwetty mawfomed job (-.-)';
-                tJson.trace.addTrace(LogLevel.WARN).trace(err);
+                tJson.trace.traceScope(LogLevel.WARN).trace(err);
                 return Either.left(new PenguenoError(err, 400));
             }
             return Either.right(tJob);
         })
-        .peek((tJob) =>
-            tJob.trace.trace(
-                tJob.get().fold(({ isLeft }) => (isLeft ? wellFormedJobMetric.failure : wellFormedJobMetric.success)),
-            ),
-        )
+        .peek(TraceUtil.traceResultingEither(wellFormedJobMetric))
         .get();
 
 export interface IJobHookActivity {
     processHook: IActivity;
 }
 
-const jobHookRequestMetric = Metric.fromName('JobHook.process');
+const jobHookRequestMetric = Metric.fromName('JobHook.process').asResult();
 export class JobHookActivityImpl implements IJobHookActivity {
     constructor(private readonly queuer: IJobQueuer<ITraceable<Job, ServerTrace>>) {}
 
     private trace(r: ITraceable<PenguenoRequest, ServerTrace>) {
-        return r.bimap(TraceUtil.withClassTrace(this)).bimap(TraceUtil.withMetricTrace(jobHookRequestMetric));
+        return r.flatMap(TraceUtil.withClassTrace(this)).flatMap(TraceUtil.withMetricTrace(jobHookRequestMetric));
     }
 
     public processHook(r: ITraceable<PenguenoRequest, ServerTrace>) {
@@ -63,29 +61,34 @@ export class JobHookActivityImpl implements IJobHookActivity {
                     return eitherQueued.mapLeft((e) => new PenguenoError(e.message, 500));
                 });
             })
+            .flatMapAsync(
+                TraceUtil.promiseify((tEitherQueued) => {
+                    const errorSource = tEitherQueued
+                        .get()
+                        .left()
+                        .map(({ source }) => source)
+                        .orSome(() => ErrorSource.SYSTEM)
+                        .get();
+                    const shouldWarn = errorSource === ErrorSource.USER;
+                    return TraceUtil.traceResultingEither<PenguenoError, string, LogMetricTraceSupplier>(
+                        jobHookRequestMetric,
+                        shouldWarn,
+                    )(tEitherQueued);
+                }),
+            )
             .peek(
                 TraceUtil.promiseify((tJob) =>
-                    tJob.get().fold(({ isRight, value }) => {
-                        if (isRight) {
-                            tJob.trace.trace(jobHookRequestMetric.success);
-                            tJob.trace.trace(`all queued up and weady to go :D !! ${value}`);
-                            return;
-                        }
-
-                        tJob.trace.trace(
-                            value.source === ErrorSource.SYSTEM
-                                ? jobHookRequestMetric.failure
-                                : jobHookRequestMetric.warn,
-                        );
-                        tJob.trace.addTrace(value.source).trace(`${value}`);
-                    }),
+                    tJob.get().mapRight((job) => tJob.trace.trace(`all queued up and weady to go :D !! ${job}`)),
                 ),
             )
             .map(
                 TraceUtil.promiseify(
                     (tEitherQueuedJob) =>
                         new JsonResponse(r, tEitherQueuedJob.get(), {
-                            status: tEitherQueuedJob.get().fold(({ isRight, value }) => (isRight ? 200 : value.status)),
+                            status: tEitherQueuedJob.get().fold(
+                                ({ status }) => status,
+                                () => 200,
+                            ),
                         }),
                 ),
             )