Improve coolify webhook logging

1 files changed, 40 insertions, 17 deletions

diff --git a/worker/scripts/coolify_webhook.ts b/worker/scripts/coolify_webhook.ts
index 454bc56..d1b4eb0 100644
--- a/worker/scripts/coolify_webhook.ts
+++ b/worker/scripts/coolify_webhook.ts
@@ -27,22 +27,34 @@ await LogMetricTraceable.ofLogTraceable(_logJob)
     .flatMap(TraceUtil.withMetricTrace(webhookMetric))
     .peek((tEitherJob) => tEitherJob.trace.trace('starting coolify webhook trigger! (⑅˘꒳˘)'))
     .map((tEitherJob) =>
-        tEitherJob.get().flatMapAsync((job) =>
-            eitherVault.flatMapAsync(async (vault) => {
+        tEitherJob.get().flatMapAsync(async (job) => {
+            tEitherJob.trace.trace('checking vault configuration...');
+            return eitherVault.flatMapAsync(async (vault) => {
+                tEitherJob.trace.trace('unlocking vault...');
                 const eitherKey = await vault.unlock(tEitherJob);
-                tEitherJob.trace.trace('unlocked vault :3');
+                eitherKey.fold(
+                    (err) => tEitherJob.trace.trace(`failed to unlock vault: ${err.message || err}`),
+                    () => tEitherJob.trace.trace('unlocked vault :3'),
+                );
                 return eitherKey.mapRight((key) => ({ job, key, vault }));
-            }),
-        ),
-    )
-    .map(async (tEitherJobVault) =>
-        (await tEitherJobVault.get()).flatMapAsync(({ job, key, vault }) =>
-            vault
-                .fetchSecret<SecureNote>(tEitherJobVault, key, 'coolify')
-                .then((e) => e.mapRight(({ notes }) => ({ job, webhookSecret: notes })))
-                .finally(() => vault.lock(tEitherJobVault, key)),
-        ),
+            });
+        }),
     )
+    .map(async (tEitherJobVault) => {
+        const eitherJobVault = await tEitherJobVault.get();
+        return eitherJobVault.flatMapAsync(async ({ job, key, vault }) => {
+            tEitherJobVault.trace.trace('fetching coolify secret from vault...');
+            const eitherSecret = await vault.fetchSecret<SecureNote>(tEitherJobVault, key, 'coolify');
+            await vault.lock(tEitherJobVault, key);
+
+            eitherSecret.fold(
+                (err: Error) => tEitherJobVault.trace.trace(`failed to fetch coolify secret: ${err.message || err}`),
+                () => tEitherJobVault.trace.trace('successfully retrieved coolify webhook secret'),
+            );
+
+            return eitherSecret.mapRight(({ notes }: SecureNote) => ({ job, webhookSecret: notes }));
+        });
+    })
     .map(async (tEitherJobAndSecret) => {
         const eitherJobAndSecret = await tEitherJobAndSecret.get();
         return eitherJobAndSecret.flatMapAsync(async ({ job, webhookSecret }) => {
@@ -58,21 +70,32 @@ await LogMetricTraceable.ofLogTraceable(_logJob)
                     body: JSON.stringify({}),
                 }).then(async (response) => {
                     if (!response.ok) {
-                        throw new Error(
-                            `webhook request failed with status ${response.status}: ${await response.text()}`,
+                        const errorText = await response.text();
+                        tEitherJobAndSecret.trace.trace(
+                            `webhook failed with status ${response.status}: ${errorText}`,
                         );
+                        throw new Error(`webhook request failed with status ${response.status}: ${errorText}`);
                     }
                     return response.text();
                 }),
             ).then((e) => {
-                e.mapRight((responseText) =>
-                    tEitherJobAndSecret.trace.trace(`webhook response: ${responseText}`),
+                e.fold(
+                    (err) => tEitherJobAndSecret.trace.trace(`webhook error: ${err.message || err}`),
+                    (responseText) => tEitherJobAndSecret.trace.trace(`webhook response: ${responseText}`),
                 );
                 return e;
             });
         });
     })
     .peek(TraceUtil.promiseify(TraceUtil.traceResultingEither(webhookMetric)))
+    .peek(
+        TraceUtil.promiseify((tEitherResult) =>
+            tEitherResult.get().fold(
+                (err) => tEitherResult.trace.trace(`oh nyoo webhook failed :(( ${err.message || err}`),
+                () => tEitherResult.trace.trace('webhook triggered successfully! (◕ᴗ◕✿)'),
+            ),
+        ),
+    )
     .map(async (tEitherJob) => {
         const eitherJob = await tEitherJob.get();
         return eitherJob.fold(