feat: allow passing a logger function to quirrel client (#1039)

currently the logging is really simple and very verbose. this gives
users the options to define their own logger functions for the quirrel
client.

Co-authored-by: Simon Knott <[email protected]>

Author: boredland

src/client/index.ts

@@ -23,13 +23,24 @@ export interface JobMeta
   readonly nextRepetition?: Date;
 }
 
+export type QuirrelLogger<Payload = unknown> = {
+  receivedJob: (route: string, data: Payload) => void;
+  processingError: (route: string, data: Payload, error: unknown) => void;
+};
+
+const defaultLogger: QuirrelLogger = {
+  receivedJob: (route, data) => console.log(`Received job to ${route}`, data),
+  processingError: (route, data, error) =>
+    console.error(`Error in job at ${route}`, data, error),
+};
+
 export type QuirrelJobHandler<T> = (job: T, meta: JobMeta) => Promise<void>;
 export type DefaultJobOptions = Pick<EnqueueJobOptions, "exclusive" | "retry">;
 
 interface CreateQuirrelClientArgs<T> {
   route: string;
   handler: QuirrelJobHandler<T>;
-  defaultJobOptions?: DefaultJobOptions;
+  options?: QuirrelOptions<T>;
   config?: {
     /**
      * Recommended way to set this: process.env.QUIRREL_BASE_URL
@@ -137,10 +148,6 @@ const EnqueueJobOptionsSchema = z.object({
 
 type EnqueueJobOptionsSchema = z.TypeOf<typeof EnqueueJobOptionsSchema>;
 
-type EnqueueJobOptionssSchemaMatchesDocs = AssertTrue<
-  IsExact<EnqueueJobOptions, EnqueueJobOptionsSchema>
->;
-
 /**
  * @deprecated renamed to EnqueueJobOptions
  */
@@ -250,6 +257,10 @@ function getAuthHeaders(
   return { Authorization: `Bearer ${token}` };
 }
 
+export interface QuirrelOptions<T = unknown> extends DefaultJobOptions {
+  logger?: QuirrelLogger<T>;
+}
+
 export class QuirrelClient<T> {
   private handler;
   private route;
@@ -265,17 +276,19 @@ export class QuirrelClient<T> {
   private fetch;
   private catchDecryptionErrors;
   private signaturePublicKey;
+  private logger: QuirrelLogger<T>;
 
   constructor(args: CreateQuirrelClientArgs<T>) {
     this.handler = args.handler;
-    this.defaultJobOptions = args.defaultJobOptions;
+    this.defaultJobOptions = args.options;
 
     const token = args.config?.token ?? config.getQuirrelToken();
     this.defaultHeaders = {
       ...getAuthHeaders(token),
       "X-QuirrelClient-Version": pack.version,
     };
 
+    this.logger = args.options?.logger ?? defaultLogger;
     const quirrelBaseUrl =
       args.config?.quirrelBaseUrl ?? config.getQuirrelBaseUrl();
     this.applicationBaseUrl = config.withoutTrailingSlash(
@@ -691,7 +704,7 @@ export class QuirrelClient<T> {
       (headers["x-quirrel-meta"] as string) ?? "{}"
     );
 
-    console.log(`Received job to ${this.route}: `, payload);
+    this.logger.receivedJob(this.route, payload);
 
     try {
       await this.handler(payload, {
@@ -708,7 +721,7 @@ export class QuirrelClient<T> {
         body: "OK",
       };
     } catch (error) {
-      console.error(error);
+      this.logger.processingError(this.route, payload, error);
       return {
         status: 500,
         headers: {},

src/client/test/logger.test.ts

@@ -0,0 +1,97 @@
+import { run } from "../../api/test/runQuirrel";
+import { getAddress, makeSignal } from "./util";
+import { QuirrelClient } from "..";
+import http from "http";
+
+const errorLogMock = jest.fn();
+const logMock = jest.fn();
+const receiverMock = jest.fn();
+
+global.console = {
+  ...global.console,
+  error: errorLogMock,
+  log: logMock,
+};
+
+describe("client logger", () => {
+  let quirrelBaseUrl: string;
+  let server: Awaited<ReturnType<typeof run>>;
+
+  beforeAll(async () => {
+    server = await run("Mock");
+    quirrelBaseUrl = getAddress(server.server);
+  });
+
+  afterAll(async () => {
+    server.teardown();
+  });
+
+  beforeEach(() => {
+    errorLogMock.mockReset();
+    logMock.mockReset();
+  });
+
+  it("works without passing a custom logger function", async () => {
+    const quirrel = new QuirrelClient<{ result: "success" | "fail" }>({
+      route: "routeName",
+      async handler(payload) {
+        if (payload.result === "fail") throw new Error("yey,errors");
+      },
+      config: {
+        quirrelBaseUrl,
+        applicationBaseUrl: "http://localhost",
+      },
+    });
+    await quirrel.respondTo(JSON.stringify({ result: "success" }), {});
+    expect(logMock).toHaveBeenCalledTimes(1);
+    expect(logMock).toHaveBeenLastCalledWith("Received job to routeName", {
+      result: "success",
+    });
+    expect(errorLogMock).toHaveBeenCalledTimes(0);
+
+    await quirrel.respondTo(JSON.stringify({ result: "fail" }), {});
+    expect(logMock).toHaveBeenCalledTimes(2);
+    expect(logMock).toHaveBeenLastCalledWith("Received job to routeName", {
+      result: "fail",
+    });
+    expect(errorLogMock).toHaveBeenCalledTimes(1);
+    expect(errorLogMock).toHaveBeenLastCalledWith(
+      "Error in job at routeName",
+      { result: "fail" },
+      new Error("yey,errors")
+    );
+  });
+
+  it("allows passing a custom logger function", async () => {
+    const receivedJob = jest.fn();
+    const processingError = jest.fn();
+
+    const quirrel = new QuirrelClient<{ result: "success" | "fail" }>({
+      route: "",
+      async handler(payload) {
+        if (payload.result === "fail") throw new Error("fail");
+      },
+      config: {
+        quirrelBaseUrl,
+        applicationBaseUrl: "http://localhost",
+      },
+      options: {
+        logger: {
+          receivedJob,
+          processingError,
+        },
+      },
+    });
+    await quirrel.respondTo(JSON.stringify({ result: "success" }), {});
+    expect(receivedJob).toBeCalledTimes(1);
+    expect(processingError).toBeCalledTimes(0);
+    expect(logMock).toHaveBeenCalledTimes(0);
+    expect(errorLogMock).toHaveBeenCalledTimes(0);
+
+    await quirrel.respondTo(JSON.stringify({ result: "fail" }), {});
+    expect(receivedJob).toBeCalledTimes(2);
+    expect(processingError).toBeCalledTimes(1);
+    expect(logMock).toHaveBeenCalledTimes(0);
+    expect(errorLogMock).toHaveBeenCalledTimes(0);
+  });
+});

src/connect.ts

@@ -6,6 +6,7 @@ import {
   EnqueueJobOpts,
   EnqueueJobOptions,
   Job,
+  QuirrelOptions,
 } from "./client";
 import bodyParser from "body-parser";
 
@@ -29,12 +30,12 @@ declare module "connect" {
 export function Queue<Payload>(
   route: string,
   handler: QuirrelJobHandler<Payload>,
-  defaultJobOptions?: DefaultJobOptions
+  options?: QuirrelOptions<Payload>,
 ): Queue<Payload> {
   const quirrel = new QuirrelClient({
     route,
     handler,
-    defaultJobOptions,
+    options,
   });
 
   const server = connect() as Queue<Payload>;
@@ -71,7 +72,8 @@ export function Queue<Payload>(
 export function CronJob(
   route: string,
   cronSchedule: NonNullable<NonNullable<EnqueueJobOptions["repeat"]>["cron"]>,
-  handler: () => Promise<void>
+  handler: () => Promise<void>,
+  options?: QuirrelOptions
 ) {
-  return Queue(route, handler) as unknown;
+  return Queue(route, handler, options) as unknown;
 }

src/index.ts

@@ -5,5 +5,7 @@ export {
   EnqueueJobOptions,
   Job,
   QuirrelClient,
+  QuirrelOptions,
+  QuirrelLogger,
 } from "./client";
 export { runQuirrelDev } from "./cli/commands/index";

src/next.ts

@@ -5,6 +5,7 @@ import {
   Job,
   DefaultJobOptions,
   QuirrelJobHandler,
+  QuirrelOptions,
 } from "./client";
 import { registerDevelopmentDefaults } from "./client/config";
 import type { IncomingHttpHeaders } from "http";
@@ -45,10 +46,10 @@ export type Queue<Payload> = Omit<
 export function Queue<Payload>(
   route: string,
   handler: QuirrelJobHandler<Payload>,
-  defaultJobOptions?: DefaultJobOptions
+  options?: QuirrelOptions,
 ): Queue<Payload> & NextApiHandler {
   const quirrel = new QuirrelClient<Payload>({
-    defaultJobOptions,
+    options,
     handler,
     route,
   });
@@ -83,7 +84,8 @@ export function Queue<Payload>(
 export function CronJob(
   route: string,
   cronSchedule: NonNullable<NonNullable<EnqueueJobOptions["repeat"]>["cron"]>,
-  handler: () => Promise<void>
+  handler: () => Promise<void>,
+  options?: QuirrelOptions
 ) {
-  return Queue(route, handler) as unknown;
+  return Queue(route, handler, options) as unknown;
 }

src/nuxt.ts

@@ -1,4 +1,4 @@
-import { EnqueueJobOptions, QuirrelClient } from "./client";
+import { EnqueueJobOptions, QuirrelClient, QuirrelOptions } from "./client";
 import { registerDevelopmentDefaults } from "./client/config";
 import * as connect from "./connect";
 
@@ -9,9 +9,9 @@ registerDevelopmentDefaults({
 export function Queue<Payload>(
   path: string,
   handler: connect.QuirrelJobHandler<Payload>,
-  defaultJobOptions?: connect.DefaultJobOptions
+  options?: QuirrelOptions,
 ): Omit<QuirrelClient<Payload>, "respondTo" | "makeRequest"> {
-  const client = connect.Queue(path, handler, defaultJobOptions);
+  const client = connect.Queue(path, handler, options);
 
   (client as any).path = path;
   (client as any).handler = client.handle;
@@ -22,9 +22,10 @@ export function Queue<Payload>(
 export function CronJob(
   route: string,
   cronSchedule: NonNullable<NonNullable<EnqueueJobOptions["repeat"]>["cron"]>,
-  handler: () => Promise<void>
+  handler: () => Promise<void>,
+  options?: QuirrelOptions
 ) {
-  return Queue(route, handler) as unknown;
+  return Queue(route, handler, options) as unknown;
 }
 
 export * from "./connect";

src/redwood.ts

@@ -5,10 +5,17 @@ import {
   Job,
   DefaultJobOptions,
   QuirrelJobHandler,
+  QuirrelOptions,
 } from "./client";
 import { registerDevelopmentDefaults } from "./client/config";
 
-export { Job, EnqueueJobOpts, EnqueueJobOptions, DefaultJobOptions, QuirrelJobHandler };
+export {
+  Job,
+  EnqueueJobOpts,
+  EnqueueJobOptions,
+  DefaultJobOptions,
+  QuirrelJobHandler,
+};
 
 registerDevelopmentDefaults({
   applicationBaseUrl: "http://localhost:8911",
@@ -38,10 +45,10 @@ export type Queue<Payload> = Omit<
 export function Queue<Payload>(
   route: string,
   handler: QuirrelJobHandler<Payload>,
-  defaultJobOptions?: DefaultJobOptions
+  options?: QuirrelOptions<Payload>,
 ): Queue<Payload> {
   const quirrel = new QuirrelClient<Payload>({
-    defaultJobOptions,
+    options,
     handler,
     route,
   });
@@ -79,7 +86,8 @@ export function Queue<Payload>(
 export function CronJob(
   route: string,
   cronSchedule: NonNullable<NonNullable<EnqueueJobOptions["repeat"]>["cron"]>,
-  handler: () => Promise<void>
+  handler: () => Promise<void>,
+  options?: QuirrelOptions
 ) {
-  return Queue(route, handler) as unknown;
+  return Queue(route, handler, options) as unknown;
 }

src/remix.ts

@@ -5,12 +5,13 @@ import {
   Job,
   DefaultJobOptions,
   QuirrelJobHandler,
+  QuirrelOptions,
 } from "./client";
 import { registerDevelopmentDefaults } from "./client/config";
 
 type DataFunctionArgs = {
   request: Request;
-}
+};
 
 type ActionFunction = (args: DataFunctionArgs) => Promise<Response> | Response;
 
@@ -34,26 +35,32 @@ export type Queue<Payload> = Omit<
 export function Queue<Payload>(
   route: string,
   handler: QuirrelJobHandler<Payload>,
-  defaultJobOptions?: DefaultJobOptions,
+  options?: QuirrelOptions<Payload>
 ): ActionFunction & Queue<Payload> {
   const quirrel = new QuirrelClient<Payload>({
-    defaultJobOptions,
+    options,
     handler,
     route,
   });
 
   async function action({ request }: DataFunctionArgs) {
     const body = await request.text();
-    const response = await quirrel.respondTo(body, Object.fromEntries(request.headers.entries()));
+    const response = await quirrel.respondTo(
+      body,
+      Object.fromEntries(request.headers.entries())
+    );
     return new Response(response.body, {
       headers: response.headers,
       status: response.status,
     });
   }
 
-  action.enqueue = (payload: Payload, options: EnqueueJobOptions) => quirrel.enqueue(payload, options);
+  action.enqueue = (payload: Payload, options: EnqueueJobOptions) =>
+    quirrel.enqueue(payload, options);
 
-  action.enqueueMany = (jobs: { payload: Payload; options?: EnqueueJobOptions }[]) => quirrel.enqueueMany(jobs);
+  action.enqueueMany = (
+    jobs: { payload: Payload; options?: EnqueueJobOptions }[]
+  ) => quirrel.enqueueMany(jobs);
 
   action.delete = (jobId: string) => quirrel.delete(jobId);
 
@@ -70,6 +77,7 @@ export function CronJob(
   route: string,
   cronSchedule: NonNullable<NonNullable<EnqueueJobOptions["repeat"]>["cron"]>,
   handler: () => Promise<void>,
+  options?: QuirrelOptions
 ) {
-  return Queue(route, handler) as unknown;
+  return Queue(route, handler, options) as unknown;
 }