Hier is een voorbeeld Python-script dat automatisch foutmeldingen en uitzonderingen detecteert bij API-aanroepen naar jouw opgegeven URL. Het script logt fouten met tijdstip, foutcode en foutomschrijving en bevat uitgebreide foutafhandeling. Daarnaast geef ik uitleg en suggesties voor verbetering. ```python import requests import logging from datetime import datetime # Configureer logging logging.basicConfig( filename='api_error_log.txt', level=logging.ERROR, format='%(asctime)s - %(levelname)s - %(message)s' ) def fetch_weather_data(): url = 'https://api.weather.com/v3/wx/conditions/current' params = { # Voeg hier je API-sleutel en andere vereiste parameters toe 'apiKey': 'Jouw_API_Sleutel', # vervang door je echte API-sleutel 'geocode': '52.3676,4.9041', # voorbeeld: Amsterdam 'format': 'json' } try: response = requests.get(url, params=params, timeout=10) # Controleer of de response succesvol was response.raise_for_status() data = response.json() # Hier kun je verdere verwerking doen return data except requests.exceptions.HTTPError as http_err: log_error('HTTPError', response.status_code, str(http_err)) except requests.exceptions.ConnectionError as conn_err: log_error('ConnectionError', None, str(conn_err)) except requests.exceptions.Timeout as timeout_err: log_error('Timeout', None, str(timeout_err)) except requests.exceptions.RequestException as req_err: log_error('RequestException', None, str(req_err)) except ValueError as json_err: # JSON decoding error log_error('JSONDecodeError', None, str(json_err)) return None def log_error(error_type, status_code, message): tijdstip = datetime.now().strftime('%Y-%m-%d %H:%M:%S') if status_code: error_msg = f"{error_type} - Status code: {status_code} - Bericht: {message}" else: error_msg = f"{error_type} - Bericht: {message}" logging.error(error_msg) # Optioneel: print naar console print(f"{tijdstip} - Fout: {error_msg}") if __name__ == "__main__": data = fetch_weather_data() if data: print("API-aanroep geslaagd.") # Verwerk hier de data else: print("Er zijn fouten opgetreden bij het ophalen van data. Zie 'api_error_log.txt' voor details.") ``` **Uitleg over foutafhandeling:** - Het script gebruikt `try-except` blokken om verschillende soorten uitzonderingen op te vangen: - `HTTPError` voor niet-200 statuscodes. - `ConnectionError` voor netwerkproblemen. - `Timeout` voor het verlopen van de aanvraag. - `RequestException` voor andere onvoorziene fouten. - `ValueError` voor JSON-decoderingsfouten. - Bij een fout wordt `log_error()` aangeroepen die alle relevante informatie (tijdstip, fouttype, statuscode indien beschikbaar, foutbericht) logt in een tekstbestand. - Dit maakt het mogelijk om alle fouten te verzamelen en te analyseren. **Suggesties voor verbetering:** 1. **Herhaalpogingen (retries):** Implementeer een mechanisme om bij tijdelijke fouten meerdere pogingen te doen met tussenpozen (bijvoorbeeld met de `retrying`-bibliotheek of `urllib3.util.retry`). 2. **Alerting:** Voeg e-mail of andere notificaties toe bij kritieke fouten. 3. **Validatie:** Controleer de inhoud van de API-respons op verwachte velden en waarden. 4. **Robuustheid:** Gebruik environment variables voor API-sleutels en andere gevoelige gegevens. 5. **Monitoring:** Integreer met monitoringtools voor continue controle. Met dit script heb je een goede basis voor automatische foutdetectie en rapportage bij API-aanroepen.

Hier is een Python script met uitgebreide foutafhandeling voor uw API-aanroepen: ```python import requests import json import logging import time from datetime import datetime from typing import Dict, Any, Optional class APIErrorMonitor: def __init__(self, api_url: str): self.api_url = api_url self.setup_logging() def setup_logging(self): """Configureer logging voor gedetailleerde foutrapportage""" logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('api_error_log.txt'), logging.StreamHandler() ] ) self.logger = logging.getLogger(__name__) def make_api_request(self, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: """Maak een API-aanroep met uitgebreide foutafhandeling""" error_report = { 'timestamp': datetime.now().isoformat(), 'api_url': self.api_url, 'status': None, 'error_code': None, 'error_message': None, 'response_time': None, 'suggestions': [] } start_time = time.time() try: response = requests.get( self.api_url, params=params or {}, timeout=10, headers={'User-Agent': 'WeatherAPI-Monitor/1.0'} ) response_time = time.time() - start_time error_report['response_time'] = round(response_time, 2) # Controleer HTTP status code if response.status_code != 200: error_report['status'] = response.status_code error_report['error_code'] = f"HTTP_{response.status_code}" error_report['error_message'] = response.reason self.handle_http_error(error_report, response) return error_report # Probeer JSON response te parsen try: data = response.json() # Controleer op API-specifieke fouten in de response if 'errors' in data or 'error' in data: self.handle_api_error(error_report, data) except json.JSONDecodeError: error_report['error_code'] = "INVALID_JSON" error_report['error_message'] = "Ongeldige JSON response" error_report['suggestions'].append("Controleer API endpoint validiteit") except requests.exceptions.Timeout: error_report['error_code'] = "TIMEOUT" error_report['error_message'] = "API request timeout" error_report['suggestions'].extend([ "Verhoog timeout waarde", "Implementeer retry mechanisme" ]) except requests.exceptions.ConnectionError: error_report['error_code'] = "CONNECTION_ERROR" error_report['error_message'] = "Kan geen verbinding maken met API" error_report['suggestions'].extend([ "Controleer netwerkverbinding", "Verifieer API URL" ]) except requests.exceptions.RequestException as e: error_report['error_code'] = "REQUEST_ERROR" error_report['error_message'] = str(e) error_report['suggestions'].append("Controleer request parameters") # Log de fout indien aanwezig if error_report['error_code']: self.log_error(error_report) return error_report def handle_http_error(self, error_report: Dict[str, Any], response: requests.Response): """Behandel HTTP-specifieke fouten""" status = response.status_code if status == 401: error_report['suggestions'].extend([ "Controleer API sleutel", "Verifieer authenticatie headers" ]) elif status == 403: error_report['suggestions'].append("Controleer toegangsrechten") elif status == 404: error_report['suggestions'].append("Verifieer API endpoint URL") elif status == 429: error_report['suggestions'].extend([ "Implementeer rate limiting", "Voeg vertraging toe tussen requests" ]) elif status >= 500: error_report['suggestions'].append("Neem contact op met API aanbieder") def handle_api_error(self, error_report: Dict[str, Any], data: Dict[str, Any]): """Behandel API-specifieke fouten uit response body""" if 'errors' in data: error_report['error_code'] = data['errors'].get('code', 'UNKNOWN') error_report['error_message'] = data['errors'].get('message', 'Onbekende fout') elif 'error' in data: error_report['error_code'] = data.get('error', {}).get('code', 'UNKNOWN') error_report['error_message'] = data.get('error', {}).get('message', 'Onbekende fout') def log_error(self, error_report: Dict[str, Any]): """Log gedetailleerde foutinformatie""" log_message = ( f"Fout gedetecteerd - " f"Tijd: {error_report['timestamp']} | " f"Code: {error_report['error_code']} | " f"Bericht: {error_report['error_message']} | " f"Response tijd: {error_report['response_time']}s" ) self.logger.error(log_message) # Schrijf compleet rapport naar bestand with open('detailed_error_report.json', 'a') as f: f.write(json.dumps(error_report, indent=2) + '\n') def generate_reliability_report(self): """Genereer een betrouwbaarheidsrapport""" # Implementeer log analyse voor trends en patronen pass # Gebruiksvoorbeeld if __name__ == "__main__": api_url = "https://api.weather.com/v3/wx/conditions/current" monitor = APIErrorMonitor(api_url) # Voorbeeld parameters (vervang met uw werkelijke parameters) params = { 'apiKey': 'UW_API_SLEUTEL', 'language': 'nl-NL', 'format': 'json' } result = monitor.make_api_request(params) print("Foutrapport:", json.dumps(result, indent=2)) ``` ## Foutafhandeling Implementatie Uitleg: ### 1. **Try-Except Blokken** - **Timeout**: Vangt trage responses op - **ConnectionError**: Detecteert netwerkproblemen - **JSONDecodeError**: Identificeert ongeldige responses - **RequestException**: Algemene request fouten ### 2. **HTTP Status Code Handling** - 401/403: Authenticatie issues - 404: Endpoint niet gevonden - 429: Rate limiting - 5xx: Server-side errors ### 3. **Gedetailleerde Logging** - Tijdstempels voor elke fout - Foutcodes en beschrijvingen - Response tijden metingen ## Betrouwbaarheidsverbeteringen: ### 1. **Retry Mechanisme** (Toevoegen) ```python from tenacity import retry, stop_after_attempt, wait_exponential @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10)) def make_api_request(self, params): # bestaande code ``` ### 2. **Circuit Breaker Pattern** ```python import pybreaker cb = pybreaker.CircuitBreaker(fail_max=5, reset_timeout=60) @cb def make_api_request(self, params): # bestaande code ``` ### 3. **Monitoring en Alerting** - Integreer met monitoring tools (Prometheus, Datadog) - Stel alerts in voor kritieke fouten - Monitor response tijd trends ### 4. **Caching Implementatie** ```python from cachetools import TTLCache cache = TTLCache(maxsize=100, ttl=300) # 5 minuten cache def get_cached_data(self, params): cache_key = str(params) if cache_key in cache: return cache[cache_key] # else: maak API call ``` ### 5. **Health Checks** ```python def health_check(self): """Voer periodieke health checks uit""" result = self.make_api_request() return result['error_code'] is None ``` Dit script biedt een robuuste basis voor API monitoring met uitgebreide foutdetectie en suggesties voor betrouwbaarheidsverbeteringen.