jac-loadtest 0.2.1__tar.gz → 0.2.3__tar.gz

{jac_loadtest-0.2.1 → jac_loadtest-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jac-loadtest
-Version: 0.2.1
+Version: 0.2.3
 Summary: HAR-based load testing CLI for jac-scale applications
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{jac_loadtest-0.2.1 → jac_loadtest-0.2.3}/jac_loadtest/bridge/topology.py

@@ -104,6 +104,8 @@ class TopologyRouter:
     def _build_microservice(cls, config: LoadTestConfig) -> TopologyRouter:
         toml_routes = _load_toml_routes()   # service_name → prefix; {} if unavailable
 
+        routes: list[ServiceRoute]
+
         if config.services_map:
             try:
                 services_json: dict[str, str] = json.loads(config.services_map)
@@ -129,7 +131,7 @@ class TopologyRouter:
                 "[plugins.scale.microservices.routes] in jac.toml. Neither was found."
             )
 
-        routes: list[ServiceRoute] = []
+        routes = []
         missing: list[str] = []
         for name, prefix in toml_routes.items():
             env_var = f"JAC_SV_{name.upper()}_URL"

{jac_loadtest-0.2.1 → jac_loadtest-0.2.3}/jac_loadtest/cli.py

@@ -15,7 +15,7 @@ def run(args: object) -> None:
     from jac_loadtest.core.har_parser import parse_har
     from jac_loadtest.core.engine import run_all_vus
     from jac_loadtest.core.metrics import MetricsCollector
-    from jac_loadtest.output.reporter import render_console
+    from jac_loadtest.output.reporter import render_console, render_json, render_html
 
     config = from_args(args)
 
@@ -70,17 +70,72 @@ def run(args: object) -> None:
         print(f"Error: {exc}", file=sys.stderr)
         sys.exit(2)
 
-    metrics = MetricsCollector(max_samples=config.max_samples)
+    from rich.console import Console as _Console
+    _console = _Console(stderr=True)
+
     t_start = time.time()
 
     try:
-        asyncio.run(
-            run_all_vus(entries, config, metrics, topology=topology, auth_provider=auth_provider)
-        )
+        with _console.status(f"Running load test — {config.vus} VUs..."):
+            if config.workers > 1:
+                from jac_loadtest.core.process_runner import run_multiprocess
+                metrics = run_multiprocess(entries, config, topology, auth_provider)
+            else:
+                metrics = MetricsCollector(max_samples=config.max_samples)
+                asyncio.run(
+                    run_all_vus(entries, config, metrics, topology=topology, auth_provider=auth_provider)
+                )
     except AuthenticationError as exc:
         print(f"Error: {exc}", file=sys.stderr)
         sys.exit(2)
 
     duration_s = time.time() - t_start
-    stats = metrics.compute_endpoint_stats(duration_s)
-    render_console(stats, config, actual_duration_s=duration_s)
+    stats = metrics.compute_endpoint_stats()
+    snapshots = metrics.generate_timeseries(t_start)
+    completion_p50, completion_p95, completion_p99 = metrics.completion_percentiles(t_start)
+
+    fmt = config.report_format
+
+    if fmt == "json":
+        output = render_json(
+            stats, config,
+            actual_duration_s=duration_s,
+            total_rps=metrics.global_rps(duration_s),
+            snapshots=snapshots,
+            completion_p50_s=completion_p50,
+            completion_p95_s=completion_p95,
+            completion_p99_s=completion_p99,
+        )
+        if config.report_out:
+            with open(config.report_out, "w", encoding="utf-8") as fh:
+                fh.write(output)
+            print(f"JSON report written to {config.report_out}")
+        else:
+            print(output)
+
+    elif fmt == "html":
+        if not config.report_out:
+            print("Error: --report-out <path> is required for --report-format html", file=sys.stderr)
+            sys.exit(2)
+        output = render_html(
+            stats, config,
+            actual_duration_s=duration_s,
+            total_rps=metrics.global_rps(duration_s),
+            snapshots=snapshots,
+            completion_p50_s=completion_p50,
+            completion_p95_s=completion_p95,
+            completion_p99_s=completion_p99,
+        )
+        with open(config.report_out, "w", encoding="utf-8") as fh:
+            fh.write(output)
+        print(f"HTML report written to {config.report_out}", file=sys.stderr)
+
+    else:
+        render_console(
+            stats, config,
+            actual_duration_s=duration_s,
+            total_rps=metrics.global_rps(duration_s),
+            completion_p50_s=completion_p50,
+            completion_p95_s=completion_p95,
+            completion_p99_s=completion_p99,
+        )

{jac_loadtest-0.2.1 → jac_loadtest-0.2.3}/jac_loadtest/config.py

@@ -4,15 +4,18 @@ Phase 0: dataclass with built-in defaults only.
 Phase 2 will add jac.toml reading via jac_scale.config_loader.
 """
 from __future__ import annotations
+import os
 from dataclasses import dataclass, field
+from typing import Any
 
 
 BUILT_IN_DEFAULTS: dict = {
     "vus": 1,
     "duration": "30s",
-    "iterations": None,
+    "iterations": 1,
     "ramp_up": "0s",
     "timeout": "30s",
+    "workers": os.cpu_count() or 1,
     "mode": "monolith",
     "think_time": "none",
     "think_time_scale": 1.0,
@@ -36,9 +39,10 @@ class LoadTestConfig:
     # Load shape
     vus: int = 1
     duration: str = "30s"
-    iterations: int | None = None
+    iterations: int  = 1
     ramp_up: str = "0s"
     timeout: str = "30s"
+    workers: int = 1
 
     # Traffic
     mode: str = "monolith"
@@ -107,7 +111,7 @@ def from_args(args: object) -> LoadTestConfig:
 
     # For toml-sourced fields, use CLI value if provided (not None), else toml value,
     # else built-in default.
-    def resolve(name: str) -> object:
+    def resolve(name: str) -> Any:
         cli_val = getattr(args, name, None)
         if cli_val is not None:
             return cli_val
@@ -128,6 +132,7 @@ def from_args(args: object) -> LoadTestConfig:
         iterations=resolve("iterations"),
         mode=resolve("mode"),
         vus=resolve("vus"),
+        workers=resolve("workers"),
         duration=resolve("duration"),
         ramp_up=resolve("ramp_up"),
         timeout=resolve("timeout"),

jac_loadtest-0.2.3/jac_loadtest/core/engine.py

@@ -0,0 +1,343 @@
+"""asyncio VU pool: ramp-up, duration/iteration control, graceful shutdown.
+
+core/ has zero knowledge of jac-scale internals.
+"""
+from __future__ import annotations
+
+import asyncio
+import signal
+import socket
+import sys
+from typing import TYPE_CHECKING
+
+import aiohttp
+from aiohttp.abc import AbstractResolver as _AbstractResolver
+
+from jac_loadtest.config import parse_duration
+from jac_loadtest.core.metrics import RequestResult, normalize_path
+
+if TYPE_CHECKING:
+    from jac_loadtest.core.har_parser import HarEntry
+    from jac_loadtest.core.metrics import MetricsCollector
+    from jac_loadtest.config import LoadTestConfig
+    from jac_loadtest.bridge.topology import TopologyRouter
+    from jac_loadtest.bridge.auth import AuthProvider
+
+
+class _PreResolvedResolver(_AbstractResolver):
+    """Resolver that returns a pre-resolved IP for known hostnames, falling back to
+    system DNS for anything else. Injected into each worker's TCPConnector so workers
+    never issue their own DNS lookups for the target host."""
+
+    def __init__(self, host_map: dict[str, str]) -> None:
+        self._host_map = host_map
+        self._fallback = aiohttp.ThreadedResolver()
+
+    async def resolve(  # type: ignore[override]
+        self, hostname: str, port: int = 0, family: socket.AddressFamily = socket.AF_INET
+    ) -> list[dict]:
+        if hostname in self._host_map:
+            ip = self._host_map[hostname]
+            addr_family = socket.AF_INET6 if ":" in ip else socket.AF_INET
+            return [{"hostname": hostname, "host": ip, "port": port, "family": addr_family, "proto": 0, "flags": 0}]
+        return await self._fallback.resolve(hostname, port, family)  # type: ignore[return-value]
+
+    async def close(self) -> None:
+        await self._fallback.close()
+
+
+async def run_all_vus(
+    entries: list[HarEntry],
+    config: LoadTestConfig,
+    metrics: MetricsCollector,
+    topology: TopologyRouter | None = None,
+    auth_provider: AuthProvider | None = None,
+    vu_id_offset: int = 0,
+    pre_authed_tokens: dict[int, str] | None = None,
+    pre_resolved_hosts: dict[str, str] | None = None,
+) -> None:
+    """Spawn N virtual user coroutines and run until duration/iterations/stop signal."""
+    stop_requested = asyncio.Event()
+    loop = asyncio.get_event_loop()
+
+    original_sigint = signal.getsignal(signal.SIGINT)
+
+    def _on_second_sigint(sig: int, frame: object) -> None:
+        sys.exit(130)
+
+    def _on_first_sigint(sig: int, frame: object) -> None:
+        stop_requested.set()
+        signal.signal(signal.SIGINT, _on_second_sigint)
+
+    signal.signal(signal.SIGINT, _on_first_sigint)
+
+    timeout = aiohttp.ClientTimeout(total=parse_duration(config.timeout))
+    ramp_up_seconds = parse_duration(config.ramp_up)
+
+    # Use pre-computed tokens when provided (multi-process path: auth ran in main process).
+    # Otherwise authenticate here (single-process path).
+    token_by_vu: dict[int, str] = {}
+    if pre_authed_tokens is not None:
+        token_by_vu = pre_authed_tokens
+    elif auth_provider is not None:
+        if not config.url:
+            raise ValueError("auth_provider requires --url to be set")
+        n_creds = len(auth_provider._credentials)
+        # Unique credential indices needed by this worker's VU slice.
+        cred_indices = {(vu_id_offset + i) % n_creds for i in range(config.vus)}
+        sem = asyncio.Semaphore(min(50, len(cred_indices)))
+
+        async def _do_auth(cred_idx: int) -> tuple[int, str]:
+            async with sem:
+                async with aiohttp.ClientSession(timeout=timeout) as auth_session:
+                    if config.url is not None:
+                        tok = await auth_provider.authenticate(cred_idx, auth_session, config.url)
+            return cred_idx, tok
+
+        auth_results: list[tuple[int, str]] = list(
+            await asyncio.gather(*[_do_auth(idx) for idx in cred_indices])
+        )
+        token_by_cred = dict(auth_results)
+        token_by_vu = {
+            vu_id_offset + i: token_by_cred[(vu_id_offset + i) % n_creds]
+            for i in range(config.vus)
+        }
+
+    tasks = [
+        asyncio.create_task(
+            _run_vu(
+                vu_id=vu_id_offset + i,
+                delay=(i / config.vus) * ramp_up_seconds if config.vus > 1 else 0.0,
+                entries=entries,
+                config=config,
+                metrics=metrics,
+                stop_requested=stop_requested,
+                loop=loop,
+                token=token_by_vu.get(vu_id_offset + i),
+                topology=topology,
+                pre_resolved_hosts=pre_resolved_hosts or {},
+            )
+        )
+        for i in range(config.vus)
+    ]
+
+    try:
+        await asyncio.gather(*tasks)
+    finally:
+        signal.signal(signal.SIGINT, original_sigint)
+
+
+async def _run_vu(
+    vu_id: int,
+    delay: float,
+    entries: list[HarEntry],
+    config: LoadTestConfig,
+    metrics: MetricsCollector,
+    stop_requested: asyncio.Event,
+    loop: asyncio.AbstractEventLoop,
+    token: str | None = None,
+    topology: TopologyRouter | None = None,
+    pre_resolved_hosts: dict[str, str] | None = None,
+) -> None:
+    """Single virtual user: wait ramp delay, then replay HAR entries with a pre-fetched token."""
+    if delay > 0:
+        await asyncio.sleep(delay)
+
+    timeout = aiohttp.ClientTimeout(total=parse_duration(config.timeout))
+   
+    iteration = 0
+    # Warn once per unrouted path within this VU to avoid spam across iterations.
+    _warned_unrouted: set[str] = set()
+
+    connector = (
+        aiohttp.TCPConnector(resolver=_PreResolvedResolver(pre_resolved_hosts))
+        if pre_resolved_hosts
+        else aiohttp.TCPConnector()
+    )
+    async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
+        while not stop_requested.is_set():
+            if config.iterations is not None and iteration >= config.iterations:
+                break
+
+            for entry in entries:
+                if stop_requested.is_set():
+                    break
+                # Skip the HAR-recorded login; auth is handled by pre-fetched token.
+                if entry.is_login and token is not None:
+                    continue
+                result = await _send_request(
+                    session=session,
+                    entry=entry,
+                    vu_id=vu_id,
+                    config=config,
+                    loop=loop,
+                    token=token,
+                    topology=topology,
+                )
+                if result is None:
+                    from urllib.parse import urlparse as _up
+                    path = _up(entry.url).path
+                    if path not in _warned_unrouted:
+                        print(
+                            f"\n\033[33mWarning: no route for '{path}' — skipping. "
+                            "Add a matching prefix to --services-map or set --url as fallback.\033[0m",
+                            file=sys.stderr,
+                        )
+                        _warned_unrouted.add(path)
+                    continue
+                metrics.record(result)
+                if config.think_time == "real" and entry.think_time_ms > 0:
+                    await asyncio.sleep(
+                        entry.think_time_ms / 1000.0 * config.think_time_scale
+                    )
+
+            iteration += 1
+
+
+async def _send_request(
+    session: aiohttp.ClientSession,
+    entry: HarEntry,
+    vu_id: int,
+    config: LoadTestConfig,
+    loop: asyncio.AbstractEventLoop,
+    token: str | None = None,
+    topology: TopologyRouter | None = None,
+) -> RequestResult | None:
+    """Send one HTTP request and return a RequestResult, or None if no route exists."""
+    headers = dict(entry.headers)
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    if topology is not None:
+        try:
+            request_url, service_name = topology.resolve(entry.url)
+        except ValueError:
+            return None  # caller warns and skips
+    else:
+        request_url, service_name = entry.url, "monolith"
+
+    import time as _time
+    endpoint = normalize_path(entry.url)
+    t0 = loop.time()   # high-res clock for latency measurement only
+    ts = _time.time()  # wall-clock for cross-process timestamp comparison
+
+    try:
+        async with session.request(
+            method=entry.method,
+            url=request_url,
+            headers=headers,
+            data=entry.body,
+            allow_redirects=False,
+        ) as resp:
+            body = await resp.read()
+            latency_ms = (loop.time() - t0) * 1000
+            return RequestResult(
+                endpoint=endpoint,
+                service=service_name,
+                status=resp.status,
+                latency_ms=latency_ms,
+                bytes_received=len(body),
+                timestamp=ts,
+                vu_id=vu_id,
+                error_type=None,
+                occurrence=entry.occurrence,
+                total_occurrences=entry.total_occurrences,
+            )
+
+    except asyncio.TimeoutError:
+        return RequestResult(
+            endpoint=endpoint,
+            service=service_name,
+            status=0,
+            latency_ms=parse_duration(config.timeout) * 1000,
+            bytes_received=0,
+            timestamp=ts,
+            vu_id=vu_id,
+            error_type="TIMEOUT",
+            occurrence=entry.occurrence,
+            total_occurrences=entry.total_occurrences,
+        )
+
+    except aiohttp.ClientConnectorDNSError:
+        return RequestResult(
+            endpoint=endpoint,
+            service=service_name,
+            status=0,
+            latency_ms=0.0,
+            bytes_received=0,
+            timestamp=ts,
+            vu_id=vu_id,
+            error_type="DNS_ERROR",
+            occurrence=entry.occurrence,
+            total_occurrences=entry.total_occurrences,
+        )
+
+    except aiohttp.ClientSSLError:
+        return RequestResult(
+            endpoint=endpoint,
+            service=service_name,
+            status=0,
+            latency_ms=0.0,
+            bytes_received=0,
+            timestamp=ts,
+            vu_id=vu_id,
+            error_type="SSL_ERROR",
+            occurrence=entry.occurrence,
+            total_occurrences=entry.total_occurrences,
+        )
+
+    except aiohttp.ClientConnectorError:
+        return RequestResult(
+            endpoint=endpoint,
+            service=service_name,
+            status=0,
+            latency_ms=0.0,
+            bytes_received=0,
+            timestamp=ts,
+            vu_id=vu_id,
+            error_type="CONNECTION_REFUSED",
+            occurrence=entry.occurrence,
+            total_occurrences=entry.total_occurrences,
+        )
+
+    except aiohttp.ServerDisconnectedError:
+        return RequestResult(
+            endpoint=endpoint,
+            service=service_name,
+            status=0,
+            latency_ms=(loop.time() - t0) * 1000,
+            bytes_received=0,
+            timestamp=ts,
+            vu_id=vu_id,
+            error_type="SERVER_DISCONNECTED",
+            occurrence=entry.occurrence,
+            total_occurrences=entry.total_occurrences,
+        )
+
+    except aiohttp.ClientOSError:
+        return RequestResult(
+            endpoint=endpoint,
+            service=service_name,
+            status=0,
+            latency_ms=(loop.time() - t0) * 1000,
+            bytes_received=0,
+            timestamp=ts,
+            vu_id=vu_id,
+            error_type="CONNECTION_RESET",
+            occurrence=entry.occurrence,
+            total_occurrences=entry.total_occurrences,
+        )
+
+    except Exception as e:
+        return RequestResult(
+            endpoint=endpoint,
+            service=service_name,
+            status=0,
+            latency_ms=(loop.time() - t0) * 1000,
+            bytes_received=0,
+            timestamp=ts,
+            vu_id=vu_id,
+            error_type=str(e).upper() or type(e).__name__.upper(),
+            occurrence=entry.occurrence,
+            total_occurrences=entry.total_occurrences,
+        )

{jac_loadtest-0.2.1 → jac_loadtest-0.2.3}/jac_loadtest/core/har_parser.py

@@ -49,6 +49,8 @@ class HarEntry:
     think_time_ms: float
     is_login: bool
     original_url: str
+    occurrence: int = 0
+    total_occurrences: int = 0
 
 
 def _origin(url: str) -> str:
@@ -81,6 +83,22 @@ def _is_unsupported_type(entry: dict) -> bool:
     return url.startswith(("ws://", "wss://"))
 
 
+def _has_missing_body(method: str, raw_headers: list[dict], post_data: dict | None) -> bool:
+    """Return True if a request should have a body but none was captured in the HAR."""
+    if method.upper() not in ("POST", "PUT", "PATCH"):
+        return False
+    content_length = next(
+        (h["value"] for h in raw_headers if h.get("name", "").lower() == "content-length"),
+        "0",
+    )
+    try:
+        has_content = int(content_length) > 0
+    except ValueError:
+        has_content = False
+    body_text = (post_data or {}).get("text")
+    return has_content and not body_text
+
+
 def _has_cache_buster(url: str) -> bool:
     """Return True if the URL contains a stale cache-busting timestamp parameter."""
     qs = parse_qs(urlparse(url).query)
@@ -125,6 +143,7 @@ def parse_har(
     result: list[HarEntry] = []
     warned_unsupported = False
     warned_cache_buster = False
+    warned_missing_body = False
 
     for entry in raw_entries:
         req = entry["request"]
@@ -135,9 +154,9 @@ def parse_har(
         if _is_unsupported_type(entry):
             if not warned_unsupported:
                 print(
-                    "Warning: HAR contains WebSocket, SSE, or non-API entries "
+                    "\n\033[33mWarning: HAR contains WebSocket, SSE, or non-API entries "
                     "(websocket, eventsource, document, etc.). "
-                    "These are skipped automatically.",
+                    "These are skipped automatically.\033[0m",
                     file=sys.stderr,
                 )
                 warned_unsupported = True
@@ -148,9 +167,9 @@ def parse_har(
         if _has_cache_buster(original_url):
             if not warned_cache_buster:
                 print(
-                    "Warning: HAR contains URLs with cache-busting timestamp "
+                    "\n\033[33mWarning: HAR contains URLs with cache-busting timestamp "
                     "parameters (e.g. ?_=<timestamp>). These entries are skipped — "
-                    "the stale timestamp causes the server to reject the request.",
+                    "the stale timestamp causes the server to reject the request.\033[0m",
                     file=sys.stderr,
                 )
                 warned_cache_buster = True
@@ -164,7 +183,21 @@ def parse_har(
         else:
             rewritten_url = original_url  # keep recorded URL; topology handles routing
 
-        headers = _sanitize_headers(req.get("headers", []))
+        raw_headers = req.get("headers", [])
+
+        if _has_missing_body(req["method"], raw_headers, req.get("postData")):
+            if not warned_missing_body:
+                print(
+                    "\n\033[33mWarning: HAR contains POST/PUT/PATCH entries where the request body "
+                    "was not captured (postData missing despite non-zero Content-Length). "
+                    "These entries are skipped — replaying them without a body would cause "
+                    "422 errors. Re-record the HAR to capture the full request body.\033[0m",
+                    file=sys.stderr,
+                )
+                warned_missing_body = True
+            continue
+
+        headers = _sanitize_headers(raw_headers)
 
         post_data = req.get("postData", {}) or {}
         body = post_data.get("text") or None
@@ -188,6 +221,19 @@ def parse_har(
             )
         )
 
+    # Count how many times each path appears so occurrence numbers can be assigned.
+    totals: dict[str, int] = {}
+    for entry in result:
+        path = urlparse(entry.url).path
+        totals[path] = totals.get(path, 0) + 1
+
+    seen: dict[str, int] = {}
+    for entry in result:
+        path = urlparse(entry.url).path
+        seen[path] = seen.get(path, 0) + 1
+        entry.occurrence = seen[path]
+        entry.total_occurrences = totals[path]
+
     return result
 
 
@@ -198,10 +244,10 @@ def _check_version(version: str) -> None:
     """Warn if the HAR version is outside the tested range."""
     if version not in _SUPPORTED_HAR_VERSIONS:
         print(
-            f"Warning: HAR version '{version}' is not tested with this tool "
+            f"\n\033[33mWarning: HAR version '{version}' is not tested with this tool "
             f"(tested: {', '.join(sorted(_SUPPORTED_HAR_VERSIONS))}).\n"
             "Parsing will continue but results may be incomplete or incorrect.\n"
-            "If the output looks wrong, check for a jac-loadtest update.",
+            "If the output looks wrong, check for a jac-loadtest update.\033[0m",
             file=sys.stderr,
         )
 
@@ -214,10 +260,10 @@ def _security_scan(entries: list[dict]) -> None:
             value = hdr.get("value", "")
             if name in ("authorization", "cookie") and value:
                 print(
-                    "Warning: HAR file contains Authorization/Cookie headers from the "
+                    "\n\033[33mWarning: HAR file contains Authorization/Cookie headers from the "
                     "recording session.\nThese headers are stripped before replay, but "
                     "the file itself contains sensitive data.\n"
-                    "Do not commit this HAR file to version control.",
+                    "Do not commit this HAR file to version control.\033[0m",
                     file=sys.stderr,
                 )
                 return