remove logging add test

Author: partouf

CLAUDE.md

@@ -18,12 +18,15 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ### Core Services
 - **Express Router Service**: Main HTTP server handling compilation and cmake requests for Compiler Explorer
+- **HTTP Forwarder** (`src/services/http-forwarder.ts`): Direct HTTP forwarding to target URLs with proper header handling
 - **WebSocket Manager** (`src/services/websocket-manager.ts`): Robust WebSocket client with automatic reconnection, subscription management, and ping/pong keepalive
 - **AWS Clients** (`src/services/aws-clients.ts`): Pre-configured AWS SDK v3 clients for DynamoDB, S3, SQS, SSM, and STS
 
 ### Key Endpoints
 - `POST /api/compiler/:compilerid/compile` - Handles compilation requests for specific compilers
 - `POST /api/compiler/:compilerid/cmake` - Handles CMake build requests
+- `POST /:env/api/compiler/:compilerid/compile` - Environment-prefixed compilation requests (beta, staging)
+- `POST /:env/api/compiler/:compilerid/cmake` - Environment-prefixed CMake requests
 - `GET /healthcheck` - Health status including WebSocket connection state
 
 ### WebSocket Integration
@@ -51,5 +54,31 @@ The service maintains a persistent WebSocket connection to `wss://events.compile
 - 120 character line width
 - Strict TypeScript configuration with unused parameter/local detection
 
-The codebase is a TypeScript replacement for an AWS Lambda function, designed to handle Compiler Explorer routing requests with WebSocket-based real-time communication.
-- always lint and check the code when you have finished code changes
+## Routing Architecture
+
+The service supports two routing methods:
+
+### Queue-based Routing (Default)
+- Requests are sent to SQS queues for processing
+- Results are returned via WebSocket connections
+- Supports automatic failover and load balancing
+- Used for most compilation requests
+
+### URL-based Routing
+- Direct HTTP forwarding to specific target URLs
+- Configured via DynamoDB routing table
+- Used for specialized compilers (e.g., GPU compilers)
+- Handles HTTP header normalization to prevent protocol violations
+
+### Important Notes
+- HTTP responses automatically remove conflicting headers (e.g., `transfer-encoding` when setting `content-length`)
+- Large responses (>1MB) are flagged with warnings due to ALB limits
+- CORS headers are automatically added to all responses
+
+The codebase is a TypeScript replacement for an AWS Lambda function, designed to handle Compiler Explorer routing requests with both WebSocket-based real-time communication and direct HTTP forwarding.
+
+## Development Guidelines
+- Always lint and check the code when you have finished code changes
+- Use debug-level logging for detailed troubleshooting information
+- Keep info-level logging for essential operational messages
+- Prefer unit tests for pure functions over integration tests where possible

src/compiler-explorer-router.ts

@@ -1,4 +1,3 @@
-import {createHash} from 'node:crypto';
 import express from 'express';
 import type {Application, Request, Response} from 'express';
 import {logger} from './lib/logger.js';
@@ -219,7 +218,7 @@ export class CompilerExplorerRouter {
         await this.resultWaiter.unsubscribe(guid);
 
         try {
-            logger.info(`Starting URL forwarding for ${compilerid} to ${routingInfo.target}`);
+            logger.debug(`Starting URL forwarding for ${compilerid} to ${routingInfo.target}`);
             const response = await forwardToEnvironmentUrl(
                 compilerid,
                 routingInfo.target,
@@ -228,86 +227,43 @@ export class CompilerExplorerRouter {
                 headers as Record<string, string | string[]>,
             );
 
-            logger.info(
+            logger.debug(
                 `Got response from forwardToEnvironmentUrl: status=${response.statusCode}, body length=${response.body.length}`,
             );
 
-            // Ensure CORS headers are present and clean up conflicting headers
+            // Ensure CORS headers are present
             const responseHeaders: Record<string, string> = {
                 ...response.headers,
                 'Access-Control-Allow-Origin': '*',
                 'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
                 'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization',
             };
 
-            // Remove transfer-encoding if present since we're setting content-length
-            delete responseHeaders['transfer-encoding'];
-
             // Check if response was already sent
             if (res.headersSent) {
                 logger.error(`Headers already sent for ${compilerid}, cannot send response`);
                 return;
             }
 
-            logger.info(
-                `Sending response to client with status ${response.statusCode}, body length ${response.body.length}`,
-            );
-
             // Set content-length header explicitly to help proxies
             const bodyBuffer = Buffer.from(response.body);
-            const bodyHash = createHash('md5').update(bodyBuffer).digest('hex');
             responseHeaders['content-length'] = bodyBuffer.length.toString();
-            logger.info(`Response body is ${bodyBuffer.length} bytes, MD5: ${bodyHash}, setting content-length header`);
 
             // Check if response is too large for some proxies (ALB limit is 1MB)
             if (bodyBuffer.length > 1000000) {
                 logger.warn(`Response body size ${bodyBuffer.length} bytes exceeds 1MB - may cause ALB issues`);
             }
 
-            // Log response body type and sample
-            if (typeof response.body === 'string') {
-                const preview = response.body.length > 100 ? response.body.substring(0, 100) + '...' : response.body;
-                logger.info(`Response body (string): ${preview}`);
-            } else {
-                const bodyType = typeof response.body;
-                const constructorName = response.body && typeof response.body === 'object' ? (response.body as any).constructor?.name : 'unknown';
-                logger.info(`Response body type: ${bodyType}, constructor: ${constructorName}`);
-            }
-
             // Send the response
             try {
-                logger.info(`About to send response with status ${response.statusCode}`);
-                res.status(response.statusCode);
-                logger.info('Status set successfully');
-                res.set(responseHeaders);
-                logger.info('Headers set successfully');
-
-                // Handle any response errors
-                res.on('error', err => {
-                    logger.error('Error sending response:', err);
-                });
-
-                // Handle response finish event
-                res.on('finish', () => {
-                    logger.info(`Response finished for ${compilerid}`);
-                });
-
-                // Handle response close event
-                res.on('close', () => {
-                    logger.info(`Response connection closed for ${compilerid}`);
-                });
-
-                res.send(bodyBuffer);
-                logger.info(`Called res.send for ${compilerid} with status ${response.statusCode}`);
+                res.status(response.statusCode).set(responseHeaders).send(bodyBuffer);
+                logger.info(`Successfully forwarded response for ${compilerid} with status ${response.statusCode}`);
             } catch (sendError) {
                 logger.error(`Error sending response to client: ${(sendError as Error).message}`);
-                logger.error('Send error stack:', (sendError as Error).stack);
                 throw sendError; // Re-throw to be caught by outer catch
             }
         } catch (error) {
             logger.error('URL forwarding error:', error);
-            logger.error('Error stack:', (error as Error).stack);
-            logger.error('Error occurred after receiving response, might be a send issue');
 
             // Check if response was already sent
             if (res.headersSent) {
@@ -316,7 +272,6 @@ export class CompilerExplorerRouter {
             }
 
             const errorResponse = createErrorResponse(502, `Failed to forward request: ${(error as Error).message}`);
-            logger.info(`Sending error response with status ${errorResponse.statusCode}`);
             res.status(errorResponse.statusCode).set(errorResponse.headers).send(errorResponse.body);
         }
     }

src/services/http-forwarder.ts

@@ -21,14 +21,14 @@ export function prepareForwardHeaders(headers: Record<string, string | string[]>
         }
     });
 
-    // Remove hop-by-hop headers
+    // Remove hop-by-hop headers and headers that conflict with our processing
     delete forwardHeaders['connection'];
     delete forwardHeaders['upgrade'];
     delete forwardHeaders['proxy-authenticate'];
     delete forwardHeaders['proxy-authorization'];
     delete forwardHeaders['te'];
     delete forwardHeaders['trailers'];
-    delete forwardHeaders['transfer-encoding'];
+    delete forwardHeaders['transfer-encoding']; // Conflicts with content-length we set
 
     return forwardHeaders;
 }
@@ -40,19 +40,17 @@ export async function forwardToEnvironmentUrl(
     isCmake: boolean,
     headers: Record<string, string | string[]>,
 ): Promise<ForwardResponse> {
-    const startTime = Date.now();
     try {
         const fullUrl = buildForwardUrl(targetUrl);
         const endpoint = isCmake ? 'cmake' : 'compile';
 
         logger.info(`Forwarding ${endpoint} request for ${compilerId} to: ${fullUrl}`);
 
         const forwardHeaders = prepareForwardHeaders(headers);
-        logger.info('Forward headers:', forwardHeaders);
+        logger.debug('Forward headers:', forwardHeaders);
 
         // Make the HTTP request
-        logger.info(`Making POST request to ${fullUrl} with body length: ${body.length}`);
-        const requestStartTime = Date.now();
+        logger.debug(`Making POST request to ${fullUrl} with body length: ${body.length}`);
         const response = await axios({
             method: 'POST',
             url: fullUrl,
@@ -66,36 +64,19 @@ export async function forwardToEnvironmentUrl(
             transformResponse: [data => data], // Don't let axios parse the response
         });
 
-        const requestDuration = Date.now() - requestStartTime;
         const responseBody = response.data || '';
-        logger.info(
-            `Received response from ${fullUrl}: status=${response.status}, body length=${responseBody.length}, request took ${requestDuration}ms`,
+        logger.debug(
+            `Received response from ${fullUrl}: status=${response.status}, body length=${responseBody.length}`,
         );
-        logger.info('Response headers:', response.headers);
 
         const result = {
             statusCode: response.status,
             headers: response.headers as Record<string, string>,
             body: responseBody,
         };
-        const totalDuration = Date.now() - startTime;
-        logger.info(
-            `Returning response with status ${result.statusCode} and body length ${result.body.length}, total time ${totalDuration}ms`,
-        );
         return result;
     } catch (error) {
         logger.error('HTTP forwarding error:', error);
-        logger.error('Error details:', {
-            message: (error as Error).message,
-            code: axios.isAxiosError(error) ? error.code : undefined,
-            response:
-                axios.isAxiosError(error) && error.response
-                    ? {
-                          status: error.response.status,
-                          data: error.response.data,
-                      }
-                    : undefined,
-        });
 
         if (axios.isAxiosError(error)) {
             if (error.code === 'ECONNABORTED') {

test/unit/http-forwarder.test.ts

@@ -97,5 +97,19 @@ describe('HTTP Forwarder', () => {
                 cookie: 'session=abc, preference=dark',
             });
         });
+
+        it('should remove transfer-encoding header to prevent conflicts with content-length', () => {
+            const headers = {
+                'content-type': 'application/json',
+                'transfer-encoding': 'chunked',
+                'content-length': '1234',
+                'x-custom-header': 'value',
+            };
+            const result = prepareForwardHeaders(headers);
+            expect(result['transfer-encoding']).toBeUndefined();
+            expect(result['content-type']).toBe('application/json');
+            expect(result['content-length']).toBe('1234');
+            expect(result['x-custom-header']).toBe('value');
+        });
     });
 });