feat: durable logger

src/typegate/src/runtimes/substantial/deno_context.ts

@@ -14,10 +14,12 @@ export class Context {
   private id = 0;
   public kwargs = {};
   gql: ReturnType<typeof createGQLClient>;
+  logger: SubLogger;
 
   constructor(private run: Run, private internal: TaskContext) {
     this.gql = createGQLClient(internal);
     this.kwargs = getKwargsCopy(run);
+    this.logger = new SubLogger(this);
   }
 
   #nextId() {
@@ -414,6 +416,53 @@ class RetryStrategy {
   }
 }
 
+
+class SubLogger {
+  constructor(private ctx: Context) {}
+
+  async #log(kind: "warn" | "error" | "info", ...args: unknown[]) {
+    await this.ctx.save(() => {
+      const prefix = `[${kind.toUpperCase()}: ${this.ctx.getRun().run_id}]`;
+      switch(kind) {
+        case "warn": {
+          console.warn(prefix, ...args);
+          break;
+        }
+        case "error": {
+          console.error(prefix,...args);
+          break;
+        }
+        default: {
+          console.info(prefix, ...args);
+          break;
+        }
+      }
+
+      const message = args.map((arg) => {
+        try {
+          return JSON.stringify(arg);
+        } catch(_) {
+          return String(arg);
+        }
+      }).join(" ");
+
+      return `${prefix}: ${message}`;
+    });
+  }
+
+  async warn(...payload: unknown[]) {
+    await this.#log("warn", ...payload);
+  }
+
+  async info(...payload: unknown[]) {
+    await this.#log("info", ...payload);
+  }
+
+  async error(...payload: unknown[]) {
+    await this.#log("error", ...payload);
+  }
+}
+
 function createGQLClient(internal: TaskContext) {
   const tgLocal = new URL(internal.meta.url);
   if (testBaseUrl) {

tests/runtimes/substantial/imports/common_types.ts

@@ -46,6 +46,14 @@ export interface Context {
   createWorkflowHandle(
     handleDef: SerializableWorkflowHandle,
   ): ChildWorkflowHandle;
+
+  logger: SubLogger
+}
+
+interface SubLogger {
+  warn: (...args: unknown[]) => Promise<void>;
+  info: (...args: unknown[]) => Promise<void>;
+  error: (...args: unknown[]) => Promise<void>;
 }
 
 export type TaskCtx = {

tests/runtimes/substantial/workflow.ts

@@ -14,11 +14,14 @@ export const eventsAndExceptionExample: Workflow<string> = async (
 ) => {
   const { to } = ctx.kwargs;
   const messageDialog = await ctx.save(() => sendSubscriptionEmail(to));
+  await ctx.logger.info("Will send to", to);
+  await ctx.logger.warn("Will now wait on an event");
 
   // This will wait until a `confirmation` event is sent to THIS workflow
   const confirmation = ctx.receive<boolean>("confirmation");
 
   if (!confirmation) {
+    await ctx.logger.error("Denial", to);
     throw new Error(`${to} has denied the subscription`);
   }