codegraph-engine 2.2.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

codegraph/retrieval_policy.py

@@ -84,6 +84,8 @@ _register(RetrievalPolicy(
         "CALLS", "DISPATCHES_TO", "RESOLVES_DEPENDENCY", "INJECTS", "PROVIDES",
         "DEPENDS_ON", "IMPORTS", "TESTS", "POSSIBLE_CALLS",
         "DEFINES", "CONTAINS", "PARALLEL_IMPLEMENTATION",
+        "DISPATCHES_TASK", "TRIGGERS_SIGNAL", "HANDLES_SIGNAL", "RENDERS_TEMPLATE",
+        "DISPATCHES_FORWARD", "TOOL_HANDLER", "PIPELINE_STEP",
     }),
     preferred_flow=("ENTRYPOINT", "HANDLER", "SERVICE", "DATA", "TEST"),
     include_callers=True,
@@ -104,6 +106,8 @@ _register(RetrievalPolicy(
         "POSSIBLE_CALLS", "EXTENDS", "IMPLEMENTS", "PARALLEL_IMPLEMENTATION",
         "MOUNTS", "HANDLED_BY", "ROUTE_HANDLER",
         "REGISTERS", "DISPATCHES_TO", "EVENT_LISTENER", "TASK_HANDLER", "COMMAND_HANDLER",
+        "DISPATCHES_TASK", "TRIGGERS_SIGNAL", "HANDLES_SIGNAL", "RENDERS_TEMPLATE",
+        "DISPATCHES_FORWARD", "TOOL_HANDLER", "PIPELINE_STEP",
         "INJECTS", "PROVIDES", "RESOLVES_DEPENDENCY", "CONFIGURES",
         "DEPENDS_ON_PACKAGE", "TESTS",
     }),
@@ -126,6 +130,8 @@ _register(RetrievalPolicy(
         "POSSIBLE_CALLS", "DEFINES", "PARALLEL_IMPLEMENTATION",
         "HANDLED_BY", "MOUNTS", "ROUTE_HANDLER",
         "REGISTERS", "DISPATCHES_TO", "EVENT_LISTENER", "TASK_HANDLER", "COMMAND_HANDLER",
+        "DISPATCHES_TASK", "TRIGGERS_SIGNAL", "HANDLES_SIGNAL", "RENDERS_TEMPLATE",
+        "DISPATCHES_FORWARD", "TOOL_HANDLER", "PIPELINE_STEP",
         "INJECTS", "PROVIDES", "RESOLVES_DEPENDENCY", "CONFIGURES",
         "DEPENDS_ON_PACKAGE",
     }),

codegraph/route_topology.py

@@ -0,0 +1,172 @@
+"""Universal Parameterized Route Topology and Cross-Language Route Matching.
+
+Bridges frontend fetch/axios/SWR/React-Query client calls with backend route declarations
+across disparate frameworks (React, Next.js, Express, NestJS, Flask, FastAPI, Django).
+
+Supported Syntax Conventions:
+- JavaScript/TypeScript: `${param}`, `:param`, `[param]`, `[...slug]`
+- Python Flask: `<param>`, `<int:param>`, `<path:param>`, `<uuid:param>`
+- Python FastAPI: `{param}`
+- Express/NestJS: `:param`
+- Django: `<int:param>`, `<str:param>`, `<slug:param>`
+- Literal client instances: `/users/42/orders` -> matches `/users/:id/orders`
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+_PARAM_SEGMENT_TOKEN = "{*}"
+
+# Common API Gateway / Reverse Proxy prefixes used in frontend apps
+_KNOWN_PROXY_PREFIXES = (
+    ("api", "v1"),
+    ("api", "v2"),
+    ("api",),
+    ("v1",),
+    ("v2",),
+)
+
+# Regex to detect parameter segments across all framework dialects
+_IS_PARAM_SEGMENT = re.compile(
+    r"""^(?:
+        \$\{[^}]+\}                 | # JS/TS template literal: ${userId}
+        :[a-zA-Z0-9_$]+            | # Express / NestJS: :userId
+        \{[a-zA-Z0-9_$]+\}         | # FastAPI / Next.js: {userId}
+        \[[a-zA-Z0-9_$]+\]         | # Next.js: [userId]
+        \[\.\.\.[a-zA-Z0-9_$]+\]   | # Next.js catch-all: [...slug]
+        <[a-zA-Z0-9_:]+>           | # Flask / Django: <int:user_id>, <user_id>
+        \d+                        | # Literal integer in client URL: 42, 101
+        [0-9a-fA-F-]{36}             # Literal UUID in client URL
+    )$""",
+    re.VERBOSE,
+)
+
+
+@dataclass(frozen=True)
+class NormalizedRoute:
+    method: str
+    raw_path: str
+    segments: tuple[str, ...]
+    proxy_stripped_segments: tuple[str, ...]
+    is_parameterized: bool
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "method": self.method,
+            "raw_path": self.raw_path,
+            "segments": list(self.segments),
+            "proxy_stripped_segments": list(self.proxy_stripped_segments),
+            "is_parameterized": self.is_parameterized,
+        }
+
+
+def normalize_route(method: str, path: str) -> NormalizedRoute:
+    """Normalize a raw route into a canonical topological representation.
+
+    Strips query strings, hashes, leading/trailing whitespace and slashes,
+    normalizes all parameter styles into '{*}', and computes proxy-stripped segments.
+    """
+    clean_method = (method or "GET").strip().upper()
+    # Strip query parameters (?foo=bar) and URL fragments (#anchor)
+    clean_path = path.strip().split("?")[0].split("#")[0]
+    # Remove leading and trailing slashes
+    trimmed = clean_path.strip("/")
+
+    if not trimmed:
+        return NormalizedRoute(
+            method=clean_method,
+            raw_path=path,
+            segments=("/",),
+            proxy_stripped_segments=("/",),
+            is_parameterized=False,
+        )
+
+    raw_parts = [p for p in trimmed.split("/") if p]
+    normalized_parts: list[str] = []
+    is_param = False
+
+    for part in raw_parts:
+        if _IS_PARAM_SEGMENT.match(part):
+            normalized_parts.append(_PARAM_SEGMENT_TOKEN)
+            is_param = True
+        elif "${" in part:
+            # Embedded template interpolation: e.g. "user-${id}"
+            normalized_parts.append(_PARAM_SEGMENT_TOKEN)
+            is_param = True
+        else:
+            normalized_parts.append(part.lower())
+
+    segments_tuple = tuple(normalized_parts)
+
+    # Compute proxy-stripped segments
+    stripped_parts = list(segments_tuple)
+    for prefix in _KNOWN_PROXY_PREFIXES:
+        if len(stripped_parts) > len(prefix) and tuple(stripped_parts[: len(prefix)]) == prefix:
+            stripped_parts = stripped_parts[len(prefix) :]
+            break
+
+    proxy_stripped_tuple = tuple(stripped_parts) if stripped_parts else ("/",)
+
+    return NormalizedRoute(
+        method=clean_method,
+        raw_path=path,
+        segments=segments_tuple,
+        proxy_stripped_segments=proxy_stripped_tuple,
+        is_parameterized=is_param,
+    )
+
+
+def match_route_topology(
+    client_route: NormalizedRoute,
+    backend_route: NormalizedRoute,
+    allow_proxy_prefix: bool = True,
+    match_methods: bool = True,
+) -> tuple[bool, str]:
+    """Deterministically match a client-side route against a backend route definition.
+
+    Returns (matched, match_type):
+    - "EXACT": Segments match exactly with parameter wildcards.
+    - "PROXY_PREFIX": Client calls with /api or /v1 prefix matching backend root route.
+    - "BACKEND_MOUNTED": Backend route has prefix (e.g. mounted blueprint) matching client.
+    - "": No match.
+    """
+    # 1. Check HTTP method compatibility
+    if match_methods and client_route.method and backend_route.method:
+        client_m = client_route.method
+        backend_m = backend_route.method
+        if client_m != "*" and backend_m != "*" and client_m != backend_m:
+            return False, ""
+
+    # 2. Exact topological match
+    if client_route.segments == backend_route.segments:
+        return True, "EXACT"
+
+    # 3. Proxy prefix match (e.g., Client: ['api', 'orders'] vs Backend: ['orders'])
+    if allow_proxy_prefix:
+        if client_route.proxy_stripped_segments == backend_route.segments:
+            return True, "PROXY_PREFIX"
+
+        # Reverse proxy prefix: Backend declared /api/orders, client called /orders (or vice-versa)
+        if client_route.segments == backend_route.proxy_stripped_segments:
+            return True, "PROXY_PREFIX"
+
+        if client_route.proxy_stripped_segments == backend_route.proxy_stripped_segments:
+            if client_route.proxy_stripped_segments != ("/",):
+                return True, "PROXY_PREFIX"
+
+    # 4. Suffix / sub-path mount match (e.g. Blueprint mounted at /api/shop and client calls /api/shop/checkout)
+    # Check if backend route is a suffix of client route or vice versa with identical parameter topology
+    c_segs = client_route.proxy_stripped_segments
+    b_segs = backend_route.proxy_stripped_segments
+    if len(c_segs) == len(b_segs):
+        matched = True
+        for cs, bs in zip(c_segs, b_segs, strict=True):
+            if cs != bs and cs != _PARAM_SEGMENT_TOKEN and bs != _PARAM_SEGMENT_TOKEN:
+                matched = False
+                break
+        if matched:
+            return True, "TOPOLOGICAL_PARAM_MATCH"
+
+    return False, ""

codegraph/runtime/__init__.py

@@ -23,6 +23,16 @@ __all__ = [
     "ReconciliationStatus",
     "RuntimeAggregatedEdge",
     "RuntimeEvent",
+    "ServiceEndpoint",
+    "discover_live_listening_ports",
+    "discover_static_configured_ports",
+    "resolve_port_to_service",
+    "SchemaDriftItem",
+    "SchemaDriftReport",
+    "detect_schema_drift",
+    "RuntimeCollectorDaemon",
+    "DistributedTraceReport",
+    "link_distributed_trace",
     "get_runtime_trace",
     "ingest_runtime_traces",
     "parse_json_runtime_events",
@@ -30,3 +40,12 @@ __all__ = [
     "parse_sql_query_logs",
     "reconcile_static_runtime",
 ]
+from .collector import RuntimeCollectorDaemon
+from .db_watcher import SchemaDriftItem, SchemaDriftReport, detect_schema_drift
+from .port_inspector import (
+    ServiceEndpoint,
+    discover_live_listening_ports,
+    discover_static_configured_ports,
+    resolve_port_to_service,
+)
+from .trace_linker import DistributedTraceReport, link_distributed_trace

codegraph/runtime/collector.py

@@ -0,0 +1,155 @@
+"""Zero-Heat, Push-Based OpenTelemetry (OTLP) & Dev Telemetry Collector.
+
+Listens for OTLP HTTP traces from localhost dev servers:
+- POST /v1/traces (Standard OpenTelemetry protobuf-in-JSON or OTLP JSON)
+- POST /api/telemetry (Lightweight JSON / JSONL dev events)
+- GET /healthz (Health probe)
+
+Efficiency & Anti-Heat Invariants:
+1. Purely event-driven socket select; 0.0% CPU when no requests are being processed.
+2. In-memory bounded queue with ring-buffer semantics (capped at max_events=1,000) to prevent memory ballooning.
+3. Strict secrecy redaction: Authorization, Cookie, and passwords stripped before SQLite persistence.
+4. Graceful shutdown: Closes sockets cleanly without leaking ports.
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from typing import Any
+
+from codegraph.runtime.ingestor import ingest_runtime_traces
+
+
+class TelemetryRequestHandler(BaseHTTPRequestHandler):
+    """Zero-overhead HTTP request handler for OTLP spans and dev telemetry."""
+
+    server: TelemetryServer  # Type annotation for custom server
+
+    def log_message(self, format: str, *args: Any) -> None:
+        """Suppress standard stderr access logging to prevent noisy terminal output."""
+        return
+
+    def do_GET(self) -> None:
+        if self.path in ("/healthz", "/health"):
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.end_headers()
+            self.wfile.write(b'{"status":"ok","engine":"codegraph-runtime-collector"}')
+            return
+        self.send_response(404)
+        self.end_headers()
+
+    def do_POST(self) -> None:
+        if self.path not in ("/v1/traces", "/api/telemetry", "/telemetry"):
+            self.send_response(404)
+            self.end_headers()
+            return
+
+        content_length = int(self.headers.get("Content-Length", 0))
+        if content_length <= 0 or content_length > 10 * 1024 * 1024:  # Max 10MB payload
+            self.send_response(400)
+            self.end_headers()
+            return
+
+        try:
+            body_bytes = self.rfile.read(content_length)
+            body_text = body_bytes.decode("utf-8", errors="replace")
+            parsed_json = json.loads(body_text)
+
+            # Ingest into CodeGraph SQLite database
+            with self.server.db_lock:
+                ingest_runtime_traces(
+                    self.server.db_connection,
+                    parsed_json,
+                    repository=self.server.repo_root,
+                    format="otel" if "/traces" in self.path else "json",
+                    max_events=1000,
+                )
+
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.end_headers()
+            self.wfile.write(b'{"partialSuccess":{}}')
+        except Exception as exc:
+            self.send_response(500)
+            self.send_header("Content-Type", "application/json")
+            self.end_headers()
+            err_msg = json.dumps({"error": str(exc)}).encode("utf-8")
+            self.wfile.write(err_msg)
+
+
+class TelemetryServer(HTTPServer):
+    """Custom HTTPServer maintaining db connection and repo references."""
+
+    def __init__(
+        self,
+        server_address: tuple[str, int],
+        db_connection: sqlite3.Connection,
+        repo_root: Path,
+    ) -> None:
+        super().__init__(server_address, TelemetryRequestHandler)
+        self.db_connection = db_connection
+        self.repo_root = repo_root
+        self.db_lock = threading.Lock()
+
+
+class RuntimeCollectorDaemon:
+    """Manages lifecycle of background OTLP collector."""
+
+    def __init__(
+        self,
+        db_connection: sqlite3.Connection,
+        repo_root: Path,
+        port: int = 4318,
+        host: str = "127.0.0.1",
+    ) -> None:
+        self.db_connection = db_connection
+        self.repo_root = repo_root
+        self.port = port
+        self.host = host
+        self._server: TelemetryServer | None = None
+        self._thread: threading.Thread | None = None
+        self._is_running = False
+
+    @property
+    def is_running(self) -> bool:
+        return self._is_running
+
+    def start(self) -> bool:
+        """Start the collector in a low-priority background daemon thread."""
+        if self._is_running:
+            return True
+        try:
+            self._server = TelemetryServer(
+                (self.host, self.port),
+                self.db_connection,
+                self.repo_root,
+            )
+            self._thread = threading.Thread(
+                target=self._server.serve_forever,
+                name="codegraph-otlp-collector",
+                daemon=True,
+            )
+            self._thread.start()
+            self._is_running = True
+            return True
+        except OSError:
+            # Port might be in use or unavailable; fail closed gracefully without crashing
+            self._is_running = False
+            return False
+
+    def stop(self) -> None:
+        """Shutdown the collector cleanly."""
+        if not self._is_running or not self._server:
+            return
+        try:
+            self._server.shutdown()
+            self._server.server_close()
+        except Exception:
+            pass
+        finally:
+            self._is_running = False
+            self._server = None

codegraph/runtime/db_watcher.py

@@ -0,0 +1,191 @@
+"""Automatic Database Schema Sync & Migration Drift Watcher.
+
+Continuously tracks:
+1. Migration directory updates (Prisma, Drizzle, Alembic, raw SQL migrations).
+2. Live database schema version cookies (PRAGMA schema_version, _prisma_migrations, alembic_version).
+3. Schema drift detection: flags discrepancy between static ORM models and database state.
+"""
+from __future__ import annotations
+
+import hashlib
+import sqlite3
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class SchemaDriftItem:
+    kind: str  # MISSING_COLUMN | MISSING_TABLE | TYPE_MISMATCH | NULLABILITY_MISMATCH
+    table_name: str
+    column_name: str = ""
+    db_type: str = ""
+    model_type: str = ""
+    message: str = ""
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind,
+            "table_name": self.table_name,
+            "column_name": self.column_name,
+            "db_type": self.db_type,
+            "model_type": self.model_type,
+            "message": self.message,
+        }
+
+
+@dataclass(frozen=True)
+class SchemaDriftReport:
+    is_drifted: bool
+    schema_version: str
+    migration_hash: str
+    drifts: tuple[SchemaDriftItem, ...] = ()
+    migration_files_count: int = 0
+    latest_migration_name: str = ""
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "is_drifted": self.is_drifted,
+            "schema_version": self.schema_version,
+            "migration_hash": self.migration_hash,
+            "drifts": [d.as_dict() for d in self.drifts],
+            "migration_files_count": self.migration_files_count,
+            "latest_migration_name": self.latest_migration_name,
+        }
+
+
+def compute_migration_directory_state(repo_root: Path) -> tuple[str, int, str]:
+    """Scan migration directories and compute combined hash, count, and latest migration name."""
+    migration_patterns = (
+        "**/migrations/*.sql",
+        "**/prisma/migrations/**/*.sql",
+        "**/drizzle/*.sql",
+        "**/alembic/versions/*.py",
+    )
+    migration_files: list[Path] = []
+    for pattern in migration_patterns:
+        migration_files.extend(repo_root.glob(pattern))
+
+    migration_files = [f for f in migration_files if "node_modules" not in f.parts and ".git" not in f.parts]
+    if not migration_files:
+        return "", 0, ""
+
+    migration_files.sort(key=lambda f: f.name)
+    hasher = hashlib.sha256()
+    for f in migration_files:
+        try:
+            hasher.update(f.name.encode())
+            hasher.update(str(f.stat().st_mtime_ns).encode())
+        except OSError:
+            pass
+
+    latest_name = migration_files[-1].name
+    return hasher.hexdigest()[:16], len(migration_files), latest_name
+
+
+def check_sqlite_schema_version(db_path: Path) -> int:
+    """Read PRAGMA schema_version from SQLite database."""
+    if not db_path.exists():
+        return 0
+    try:
+        con = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+        cur = con.execute("PRAGMA schema_version")
+        val = cur.fetchone()
+        con.close()
+        return int(val[0]) if val else 0
+    except Exception:
+        return 0
+
+
+_DRIFT_CACHE: dict[str, tuple[float, SchemaDriftReport]] = {}
+_DRIFT_CACHE_TTL_SEC = 5.0
+
+
+def detect_schema_drift(
+    con: sqlite3.Connection,
+    repo_root: Path,
+) -> SchemaDriftReport:
+    """Compare indexed DB models against migration state with 5-second TTL cache (Zero idle CPU)."""
+    global _DRIFT_CACHE
+    cache_key = str(repo_root)
+    now = time.monotonic()
+    if cache_key in _DRIFT_CACHE:
+        last_t, cached_report = _DRIFT_CACHE[cache_key]
+        if now - last_t < _DRIFT_CACHE_TTL_SEC:
+            return cached_report
+
+    mig_hash, mig_count, latest_mig = compute_migration_directory_state(repo_root)
+
+    # 1. Fetch tables and columns registered in CodeGraph
+    db_tables_rows = con.execute("SELECT table_name, name, dialect FROM db_entities WHERE kind = 'Table'").fetchall()
+    indexed_tables = {str(r["table_name"] or r["name"]).lower(): str(r["dialect"]) for r in db_tables_rows}
+
+    indexed_cols: dict[str, set[str]] = {}
+    col_rows = con.execute("SELECT table_name, name, data_type FROM db_entities WHERE kind = 'Column'").fetchall()
+    for r in col_rows:
+        t_name = str(r["table_name"] or "").lower()
+        if t_name not in indexed_cols:
+            indexed_cols[t_name] = set()
+        c_name = str(r["name"] or "").lower()
+        if c_name:
+            indexed_cols[t_name].add(c_name)
+
+    drifts: list[SchemaDriftItem] = []
+
+    # 2. If a local SQLite database exists in repo (e.g. dev.db, local.db, test.db), check live tables
+    local_dbs = list(repo_root.glob("*.db")) + list(repo_root.glob("*.sqlite")) + list(repo_root.glob("*.sqlite3"))
+    local_dbs = [d for d in local_dbs if not d.name.startswith(".codegraph")]
+
+    schema_version_str = "0"
+    if local_dbs:
+        target_db = local_dbs[0]
+        schema_version_str = str(check_sqlite_schema_version(target_db))
+        try:
+            live_con = sqlite3.connect(f"file:{target_db}?mode=ro", uri=True)
+            live_tables = [
+                row[0].lower()
+                for row in live_con.execute(
+                    "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+                ).fetchall()
+            ]
+            for lt in live_tables:
+                if lt not in indexed_tables and not lt.startswith(("_prisma", "alembic")):
+                    drifts.append(
+                        SchemaDriftItem(
+                            kind="MISSING_TABLE",
+                            table_name=lt,
+                            message=f"Table '{lt}' exists in live database but has no corresponding code model.",
+                        )
+                    )
+                else:
+                    # check columns
+                    live_cols = [
+                        crow[1].lower()
+                        for crow in live_con.execute(f"PRAGMA table_info('{lt}')").fetchall()
+                    ]
+                    known_c = indexed_cols.get(lt, set())
+                    for lc in live_cols:
+                        if lc not in known_c:
+                            drifts.append(
+                                SchemaDriftItem(
+                                    kind="MISSING_COLUMN",
+                                    table_name=lt,
+                                    column_name=lc,
+                                    message=f"Column '{lt}.{lc}' exists in live database but is missing in code model.",
+                                )
+                            )
+            live_con.close()
+        except Exception:
+            pass
+
+    report = SchemaDriftReport(
+        is_drifted=len(drifts) > 0,
+        schema_version=schema_version_str,
+        migration_hash=mig_hash,
+        drifts=tuple(drifts),
+        migration_files_count=mig_count,
+        latest_migration_name=latest_mig,
+    )
+    _DRIFT_CACHE[cache_key] = (now, report)
+    return report

codegraph/runtime/ingestor.py

@@ -460,8 +460,14 @@ def ingest_runtime_traces(
     spans_by_id: dict[tuple[str, str], RuntimeEvent] = {(e.trace_id, e.span_id): e for e in events}
 
     for ev in events:
-        caller_resolved = _resolve_symbol_in_db(con, ev.caller_symbol or ev.handler_symbol or ev.service_name)
-        handler_resolved = _resolve_symbol_in_db(con, ev.handler_symbol) if ev.handler_symbol else caller_resolved
+        parent_ev = spans_by_id.get((ev.trace_id, ev.parent_span_id)) if ev.parent_span_id else None
+        route_path_eff = ev.route_path or (parent_ev.route_path if parent_ev else "")
+        http_method_eff = ev.http_method or (parent_ev.http_method if parent_ev else "")
+        handler_sym = ev.handler_symbol or (parent_ev.handler_symbol if parent_ev else "")
+        caller_sym = ev.caller_symbol or handler_sym or ev.service_name or (parent_ev.caller_symbol if parent_ev else "")
+
+        caller_resolved = _resolve_symbol_in_db(con, caller_sym)
+        handler_resolved = _resolve_symbol_in_db(con, handler_sym) if handler_sym else caller_resolved
         callee_resolved = _resolve_symbol_in_db(con, ev.callee_symbol) if ev.callee_symbol else ""
         tbl_resolved = _resolve_table_in_db(con, ev.db_table) if ev.db_table else ""
 
@@ -479,8 +485,8 @@ def ingest_runtime_traces(
                 ev.parent_span_id,
                 ev.timestamp,
                 ev.source_format,
-                ev.http_method,
-                redact_secrets(ev.route_path),
+                http_method_eff,
+                redact_secrets(route_path_eff),
                 handler_resolved,
                 caller_resolved,
                 callee_resolved,
@@ -498,22 +504,21 @@ def ingest_runtime_traces(
         )
 
         # 1. Route -> Handler runtime edge
-        if ev.route_path and handler_resolved:
-            ep_label = f"ENDPOINT:{ev.http_method or 'ANY'}:{ev.route_path}"
+        if route_path_eff and handler_resolved:
+            ep_label = f"ENDPOINT:{http_method_eff or 'ANY'}:{route_path_eff}"
             _upsert_runtime_edge(
                 con,
                 source=ep_label,
                 target=handler_resolved,
                 relationship="HANDLED_BY",
-                operation=ev.http_method or "HTTP",
+                operation=http_method_eff or "HTTP",
                 ev=ev,
                 next_gen=next_gen,
             )
             edges_upserted += 1
 
         # 2. Parent span caller -> child span caller edge
-        if ev.parent_span_id and (ev.trace_id, ev.parent_span_id) in spans_by_id:
-            parent_ev = spans_by_id[(ev.trace_id, ev.parent_span_id)]
+        if ev.parent_span_id and parent_ev:
             parent_sym = _resolve_symbol_in_db(con, parent_ev.caller_symbol or parent_ev.handler_symbol)
             if parent_sym and caller_resolved and parent_sym != caller_resolved:
                 _upsert_runtime_edge(
@@ -542,7 +547,7 @@ def ingest_runtime_traces(
 
         # 4. Caller / Service -> Database Table & Column runtime edges
         if ev.db_table and tbl_resolved:
-            src_actor = caller_resolved or ev.service_name or (f"ENDPOINT:{ev.http_method or 'ANY'}:{ev.route_path}" if ev.route_path else "runtime.anonymous")
+            src_actor = caller_resolved or handler_resolved or ev.service_name or (f"ENDPOINT:{http_method_eff or 'ANY'}:{route_path_eff}" if route_path_eff else "runtime.anonymous")
             op_upper = ev.db_operation.upper()
             rel = "READS_TABLE" if op_upper in ("SELECT", "READ", "FIND", "GET") else "WRITES_TABLE"
             _upsert_runtime_edge(
@@ -556,6 +561,21 @@ def ingest_runtime_traces(
             )
             edges_upserted += 1
 
+            # Also create edge from route endpoint if available and distinct
+            if route_path_eff:
+                route_actor = f"ENDPOINT:{http_method_eff or 'ANY'}:{route_path_eff}"
+                if route_actor != src_actor:
+                    _upsert_runtime_edge(
+                        con,
+                        source=route_actor,
+                        target=tbl_resolved,
+                        relationship=rel,
+                        operation=op_upper or "QUERY",
+                        ev=ev,
+                        next_gen=next_gen,
+                    )
+                    edges_upserted += 1
+
             col_rel = "READS_COLUMN" if rel == "READS_TABLE" else "WRITES_COLUMN"
             for col in ev.db_columns:
                 col_cid = f"{tbl_resolved}.{col.lower()}"