Natuurlijk! Hier zijn richtlijnen en een voorbeeld voor het maken van een middleware in Flask die verzoeken logt, met aandacht voor structuur, verschillende verzoektypen en gebruiksscenario's. ### 1. Structuur van de Middleware In Flask kun je middleware implementeren door gebruik te maken van `before_request`, `after_request` en/of het maken van een WSGI Middleware. Voor eenvoudige logging en andere taken is het meestal voldoende om `before_request` en `after_request` te gebruiken. **Basisopzet:** ```python from flask import Flask, request app = Flask(__name__) # Middleware: verzoek loggen vóór verwerking @app.before_request def log_request(): print(f"Ontvangen {request.method} verzoek naar {request.path}") # Voeg eventueel meer logging toe, zoals headers of request data # Middleware: respons aanpassen of loggen na verwerking @app.after_request def after_response(response): print(f"Verzoek naar {request.path} voltooid met status {response.status}") # Hier kun je de response aanpassen indien nodig return response ``` ### 2. Verschillende verzoektypen afhandelen Je kunt logica bepalen op basis van `request.method`, bijvoorbeeld: ```python @app.before_request def handle_requests(): if request.method == 'GET': # Log of verwerk GET-verzoeken print(f"GET verzoek naar {request.path}") elif request.method == 'POST': # Log of verwerk POST-verzoeken print(f"POST verzoek met data: {request.get_data()}") # Voeg meer logica toe voor andere methoden ``` ### 3. Voorbeeld: Authenticatie Logica Voor authenticatie kun je bijvoorbeeld controleren op een token in headers: ```python @app.before_request def authenticate(): token = request.headers.get('Authorization') if not token or token != 'jouw_token': return {"error": "Niet geautoriseerd"}, 401 ``` ### 4. Complete Voorbeeld Hier is een compleet voorbeeld dat verzoeken logt, authenticatie controleert en verschillende methoden afhandelt: ```python from flask import Flask, request, jsonify app = Flask(__name__) @app.before_request def log_request(): print(f"Ontvangen {request.method} verzoek naar {request.path}") @app.before_request def authenticate(): token = request.headers.get('Authorization') if not token or token != 'jouw_token': return jsonify({"error": "Niet geautoriseerd"}), 401 @app.route('/voorbeeld', methods=['GET', 'POST']) def voorbeeld(): if request.method == 'GET': return jsonify({"message": "Dit is een GET-verzoek"}) elif request.method == 'POST': data = request.get_json() return jsonify({"message": "Post data ontvangen", "data": data}) @app.after_request def after_response(response): print(f"Verzoek naar {request.path} voltooid met status {response.status}") return response if __name__ == '__main__': app.run(debug=True) ``` ### 5. Samenvatting - Gebruik `@app.before_request` voor taken vóór de verwerking (bv. logging, authenticatie). - Gebruik `@app.after_request` voor taken na verwerking (bv. respons aanpassen, logging). - Controleer `request.method` om verschillende verzoektypes te onderscheiden. - Voeg op maat gemaakte logica toe voor authenticatie en andere taken. Mocht je meer specifieke voorbeelden of hulp nodig hebben bij complexere middleware, laat het gerust weten!

Hier is een gestructureerde handleiding voor het maken van aangepaste middleware in Flask, specifiek gericht op request logging: ## Basisstructuur Flask Middleware ### 1. Middleware Klasse Structuur ```python import time import logging from flask import Flask, request, g class RequestLoggingMiddleware: def __init__(self, app): self.app = app self.logger = logging.getLogger('request_logger') self.setup_logging() def setup_logging(self): """Configureer logging instellingen""" handler = logging.FileHandler('requests.log') formatter = logging.Formatter( '%(asctime)s - %(levelname)s - %(message)s' ) handler.setFormatter(formatter) self.logger.addHandler(handler) self.logger.setLevel(logging.INFO) def __call__(self, environ, start_response): """WSGI middleware methode""" # Pre-request verwerking self.before_request() # Verwerk request door de Flask app return self.app(environ, start_response) def before_request(self): """Wordt uitgevoerd voor elk request""" g.start_time = time.time() # Log request details self.log_request() def log_request(self): """Log request informatie""" request_data = { 'method': request.method, 'path': request.path, 'remote_addr': request.remote_addr, 'user_agent': str(request.user_agent), 'timestamp': time.strftime('%Y-%m-%d %H:%M:%S') } self.logger.info(f"Request ontvangen: {request_data}") ``` ### 2. Alternatieve Aanpak: Decorator-based Middleware ```python from functools import wraps from flask import request, g import time def log_requests(f): @wraps(f) def decorated_function(*args, **kwargs): # Pre-request logging start_time = time.time() print(f"Request: {request.method} {request.path}") print(f"Headers: {dict(request.headers)}") # Voer de originele functie uit response = f(*args, **kwargs) # Post-request logging duration = time.time() - start_time print(f"Response tijd: {duration:.2f}s") print(f"Status: {response.status_code}") return response return decorated_function ``` ### 3. Gebruik in Flask Applicatie ```python from flask import Flask, jsonify app = Flask(__name__) # Middleware initialiseren middleware = RequestLoggingMiddleware(app) @app.route('/') @log_requests # Decorator middleware def home(): return jsonify({"message": "Welkom bij de applicatie"}) @app.route('/api/data') def get_data(): return jsonify({"data": [1, 2, 3, 4, 5]}) @app.route('/api/users', methods=['POST']) def create_user(): return jsonify({"status": "gebruiker aangemaakt"}), 201 if __name__ == '__main__': app.run(debug=True) ``` ### 4. Uitgebreide Logging Middleware ```python import json from datetime import datetime class AdvancedRequestLogger: def __init__(self, app): self.app = app self.app.before_request(self.before_request) self.app.after_request(self.after_request) def before_request(self): """Pre-request verwerking""" g.start_time = time.time() g.request_id = datetime.now().strftime('%Y%m%d%H%M%S%f') self.log_request_start() def after_request(self, response): """Post-request verwerking""" duration = time.time() - g.start_time log_data = { 'request_id': g.request_id, 'method': request.method, 'endpoint': request.endpoint, 'path': request.path, 'status_code': response.status_code, 'duration': f"{duration:.3f}s", 'timestamp': datetime.now().isoformat(), 'ip_address': request.remote_addr } print(f"REQUEST LOG: {json.dumps(log_data, indent=2)}") return response def log_request_start(self): start_log = { 'request_id': g.request_id, 'method': request.method, 'path': request.path, 'start_time': datetime.now().isoformat() } print(f"REQUEST START: {json.dumps(start_log)}") ``` ### 5. Gebruiksscenario's #### Scenario 1: API Request Monitoring ```python @app.route('/api/orders', methods=['POST']) @log_requests def create_order(): # Business logica voor order creatie order_data = request.get_json() print(f"Order data ontvangen: {order_data}") return jsonify({"order_id": 12345}), 201 ``` #### Scenario 2: Foutafhandeling met Logging ```python @app.errorhandler(404) def not_found(error): print(f"404 Error: {request.path} - IP: {request.remote_addr}") return jsonify({"error": "Niet gevonden"}), 404 @app.errorhandler(500) def internal_error(error): print(f"500 Error: {request.path} - Fout: {str(error)}") return jsonify({"error": "Interne server fout"}), 500 ``` #### Scenario 3: Gefilterde Logging ```python def should_log_request(): """Bepaal of request gelogd moet worden""" exclude_paths = ['/health', '/static/'] return not any(request.path.startswith(path) for path in exclude_paths) @app.before_request def conditional_logging(): if should_log_request(): print(f"Gelogd: {request.method} {request.path}") ``` ### 6. Best Practices 1. **Log Niveaus**: Gebruik verschillende log levels (INFO, WARNING, ERROR) 2. **Gevoelige Data**: Filter gevoelige informatie zoals wachtwoorden 3. **Performance**: Voorkom zware operaties in middleware 4. **Foutafhandeling**: Zorg voor robuuste error handling 5. **Configuratie**: Maak logging niveau configureerbaar ### 7. Configuratie Voorbeeld ```python import logging def setup_logging(): logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('app_requests.log'), logging.StreamHandler() ] ) ``` Deze structuur biedt een solide basis voor request logging middleware in Flask, met mogelijkheden voor uitbreiding naar andere functionaliteiten zoals authenticatie en response manipulatie.