@vercel/python 5.0.6 → 5.0.8

package/dist/index.js

@@ -2836,16 +2836,10 @@ async function getUserScriptsDir(pythonPath) {
     return null;
   }
 }
-async function pipInstall(pipPath, pythonPath, workPath, args, targetDir) {
+async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
   const target = targetDir ? (0, import_path.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
   process.env.PIP_USER = "0";
-  let uvBin = null;
-  try {
-    uvBin = await getUvBinaryOrInstall(pythonPath);
-  } catch (err) {
-    console.log("Failed to install uv, falling back to pip");
-  }
-  if (uvBin) {
+  if (uvPath) {
     const uvArgs = [
       "pip",
       "install",
@@ -2855,10 +2849,10 @@ async function pipInstall(pipPath, pythonPath, workPath, args, targetDir) {
       target,
       ...args
     ];
-    const prettyUv = `${uvBin} ${uvArgs.join(" ")}`;
+    const prettyUv = `${uvPath} ${uvArgs.join(" ")}`;
     (0, import_build_utils.debug)(`Running "${prettyUv}"...`);
     try {
-      await (0, import_execa.default)(uvBin, uvArgs, {
+      await (0, import_execa.default)(uvPath, uvArgs, {
         cwd: workPath
       });
       return;
@@ -2932,10 +2926,8 @@ async function maybeFindUvBin(pythonPath) {
 }
 async function getUvBinaryOrInstall(pythonPath) {
   const uvBin = await maybeFindUvBin(pythonPath);
-  if (uvBin) {
-    console.log(`Using uv at "${uvBin}"`);
+  if (uvBin)
     return uvBin;
-  }
   try {
     console.log("Installing uv...");
     await (0, import_execa.default)(
@@ -2966,6 +2958,7 @@ async function getUvBinaryOrInstall(pythonPath) {
 async function installRequirement({
   pythonPath,
   pipPath,
+  uvPath,
   dependency,
   version: version2,
   workPath,
@@ -2981,11 +2974,12 @@ async function installRequirement({
     return;
   }
   const exact = `${dependency}==${version2}`;
-  await pipInstall(pipPath, pythonPath, workPath, [exact, ...args], targetDir);
+  await pipInstall(pipPath, uvPath, workPath, [exact, ...args], targetDir);
 }
 async function installRequirementsFile({
   pythonPath,
   pipPath,
+  uvPath,
   filePath,
   workPath,
   targetDir,
@@ -2999,27 +2993,29 @@ async function installRequirementsFile({
   }
   await pipInstall(
     pipPath,
-    pythonPath,
+    uvPath,
     workPath,
     ["--upgrade", "-r", filePath, ...args],
     targetDir
   );
 }
-async function exportRequirementsFromUv(pythonPath, projectDir, options = {}) {
+async function exportRequirementsFromUv(projectDir, uvPath, options = {}) {
   const { locked = false } = options;
-  const uvBin = await getUvBinaryOrInstall(pythonPath);
+  if (!uvPath) {
+    throw new Error("uv is not available to export requirements");
+  }
   const args = ["export"];
   if (locked) {
     args.push("--frozen");
   }
-  (0, import_build_utils.debug)(`Running "${uvBin} ${args.join(" ")}" in ${projectDir}...`);
+  (0, import_build_utils.debug)(`Running "${uvPath} ${args.join(" ")}" in ${projectDir}...`);
   let stdout;
   try {
-    const { stdout: out } = await (0, import_execa.default)(uvBin, args, { cwd: projectDir });
+    const { stdout: out } = await (0, import_execa.default)(uvPath, args, { cwd: projectDir });
     stdout = out;
   } catch (err) {
     throw new Error(
-      `Failed to run "${uvBin} ${args.join(" ")}": ${err instanceof Error ? err.message : String(err)}`
+      `Failed to run "${uvPath} ${args.join(" ")}": ${err instanceof Error ? err.message : String(err)}`
     );
   }
   const tmpDir = await import_fs.default.promises.mkdtemp((0, import_path.join)(import_os.default.tmpdir(), "vercel-uv-"));
@@ -3031,6 +3027,7 @@ async function exportRequirementsFromUv(pythonPath, projectDir, options = {}) {
 async function exportRequirementsFromPipfile({
   pythonPath,
   pipPath,
+  uvPath,
   projectDir,
   meta
 }) {
@@ -3044,7 +3041,8 @@ async function exportRequirementsFromPipfile({
     version: "0.3.0",
     workPath: tempDir,
     meta,
-    args: ["--no-warn-script-location"]
+    args: ["--no-warn-script-location"],
+    uvPath
   });
   const tempVendorDir = (0, import_path.join)(tempDir, resolveVendorDir());
   const convertCmd = isWin ? (0, import_path.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path.join)(tempVendorDir, "bin", "pipfile2req");
@@ -3151,16 +3149,27 @@ function getSupportedPythonVersion({
       }
       if (isInstalled2(requested)) {
         selection = requested;
+        console.log(`Using Python ${selection.version} from ${source}`);
       } else {
         console.warn(
           `Warning: Python version "${version2}" detected in ${source} is not installed and will be ignored. http://vercel.link/python-version`
         );
+        console.log(
+          `Falling back to latest installed version: ${selection.version}`
+        );
       }
     } else {
       console.warn(
         `Warning: Python version "${version2}" detected in ${source} is invalid and will be ignored. http://vercel.link/python-version`
       );
+      console.log(
+        `Falling back to latest installed version: ${selection.version}`
+      );
     }
+  } else {
+    console.log(
+      `No Python version specified in pyproject.toml or Pipfile.lock. Using latest installed version: ${selection.version}`
+    );
   }
   if (isDiscontinued(selection)) {
     throw new import_build_utils2.NowBuildError({
@@ -3215,6 +3224,47 @@ function isFastapiEntrypoint(file) {
     return false;
   }
 }
+var FLASK_ENTRYPOINT_FILENAMES = ["app", "index", "server", "main"];
+var FLASK_ENTRYPOINT_DIRS = ["", "src", "app"];
+var FLASK_CONTENT_REGEX = /(from\s+flask\s+import\s+Flask|import\s+flask|Flask\s*\()/;
+var FLASK_CANDIDATE_ENTRYPOINTS = FLASK_ENTRYPOINT_FILENAMES.flatMap(
+  (filename) => FLASK_ENTRYPOINT_DIRS.map(
+    (dir) => import_path2.posix.join(dir, `${filename}.py`)
+  )
+);
+function isFlaskEntrypoint(file) {
+  try {
+    const fsPath = file.fsPath;
+    if (!fsPath)
+      return false;
+    const contents = import_fs2.default.readFileSync(fsPath, "utf8");
+    return FLASK_CONTENT_REGEX.test(contents);
+  } catch {
+    return false;
+  }
+}
+async function detectFlaskEntrypoint(workPath, configuredEntrypoint) {
+  const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+  try {
+    const fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+    if (fsFiles[entry])
+      return entry;
+    const candidates = FLASK_CANDIDATE_ENTRYPOINTS.filter(
+      (c) => !!fsFiles[c]
+    );
+    if (candidates.length > 0) {
+      const flaskEntrypoint = candidates.find(
+        (c) => isFlaskEntrypoint(fsFiles[c])
+      ) || candidates[0];
+      (0, import_build_utils3.debug)(`Detected Flask entrypoint: ${flaskEntrypoint}`);
+      return flaskEntrypoint;
+    }
+    return null;
+  } catch {
+    (0, import_build_utils3.debug)("Failed to discover entrypoint for Flask");
+    return null;
+  }
+}
 async function detectFastapiEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
@@ -3606,7 +3656,6 @@ var build = async ({
   meta = {},
   config
 }) => {
-  let pythonVersion = getLatestPythonVersion(meta);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -3637,6 +3686,20 @@ var build = async ({
         message: `No FastAPI entrypoint found. Searched for: ${searchedList}`
       });
     }
+  } else if (!fsFiles[entrypoint] && config?.framework === "flask") {
+    const detected = await detectFlaskEntrypoint(workPath, entrypoint);
+    if (detected) {
+      (0, import_build_utils5.debug)(
+        `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
+      );
+      entrypoint = detected;
+    } else {
+      const searchedList = FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
+      throw new import_build_utils5.NowBuildError({
+        code: "FLASK_ENTRYPOINT_NOT_FOUND",
+        message: `No Flask entrypoint found. Searched for: ${searchedList}`
+      });
+    }
   }
   const entryDirectory = (0, import_path5.dirname)(entrypoint);
   const hasReqLocal = !!fsFiles[(0, import_path5.join)(entryDirectory, "requirements.txt")];
@@ -3655,22 +3718,26 @@ var build = async ({
   });
   const pipfileLockDir = fsFiles[(0, import_path5.join)(entryDirectory, "Pipfile.lock")] ? (0, import_path5.join)(workPath, entryDirectory) : fsFiles["Pipfile.lock"] ? workPath : null;
   const pipfileDir = fsFiles[(0, import_path5.join)(entryDirectory, "Pipfile")] ? (0, import_path5.join)(workPath, entryDirectory) : fsFiles["Pipfile"] ? workPath : null;
+  let declaredPythonVersion;
   if (pyprojectDir) {
     let requiresPython;
     try {
       const pyproject = await (0, import_build_utils6.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
       requiresPython = pyproject?.project?.["requires-python"];
-    } catch {
-      (0, import_build_utils5.debug)("Failed to parse pyproject.toml");
+    } catch (err) {
+      (0, import_build_utils5.debug)("Failed to parse pyproject.toml", err);
     }
     const VERSION_REGEX = /\b\d+\.\d+\b/;
     const exact = requiresPython?.trim().match(VERSION_REGEX)?.[0];
     if (exact) {
-      const selected = getSupportedPythonVersion({
-        isDev: meta.isDev,
-        declaredPythonVersion: { version: exact, source: "pyproject.toml" }
-      });
-      pythonVersion = selected;
+      declaredPythonVersion = { version: exact, source: "pyproject.toml" };
+      (0, import_build_utils5.debug)(
+        `Found Python version ${exact} in pyproject.toml (requires-python: "${requiresPython}")`
+      );
+    } else if (requiresPython) {
+      (0, import_build_utils5.debug)(
+        `Could not parse Python version from pyproject.toml requires-python: "${requiresPython}"`
+      );
     }
   } else if (pipfileLockDir) {
     let lock = {};
@@ -3684,11 +3751,15 @@ var build = async ({
       });
     }
     const pyFromLock = lock?._meta?.requires?.python_version;
-    pythonVersion = getSupportedPythonVersion({
-      isDev: meta.isDev,
-      declaredPythonVersion: pyFromLock ? { version: pyFromLock, source: "Pipfile.lock" } : void 0
-    });
+    if (pyFromLock) {
+      declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
+      (0, import_build_utils5.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+    }
   }
+  const pythonVersion = getSupportedPythonVersion({
+    isDev: meta.isDev,
+    declaredPythonVersion
+  });
   fsFiles = await (0, import_build_utils5.glob)("**", workPath);
   const requirementsTxt = (0, import_path5.join)(entryDirectory, "requirements.txt");
   const vendorBaseDir = (0, import_path5.join)(
@@ -3704,10 +3775,42 @@ var build = async ({
     console.log("Failed to create vendor cache directory");
     throw err;
   }
-  console.log("Installing required dependencies...");
+  let installationSource;
+  if (uvLockDir && pyprojectDir) {
+    installationSource = "uv.lock";
+  } else if (pyprojectDir) {
+    installationSource = "pyproject.toml";
+  } else if (pipfileLockDir) {
+    installationSource = "Pipfile.lock";
+  } else if (pipfileDir) {
+    installationSource = "Pipfile";
+  } else if (fsFiles[requirementsTxt] || fsFiles["requirements.txt"]) {
+    installationSource = "requirements.txt";
+  }
+  if (installationSource) {
+    console.log(
+      `Installing required dependencies from ${installationSource}...`
+    );
+  } else {
+    console.log("Installing required dependencies...");
+  }
+  let uvPath = null;
+  try {
+    uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
+    console.log(`Using uv at "${uvPath}"`);
+  } catch (err) {
+    if (uvLockDir || pyprojectDir && !hasReqLocal && !hasReqGlobal) {
+      console.log("Failed to install uv");
+      throw new Error(
+        `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    (0, import_build_utils5.debug)("Failed to install uv", err);
+  }
   await installRequirement({
     pythonPath: pythonVersion.pythonPath,
     pipPath: pythonVersion.pipPath,
+    uvPath,
     dependency: "werkzeug",
     version: "1.0.1",
     workPath,
@@ -3718,14 +3821,13 @@ var build = async ({
   if (uvLockDir) {
     (0, import_build_utils5.debug)('Found "uv.lock"');
     if (pyprojectDir) {
-      const exportedReq = await exportRequirementsFromUv(
-        pythonVersion.pythonPath,
-        pyprojectDir,
-        { locked: true }
-      );
+      const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
+        locked: true
+      });
       await installRequirementsFile({
         pythonPath: pythonVersion.pythonPath,
         pipPath: pythonVersion.pipPath,
+        uvPath,
         filePath: exportedReq,
         workPath,
         targetDir: vendorBaseDir,
@@ -3742,14 +3844,13 @@ var build = async ({
         "Detected both pyproject.toml and requirements.txt but no lockfile; using pyproject.toml"
       );
     }
-    const exportedReq = await exportRequirementsFromUv(
-      pythonVersion.pythonPath,
-      pyprojectDir,
-      { locked: false }
-    );
+    const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
+      locked: false
+    });
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
       pipPath: pythonVersion.pipPath,
+      uvPath,
       filePath: exportedReq,
       workPath,
       targetDir: vendorBaseDir,
@@ -3764,12 +3865,14 @@ var build = async ({
       const exportedReq = await exportRequirementsFromPipfile({
         pythonPath: pythonVersion.pythonPath,
         pipPath: pythonVersion.pipPath,
+        uvPath,
         projectDir: pipfileLockDir || pipfileDir,
         meta
       });
       await installRequirementsFile({
         pythonPath: pythonVersion.pythonPath,
         pipPath: pythonVersion.pipPath,
+        uvPath,
         filePath: exportedReq,
         workPath,
         targetDir: vendorBaseDir,
@@ -3784,6 +3887,7 @@ var build = async ({
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
       pipPath: pythonVersion.pipPath,
+      uvPath,
       filePath: requirementsTxtPath,
       workPath,
       targetDir: vendorBaseDir,
@@ -3795,6 +3899,7 @@ var build = async ({
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
       pipPath: pythonVersion.pipPath,
+      uvPath,
       filePath: requirementsTxtPath,
       workPath,
       targetDir: vendorBaseDir,
@@ -3865,6 +3970,12 @@ var shouldServe = (opts) => {
       return false;
     }
     return true;
+  } else if (framework === "flask") {
+    const requestPath = opts.requestPath.replace(/\/$/, "");
+    if (requestPath.startsWith("api") && opts.hasMatched) {
+      return false;
+    }
+    return true;
   }
   return defaultShouldServe(opts);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "5.0.6",
+  "version": "5.0.8",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -20,7 +20,7 @@
     "@types/jest": "27.4.1",
     "@types/node": "14.18.33",
     "@types/which": "3.0.0",
-    "@vercel/build-utils": "12.1.0",
+    "@vercel/build-utils": "12.1.2",
     "cross-env": "7.0.3",
     "execa": "^1.0.0",
     "fs-extra": "11.1.1",

package/vc_init.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 import os
 import site
@@ -7,9 +8,17 @@ import json
 import inspect
 import threading
 import asyncio
+import http
+import time
 from importlib import util
-from http.server import BaseHTTPRequestHandler
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 import socket
+import functools
+import logging
+import builtins
+from typing import Callable, Literal
+import contextvars
+import io
 
 _here = os.path.dirname(__file__)
 _vendor_rel = '__VC_HANDLER_VENDOR_DIR'
@@ -53,72 +62,69 @@ def format_headers(headers, decode=False):
         keyToList[key].append(value)
     return keyToList
 
-if 'VERCEL_IPC_PATH' in os.environ:
-    from http.server import ThreadingHTTPServer
-    import http
-    import time
-    import contextvars
-    import functools
-    import builtins
-    import logging
+# Custom logging handler so logs are properly categorized
+class VCLogHandler(logging.Handler):
+    def __init__(self, send_message: Callable[[dict], None], context_getter: Callable[[], dict] | None = None):
+        super().__init__()
+        self._send_message = send_message
+        self._context_getter = context_getter
 
-    start_time = time.time()
-    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    sock.connect(os.getenv("VERCEL_IPC_PATH", ""))
+    def emit(self, record):
+        try:
+            message = record.getMessage()
+        except Exception:
+            try:
+                message = f"{record.msg}"
+            except Exception:
+                message = ""
+
+        if record.levelno >= logging.CRITICAL:
+            level = "fatal"
+        elif record.levelno >= logging.ERROR:
+            level = "error"
+        elif record.levelno >= logging.WARNING:
+            level = "warn"
+        elif record.levelno >= logging.INFO:
+            level = "info"
+        else:
+            level = "debug"
 
-    send_message = lambda message: sock.sendall((json.dumps(message) + '\0').encode())
-    storage = contextvars.ContextVar('storage', default=None)
+        ctx = None
+        try:
+            ctx = self._context_getter() if self._context_getter is not None else None
+        except Exception:
+            ctx = None
 
-    # Override urlopen from urllib3 (& requests) to send Request Metrics
-    try:
-        import urllib3
-        from urllib.parse import urlparse
+        if ctx is not None:
+            try:
+                self._send_message({
+                    "type": "log",
+                    "payload": {
+                        "context": {
+                            "invocationId": ctx['invocationId'],
+                            "requestId": ctx['requestId'],
+                        },
+                        "message": base64.b64encode(message.encode()).decode(),
+                        "level": level,
+                    }
+                })
+            except Exception:
+                pass
+        else:
+            try:
+                sys.stdout.write(message + "\n")
+            except Exception:
+                pass
 
-        def timed_request(func):
-            fetchId = 0
-            @functools.wraps(func)
-            def wrapper(self, method, url, *args, **kwargs):
-                nonlocal fetchId
-                fetchId += 1
-                start_time = int(time.time() * 1000)
-                result = func(self, method, url, *args, **kwargs)
-                elapsed_time = int(time.time() * 1000) - start_time
-                parsed_url = urlparse(url)
-                context = storage.get()
-                if context is not None:
-                    send_message({
-                        "type": "metric",
-                        "payload": {
-                            "context": {
-                                "invocationId": context['invocationId'],
-                                "requestId": context['requestId'],
-                            },
-                            "type": "fetch-metric",
-                            "payload": {
-                                "pathname": parsed_url.path,
-                                "search": parsed_url.query,
-                                "start": start_time,
-                                "duration": elapsed_time,
-                                "host": parsed_url.hostname or self.host,
-                                "statusCode": result.status,
-                                "method": method,
-                                "id": fetchId
-                            }
-                        }
-                    })
-                return result
-            return wrapper
-        urllib3.connectionpool.HTTPConnectionPool.urlopen = timed_request(urllib3.connectionpool.HTTPConnectionPool.urlopen)
-    except:
-        pass
 
+def setup_logging(send_message: Callable[[dict], None], storage: contextvars.ContextVar[dict | None]):
     # Override sys.stdout and sys.stderr to map logs to the correct request
     class StreamWrapper:
-        def __init__(self, stream, stream_name):
+        def __init__(self, stream: io.TextIOBase, stream_name: Literal["stdout", "stderr"]):
             self.stream = stream
             self.stream_name = stream_name
 
-        def write(self, message):
+        def write(self, message: str):
             context = storage.get()
             if context is not None:
                 send_message({
@@ -141,19 +147,15 @@ if 'VERCEL_IPC_PATH' in os.environ:
     sys.stdout = StreamWrapper(sys.stdout, "stdout")
     sys.stderr = StreamWrapper(sys.stderr, "stderr")
 
-    # Override the global print to log to stdout
-    def print_wrapper(func):
+    # Wrap top-level logging helpers to emit structured logs when a request
+    # context is available; otherwise fall back to the original behavior.
+    def logging_wrapper(func: Callable[..., None], level: str = "info") -> Callable[..., None]:
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            sys.stdout.write(' '.join(map(str, args)) + '\n')
-        return wrapper
-    builtins.print = print_wrapper(builtins.print)
-
-    # Override logging to maps logs to the correct request
-    def logging_wrapper(func, level="info"):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            context = storage.get()
+            try:
+                context = storage.get()
+            except Exception:
+                context = None
             if context is not None:
                 send_message({
                     "type": "log",
@@ -170,12 +172,77 @@ if 'VERCEL_IPC_PATH' in os.environ:
                 func(*args, **kwargs)
         return wrapper
 
-    logging.basicConfig(level=logging.INFO)
-    logging.debug = logging_wrapper(logging.debug)
-    logging.info = logging_wrapper(logging.info)
+    logging.basicConfig(level=logging.INFO, handlers=[VCLogHandler(send_message, storage.get)], force=True)
+    logging.debug = logging_wrapper(logging.debug, "debug")
+    logging.info = logging_wrapper(logging.info, "info")
     logging.warning = logging_wrapper(logging.warning, "warn")
     logging.error = logging_wrapper(logging.error, "error")
-    logging.critical = logging_wrapper(logging.critical, "error")
+    logging.fatal = logging_wrapper(logging.fatal, "fatal")
+    logging.critical = logging_wrapper(logging.critical, "fatal")
+
+    # Ensure built-in print funnels through stdout wrapper so prints are
+    # attributed to the current request context.
+    def print_wrapper(func: Callable[..., None]) -> Callable[..., None]:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            sys.stdout.write(' '.join(map(str, args)) + '\n')
+        return wrapper
+
+    builtins.print = print_wrapper(builtins.print)
+
+
+if 'VERCEL_IPC_PATH' in os.environ:
+    start_time = time.time()
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.connect(os.getenv("VERCEL_IPC_PATH", ""))
+
+    send_message = lambda message: sock.sendall((json.dumps(message) + '\0').encode())
+    storage = contextvars.ContextVar('storage', default=None)
+
+    # Override urlopen from urllib3 (& requests) to send Request Metrics
+    try:
+        import urllib3
+        from urllib.parse import urlparse
+
+        def timed_request(func):
+            fetchId = 0
+            @functools.wraps(func)
+            def wrapper(self, method, url, *args, **kwargs):
+                nonlocal fetchId
+                fetchId += 1
+                start_time = int(time.time() * 1000)
+                result = func(self, method, url, *args, **kwargs)
+                elapsed_time = int(time.time() * 1000) - start_time
+                parsed_url = urlparse(url)
+                context = storage.get()
+                if context is not None:
+                    send_message({
+                        "type": "metric",
+                        "payload": {
+                            "context": {
+                                "invocationId": context['invocationId'],
+                                "requestId": context['requestId'],
+                            },
+                            "type": "fetch-metric",
+                            "payload": {
+                                "pathname": parsed_url.path,
+                                "search": parsed_url.query,
+                                "start": start_time,
+                                "duration": elapsed_time,
+                                "host": parsed_url.hostname or self.host,
+                                "statusCode": result.status,
+                                "method": method,
+                                "id": fetchId
+                            }
+                        }
+                    })
+                return result
+            return wrapper
+        urllib3.connectionpool.HTTPConnectionPool.urlopen = timed_request(urllib3.connectionpool.HTTPConnectionPool.urlopen)
+    except:
+        pass
+
+    setup_logging(send_message, storage)
 
     class BaseHandler(BaseHTTPRequestHandler):
         # Re-implementation of BaseHTTPRequestHandler's log_message method to
@@ -367,6 +434,8 @@ if 'VERCEL_IPC_PATH' in os.environ:
 
                     # Event to signal that the response has been fully sent
                     response_done = threading.Event()
+                    # Event to signal the ASGI app has fully completed (incl. background tasks)
+                    app_done = threading.Event()
 
                     # Propagate request context to background thread for logging & metrics
                     request_context = storage.get()
@@ -421,6 +490,8 @@ if 'VERCEL_IPC_PATH' in os.environ:
                                 # Run ASGI app (includes background tasks)
                                 asgi_instance = app(scope, receive, send)
                                 await asgi_instance
+                                # Mark app completion when the ASGI callable returns
+                                app_done.set()
 
                             asyncio.run(runner())
                         except Exception:
@@ -437,10 +508,9 @@ if 'VERCEL_IPC_PATH' in os.environ:
                                 pass
                         finally:
                             # Always unblock the waiting thread to avoid hangs
-                            try:
-                                response_done.set()
-                            except Exception:
-                                pass
+                            response_done.set()
+                            # Ensure app completion is always signaled
+                            app_done.set()
                             if token is not None:
                                 storage.reset(token)
 
@@ -450,6 +520,8 @@ if 'VERCEL_IPC_PATH' in os.environ:
 
                     # Wait until final body chunk has been flushed to client
                     response_done.wait()
+                    # Also wait until the ASGI app finishes (includes background tasks)
+                    app_done.wait()
 
     if 'Handler' in locals():
         server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)