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

codegraph/__init__.py

@@ -1,6 +1,6 @@
 """CodeGraph MCP: local, evidence-backed codebase intelligence."""
 
-__version__ = "2.1.8"
+__version__ = "2.2.1"
 from codegraph.errors import (
     CodeGraphError,
     ErrorCode,

codegraph/cli.py

@@ -434,6 +434,8 @@ def routes(
     framework: Annotated[str | None, typer.Option("--framework", "-f", help="Filter by framework (e.g. flask, fastapi)")] = None,
     method: Annotated[str | None, typer.Option("--method", "-m", help="Filter by HTTP method (e.g. GET, POST)")] = None,
     route_path: Annotated[str | None, typer.Option("--path", "-p", help="Filter by route path substring")] = None,
+    limit: Annotated[int | None, typer.Option("--limit", "-l", help="Maximum number of routes to return")] = None,
+    offset: Annotated[int, typer.Option("--offset", help="Number of routes to skip")] = 0,
     json_output: Annotated[bool, typer.Option("--json", help="Output raw JSON array")] = False,
 ) -> None:
     """List and inspect indexed framework routes."""
@@ -479,6 +481,11 @@ def routes(
             for r in rows
         ]
 
+        if limit is not None:
+            safe_offset = max(0, offset)
+            safe_limit = max(0, limit)
+            route_list = route_list[safe_offset : safe_offset + safe_limit]
+
         if json_output:
             typer.echo(json.dumps(route_list, indent=2))
         else:
@@ -597,19 +604,60 @@ def debug(
         )
 
 
-@app.command()
-def serve(
-    path: Annotated[Path | None, typer.Argument(help="Repository path (default: current directory)")] = None,
+@app.command(
+    "run",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
+)
+def run_cmd(
+    ctx: typer.Context,
+    command: Annotated[list[str] | None, typer.Argument(help="Development command and arguments to execute")] = None,
     repository: Annotated[Path | None, typer.Option("--repository", "-r", "--repo", help="Repository path")] = None,
-    profile: Annotated[str, typer.Option("--profile", help="Tool profile: core | minimal | developer | full")] = "full",
+    sample_rate: Annotated[float, typer.Option("--sample-rate", help="Sampling rate for trace capture (0.0..1.0)")] = 1.0,
+) -> None:
+    """Execute a development command or server with transparent runtime trace capture."""
+    full_cmd = (command or []) + ctx.args
+    if not full_cmd:
+        cli_echo("Error: Command cannot be empty. Usage: codegraph run <command> [args...]")
+        raise typer.Exit(code=1)
+
+    repo = _resolve_repo(None, repository)
+    from codegraph.runtime.runner import run_with_telemetry
+
+    exit_code = run_with_telemetry(full_cmd, repository=repo, sample_rate=sample_rate)
+    raise typer.Exit(code=exit_code)
+
+
+def _run_server(
+    path: Path | None,
+    repository: Path | None,
+    profile: str,
+    transport: str = "stdio",
+    host: str = "127.0.0.1",
+    port: int = 8765,
 ) -> None:
-    """Run the stdio MCP server (requires the optional mcp extra)."""
     repo = _resolve_repo(path, repository)
     from codegraph.mcp import create_server
     from codegraph.process_lifecycle import run_mcp_stdio_server
 
-    server = create_server(repo, profile=profile)
-    run_mcp_stdio_server(server, repo, profile=profile)
+    if transport.lower() == "sse":
+        server = create_server(repo, profile=profile, host=host, port=port)
+        server.run(transport="sse")
+    else:
+        server = create_server(repo, profile=profile)
+        run_mcp_stdio_server(server, repo, profile=profile)
+
+
+@app.command()
+def serve(
+    path: Annotated[Path | None, typer.Argument(help="Repository path (default: current directory)")] = None,
+    repository: Annotated[Path | None, typer.Option("--repository", "-r", "--repo", help="Repository path")] = None,
+    profile: Annotated[str, typer.Option("--profile", help="Tool profile: core | minimal | developer | full")] = "full",
+    transport: Annotated[str, typer.Option("--transport", "-t", help="MCP transport: stdio | sse")] = "stdio",
+    host: Annotated[str, typer.Option("--host", help="Host for SSE server")] = "127.0.0.1",
+    port: Annotated[int, typer.Option("--port", "-p", help="Port for SSE server")] = 8765,
+) -> None:
+    """Run the CodeGraph MCP server via stdio or SSE transport."""
+    _run_server(path, repository, profile, transport=transport, host=host, port=port)
 
 
 mcp_app = typer.Typer(help="MCP server commands.")
@@ -621,14 +669,12 @@ def mcp_serve(
     path: Annotated[Path | None, typer.Argument(help="Repository path (default: current directory)")] = None,
     repository: Annotated[Path | None, typer.Option("--repository", "-r", "--repo", help="Repository path")] = None,
     profile: Annotated[str, typer.Option("--profile", help="Tool profile: core | graph | minimal | developer | full")] = "full",
+    transport: Annotated[str, typer.Option("--transport", "-t", help="MCP transport: stdio | sse")] = "stdio",
+    host: Annotated[str, typer.Option("--host", help="Host for SSE server")] = "127.0.0.1",
+    port: Annotated[int, typer.Option("--port", "-p", help="Port for SSE server")] = 8765,
 ) -> None:
-    """Run the stdio MCP server (requires the optional mcp extra)."""
-    repo = _resolve_repo(path, repository)
-    from codegraph.mcp import create_server
-    from codegraph.process_lifecycle import run_mcp_stdio_server
-
-    server = create_server(repo, profile=profile)
-    run_mcp_stdio_server(server, repo, profile=profile)
+    """Run the CodeGraph MCP server via stdio or SSE transport."""
+    _run_server(path, repository, profile, transport=transport, host=host, port=port)
 
 
 def _execute_stop(

codegraph/context.py

@@ -594,6 +594,7 @@ def _get_context_impl(
             if path:
                 c = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
                 c.row_factory = sqlite3.Row
+                c.execute("PRAGMA busy_timeout = 15000")
                 try:
                     for query in queries:
                         for item in search(
@@ -629,6 +630,7 @@ def _get_context_impl(
                 if path:
                     c = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
                     c.row_factory = sqlite3.Row
+                    c.execute("PRAGMA busy_timeout = 15000")
                     try:
                         return c.execute(
                             "SELECT route_path, http_method, handler_name, file_path, line, endpoint_id FROM framework_routes"
@@ -665,6 +667,7 @@ def _get_context_impl(
                 if path:
                     c = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
                     c.row_factory = sqlite3.Row
+                    c.execute("PRAGMA busy_timeout = 15000")
                     try:
                         archs.append(get_architecture(c, repo))
                     finally:

codegraph/database/interrogation.py

@@ -748,6 +748,8 @@ def get_db_schema(
     schema: str | None = None,
     *,
     dialect: str | None = None,
+    limit: int | None = None,
+    offset: int = 0,
 ) -> dict[str, Any]:
     """Return the complete repository database schema overview with safe credential redaction."""
     if isinstance(repo_or_dialect, str) and not dialect:
@@ -800,21 +802,42 @@ def get_db_schema(
 
     dialects = sorted({t["dialect"] for t in tables if t.get("dialect")}) or ["UNKNOWN"]
 
-    return redact_payload({
+    safe_tables = tables
+    safe_models = models
+    safe_migrations = migrations
+    safe_cols = columns
+    safe_rels = rels
+
+    if limit is not None:
+        safe_offset = max(0, offset)
+        safe_limit = max(0, limit)
+        safe_tables = tables[safe_offset : safe_offset + safe_limit]
+        safe_models = models[safe_offset : safe_offset + safe_limit]
+        safe_migrations = migrations[safe_offset : safe_offset + safe_limit]
+        safe_cols = columns[: max(safe_limit * 5, 20)]
+        safe_rels = rels[: max(safe_limit * 5, 20)]
+
+    result_dict: dict[str, Any] = {
         "status": "ok",
         "dialects": dialects,
         "table_count": len(tables),
         "column_count": len(columns),
         "model_count": len(models),
         "migration_count": len(migrations),
-        "tables": tables,
-        "columns": columns,
-        "models": models,
-        "relationships": rels,
-        "migrations": migrations,
+        "tables": safe_tables,
+        "columns": safe_cols,
+        "models": safe_models,
+        "relationships": safe_rels,
+        "migrations": safe_migrations,
         "env_variables": env_vars,
         "database_credentials": "REDACTED",
-    })
+    }
+    if limit is not None:
+        result_dict["limit"] = safe_limit
+        result_dict["offset"] = safe_offset
+        result_dict["has_more"] = (safe_offset + len(safe_tables)) < len(tables)
+
+    return redact_payload(result_dict)
 
 
 def get_db_impact(

codegraph/freshness.py

@@ -235,30 +235,68 @@ def check_freshness(
     deleted: list[str] = []
     parse_failed: list[str] = []
 
-    try:
-        rows = con.execute("SELECT path, hash, status FROM files").fetchall()
-    except sqlite3.OperationalError:
-        rows = con.execute("SELECT path, hash, 'ok' AS status FROM files").fetchall()
-
-    for row in rows:
-        rel = str(row["path"])
-        if row["status"] == "parse_failed":
-            parse_failed.append(rel)
-            if rel not in modified:
-                modified.append(rel)
-        abs_path = repository / rel
-        if not abs_path.exists():
-            deleted.append(rel)
-        else:
+    # Fast path 1: Git commit diff (branch switch or commit advance)
+    git_diff_handled = False
+    if cur_commit and idx_commit and cur_commit != idx_commit:
+        diff_out = _run_git(repository, "diff", "--name-status", idx_commit, cur_commit)
+        if diff_out is not None:
+            git_diff_handled = True
+            for line in diff_out.splitlines():
+                parts = line.strip().split(maxsplit=1)
+                if len(parts) == 2:
+                    action, fpath = parts[0], parts[1]
+                    if action.startswith("D"):
+                        deleted.append(fpath)
+                    else:
+                        modified.append(fpath)
+
+    # Fast path 2: Git status when HEAD commit is unchanged
+    if not git_diff_handled and cur_commit and idx_commit and cur_commit == idx_commit:
+        status_out = _run_git(repository, "status", "--porcelain", "--untracked-files=no")
+        if status_out is not None and not status_out.strip():
+            # Working tree has zero tracked changes against HEAD
+            git_diff_handled = True
             try:
-                digest = hashlib.sha256(
-                    abs_path.read_text(encoding="utf-8", errors="replace").encode()
-                ).hexdigest()
-                if digest != row["hash"] and rel not in modified:
-                    modified.append(rel)
-            except OSError:
+                pf_rows = con.execute("SELECT path FROM files WHERE status='parse_failed'").fetchall()
+                for r in pf_rows:
+                    parse_failed.append(str(r[0]))
+                    modified.append(str(r[0]))
+            except sqlite3.OperationalError:
+                pass
+
+    if not git_diff_handled:
+        try:
+            rows = con.execute("SELECT path, hash, status, indexed_at FROM files").fetchall()
+        except sqlite3.OperationalError:
+            try:
+                rows = con.execute("SELECT path, hash, status, 0 AS indexed_at FROM files").fetchall()
+            except sqlite3.OperationalError:
+                rows = con.execute("SELECT path, hash, 'ok' AS status, 0 AS indexed_at FROM files").fetchall()
+
+        for row in rows:
+            rel = str(row["path"])
+            if row["status"] == "parse_failed":
+                parse_failed.append(rel)
                 if rel not in modified:
                     modified.append(rel)
+            abs_path = repository / rel
+            if not abs_path.exists():
+                deleted.append(rel)
+            else:
+                try:
+                    st = abs_path.stat()
+                    # Mtime check: skip reading & hashing files strictly older than indexing time
+                    idx_at = int(row["indexed_at"] or 0)
+                    if idx_at > 0 and int(st.st_mtime) < idx_at and row["status"] != "parse_failed":
+                        continue
+                    digest = hashlib.sha256(
+                        abs_path.read_text(encoding="utf-8", errors="replace").encode()
+                    ).hexdigest()
+                    if digest != row["hash"] and rel not in modified:
+                        modified.append(rel)
+                except OSError:
+                    if rel not in modified:
+                        modified.append(rel)
 
     changed = len(modified) + len(deleted)
     if changed == 0 and not parse_failed and (idx_commit == cur_commit or cur_commit is None):

codegraph/indexing/indexer.py

@@ -493,8 +493,11 @@ class Indexer:
         con = sqlite3.connect(self.db_path)
         con.row_factory = make_compat_row
         con.execute("PRAGMA journal_mode = WAL")
+        con.execute("PRAGMA synchronous = NORMAL")
         con.execute("PRAGMA foreign_keys = ON")
-        con.execute("PRAGMA busy_timeout = 5000")
+        con.execute("PRAGMA busy_timeout = 15000")
+        con.execute("PRAGMA cache_size = -64000")
+        con.execute("PRAGMA temp_store = MEMORY")
         self._ensure_schema(con)
         return con
 

codegraph/indexing/parser.py

@@ -597,29 +597,63 @@ class _PythonScopeVisitor(ast.NodeVisitor):
         doc = ast.get_docstring(node)
         c_hash = _normalized_body_hash(self.lines, node.lineno, end_line)
 
-        self.symbols.append(
-            Symbol(
-                id=canon_id,
-                canonical_id=canon_id,
-                name=node.name,
-                qualified_name=qname,
-                kind=kind,
-                language="python",
-                module=self.module,
-                path=self.file_path,
-                file_path=self.file_path,
-                scope=parent_scope,
-                signature=sig,
-                start_line=node.lineno,
-                end_line=end_line,
+        # Avoid duplicate canonical symbol IDs for @name.setter within the same class
+        is_setter = any(d.endswith(".setter") for d in decorators)
+        existing_prop = None
+        if is_setter and parent_kind == "class":
+            for s in self.symbols:
+                if s.canonical_id == canon_id and s.kind == "property":
+                    existing_prop = s
+                    break
+
+        if existing_prop is not None:
+            # Merge setter signature/span into the existing property symbol
+            idx = self.symbols.index(existing_prop)
+            self.symbols[idx] = Symbol(
+                id=existing_prop.id,
+                canonical_id=existing_prop.canonical_id,
+                name=existing_prop.name,
+                qualified_name=existing_prop.qualified_name,
+                kind="property",
+                language=existing_prop.language,
+                module=existing_prop.module,
+                path=existing_prop.path,
+                file_path=existing_prop.file_path,
+                scope=existing_prop.scope,
+                signature=f"{existing_prop.signature} | setter: {sig}" if existing_prop.signature else sig,
+                start_line=existing_prop.start_line,
+                end_line=max(existing_prop.end_line, end_line),
                 content_hash=c_hash,
-                parent_symbol_id=parent_canon,
-                decorators=decorators,
-                return_type=ret_type,
-                parameter_count=param_count,
-                documentation=doc,
+                parent_symbol_id=existing_prop.parent_symbol_id,
+                decorators=list(dict.fromkeys(existing_prop.decorators + decorators)),
+                return_type=existing_prop.return_type,
+                parameter_count=existing_prop.parameter_count,
+                documentation=existing_prop.documentation or doc,
+            )
+        else:
+            self.symbols.append(
+                Symbol(
+                    id=canon_id,
+                    canonical_id=canon_id,
+                    name=node.name,
+                    qualified_name=qname,
+                    kind=kind,
+                    language="python",
+                    module=self.module,
+                    path=self.file_path,
+                    file_path=self.file_path,
+                    scope=parent_scope,
+                    signature=sig,
+                    start_line=node.lineno,
+                    end_line=end_line,
+                    content_hash=c_hash,
+                    parent_symbol_id=parent_canon,
+                    decorators=decorators,
+                    return_type=ret_type,
+                    parameter_count=param_count,
+                    documentation=doc,
+                )
             )
-        )
 
         # Framework analyzer hook: check function/class for route decorators during this traversal
         if node.decorator_list or isinstance(node, ast.ClassDef):

codegraph/interrogation.py

@@ -1979,6 +1979,8 @@ def list_routes(
     framework: str | None = None,
     method: str | None = None,
     path: str | None = None,
+    limit: int | None = None,
+    offset: int = 0,
 ) -> dict[str, Any]:
     """Expose application routes discovered from the repository."""
     unindexed = check_index_available(con, repository)
@@ -2028,10 +2030,27 @@ def list_routes(
         for r in rows
     ]
 
+    total_count = len(routes)
+    if limit is not None:
+        safe_offset = max(0, offset)
+        safe_limit = max(0, limit)
+        paginated_routes = routes[safe_offset : safe_offset + safe_limit]
+        return {
+            "status": "ok",
+            **meta,
+            "count": len(paginated_routes),
+            "total_count": total_count,
+            "limit": safe_limit,
+            "offset": safe_offset,
+            "has_more": (safe_offset + len(paginated_routes)) < total_count,
+            "routes": paginated_routes,
+        }
+
     return {
         "status": "ok",
         **meta,
         "count": len(routes),
+        "total_count": total_count,
         "routes": routes,
     }
 

codegraph/mcp/server.py

@@ -173,6 +173,8 @@ def create_server(
     repository: Path,
     settings: Settings | None = None,
     profile: str = "full",
+    host: str = "127.0.0.1",
+    port: int = 8765,
 ) -> Any:
     """Build an MCP FastMCP server lazily so normal CLI use needs no MCP dependency."""
     try:
@@ -184,7 +186,12 @@ def create_server(
 
     indexer = Indexer(repository, settings)
     memory = MemoryStore(indexer.db_path)
-    app = FastMCP("CodeGraph MCP", instructions=render_agent_rules("antigravity"))
+    app = FastMCP(
+        "CodeGraph MCP",
+        instructions=render_agent_rules("antigravity"),
+        host=host,
+        port=port,
+    )
     max_read_bytes = indexer.settings.max_read_bytes
 
     # -----------------------------------------------------------------------

codegraph/runtime/runner.py

@@ -0,0 +1,204 @@
+"""Zero-Friction Development Server Runtime Interceptor (v2.2.0).
+
+Enables 1-line development telemetry capture:
+    codegraph run npm run dev
+    codegraph run uvicorn main:app
+    codegraph run python app.py
+
+Security & Reliability Invariants:
+- Passes stdin/stdout/stderr directly to the user's terminal with zero distortion.
+- Strips authorization headers, cookies, and sensitive credentials via existing redaction rules.
+- Streams captured HTTP requests and uncaught exceptions directly into `.codegraph/runtime.sqlite3`
+  without requiring code changes to the user's application.
+- Cleans up child processes and temporary interceptor hooks on exit.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+from codegraph.indexing import Indexer
+from codegraph.runtime.ingestor import ingest_runtime_traces
+
+
+def _generate_node_interceptor(output_jsonl: Path) -> str:
+    """Generate lightweight Node.js HTTP/Express/Fastify request interceptor."""
+    escaped_log_path = json.dumps(str(output_jsonl))
+    return f"""// CodeGraph Node.js Runtime Interceptor
+const http = require('http');
+const https = require('https');
+const fs = require('fs');
+
+const logPath = {escaped_log_path};
+
+function emitEvent(event) {{
+  try {{
+    fs.appendFileSync(logPath, JSON.stringify(event) + '\\n');
+  }} catch (_) {{}}
+}}
+
+function hookServer(serverProto) {{
+  const origEmit = serverProto.emit;
+  serverProto.emit = function(event, req, res) {{
+    if (event === 'request' && req && res) {{
+      const startTime = Date.now();
+      const method = req.method || 'GET';
+      const url = req.url ? req.url.split('?')[0] : '/';
+
+      res.on('finish', () => {{
+        const duration = Date.now() - startTime;
+        emitEvent({{
+          trace_id: 'tr_' + Math.random().toString(36).substring(2, 10),
+          span_id: 'sp_' + Math.random().toString(36).substring(2, 10),
+          timestamp: new Date().toISOString(),
+          http_method: method,
+          route_path: url,
+          status_code: res.statusCode,
+          duration_ms: duration,
+          service_name: 'node_dev_server',
+          source_format: 'json'
+        }});
+      }});
+    }}
+    return origEmit.apply(this, arguments);
+  }};
+}}
+
+try {{
+  hookServer(http.Server.prototype);
+}} catch (_) {{}}
+
+process.on('uncaughtExceptionMonitor', (err) => {{
+  emitEvent({{
+    trace_id: 'err_' + Math.random().toString(36).substring(2, 10),
+    span_id: 'sp_err',
+    timestamp: new Date().toISOString(),
+    exception_type: (err && err.name) ? err.name : 'UncaughtException',
+    service_name: 'node_dev_server',
+    status_code: 500,
+    source_format: 'json'
+  }});
+}});
+"""
+
+
+def _generate_python_interceptor(output_jsonl: Path) -> str:
+    """Generate lightweight Python WSGI/ASGI/FastAPI request interceptor."""
+    escaped_log_path = repr(str(output_jsonl))
+    return f"""# CodeGraph Python Runtime Interceptor
+import sys
+import json
+import time
+
+LOG_PATH = {escaped_log_path}
+
+def emit_event(event):
+    try:
+        with open(LOG_PATH, "a", encoding="utf-8") as f:
+            f.write(json.dumps(event) + "\\n")
+    except Exception:
+        pass
+
+# Intercept uncaught exceptions
+_orig_excepthook = sys.excepthook
+def _cg_excepthook(exc_type, exc_value, exc_traceback):
+    emit_event({{
+        "trace_id": "err_" + str(int(time.time())),
+        "span_id": "sp_err",
+        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "exception_type": getattr(exc_type, "__name__", "Exception"),
+        "service_name": "python_dev_server",
+        "status_code": 500,
+        "source_format": "json"
+    }})
+    return _orig_excepthook(exc_type, exc_value, exc_traceback)
+
+sys.excepthook = _cg_excepthook
+"""
+
+
+def run_with_telemetry(
+    command: list[str],
+    repository: Path,
+    sample_rate: float = 1.0,
+) -> int:
+    """Execute a development command with transparent runtime trace capture."""
+    if not command:
+        raise ValueError("Command cannot be empty.")
+
+    hooks_dir = repository / ".codegraph" / "runtime_hooks"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+    trace_file = hooks_dir / "active_traces.jsonl"
+    # Ensure fresh trace buffer
+    if trace_file.exists():
+        try:
+            trace_file.unlink()
+        except OSError:
+            pass
+
+    node_hook = hooks_dir / "cg_node_hook.js"
+    node_hook.write_text(_generate_node_interceptor(trace_file), encoding="utf-8")
+
+    python_hook = hooks_dir / "cg_python_hook.py"
+    python_hook.write_text(_generate_python_interceptor(trace_file), encoding="utf-8")
+
+    env = dict(os.environ)
+
+    # Inject Node hook
+    old_node_opts = env.get("NODE_OPTIONS", "")
+    env["NODE_OPTIONS"] = f"--require {node_hook} {old_node_opts}".strip()
+
+    # Inject Python hook
+    old_py_start = env.get("PYTHONSTARTUP", "")
+    if not old_py_start:
+        env["PYTHONSTARTUP"] = str(python_hook)
+
+    # Background ingestion thread
+    stop_event = threading.Event()
+    indexer = Indexer(repository)
+
+    def _ingest_loop() -> None:
+        last_pos = 0
+        while not stop_event.is_set():
+            time.sleep(1.0)
+            if not trace_file.exists():
+                continue
+            try:
+                size = trace_file.stat().st_size
+                if size > last_pos:
+                    with open(trace_file, encoding="utf-8", errors="replace") as f:
+                        f.seek(last_pos)
+                        new_content = f.read()
+                        last_pos = f.tell()
+                    if new_content.strip():
+                        with indexer.session() as con:
+                            ingest_runtime_traces(con, new_content, repository=repository, max_events=1000, sampling_rate=sample_rate)
+            except Exception:
+                pass
+
+    ingest_worker = threading.Thread(target=_ingest_loop, daemon=True)
+    ingest_worker.start()
+
+    # Spawn interactive dev process
+    try:
+        proc = subprocess.Popen(command, cwd=str(repository), env=env)
+        returncode = proc.wait()
+    except KeyboardInterrupt:
+        returncode = 0
+    finally:
+        stop_event.set()
+        # Drain remaining lines on shutdown
+        if trace_file.exists():
+            try:
+                content = trace_file.read_text(encoding="utf-8", errors="replace")
+                if content.strip():
+                    with indexer.session() as con:
+                        ingest_runtime_traces(con, content, repository=repository, max_events=1000, sampling_rate=sample_rate)
+            except Exception:
+                pass
+
+    return returncode