feat: enhance task handlers with logging and performance monitoring using Fastify's request.log for improved observability in backend-nodejs

Author: erweixin

backend-nodejs/domains/task/handlers/complete_task.handler.ts

@@ -11,19 +11,53 @@ import { createContextFromRequest } from '../../../shared/types/context.js';
 /**
  * CompleteTask Handler
  * HTTP 适配层：处理完成任务的 HTTP 请求
+ * 负责日志记录和性能监控，使用 Fastify 的 request.log（自动包含请求上下文）
  * 错误由全局错误处理中间件统一处理
  */
 export async function completeTaskHandler(
   deps: HandlerDependencies,
   req: FastifyRequest<{ Params: { id: string } }>,
   reply: FastifyReply
 ): Promise<void> {
+  const startTime = Date.now();
   const userId = requireUserId(req);
   const taskId = req.params.id;
 
-  const input = toCompleteTaskInput(userId, taskId);
-  const ctx = createContextFromRequest({ userId, ...req });
-  const output = await deps.taskService.completeTask(ctx, input);
+  req.log.info({
+    taskId,
+    userId,
+  }, 'Completing task');
 
-  reply.code(200).send(toCompleteTaskResponse(output.task));
+  try {
+    const input = toCompleteTaskInput(userId, taskId);
+    const ctx = createContextFromRequest({ userId, ...req });
+    const output = await deps.taskService.completeTask(ctx, input);
+
+    const duration = Date.now() - startTime;
+    req.log.info({
+      taskId: output.task.id,
+      userId: output.task.userId,
+      duration,
+    }, 'Task completed successfully');
+
+    if (duration > 1000) {
+      req.log.warn({
+        taskId: output.task.id,
+        duration,
+        threshold: 1000,
+      }, 'Slow task completion');
+    }
+
+    reply.code(200).send(toCompleteTaskResponse(output.task));
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    req.log.error({
+      taskId,
+      userId,
+      duration,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    }, 'Failed to complete task');
+    throw error;
+  }
 }

backend-nodejs/domains/task/handlers/create_task.handler.ts

@@ -13,25 +13,65 @@ import { createContextFromRequest } from '../../../shared/types/context.js';
 /**
  * CreateTask Handler
  * HTTP 适配层：处理创建任务的 HTTP 请求
+ * 负责日志记录和性能监控，使用 Fastify 的 request.log（自动包含请求上下文）
  * 错误由全局错误处理中间件统一处理
  */
 export async function createTaskHandler(
   deps: HandlerDependencies,
   req: FastifyRequest<{ Body: CreateTaskRequest }>,
   reply: FastifyReply
 ): Promise<void> {
-  // 1. 获取用户 ID（从 JWT Token 中提取）
+  const startTime = Date.now();
   const userId = requireUserId(req);
 
-  // 2. 转换为 Domain Input
-  const input = toCreateTaskInput(userId, req.body);
+  // 使用 Fastify 的 request.log（自动包含 traceId, requestId）
+  req.log.info({
+    userId,
+    title: req.body.title,
+    priority: req.body.priority,
+    hasDueDate: !!req.body.due_date,
+    tagCount: req.body.tags?.length || 0,
+  }, 'Creating task');
 
-  // 3. 创建请求上下文
-  const ctx = createContextFromRequest({ userId, ...req });
+  try {
+    // 转换为 Domain Input
+    const input = toCreateTaskInput(userId, req.body);
 
-  // 4. 调用 Domain Service（错误会自动向上抛出，由全局错误处理中间件处理）
-  const output = await deps.taskService.createTask(ctx, input);
+    // 创建请求上下文
+    const ctx = createContextFromRequest({ userId, ...req });
 
-  // 4. 转换为 HTTP 响应
-  reply.code(200).send(toCreateTaskResponse(output.task));
+    // 调用 Domain Service（纯业务逻辑，不包含日志）
+    const output = await deps.taskService.createTask(ctx, input);
+
+    // 记录成功日志和性能指标
+    const duration = Date.now() - startTime;
+    req.log.info({
+      taskId: output.task.id,
+      userId: output.task.userId,
+      duration,
+    }, 'Task created successfully');
+
+    // 慢操作警告
+    if (duration > 1000) {
+      req.log.warn({
+        taskId: output.task.id,
+        duration,
+        threshold: 1000,
+      }, 'Slow task creation');
+    }
+
+    // 转换为 HTTP 响应
+    reply.code(200).send(toCreateTaskResponse(output.task));
+  } catch (error) {
+    // 记录错误日志
+    const duration = Date.now() - startTime;
+    req.log.error({
+      userId,
+      title: req.body.title,
+      duration,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    }, 'Failed to create task');
+    throw error; // 由全局错误处理器处理
+  }
 }

backend-nodejs/domains/task/handlers/delete_task.handler.ts

@@ -11,19 +11,53 @@ import { createContextFromRequest } from '../../../shared/types/context.js';
 /**
  * DeleteTask Handler
  * HTTP 适配层：处理删除任务的 HTTP 请求
+ * 负责日志记录和性能监控，使用 Fastify 的 request.log（自动包含请求上下文）
  * 错误由全局错误处理中间件统一处理
  */
 export async function deleteTaskHandler(
   deps: HandlerDependencies,
   req: FastifyRequest<{ Params: { id: string } }>,
   reply: FastifyReply
 ): Promise<void> {
+  const startTime = Date.now();
   const userId = requireUserId(req);
   const taskId = req.params.id;
 
-  const input = toDeleteTaskInput(userId, taskId);
-  const ctx = createContextFromRequest({ userId, ...req });
-  const output = await deps.taskService.deleteTask(ctx, input);
+  req.log.info({
+    taskId,
+    userId,
+  }, 'Deleting task');
 
-  reply.code(200).send(toDeleteTaskResponse(output.success, output.deletedAt));
+  try {
+    const input = toDeleteTaskInput(userId, taskId);
+    const ctx = createContextFromRequest({ userId, ...req });
+    const output = await deps.taskService.deleteTask(ctx, input);
+
+    const duration = Date.now() - startTime;
+    req.log.info({
+      taskId,
+      userId,
+      duration,
+    }, 'Task deleted successfully');
+
+    if (duration > 1000) {
+      req.log.warn({
+        taskId,
+        duration,
+        threshold: 1000,
+      }, 'Slow task deletion');
+    }
+
+    reply.code(200).send(toDeleteTaskResponse(output.success, output.deletedAt));
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    req.log.error({
+      taskId,
+      userId,
+      duration,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    }, 'Failed to delete task');
+    throw error;
+  }
 }

backend-nodejs/domains/task/handlers/get_task.handler.ts

@@ -11,19 +11,53 @@ import { createContextFromRequest } from '../../../shared/types/context.js';
 /**
  * GetTask Handler
  * HTTP 适配层：处理获取任务详情的 HTTP 请求
+ * 负责日志记录和性能监控，使用 Fastify 的 request.log（自动包含请求上下文）
  * 错误由全局错误处理中间件统一处理
  */
 export async function getTaskHandler(
   deps: HandlerDependencies,
   req: FastifyRequest<{ Params: { id: string } }>,
   reply: FastifyReply
 ): Promise<void> {
+  const startTime = Date.now();
   const userId = requireUserId(req);
   const taskId = req.params.id;
 
-  const input = toGetTaskInput(userId, taskId);
-  const ctx = createContextFromRequest({ userId, ...req });
-  const output = await deps.taskService.getTask(ctx, input);
+  req.log.info({
+    taskId,
+    userId,
+  }, 'Getting task');
 
-  reply.code(200).send(toGetTaskResponse(output.task));
+  try {
+    const input = toGetTaskInput(userId, taskId);
+    const ctx = createContextFromRequest({ userId, ...req });
+    const output = await deps.taskService.getTask(ctx, input);
+
+    const duration = Date.now() - startTime;
+    req.log.info({
+      taskId: output.task.id,
+      userId: output.task.userId,
+      duration,
+    }, 'Task retrieved successfully');
+
+    if (duration > 500) {
+      req.log.warn({
+        taskId: output.task.id,
+        duration,
+        threshold: 500,
+      }, 'Slow task retrieval');
+    }
+
+    reply.code(200).send(toGetTaskResponse(output.task));
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    req.log.error({
+      taskId,
+      userId,
+      duration,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    }, 'Failed to get task');
+    throw error;
+  }
 }

backend-nodejs/domains/task/handlers/list_tasks.handler.ts

@@ -12,28 +12,66 @@ import { createContextFromRequest } from '../../../shared/types/context.js';
 /**
  * ListTasks Handler
  * HTTP 适配层：处理列出任务的 HTTP 请求
+ * 负责日志记录和性能监控，使用 Fastify 的 request.log（自动包含请求上下文）
  * 错误由全局错误处理中间件统一处理
  */
 export async function listTasksHandler(
   deps: HandlerDependencies,
   req: FastifyRequest<{ Querystring: ListTasksQuery }>,
   reply: FastifyReply
 ): Promise<void> {
+  const startTime = Date.now();
   const userId = requireUserId(req);
 
-  const input = toListTasksInput(userId, req.query);
-  const ctx = createContextFromRequest({ userId, ...req });
-  const output = await deps.taskService.listTasks(ctx, input);
+  req.log.info({
+    userId,
+    page: req.query.page,
+    limit: req.query.limit,
+    status: req.query.status,
+    priority: req.query.priority,
+  }, 'Listing tasks');
 
-  reply
-    .code(200)
-    .send(
-      toListTasksResponse(
-        output.tasks,
-        output.totalCount,
-        output.page,
-        output.limit,
-        output.hasMore
-      )
-    );
+  try {
+    const input = toListTasksInput(userId, req.query);
+    const ctx = createContextFromRequest({ userId, ...req });
+    const output = await deps.taskService.listTasks(ctx, input);
+
+    const duration = Date.now() - startTime;
+    req.log.info({
+      userId,
+      taskCount: output.tasks.length,
+      totalCount: output.totalCount,
+      duration,
+    }, 'Tasks listed successfully');
+
+    if (duration > 1000) {
+      req.log.warn({
+        userId,
+        taskCount: output.tasks.length,
+        duration,
+        threshold: 1000,
+      }, 'Slow task listing');
+    }
+
+    reply
+      .code(200)
+      .send(
+        toListTasksResponse(
+          output.tasks,
+          output.totalCount,
+          output.page,
+          output.limit,
+          output.hasMore
+        )
+      );
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    req.log.error({
+      userId,
+      duration,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    }, 'Failed to list tasks');
+    throw error;
+  }
 }

backend-nodejs/domains/task/handlers/update_task.handler.ts

@@ -15,6 +15,7 @@ import { createContextFromRequest } from '../../../shared/types/context.js';
 /**
  * UpdateTask Handler
  * HTTP 适配层：处理更新任务的 HTTP 请求
+ * 负责日志记录和性能监控，使用 Fastify 的 request.log（自动包含请求上下文）
  * 错误由全局错误处理中间件统一处理
  */
 export async function updateTaskHandler(
@@ -25,13 +26,50 @@ export async function updateTaskHandler(
   }>,
   reply: FastifyReply
 ): Promise<void> {
-  // 使用工具函数提取用户 ID 和路径参数
+  const startTime = Date.now();
   const userId = getUserIDFromRequest(req);
   const taskId = getRequiredPathParam(req, 'id');
 
-  const input = toUpdateTaskInput(userId, taskId, req.body);
-  const ctx = createContextFromRequest({ userId, ...req });
-  const output = await deps.taskService.updateTask(ctx, input);
+  req.log.info({
+    taskId,
+    userId,
+    hasTitle: req.body.title !== undefined,
+    hasDescription: req.body.description !== undefined,
+    hasPriority: req.body.priority !== undefined,
+    hasDueDate: req.body.due_date !== undefined,
+    hasTags: req.body.tags !== undefined,
+  }, 'Updating task');
 
-  reply.code(200).send(toUpdateTaskResponse(output.task));
+  try {
+    const input = toUpdateTaskInput(userId, taskId, req.body);
+    const ctx = createContextFromRequest({ userId, ...req });
+    const output = await deps.taskService.updateTask(ctx, input);
+
+    const duration = Date.now() - startTime;
+    req.log.info({
+      taskId: output.task.id,
+      userId: output.task.userId,
+      duration,
+    }, 'Task updated successfully');
+
+    if (duration > 1000) {
+      req.log.warn({
+        taskId: output.task.id,
+        duration,
+        threshold: 1000,
+      }, 'Slow task update');
+    }
+
+    reply.code(200).send(toUpdateTaskResponse(output.task));
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    req.log.error({
+      taskId,
+      userId,
+      duration,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    }, 'Failed to update task');
+    throw error;
+  }
 }