locust 2.20.2.dev40__tar.gz → 2.20.2.dev49__tar.gz

{locust-2.20.2.dev40 → 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.dev40/locust.egg-info → locust-2.20.2.dev49}/PKG-INFO

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

{locust-2.20.2.dev40 → 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.dev40 → locust-2.20.2.dev49}/docs/running-distributed.rst

@@ -4,29 +4,25 @@
 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. If the workers are not on the same machine as the master you use ``--master-host`` to point them to the IP/hostname of the machine running the master.
+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 make this easier, you can use the ``--processes`` flag to launch multiple instances. By default it will launch a master process and the specified number of worker processes. Used in combination with ``--worker`` it will only launch the workers.
+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::
-    ``--processes`` was introduced in Locust 2.19 and is somewhat experimental. Child processes are launched using fork, which is not available in Windows.
-
-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.
-
-Both the master and worker machines must have a copy of the locustfile when running Locust distributed.
+    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.
+    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 there is no warning, you can be pretty sure your test is not limited by load generator CPU.
+    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>`_.
 
-Example 1: Everything on one machine
-====================================
+Single machine
+==============
 
 It is really simple to launch a master and 4 worker processes::
 
@@ -36,23 +32,23 @@ You can even auto-detect the number of cores in your machine and launch one work
 
     locust --processes -1
 
-Example 2: Multiple machines
-============================
+Multiple machines
+=================
 
 Start locust in master mode on one machine::
 
     locust -f my_locustfile.py --master
 
-And then on each worker machine:
+And then on each worker machine (make sure they also have a copy of the locustfile)::
 
 .. code-block:: bash
 
     locust -f my_locustfile.py --worker --master-host <your master's address> --processes 4
 
-Example 2.1: Multiple machines, using locust-swarm
-==================================================
+Multiple machines, using locust-swarm
+=====================================
 
-Both worker and master need access to the locustfile, and when you make changes to it you'll need to restart all Locust processes. `locust-swarm <https://github.com/SvenskaSpel/locust-swarm>`_ automates this for you. It also solves the issue of firewall/network access from workers to master using SSH tunnels (this is often a problem if master is running on your workstation and workers are running in some datacenter).
+Both worker and master need access to the locustfile, and when you make changes to it you'll need to restart all Locust processes. `locust-swarm <https://github.com/SvenskaSpel/locust-swarm>`_ automates this for you. It also solves the issue of firewall/network access from workers to master using SSH tunnels (this is often a problem if the master is running on your workstation and workers are running in some datacenter).
 
 .. code-block:: bash
 
@@ -98,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.dev40 → locust-2.20.2.dev49}/docs/what-is-locust.rst

@@ -52,9 +52,7 @@ load against a dynamic website where most pages had different content for differ
 verbose configuration files to declare the tests. In Locust we took a different approach. Instead of configuration formats or UIs 
 you'd get a python framework that would let you define the behaviour of your users using Python code. 
 
-`Locust <https://en.wikipedia.org/wiki/Locust>`_ takes its name from the grasshopper species, known for their swarming behaviour. 
-
-Previous versions of Locust used terminology borrowed from nature (swarming, hatching, attacking etc), but now employs more industry standard naming.
+Locust takes its name from the `grasshopper species <https://en.wikipedia.org/wiki/Locust>`_, known for their swarming behaviour. 
 
 :ref:`history`
 

{locust-2.20.2.dev40 → 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.dev40'
-__version_tuple__ = version_tuple = (2, 20, 2, 'dev40')
+__version__ = version = '2.20.2.dev49'
+__version_tuple__ = version_tuple = (2, 20, 2, 'dev49')

{locust-2.20.2.dev40 → 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.dev40 → 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.dev40 → 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.dev40 → locust-2.20.2.dev49/locust.egg-info}/PKG-INFO

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

{locust-2.20.2.dev40 → 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"]