Reformat monitor.ts, add logging calls

src/monitor.ts

@@ -1,59 +1,60 @@
-import { env } from "@/env/server.mjs";
+import { env } from '@/env/server.mjs';
-import { z } from "zod";
+import { z } from 'zod';
+import logger from '@/logger';
 
 const BASE_URL = `https://cronitor.link/p/${env.CRONITOR_ACCOUNT_ID}/${env.CRONITOR_JOB_ID}`;
 const parameterSchema = z.object({
-  env: z.string().optional(),
+	env: z.string().optional(),
-  host: z.string().optional(),
+	host: z.string().optional(),
-  message: z.string().optional(),
+	message: z.string().optional(),
-  metric: z
+	metric: z
-    .union([
+		.union([
-      z.object({ count: z.number() }),
+			z.object({ count: z.number() }),
-      z.object({ duration: z.number() }),
+			z.object({ duration: z.number() }),
-      z.object({ error_count: z.number() }),
+			z.object({ error_count: z.number() })
-    ])
+		])
-    .optional(),
+		.optional(),
-  series: z.string().optional(),
+	series: z.string().optional(),
-  state: z.enum(["run", "complete", "fail", "ok"]).optional(),
+	state: z.enum(['run', 'complete', 'fail', 'ok']).optional(),
-  status_code: z.number().int().optional(),
+	status_code: z.number().int().optional()
 });
 
 function buildURL(parameters: z.infer<typeof parameterSchema>) {
-  const url = new URL(BASE_URL);
+	const url = new URL(BASE_URL);
 
-  // Definite string properties
+	// Definite string properties
-  const { env, host, message, series, state } = parameters;
+	const { env, host, message, series, state } = parameters;
-  for (const [key, value] of Object.entries({
+	for (const [key, value] of Object.entries({
-    env,
+		env,
-    host,
+		host,
-    message,
+		message,
-    series,
+		series,
-    state,
+		state
-  }).filter(([, value]) => value != undefined))
+	}).filter(([, value]) => value != undefined))
-    url.searchParams.append(key, value!);
+		url.searchParams.append(key, value!);
 
-  // Extract potentially undefined specified properties
+	// Extract potentially undefined specified properties
-  if (parameters.metric != undefined) {
+	if (parameters.metric != undefined) {
-    const { count, duration, error_count } = parameters.metric as {
+		const { count, duration, error_count } = parameters.metric as {
-      count?: number;
+			count?: number;
-      duration?: number;
+			duration?: number;
-      error_count?: number;
+			error_count?: number;
-    };
+		};
-    if (count != undefined) url.searchParams.append("metric", `count:${count}`);
+		if (count != undefined) url.searchParams.append('metric', `count:${count}`);
-    else if (duration != undefined)
+		else if (duration != undefined)
-      url.searchParams.append("metric", `duration:${duration}`);
+			url.searchParams.append('metric', `duration:${duration}`);
-    else if (error_count != undefined)
+		else if (error_count != undefined)
-      url.searchParams.append("metric", `error_count:${error_count}`);
+			url.searchParams.append('metric', `error_count:${error_count}`);
-  }
+	}
 
-  return url;
+	return url;
 }
 
 /**
  * @returns The duration in seconds between the start and end dates
  */
 function getDuration(start: Date, end: Date) {
-  return (end.getTime() - start.getTime()) / 1000;
+	return (end.getTime() - start.getTime()) / 1000;
 }
 
 /**
@@ -62,37 +63,37 @@ function getDuration(start: Date, end: Date) {
  * @throws Any error thrown by the function will be rethrown. Cronitor will be notified of the failure.
  */
 export default async function monitorAsync<T = any>(
-  execute: () => Promise<T>
+	execute: () => Promise<T>
 ): Promise<T> {
-  // Tell Cronitor that the job is running
+	// Tell Cronitor that the job is running
-  const start = new Date();
+	const start = new Date();
-  const series = start.getTime().toString();
+	const series = start.getTime().toString();
-  await fetch(buildURL({ state: "run", series }).toString());
+	await fetch(buildURL({ state: 'run', series }).toString());
-  console.log("Cronitor: Job started");
+	logger.info('Cronitor: Job started');
 
-  // Execute the function, provide try/catch
+	// Execute the function, provide try/catch
-  let result: T | undefined = undefined;
+	let result: T | undefined = undefined;
-  try {
+	try {
-    result = await execute();
+		result = await execute();
-  } catch (error) {
+	} catch (error) {
-    const duration = getDuration(start, new Date());
+		const duration = getDuration(start, new Date());
-    await fetch(
+		await fetch(
-      buildURL({
+			buildURL({
-        state: "fail",
+				state: 'fail',
-        series,
+				series,
-        message: error instanceof Error ? error.message : undefined,
+				message: error instanceof Error ? error.message : undefined,
-        metric: { duration },
+				metric: { duration }
-      }).toString()
+			}).toString()
-    );
+		);
-    throw error;
+		throw error;
-  }
+	}
 
-  // Tell Cronitor that the job is complete (success)
+	// Tell Cronitor that the job is complete (success)
-  console.log("Cronitor: Job completed");
+	logger.info('Cronitor: Job completed');
-  const duration = getDuration(start, new Date());
+	const duration = getDuration(start, new Date());
-  await fetch(
+	await fetch(
-    buildURL({ state: "complete", series, metric: { duration } }).toString()
+		buildURL({ state: 'complete', series, metric: { duration } }).toString()
-  );
+	);
 
-  return result as T;
+	return result as T;
 }