Xử lý lỗi JavaScript và ghi log để tìm ra lỗi lúc 2 giờ sáng

Xử lý lỗi JavaScript trong API Node.js: ghi log JSON có mã request, tách lỗi của người gửi khỏi lỗi máy chủ, giữ lỗi gốc bằng cause, không lộ chi tiết ra ngoài.

Xử lý lỗi tốt là để máy chủ lại đủ dấu vết cho người đến sau tìm ra nguyên nhân. Hãy ghi log mỗi request kèm mã riêng, tách lỗi của người gửi khỏi lỗi máy chủ, và giữ lỗi gốc. Cùng mình làm nhé?

Máy chủ chạy ổn, nhưng lúc có chuyện thì nó im lặng

Ở bài trước, mình thêm cho máy chủ đơn hàng của quán Mộc một cánh cửa kiểm tra bằng Zod, để đơn hỏng gửi từ website bị chặn ở cửa. (Quán Mộc là nhân vật minh họa của series này.) Chủ quán hài lòng, nhưng mình vẫn thấy lấn cấn một chuyện: nếu website gửi sai liên tục lúc hai giờ sáng, thì sáng ra ai biết? Người gửi nhận mã 400, còn máy chủ thì không nói gì cả.

Còn một chuyện nữa. Khi có lỗi thật sự trong máy chủ, nó chỉ in ra một đoạn stack trace. Để bạn thấy đoạn đó nghèo thông tin đến mức nào, mình dựng một tình huống. Trong danh sách đơn có sẵn một đơn hỏng, mã 1050: khách có số điện thoại nhưng thiếu tên, kiểu dữ liệu mà một máy bán hàng cũ có thể để lại. Rồi mình gửi hai request vào máy chủ của bài trước: một đơn sai (số lượng là chữ "hai") và một lệnh xem danh sách. Hàm trả danh sách của máy chủ cũ là thế này:

Hàm trả danh sách ở bài trước
function sendOrderList(response: ServerResponse, orders: Order[]): void {
  try {
    const orderListJson = JSON.stringify(listOrders(orders), null, 2);
    response.writeHead(200, JSON_HEADERS).end(orderListJson);
  } catch (error) {
    console.error(error);
    response.writeHead(500, TEXT_HEADERS).end("Lỗi máy chủ");
  }
}

Mình chạy hai request đó, và đây là mọi thứ máy chủ để lại trên màn hình. Mình bỏ bớt các dòng khung gọi hàm bên trong Node, giữ phần đầu:

Kết quả máy chủ bài trước
POST đơn sai: 400
Error: Không liệt kê được đơn 1050
    at src/orders.ts:61:13
    at Array.map (<anonymous>)
    ...
  [cause]: TypeError: Cannot read properties of undefined (reading 'toUpperCase')
      at customerLabel (src/orders.ts:48:30)
GET danh sách: 500 Lỗi máy chủ

Hai dòng "POST đơn sai: 400" và "GET danh sách: 500" là do script thử in ra, không phải máy chủ ghi. Thứ máy chủ tự ghi chỉ có đoạn stack trace ở giữa, và nó không cho biết: lúc nào, request nào, ai gọi, và đơn sai kia bị từ chối vì lý do gì (không dòng nào cả). Nếu lúc hai giờ sáng có bốn mươi request xen kẽ, đoạn stack trace đó trôi lẫn giữa chúng. Bạn đọc được lỗi, nhưng không biết nó thuộc về lần gọi nào.

Điều mình cần là một dòng ghi lại cho mỗi sự kiện, đủ để trả lời bốn câu hỏi: chuyện gì, lúc nào, của request nào, và quan trọng đến mức nào.

Một dòng log tốt trông như thế nào?

Mình dùng log dạng JSON, mỗi dòng một sự kiện. Lý do rất thực tế: một dòng chữ tự do như "Lỗi khi tải đơn 1050" thì người đọc được, nhưng muốn lọc "mọi lỗi của request abc" hay "mọi request chậm hơn một giây" thì phải viết biểu thức chính quy mong manh. Với JSON, mỗi mẩu thông tin có tên riêng, nên công cụ lọc theo tên được. Mỗi dòng có bốn thứ cố định: time, level (mức độ), msg (việc gì xảy ra) và requestId, mã ngắn gắn với đúng một request.

Mức độ có ba loại, và mình chia theo câu hỏi "lỗi của ai":

  • info: chuyện bình thường, ví dụ một đơn được nhận.
  • warn: người gọi gửi sai. Mã 4xx. Máy chủ làm đúng, chỉ là có người gửi dữ liệu hỏng.
  • error: máy chủ làm sai. Mã 5xx. Cần có người xem.

Chia như vậy thì lúc hai giờ sáng bạn chỉ cần lọc error. Nếu để mọi thứ là error, một website gửi sai năm trăm đơn sẽ chôn mất lỗi thật duy nhất của máy chủ. Cảnh báo đỏ quá nhiều thì rồi không ai nhìn nữa.

Để bạn làm theo được, mình dựng lại phần cần thiết trong một thư mục mới. Cấu trúc:

Cấu trúc thư mục
don-hang-moc/
  package.json
  src/orders.ts
  src/order-schema.ts
  src/logger.ts
  src/order-server.ts
  thu-log.ts

package.json cần Node.js 22.18 trở lên, vì từ bản đó Node chạy thẳng file .ts. Chạy npm install để cài Zod:

package.json
{
  "name": "don-hang-moc",
  "private": true,
  "type": "module",
  "dependencies": { "zod": "4.6.7" }
}

File src/orders.ts mô tả đơn hàng và có hàm listOrders trả danh sách cho trang quản lý. Hãy nhìn kỹ khối try/catch trong listOrders, mình sẽ quay lại nó ở phần sau:

src/orders.ts
export type Customer = { name: string; phone: string };
export type OrderItem = { name: string; price: number; quantity: number };
export type Order = {
  id: number;
  createdAt: string;
  source: "web" | "may-cu";
  customer?: Customer; // đơn bán tại quầy có thể không có khách
  items: OrderItem[];
};

export function customerLabel(order: Order): string {
  if (!order.customer) return "KHÁCH TẠI QUẦY";
  return order.customer.name.toUpperCase();
}

export function orderTotal(order: Order): number {
  return order.items.reduce((sum, item) => sum + item.price * item.quantity, 0);
}

// Danh sách cho trang quản lý: mỗi đơn một dòng gồm mã, tên khách (in hoa) và tổng tiền.
export function listOrders(orders: Order[]) {
  return orders.map((order) => {
    try {
      return { id: order.id, khach: customerLabel(order), tong: orderTotal(order) };
    } catch (error) {
      // Thêm ngữ cảnh (đơn nào) và giữ lỗi gốc trong cause, để log chỉ ra được đơn hỏng.
      throw new Error(`Không liệt kê được đơn ${order.id}`, { cause: error });
    }
  });
}

Còn src/order-schema.ts là bản rút gọn của schema Zod ở bài trước, vừa đủ để máy chủ từ chối một đơn có số lượng là chữ:

src/order-schema.ts
import { z } from "zod";

// Bản rút gọn của schema ở bài trước, đủ cho bài này.
const itemSchema = z.strictObject({
  name: z.string().min(1),
  price: z.number().int().min(1000, "Giá phải từ 1.000đ"),
  quantity: z.number("Số lượng phải là số").int().min(1),
});

export const newOrderSchema = z.strictObject({
  customer: z.strictObject({ name: z.string().min(1), phone: z.string().regex(/^0\d{9}$/) }),
  items: z.array(itemSchema).min(1),
});

// Mỗi lỗi một dòng, nói rõ trường nào và sai gì.
export function listIssues(error: z.ZodError): { truong: string; loi: string }[] {
  return error.issues.map((issue) => ({ truong: issue.path.join(".") || "(cả đơn)", loi: issue.message }));
}

Viết một logger nhỏ, và cái bẫy của đối tượng Error

Bạn hoàn toàn có thể dùng thư viện như Pino. Mình tự viết một logger bốn chục dòng để cho thấy nó làm gì bên trong, và vì như vậy bạn hiểu được mỗi dòng log đến từ đâu. Khi làm dự án thật, theo mình bạn nên dùng thư viện có sẵn thay vì tự viết.

Có một chi tiết dễ làm bạn bất ngờ khi viết logger lần đầu. Bạn thử JSON.stringify({ error: new Error("hỏng") }) xem. Kết quả là {"error":{}}, một đối tượng rỗng. Lý do là name, message và stack của một lỗi thật không phải thuộc tính "đếm được", nên JSON.stringify bỏ qua chúng. Hậu quả là nếu bạn ghi log kiểu log.error("lỗi", { error }) thì dòng log có chữ "lỗi" và một đối tượng rỗng. Vì vậy mình viết hàm describeError để biến lỗi thành dữ liệu thường:

src/logger.ts
import { pathToFileURL } from "node:url";

// Ghi log dạng JSON, mỗi dòng một sự kiện. Máy đọc được, người cũng đọc được.
export type Level = "info" | "warn" | "error";
export type Fields = Record<string, unknown>;

export type Logger = {
  info(msg: string, fields?: Fields): void;
  warn(msg: string, fields?: Fields): void;
  error(msg: string, fields?: Fields): void;
  // Logger mới luôn ghi kèm các trường này (ví dụ requestId), khỏi phải truyền lại ở mỗi dòng.
  child(fields: Fields): Logger;
};

export type ErrorInfo = { name: string; message: string; stack?: string; cause?: ErrorInfo };

const PROJECT_URL = pathToFileURL(process.cwd()).href + "/";

// Biến một lỗi thành dữ liệu thường để JSON.stringify ghi được. Lỗi thật có name/message/stack
// là thuộc tính không đếm được, nên JSON.stringify(new Error("x")) chỉ ra "{}".
// Đi theo chuỗi cause để không mất lỗi gốc. Stack chỉ giữ 4 dòng đầu cho log gọn.
export function describeError(error: unknown): ErrorInfo {
  if (!(error instanceof Error)) return { name: "NonError", message: String(error) };
  return {
    name: error.name,
    message: error.message,
    stack: error.stack?.split("\n").slice(1, 5).map((line) => line.trim().replace(PROJECT_URL, "")).join(" | "),
    ...(error.cause === undefined ? {} : { cause: describeError(error.cause) }),
  };
}

export function createLogger(write: (line: string) => void = console.log, base: Fields = {}): Logger {
  const emit = (level: Level, msg: string, fields: Fields = {}) =>
    write(JSON.stringify({ time: new Date().toISOString(), level, msg, ...base, ...fields }));
  return {
    info: (msg, fields) => emit("info", msg, fields),
    warn: (msg, fields) => emit("warn", msg, fields),
    error: (msg, fields) => emit("error", msg, fields),
    child: (fields) => createLogger(write, { ...base, ...fields }),
  };
}

Có ba điểm đáng chú ý trong file này. Thứ nhất, child trả về một logger mới luôn ghi kèm các trường đã cho. Máy chủ sẽ tạo một logger con cho mỗi request, gắn sẵn requestId, method và path, rồi mọi dòng log của request đó tự mang chúng theo, không ai phải nhớ truyền. Thứ hai, describeError đi theo cause, tức là lỗi gốc mà một lỗi khác bọc bên ngoài. Thứ ba, logger nhận hàm write làm tham số, mặc định là console.log. Nhờ vậy khi viết test, bạn truyền vào một hàm gom các dòng vào mảng, không cần đọc màn hình.

Nối logger vào máy chủ: mỗi request một mã, mỗi lý do một dòng

Giờ đến máy chủ. Có bốn thay đổi so với bài trước, và mình sẽ chỉ ra từng cái sau khi bạn xem code:

src/order-server.ts
import { randomUUID } from "node:crypto";
import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";

import { createLogger, describeError, type Logger } from "./logger.ts";
import { listIssues, newOrderSchema } from "./order-schema.ts";
import { listOrders, type Order } from "./orders.ts";

const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
const MAX_BODY_BYTES = 100_000;

// Máy chủ HTTP cho đơn hàng. Mỗi request có một mã ngắn (requestId) gắn vào mọi dòng log của nó.
export function createOrderServer(orders: Order[], logger: Logger = createLogger()): Server {
  return createServer(async (request, response) => {
    const requestId = randomUUID().slice(0, 8);
    const log = logger.child({ requestId, method: request.method, path: request.url });
    const startedAt = performance.now();

    // Một dòng tóm tắt cho mỗi request: mã trạng thái và thời gian xử lý. 4xx là lỗi của người gửi
    // nên chỉ là warn; 5xx là lỗi của máy chủ nên là error.
    response.on("finish", () => {
      const status = response.statusCode;
      const level = status >= 500 ? "error" : status >= 400 ? "warn" : "info";
      log[level]("request", { status, ms: Math.round(performance.now() - startedAt) });
    });

    try {
      await route(request, response, orders, log);
    } catch (error) {
      // Lỗi không lường trước: ghi đủ chi tiết vào log, nhưng chỉ đưa cho người gọi một mã để tra.
      log.error("lỗi không lường trước", { error: describeError(error) });
      if (response.headersSent) response.end();
      else sendError(response, 500, "Lỗi máy chủ", { maLoi: requestId });
    }
  });
}

async function route(request: IncomingMessage, response: ServerResponse, orders: Order[], log: Logger): Promise<void> {
  if (request.url === "/don-hang" && request.method === "POST") return receiveOrder(request, response, orders, log);
  if (request.url === "/don-hang") return sendOrderList(response, orders);
  response.writeHead(404).end();
}

async function receiveOrder(request: IncomingMessage, response: ServerResponse, orders: Order[], log: Logger): Promise<void> {
  const body = await readBody(request);
  if (body === null) {
    log.warn("từ chối đơn", { lyDo: "nội dung quá lớn", gioiHanKyTu: MAX_BODY_BYTES });
    return sendError(response, 413, "Nội dung gửi lên quá lớn");
  }

  let data: unknown;
  try {
    data = JSON.parse(body);
  } catch {
    log.warn("từ chối đơn", { lyDo: "không phải JSON", doDai: body.length });
    return sendError(response, 400, "Nội dung gửi lên không phải JSON hợp lệ");
  }

  const result = newOrderSchema.safeParse(data);
  if (!result.success) {
    // Ghi tên trường và lý do, không ghi giá trị khách gửi lên: số điện thoại, tên là dữ liệu cá nhân.
    const issues = listIssues(result.error);
    log.warn("từ chối đơn", { lyDo: "dữ liệu không hợp lệ", chiTiet: issues });
    return sendError(response, 400, "Đơn hàng không hợp lệ", { chiTiet: issues });
  }

  const order: Order = {
    id: Math.max(0, ...orders.map((existing) => existing.id)) + 1,
    createdAt: new Date().toISOString(),
    source: "web",
    ...result.data,
  };
  orders.push(order);
  log.info("đã nhận đơn", { orderId: order.id, soMon: order.items.length });
  response.writeHead(201, JSON_HEADERS).end(JSON.stringify({ id: order.id }));
}

// Đọc tối đa MAX_BODY_BYTES; vượt quá thì trả null để bên gọi từ chối.
async function readBody(request: IncomingMessage): Promise<string | null> {
  let body = "";
  for await (const chunk of request) {
    body += chunk;
    if (body.length > MAX_BODY_BYTES) return null;
  }
  return body;
}

function sendError(response: ServerResponse, status: number, message: string, extra: object = {}): void {
  response.writeHead(status, JSON_HEADERS).end(JSON.stringify({ loi: message, ...extra }));
}

function sendOrderList(response: ServerResponse, orders: Order[]): void {
  // Không còn try/catch ở đây: nếu listOrders ném lỗi, hàm bọc ngoài ghi log và trả 500.
  // Dựng xong nội dung rồi mới writeHead(200): đã gửi mã 200 đi thì không đổi thành 500 được nữa.
  const orderListJson = JSON.stringify(listOrders(orders), null, 2);
  response.writeHead(200, JSON_HEADERS).end(orderListJson);
}

Bốn thay đổi là như sau. Một: ngay khi request đến, máy chủ tạo requestId và một logger con, nên mọi dòng sau đó của request này cùng mang mã đó. Hai: sự kiện finish của response ghi đúng một dòng tóm tắt khi request kết thúc, gồm mã trạng thái và số mili giây xử lý, ở mức info, warn hoặc error tùy mã trạng thái. Ba: mỗi lần từ chối một đơn, máy chủ ghi lý do. Riêng với đơn sai schema, mình ghi tên trường và lỗi, và cố ý không ghi giá trị khách gửi lên, vì tên và số điện thoại là dữ liệu cá nhân, và file log thường sống lâu hơn bạn nghĩ. Bốn: khối try/catch bao ngoài mọi thứ là nơi duy nhất bắt lỗi không lường trước. Hàm sendOrderList không cần tự bắt nữa.

Về phần khách: khi lỗi 500 xảy ra, người gọi nhận {"loi":"Lỗi máy chủ","maLoi":"..."}, chỉ gồm một mã. Mọi chi tiết nội bộ như tên hàm, đường dẫn file hay thông báo của thư viện ở lại trong log. Lý do là chi tiết nội bộ là thứ kẻ tấn công thích đọc, còn người dùng bình thường thì không hiểu nó. Mã maLoi giống hệt requestId trong log, nên nếu khách phàn nàn, bạn chỉ cần hỏi mã đó.

Một chi tiết nhỏ mà mình đã sai ở lần viết đầu: ban đầu mình viết response.writeHead(200).end(JSON.stringify(listOrders(orders))) trên một dòng. writeHead(200) chạy trước, rồi listOrders mới ném lỗi, và lúc đó mã 200 đã được gán. Dòng log tóm tắt của request ghi status: 200 ngay cạnh dòng error, và người gọi nhận một câu trả lời rỗng với mã thành công. Chính cái log mới viết là thứ làm lộ lỗi của nó. Vì vậy trong code trên mình dựng nội dung trước rồi mới gửi mã trạng thái.

Chạy thử: gửi ba request và đọc log

Script dưới đây khởi động máy chủ với hai đơn có sẵn (một đơn tốt, một đơn hỏng 1050 thiếu tên khách), gửi ba request, rồi in câu trả lời ra stderr để tách khỏi log, vốn ra stdout:

thu-log.ts
// Chạy máy chủ có log với một đơn dữ liệu hỏng, gửi ba request và in log lẫn câu trả lời. Chạy: node thu-log.ts
import type { AddressInfo } from "node:net";

import { createOrderServer } from "./src/order-server.ts";
import type { Order } from "./src/orders.ts";

const donTot: Order = {
  id: 1041,
  createdAt: "2026-11-03T08:12:00+07:00",
  source: "web",
  customer: { name: "Nguyễn An", phone: "0901000001" },
  items: [{ name: "Cà phê sữa", price: 29000, quantity: 2 }],
};
// Đơn 1050 có số điện thoại nhưng thiếu tên khách: dữ liệu hỏng đã nằm sẵn trong danh sách.
const donHong = { id: 1050, createdAt: "2026-11-04T09:00:00+07:00", source: "may-cu", customer: { phone: "0901000050" }, items: [{ name: "Trà đào", price: 35000, quantity: 1 }] } as unknown as Order;

const server = createOrderServer([donTot, donHong]);
await new Promise<void>((resolve) => server.listen(0, resolve));
const goc = `http://localhost:${(server.address() as AddressInfo).port}/don-hang`;
const khach = { name: "Phạm Dung", phone: "0901000010" };

const gui = async (ten: string, init?: RequestInit) => {
  const phanHoi = await fetch(goc, init);
  console.error(`→ ${ten}: ${phanHoi.status} ${(await phanHoi.text()).replace(/\s+/g, " ").slice(0, 110)}`);
};

await gui("POST đơn đúng", { method: "POST", body: JSON.stringify({ customer: khach, items: [{ name: "Cà phê sữa", price: 29000, quantity: 2 }] }) });
await gui("POST số lượng là chữ", { method: "POST", body: JSON.stringify({ customer: khach, items: [{ name: "Cà phê sữa", price: 29000, quantity: "hai" }] }) });
await gui("GET danh sách");
server.close();

Bạn chạy node thu-log.ts (mã requestId và thời gian của bạn sẽ khác). Phần câu trả lời mà khách nhận được:

node thu-log.ts (phần stderr: câu trả lời)
→ POST đơn đúng: 201 {"id":1051}
→ POST số lượng là chữ: 400 {"loi":"Đơn hàng không hợp lệ","chiTiet":[{"truong":"items.0.quantity","loi":"Số lượng phải là số"}]}
→ GET danh sách: 500 {"loi":"Lỗi máy chủ","maLoi":"798637a1"}

Và đây là phần log của máy chủ (stdout), sáu dòng cho ba request:

node thu-log.ts (phần stdout: log)
{"time":"2026-11-12T01:59:37.802Z","level":"info","msg":"đã nhận đơn","requestId":"79833643","method":"POST","path":"/don-hang","orderId":1051,"soMon":1}
{"time":"2026-11-12T01:59:37.804Z","level":"info","msg":"request","requestId":"79833643","method":"POST","path":"/don-hang","status":201,"ms":6}
{"time":"2026-11-12T01:59:37.811Z","level":"warn","msg":"từ chối đơn","requestId":"4e075de4","method":"POST","path":"/don-hang","lyDo":"dữ liệu không hợp lệ","chiTiet":[{"truong":"items.0.quantity","loi":"Số lượng phải là số"}]}
{"time":"2026-11-12T01:59:37.811Z","level":"warn","msg":"request","requestId":"4e075de4","method":"POST","path":"/don-hang","status":400,"ms":1}
{"time":"2026-11-12T01:59:37.813Z","level":"error","msg":"lỗi không lường trước","requestId":"798637a1","method":"GET","path":"/don-hang","error":{"name":"Error","message":"Không liệt kê được đơn 1050","stack":"at src/orders.ts:27:13 | at Array.map (<anonymous>) | at listOrders (src/orders.ts:22:17) | at sendOrderList (src/order-server.ts:94:40)","cause":{"name":"TypeError","message":"Cannot read properties of undefined (reading 'toUpperCase')","stack":"at customerLabel (src/orders.ts:13:30) | at src/orders.ts:24:37 | at Array.map (<anonymous>) | at listOrders (src/orders.ts:22:17)"}}}
{"time":"2026-11-12T01:59:37.814Z","level":"error","msg":"request","requestId":"798637a1","method":"GET","path":"/don-hang","status":500,"ms":1}

Mình xin chỉ ba chỗ cần nhìn. Thứ nhất, requestId của dòng error là 798637a1, trùng với maLoi mà khách nhận được ở dòng cuối của phần stderr. Nếu khách gọi điện, bạn tìm đúng mã đó là ra. Thứ hai, trong dòng error có message là "Không liệt kê được đơn 1050", cho biết đơn nào hỏng, và cause giữ lại lỗi gốc TypeError: Cannot read properties of undefined (reading 'toUpperCase') kèm nơi nó xảy ra, customerLabel (src/orders.ts:13:30). Cặp đó trả lời được hai câu hỏi mà stack trace cũ không trả lời được: đơn nào, và lỗi gốc ở dòng nào. Thứ ba, đơn bị từ chối vì sai số lượng chỉ là warn, không phải error, và log nói rõ trường nào (items.0.quantity) mà không lộ tên hay số điện thoại.

Cuối cùng, để tìm mọi dòng của một request, bạn lọc theo mã. Ví dụ với grep:

Lọc log theo mã request
node thu-log.ts 2>/dev/null | grep 798637a1

Lệnh này chạy lại máy chủ nên mã sẽ khác, nhưng khi máy chủ chạy thật và log được ghi vào file, bạn dùng đúng cách đó với mã khách đưa. Dòng nào cũng là JSON nên bạn cũng có thể lọc theo mức, ví dụ chỉ giữ các dòng "level":"error".

Ghi gì, và đừng ghi gì?

Nếu bạn làm theo thì phần khó nhất không phải code mà là các quyết định về nội dung. Mình theo mấy nguyên tắc sau, và theo mình nên giữ chúng khi bạn làm dự án thật.

Ghi những gì giúp người đến sau trả lời "chuyện gì, lúc nào, của ai, vì sao": mã request, mã đơn (mã nghiệp vụ như orderId), tên trường sai, thời gian xử lý. Đừng ghi dữ liệu cá nhân và bí mật: số điện thoại, mật khẩu, token, khóa API. Mình đã viết sẵn một test cho điều này, bạn sẽ thấy ở dưới. Lý do là file log thường được chép sang nhiều nơi (công cụ giám sát, email báo lỗi, ảnh chụp màn hình gửi cho đồng nghiệp), nên bất cứ thứ gì bạn ghi vào đó coi như đã lộ ra ngoài dự án.

Đừng "nuốt" lỗi. Một khối catch {} rỗng hay catch (e) { console.log("lỗi") } còn tệ hơn không bắt, vì nó biến lỗi thành im lặng. Bạn sẽ thấy hệ thống "chạy" nhưng dữ liệu sai, và không có dấu vết nào để lần theo. Nếu không biết xử lý thế nào thì để lỗi đi lên tầng trên, nơi có một khối bắt tập trung như đoạn catch ở createOrderServer.

Và đừng ghi mọi thứ ở mức error. Nếu đơn sai ghi error thì khi website gửi sai năm trăm đơn, bạn có năm trăm dòng đỏ che mất một lỗi thật. Mình nhắc lại vì chỗ này rất dễ làm ngược.

Viết test cho log

Log cũng là một hành vi của chương trình. Nếu không có test, sẽ có ngày ai đó sửa code làm mất mã requestId mà không ai hay. Vì logger nhận hàm write, test chỉ cần gom các dòng vào một mảng rồi kiểm tra. Đây là test quan trọng nhất: nó gửi một đơn có số điện thoại 0901234567, rồi khẳng định số đó không xuất hiện ở bất kỳ dòng log nào.

src/order-server.log.test.ts
import type { AddressInfo } from "node:net";
import { expect, test } from "vitest";

import { createLogger } from "./logger.ts";
import { createOrderServer } from "./order-server.ts";
import type { Order } from "./orders.ts";

// Chạy máy chủ với logger ghi vào mảng, gửi một request, trả về câu trả lời và các dòng log đã parse.
async function call(orders: Order[], path: string, init?: RequestInit) {
  const lines: Record<string, unknown>[] = [];
  const server = createOrderServer(orders, createLogger((line) => lines.push(JSON.parse(line))));
  await new Promise<void>((resolve) => server.listen(0, resolve));
  try {
    const response = await fetch(`http://localhost:${(server.address() as AddressInfo).port}${path}`, init);
    const body = await response.text();
    await new Promise((resolve) => setTimeout(resolve, 20)); // chờ dòng "request" ghi xong
    return { status: response.status, body, lines };
  } finally {
    server.close();
  }
}

test("đơn bị từ chối: log warn ghi tên trường, không ghi số điện thoại khách", async () => {
  const body = JSON.stringify({ customer: { name: "An", phone: "0901234567" }, items: [{ name: "Cà phê", price: 29000, quantity: "hai" }] });
  const { lines } = await call([], "/don-hang", { method: "POST", body });
  const rejected = lines.find((line) => line.msg === "từ chối đơn");
  expect(rejected).toMatchObject({ level: "warn", chiTiet: [{ truong: "items.0.quantity" }] });
  expect(JSON.stringify(lines)).not.toContain("0901234567");
});

Để chạy, bạn thêm "vitest": "5.1.0" vào devDependencies trong package.json, chạy npm install, rồi npx vitest run src/order-server.log.test.ts. Trong repo demo mình viết thêm hai test cùng kiểu: lỗi 500 phải có requestId trùng với maLoi trả cho khách và có lỗi gốc trong cause, còn mọi request phải có đúng một dòng tóm tắt. Chạy chung với các test cũ của những bài trước, kết quả là 47 test xanh:

npx vitest run src (trong repo demo, có cả test của các bài trước)
 Test Files  7 passed (7)
      Tests  47 passed (47)

Nếu một ngày ai đó "tiện tay" ghi cả nội dung request vào log để dễ debug, test này đỏ ngay.

Lỗi giờ đã có dấu vết, còn lỗi chậm thì sao?

Đến đây máy chủ của quán Mộc đã có thứ mà ngày trước nó không có: khi có chuyện, nó kể lại bằng log. Mỗi request có mã, mỗi lỗi có chỗ ở, và dữ liệu khách không bị lộ. Nhưng chú ý một điều trong các dòng log ở trên: mỗi request đều ghi ms, thời gian xử lý, và hiện tại các con số đó đều là vài mili giây. Khi một request nào đó bắt đầu chậm, log sẽ cho bạn biết request nào chậm và chậm bao lâu. Nó chưa cho bạn biết chậm ở dòng code nào. Cách tìm đúng chỗ chậm mà không đoán mò là việc của các bài viết sau.

Bạn theo dõi cả câu chuyện ở series Nhận dự án cũ. Nếu muốn ôn lại cách đọc một lỗi, bài đọc stack trace là điểm bắt đầu, và các câu hỏi về xử lý lỗi, API có trong ngân hàng câu hỏi phỏng vấn.

Nhận bài tiếp theo qua email.

Một email mỗi tuần, chỉ khi có điều đáng đọc. Không spam.