Improve logs

Author: bortoz

next.config.ts

@@ -45,6 +45,18 @@ const nextConfig: NextConfig = {
         destination: "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
         permanent: true,
       },
+      {
+        source: "/(.*)",
+        has: [
+          {
+            type: "header",
+            key: "next-action",
+            value: "x",
+          },
+        ],
+        destination: "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+        permanent: true,
+      },
     ];
   },
   turbopack: {

src/app/auth/error/route.ts

@@ -3,25 +3,25 @@ import type { NextRequest } from "next/server";
 
 import { msg } from "@lingui/core/macro";
 
-import { authErrors } from "~/lib/auth/errors";
+import { authErrors, commonErrors } from "~/lib/auth/errors";
 import { logger } from "~/lib/logger";
 
 export const dynamic = "force-dynamic";
 
 export function GET(request: NextRequest): Promise<Response> {
-  logger.error("Auth error", { request });
-
   let messageId = msg`Errore sconosciuto`;
 
   const code = request.nextUrl.searchParams.get("error")?.toUpperCase();
   if (!code) {
-    logger.error("Missing auth error code", { request });
+    logger.error("Missing auth error code");
   } else if (code in authErrors) {
     messageId = authErrors[code];
   } else {
     logger.error("Missing auth code", { code });
   }
 
-  logger.error("Auth error", { code });
+  if (code && !commonErrors.includes(code)) {
+    logger.error("Auth error", { code });
+  }
   redirect(`/?error=${encodeURIComponent(messageId.id)}`);
 }

src/instrumentation.ts

@@ -2,11 +2,15 @@ import type { Instrumentation } from "next";
 
 import { outLogger } from "~/lib/logger";
 
-export const onRequestError: Instrumentation.onRequestError = (_err, request, context) => {
+export const onRequestError: Instrumentation.onRequestError = (error, request, context) => {
   const headers = Object.entries(request.headers).flatMap(([key, values]): [string, string][] => {
     if (!values) return [];
     return Array.isArray(values) ? values.map((value) => [key, value]) : [[key, values]];
   });
 
-  outLogger.error("Error while processing request", { request, context }, new Headers(headers));
+  outLogger.error(
+    "Error while processing request",
+    { error, request, context },
+    new Headers(headers),
+  );
 };

src/lib/auth/errors.ts

@@ -57,17 +57,17 @@ export const authErrors: Record<keyof typeof auth.$ERROR_CODES | string, Message
   VALIDATION_ERROR: msg`Dati non validi`,
 };
 
+export const commonErrors: (keyof typeof authErrors)[] = [
+  "INVALID_EMAIL_OR_PASSWORD",
+  "INVALID_USERNAME_OR_PASSWORD",
+  "INVALID_PASSWORD",
+  "USER_NOT_FOUND",
+  "PLEASE_RESTART_THE_PROCESS",
+  "ACCESS_DENIED",
+];
+
 export function getAuthError(err: unknown): MessageDescriptor {
-  const isCommonError =
-    err instanceof APIError &&
-    [
-      "INVALID_EMAIL_OR_PASSWORD",
-      "INVALID_USERNAME_OR_PASSWORD",
-      "INVALID_PASSWORD",
-      "USER_NOT_FOUND",
-      "PLEASE_RESTART_THE_PROCESS",
-      "ACCESS_DENIED",
-    ].includes(err.body?.code ?? "");
+  const isCommonError = err instanceof APIError && commonErrors.includes(err.body?.code ?? "");
 
   if (!isCommonError) {
     logger.error("Auth error", err);

src/lib/logger.ts

@@ -52,17 +52,19 @@ export async function logRequest(req: NextRequest, userId: string | undefined, t
     referer,
   };
 
-  const labels: Record<string, string> = {};
-  if (userId) {
-    labels.userId = userId;
-  }
-
   const metadata = buildEntry({
     severity: "INFO",
     httpRequest,
-    labels,
     trace,
   });
+  if (userId) {
+    metadata.labels!.userId = userId;
+  }
+  req.headers.forEach((value, key) => {
+    if (key.startsWith("sec-ch-")) {
+      metadata.labels![key] = value;
+    }
+  });
 
   const log = logging.log("training-requests");
   const entry = log.entry(metadata);
@@ -73,18 +75,22 @@ async function writeLog(
   logName: string,
   severity: "DEBUG" | "INFO" | "WARNING" | "ERROR",
   headerList: Headers | null | undefined,
+  stack: string | undefined,
   message: string,
   data?: any,
 ) {
   if (!logging) return;
 
   const trace = headerList?.get("x-trace");
 
+  const metadata = buildEntry({ severity, trace });
+
   const log = logging.log(`training-${logName}`);
-  const entry = log.entry(
-    buildEntry({ severity, trace }),
-    isErrorLike(data) ? { error: serializeError(data), message } : { ...data, message },
-  );
+  const entry = log.entry(metadata, {
+    ...serializeError(isErrorLike(data) ? { error: data } : data),
+    message,
+    stack,
+  });
   await log.write(entry);
 }
 
@@ -94,7 +100,9 @@ function logInsideRequest(
   message: string,
   data?: any,
 ) {
-  after(async () => writeLog(logName, severity, await headers(), message, data));
+  const trace: { stack?: string } = {};
+  Error.captureStackTrace(trace, logInsideRequest);
+  after(async () => writeLog(logName, severity, await headers(), trace.stack, message, data));
 }
 
 function logOutsideRequest(
@@ -104,7 +112,9 @@ function logOutsideRequest(
   data?: any,
   headerList?: Headers | null,
 ) {
-  void writeLog(logName, severity, headerList, message, data);
+  const trace: { stack?: string } = {};
+  Error.captureStackTrace(trace, logOutsideRequest);
+  void writeLog(logName, severity, headerList, trace.stack, message, data);
 }
 
 export const logger = {
@@ -125,7 +135,13 @@ function logAuth(
   message: string,
   ...params: any[]
 ) {
-  logOutsideRequest("auth", severity, message, merge({}, ...params), headerList);
+  logOutsideRequest(
+    "auth",
+    severity === "ERROR" ? "WARNING" : severity,
+    message,
+    merge({}, ...params),
+    headerList,
+  );
 }
 
 export const authLogger: AuthLogger = {