mite 2.0.2__tar.gz → 2.1.0__tar.gz

{mite-2.0.2 → mite-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mite
-Version: 2.0.2
+Version: 2.1.0
 Summary: A Python Performance Testing Framework
 Home-page: https://github.com/sky-uk/mite/
 Classifier: License :: OSI Approved :: MIT License

{mite-2.0.2 → mite-2.1.0}/docker_compose.yml

@@ -1,4 +1,3 @@
-version: '3.9'
 services:
   apiserver:
     image: python:3.11-alpine3.16

{mite-2.0.2 → mite-2.1.0}/docker_compose_monitoring.yml

@@ -1,4 +1,3 @@
-version: '3.9'
 services:
   prometheus:
     image: "prom/prometheus:latest"

{mite-2.0.2 → mite-2.1.0}/mite/__main__.py

@@ -56,41 +56,45 @@ Examples:
 
 
 Options:
-    -h --help                               Show this screen
-    --version                               Show version
-    --debugging                             Drop into debugger (pdb) on journey error and exit.  Select debugger with PYTHONBREAKPOINT and PYTHONPOSTMORTEM
-    --memory-tracing                        Print heap alloc diffs every 60 seconds
-    --log-level=LEVEL                       Set logger level, one of DEBUG, INFO, WARNING, ERROR, CRITICAL [default: INFO]
-    --config=CONFIG_SPEC                    Set a config loader to a callable loaded via a spec [default: mite.config:default_config_loader]
-    --add-to-config=NEW_VALUE               Add a key:value to the config map, in addition to what's loaded from a file
-    --spawn-rate=NUM_PER_SECOND             Maximum spawn rate [default: 1000]
-    --max-loop-delay=SECONDS                Runner internal loop delay maximum [default: 1]
-    --min-loop-delay=SECONDS                Runner internal loop delay minimum [default: 0]
-    --runner-max-journeys=NUMBER            Max number of concurrent journeys a runner can run
-    --controller-socket=SOCKET              Controller socket [default: tcp://127.0.0.1:14301]
-    --message-socket=SOCKET                 Message socket [default: tcp://127.0.0.1:14302]
-    --collector-socket=SOCKET               Socket [default: tcp://127.0.0.1:14303]
-    --stats-in-socket=SOCKET                Socket [default: tcp://127.0.0.1:14304]
-    --stats-out-socket=SOCKET               Socket [default: tcp://127.0.0.1:14305]
-    --stats-include-processors=PROCESSORS   Stats processor names to include, as a comma separated list (no spaces)
-    --stats-exclude-processors=PROCESSORS   Stats processor names to exclude, as a comma separated list (no spaces)
-    --recorder-socket=SOCKET                Socket [default: tcp://127.0.0.1:14306]
-    --delay-start-seconds=DELAY             Delay start allowing others to connect [default: 0]
-    --volume=VOLUME                         Volume to run journey at [default: 1]
-    --web-address=HOST_PORT                 Web bind address [default: 127.0.0.1:9301]
-    --message-backend=BACKEND               Backend to transport messages over [default: ZMQ]
-    --exclude-working-directory             By default mite puts the current directory on the python path
-    --collector-dir=DIRECTORY               Set the collectors output directory [default: collector_data]
-    --collector-filter=SPEC                 Function spec to filter messages collected by the collector
-    --collector-roll=NUM_LINES              How many lines per collector output file [default: 100000]
-    --collector-use-json                    Output in json format rather than msgpack
-    --recorder-dir=DIRECTORY                Set the recorders output directory [default: recorder_data]
-    --sleep-time=SLEEP                      Set the second to await between each request [default: 1]
-    --logging-webhook=URL                   URL of an HTTP server to log test runs to
-    --message-processors=PROCESSORS         Classes to connect to the message bus for local testing [default: mite.logoutput:HttpStatsOutput,mite.logoutput:MsgOutput]
-    --prettify-timestamps                   Reformat unix timestamps to human readable dates
-    --journey-logging                       Log errors on a per journey basis
-    --max-errors-threshold=THRESHOLD        Set the maximum number of errors accepted before setting exit status to 1 [default: 0]
+    -h --help                                 Show this screen
+    --version                                 Show version
+    --debugging                               Drop into debugger (pdb) on journey error and exit.  Select debugger with PYTHONBREAKPOINT and PYTHONPOSTMORTEM
+    --memory-tracing                          Print heap alloc diffs every 60 seconds
+    --log-level=LEVEL                         Set logger level, one of DEBUG, INFO, WARNING, ERROR, CRITICAL [default: INFO]
+    --config=CONFIG_SPEC                      Set a config loader to a callable loaded via a spec [default: mite.config:default_config_loader]
+    --add-to-config=NEW_VALUE                 Add a key:value to the config map, in addition to what's loaded from a file
+    --spawn-rate=NUM_PER_SECOND               Maximum spawn rate [default: 1000]
+    --max-loop-delay=SECONDS                  Runner internal loop delay maximum [default: 1]
+    --min-loop-delay=SECONDS                  Runner internal loop delay minimum [default: 0]
+    --runner-max-journeys=NUMBER              Max number of concurrent journeys a runner can run
+    --controller-socket=SOCKET                Controller socket [default: tcp://127.0.0.1:14301]
+    --message-socket=SOCKET                   Message socket [default: tcp://127.0.0.1:14302]
+    --collector-socket=SOCKET                 Socket [default: tcp://127.0.0.1:14303]
+    --stats-in-socket=SOCKET                  Socket [default: tcp://127.0.0.1:14304]
+    --stats-out-socket=SOCKET                 Socket [default: tcp://127.0.0.1:14305]
+    --stats-include-processors=PROCESSORS     Stats processor names to include, as a comma separated list (no spaces)
+    --stats-exclude-processors=PROCESSORS     Stats processor names to exclude, as a comma separated list (no spaces)
+    --recorder-socket=SOCKET                  Socket [default: tcp://127.0.0.1:14306]
+    --delay-start-seconds=DELAY               Delay start allowing others to connect [default: 0]
+    --volume=VOLUME                           Volume to run journey at [default: 1]
+    --web-address=HOST_PORT                   Web bind address [default: 127.0.0.1:9301]
+    --message-backend=BACKEND                 Backend to transport messages over [default: ZMQ]
+    --exclude-working-directory               By default mite puts the current directory on the python path
+    --collector-dir=DIRECTORY                 Set the collectors output directory [default: collector_data]
+    --collector-filter=SPEC                   Function spec to filter messages collected by the collector
+    --collector-roll=NUM_LINES                How many lines per collector output file [default: 100000]
+    --collector-use-json                      Output in json format rather than msgpack
+    --recorder-dir=DIRECTORY                  Set the recorders output directory [default: recorder_data]
+    --sleep-time=SLEEP                        Set the second to await between each request [default: 1]
+    --logging-webhook=URL                     URL of an HTTP server to log test runs to
+    --message-processors=PROCESSORS           Classes to connect to the message bus for local testing [default: mite.logoutput:HttpStatsOutput,mite.logoutput:MsgOutput]
+    --prettify-timestamps                     Reformat unix timestamps to human readable dates
+    --journey-logging                         Log errors on a per journey basis
+    --report                                  Report stats at the end of the test
+    --hide-constant-logs                      Hide logs that are printed every 2 seconds
+    --max-errors-threshold=THRESHOLD          Set the maximum number of errors accepted before setting exit status to 1 [default: 0]
+    --max-response-time-threshold=THRESHOLD   Set the maximum response time accepted before setting exit status to 1 [default: 0]
+    --mean-response-time-threshold=THRESHOLD  Set the mean response time accepted before setting exit status to 1 [default: 0]
 """
 import asyncio
 import logging

{mite-2.0.2 → mite-2.1.0}/mite/cli/test.py

@@ -2,6 +2,7 @@ import asyncio
 import gc
 import logging
 import sys
+import time
 import tracemalloc
 
 from mite.datapools import SingleRunDataPoolWrapper
@@ -142,7 +143,7 @@ def test_scenarios(test_name, opts, scenarios, config_manager):
 
     tasks = [
         loop.create_task(controller_report(controller, receiver)),
-        loop.create_task(_create_runner(opts, transport, receiver.recieve).run())
+        loop.create_task(_create_runner(opts, transport, receiver.recieve).run()),
     ]
 
     if opts["--memory-tracing"]:
@@ -152,12 +153,28 @@ def test_scenarios(test_name, opts, scenarios, config_manager):
 
     loop.run_until_complete(asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED))
 
+    http_stats_output._scenarios_completed_time = time.time()
+
     # Run one last report before exiting
     controller.report(receiver.recieve)
     has_error = http_stats_output is not None and http_stats_output.error_total > int(
         opts.get("--max-errors-threshold")
     )
 
+    if opts.get("--max-response-time-threshold") != "0":
+        max_response_time = http_stats_output._resp_time_max * 1000
+        if max_response_time > int(opts["--max-response-time-threshold"]):
+            has_error = True
+            logging.error("Max response time exceeded: %sms", max_response_time)
+    if opts.get("--mean-response-time-threshold") != "0":
+        mean_response_time = http_stats_output.mean_resp_time * 1000
+        if mean_response_time > int(opts["--mean-response-time-threshold"]):
+            has_error = True
+            logging.error("Mean response time exceeded: %sms", mean_response_time)
+
+    if opts.get("--report"):
+        benchmark_report(opts, http_stats_output)
+
     # Ensure any open files get closed
     del receiver._raw_listeners
     del receiver._listeners
@@ -165,6 +182,43 @@ def test_scenarios(test_name, opts, scenarios, config_manager):
     sys.exit(int(has_error))
 
 
+def human_readable_bytes(size):
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if size < 1024.0:
+            return size, unit
+        size /= 1024.0
+    return size, "PB"
+
+
+def benchmark_report(opts, http_stats_output):
+    report_output = """
+
+\t\tAvg\t\tMin\t\tMax
+Latency\t\t{mean_resp_time:.2f}ms\t\t{min_resp_time:.2f}ms\t\t{max_resp_time:.2f}ms
+Req/Sec\t\t{req_per_sec_mean:.2f}\t\t{min_req_per_sec:.2f}\t\t{max_req_per_sec:.2f}
+
+{total_reqs} requests in {total_time:.2f}s, {data_transfer:.2f}{data_unit} data transfered
+"""
+
+    data_transfer, data_unit = human_readable_bytes(http_stats_output._data_transferred)
+
+    print(
+        report_output.format(
+            mean_resp_time=http_stats_output.mean_resp_time * 1000,
+            min_resp_time=http_stats_output._resp_time_min * 1000,
+            max_resp_time=http_stats_output._resp_time_max * 1000,
+            req_per_sec_mean=http_stats_output.req_sec_mean,
+            min_req_per_sec=http_stats_output._req_sec_min,
+            max_req_per_sec=http_stats_output._req_sec_max,
+            total_reqs=http_stats_output._req_total,
+            total_time=http_stats_output._scenarios_completed_time
+            - http_stats_output._init_time,
+            data_transfer=data_transfer,
+            data_unit=data_unit,
+        )
+    )
+
+
 def scenario_test_cmd(opts):
     scenario_spec = opts["SCENARIO_SPEC"]
     config_manager = _create_config_manager(opts)

{mite-2.0.2 → mite-2.1.0}/mite/logoutput.py

@@ -42,13 +42,23 @@ class GenericStatsOutput:
         self._journey_logging = opts.get("--journey-logging", False)
         if self._journey_logging is not False:
             self._journey_logging = True
+        self._hide_constant_logs = opts.get("--hide-constant-logs")
         self._logger = logging.getLogger(f"{self.log_name} Stats")
+        self._init_time = time.time()
         self._start_t = None
         self._req_total = 0
         self._req_recent = 0
         self._error_total = 0
         self._error_recent = 0
         self._resp_time_recent = []
+        self._resp_time_min = 0
+        self._resp_time_max = 0
+        self._resp_time_mean = 0
+        self._resp_time_mean_store = []
+        self._req_sec_min = 0
+        self._req_sec_max = 0
+        self._scenarios_completed_time = 0
+        self._data_transferred = 0
         self._error_journeys = defaultdict(int)
 
     def _pct(self, percentile):
@@ -80,18 +90,20 @@ class GenericStatsOutput:
     def print_output(self, t):
         dt = t - self._start_t
         self._resp_time_recent.sort()
-        self._logger.info(f"Total> #Reqs:{self._req_total} #Errs:{self._error_total}")
+        if not self._hide_constant_logs:
+            self._logger.info(f"Total> #Reqs:{self._req_total} #Errs:{self._error_total}")
         # only output journey logs if the --journey_logging switch is set
         if self._journey_logging:
             for k, v in self._error_journeys.items():
                 self._logger.info(f"Total errors for {k} :{v}")
-        self._logger.info(
-            f"Last {self._period} Secs> #Reqs:{self._req_recent} #Errs:{self._error_recent} "
-            + f"Req/S:{self._req_recent / dt:.1f} min:{self._pct(0)} "
-            + f"25%:{self._pct(25)} 50%:{self._pct(50)} 75%:{self._pct(75)} "
-            + f"90%:{self._pct(90)} 99%:{self._pct(99)} 99.9%:{self._pct(99.9)} "
-            + f"max:{self._pct(100)}",
-        )
+        if not self._hide_constant_logs:
+            self._logger.info(
+                f"Last {self._period} Secs> #Reqs:{self._req_recent} #Errs:{self._error_recent} "
+                + f"Req/S:{self._req_recent / dt:.1f} min:{self._pct(0)} "
+                + f"25%:{self._pct(25)} 50%:{self._pct(50)} 75%:{self._pct(75)} "
+                + f"90%:{self._pct(90)} 99%:{self._pct(99)} 99.9%:{self._pct(99.9)} "
+                + f"max:{self._pct(100)}",
+            )
         self._start_t = t
         del self._resp_time_recent[:]
         self._req_recent = 0
@@ -105,9 +117,32 @@ class GenericStatsOutput:
         if self._start_t is None:
             self._start_t = t
         if self._start_t + self._period < t:
+
+            if self._resp_time_recent:
+                if self._resp_time_min == 0:
+                    self._resp_time_min = self.min_resp_time
+                else:
+                    self._resp_time_min = min(self.min_resp_time, self._resp_time_min)
+
+                self._resp_time_max = max(self.max_resp_time_recent, self._resp_time_max)
+
+            self._resp_time_mean_store.append(
+                sum(self._resp_time_recent) / len(self._resp_time_recent)
+            )
+
+            if self._req_recent:
+                req_sec = self._req_recent / (t - self._start_t)
+                if self._req_sec_min == 0:
+                    self._req_sec_min = req_sec
+                else:
+                    self._req_sec_min = min(req_sec, self._req_sec_min)
+
+                self._req_sec_max = max(req_sec, self._req_sec_max)
+
             self.print_output(t)
         if msg_type in self.message_types:
             self._resp_time_recent.append(message["total_time"])
+            self._data_transferred += message.get("download_size", 0)
             self._req_total += 1
             self._req_recent += 1
         elif msg_type in ("error", "exception"):
@@ -117,6 +152,28 @@ class GenericStatsOutput:
                 journey_name = message.get("journey")
                 self._error_journeys[journey_name] += 1
 
+    @property
+    def mean_resp_time(self):
+        if not self._resp_time_mean_store:
+            return 0
+        return sum(self._resp_time_mean_store) / len(self._resp_time_mean_store)
+
+    @property
+    def max_resp_time_recent(self):
+        if not self._resp_time_recent:
+            return 0
+        return max(self._resp_time_recent)
+
+    @property
+    def min_resp_time(self):
+        if not self._resp_time_recent:
+            return 0
+        return min(self._resp_time_recent)
+
+    @property
+    def req_sec_mean(self):
+        return self._req_total / (self._scenarios_completed_time - self._init_time)
+
 
 class HttpStatsOutput(GenericStatsOutput):
     message_types = {

{mite-2.0.2 → mite-2.1.0}/mite.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mite
-Version: 2.0.2
+Version: 2.1.0
 Summary: A Python Performance Testing Framework
 Home-page: https://github.com/sky-uk/mite/
 Classifier: License :: OSI Approved :: MIT License

{mite-2.0.2 → mite-2.1.0}/mite_http/__init__.py

@@ -82,6 +82,7 @@ class SessionPool:
                 total_time=r.total_time,
                 primary_ip=r.primary_ip,
                 method=r.request.method,
+                download_size=r.download_size,
                 **session_wrapper.additional_metrics,
             )