feat(servers): add logging for create, delete, and list server requests (#300)

Author: sonikro

packages/entrypoints/src/http/routes/servers/createServer.ts

@@ -1,6 +1,7 @@
 import { Request, Response } from 'express';
 import { BackgroundTaskQueue, Region, Variant } from '@tf2qs/core';
 import { CreateServerForClientTaskData } from '@tf2qs/providers';
+import { logger } from '@tf2qs/telemetry';
 
 export function createCreateServerHandler(backgroundTaskQueue: BackgroundTaskQueue) {
     /**
@@ -37,6 +38,11 @@ export function createCreateServerHandler(backgroundTaskQueue: BackgroundTaskQue
     return async (req: Request, res: Response): Promise<void> => {
         const clientId = req.auth?.payload.azp || req.auth?.payload.sub;
         if (!clientId) {
+            logger.emit({
+                severityText: 'WARN',
+                body: 'Create server request with no client ID in token',
+                attributes: { path: req.path, method: req.method },
+            });
             res.status(401).json({ error: 'Unauthorized', message: 'No client ID found in token' });
             return;
         }
@@ -48,32 +54,74 @@ export function createCreateServerHandler(backgroundTaskQueue: BackgroundTaskQue
             firstMap?: unknown;
         };
 
+        logger.emit({
+            severityText: 'INFO',
+            body: 'Create server request received',
+            attributes: {
+                clientId: clientId as string,
+                region: region as string,
+                variantName: variantName as string,
+                firstMap: firstMap as string | undefined,
+                hasExtraEnvs: String(extraEnvs !== undefined),
+            },
+        });
+
         if (!region || typeof region !== 'string') {
+            logger.emit({
+                severityText: 'WARN',
+                body: 'Create server validation failed: invalid region',
+                attributes: { clientId: String(clientId), region: String(region), reason: 'not a string or missing' },
+            });
             res.status(400).json({ error: 'Bad Request', message: 'region is required and must be a string' });
             return;
         }
         if (!Object.values(Region).includes(region as Region)) {
+            logger.emit({
+                severityText: 'WARN',
+                body: 'Create server validation failed: unknown region',
+                attributes: { clientId: String(clientId), region: String(region), reason: 'not a valid Region enum value' },
+            });
             res.status(400).json({ error: 'Bad Request', message: 'region is not a valid region' });
             return;
         }
         if (!variantName || typeof variantName !== 'string') {
+            logger.emit({
+                severityText: 'WARN',
+                body: 'Create server validation failed: invalid variantName',
+                attributes: { clientId: String(clientId), region: String(region), variantName: String(variantName), reason: 'not a string or missing' },
+            });
             res.status(400).json({ error: 'Bad Request', message: 'variantName is required and must be a string' });
             return;
         }
         if (firstMap !== undefined && (typeof firstMap !== 'string' || !/^\w+$/.test(firstMap))) {
+            logger.emit({
+                severityText: 'WARN',
+                body: 'Create server validation failed: invalid map',
+                attributes: { clientId: String(clientId), region: String(region), variantName: String(variantName), firstMap: String(firstMap), reason: 'map name contains invalid characters' },
+            });
             res.status(400).json({ error: 'Bad Request', message: 'Invalid map' });
             return;
         }
 
         let sanitizedExtraEnvs: Record<string, string> | undefined;
         if (extraEnvs !== undefined) {
             if (typeof extraEnvs !== 'object' || Array.isArray(extraEnvs) || extraEnvs === null) {
+                logger.emit({
+                    severityText: 'WARN',
+                    body: 'Create server validation failed: invalid extraEnvs type',
+                    attributes: { clientId: String(clientId), region: String(region), variantName: String(variantName), reason: 'not a key-value object' },
+                });
                 res.status(400).json({ error: 'Bad Request', message: 'extraEnvs must be a key-value object if provided' });
                 return;
             }
             const result: Record<string, string> = {};
             for (const [key, value] of Object.entries(extraEnvs as Record<string, unknown>)) {
                 if (typeof value !== 'string') {
+                    logger.emit({
+                        severityText: 'WARN',
+                        body: 'Create server validation failed: extraEnvs non-string value',
+                        attributes: { clientId: String(clientId), region: String(region), variantName: String(variantName), extraEnvKey: key },
+                    });
                     res.status(400).json({ error: 'Bad Request', message: 'extraEnvs values must be strings' });
                     return;
                 }
@@ -87,11 +135,23 @@ export function createCreateServerHandler(backgroundTaskQueue: BackgroundTaskQue
             variantName: variantName as Variant,
             clientId: clientId as string,
             extraEnvs: sanitizedExtraEnvs,
-            firstMap:firstMap as string | undefined,
+            firstMap: firstMap as string | undefined,
         };
 
         const taskId = await backgroundTaskQueue.enqueue('create-server-for-client', taskData, undefined, undefined, { ownerId: clientId as string });
 
+        logger.emit({
+            severityText: 'INFO',
+            body: 'Create server task enqueued',
+            attributes: {
+                clientId: clientId as string,
+                region: region as string,
+                variantName: variantName as string,
+                taskId,
+                firstMap: firstMap as string | undefined,
+            },
+        });
+
         res.status(202).json({ taskId });
     };
 }

packages/entrypoints/src/http/routes/servers/deleteServer.ts

@@ -1,5 +1,6 @@
 import { Request, Response } from 'express';
 import { BackgroundTaskQueue, ServerRepository } from '@tf2qs/core';
+import { logger } from '@tf2qs/telemetry';
 
 export function createDeleteServerHandler(backgroundTaskQueue: BackgroundTaskQueue, serverRepository: ServerRepository) {
     /**
@@ -39,25 +40,52 @@ export function createDeleteServerHandler(backgroundTaskQueue: BackgroundTaskQue
     return async (req: Request, res: Response): Promise<void> => {
         const clientId = req.auth?.payload.azp || req.auth?.payload.sub;
         if (!clientId) {
+            logger.emit({
+                severityText: 'WARN',
+                body: 'Delete server request with no client ID in token',
+                attributes: { path: req.path, method: req.method },
+            });
             res.status(401).json({ error: 'Unauthorized', message: 'No client ID found in token' });
             return;
         }
 
         const { serverId } = req.params;
 
+        logger.emit({
+            severityText: 'INFO',
+            body: 'Delete server request received',
+            attributes: { clientId: clientId as string, serverId },
+        });
+
         const server = await serverRepository.findById(serverId);
         if (!server) {
+            logger.emit({
+                severityText: 'WARN',
+                body: 'Delete server failed: server not found',
+                attributes: { clientId: clientId as string, serverId },
+            });
             res.status(404).json({ error: 'Not Found', message: `Server ${serverId} not found` });
             return;
         }
 
         if (server.createdBy !== clientId) {
+            logger.emit({
+                severityText: 'WARN',
+                body: 'Delete server forbidden: client does not own server',
+                attributes: { clientId: clientId as string, serverId, serverOwner: server.createdBy },
+            });
             res.status(403).json({ error: 'Forbidden', message: 'You do not have permission to delete this server' });
             return;
         }
 
         const taskId = await backgroundTaskQueue.enqueue('delete-server', { serverId }, undefined, undefined, { ownerId: clientId as string });
 
+        logger.emit({
+            severityText: 'INFO',
+            body: 'Delete server task enqueued',
+            attributes: { clientId: clientId as string, serverId, taskId, region: server.region },
+        });
+
         res.status(202).json({ taskId });
     };
 }

packages/entrypoints/src/http/routes/servers/listServers.ts

@@ -1,5 +1,6 @@
 import { Request, Response } from 'express';
 import { GetUserServers } from '@tf2qs/core';
+import { logger } from '@tf2qs/telemetry';
 
 export function createListServersHandler(getUserServers: GetUserServers) {
     /**
@@ -27,11 +28,29 @@ export function createListServersHandler(getUserServers: GetUserServers) {
     return async (req: Request, res: Response): Promise<void> => {
         const clientId = req.auth?.payload.azp || req.auth?.payload.sub;
         if (!clientId) {
+            logger.emit({
+                severityText: 'WARN',
+                body: 'List servers request with no client ID in token',
+                attributes: { path: req.path, method: req.method },
+            });
             res.status(401).json({ error: 'Unauthorized', message: 'No client ID found in token' });
             return;
         }
 
+        logger.emit({
+            severityText: 'INFO',
+            body: 'List servers request received',
+            attributes: { clientId: clientId as string },
+        });
+
         const servers = await getUserServers.execute({ userId: clientId as string });
+
+        logger.emit({
+            severityText: 'INFO',
+            body: 'List servers response',
+            attributes: { clientId: clientId as string, serverCount: servers.length },
+        });
+
         res.json(servers);
     };
 }