locust 2.43.5.dev25__tar.gz → 2.43.5.dev31__tar.gz

{locust-2.43.5.dev25 → locust-2.43.5.dev31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: locust
-Version: 2.43.5.dev25
+Version: 2.43.5.dev31
 Summary: Developer-friendly load testing framework
 Project-URL: homepage, https://locust.io/
 Project-URL: repository, https://github.com/locustio/locust

{locust-2.43.5.dev25 → locust-2.43.5.dev31}/locust/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.43.5.dev25'
-__version_tuple__ = version_tuple = (2, 43, 5, 'dev25')
+__version__ = version = '2.43.5.dev31'
+__version_tuple__ = version_tuple = (2, 43, 5, 'dev31')
 
 __commit_id__ = commit_id = None

locust-2.43.5.dev31/locust/contrib/csv_request_logger.py

@@ -0,0 +1,187 @@
+"""
+Per-request CSV logger for Locust.
+
+Hooks into the ``request`` event and appends one row per completed request to a
+CSV file.  Useful for post-run analysis that requires individual data-points
+rather than the aggregated statistics provided by the built-in
+``--csv`` flag.
+
+Usage::
+
+    from locust import HttpUser, task, events
+    from locust.contrib.csv_request_logger import CsvRequestLogger
+
+    logger = CsvRequestLogger("results/requests.csv")
+
+    @events.init.add_listener
+    def on_locust_init(environment, **kwargs):
+        logger.register(environment)
+
+    class MyUser(HttpUser):
+        @task
+        def index(self):
+            self.client.get("/")
+
+The CSV file is created (or truncated) when :meth:`CsvRequestLogger.register`
+is called and closed when the ``quitting`` event fires.
+
+CSV columns
+-----------
+``timestamp``
+    Unix timestamp (seconds, float) at which the request was sent.
+``request_type``
+    HTTP method or custom protocol name (e.g. ``GET``, ``POST``, ``WS``).
+``name``
+    URL path / request name as reported to Locust stats.
+``response_time_ms``
+    Response time in **milliseconds** (float, rounded to 2 dp).
+``response_length``
+    Response body size in bytes (int).
+``status_code``
+    HTTP status code (int).  ``0`` when the request failed before a response
+    was received (e.g. connection error or custom failure).
+``exception``
+    String representation of the exception if the request failed, else empty.
+"""
+
+import csv
+import io
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from locust.env import Environment
+    from locust.stats import CSVWriter
+
+logger = logging.getLogger(__name__)
+
+#: Column headers written to the CSV file.
+CSV_COLUMNS = (
+    "timestamp",
+    "request_type",
+    "name",
+    "response_time_ms",
+    "response_length",
+    "status_code",
+    "exception",
+)
+
+
+def _status_code(response: Any, exception: Any) -> int:
+    """Extract the HTTP status code from a response object.
+
+    Returns ``0`` when no response is available (connection errors, custom
+    ``ResponseContextManager`` failures, non-HTTP protocols, etc.).
+    """
+    if exception is not None and response is None:
+        return 0
+    try:
+        code = int(response.status_code)
+        return code
+    except (AttributeError, TypeError, ValueError):
+        return 0
+
+
+class CsvRequestLogger:
+    """Listens to Locust's ``request`` event and writes one CSV row per request.
+
+    Parameters
+    ----------
+    filepath:
+        Path to the output CSV file.  Parent directories must already exist.
+        If the file exists it will be **overwritten** at the start of each run.
+    flush_interval:
+        Number of rows to buffer before flushing to disk.  Use ``1`` for
+        immediate write-through (safest for crash recovery), or a larger value
+        for better performance on high-RPS tests.  Defaults to ``1``.
+    """
+
+    def __init__(self, filepath: str, *, flush_interval: int = 1) -> None:
+        self.filepath = filepath
+        self.flush_interval = max(1, flush_interval)
+
+        self._filehandle: io.TextIOWrapper | None = None
+        self._writer: CSVWriter | None = None
+        self._pending: int = 0
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def register(self, environment: "Environment") -> None:
+        """Attach this logger to *environment*'s event hooks.
+
+        Must be called once, typically inside an ``@events.init`` listener.
+        """
+        environment.events.request.add_listener(self._on_request)
+        environment.events.quitting.add_listener(self._on_quitting)
+        self._open()
+        logger.debug("CsvRequestLogger: writing per-request log to %s", self.filepath)
+
+    def close(self) -> None:
+        """Flush and close the underlying file handle.
+
+        Safe to call multiple times.
+        """
+        if self._filehandle is not None and not self._filehandle.closed:
+            self._filehandle.flush()
+            self._filehandle.close()
+            logger.debug("CsvRequestLogger: closed %s", self.filepath)
+        self._filehandle = None
+        self._writer = None
+        self._pending = 0
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _open(self) -> None:
+        """Open (or re-open) the CSV file and write the header row."""
+        self.close()
+        self._filehandle = open(self.filepath, "w", newline="", encoding="utf-8")
+        self._writer = csv.writer(self._filehandle)
+        self._writer.writerow(CSV_COLUMNS)
+        self._filehandle.flush()
+
+    def _on_request(
+        self,
+        *,
+        request_type: str,
+        name: str,
+        response_time: float,
+        response_length: int,
+        exception: Any = None,
+        response: Any = None,
+        start_time: float | None = None,
+        context: Any = None,
+        **kwargs: Any,
+    ) -> None:
+        """Event handler — called by Locust for every completed request."""
+        if self._writer is None:
+            return
+
+        ts = start_time if start_time is not None else time.time()
+        status_code = _status_code(response, exception)
+        exc_str = str(exception) if exception is not None else ""
+
+        self._writer.writerow(
+            [
+                round(ts, 6),
+                request_type,
+                name,
+                round(response_time, 2),
+                response_length,
+                status_code,
+                exc_str,
+            ]
+        )
+
+        self._pending += 1
+        if self._pending >= self.flush_interval:
+            self._filehandle.flush()  # type: ignore[union-attr]
+            self._pending = 0
+
+    def _on_quitting(self, **kwargs: Any) -> None:
+        """Flush and close when Locust shuts down."""
+        self.close()

{locust-2.43.5.dev25 → locust-2.43.5.dev31}/locust/contrib/oai.py

@@ -33,7 +33,7 @@ class OpenAIClient(OpenAI):
                 exception = e
             request_event.fire(
                 request_type=response.request.method,
-                name=self.request_name if self.request_name else response.url.path,
+                name=self.request_name or response.url.path,
                 context={},
                 response=response,
                 exception=exception,

{locust-2.43.5.dev25 → locust-2.43.5.dev31}/locust/main.py

@@ -587,18 +587,26 @@ See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-numb
         input_listener_greenlet = gevent.spawn(
             input_listener(
                 {
-                    "w": lambda: runner.start(runner.user_count + 1, 100)
-                    if runner.state != "spawning"
-                    else logging.warning("Already spawning users, can't spawn more right now"),
-                    "W": lambda: runner.start(runner.user_count + 10, 100)
-                    if runner.state != "spawning"
-                    else logging.warning("Already spawning users, can't spawn more right now"),
-                    "s": lambda: runner.start(max(0, runner.user_count - 1), 100)
-                    if runner.state != "spawning"
-                    else logging.warning("Spawning users, can't stop right now"),
-                    "S": lambda: runner.start(max(0, runner.user_count - 10), 100)
-                    if runner.state != "spawning"
-                    else logging.warning("Spawning users, can't stop right now"),
+                    "w": lambda: (
+                        runner.start(runner.user_count + 1, 100)
+                        if runner.state != "spawning"
+                        else logging.warning("Already spawning users, can't spawn more right now")
+                    ),
+                    "W": lambda: (
+                        runner.start(runner.user_count + 10, 100)
+                        if runner.state != "spawning"
+                        else logging.warning("Already spawning users, can't spawn more right now")
+                    ),
+                    "s": lambda: (
+                        runner.start(max(0, runner.user_count - 1), 100)
+                        if runner.state != "spawning"
+                        else logging.warning("Spawning users, can't stop right now")
+                    ),
+                    "S": lambda: (
+                        runner.start(max(0, runner.user_count - 10), 100)
+                        if runner.state != "spawning"
+                        else logging.warning("Spawning users, can't stop right now")
+                    ),
                     "\r": lambda: webbrowser.open_new_tab(url),
                     "\n": lambda: webbrowser.open_new_tab(url),
                 },

{locust-2.43.5.dev25 → locust-2.43.5.dev31}/locust/stats.py

@@ -774,7 +774,7 @@ class StatsError:
         def _getattr(obj: StatsError, key: str, default: Any) -> Any:
             value = getattr(obj, key, default)
 
-            if key in ["error"]:
+            if key == "error":
                 value = StatsError.parse_error(value)
 
             return value

{locust-2.43.5.dev25 → locust-2.43.5.dev31}/locust/user/inspectuser.py

@@ -35,7 +35,7 @@ def _calc_distribution(user_classes, num_users):
     user_classes_count = {}
 
     for u in user_classes:
-        count = u.fixed_count if u.fixed_count else (u.weight / total_weight) * weighted_count
+        count = u.fixed_count or (u.weight / total_weight) * weighted_count
         user_classes_count[u.__name__] = round(count)
 
     return user_classes_count

{locust-2.43.5.dev25 → locust-2.43.5.dev31}/locust/web.py

@@ -726,7 +726,7 @@ class WebUI:
             "is_distributed": is_distributed,
             "user_count": self.environment.runner.user_count,
             "version": version,
-            "host": host if host else "",
+            "host": host or "",
             "history": request_stats.history if request_stats.num_requests > 0 else [],
             "override_host_warning": override_host_warning,
             "missing_host_warning": missing_host_warning,

{locust-2.43.5.dev25 → locust-2.43.5.dev31}/pyproject.toml

@@ -82,7 +82,7 @@ test = [
 ]
 lint = [
     "pre-commit>=3.7.1,<4.0.0",
-    "ruff==0.14.3",
+    "ruff==0.15.12",
     "mypy>=1.13.0,<1.15.0",
     "types-requests==2.32.4.20250809",
 ]