@vercel/python 6.18.1 → 6.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.18.1",
+  "version": "6.19.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -35,9 +35,9 @@
     "which": "3.0.0",
     "get-port": "5.1.1",
     "is-port-reachable": "3.1.0",
-    "@vercel/python-runtime": "0.5.3",
+    "@vercel/build-utils": "13.6.1",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/build-utils": "13.6.1"
+    "@vercel/python-runtime": "0.5.3"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",

package/vc_init_dev.py

@@ -4,6 +4,8 @@
 import sys
 import os
 import inspect
+import logging
+import logging.config
 from os import path as _p
 from importlib import util as _importlib_util
 import mimetypes
@@ -23,6 +25,175 @@ def _color(text: str, code: str) -> str:
     return f"{code}{text}{_RESET}"
 
 
+# Configure logging to output DEBUG-WARNING to the stdout
+# and ERROR-CRITICAL to the stderr.
+
+
+# We need a custom filter for the stdout stream
+# so it won't print anything higher than WARNING.
+class _MaxLevelFilter(logging.Filter):
+    def __init__(self, max_level):
+        super().__init__()
+        self.max_level = max_level
+
+    def filter(self, record):
+        return record.levelno <= self.max_level
+
+
+def _build_log_config(loggers, _filter_ref=None) -> dict:
+    if _filter_ref is None:
+        _filter_ref = "vc_init_dev._MaxLevelFilter"
+
+    return {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "filters": {
+            "max_warning": {
+                "()": _filter_ref,
+                "max_level": logging.WARNING,
+            }
+        },
+        "handlers": {
+            "stdout": {
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stdout",
+                "filters": ["max_warning"],
+            },
+            "stderr": {
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stderr",
+                "level": "ERROR",
+            },
+        },
+        "loggers": loggers,
+        "root": {
+            "handlers": ["stdout", "stderr"],
+            "level": "INFO",
+        },
+    }
+
+
+def _setup_server_log_routing(logger_name=None):
+    loggers = {}
+
+    if logger_name:
+        loggers[logger_name] = {
+            "handlers": ["stdout", "stderr"],
+            "level": "INFO",
+            "propagate": False,
+        }
+
+    logging.config.dictConfig(
+        _build_log_config(
+            loggers=loggers,
+            _filter_ref=_MaxLevelFilter,
+        ),
+    )
+
+
+def _build_uvicorn_log_config(default_fmt=None, access_fmt=None) -> dict:
+    try:
+        from uvicorn.config import LOGGING_CONFIG  # type: ignore
+
+        uvicorn_fmts = LOGGING_CONFIG["formatters"]
+    except ImportError:
+        uvicorn_fmts = {
+            "default": {
+                "()": "uvicorn.logging.DefaultFormatter",
+                "fmt": "%(levelprefix)s %(message)s",
+                "use_colors": None,
+            },
+            "access": {
+                "()": "uvicorn.logging.AccessFormatter",
+                "fmt": '%(levelprefix)s %(client_addr)s - "%(request_line)s" %(status_code)s',
+            },
+        }
+
+    cfg = _build_log_config(
+        loggers={
+            "uvicorn": {
+                "handlers": ["stdout", "stderr"],
+                "level": "INFO",
+                "propagate": False,
+            },
+            "uvicorn.error": {"level": "INFO"},
+            "uvicorn.access": {
+                "handlers": ["access"],
+                "level": "INFO",
+                "propagate": False,
+            },
+        },
+    )
+
+    if default_fmt is None:
+        default_fmt = {**uvicorn_fmts["default"], "use_colors": not _NO_COLOR}
+
+    if access_fmt is None:
+        access_fmt = {**uvicorn_fmts["access"], "use_colors": not _NO_COLOR}
+
+    cfg["formatters"] = {"default": default_fmt, "access": access_fmt}
+    cfg["handlers"]["stdout"]["formatter"] = "default"
+    cfg["handlers"]["stderr"]["formatter"] = "default"
+    cfg["handlers"]["access"] = {
+        "class": "logging.StreamHandler",
+        "stream": "ext://sys.stdout",
+        "formatter": "access",
+    }
+
+    return cfg
+
+
+def _build_hypercorn_log_config():
+    return _build_log_config(
+        loggers={
+            "hypercorn.error": {
+                "handlers": ["stdout", "stderr"],
+                "level": "INFO",
+                "propagate": False,
+            },
+            "hypercorn.access": {
+                "handlers": ["stdout"],
+                "level": "INFO",
+                "propagate": False,
+            },
+        },
+    )
+
+
+def _patch_fastapi_cli_log_config():
+    try:
+        import fastapi_cli.utils.cli as _fcli  # type: ignore
+        import fastapi_cli.cli as _fcli_cli  # type: ignore
+
+        _orig_get_config = _fcli.get_uvicorn_log_config  # to ensure it's there
+        _fcli_cli.get_uvicorn_log_config  # to ensure it's there
+    except (ImportError, AttributeError):
+        return
+
+    def _get_routed_config():
+        orig = _orig_get_config()
+        return _build_uvicorn_log_config(
+            default_fmt={
+                "()": "fastapi_cli.utils.cli.CustomFormatter",
+                "fmt": orig["formatters"]["default"].get(
+                    "fmt", "%(levelprefix)s %(message)s"
+                ),
+                "use_colors": orig["formatters"]["default"].get("use_colors"),
+            },
+            access_fmt={
+                "()": "fastapi_cli.utils.cli.CustomFormatter",
+                "fmt": orig["formatters"]["access"].get(
+                    "fmt",
+                    "%(levelprefix)s %(client_addr)s - '%(request_line)s' %(status_code)s",
+                ),
+            },
+        )
+
+    _fcli.get_uvicorn_log_config = _get_routed_config
+    # we need to patch the local binding as well
+    _fcli_cli.get_uvicorn_log_config = _get_routed_config
+
+
 def _normalize_service_route_prefix(raw_prefix):
     if not raw_prefix:
         return ""
@@ -71,6 +242,11 @@ def _strip_service_route_prefix(path_value):
     return path_value, ""
 
 
+# Pre-configure the root logger before user module import so that any log
+# calls emitted at import time are routed to stdout/stderr correctly.
+_setup_server_log_routing()
+
+
 # ASGI/WSGI app detection
 _MODULE_NAME = "__VC_DEV_MODULE_NAME__"
 _ENTRY_ABS = "__VC_DEV_ENTRY_ABS__"
@@ -355,7 +531,8 @@ if __name__ == "__main__":
         try:
             from werkzeug.serving import run_simple  # type: ignore
 
-            run_simple(host, port, wsgi_app, use_reloader=True)
+            _setup_server_log_routing("werkzeug")
+            run_simple(host, port, wsgi_app, use_reloader=True, threaded=True)
         except Exception:
             print(
                 _color(
@@ -376,6 +553,7 @@ if __name__ == "__main__":
             fastapi_dev = None
 
         if fastapi_dev is not None:
+            _patch_fastapi_cli_log_config()
             fastapi_dev(
                 entrypoint="vc_init_dev:asgi_app", host=host, port=port, reload=True
             )
@@ -390,6 +568,7 @@ if __name__ == "__main__":
                 port=port,
                 use_colors=True,
                 reload=True,
+                log_config=_build_uvicorn_log_config(),
             )
         except Exception:
             try:
@@ -399,6 +578,8 @@ if __name__ == "__main__":
 
                 config = Config()
                 config.bind = [f"{host}:{port}"]
+                config.use_reloader = True
+                config.logconfig_dict = _build_hypercorn_log_config()
 
                 async def _run():
                     await serve(asgi_app, config)