Added basic logging logic

Author: Veinar

.gitignore

@@ -1,3 +1,4 @@
+[V|venv]
 [I|i]nclude
 [L|l]ib
 [S|s]cripts

dracan/core/app_factory.py

@@ -11,6 +11,9 @@ def create_app():
     """
     app = Flask(__name__)
 
+    # Set up logging
+    setup_logging(app)
+
     # Load configurations
     proxy_config = load_proxy_config()
     rules_config = load_rules_config()
@@ -20,9 +23,9 @@ def create_app():
     json_validation_enabled = os.getenv("JSON_VALIDATION_ENABLED", "true").lower() == "true"
     rate_limiting_enabled = os.getenv("RATE_LIMITING_ENABLED", "true").lower() == "true"
 
-    # Create validators if flags are set
-    validate_method = create_method_validator(rules_config) if method_validation_enabled else lambda: (True, None)
-    validate_json = create_json_validator(rules_config) if json_validation_enabled else lambda: (True, None)
+    # Create validators and pass the app logger
+    validate_method = create_method_validator(rules_config, app.logger) if method_validation_enabled else lambda: (True, None)
+    validate_json = create_json_validator(rules_config, app.logger) if json_validation_enabled else lambda: (True, None)
 
     # Apply rate limiter if enabled
     if rate_limiting_enabled:
@@ -31,10 +34,34 @@ def create_app():
     # Route handling
     @app.route('/', methods=['GET', 'POST', 'PUT', 'DELETE'])
     def proxy_route_without_sub():
+        app.logger.info(f"Proxying request without sub-path")
         return handle_proxy(proxy_config, rules_config, validate_method, validate_json)
 
     @app.route('/<path:sub>', methods=['GET', 'POST', 'PUT', 'DELETE'])
     def proxy_route(sub):
+        app.logger.info(f"Proxying request to sub-path: {sub}")
         return handle_proxy(proxy_config, rules_config, validate_method, validate_json, sub=sub)
 
     return app
+
+def setup_logging(app):
+    """
+    Set up logging for the Flask app.
+    """
+    # Set the log level (can be adjusted as needed)
+    log_level = os.getenv("LOG_LEVEL", "INFO").upper()
+
+    # Configure logging for the application
+    import logging
+    logging.basicConfig(
+        level=log_level,  # Set the logging level
+        format="%(asctime)s [%(levelname)s] %(message)s",  # Log format
+        handlers=[
+            logging.StreamHandler(),  # Log to console
+            #logging.FileHandler("app.log", mode='a')  # Optionally log to a file
+        ]
+    )
+
+    # Override Flask's default logger with the configured one
+    app.logger.setLevel(log_level)
+    app.logger.info("Logger setup complete.")

dracan/core/proxy.py

@@ -1,4 +1,4 @@
-from flask import request, jsonify
+from flask import request, jsonify, current_app as app
 import requests
 import json
 
@@ -26,21 +26,32 @@ def forward_request(request, sub, config):
     :param sub: The additional path after the base URL.
     :return: Response from the destination service.
     """
+    # Build the destination URL based on the proxy configuration and subpath
     if sub is None:
         destination_url = f"http://{config['destination']['host']}:{config['destination']['port']}{config['destination']['path']}"
     else:
-        destination_url = f"http://{config['destination']['host']}:{config['destination']['port']}{config['destination']['path']}/{sub}"
-    
-    if request.method == 'GET':
-        response = requests.get(destination_url, headers=request.headers, params=request.args)
-    elif request.method == 'POST':
-        response = requests.post(destination_url, headers=request.headers, json=request.get_json())
-    elif request.method == 'PUT':
-        response = requests.put(destination_url, headers=request.headers, json=request.get_json())
-    elif request.method == 'DELETE':
-        response = requests.delete(destination_url, headers=request.headers)
-    
-    return response
+        destination_url = f"http://{config['destination']['host']}:{config['destination']['port']}{config['destination']['path']}{sub}"
+
+    app.logger.info(f"Forwarding {request.method} request to {destination_url}")  # Log request forwarding
+
+    # Forward the request based on its method
+    try:
+        if request.method == 'GET':
+            response = requests.get(destination_url, headers=request.headers, params=request.args)
+        elif request.method == 'POST':
+            response = requests.post(destination_url, headers=request.headers, json=request.get_json())
+        elif request.method == 'PUT':
+            response = requests.put(destination_url, headers=request.headers, json=request.get_json())
+        elif request.method == 'DELETE':
+            response = requests.delete(destination_url, headers=request.headers)
+        
+        app.logger.info(f"Received {response.status_code} from {destination_url}")  # Log response status
+        return response
+
+    except requests.exceptions.RequestException as e:
+        # Log any exception that occurs during forwarding
+        app.logger.error(f"Error forwarding request to {destination_url}: {str(e)}")
+        raise
 
 def handle_proxy(config, rules_config, validate_method, validate_json, sub=None):
     """
@@ -56,18 +67,21 @@ def handle_proxy(config, rules_config, validate_method, validate_json, sub=None)
     # First, validate the method
     is_valid, validation_response = validate_method()
     if not is_valid:
-        return validation_response  # Return the error response if the method is not allowed
+        app.logger.warning("Method validation failed")  # Log method validation failure
+        return validation_response
 
     # Then, validate the request's JSON (if applicable)
     is_valid, validation_response = validate_json()
     if not is_valid:
-        return validation_response  # Return the error response if the JSON is invalid
+        app.logger.warning("JSON validation failed")  # Log JSON validation failure
+        return validation_response
 
     # If both validations pass, forward the request
     try:
         response = forward_request(request, sub, config)
         return (response.content, response.status_code, response.headers.items())
 
     except Exception as e:
-        # Handle any exception during the forwarding process
-        return jsonify({'error': str(e)}), 500
+        # Handle any exception during the forwarding process and log it
+        app.logger.error(f"Error during request forwarding: {str(e)}")
+        return jsonify({'error': str(e)}), 500

dracan/validators/json_validator.py

@@ -1,30 +1,34 @@
 from flask import request, jsonify
 from jsonschema import validate, ValidationError
 
-def validate_json(data, schema):
+def validate_json(data, schema, logger):
     """
     Validate the given JSON data against the provided schema, including required fields.
     
     :param data: The JSON data to validate.
-    :param schema: The schema to validate against, which includes 'required' fields.
+    :param schema: The schema to validate against, which includes required fields.
+    :param logger: The logger to use for logging.
     :return: Tuple (is_valid, error_message).
     """
     try:
         # Validate the data against the schema, which includes required fields
         validate(instance=data, schema=schema)
+        logger.info("JSON validation passed.")  # Log successful validation
         return True, None
     except ValidationError as e:
         # Return False and a clear error message if validation fails
+        logger.error(f"JSON validation failed: {str(e)}")  # Log validation error
         return False, str(e)
 
-def create_json_validator(rules_config):
+def create_json_validator(rules_config, logger):
     """
     Creates a function that validates the request JSON based on the provided rules_config.
     
     :param rules_config: The configuration that contains JSON validation rules, including the JSON schema.
+    :param logger: The logger to use for logging.
     :return: A validation function or None if JSON validation is disabled.
     """
-    json_validation_enabled = rules_config.get("json_validation_enabled", False) 
+    json_validation_enabled = rules_config.get("json_validation_enabled", False)
     json_schema = rules_config.get("json_schema", {})
     detailed_errors_enabled = rules_config.get("detailed_errors_enabled", False)  # Default to False
 
@@ -35,17 +39,16 @@ def validate_json_request():
         """
         if json_validation_enabled and request.method in ['POST', 'PUT']:
             data = request.get_json()
-            is_valid, error_message = validate_json(data, json_schema)
+            is_valid, error_message = validate_json(data, json_schema, logger)
             if not is_valid:
-                # Determine whether to include detailed error information
                 error_message_to_display = error_message if detailed_errors_enabled else "Invalid JSON format"
-                # Return False and a 400 Bad Request response with only two values
+                logger.warning(f"Invalid JSON: {error_message_to_display}")  # Log failed request
                 return False, (jsonify({'error': f"{error_message_to_display}"}), 400)
         return True, None
 
     if json_validation_enabled:
-        print("JSON validation is enabled")
+        logger.info("JSON validation is enabled.")
     else:
-        print("JSON validation is disabled")
+        logger.info("JSON validation is disabled.")
 
     return validate_json_request

dracan/validators/method_validator.py

@@ -1,10 +1,11 @@
 from flask import request, jsonify
 
-def create_method_validator(rules_config):
+def create_method_validator(rules_config, logger):
     """
     Creates a function that validates if the request method is allowed based on the provided rules_config.
     
     :param rules_config: The configuration that contains allowed methods and whether method validation is enabled.
+    :param logger: The logger from the Flask app to use for logging.
     :return: A validation function for HTTP methods.
     """
     allowed_methods = rules_config.get("allowed_methods", ["GET", "PUT", "POST", "DELETE"])
@@ -16,20 +17,19 @@ def validate_http_method():
         :return: Tuple (is_valid, response) - is_valid is True if valid, False otherwise.
         """
         if not method_validation_enabled:
-            # If method validation is disabled, always return True
+            logger.info("Method validation is disabled.")
             return True, None
 
         if request.method not in allowed_methods:
-            # Return False and a validation response with a 405 status code if method is not allowed
+            logger.warning(f"Method {request.method} not allowed.")  # Log disallowed method
             return False, (jsonify({'error': f"Method {request.method} not allowed"}), 405)
-        
-        # Return True and None if the method is allowed
+
+        logger.info(f"Method {request.method} is allowed.")  # Log allowed method
         return True, None
 
     if method_validation_enabled:
-        print("HTTP Method validation is enabled, allowed methods: " + " | ".join(allowed_methods))
+        logger.info("HTTP Method validation is enabled. Allowed methods: " + " | ".join(allowed_methods))
     else:
-        print("HTTP Method validation is disabled")
-
+        logger.info("HTTP Method validation is disabled.")
 
     return validate_http_method