locust 2.20.2.dev42__tar.gz → 2.20.2.dev49__tar.gz

{locust-2.20.2.dev42 → locust-2.20.2.dev49}/.git-blame-ignore-revs

@@ -7,3 +7,5 @@
 313b80f27f525441c449593a3aeaf38389f63c13
 # upgrade typing annotations using fix-future-annotations
 b5324820b299b1fe7da0608f0cc8ec47f58b1e40
+# upgrade code style to 3.8 using pyupgrade
+60f3bceacc4ab9567433d40ae3ed280750f55ff1

{locust-2.20.2.dev42/locust.egg-info → locust-2.20.2.dev49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: locust
-Version: 2.20.2.dev42
+Version: 2.20.2.dev49
 Summary: Developer friendly load testing framework
 License: MIT
 Project-URL: Homepage, https://locust.io/

{locust-2.20.2.dev42 → locust-2.20.2.dev49}/benchmarks/dispatch.py

@@ -632,8 +632,8 @@ if __name__ == "__main__":
         print()
         print(table)
 
-        with open(f"results-dispatch-benchmarks-{int(now)}.txt", "wt") as file:
+        with open(f"results-dispatch-benchmarks-{int(now)}.txt", "w") as file:
             file.write(table.get_string())
 
-        with open(f"results-dispatch-benchmarks-{int(now)}.json", "wt") as file:
+        with open(f"results-dispatch-benchmarks-{int(now)}.json", "w") as file:
             file.write(table.get_json_string())

{locust-2.20.2.dev42 → locust-2.20.2.dev49}/docs/running-distributed.rst

@@ -4,21 +4,22 @@
 Distributed load generation
 ===========================
 
-A single process running Locust can simulate a reasonably high throughput. For a simple test plan it should be able to make many hundreds of requests per second, thousands if you use :ref:`FastHttpUser <increase-performance>`.
+A single process running Locust can simulate a reasonably high throughput. For a simple test plan and small payloads it can make more than a thousand requests per second, possibly over ten thousand if you use :ref:`FastHttpUser <increase-performance>`.
 
-But if your test plan is complex or you want to run even more load, you'll need to scale out to multiple processes, maybe even multiple machines. Because Python cannot fully utilize more than one core per process (see `GIL <https://realpython.com/python-gil/>`_), you may need to run **one worker instance per processor core** in order to have access to all your computing power.
+But if your test plan is complex or you want to run even more load, you'll need to scale out to multiple processes, maybe even multiple machines. Fortunately, Locust supports distributed runs out of the box.
 
-To do this, you start one instance of Locust in master mode using the ``--master`` flag and multiple worker instances using the ``--worker`` flag.
-
-The master instance runs Locust's web interface, and tells the workers when to spawn/stop Users. The worker instances run your Users and send statistics back to the master. The master instance doesn't run any Users itself.
+To do this, you start one instance of Locust with the ``--master`` flag and one or more using the ``--worker`` flag. The master instance runs Locust's web interface, and tells the workers when to spawn/stop Users. The worker instances run your Users and send statistics back to the master. The master instance doesn't run any Users itself.
 
 To simplify startup, you can use the ``--processes`` flag. It will launch a master process and the specified number of worker processes. Used in combination with ``--worker`` it will only launch workers. ``--processes`` relies on `fork() <https://linux.die.net/man/3/fork>`_ so it doesn't work on Windows.
 
 .. note::
-    There is almost no limit to how many *Users* you can run per worker. Locust/gevent can run thousands or even tens of thousands of Users per process just fine, as long as their total request rate (RPS) is not too high.
+    Because Python cannot fully utilize more than one core per process (see `GIL <https://realpython.com/python-gil/>`_), you need to run one worker instance per processor core in order to have access to all your computing power.
+
+.. note::
+    There is almost no limit to how many Users you can run per worker. Locust/gevent can run thousands or even tens of thousands of Users per process just fine, as long as their total request rate (RPS) is not too high.
 
 .. note::
-    If Locust is getting close to running out of CPU resources, it will log a warning.
+    If Locust is getting close to running out of CPU resources, it will log a warning. If there is no warning but you are still unable to generate the expected load, then the problem must be `something else <https://github.com/locustio/locust/wiki/FAQ#increase-my-request-raterps>`_.
 
 Single machine
 ==============
@@ -93,7 +94,7 @@ Communicating across nodes
 =============================================
 
 When running Locust in distributed mode, you may want to communicate between master and worker nodes in 
-order to coordinate data. This can be easily accomplished with custom messages using the built in messaging hooks:
+order to coordinate the test. This can be easily accomplished with custom messages using the built in messaging hooks:
 
 .. code-block:: python
 

{locust-2.20.2.dev42 → locust-2.20.2.dev49}/locust/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.20.2.dev42'
-__version_tuple__ = version_tuple = (2, 20, 2, 'dev42')
+__version__ = version = '2.20.2.dev49'
+__version_tuple__ = version_tuple = (2, 20, 2, 'dev49')

{locust-2.20.2.dev42 → locust-2.20.2.dev49}/locust/dispatch.py

@@ -124,7 +124,7 @@ class UsersDispatcher(Iterator):
         worker_nodes_by_id = sorted(self._worker_nodes, key=lambda w: w.id)
 
         # Give every worker an index indicating how many workers came before it on that host
-        workers_per_host = defaultdict(lambda: 0)
+        workers_per_host = defaultdict(int)
         for worker_node in worker_nodes_by_id:
             host = worker_node.id.split("_")[0]
             worker_node._index_within_host = workers_per_host[host]

{locust-2.20.2.dev42 → locust-2.20.2.dev49}/locust/runners.py

@@ -215,8 +215,7 @@ class Runner:
             self.update_state(STATE_SPAWNING)
 
         logger.debug(
-            "Spawning additional %s (%s already running)..."
-            % (json.dumps(user_classes_spawn_count), json.dumps(self.user_classes_count))
+            f"Spawning additional {json.dumps(user_classes_spawn_count)} ({json.dumps(self.user_classes_count)} already running)..."
         )
 
         def spawn(user_class: str, spawn_count: int) -> list[User]:
@@ -902,7 +901,7 @@ class MasterRunner(DistributedRunner):
         self.stop(send_stop_to_client=False)
         logger.debug("Quitting...")
         for client in self.clients.all:
-            logger.debug("Sending quit message to worker %s (index %s)" % (client.id, self.get_worker_index(client.id)))
+            logger.debug(f"Sending quit message to worker {client.id} (index {self.get_worker_index(client.id)})")
             self.server.send_to_client(Message("quit", None, client.id))
         gevent.sleep(0.5)  # wait for final stats report from all workers
         self.greenlet.kill(block=True)
@@ -1123,7 +1122,7 @@ class MasterRunner(DistributedRunner):
 
     @property
     def reported_user_classes_count(self) -> dict[str, int]:
-        reported_user_classes_count: dict[str, int] = defaultdict(lambda: 0)
+        reported_user_classes_count: dict[str, int] = defaultdict(int)
         for client in self.clients.ready + self.clients.spawning + self.clients.running:
             for name, count in client.user_classes_count.items():
                 reported_user_classes_count[name] += count
@@ -1139,11 +1138,11 @@ class MasterRunner(DistributedRunner):
                             If None, will send to all attached workers
         """
         if client_id:
-            logger.debug("Sending %s message to worker %s" % (msg_type, client_id))
+            logger.debug(f"Sending {msg_type} message to worker {client_id}")
             self.server.send_to_client(Message(msg_type, data, client_id))
         else:
             for client in self.clients.all:
-                logger.debug("Sending %s message to worker %s" % (msg_type, client.id))
+                logger.debug(f"Sending {msg_type} message to worker {client.id}")
                 self.server.send_to_client(Message(msg_type, data, client.id))
 
 

{locust-2.20.2.dev42 → locust-2.20.2.dev49}/locust/user/task.py

@@ -423,11 +423,7 @@ class TaskSet(metaclass=TaskSetMeta):
             return random.randint(self.min_wait, self.max_wait) / 1000.0
         else:
             raise MissingWaitTimeError(
-                "You must define a wait_time method on either the %s or %s class"
-                % (
-                    type(self.user).__name__,
-                    type(self).__name__,
-                )
+                "You must define a wait_time method on either the {type(self.user).__name__} or {type(self).__name__} class"
             )
 
     def wait(self):

{locust-2.20.2.dev42 → locust-2.20.2.dev49/locust.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: locust
-Version: 2.20.2.dev42
+Version: 2.20.2.dev49
 Summary: Developer friendly load testing framework
 License: MIT
 Project-URL: Homepage, https://locust.io/

{locust-2.20.2.dev42 → locust-2.20.2.dev49}/pyproject.toml

@@ -60,6 +60,7 @@ license-files = ["LICENSE"]
 include-package-data = false
 
 [tool.ruff]
+target-version = "py38"
 line-length = 120
 extend-exclude = [
     "build",
@@ -67,7 +68,7 @@ extend-exclude = [
     "src/readthedocs-sphinx-search/",
 ]
 ignore = ["E402", "E501", "E713", "E731", "E741", "F401"]
-select = ["E", "F", "W"]
+select = ["E", "F", "W", "UP", "FA102"]
 
 [tool.ruff.per-file-ignores]
 "examples/*" = ["F841"]