make log format uniform

api/Dockerfile

@@ -9,4 +9,4 @@ RUN pip install --no-cache-dir --upgrade -r ./requirements.txt
 
 COPY . .
 
-CMD python -m uvicorn api.main:app --host 0.0.0.0 --port 8000
+CMD python -m api.main

api/api/config.py

@@ -1,4 +1,5 @@
 import os
 
 api_version = os.getenv("API_VERSION", "v1")
+service_port = int(os.getenv("SERVICE_PORT", 8000))
 log_level = int(os.getenv("LOG_LEVEL", 20))

api/api/main.py

@@ -1,17 +1,27 @@
 from dataclasses import asdict
 import logging
 
+import uvicorn
 from fastapi import FastAPI, HTTPException, APIRouter
 
-from .config import api_version, log_level
+from .config import api_version, log_level, service_port
 from .models import PredictionResponse
 from .pollution.pollution import ArtificialNightSkyBrightnessMapImage, Coords
 from .prediction.prediction import (
     Prediction,
     predict_sky_brightness,
 )
 
-logging.basicConfig(level=log_level)
+log_format = "%(asctime)s [%(levelname)s] %(message)s"
+logging.basicConfig(level=log_level, format=log_format)
+
+
+def get_log_config():
+    config = uvicorn.config.LOGGING_CONFIG
+    config["formatters"]["access"]["fmt"] = log_format
+    return config
+
+
 app = FastAPI()
 main_router = APIRouter(prefix=f"/api/{api_version}")
 
@@ -49,3 +59,6 @@ async def get_artificial_light_pollution(lat, lon):
 
 
 app.include_router(main_router)
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=service_port, log_config=get_log_config())

api/api/prediction/meteo/open_meteo_client.py

@@ -12,7 +12,7 @@ def __init__(self, site: ObserverSite) -> None:
         self.url_base = f"{PROTOCOL}://{open_meteo_host}:{open_meteo_port}"
 
     async def get_values_at_site(self) -> t.Tuple[int, float]:
-        """ask the instance of open meteo for cloud cover and elevation values for the observer site"""
+        """ask open meteo for cloud cover and elevation for the observer site"""
         import httpx
 
         lat, lon = self.site.latitude.value, self.site.longitude.value

pp/pp/main.py

@@ -39,6 +39,7 @@ async def main():
         try:
             async with httpx.AsyncClient() as client:
                 while True:
+                    # allow predictions over cells to run in interleaved way
                     for cell_coords in resolution_zero_cell_coords:
                         await asyncio.create_task(predict_on_cell_coords(client, cell_coords, channel))
                         await asyncio.sleep(task_sleep_interval)

pp/pp/prediction.py

@@ -16,33 +16,38 @@
 
 
 async def get_prediction_message_for_lat_lon(client: httpx.AsyncClient, lat: float, lon: float) -> PredictionMessage:
+    """create the object that will get published to rabbitmq"""
     res = await client.get(prediction_endpoint_url, params={"lat": lat, "lon": lon})
     res.raise_for_status()
+
     data = res.json()
     if (mpsas := data.get("sky_brightness", None)) is None:
         raise ValueError("no sky brightness reading in api response")
 
-    return PredictionMessage(
+    message = PredictionMessage(
         lat=lat,
         lon=lon,
         h3_id=h3.geo_to_h3(lat, lon, 0),
         utc=datetime.utcnow().isoformat(),
         mpsas=mpsas,
     )
+    return message
 
 
 # message_store = {}
 
 
-async def predict_on_cell_coords(client: httpx.AsyncClient, coords: Tuple[float, float], channel: Channel):
+async def predict_on_cell_coords(client: httpx.AsyncClient, h3_coords: Tuple[float, float], channel: Channel):
     """retrieve and publish a sky brightness prediction at coords for the h3 cell"""
     import json
 
     try:
-        lat, lon = coords
+        lat, lon = h3_coords
 
         m = await get_prediction_message_for_lat_lon(client, lat, lon)
         message_body = asdict(m)
+
+        log.info(f"publishing {message_body} to {prediction_queue}")
         channel.basic_publish(exchange="", routing_key=prediction_queue, body=json.dumps(message_body))
 
         # keep track of how many messages are published for each cell
@@ -53,4 +58,4 @@ async def predict_on_cell_coords(client: httpx.AsyncClient, coords: Tuple[float,
     except httpx.HTTPStatusError as e:
         log.error(f"got bad status from api server {e}")
     except Exception as e:
-        log.error(f"could not publish prediction at {coords} because {e}")
+        log.error(f"could not publish prediction at {h3_coords} because {e}")