Python Integration

pip install requests

# error_logger.py
import requests
import traceback
import os

API_KEY = os.getenv('ERROR_LOG_API_KEY', 'YOUR_API_KEY')
SECURITY_KEY = os.getenv('ERROR_LOG_SECURITY_KEY', 'YOUR_SECURITY_KEY')
WEBHOOK_URL = f'https://your-domain.com/api/ingest/{API_KEY}'

def log_error(exception, context=None):
    try:
        payload = {
            'message': str(exception),
            'stackTrace': traceback.format_exc()
        }
        
        if context:
            payload.update(context)
        
        requests.post(
            WEBHOOK_URL,
            json=payload,
            headers={'X-Security-Key': SECURITY_KEY},
            timeout=5
        )
    except Exception as e:
        # Silently fail
        print(f'Failed to log error: {e}')

from flask import Flask, jsonify, request
from error_logger import log_error

app = Flask(__name__)

@app.errorhandler(Exception)
def handle_exception(e):
    # Log to ErrorLogDashboard
    log_error(e, {
        'url': request.url,
        'method': request.method,
        'ip': request.remote_addr
    })
    
    return jsonify({'error': 'Internal server error'}), 500

@app.route('/api/users/<int:user_id>')
def get_user(user_id):
    try:
        # Your code here
        return jsonify({'user': 'data'})
    except Exception as e:
        log_error(e, {'user_id': user_id})
        return jsonify({'error': 'Failed to fetch user'}), 500

if __name__ == '__main__':
    app.run(debug=True)

# middleware/error_logging.py
from error_logger import log_error

class ErrorLoggingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        return self.get_response(request)

    def process_exception(self, request, exception):
        log_error(exception, {
            'url': request.path,
            'method': request.method,
            'user': str(request.user)
        })
        return None  # Let Django handle the response

# In settings.py:
MIDDLEWARE = [
    # ... other middleware
    'middleware.error_logging.ErrorLoggingMiddleware',
]

from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import JSONResponse
from error_logger import log_error

app = FastAPI()

@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
    log_error(exc, {
        'url': str(request.url),
        'method': request.method
    })
    return JSONResponse(
        status_code=500,
        content={'error': 'Internal server error'}
    )

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    try:
        # Your code
        return {"user": "data"}
    except Exception as e:
        log_error(e, {'user_id': user_id})
        raise HTTPException(status_code=500)