Update api_executor.py

api_executor.py

@@ -8,6 +8,10 @@ from typing import Any, Dict, Optional, Union
 from logger import log_info, log_error, log_warning, log_debug
 from config_provider import ConfigProvider, APIConfig
 from session import Session
+import os
+
+MAX_RESPONSE_SIZE = 10 * 1024 * 1024  # 10MB
+DEFAULT_TIMEOUT = int(os.getenv("API_TIMEOUT_SECONDS", "30"))
 
 _placeholder = re.compile(r"\{\{\s*([^\}]+?)\s*\}\}")
 
@@ -213,13 +217,17 @@ def _ensure_token(api: APIConfig, session: Session) -> None:
     _fetch_token(api, session)
 
 def call_api(api: APIConfig, session: Session) -> requests.Response:
-    """Execute API call with automatic token management"""
+    """Execute API call with automatic token management and better error handling"""
+    
     # Ensure valid token
     _ensure_token(api, session)
     
     # Prepare request
-    headers = _render(api.headers, session, api.name)  # Headers are always strings
-    body = _render_json(api.body_template, session, api.name)  # Body preserves types
+    headers = _render(api.headers, session, api.name)
+    body = _render_json(api.body_template, session, api.name)
+    
+    # Get timeout with fallback
+    timeout = api.timeout_seconds if api.timeout_seconds else DEFAULT_TIMEOUT
     
     # Handle proxy
     proxies = None
@@ -235,7 +243,8 @@ def call_api(api: APIConfig, session: Session) -> requests.Response:
         "method": api.method,
         "url": str(api.url),
         "headers": headers,
-        "timeout": api.timeout_seconds
+        "timeout": timeout,  # Use configured timeout
+        "stream": True  # Enable streaming for large responses
     }
     
     # Add body based on method
@@ -254,84 +263,164 @@ def call_api(api: APIConfig, session: Session) -> requests.Response:
     
     for attempt in range(retry_count + 1):
         try:
-            log_info(f"🌐 API call: {api.name} {api.method} {api.url} (attempt {attempt + 1}/{retry_count + 1})")
-            log_info(f"📋 Request body: {json.dumps(body, ensure_ascii=False)}")
-            
-            response = requests.request(**request_params)
-            
-            # Handle 401 Unauthorized
-            if response.status_code == 401 and api.auth and api.auth.enabled and attempt < retry_count:
-                log_info(f"🔒 Got 401, refreshing token for {api.name}")
-                _fetch_token(api, session)  # Force new token
-                headers = _render(api.headers, session, api.name)  # Re-render headers
-                request_params["headers"] = headers
-                continue
-            
-            response.raise_for_status()
-            log_info(f"✅ API call successful: {api.name} ({response.status_code})")
-            
-            # Response mapping işlemi
-            if response.status_code in (200, 201, 202, 204) and hasattr(api, 'response_mappings') and api.response_mappings:
-                try:
-                    if response.status_code != 204 and response.content:
-                        response_json = response.json()
-                        
-                        for mapping in api.response_mappings:
-                            var_name = mapping.get('variable_name')
-                            var_type = mapping.get('type', 'str')
-                            json_path = mapping.get('json_path')
-                            
-                            if not all([var_name, json_path]):
-                                continue
-                            
-                            # JSON path'ten değeri al
-                            value = response_json
-                            for path_part in json_path.split('.'):
-                                if isinstance(value, dict):
-                                    value = value.get(path_part)
-                                    if value is None:
-                                        break
+            # Use LogTimer for performance tracking
+            with LogTimer(f"API call {api.name}", attempt=attempt + 1):
+                log_info(
+                    f"🌐 API call starting",
+                    api=api.name,
+                    method=api.method,
+                    url=api.url,
+                    attempt=f"{attempt + 1}/{retry_count + 1}",
+                    timeout=timeout
+                )
+                
+                if body:
+                    log_debug(f"📋 Request body", body=json.dumps(body, ensure_ascii=False)[:500])
+                
+                # Make request with streaming
+                response = requests.request(**request_params)
+                
+                # Check response size from headers
+                content_length = response.headers.get('content-length')
+                if content_length and int(content_length) > MAX_RESPONSE_SIZE:
+                    response.close()
+                    raise ValueError(f"Response too large: {int(content_length)} bytes (max: {MAX_RESPONSE_SIZE})")
+                
+                # Handle 401 Unauthorized
+                if response.status_code == 401 and api.auth and api.auth.enabled and attempt < retry_count:
+                    log_warning(f"🔒 Got 401, refreshing token", api=api.name)
+                    _fetch_token(api, session)
+                    headers = _render(api.headers, session, api.name)
+                    request_params["headers"] = headers
+                    response.close()
+                    continue
+                
+                # Read response with size limit
+                content_size = 0
+                chunks = []
+                
+                for chunk in response.iter_content(chunk_size=8192):
+                    chunks.append(chunk)
+                    content_size += len(chunk)
+                    
+                    if content_size > MAX_RESPONSE_SIZE:
+                        response.close()
+                        raise ValueError(f"Response exceeded size limit: {content_size} bytes")
+                
+                # Reconstruct response content
+                response._content = b''.join(chunks)
+                response._content_consumed = True
+                
+                # Check status
+                response.raise_for_status()
+                
+                log_info(
+                    f"✅ API call successful",
+                    api=api.name,
+                    status_code=response.status_code,
+                    response_size=content_size,
+                    duration_ms=f"{response.elapsed.total_seconds() * 1000:.2f}"
+                )
+                
+                # Mevcut response mapping işlemi korunacak
+                if response.status_code in (200, 201, 202, 204) and hasattr(api, 'response_mappings') and api.response_mappings:
+                    try:
+                        if response.status_code != 204 and response.content:
+                            response_json = response.json()
                             
-                            if value is not None:
-                                # Type conversion
-                                if var_type == 'int':
-                                    value = int(value)
-                                elif var_type == 'float':
-                                    value = float(value)
-                                elif var_type == 'bool':
-                                    value = bool(value)
-                                elif var_type == 'date':
-                                    # ISO format'ta sakla
-                                    value = str(value)
-                                else:  # str
-                                    value = str(value)
+                            for mapping in api.response_mappings:
+                                var_name = mapping.get('variable_name')
+                                var_type = mapping.get('type', 'str')
+                                json_path = mapping.get('json_path')
                                 
-                                # Session'a kaydet
-                                session.variables[var_name] = value
-                                log_info(f"📝 Mapped response value: {var_name} = {value}")
+                                if not all([var_name, json_path]):
+                                    continue
                                 
-                except Exception as e:
-                    log_error("⚠️ Response mapping error", e)
-            
-            return response
-            
+                                # JSON path'ten değeri al
+                                value = response_json
+                                for path_part in json_path.split('.'):
+                                    if isinstance(value, dict):
+                                        value = value.get(path_part)
+                                        if value is None:
+                                            break
+                                
+                                if value is not None:
+                                    # Type conversion
+                                    if var_type == 'int':
+                                        value = int(value)
+                                    elif var_type == 'float':
+                                        value = float(value)
+                                    elif var_type == 'bool':
+                                        value = bool(value)
+                                    elif var_type == 'date':
+                                        value = str(value)
+                                    else:  # str
+                                        value = str(value)
+                                    
+                                    # Session'a kaydet
+                                    session.variables[var_name] = value
+                                    log_info(f"📝 Mapped response", variable=var_name, value=value)
+                                    
+                    except Exception as e:
+                        log_error("⚠️ Response mapping error", error=str(e))
+                
+                return response
+                
         except requests.exceptions.Timeout as e:
             last_error = e
-            log_warning(f"⏱️ API timeout for {api.name} (attempt {attempt + 1})")
+            log_warning(
+                f"⏱️ API timeout",
+                api=api.name,
+                attempt=attempt + 1,
+                timeout=timeout
+            )
             
         except requests.exceptions.RequestException as e:
             last_error = e
-            log_error(f"❌ API error for {api.name}", e)
+            log_error(
+                f"❌ API request error",
+                api=api.name,
+                error=str(e),
+                attempt=attempt + 1
+            )
+            
+        except ValueError as e:  # Size limit exceeded
+            log_error(
+                f"❌ Response size error",
+                api=api.name,
+                error=str(e)
+            )
+            raise  # Don't retry for size errors
             
+        except Exception as e:
+            last_error = e
+            log_error(
+                f"❌ Unexpected API error",
+                api=api.name,
+                error=str(e),
+                attempt=attempt + 1
+            )
+        
         # Retry backoff
         if attempt < retry_count:
             backoff = api.retry.backoff_seconds if api.retry else 2
             if api.retry and api.retry.strategy == "exponential":
                 backoff = backoff * (2 ** attempt)
-            log_info(f"⏳ Waiting {backoff}s before retry...")
+            log_info(f"⏳ Retry backoff", wait_seconds=backoff, next_attempt=attempt + 2)
             time.sleep(backoff)
     
     # All retries failed
+    error_msg = f"API call failed after {retry_count + 1} attempts"
+    log_error(error_msg, api=api.name, last_error=str(last_error))
+    
     if last_error:
         raise last_error
-    raise requests.exceptions.RequestException(f"API call failed after {retry_count + 1} attempts")
+    raise requests.exceptions.RequestException(error_msg)
+
+def format_size(size_bytes: int) -> str:
+    """Format bytes to human readable format"""
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} TB"