mtk-logger 0.3.0__tar.gz

mtk_logger-0.3.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.3
+Name: mtk_logger
+Version: 0.3.0
+Summary: Logging utilities for Python applications
+Author: Patrick Prasquier
+Author-email: pprasquier@odm-tech.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: fastapi[all] (>=0.115.0,<0.116.0)
+Requires-Dist: prefy (>=1.4.1,<2.0.0)
+Project-URL: Repository, https://github.com/pprasquier/mtk_logger
+Description-Content-Type: text/markdown
+
+# MTK Logger
+
+Logging utilities for MarkTrack applications.
+
+## Installation
+
+To install from GitHub Packages:
+
+```bash
+# Configure pip to use GitHub Packages
+pip config set global.extra-index-url https://YOUR_GITHUB_TOKEN@github.com/pprasquier/mtk_logger/raw/main/dist/
+
+# Install the package
+pip install mtk_logger
+```
+
+Or with Poetry:
+
+```bash
+# Add GitHub Packages as a source
+poetry source add --priority=supplemental github https://github.com/pprasquier/mtk_logger/raw/main/dist/
+
+# Install the package
+poetry add mtk_logger
+```
+
+## Usage
+
+```python
+from mtk_logger.logger import get_logger
+
+logger = get_logger(__name__)
+logger.info("This is a log message")
+```
+
+For FastAPI middleware:
+
+```python
+from mtk_logger.fastapi_middleware import RequestLoggingMiddleware
+
+app.add_middleware(RequestLoggingMiddleware)
+``` 

mtk_logger-0.3.0/README.md

@@ -0,0 +1,42 @@
+# MTK Logger
+
+Logging utilities for MarkTrack applications.
+
+## Installation
+
+To install from GitHub Packages:
+
+```bash
+# Configure pip to use GitHub Packages
+pip config set global.extra-index-url https://YOUR_GITHUB_TOKEN@github.com/pprasquier/mtk_logger/raw/main/dist/
+
+# Install the package
+pip install mtk_logger
+```
+
+Or with Poetry:
+
+```bash
+# Add GitHub Packages as a source
+poetry source add --priority=supplemental github https://github.com/pprasquier/mtk_logger/raw/main/dist/
+
+# Install the package
+poetry add mtk_logger
+```
+
+## Usage
+
+```python
+from mtk_logger.logger import get_logger
+
+logger = get_logger(__name__)
+logger.info("This is a log message")
+```
+
+For FastAPI middleware:
+
+```python
+from mtk_logger.fastapi_middleware import RequestLoggingMiddleware
+
+app.add_middleware(RequestLoggingMiddleware)
+``` 

mtk_logger-0.3.0/pyproject.toml

@@ -0,0 +1,17 @@
+[tool.poetry]
+name = "mtk_logger"
+version = "0.3.0"
+description = "Logging utilities for Python applications"
+authors = ["Patrick Prasquier <pprasquier@odm-tech.com>"]
+readme = "README.md"
+packages = [{include = "mtk_logger", from = "src"}]
+repository = "https://github.com/pprasquier/mtk_logger"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+fastapi = {extras = ["all"], version = "^0.115.0"}
+prefy = "^1.4.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api" 

mtk_logger-0.3.0/src/mtk_logger/fastapi_middleware.py

@@ -0,0 +1,103 @@
+import uuid
+import json
+import os
+from starlette.middleware.base import BaseHTTPMiddleware
+from typing import Callable
+from starlette.responses import StreamingResponse
+from fastapi import Request
+import time
+from .logger import get_logger
+
+class RequestLoggingMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next: Callable):
+        # Get request details
+        request_id = str(uuid.uuid4())
+        start_time = time.time()
+        logger = get_logger(os.path.basename(__file__))
+
+        # Extract path and method
+        path = request.url.path
+        method = request.method
+        logger.debug(f'("Request: {request_id} - {method} {path}")')
+
+        # Try to extract query parameters
+        # Convert query_params to dict, preserving lists for repeated keys
+        query_params = {}
+        for key, value in request.query_params.multi_items():
+            if key in query_params:
+                logger.debug(f"Duplicate key '{key}' found in query parameters")
+                # If the key exists but its value is not a list yet, convert it to a list
+                if not isinstance(query_params[key], list):
+                    query_params[key] = [query_params[key]]
+                # Now we can safely append the new value
+                query_params[key].append(value)
+            else:
+                query_params[key] = value
+                logger.debug(f"Added key '{key}' to query parameters")
+
+        # Try to extract request body (this is tricky because we can only read it once)
+        body = None
+        if method in ["POST", "PUT", "PATCH"]:
+            try:
+                # We need to read the body and then restore it for the actual endpoint
+                body_bytes = await request.body()
+                # Restore the request body
+                request._body = body_bytes
+
+                # Try to parse as JSON, but handle non-JSON bodies gracefully
+                try:
+                    body = json.loads(body_bytes.decode())
+                    # For large payloads, consider truncating or summarizing
+                    if isinstance(body, dict):
+                        # For each list in the body, replace with count and sample
+                        for key, value in body.items():
+                            if isinstance(value, list) and len(value) > 5:
+                                sample = value[:3]  # Take first 3 items as sample
+                                body[key] = {
+                                    "count": len(value),
+                                    "sample": sample
+                                }
+                except:
+                    body = {"raw_size": len(body_bytes), "note": "Non-JSON body"}
+            except:
+                body = {"note": "Could not read request body"}
+
+        # Log the request
+        log_data = {
+            "request_id": request_id,
+            "method": method,
+            "path": path,
+            "query_params": query_params,
+            "body": body
+        }
+
+        logger.info(f"API Request: {json.dumps(log_data)}")
+
+        # Process the request
+        response = await call_next(request)
+
+        # Read and log the response body
+        response_body = b""
+        async for chunk in response.body_iterator:
+            response_body += chunk
+
+        # Decode the response body
+        responses = response_body.decode()
+
+        # Try to parse the response body as JSON and count the records
+        try:
+            response_data = json.loads(responses)
+            if isinstance(response_data, list):
+                record_count = len(response_data)
+            else:
+                record_count = 1  # If it's not a list, assume it's a single record
+        except json.JSONDecodeError:
+            record_count = 0  # If the response is not JSON, set record count to 0
+
+        # Log response details
+        process_time = time.time() - start_time
+        logger.info(f"Request {request_id} completed in {process_time:.4f}s with status {response.status_code} and {record_count} records")
+        logger.debug(f'Request {request_id} response= {responses}')
+
+        # Return a new StreamingResponse with the original response body
+        return StreamingResponse(iter([response_body]), status_code=response.status_code, headers=dict(response.headers))

mtk_logger-0.3.0/src/mtk_logger/logger.py

@@ -0,0 +1,55 @@
+import os
+import sys
+import logging
+from logging.handlers import TimedRotatingFileHandler
+from prefy import Preferences
+
+### BE SURE TO ADD log_file_name and app_name settings. Cf. settings_example.json
+
+class MTKLogger(logging.Logger):
+    def __init__(self, script_name=None, backup_count=7):
+        settings = Preferences()
+        
+        log_file_name=settings.log_file_name
+        app_name=settings.app_name
+
+        # Set up base logger
+        super().__init__(app_name)
+        preferences_level=settings.log_level
+        level = getattr(logging, preferences_level, logging.DEBUG)
+        self.setLevel(level)
+
+        # Common log file for the day
+        log_filename = os.path.join(settings.log_dir, f'{log_file_name}.log')
+
+        # Script name for contextual logging
+        script_id = script_name or os.path.basename(sys.argv[0])
+
+        # Custom formatter including script name
+        formatter = logging.Formatter(
+            f'%(asctime)s - %(name)s - %(levelname)s - {script_id} - [Line %(lineno)d] - %(message)s'
+        )
+
+        # Timed rotating file handler (daily, retain N days)
+        file_handler = TimedRotatingFileHandler(
+            filename=log_filename,
+            when='midnight',
+            interval=1,
+            backupCount=backup_count,
+            encoding='utf-8',
+            utc=False  # Use True if you want UTC timestamps
+        )
+        file_handler.setLevel(logging.DEBUG)
+        file_handler.setFormatter(formatter)
+        self.addHandler(file_handler)
+
+        # Console handler
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(logging.DEBUG)
+        console_handler.setFormatter(formatter)
+        self.addHandler(console_handler)
+
+        self.debug("Logging initialized for script: %s, daily rotation enabled, logs in: %s", script_id, log_filename)
+
+def get_logger(script_name=None, backup_count=7):
+    return MTKLogger(script_name, backup_count)