json-logify 0.1.0__py3-none-any.whl

json_logify-0.1.0.dist-info/METADATA

@@ -0,0 +1,263 @@
+Metadata-Version: 2.4
+Name: json-logify
+Version: 0.1.0
+Summary: Universal structured logging with exact JSON schema for Python frameworks
+Author-email: Bakdoolot Kulbarakov <kulbarakovbh@gmail.com>
+Maintainer-email: Bakdoolot Kulbarakov <kulbarakovbh@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Kulbarakov Bakdoolot
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/yourusername/json-logify
+Project-URL: Documentation, https://json-logify.readthedocs.io/
+Project-URL: Repository, https://github.com/yourusername/json-logify
+Project-URL: Issues, https://github.com/yourusername/json-logify/issues
+Project-URL: Changelog, https://github.com/yourusername/json-logify/blob/main/CHANGELOG.md
+Keywords: logging,structured,json,django,fastapi,flask,universal,schema,orjson,structlog
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Logging
+Classifier: Framework :: Django
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Flask
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: structlog>=23.0.0
+Requires-Dist: orjson>=3.8.0
+Provides-Extra: django
+Requires-Dist: django>=5.2.6; extra == "django"
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.116.1; extra == "fastapi"
+Requires-Dist: uvicorn>=0.35.0; extra == "fastapi"
+Provides-Extra: flask
+Requires-Dist: flask>=3.1.2; extra == "flask"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.4.2; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+Requires-Dist: bandit>=1.7.5; extra == "dev"
+Provides-Extra: all
+Requires-Dist: json-logify[django,fastapi,flask]; extra == "all"
+Dynamic: license-file
+
+# json-logify
+
+Universal structured logging with exact JSON schema for Python frameworks.
+
+[![PyPI version](https://badge.fury.io/py/json-logify.svg)](https://badge.fury.io/py/json-logify)
+[![Python Support](https://img.shields.io/pypi/pyversions/json-logify.svg)](https://pypi.org/project/json-logify/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- <� **Exact JSON Schema**: Consistent log format across all frameworks
+- � **High Performance**: Built with structlog and orjson for maximum speed
+- < **Universal**: Works with Django, FastAPI, Flask, and standalone Python
+- =' **Easy Setup**: One-line configuration for most use cases
+- =� **Rich Context**: Request IDs, user tracking, and custom payload support
+- =
+ **Modern Python**: Full type hints and async support
+
+## Quick Start
+
+### Installation
+
+```bash
+# Basic installation
+pip install json-logify
+
+# For specific frameworks
+pip install json-logify[django]
+pip install json-logify[fastapi]
+pip install json-logify[flask]
+
+# Everything
+pip install json-logify[all]
+```
+
+### Basic Usage
+
+```python
+from logify import info, error
+
+# Simple logging
+info("User logged in", user_id="12345", action="login")
+
+# Error logging with exception
+try:
+    raise ValueError("Something went wrong")
+except Exception as e:
+    error("Operation failed", error=e, operation="data_processing")
+```
+
+Output:
+```json
+{
+  "timestamp": "2025-01-15T10:30:00.123Z",
+  "message": "User logged in",
+  "level": "INFO",
+  "payload": {
+    "user_id": "12345",
+    "action": "login"
+  }
+}
+```
+
+### Django Integration
+
+```python
+# settings.py
+from logify.django import get_logging_config
+
+LOGGING = get_logging_config(
+    service_name="myapp",
+    json_logs=True
+)
+
+# Add middleware (optional for request tracking)
+MIDDLEWARE = [
+    'logify.django.LogifyMiddleware',
+    # ... other middleware
+]
+```
+
+### FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from logify.fastapi import LogifyMiddleware
+
+app = FastAPI()
+app.add_middleware(LogifyMiddleware, service_name="myapi")
+
+@app.get("/")
+async def root():
+    from logify import info
+    info("API endpoint called", endpoint="/")
+    return {"message": "Hello World"}
+```
+
+### Flask Integration
+
+```python
+from flask import Flask
+from logify.flask import init_logify
+
+app = Flask(__name__)
+init_logify(app, service_name="myapp")
+
+@app.route("/")
+def hello():
+    from logify import info
+    info("Flask endpoint called", endpoint="/")
+    return "Hello, World!"
+```
+
+## Advanced Usage
+
+### Context Management
+
+```python
+from logify import bind, set_request_context, clear_request_context
+
+# Bind context to a logger
+logger = bind(service="auth", module="login")
+logger.info("Processing login", user_id="123")
+
+# Set request-level context (useful in middleware)
+set_request_context(request_id="req-456", user_id="123")
+info("User action", action="view_profile")  # Includes request context
+clear_request_context()
+```
+
+### Performance Tracking
+
+```python
+from logify import track_performance
+
+@track_performance
+def expensive_operation():
+    # Your code here
+    return "result"
+
+# Automatically logs function start, completion, and duration
+```
+
+### Custom Configuration
+
+```python
+from logify import configure_logging
+
+# Configure with custom settings
+configure_logging(
+    service_name="myapp",
+    level="DEBUG"
+)
+```
+
+## Log Schema
+
+All logs follow this exact JSON schema:
+
+```json
+{
+  "timestamp": "2025-01-15T10:30:00.123Z",
+  "message": "Log message here",
+  "level": "INFO",
+  "error": "Error description (optional)",
+  "payload": {
+    "service": "myapp",
+    "request_id": "req-123",
+    "custom_field": "custom_value"
+  }
+}
+```
+
+The `error` field is optional and will only appear when logging errors or exceptions.
+
+## Requirements
+
+- Python 3.8+
+- structlog >= 23.0.0
+- orjson >= 3.8.0
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

json_logify-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+json_logify-0.1.0.dist-info/licenses/LICENSE,sha256=qRyWd6Y0_db_j_ECsAAEJW8-XMnhYUg_yK3c5UkOfNI,1077
+logify/__init__.py,sha256=t2Jjw7T4jRMIYvXJOTBraaW6MneifmS_gDKDlrRHmeU,1053
+logify/core.py,sha256=kiMraMhpH9GShY0lPhXAnBO0bTMe0a77cIVpWldecZY,5548
+logify/django.py,sha256=i5z9-nzrBF712ba1xkMpAsND-RLFopDLk8M7tsyTPzk,2526
+logify/fastapi.py,sha256=ACQPWGVfTexUUCQX2oh-s5NBT1q0q5UDARbNsKulamU,2567
+logify/flask.py,sha256=YPRsaFiojP-2buZCwNhm5JmpgBAakJAQsKy1hh6r8ek,2645
+logify/version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+json_logify-0.1.0.dist-info/METADATA,sha256=Lu5bw9vf8mz16MTG0jkOXmKltqX1osvMl8E03aXRR30,7659
+json_logify-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+json_logify-0.1.0.dist-info/top_level.txt,sha256=MRERkeaav8J-KtwGpiLDCnSNQ5e2JqKUMAlJnYVntao,7
+json_logify-0.1.0.dist-info/RECORD,,

json_logify-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

json_logify-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kulbarakov Bakdoolot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

json_logify-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+logify

logify/__init__.py

@@ -0,0 +1,50 @@
+"""
+json-logify - Universal structured logging with exact JSON schema for Python frameworks.
+
+Simple usage:
+    from logify import info, error
+
+    info("User logged in", user_id="12345")
+    error("Database error", error="Connection timeout")
+
+For more examples, see: https://github.com/yourusername/json-logify
+"""
+
+from .core import (  # Convenience functions; Configuration; Context management; Utilities
+    bind,
+    clear_request_context,
+    configure_logging,
+    critical,
+    debug,
+    error,
+    exception,
+    generate_request_id,
+    get_logger,
+    info,
+    set_request_context,
+    track_performance,
+    warning,
+)
+from .version import __version__
+
+__all__ = [
+    # Version
+    "__version__",
+    # Convenience functions
+    "debug",
+    "info",
+    "warning",
+    "error",
+    "critical",
+    "exception",
+    # Configuration
+    "configure_logging",
+    "get_logger",
+    # Context management
+    "bind",
+    "set_request_context",
+    "clear_request_context",
+    # Utilities
+    "generate_request_id",
+    "track_performance",
+]

logify/core.py

@@ -0,0 +1,198 @@
+"""
+Core structured logging functionality for json-logify.
+Provides universal structured logging with exact JSON schema using orjson and structlog.
+"""
+
+import time
+import uuid
+from contextvars import ContextVar
+from datetime import UTC, datetime
+from typing import Any, Dict
+
+import orjson
+import structlog
+
+# Context variables for request tracking
+_request_context: ContextVar[Dict[str, Any]] = ContextVar("request_context", default={})
+
+
+def orjson_serializer(_, __, event_dict):
+    """Serialize log entries using orjson for performance."""
+    return orjson.dumps(event_dict).decode("utf-8")
+
+
+def add_timestamp(_, __, event_dict):
+    """Add ISO timestamp to log entries."""
+    # Unresolved attribute reference 'UTC' for class 'datetime'
+    event_dict["timestamp"] = datetime.now(UTC).isoformat().replace("+00:00", "Z")
+    return event_dict
+
+
+def format_log_entry(logger, name, event_dict):
+    """Format log entry according to json-logify schema."""
+    message = event_dict.pop("event", "")
+
+    # Get the correct log level from the logger name if available
+    # or from the event dict, defaulting to INFO
+    level = name or event_dict.get("level", "INFO")
+
+    # Remove level from event_dict to avoid duplication
+    event_dict.pop("level", None)
+
+    # Get context
+    try:
+        context = _request_context.get({})
+    except LookupError:
+        context = {}
+
+    # Extract error from event_dict if present
+    error_field = event_dict.pop("error", None)
+
+    # Build the standardized log entry
+    formatted_entry = {
+        "timestamp": event_dict.pop("timestamp", datetime.now(UTC).isoformat().replace("+00:00", "Z")),
+        "message": message,
+        "level": level.upper(),
+        "payload": {**context, **event_dict},
+    }
+
+    # Add optional error field at top level
+    if error_field:
+        formatted_entry["error"] = str(error_field)
+
+    return formatted_entry
+
+
+# Configure structlog with the right processors
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_log_level,
+        add_timestamp,
+        format_log_entry,
+        orjson_serializer,
+    ],
+    wrapper_class=structlog.BoundLogger,
+    logger_factory=structlog.PrintLoggerFactory(),
+    cache_logger_on_first_use=True,
+)
+
+
+# Get the default logger
+logger = structlog.get_logger("json-logify")
+
+
+# Convenience functions
+def debug(message: str, **kwargs):
+    """Log debug message."""
+    logger.debug(message, **kwargs)
+
+
+def info(message: str, **kwargs):
+    """Log info message."""
+    logger.info(message, **kwargs)
+
+
+def warning(message: str, **kwargs):
+    """Log warning message."""
+    logger.warning(message, **kwargs)
+
+
+def warn(message: str, **kwargs):
+    """Alias for warning."""
+    logger.warning(message, **kwargs)
+
+
+def error(message: str, error: Exception = None, **kwargs):
+    """Log error message."""
+    if error:
+        kwargs["error"] = error  # Will be moved to top-level by format_log_entry
+        kwargs["error_type"] = type(error).__name__
+    logger.error(message, **kwargs)
+
+
+def critical(message: str, **kwargs):
+    """Log critical message."""
+    logger.critical(message, **kwargs)
+
+
+def exception(message: str, **kwargs):
+    """Log exception with traceback."""
+    import traceback
+
+    kwargs["traceback"] = traceback.format_exc()
+    logger.error(message, **kwargs)
+
+
+def get_logger(name: str = "json-logify", service: str = "app"):
+    """Get a named logger instance."""
+    bound_logger = structlog.get_logger(name)
+    return bound_logger.bind(service=service)
+
+
+def configure_logging(service_name: str = "app", level: str = "INFO"):
+    """Configure logging for the application."""
+    import logging
+
+    # Set logging level on stdlib logger
+    logging.basicConfig(level=getattr(logging, level.upper(), logging.INFO))
+
+    structlog.configure(
+        processors=[
+            add_timestamp,
+            format_log_entry,
+            orjson_serializer,
+        ],
+        wrapper_class=structlog.BoundLogger,  # type: ignore
+        logger_factory=structlog.PrintLoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+    # Bind service name to the default logger
+    global logger
+    logger = structlog.get_logger("json-logify").bind(service=service_name)
+
+
+def bind(**kwargs):
+    """Create a bound logger with additional context."""
+    return logger.bind(**kwargs)
+
+
+def set_request_context(**kwargs):
+    """Set request-level context variables."""
+    try:
+        current = _request_context.get({})
+        _request_context.set({**current, **kwargs})
+    except LookupError:
+        _request_context.set(kwargs)
+
+
+def clear_request_context():
+    """Clear request-level context."""
+    _request_context.set({})
+
+
+def generate_request_id() -> str:
+    """Generate a unique request ID."""
+    return str(uuid.uuid4())
+
+
+def track_performance(func):
+    """Decorator to track function performance."""
+
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        request_id = generate_request_id()
+
+        info("Function started", function=func.__name__, request_id=request_id)
+
+        try:
+            result = func(*args, **kwargs)
+            duration = time.time() - start_time
+            info("Function completed", function=func.__name__, request_id=request_id, duration_seconds=duration)
+            return result
+        except Exception as e:
+            duration = time.time() - start_time
+            error("Function failed", function=func.__name__, request_id=request_id, duration_seconds=duration, error=e)
+            raise
+
+    return wrapper

logify/django.py

@@ -0,0 +1,88 @@
+"""
+Django integration for json-logify structured logging.
+"""
+
+from .core import clear_request_context, configure_logging, generate_request_id, set_request_context
+
+
+def get_logging_config(service_name: str = "django", level: str = "INFO", json_logs: bool = True):
+    """
+    Get Django logging configuration for json-logify.
+
+    Usage in settings.py:
+        from logify.django import get_logging_config
+        LOGGING = get_logging_config(service_name="myapp")
+    """
+    if json_logs:
+        configure_logging(service_name=service_name, level=level)
+
+    return {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "json": {"format": "%(message)s"},
+        },
+        "handlers": {
+            "console": {
+                "class": "logging.StreamHandler",
+                "formatter": "json",
+            },
+        },
+        "root": {
+            "handlers": ["console"],
+            "level": level,
+        },
+        "loggers": {
+            "django": {
+                "handlers": ["console"],
+                "level": level,
+                "propagate": False,
+            },
+            service_name: {
+                "handlers": ["console"],
+                "level": level,
+                "propagate": False,
+            },
+        },
+    }
+
+
+class LogifyMiddleware:
+    """Django middleware for structured logging with request context."""
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        # Generate request ID and set context
+        request_id = generate_request_id()
+        request.logify_request_id = request_id
+
+        set_request_context(
+            request_id=request_id,
+            method=request.method,
+            path=request.path,
+            user_agent=request.META.get("HTTP_USER_AGENT", ""),
+            remote_addr=request.META.get("REMOTE_ADDR", ""),
+        )
+
+        try:
+            response = self.get_response(request)
+
+            # Add response info to context
+            set_request_context(
+                status_code=response.status_code,
+                content_length=len(response.content) if hasattr(response, "content") else None,
+            )
+
+            return response
+        finally:
+            clear_request_context()
+
+
+def setup_django_logging(service_name: str = "django"):
+    """
+    Set up Django logging with json-logify.
+    Call this in your Django settings or apps.py
+    """
+    configure_logging(service_name=service_name)

logify/fastapi.py

@@ -0,0 +1,82 @@
+"""
+FastAPI integration for json-logify structured logging.
+"""
+
+import time
+
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from .core import clear_request_context, configure_logging, error, generate_request_id, info, set_request_context
+
+
+class LogifyMiddleware(BaseHTTPMiddleware):
+    """FastAPI middleware for structured logging with request context."""
+
+    def __init__(self, app, service_name: str = "fastapi", log_requests: bool = True):
+        super().__init__(app)
+        self.service_name = service_name
+        self.log_requests = log_requests
+        configure_logging(service_name=service_name)
+
+    async def dispatch(self, request: Request, call_next):
+        # Generate request ID and set context
+        request_id = generate_request_id()
+        start_time = time.time()
+
+        # Extract client info
+        client_host = getattr(request.client, "host", "unknown") if request.client else "unknown"
+
+        set_request_context(
+            request_id=request_id,
+            method=request.method,
+            path=request.url.path,
+            query_params=str(request.query_params) if request.query_params else None,
+            client_host=client_host,
+            user_agent=request.headers.get("user-agent", ""),
+        )
+
+        if self.log_requests:
+            info("Request started", method=request.method, path=request.url.path, request_id=request_id)
+
+        try:
+            response = await call_next(request)
+
+            duration = time.time() - start_time
+
+            # Add response info to context
+            set_request_context(status_code=response.status_code, duration_seconds=duration)
+
+            if self.log_requests:
+                info(
+                    "Request completed",
+                    status_code=response.status_code,
+                    duration_seconds=duration,
+                    request_id=request_id,
+                )
+
+            return response
+
+        except Exception as e:
+            duration = time.time() - start_time
+
+            if self.log_requests:
+                error(
+                    "Request failed",
+                    error=e,
+                    duration_seconds=duration,
+                    request_id=request_id,
+                )
+
+            raise
+
+        finally:
+            clear_request_context()
+
+
+def setup_fastapi_logging(service_name: str = "fastapi"):
+    """
+    Set up FastAPI logging with json-logify.
+    Call this when creating your FastAPI app.
+    """
+    configure_logging(service_name=service_name)

logify/flask.py

@@ -0,0 +1,88 @@
+"""
+Flask integration for json-logify structured logging.
+"""
+
+import time
+
+from flask import Flask, g, request
+
+from .core import clear_request_context, configure_logging, error, generate_request_id, info, set_request_context
+
+
+def init_logify(app: Flask, service_name: str = "flask", log_requests: bool = True):
+    """
+    Initialize json-logify for Flask application.
+
+    Usage:
+        from flask import Flask
+        from logify.flask import init_logify
+
+        app = Flask(__name__)
+        init_logify(app, service_name="myapp")
+    """
+    configure_logging(service_name=service_name)
+
+    @app.before_request
+    def before_request():
+        # Generate request ID and set context
+        request_id = generate_request_id()
+        g.logify_request_id = request_id
+        g.logify_start_time = time.time()
+
+        set_request_context(
+            request_id=request_id,
+            method=request.method,
+            path=request.path,
+            query_string=request.query_string.decode() if request.query_string else None,
+            remote_addr=request.remote_addr,
+            user_agent=request.headers.get("User-Agent", ""),
+        )
+
+        if log_requests:
+            info("Request started", method=request.method, path=request.path, request_id=request_id)
+
+    @app.after_request
+    def after_request(response):
+        try:
+            # Calculate duration
+            duration = time.time() - g.logify_start_time
+
+            # Add response info to context
+            set_request_context(
+                status_code=response.status_code, duration_seconds=duration, content_length=response.content_length
+            )
+
+            if log_requests:
+                info(
+                    "Request completed",
+                    status_code=response.status_code,
+                    duration_seconds=duration,
+                    request_id=g.logify_request_id,
+                )
+        except Exception:
+            # If we can't access g, just return the response
+            pass
+
+        return response
+
+    def teardown_request(exception):
+        # Clear request context
+        clear_request_context()
+
+        if exception and log_requests:
+            error(
+                "Request failed",
+                error=exception,
+                request_id=getattr(g, "logify_request_id", "unknown"),
+            )
+
+    # Register teardown function
+    app.teardown_appcontext(teardown_request)
+
+
+def setup_flask_logging(service_name: str = "flask"):
+    """
+    Set up Flask logging with json-logify.
+    Call this when creating your Flask app.
+    """
+    configure_logging(service_name=service_name)

logify/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"