litewave-logger 0.4.0__tar.gz → 0.6.0__tar.gz

{litewave_logger-0.4.0 → litewave_logger-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: litewave_logger
-Version: 0.4.0
+Version: 0.6.0
 Summary: A lightweight logging library with context carry forward
 Author: Litewave
 Author-email: Sonu Sudhakaran <sonu@litewave.ai>
@@ -21,6 +21,7 @@ This module provides a centralized and consistent logging solution for Litewave
 - **JSON Logging**: All logs are formatted as JSON for easy parsing and integration with log aggregation systems.
 - **Request ID Propagation**: Automatically injects a `request-id` into all log messages.
 - **FastAPI Integration**: Middleware for FastAPI to handle `request-id` for incoming HTTP requests and adds it to response headers.
+- **Flask Integration**: Middleware for Flask to handle `request-id` for incoming HTTP requests and adds it to response headers.
 - **Celery Integration**: Signal handlers to propagate the `request-id` to Celery tasks automatically.
 - **Requests Library Patching**: Automatically injects the `request-id` into outgoing HTTP requests made with the `requests` library.
 - **Endpoint Exclusion**: Configure endpoints that should not be logged (e.g., health checks, metrics).
@@ -53,6 +54,16 @@ To use the `litewave_logger` in your service, follow these steps:
     app.add_middleware(RequestIdMiddleware)
     ```
 
+    **Or for Flask applications**: If your service is a Flask application, use the `FlaskRequestIdMiddleware`.
+
+    ```python
+    from flask import Flask
+    from litewave_logger.flask_middleware import FlaskRequestIdMiddleware
+
+    app = Flask(__name__)
+    FlaskRequestIdMiddleware(app)
+    ```
+
 3.  **Patch the `requests` library**: To ensure the `request-id` is propagated to other services, patch the `requests` library.
 
     ```python
@@ -68,7 +79,7 @@ To use the `litewave_logger` in your service, follow these steps:
     import litewave_logger.celery
     ```
 
-### Example
+### FastAPI Example
 
 Here's a complete example of how to integrate the `litewave_logger` into a FastAPI application:
 
@@ -95,6 +106,53 @@ app.add_middleware(RequestIdMiddleware)
 # Your application code here...
 ```
 
+### Flask Example
+
+Here's a complete example of how to integrate the `litewave_logger` into a Flask application:
+
+```python
+from flask import Flask
+from litewave_logger import setup_logging
+from litewave_logger.flask_middleware import FlaskRequestIdMiddleware
+from litewave_logger.requests import patch_requests
+
+# Import Celery module to register signal handlers (if using Celery)
+import litewave_logger.celery
+
+# 1. Initialize logging (optionally exclude endpoints)
+setup_logging(excluded_endpoints=['/health', '/metrics'])
+
+# 2. Patch requests library
+patch_requests()
+
+app = Flask(__name__)
+
+# 3. Add FlaskRequestIdMiddleware
+FlaskRequestIdMiddleware(app)
+
+@app.route('/')
+def hello():
+    return 'Hello, World!'
+
+# Your application code here...
+```
+
+The Flask middleware also supports the application factory pattern:
+
+```python
+from flask import Flask
+from litewave_logger import setup_logging
+from litewave_logger.flask_middleware import FlaskRequestIdMiddleware
+
+middleware = FlaskRequestIdMiddleware()
+
+def create_app():
+    setup_logging(excluded_endpoints=['/health'])
+    app = Flask(__name__)
+    middleware.init_app(app)
+    return app
+```
+
 ## How It Works
 
 ### Request ID Flow

{litewave_logger-0.4.0 → litewave_logger-0.6.0}/README.md

@@ -8,6 +8,7 @@ This module provides a centralized and consistent logging solution for Litewave
 - **JSON Logging**: All logs are formatted as JSON for easy parsing and integration with log aggregation systems.
 - **Request ID Propagation**: Automatically injects a `request-id` into all log messages.
 - **FastAPI Integration**: Middleware for FastAPI to handle `request-id` for incoming HTTP requests and adds it to response headers.
+- **Flask Integration**: Middleware for Flask to handle `request-id` for incoming HTTP requests and adds it to response headers.
 - **Celery Integration**: Signal handlers to propagate the `request-id` to Celery tasks automatically.
 - **Requests Library Patching**: Automatically injects the `request-id` into outgoing HTTP requests made with the `requests` library.
 - **Endpoint Exclusion**: Configure endpoints that should not be logged (e.g., health checks, metrics).
@@ -40,6 +41,16 @@ To use the `litewave_logger` in your service, follow these steps:
     app.add_middleware(RequestIdMiddleware)
     ```
 
+    **Or for Flask applications**: If your service is a Flask application, use the `FlaskRequestIdMiddleware`.
+
+    ```python
+    from flask import Flask
+    from litewave_logger.flask_middleware import FlaskRequestIdMiddleware
+
+    app = Flask(__name__)
+    FlaskRequestIdMiddleware(app)
+    ```
+
 3.  **Patch the `requests` library**: To ensure the `request-id` is propagated to other services, patch the `requests` library.
 
     ```python
@@ -55,7 +66,7 @@ To use the `litewave_logger` in your service, follow these steps:
     import litewave_logger.celery
     ```
 
-### Example
+### FastAPI Example
 
 Here's a complete example of how to integrate the `litewave_logger` into a FastAPI application:
 
@@ -82,6 +93,53 @@ app.add_middleware(RequestIdMiddleware)
 # Your application code here...
 ```
 
+### Flask Example
+
+Here's a complete example of how to integrate the `litewave_logger` into a Flask application:
+
+```python
+from flask import Flask
+from litewave_logger import setup_logging
+from litewave_logger.flask_middleware import FlaskRequestIdMiddleware
+from litewave_logger.requests import patch_requests
+
+# Import Celery module to register signal handlers (if using Celery)
+import litewave_logger.celery
+
+# 1. Initialize logging (optionally exclude endpoints)
+setup_logging(excluded_endpoints=['/health', '/metrics'])
+
+# 2. Patch requests library
+patch_requests()
+
+app = Flask(__name__)
+
+# 3. Add FlaskRequestIdMiddleware
+FlaskRequestIdMiddleware(app)
+
+@app.route('/')
+def hello():
+    return 'Hello, World!'
+
+# Your application code here...
+```
+
+The Flask middleware also supports the application factory pattern:
+
+```python
+from flask import Flask
+from litewave_logger import setup_logging
+from litewave_logger.flask_middleware import FlaskRequestIdMiddleware
+
+middleware = FlaskRequestIdMiddleware()
+
+def create_app():
+    setup_logging(excluded_endpoints=['/health'])
+    app = Flask(__name__)
+    middleware.init_app(app)
+    return app
+```
+
 ## How It Works
 
 ### Request ID Flow

{litewave_logger-0.4.0 → litewave_logger-0.6.0}/litewave_logger/__init__.py

@@ -78,4 +78,4 @@ def get_excluded_endpoints():
     """
     return _excluded_endpoints
 
-__all__ = ["setup_logging", "request_id_var", "RequestIdFilter", "get_excluded_endpoints"]
+__all__ = ["setup_logging", "request_id_var", "RequestIdFilter", "get_excluded_endpoints", "JsonLogFormatter"]

litewave_logger-0.6.0/litewave_logger/flask_middleware.py

@@ -0,0 +1,116 @@
+import uuid
+import logging
+from flask import Flask, request, g
+
+from . import request_id_var, get_excluded_endpoints
+
+logger = logging.getLogger(__name__)
+RequestIdHeader = "X-Request-ID"
+
+
+class FlaskRequestIdMiddleware:
+    """
+    Flask middleware to handle the request ID and provide comprehensive debugging.
+    It checks for a 'X-Request-ID' header in the incoming request.
+    If the header is present, its value is used as the request ID.
+    If not, a new UUID is generated.
+    The request ID is then stored in a context variable.
+    Provides detailed logging for incoming requests and outgoing responses.
+    
+    Usage:
+        from flask import Flask
+        from litewave_logger import setup_logging
+        from litewave_logger.flask_middleware import FlaskRequestIdMiddleware
+        
+        app = Flask(__name__)
+        setup_logging(excluded_endpoints=['/health'])
+        FlaskRequestIdMiddleware(app)
+    """
+    
+    def __init__(self, app: Flask = None):
+        """
+        Initialize the middleware.
+        
+        Args:
+            app: Flask application instance. If provided, init_app() is called automatically.
+        """
+        self.app = app
+        if app is not None:
+            self.init_app(app)
+    
+    def init_app(self, app: Flask):
+        """
+        Initialize the middleware with a Flask application.
+        Supports Flask's application factory pattern.
+        
+        Args:
+            app: Flask application instance.
+        """
+        app.before_request(self._before_request)
+        app.after_request(self._after_request)
+    
+    def _before_request(self):
+        """
+        Handler called before each request.
+        Sets up request ID and logs incoming request.
+        """
+        # Get or generate request ID
+        request_id = request.headers.get(RequestIdHeader)
+        if not request_id:
+            request_id = str(uuid.uuid4())
+        
+        # Store request ID in Flask's g object for easy access in views
+        g.request_id = request_id
+        
+        # Set request ID in context variable (for logging filter)
+        request_id_var.set(request_id)
+        
+        # Check if this endpoint should be excluded from logging
+        excluded_endpoints = get_excluded_endpoints()
+        path = request.path
+        g.should_log = path not in excluded_endpoints
+        
+        if g.should_log:
+            logger.info("request received", extra={
+                "method": request.method,
+                "path": path
+            })
+    
+    def _after_request(self, response):
+        """
+        Handler called after each request.
+        Adds request ID to response headers and logs response.
+        
+        Args:
+            response: Flask response object.
+            
+        Returns:
+            Modified response with request ID header.
+        """
+        # Add request ID to response headers
+        request_id = getattr(g, 'request_id', None)
+        if request_id:
+            response.headers[RequestIdHeader] = request_id
+        
+        # Log response details only if endpoint is not excluded
+        should_log = getattr(g, 'should_log', True)
+        if should_log:
+            logger.info("response sent", extra={
+                "status_code": response.status_code
+            })
+        
+        return response
+
+
+def get_request_id():
+    """
+    Utility function to get the current request ID from Flask's g object.
+    
+    Returns:
+        The current request ID or None if not available.
+    """
+    return getattr(g, 'request_id', None)
+
+
+__all__ = ["FlaskRequestIdMiddleware", "get_request_id"]
+

{litewave_logger-0.4.0 → litewave_logger-0.6.0}/litewave_logger/middleware.py

@@ -31,6 +31,8 @@ class RequestIdMiddleware(BaseHTTPMiddleware):
         request_id = request.headers.get(RequestIdHeader)
         if not request_id:
             request_id = str(uuid.uuid4())
+            # Set the request ID in the request headers if not present
+            request.scope["headers"].append((RequestIdHeader.lower().encode(), request_id.encode()))
 
         # Set request ID in context
         request_id_var.set(request_id)

{litewave_logger-0.4.0 → litewave_logger-0.6.0}/litewave_logger.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: litewave_logger
-Version: 0.4.0
+Version: 0.6.0
 Summary: A lightweight logging library with context carry forward
 Author: Litewave
 Author-email: Sonu Sudhakaran <sonu@litewave.ai>
@@ -21,6 +21,7 @@ This module provides a centralized and consistent logging solution for Litewave
 - **JSON Logging**: All logs are formatted as JSON for easy parsing and integration with log aggregation systems.
 - **Request ID Propagation**: Automatically injects a `request-id` into all log messages.
 - **FastAPI Integration**: Middleware for FastAPI to handle `request-id` for incoming HTTP requests and adds it to response headers.
+- **Flask Integration**: Middleware for Flask to handle `request-id` for incoming HTTP requests and adds it to response headers.
 - **Celery Integration**: Signal handlers to propagate the `request-id` to Celery tasks automatically.
 - **Requests Library Patching**: Automatically injects the `request-id` into outgoing HTTP requests made with the `requests` library.
 - **Endpoint Exclusion**: Configure endpoints that should not be logged (e.g., health checks, metrics).
@@ -53,6 +54,16 @@ To use the `litewave_logger` in your service, follow these steps:
     app.add_middleware(RequestIdMiddleware)
     ```
 
+    **Or for Flask applications**: If your service is a Flask application, use the `FlaskRequestIdMiddleware`.
+
+    ```python
+    from flask import Flask
+    from litewave_logger.flask_middleware import FlaskRequestIdMiddleware
+
+    app = Flask(__name__)
+    FlaskRequestIdMiddleware(app)
+    ```
+
 3.  **Patch the `requests` library**: To ensure the `request-id` is propagated to other services, patch the `requests` library.
 
     ```python
@@ -68,7 +79,7 @@ To use the `litewave_logger` in your service, follow these steps:
     import litewave_logger.celery
     ```
 
-### Example
+### FastAPI Example
 
 Here's a complete example of how to integrate the `litewave_logger` into a FastAPI application:
 
@@ -95,6 +106,53 @@ app.add_middleware(RequestIdMiddleware)
 # Your application code here...
 ```
 
+### Flask Example
+
+Here's a complete example of how to integrate the `litewave_logger` into a Flask application:
+
+```python
+from flask import Flask
+from litewave_logger import setup_logging
+from litewave_logger.flask_middleware import FlaskRequestIdMiddleware
+from litewave_logger.requests import patch_requests
+
+# Import Celery module to register signal handlers (if using Celery)
+import litewave_logger.celery
+
+# 1. Initialize logging (optionally exclude endpoints)
+setup_logging(excluded_endpoints=['/health', '/metrics'])
+
+# 2. Patch requests library
+patch_requests()
+
+app = Flask(__name__)
+
+# 3. Add FlaskRequestIdMiddleware
+FlaskRequestIdMiddleware(app)
+
+@app.route('/')
+def hello():
+    return 'Hello, World!'
+
+# Your application code here...
+```
+
+The Flask middleware also supports the application factory pattern:
+
+```python
+from flask import Flask
+from litewave_logger import setup_logging
+from litewave_logger.flask_middleware import FlaskRequestIdMiddleware
+
+middleware = FlaskRequestIdMiddleware()
+
+def create_app():
+    setup_logging(excluded_endpoints=['/health'])
+    app = Flask(__name__)
+    middleware.init_app(app)
+    return app
+```
+
 ## How It Works
 
 ### Request ID Flow

{litewave_logger-0.4.0 → litewave_logger-0.6.0}/litewave_logger.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ pyproject.toml
 setup.py
 litewave_logger/__init__.py
 litewave_logger/celery.py
+litewave_logger/flask_middleware.py
 litewave_logger/middleware.py
 litewave_logger/requests.py
 litewave_logger.egg-info/PKG-INFO

{litewave_logger-0.4.0 → litewave_logger-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "litewave_logger"
-version = "0.4.0"
+version = "0.6.0"
 description = "A lightweight logging library with context carry forward"
 authors = [{name = "Sonu Sudhakaran", email = "sonu@litewave.ai"}]
 dependencies = [

{litewave_logger-0.4.0 → litewave_logger-0.6.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="litewave_logger",
-    version="0.4.0",
+    version="0.6.0",
     description="A centralized logging module for Litewave services.",
     author="Litewave",
     packages=find_packages(),