feat: server side request timing

app/api/v1/endpoints.py

@@ -160,6 +160,7 @@ async def translate_endpoint(
     Returns translated text with source language, inference time, and request tracking.
     """
     request_id = request.state.request_id
+    request_start_time = time.time()
 
     # Validate text length
     if len(translation_request.text) > settings.max_text_length:
@@ -214,6 +215,9 @@ async def translate_endpoint(
             inference_time=inference_time
         )
 
+        # Calculate total request time
+        total_request_time = time.time() - request_start_time
+
         return TranslationResponse(
             translated_text=translated_text,
             source_language=source_lang,
@@ -221,7 +225,8 @@ async def translate_endpoint(
             inference_time=inference_time,
             character_count=character_count,
             timestamp=full_date,
-            request_id=request_id
+            request_id=request_id,
+            total_time=total_request_time
         )
 
     except Exception as e:
@@ -272,6 +277,7 @@ async def detect_language_endpoint(
     Response includes FLORES-200 language code, native name, and confidence score.
     """
     request_id = request.state.request_id
+    request_start_time = time.time()
 
     # Validate text length
     if len(detection_request.text) > 1000:
@@ -318,6 +324,9 @@ async def detect_language_endpoint(
             character_count=character_count
         )
 
+        # Calculate total request time
+        total_request_time = time.time() - request_start_time
+
         return LanguageDetectionResponse(
             detected_language=detected_lang_code,
             language_name=language_name,
@@ -326,7 +335,8 @@ async def detect_language_endpoint(
             is_english=is_english,
             character_count=character_count,
             timestamp=full_date,
-            request_id=request_id
+            request_id=request_id,
+            total_time=total_request_time
         )
 
     except Exception as e:

app/middleware/request_middleware.py

@@ -15,10 +15,10 @@ async def request_middleware(request: Request, call_next):
     """Middleware for request tracking, metrics, and logging"""
     start_time = time.time()
     request_id = generate_request_id()
-    
+
     # Add request ID to request state
     request.state.request_id = request_id
-    
+
     # Log request
     logger.info(
         "request_started",
@@ -28,25 +28,25 @@ async def request_middleware(request: Request, call_next):
         client_ip=request.client.host if request.client else "unknown",
         user_agent=request.headers.get("user-agent", "unknown")
     )
-    
+
     try:
         response = await call_next(request)
-        
+
         # Calculate duration
         duration = time.time() - start_time
-        
+
         # Update metrics
         REQUEST_COUNT.labels(
             method=request.method,
             endpoint=request.url.path,
             status=response.status_code
         ).inc()
-        
+
         REQUEST_DURATION.labels(
             method=request.method,
             endpoint=request.url.path
         ).observe(duration)
-        
+
         # Log response
         logger.info(
             "request_completed",
@@ -54,18 +54,20 @@ async def request_middleware(request: Request, call_next):
             status_code=response.status_code,
             duration=duration
         )
-        
-        # Add request ID to response headers
+
+        # Add request ID and timing to response headers
         response.headers["X-Request-ID"] = request_id
-        
+        response.headers["X-Response-Time"] = f"{duration:.3f}s"
+        response.headers["X-Response-Time-Ms"] = f"{duration * 1000:.1f}"
+
         return response
-        
+
     except Exception as e:
         duration = time.time() - start_time
-        
+
         # Update error metrics
         ERROR_COUNT.labels(error_type=type(e).__name__).inc()
-        
+
         # Log error
         logger.error(
             "request_failed",
@@ -74,5 +76,5 @@ async def request_middleware(request: Request, call_next):
             error_type=type(e).__name__,
             duration=duration
         )
-        
+
         raise

app/models/schemas.py

@@ -126,6 +126,13 @@ class TranslationResponse(BaseModel):
         example="550e8400-e29b-41d4-a716-446655440000",
         title="Request ID"
     )
+    total_time: float = Field(
+        ...,
+        description="Total request processing time in seconds",
+        example=1.234,
+        ge=0,
+        title="Total Processing Time (seconds)"
+    )
 
     class Config:
         json_schema_extra = {
@@ -136,7 +143,8 @@ class TranslationResponse(BaseModel):
                 "inference_time": 0.234,
                 "character_count": 17,
                 "timestamp": "Monday | 2024-06-21 | 14:30:25",
-                "request_id": "550e8400-e29b-41d4-a716-446655440000"
+                "request_id": "550e8400-e29b-41d4-a716-446655440000",
+                "total_time": 1.234
             }
         }
 
@@ -253,6 +261,13 @@ class LanguageDetectionResponse(BaseModel):
         example="550e8400-e29b-41d4-a716-446655440000",
         title="Request ID"
     )
+    total_time: float = Field(
+        ...,
+        description="Total request processing time in seconds",
+        example=0.045,
+        ge=0,
+        title="Total Processing Time (seconds)"
+    )
 
     class Config:
         json_schema_extra = {
@@ -264,7 +279,8 @@ class LanguageDetectionResponse(BaseModel):
                 "is_english": False,
                 "character_count": 17,
                 "timestamp": "Monday | 2024-06-21 | 14:30:25",
-                "request_id": "550e8400-e29b-41d4-a716-446655440000"
+                "request_id": "550e8400-e29b-41d4-a716-446655440000",
+                "total_time": 0.045
             }
         }
 

tests/curl_commands.md

@@ -227,11 +227,26 @@ curl -s "$API_URL/languages/popular" | jq '.'
 curl -s "$API_URL/languages" > all_languages.json
 ```
 
-### Check Response Headers
+### Check Response Headers (Including Timing)
 ```bash
 curl -I "$API_URL/health"
 ```
 
+### View Response Headers with Translation
+```bash
+curl -v -X POST "$API_URL/translate" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Hello", "target_language": "swh_Latn"}'
+```
+
+### Extract Timing Headers Only
+```bash
+curl -s -D - -X POST "$API_URL/translate" \
+  -H "Content-Type: application/json" \
+  -d '{"text": "Hello", "target_language": "swh_Latn"}' \
+  | grep -E "X-Response-Time|X-Request-ID"
+```
+
 ### Measure Response Time
 ```bash
 curl -w "@curl-format.txt" -s -o /dev/null "$API_URL/translate" \

tests/simple_test.py

@@ -1,9 +1,10 @@
 """
-Simple API test script using requests
+Simple API test script using requests with performance tracking
 """
 
 import requests
 import json
+import time
 
 # API base URL - change this to test different environments
 API_URL = "https://sematech-sema-api.hf.space"
@@ -13,8 +14,12 @@ def test_health():
     """Test basic health check"""
     print("[TEST] Health check...")
 
+    start_time = time.time()
     response = requests.get(f"{API_URL}/status")
+    response_time = time.time() - start_time
+
     print(f"Status: {response.status_code}")
+    print(f"Response time: {response_time:.3f}s")
 
     if response.status_code == 200:
         data = response.json()
@@ -36,13 +41,16 @@ def test_translation():
         "target_language": "eng_Latn"
     }
 
+    start_time = time.time()
     response = requests.post(
         f"{API_URL}/translate",
         headers={"Content-Type": "application/json"},
         json=data
     )
+    response_time = time.time() - start_time
 
     print(f"Status: {response.status_code}")
+    print(f"Response time: {response_time:.3f}s")
 
     if response.status_code == 200:
         result = response.json()
@@ -50,7 +58,9 @@ def test_translation():
         print(f"Original: {data['text']}")
         print(f"Translation: {result['translated_text']}")
         print(f"Source language: {result['source_language']}")
-        print(f"Inference time: {result['inference_time']:.3f}s")
+        print(f"Model inference time: {result['inference_time']:.3f}s")
+        print(f"Total request time: {response_time:.3f}s")
+        print(f"Network overhead: {(response_time - result['inference_time']):.3f}s")
     else:
         print(f"[FAIL] Translation failed")
         print(f"Status code: {response.status_code}")
@@ -67,28 +77,34 @@ def test_languages():
     print("[TEST] Language endpoints...")
 
     # Test all languages
+    start_time = time.time()
     response = requests.get(f"{API_URL}/languages")
+    response_time = time.time() - start_time
     if response.status_code == 200:
         data = response.json()
-        print(f"[PASS] Found {data['total_count']} supported languages")
+        print(f"[PASS] Found {data['total_count']} supported languages ({response_time:.3f}s)")
     else:
-        print(f"[FAIL] Failed to get languages")
+        print(f"[FAIL] Failed to get languages ({response_time:.3f}s)")
 
     # Test popular languages
+    start_time = time.time()
     response = requests.get(f"{API_URL}/languages/popular")
+    response_time = time.time() - start_time
     if response.status_code == 200:
         data = response.json()
-        print(f"[PASS] Found {data['total_count']} popular languages")
+        print(f"[PASS] Found {data['total_count']} popular languages ({response_time:.3f}s)")
     else:
-        print(f"[FAIL] Failed to get popular languages")
+        print(f"[FAIL] Failed to get popular languages ({response_time:.3f}s)")
 
     # Test specific language
+    start_time = time.time()
     response = requests.get(f"{API_URL}/languages/swh_Latn")
+    response_time = time.time() - start_time
     if response.status_code == 200:
         data = response.json()
-        print(f"[PASS] Swahili info: {data['name']} ({data['native_name']})")
+        print(f"[PASS] Swahili info: {data['name']} ({data['native_name']}) ({response_time:.3f}s)")
     else:
-        print(f"[FAIL] Failed to get Swahili info")
+        print(f"[FAIL] Failed to get Swahili info ({response_time:.3f}s)")
 
     print("-" * 50)
 

tests/test_performance_timing.py

@@ -0,0 +1,273 @@
+"""
+Performance timing test script - demonstrates server-side timing implementation
+"""
+
+import requests
+import json
+import time
+import statistics
+
+def test_server_side_timing(api_url="https://sematech-sema-api.hf.space"):
+    """Test server-side timing implementation"""
+    
+    print("[INFO] Testing Server-Side Performance Timing")
+    print("=" * 60)
+    
+    # Test translation endpoint timing
+    print("\n[TEST] Translation Endpoint Timing")
+    print("-" * 40)
+    
+    test_cases = [
+        {"text": "Hello", "target_language": "swh_Latn"},
+        {"text": "Habari ya asubuhi", "target_language": "eng_Latn"},
+        {"text": "Good morning everyone", "target_language": "fra_Latn"},
+        {"text": "Bonjour tout le monde", "target_language": "eng_Latn"},
+        {"text": "How are you doing today?", "target_language": "swh_Latn"}
+    ]
+    
+    translation_times = []
+    
+    for i, test_case in enumerate(test_cases, 1):
+        print(f"\n{i}. Testing: '{test_case['text']}'")
+        
+        # Measure client-side time
+        client_start = time.time()
+        
+        response = requests.post(
+            f"{api_url}/translate",
+            headers={"Content-Type": "application/json"},
+            json=test_case,
+            timeout=30
+        )
+        
+        client_total = time.time() - client_start
+        
+        if response.status_code == 200:
+            data = response.json()
+            
+            # Extract timing information
+            server_total = data.get('total_time', 0)
+            inference_time = data.get('inference_time', 0)
+            network_overhead = client_total - server_total
+            processing_overhead = server_total - inference_time
+            
+            # Extract response headers
+            response_time_header = response.headers.get('X-Response-Time', 'N/A')
+            response_time_ms = response.headers.get('X-Response-Time-Ms', 'N/A')
+            request_id = response.headers.get('X-Request-ID', 'N/A')
+            
+            print(f"   Translation: '{data['translated_text']}'")
+            print(f"   [TIMING] Client total: {client_total:.3f}s")
+            print(f"   [TIMING] Server total: {server_total:.3f}s")
+            print(f"   [TIMING] Model inference: {inference_time:.3f}s")
+            print(f"   [TIMING] Processing overhead: {processing_overhead:.3f}s")
+            print(f"   [TIMING] Network overhead: {network_overhead:.3f}s")
+            print(f"   [HEADERS] X-Response-Time: {response_time_header}")
+            print(f"   [HEADERS] X-Response-Time-Ms: {response_time_ms}")
+            print(f"   [HEADERS] X-Request-ID: {request_id}")
+            
+            translation_times.append({
+                'client_total': client_total,
+                'server_total': server_total,
+                'inference_time': inference_time,
+                'processing_overhead': processing_overhead,
+                'network_overhead': network_overhead
+            })
+            
+        else:
+            print(f"   [FAIL] HTTP {response.status_code}")
+    
+    # Test language detection timing
+    print(f"\n[TEST] Language Detection Timing")
+    print("-" * 40)
+    
+    detection_cases = [
+        "Hello world",
+        "Habari ya dunia", 
+        "Bonjour le monde",
+        "Hola mundo",
+        "Good morning everyone, how are you doing today?"
+    ]
+    
+    detection_times = []
+    
+    for i, text in enumerate(detection_cases, 1):
+        print(f"\n{i}. Detecting: '{text}'")
+        
+        client_start = time.time()
+        
+        response = requests.post(
+            f"{api_url}/detect-language",
+            headers={"Content-Type": "application/json"},
+            json={"text": text},
+            timeout=10
+        )
+        
+        client_total = time.time() - client_start
+        
+        if response.status_code == 200:
+            data = response.json()
+            
+            server_total = data.get('total_time', 0)
+            network_overhead = client_total - server_total
+            
+            response_time_header = response.headers.get('X-Response-Time', 'N/A')
+            
+            print(f"   Detected: {data['detected_language']} ({data['language_name']})")
+            print(f"   Confidence: {data['confidence']:.3f}")
+            print(f"   [TIMING] Client total: {client_total:.3f}s")
+            print(f"   [TIMING] Server total: {server_total:.3f}s")
+            print(f"   [TIMING] Network overhead: {network_overhead:.3f}s")
+            print(f"   [HEADERS] X-Response-Time: {response_time_header}")
+            
+            detection_times.append({
+                'client_total': client_total,
+                'server_total': server_total,
+                'network_overhead': network_overhead
+            })
+            
+        else:
+            print(f"   [FAIL] HTTP {response.status_code}")
+    
+    # Performance summary
+    print(f"\n[SUMMARY] Performance Analysis")
+    print("=" * 60)
+    
+    if translation_times:
+        print(f"\nTranslation Performance:")
+        avg_client = statistics.mean([t['client_total'] for t in translation_times])
+        avg_server = statistics.mean([t['server_total'] for t in translation_times])
+        avg_inference = statistics.mean([t['inference_time'] for t in translation_times])
+        avg_processing = statistics.mean([t['processing_overhead'] for t in translation_times])
+        avg_network = statistics.mean([t['network_overhead'] for t in translation_times])
+        
+        print(f"   Average client total: {avg_client:.3f}s")
+        print(f"   Average server total: {avg_server:.3f}s")
+        print(f"   Average inference: {avg_inference:.3f}s")
+        print(f"   Average processing overhead: {avg_processing:.3f}s")
+        print(f"   Average network overhead: {avg_network:.3f}s")
+        print(f"   Efficiency: {(avg_inference/avg_server)*100:.1f}% (inference/server)")
+    
+    if detection_times:
+        print(f"\nLanguage Detection Performance:")
+        avg_client = statistics.mean([t['client_total'] for t in detection_times])
+        avg_server = statistics.mean([t['server_total'] for t in detection_times])
+        avg_network = statistics.mean([t['network_overhead'] for t in detection_times])
+        
+        print(f"   Average client total: {avg_client:.3f}s")
+        print(f"   Average server total: {avg_server:.3f}s")
+        print(f"   Average network overhead: {avg_network:.3f}s")
+    
+    print(f"\n[INFO] Server-side timing provides:")
+    print(f"   - Accurate server processing time")
+    print(f"   - Network overhead calculation")
+    print(f"   - Performance bottleneck identification")
+    print(f"   - Response headers for monitoring")
+    print(f"   - Request tracking with unique IDs")
+
+def test_concurrent_performance(api_url="https://sematech-sema-api.hf.space", num_requests=5):
+    """Test concurrent request performance"""
+    
+    print(f"\n[TEST] Concurrent Performance ({num_requests} requests)")
+    print("-" * 50)
+    
+    import threading
+    import queue
+    
+    results = queue.Queue()
+    
+    def make_request(request_id):
+        start_time = time.time()
+        try:
+            response = requests.post(
+                f"{api_url}/translate",
+                headers={"Content-Type": "application/json"},
+                json={"text": f"Hello world {request_id}", "target_language": "swh_Latn"},
+                timeout=30
+            )
+            
+            client_time = time.time() - start_time
+            
+            if response.status_code == 200:
+                data = response.json()
+                server_time = data.get('total_time', 0)
+                inference_time = data.get('inference_time', 0)
+                
+                results.put({
+                    'request_id': request_id,
+                    'success': True,
+                    'client_time': client_time,
+                    'server_time': server_time,
+                    'inference_time': inference_time,
+                    'translation': data['translated_text']
+                })
+            else:
+                results.put({
+                    'request_id': request_id,
+                    'success': False,
+                    'error': response.status_code
+                })
+                
+        except Exception as e:
+            results.put({
+                'request_id': request_id,
+                'success': False,
+                'error': str(e)
+            })
+    
+    # Start concurrent requests
+    threads = []
+    start_time = time.time()
+    
+    for i in range(num_requests):
+        thread = threading.Thread(target=make_request, args=(i+1,))
+        threads.append(thread)
+        thread.start()
+    
+    # Wait for all requests to complete
+    for thread in threads:
+        thread.join()
+    
+    total_time = time.time() - start_time
+    
+    # Collect results
+    successful_requests = []
+    failed_requests = []
+    
+    while not results.empty():
+        result = results.get()
+        if result['success']:
+            successful_requests.append(result)
+        else:
+            failed_requests.append(result)
+    
+    print(f"   Total time for {num_requests} concurrent requests: {total_time:.3f}s")
+    print(f"   Successful requests: {len(successful_requests)}")
+    print(f"   Failed requests: {len(failed_requests)}")
+    
+    if successful_requests:
+        avg_client = statistics.mean([r['client_time'] for r in successful_requests])
+        avg_server = statistics.mean([r['server_time'] for r in successful_requests])
+        avg_inference = statistics.mean([r['inference_time'] for r in successful_requests])
+        
+        print(f"   Average client time: {avg_client:.3f}s")
+        print(f"   Average server time: {avg_server:.3f}s")
+        print(f"   Average inference time: {avg_inference:.3f}s")
+        print(f"   Requests per second: {len(successful_requests)/total_time:.2f}")
+
+if __name__ == "__main__":
+    import sys
+    
+    api_url = "https://sematech-sema-api.hf.space"
+    if len(sys.argv) > 1:
+        api_url = sys.argv[1]
+    
+    print(f"[INFO] Testing performance timing at: {api_url}")
+    
+    # Test server-side timing
+    test_server_side_timing(api_url)
+    
+    # Test concurrent performance
+    test_concurrent_performance(api_url)
+    
+    print(f"\n[SUCCESS] Performance timing tests completed!")