async def completions():
    # ...
    async for chunk in response:
        if not hasattr(chunk, "content"):
            continue
        
        content = parser.parse(chunk)

        # data only messages
        if bypass:
            yield "".join(f"data: {line}\n" for line in content.splitlines()) + "\n"
            continue
        
        # named events
        elif not bypass:
            usage_metadata = getattr(chunk, "usage_metadata", None)
            response_metadata = getattr(chunk, "response_metadata", {})

            is_last = any(
                key in response_metadata for key in ["stop_reason", "finish_reason"]
            )
            yield get_named_event(content, aid, usage_metadata, is_last)

def get_named_event(
    content: str, aid: str, usage_metadata: Optional[dict], is_last: bool
) -> str:
    data = {
        "text": content,
        "success": is_last if is_last else "",
        "code": SUCCESS_CODE if is_last else "",
        "message": SUCCESS_MESSAGE if is_last else "",
        "aid": aid,
        "usage_metadata": usage_metadata,
    }
    return f"event: message\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"

import logging
import os
from contextvars import ContextVar
from logging import Logger
from logging.handlers import RotatingFileHandler

trace_id_var: ContextVar[str] = ContextVar("trace_id", default="N/A")
MAX_LOG_SIZE = 5 * 1024 * 1024  # 5MB
BACKUP_COUNT = 5


class CustomFormatter(logging.Formatter):

    def format(self, record):
        if not hasattr(record, "trace_id"):
            record.trace_id = "N/A"
        return super().format(record)


class ContextFilter(logging.Filter):
    def filter(self, record: logging.LogRecord):
        record.trace_id = str(trace_id_var.get())
        return True


def log_directory(log_dir):
    try:
        os.makedirs(log_dir)
    except FileExistsError:
        pass


def setup_logger(name: str = "app") -> Logger:
    logger = logging.getLogger(name)
    logger.setLevel(os.getenv("LOG_LEVEL", "INFO").upper())

    # 로그 파일 경로
    base_dir = os.path.dirname(
        os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
    )
    log_dir = os.path.join(base_dir, "log")
    log_file = os.path.join(log_dir, "app.log")

    # 디렉토리 생성
    log_directory(log_dir)

    log_format = "%(asctime)s %(name)s %(levelname)s [%(process)d] [%(threadName)s] [trace_id=%(trace_id)s] %(message)s"

    console_handler = logging.StreamHandler()
    console_handler.setFormatter(CustomFormatter(log_format))

    file_handler = RotatingFileHandler(
        log_file, maxBytes=MAX_LOG_SIZE, backupCount=BACKUP_COUNT
    )
    file_handler.setFormatter(CustomFormatter(log_format))

    logger.addHandler(console_handler)
    logger.addHandler(file_handler)
    logger.addFilter(ContextFilter())

    return logger


logger = setup_logger()

from app.config.logging.config import trace_id_var  # 위의 파일

# 미들웨어에서 trace_id 생성해 ContextVar에 저장하는 코드
trace_id = str(uuid.uuid4())
scope["trace_id"] = trace_id
trace_id_var.set(trace_id)

import time
import uuid
from urllib.parse import unquote

from starlette.datastructures import MutableHeaders
from starlette.requests import Request
from starlette.types import ASGIApp, Message, Receive, Scope, Send

from app.config.logging.config import logger, trace_id_var


class AccessLoggerMiddleware:
    def __init__(self, app: ASGIApp) -> None:
        self.app = app
        self.excluded_paths = [
            "/docs",
            "/swagger-ui",
            "/swagger-ui-bundle",
            "/openapi.json",
            "/web",
        ]
        self.excluded_prefixes = ["/swagger-ui"]
        self.excluded_extensions = (".js", ".css", ".png", ".svg", ".ico", ".map")

    def _is_excluded(self, path: str) -> bool:
        return (
            path in self.excluded_paths
            or any(path.startswith(prefix) for prefix in self.excluded_prefixes)
            or path.endswith(self.excluded_extensions)
        )

    async def __call__(self, scope: Scope, receive: Receive, send: Send):
        if scope["type"] != "http":
            await self.app(scope, receive, send)
            return

        trace_id = str(uuid.uuid4())
        scope["trace_id"] = trace_id
        trace_id_var.set(trace_id)

        path = scope.get("path")
        if self._is_excluded(path):
            await self.app(scope, receive, send)
            return

        request = Request(scope)
        start_time = time.perf_counter()

        async def wrapped_receive() -> Message:
            message = await receive()
            if message["type"] == "http.request":
                body = message.get("body", b"")
                try:
                    payload = body.decode("utf-8", errors="replace")
                except Exception:
                    payload = "<decode error>"

                logger.info(
                    f"Request: {request.method} {path} {unquote(str(request.query_params))} "
                    f"Payload={payload}"
                )
            return message

        async def wrapped_send(message: Message) -> None:
            aid = request.scope.get("trace_id")
            if message["type"] == "http.response.start":
                headers = MutableHeaders(scope=message)
                headers.append("X-Trace-ID", aid)

                status_code = message.get("status", 0)
                logger.info(f"Response: {status_code} {message.get('headers')} ")
            elif message["type"] == "http.response.body":
                body = message.get("body", b"") or b""
                try:
                    decoded_body = body.decode("utf-8", errors="replace")
                except Exception:
                    decoded_body = "<decode error>"

                elapsed = time.perf_counter() - start_time
                logger.info(f"Elapsed Time: {elapsed: .4f}s")
                logger.info(f"Response Body={decoded_body}")
            await send(message)

        await self.app(scope, wrapped_receive, wrapped_send)