edgeone 1.6.4 → 1.6.5

package/edgeone-dist/pages/templates/agent-python/adapter.py

@@ -13,25 +13,16 @@ from typing import Any, Callable
 from urllib.parse import parse_qs
 import httpx
 
-# --- Observability bootstrap (deferred for fast cold start) ---
-# Moved to _ensure_observability() — called by background preload thread
-# or lazily on first request. This avoids blocking startup with OTel imports.
-_obs_initialized = False
-
-
-def _ensure_observability():
-    """Initialize observability (idempotent). Called by preload thread or first request."""
-    global _obs_initialized
-    if _obs_initialized:
-        return
-    _obs_initialized = True
-    _obs_entries_raw = os.environ.get("AGENT_OBSERVABILITY_ENTRIES", "")
-    if _obs_entries_raw:
-        try:
-            from _platform._observability import setup as _obs_setup
-            _obs_setup(json.loads(_obs_entries_raw))
-        except Exception as _obs_err:
-            print(f"[observability] setup failed: {_obs_err}", file=sys.stderr, flush=True)
+# --- Observability bootstrap (must run before user code imports) ---
+# Reads entry names from AGENT_OBSERVABILITY_ENTRIES env var (set by main.py
+# or the dev runner). Idempotent — safe to call multiple times.
+_obs_entries_raw = os.environ.get("AGENT_OBSERVABILITY_ENTRIES", "")
+if _obs_entries_raw:
+    try:
+        from _platform._observability import setup as _obs_setup
+        _obs_setup(json.loads(_obs_entries_raw))
+    except Exception as _obs_err:
+        print(f"[observability] setup failed: {_obs_err}", file=sys.stderr, flush=True)
 
 from .store import InMemoryStore, BlobBackedStore
 from .runtime import AgentRuntime, RouteEntry
@@ -464,58 +455,22 @@ _registry: dict[str, RouteEntry] = {}
 # 加载失败的路由：route_path → 失败原因。404 响应时回显，避免静默 404 难以排查。
 _failed_routes: dict[str, str] = {}
 
-
-# --- Lazy route loading for fast cold start ---
-# Routes are NOT imported at startup. Instead, each route module is loaded
-# on first access (or by the background preload thread). This avoids blocking
-# the health check with heavy imports (langchain, langgraph, pydantic, etc.).
-
-class _LazyRouteEntry:
-    """Lazy-loading wrapper for RouteEntry. Defers importlib.import_module() to first access."""
-
-    __slots__ = ('_module_path', '_is_index', '_handler', '_loaded', '_load_error')
-
-    def __init__(self, module_path: str, is_index: bool):
-        self._module_path = module_path
-        self._is_index = is_index
-        self._handler = None
-        self._loaded = False
-        self._load_error: str | None = None
-
-    @property
-    def handler(self):
-        if not self._loaded:
-            self._do_load()
-        if self._load_error:
-            raise ImportError(self._load_error)
-        return self._handler
-
-    @property
-    def is_index(self):
-        return self._is_index
-
-    @property
-    def module_path(self):
-        return self._module_path
-
-    def _do_load(self):
-        """Actually import the module and resolve the handler."""
-        try:
-            mod = importlib.import_module(self._module_path)
-            handler = getattr(mod, "handler", None)
-            if handler is None:
-                self._load_error = f"module '{self._module_path}' has no 'handler' function"
-            else:
-                self._handler = handler
-        except Exception as e:
-            self._load_error = f"failed to import '{self._module_path}': {e}"
-        self._loaded = True
-
-
 for route_path, info in _route_table_raw.items():
     module_path = info["module"]
     is_index = info.get("isIndex", False)
-    _registry[route_path] = _LazyRouteEntry(module_path, is_index)
+    try:
+        mod = importlib.import_module(module_path)
+        handler = getattr(mod, "handler", None)
+        if handler is None:
+            reason = f"module '{module_path}' has no 'handler' function"
+            print(f"[agent-python] WARNING: {reason}, skipping", file=sys.stderr, flush=True)
+            _failed_routes[route_path] = reason
+            continue
+        _registry[route_path] = RouteEntry(handler=handler, is_index=is_index, module_path=module_path)
+    except Exception as e:
+        reason = f"failed to import '{module_path}': {e}"
+        print(f"[agent-python] ERROR loading {module_path}: {e}", file=sys.stderr, flush=True)
+        _failed_routes[route_path] = reason
 
 _runtime = AgentRuntime(
     registry=_registry,
@@ -525,46 +480,13 @@ _runtime = AgentRuntime(
     failed_routes=_failed_routes,
 )
 
-print(f"[agent-python] Registered {len(_registry)} routes (lazy), timeout={_timeout}s", file=sys.stderr, flush=True)
-
-
-# --- Background preload thread ---
-# After uvicorn binds the port and health check passes, this thread
-# pre-imports all route modules in the background. If a request arrives
-# before preload completes, the lazy handler property will block and
-# import synchronously (no failure, just slower first request).
-
-import threading
-
-
-def _background_preload():
-    """Preload routes + observability in background after startup."""
-    import time
-    time.sleep(0.05)  # yield to let uvicorn finish port binding
-
-    # 1. Initialize observability first (lighter, needed for spans)
-    _ensure_observability()
-
-    # 2. Trigger lazy loading for all routes
-    for route_path, entry in _registry.items():
-        try:
-            _ = entry.handler
-        except Exception as e:
-            _failed_routes[route_path] = str(e)
-            print(f"[agent-python] ERROR loading {entry.module_path}: {e}", file=sys.stderr, flush=True)
-
-    loaded_count = sum(1 for e in _registry.values() if e._loaded and e._load_error is None)
-    if _failed_routes:
-        print(
-            f"[agent-python] Preload done: {loaded_count}/{len(_registry)} routes loaded, "
-            f"{len(_failed_routes)} failed: {', '.join(_failed_routes.keys())}",
-            file=sys.stderr, flush=True,
-        )
-    else:
-        print(f"[agent-python] Preload done: {loaded_count}/{len(_registry)} routes loaded", file=sys.stderr, flush=True)
-
-
-threading.Thread(target=_background_preload, daemon=True, name="agent-preload").start()
+print(f"[agent-python] Loaded {len(_registry)} routes, timeout={_timeout}s", file=sys.stderr, flush=True)
+if _failed_routes:
+    print(
+        f"[agent-python] WARNING: {len(_failed_routes)} route(s) failed to load: "
+        f"{', '.join(_failed_routes.keys())}",
+        file=sys.stderr, flush=True,
+    )
 
 
 # --- ASGI app ---
@@ -589,11 +511,6 @@ async def app(scope: dict, receive, send) -> None:
     if scope["type"] != "http":
         return
 
-    # Ensure observability is initialized before processing requests.
-    # Usually already done by background preload, but if a request arrives
-    # before preload completes, this ensures instrumentation is active.
-    _ensure_observability()
-
     # Read body
     body_parts = []
     while True:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edgeone",
-  "version": "1.6.4",
+  "version": "1.6.5",
   "description": "Command-line interface for TencentCloud Pages Functions",
   "bin": {
     "edgeone": "./edgeone-bin/edgeone.js"