utility_logs

#APP
import logging
import sys

from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware


from routers import add_routers
from models.ireg_agent.utility_logging import set_request_id, get_logger, RequestIdFilter, patch_logger
import uuid

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - [%(request_id)s] - %(levelname)s - %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)
logging.getLogger().addFilter(RequestIdFilter())

root_logger = logging.getLogger()
root_logger.addFilter(RequestIdFilter())

# Patch commonly used libraries
patch_logger('requests')
patch_logger('urllib3')
# patch_logger('uvicorn')
# patch_logger('uvicorn.access')
# patch_logger('urllib3')

from config import settings
# Set global logging options
if settings.log_level.lower() == 'critical':
    root_logger.setLevel(logging.CRITICAL)
elif settings.log_level.lower() in ('warn', 'warning'):
    root_logger.setLevel(logging.WARNING)
elif settings.log_level.lower() == 'debug':
    root_logger.setLevel(logging.DEBUG)
else:
    root_logger.setLevel(logging.INFO)




get_logger("httpcore").setLevel(logging.WARNING)
get_logger("httpx").setLevel(logging.WARNING)
# Initialize Application
app = FastAPI()


# Configure CORS
allowed_cors_origins = ['*']
app.add_middleware(
  CORSMiddleware,
  allow_origins=allowed_cors_origins,
  allow_credentials=True,
  allow_methods=["*"],
  allow_headers=["*"],
)

@app.middleware("http")
async def add_request_id(request: Request, call_next):
    request_id = str(uuid.uuid4())
    set_request_id(request_id)
    response = await call_next(request)
    return response

# Add our routers
add_routers(app)

#####Utility login g

import contextvars
import logging
import uuid

request_id_var = contextvars.ContextVar('request_id', default=None)

class RequestIdFilter(logging.Filter):
    def filter(self, record):
        request_id = request_id_var.get()
        if request_id is None:
            request_id = str(uuid.uuid4())
            request_id_var.set(request_id)
        record.request_id = request_id
        return True


def get_logger(name):
    logger = logging.getLogger(name)
    if not any(isinstance(f, RequestIdFilter) for f in logger.filters):
        logger.addFilter(RequestIdFilter())
    return logger

def set_request_id(request_id=None):
    if request_id is None:
        request_id = str(uuid.uuid4())
    request_id_var.set(request_id)

def get_request_id():
    return request_id_var.get()

def patch_logger(logger_name):
    logger = logging.getLogger(logger_name)
    if not any(isinstance(f, RequestIdFilter) for f in logger.filters):
        logger.addFilter(RequestIdFilter())
    for handler in logger.handlers:
        if isinstance(handler, logging.StreamHandler):
            handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - [%(request_id)s] - %(levelname)s - %(message)s'))



# # script1.py
# from shared_logging import get_logger

# logger = get_logger(__name__)

# def do_something():
#     logger.info("Doing something in script1")
#     # Your logic here

# # script2.py
# from shared_logging import get_logger

# logger = get_logger(__name__)

# def do_something_else():
#     logger.info("Doing something else in script2")
#     # Your logic here

# # script3.py
# from shared_logging import get_logger

# logger = get_logger(__name__)

# def final_operation():
#     logger.info("Performing final operation in script3")
#     # Your logic here
#     return "Operation complete"


# import logging

# logging.basicConfig(
#     level=logging.INFO,
#     format='%(asctime)s - %(name)s - [%(request_id)s] - %(levelname)s - %(message)s',
#     datefmt='%Y-%m-%d %H:%M:%S'
# )

# 2023-05-20 10:15:30 - main_api - [123e4567-e89b-12d3-a456-426614174000] - INFO - Received request
# 2023-05-20 10:15:30 - script1 - [123e4567-e89b-12d3-a456-426614174000] - INFO -

# Add Error Handling:
# Wrap the context management in a try-except block to ensure the request ID is always reset, even if an error occurs:
# @app.middleware("http")
# async def add_request_id(request: Request, call_next):
#     request_id = generate_request_id()
#     token = request_id_var.set(request_id)
#     try:
#         response = await call_next(request)
#         return response
#     finally:
#         request_id_var.reset(token)