Break up src/app/api.py module (#174)

The goal of this commit is to move some of the code currently present in
`src/app/api.py` into more appropriate modules. The result is that the
 three modules involved have more obvious "jobs":
- `log.py`: logging config and any helpers
- `router.py`: all route handling logic
- `main.py`: building the FastAPI app (middleware, adding static files,
  registering the router)

Author: grahamalama

asgi.py

@@ -9,7 +9,7 @@
 if __name__ == "__main__":
     server = uvicorn.Server(
         uvicorn.Config(
-            "src.app.api:app",
+            "src.app.main:app",
             host=settings.host,
             port=settings.port,
             reload=settings.app_reload,

src/app/api.py

@@ -4,6 +4,11 @@
 import logging
 import logging.config
 import sys
+import time
+from datetime import datetime
+from typing import Dict
+
+from fastapi import Request
 
 from src.app.environment import get_settings
 
@@ -37,3 +42,23 @@
         "uvicorn.access": {"handlers": ["null"], "propagate": False},
     },
 }
+
+
+def format_request_summary_fields(
+    request: Request, request_time: float, status_code: int
+) -> Dict:
+    """Prepare Fields for Mozlog request summary"""
+
+    current_time = time.time()
+    fields = {
+        "agent": request.headers.get("User-Agent"),
+        "path": request.url.path,
+        "method": request.method,
+        "lang": request.headers.get("Accept-Language"),
+        "querystring": dict(request.query_params),
+        "errno": 0,
+        "t": int((current_time - request_time) * 1000.0),
+        "time": datetime.fromtimestamp(current_time).isoformat(),
+        "status_code": status_code,
+    }
+    return fields

src/app/log.py

@@ -0,0 +1,55 @@
+"""
+Core FastAPI app (setup, middleware)
+"""
+import logging
+import time
+from pathlib import Path
+
+import sentry_sdk
+from fastapi import FastAPI, Request
+from fastapi.staticfiles import StaticFiles
+from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
+
+from src.app.environment import get_settings
+from src.app.log import format_request_summary_fields
+from src.app.router import router
+
+SRC_DIR = Path(__file__).parents[1]
+
+settings = get_settings()
+
+
+app = FastAPI(
+    title="Jira Bugzilla Integration (JBI)",
+    description="JBI v2 Platform",
+    version="3.1.0",
+    debug=settings.app_debug,
+)
+
+app.include_router(router)
+app.mount("/static", StaticFiles(directory=SRC_DIR / "static"), name="static")
+
+sentry_sdk.init(  # pylint: disable=abstract-class-instantiated  # noqa: E0110
+    dsn=settings.sentry_dsn
+)
+app.add_middleware(SentryAsgiMiddleware)
+
+
+@app.middleware("http")
+async def request_summary(request: Request, call_next):
+    """Middleware to log request info"""
+    summary_logger = logging.getLogger("request.summary")
+    request_time = time.time()
+    try:
+        response = await call_next(request)
+        log_fields = format_request_summary_fields(
+            request, request_time, status_code=response.status_code
+        )
+        summary_logger.info("", extra=log_fields)
+        return response
+    except Exception as exc:
+        log_fields = format_request_summary_fields(
+            request, request_time, status_code=500
+        )
+        summary_logger.info(exc, extra=log_fields)
+        raise

src/app/main.py

@@ -0,0 +1,112 @@
+"""
+Core FastAPI app (setup, middleware)
+"""
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from fastapi import APIRouter, Body, Depends, Request, Response
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+from src.app.configuration import get_actions
+from src.app.environment import Settings, get_settings, get_version
+from src.jbi.bugzilla import BugzillaWebhookRequest
+from src.jbi.models import Actions
+from src.jbi.runner import IgnoreInvalidRequestError, execute_action
+from src.jbi.services import jbi_service_health_map, jira_visible_projects
+
+router = APIRouter()
+
+
+@router.get("/", include_in_schema=False)
+def root(request: Request, settings: Settings = Depends(get_settings)):
+    """Expose key configuration"""
+    return {
+        "title": request.app.title,
+        "description": request.app.description,
+        "version": request.app.version,
+        "documentation": request.app.docs_url,
+        "configuration": {
+            "jira_base_url": settings.jira_base_url,
+            "bugzilla_base_url": settings.bugzilla_base_url,
+        },
+    }
+
+
+@router.get("/__heartbeat__")
+@router.head("/__heartbeat__")
+def heartbeat(response: Response, actions: Actions = Depends(get_actions)):
+    """Return status of backing services, as required by Dockerflow."""
+    health_map = jbi_service_health_map(actions)
+    health_checks = []
+    for health in health_map.values():
+        health_checks.extend(health.values())
+    if not all(health_checks):
+        response.status_code = 503
+    return health_map
+
+
+@router.get("/__lbheartbeat__")
+@router.head("/__lbheartbeat__")
+def lbheartbeat():
+    """Dockerflow API for lbheartbeat: HEAD"""
+    return {"status": "OK"}
+
+
+@router.get("/__version__")
+def version(version_json=Depends(get_version)):
+    """Return version.json, as required by Dockerflow."""
+    return version_json
+
+
+@router.post("/bugzilla_webhook")
+def bugzilla_webhook(
+    request: BugzillaWebhookRequest = Body(..., embed=False),
+    actions: Actions = Depends(get_actions),
+    settings: Settings = Depends(get_settings),
+):
+    """API endpoint that Bugzilla Webhook Events request"""
+    try:
+        result = execute_action(request, actions, settings)
+        return result
+    except IgnoreInvalidRequestError as exception:
+        return {"error": str(exception)}
+
+
+@router.get("/whiteboard_tags/")
+def get_whiteboard_tags(
+    whiteboard_tag: Optional[str] = None,
+    actions: Actions = Depends(get_actions),
+):
+    """API for viewing whiteboard_tags and associated data"""
+    if existing := actions.get(whiteboard_tag):
+        return {whiteboard_tag: existing}
+    return actions.by_tag
+
+
+@router.get("/jira_projects/")
+def get_jira_projects():
+    """API for viewing projects that are currently accessible by API"""
+    visible_projects: List[Dict] = jira_visible_projects()
+    return [project["key"] for project in visible_projects]
+
+
+SRC_DIR = Path(__file__).parents[1]
+templates = Jinja2Templates(directory=SRC_DIR / "templates")
+
+
+@router.get("/powered_by_jbi/", response_class=HTMLResponse)
+def powered_by_jbi(
+    request: Request,
+    enabled: Optional[bool] = None,
+    actions: Actions = Depends(get_actions),
+):
+    """API for `Powered By` endpoint"""
+    context = {
+        "request": request,
+        "title": "Powered by JBI",
+        "actions": jsonable_encoder(actions),
+        "enable_query": enabled,
+    }
+    return templates.TemplateResponse("powered_by_template.html", context)