Cleanup debug logs and implement unified logger (#109)

* Implement unified logging system

- Create shared logger package with structured logging
- Integrate logger into sandbox container and DO layer
- Remove duplicate and unnecessary console.log statements
- Add trace context support for request tracking
- Update logging configuration and middleware

* Delete dead code

Author: ghostwriternr

packages/sandbox-container/src/config.ts

@@ -1,3 +1,20 @@
+/**
+ * Log level for the sandbox container.
+ *
+ * Default: info
+ * Environment variable: SANDBOX_LOG_LEVEL
+ */
+const SANDBOX_LOG_LEVEL = process.env.SANDBOX_LOG_LEVEL || 'info';
+
+/**
+ * Log format for the sandbox container.
+ *
+ * Default: json
+ * Set to "pretty" to enable colored, human-readable output.
+ * Environment variable: SANDBOX_LOG_FORMAT
+ */
+const SANDBOX_LOG_FORMAT = process.env.SANDBOX_LOG_FORMAT || 'json';
+
 /**
  * How long to wait for an interpreter process to spawn and become ready.
  * If an interpreter doesn't start within this time, something is fundamentally
@@ -65,6 +82,8 @@ const STREAM_CHUNK_DELAY_MS = 100;
 const DEFAULT_CWD = '/workspace';
 
 export const CONFIG = {
+	SANDBOX_LOG_LEVEL,
+	SANDBOX_LOG_FORMAT,
 	INTERPRETER_SPAWN_TIMEOUT_MS,
 	INTERPRETER_EXECUTION_TIMEOUT_MS,
 	COMMAND_TIMEOUT_MS,

packages/sandbox-container/src/core/container.ts

@@ -1,3 +1,5 @@
+import type { Logger } from '@repo/shared';
+import { createLogger } from '@repo/shared';
 import { ExecuteHandler } from '../handlers/execute-handler';
 import { FileHandler } from '../handlers/file-handler';
 import { GitHandler } from '../handlers/git-handler';
@@ -17,8 +19,6 @@ import { InMemoryPortStore, PortService } from '../services/port-service';
 import { InMemoryProcessStore, ProcessService } from '../services/process-service';
 import { SessionManager } from '../services/session-manager';
 import { RequestValidator } from '../validation/request-validator';
-import { ConsoleLogger } from './logger';
-import type { Logger } from './types';
 
 export interface Dependencies {
   // Services
@@ -76,7 +76,7 @@ export class Container {
     }
 
     // Initialize infrastructure
-    const logger = new ConsoleLogger();
+    const logger = createLogger({ component: 'container' });
     const security = new SecurityService(logger);
     const securityAdapter = new SecurityServiceAdapter(security);
     const validator = new RequestValidator();
@@ -85,10 +85,8 @@ export class Container {
     const processStore = new InMemoryProcessStore();
     const portStore = new InMemoryPortStore();
 
-    // Initialize SessionManager (always - no test-specific conditionals)
-    console.log('[Container] Initializing SessionManager');
+    // Initialize SessionManager
     const sessionManager = new SessionManager(logger);
-    console.log('[Container] SessionManager created');
 
     // Initialize services
     const processService = new ProcessService(processStore, logger, sessionManager);
@@ -146,9 +144,4 @@ export class Container {
   isInitialized(): boolean {
     return this.initialized;
   }
-
-  // Helper method to get all dependencies (for testing)
-  getAllDependencies(): Partial<Dependencies> {
-    return { ...this.dependencies };
-  }
 }

packages/sandbox-container/src/core/logger.ts

@@ -1,5 +1,6 @@
 // Centralized Router for handling HTTP requests
 
+import type { Logger } from '@repo/shared';
 import type { ErrorResponse } from '@repo/shared/errors';
 import { ErrorCode } from '@repo/shared/errors';
 import type {
@@ -14,6 +15,11 @@ import type {
 export class Router {
   private routes: RouteDefinition[] = [];
   private globalMiddleware: Middleware[] = [];
+  private logger: Logger;
+
+  constructor(logger: Logger) {
+    this.logger = logger;
+  }
 
   /**
    * Register a route with optional middleware
@@ -43,14 +49,12 @@ export class Router {
   async route(request: Request): Promise<Response> {
     const method = this.validateHttpMethod(request.method);
     const pathname = new URL(request.url).pathname;
-    
-    console.log(`[Router] Routing ${method} ${pathname}`);
 
     // Find matching route
     const route = this.matchRoute(method, pathname);
-    
+
     if (!route) {
-      console.log(`[Router] No route found for ${method} ${pathname}`);
+      this.logger.debug('No route found', { method, pathname });
       return this.createNotFoundResponse();
     }
 
@@ -74,7 +78,11 @@ export class Router {
         route.handler
       );
     } catch (error) {
-      console.error(`[Router] Error handling ${method} ${pathname}:`, error);
+      this.logger.error('Error handling request', error as Error, {
+        method,
+        pathname,
+        requestId: context.requestId
+      });
       return this.createErrorResponse(error instanceof Error ? error : new Error('Unknown error'));
     }
   }

packages/sandbox-container/src/core/router.ts

@@ -201,14 +201,6 @@ export type RequestHandler = (
   context: RequestContext
 ) => Promise<Response>;
 
-// Logger interface
-export interface Logger {
-  info(message: string, meta?: Record<string, unknown>): void;
-  warn(message: string, meta?: Record<string, unknown>): void;
-  error(message: string, error?: Error, meta?: Record<string, unknown>): void;
-  debug(message: string, meta?: Record<string, unknown>): void;
-}
-
 // Session types
 export interface SessionData {
   id: string;

packages/sandbox-container/src/core/types.ts

@@ -1,3 +1,5 @@
+import type { Logger } from '@repo/shared';
+import { TraceContext } from '@repo/shared';
 import {
   type ErrorCode,
   type ErrorResponse,
@@ -7,7 +9,6 @@ import {
 } from "@repo/shared/errors";
 import type {
   Handler,
-  Logger,
   RequestContext,
   ServiceError,
 } from "../core/types";
@@ -103,4 +104,32 @@ export abstract class BaseHandler<TRequest, TResponse>
     const url = new URL(request.url);
     return url.searchParams.get(param);
   }
+
+  /**
+   * Extract traceId from request headers
+   * Returns the traceId if present, null otherwise
+   */
+  protected extractTraceId(request: Request): string | null {
+    return TraceContext.fromHeaders(request.headers);
+  }
+
+  /**
+   * Create a child logger with trace context for this request
+   * Includes traceId if available in request headers
+   */
+  protected createRequestLogger(request: Request, operation?: string): Logger {
+    const traceId = this.extractTraceId(request);
+    const context: Record<string, string> = {};
+
+    if (traceId) {
+      context.traceId = traceId;
+    }
+    if (operation) {
+      context.operation = operation;
+    }
+
+    return context.traceId || context.operation
+      ? this.logger.child(context)
+      : this.logger;
+  }
 }

packages/sandbox-container/src/handlers/base-handler.ts

@@ -1,8 +1,8 @@
 // Execute Handler
-import type { ExecResult, ProcessStartResult } from '@repo/shared';
+import type { ExecResult, Logger, ProcessStartResult } from '@repo/shared';
 import { ErrorCode } from '@repo/shared/errors';
 
-import type { ExecuteRequest, Logger, RequestContext } from '../core/types';
+import type { ExecuteRequest, RequestContext } from '../core/types';
 import type { ProcessService } from '../services/process-service';
 import { BaseHandler } from './base-handler';
 
@@ -35,13 +35,6 @@ export class ExecuteHandler extends BaseHandler<Request, Response> {
     // Parse request body directly
     const body = await this.parseRequestBody<ExecuteRequest>(request);
     const sessionId = body.sessionId || context.sessionId;
-    
-    this.logger.info('Executing command', { 
-      requestId: context.requestId,
-      command: body.command,
-      sessionId,
-      background: body.background
-    });
 
     // If this is a background process, start it as a process
     if (body.background) {
@@ -51,22 +44,10 @@ export class ExecuteHandler extends BaseHandler<Request, Response> {
       });
 
       if (!processResult.success) {
-        this.logger.error('Background process start failed', undefined, {
-          requestId: context.requestId,
-          command: body.command,
-          sessionId,
-          errorCode: processResult.error.code,
-          errorMessage: processResult.error.message,
-        });
         return this.createErrorResponse(processResult.error, context);
       }
 
       const processData = processResult.data;
-      this.logger.info('Background process started successfully', {
-        requestId: context.requestId,
-        processId: processData.id,
-        command: body.command,
-      });
 
       const response: ProcessStartResult = {
         success: true,
@@ -86,23 +67,10 @@ export class ExecuteHandler extends BaseHandler<Request, Response> {
     });
 
     if (!result.success) {
-      this.logger.error('Command execution failed', undefined, {
-        requestId: context.requestId,
-        command: body.command,
-        sessionId,
-        errorCode: result.error.code,
-        errorMessage: result.error.message,
-      });
       return this.createErrorResponse(result.error, context);
     }
 
     const commandResult = result.data;
-    this.logger.info('Command executed successfully', {
-      requestId: context.requestId,
-      command: body.command,
-      exitCode: commandResult.exitCode,
-      success: commandResult.success,
-    });
 
     const response: ExecResult = {
       success: commandResult.success,
@@ -122,37 +90,18 @@ export class ExecuteHandler extends BaseHandler<Request, Response> {
     // Parse request body directly
     const body = await this.parseRequestBody<ExecuteRequest>(request);
     const sessionId = body.sessionId || context.sessionId;
-    
-    this.logger.info('Starting streaming command execution', { 
-      requestId: context.requestId,
-      command: body.command,
-      sessionId
-    });
 
     // Start the process for streaming
     const processResult = await this.processService.startProcess(body.command, {
       sessionId,
     });
 
     if (!processResult.success) {
-      this.logger.error('Streaming process start failed', undefined, {
-        requestId: context.requestId,
-        command: body.command,
-        sessionId,
-        errorCode: processResult.error.code,
-        errorMessage: processResult.error.message,
-      });
       return this.createErrorResponse(processResult.error, context);
     }
 
     const process = processResult.data;
 
-    this.logger.info('Streaming process started successfully', {
-      requestId: context.requestId,
-      processId: process.id,
-      command: body.command,
-    });
-
     // Create SSE stream
     const stream = new ReadableStream({
       start(controller) {