locust-cloud 1.8.0__py3-none-any.whl → 1.10.0__py3-none-any.whl

locust_cloud/__init__.py

@@ -1,10 +1,10 @@
 import importlib.metadata
 import os
+import sys
 
 os.environ["LOCUST_SKIP_MONKEY_PATCH"] = "1"
 __version__ = importlib.metadata.version("locust-cloud")
 
-import argparse
 import logging
 
 import configargparse
@@ -19,38 +19,29 @@ from locust_cloud.timescale.query import register_query
 from psycopg.conninfo import make_conninfo
 from psycopg_pool import ConnectionPool
 
-GRAPH_VIEWER = os.environ.get("GRAPH_VIEWER")
 logger = logging.getLogger(__name__)
 
 
 @events.init_command_line_parser.add_listener
 def add_arguments(parser: LocustArgumentParser):
-    if not (os.environ.get("PGHOST") or GRAPH_VIEWER):
+    if not (os.environ.get("PGHOST")):
         parser.add_argument_group(
             "locust-cloud",
             "locust-cloud disabled, because PGHOST was not set - this is normal for local runs",
         )
         return
 
+    try:
+        REGION = os.environ["AWS_DEFAULT_REGION"]
+    except KeyError:
+        logger.fatal("Missing AWS_DEFAULT_REGION env var")
+        sys.exit(1)
+
     os.environ["LOCUST_BUILD_PATH"] = os.path.join(os.path.dirname(__file__), "webui/dist")
     locust_cloud = parser.add_argument_group(
         "locust-cloud",
         "Arguments for use with Locust cloud",
     )
-    locust_cloud.add_argument(
-        "--exporter",
-        default=True,
-        action=argparse.BooleanOptionalAction,
-        env_var="LOCUST_EXPORTER",
-        help="Exports Locust stats to Timescale",
-    )
-    locust_cloud.add_argument(
-        "--description",
-        type=str,
-        env_var="LOCUST_DESCRIPTION",
-        default="",
-        help="Description of the test being run",
-    )
     # do not set
     # used for sending the run id from master to workers
     locust_cloud.add_argument(
@@ -59,6 +50,27 @@ def add_arguments(parser: LocustArgumentParser):
         env_var="LOCUSTCLOUD_RUN_ID",
         help=configargparse.SUPPRESS,
     )
+    locust_cloud.add_argument(
+        "--allow-signup",
+        env_var="LOCUSTCLOUD_ALLOW_SIGNUP",
+        help=configargparse.SUPPRESS,
+        default=False,
+        action="store_true",
+    )
+    locust_cloud.add_argument(
+        "--graph-viewer",
+        env_var="LOCUSTCLOUD_GRAPH_VIEWER",
+        help=configargparse.SUPPRESS,
+        default=False,
+        action="store_true",
+    )
+    locust_cloud.add_argument(
+        "--deployer-url",
+        type=str,
+        env_var="LOCUSTCLOUD_DEPLOYER_URL",
+        help=configargparse.SUPPRESS,
+        default=f"https://api.{REGION}.locust.cloud/1",
+    )
 
 
 def set_autocommit(conn: psycopg.Connection):
@@ -86,14 +98,12 @@ def on_locust_init(environment: locust.env.Environment, **_args):
         logger.exception(e)
         raise
 
-    if not GRAPH_VIEWER:
+    if not environment.parsed_options.graph_viewer:
         IdleExit(environment)
-
-    if not GRAPH_VIEWER and environment.parsed_options and environment.parsed_options.exporter:
         Exporter(environment, pool)
 
     if environment.web_ui:
-        if GRAPH_VIEWER:
+        if environment.parsed_options.graph_viewer:
             environment.web_ui.template_args["isGraphViewer"] = True
 
         register_auth(environment)

locust_cloud/auth.py

@@ -1,17 +1,15 @@
 import logging
 import os
 from datetime import UTC, datetime, timedelta
-from typing import TypedDict
+from typing import Any, TypedDict, cast
 
 import locust.env
 import requests
 import werkzeug
-from flask import redirect, request, url_for
+from flask import Blueprint, redirect, request, session, url_for
 from flask_login import UserMixin, login_user
+from locust.html import render_template_from
 from locust_cloud import __version__
-from locust_cloud.constants import DEFAULT_DEPLOYER_URL
-
-DEPLOYER_URL = os.environ.get("LOCUSTCLOUD_DEPLOYER_URL", DEFAULT_DEPLOYER_URL)
 
 logger = logging.getLogger(__name__)
 
@@ -44,9 +42,12 @@ def set_credentials(username: str, credentials: Credentials, response: werkzeug.
 
 
 def register_auth(environment: locust.env.Environment):
-    environment.web_ui.app.config["SECRET_KEY"] = os.getenv("SECRET_KEY")
+    environment.web_ui.app.config["SECRET_KEY"] = os.getenv("SECRET_KEY", "") + os.getenv("CUSTOMER_ID", "")
     environment.web_ui.app.debug = False
 
+    web_base_path = environment.parsed_options.web_base_path
+    auth_blueprint = Blueprint("locust_cloud_auth", __name__, url_prefix=web_base_path)
+
     def load_user(user_sub_id: str):
         username = request.cookies.get("username")
         refresh_token = request.cookies.get("user_token")
@@ -58,18 +59,26 @@ def register_auth(environment: locust.env.Environment):
         return None
 
     environment.web_ui.login_manager.user_loader(load_user)
-    environment.web_ui.auth_args = {
-        "username_password_callback": "/authenticate",
-    }
+    environment.web_ui.auth_args = cast(
+        Any,
+        {
+            "username_password_callback": f"{web_base_path}/authenticate",
+        },
+    )
+
+    if environment.parsed_options.allow_signup:
+        environment.web_ui.auth_args["auth_providers"] = [
+            {"label": "Sign Up", "callback_url": f"{web_base_path}/signup"}
+        ]
 
-    @environment.web_ui.app.route("/authenticate", methods=["POST"])
+    @auth_blueprint.route("/authenticate", methods=["POST"])
     def login_submit():
         username = request.form.get("username", "")
         password = request.form.get("password")
 
         try:
             auth_response = requests.post(
-                f"{DEPLOYER_URL}/auth/login",
+                f"{environment.parsed_options.deployer_url}/auth/login",
                 json={"username": username, "password": password},
                 headers={"X-Client-Version": __version__},
             )
@@ -77,19 +86,180 @@ def register_auth(environment: locust.env.Environment):
             auth_response.raise_for_status()
 
             credentials = auth_response.json()
-            response = redirect(url_for("index"))
+
+            if os.getenv("CUSTOMER_ID", "") and credentials["user_sub_id"] != os.getenv("CUSTOMER_ID", ""):
+                session["auth_error"] = "Invalid login for this deployment"
+                return redirect(url_for("locust.login"))
+
+            response = redirect(url_for("locust.index"))
             response = set_credentials(username, credentials, response)
             login_user(AuthUser(credentials["user_sub_id"]))
 
             return response
         except requests.exceptions.HTTPError as e:
             if e.response.status_code == 401:
-                environment.web_ui.auth_args["error"] = "Invalid username or password"
+                session["auth_error"] = "Invalid username or password"
             else:
                 logger.error(f"Unknown response from auth: {e.response.status_code} {e.response.text}")
 
-                environment.web_ui.auth_args["error"] = (
-                    "Unknown error during authentication, check logs and/or contact support"
-                )
+                session["auth_error"] = "Unknown error during authentication, check logs and/or contact support"
+
+            return redirect(url_for("locust.login"))
+
+    @auth_blueprint.route("/signup")
+    def signup():
+        if not environment.parsed_options.allow_signup:
+            return redirect(url_for("locust.login"))
+
+        if session.get("username"):
+            sign_up_args = {
+                "custom_form": {
+                    "inputs": [
+                        {
+                            "label": "Confirmation Code",
+                            "name": "confirmation_code",
+                            "is_required": True,
+                        },
+                    ],
+                    "callback_url": f"{web_base_path}/confirm-signup",
+                    "submit_button_text": "Confirm Email",
+                },
+            }
+        else:
+            sign_up_args = {
+                "custom_form": {
+                    "inputs": [
+                        {
+                            "label": "Username",
+                            "name": "username",
+                            "is_required": True,
+                        },
+                        {
+                            "label": "Full Name",
+                            "name": "full_name",
+                            "is_required": True,
+                        },
+                        {
+                            "label": "Password",
+                            "name": "password",
+                            "is_secret": True,
+                            "is_required": True,
+                        },
+                        {
+                            "label": "Access Code",
+                            "name": "access_code",
+                            "is_required": True,
+                        },
+                        {
+                            "label": "I consent to:\n\n1. Only test your own website/service or our example target\n\n2. Only use locust-cloud for its intended purpose: to load test other sites/services.\n\n3. Not attempt to circumvent your account limitations (e.g. max user count or max request count)\n\n4. Not use personal data (real names, addresses etc) in your tests.",
+                            "name": "consent",
+                            "default_value": False,
+                            "is_required": True,
+                        },
+                    ],
+                    "callback_url": f"{web_base_path}/create-account",
+                    "submit_button_text": "Sign Up",
+                },
+            }
+
+        if session.get("auth_info"):
+            sign_up_args["info"] = session["auth_info"]
+        if session.get("auth_sign_up_error"):
+            sign_up_args["error"] = session["auth_sign_up_error"]
+
+        return render_template_from(
+            "auth.html",
+            auth_args=sign_up_args,
+        )
+
+    @auth_blueprint.route("/create-account", methods=["POST"])
+    def create_account():
+        if not environment.parsed_options.allow_signup:
+            return redirect(url_for("locust.login"))
+
+        session["auth_sign_up_error"] = ""
+        session["auth_info"] = ""
+
+        username = request.form.get("username", "")
+        full_name = request.form.get("full_name", "")
+        password = request.form.get("password")
+        access_code = request.form.get("access_code")
+
+        try:
+            auth_response = requests.post(
+                f"{environment.parsed_options.deployer_url}/auth/signup",
+                json={"username": username, "password": password, "access_code": access_code},
+            )
+
+            auth_response.raise_for_status()
+
+            session["user_sub"] = auth_response.json().get("user_sub")
+            session["username"] = username
+            session["full_name"] = full_name
+            session["auth_info"] = (
+                "Please check your email and enter the confirmation code. If you didn't get a code after one minute, you can [request a new one](/resend-code)"
+            )
+
+            return redirect(url_for("locust_cloud_auth.signup"))
+        except requests.exceptions.HTTPError as e:
+            message = e.response.json().get("Message", "An unexpected error occured. Please try again.")
+            session["auth_info"] = ""
+            session["auth_sign_up_error"] = message
+
+            return redirect(url_for("locust_cloud_auth.signup"))
+
+    @auth_blueprint.route("/resend-code")
+    def resend_code():
+        try:
+            auth_response = requests.post(
+                f"{environment.parsed_options.deployer_url}/1/auth/resend-confirmation",
+                json={"username": session["username"]},
+            )
+
+            auth_response.raise_for_status()
+
+            session["auth_sign_up_error"] = ""
+            session["auth_info"] = "Confirmation code sent, please check your email."
+
+            return redirect(url_for("locust_cloud_auth.signup"))
+        except requests.exceptions.HTTPError as e:
+            message = e.response.json().get("Message", "An unexpected error occured. Please try again.")
+            session["auth_info"] = ""
+            session["auth_sign_up_error"] = message
+
+            return redirect(url_for("locust_cloud_auth.signup"))
+
+    @auth_blueprint.route("/confirm-signup", methods=["POST"])
+    def confirm_signup():
+        if not environment.parsed_options.allow_signup:
+            return redirect(url_for("locust.login"))
+
+        session["auth_sign_up_error"] = ""
+        confirmation_code = request.form.get("confirmation_code")
+
+        try:
+            auth_response = requests.post(
+                f"{environment.parsed_options.deployer_url}/auth/confirm-signup",
+                json={
+                    "username": session.get("username"),
+                    "full_name": session.get("full_name"),
+                    "user_sub": session["user_sub"],
+                    "confirmation_code": confirmation_code,
+                },
+            )
+
+            auth_response.raise_for_status()
+
+            session["username"] = None
+            session["auth_info"] = "Account created successfully!"
+            session["auth_sign_up_error"] = ""
+
+            return redirect("https://docs.locust.cloud/")
+        except requests.exceptions.HTTPError as e:
+            message = e.response.json().get("Message", "An unexpected error occured. Please try again.")
+            session["auth_info"] = ""
+            session["auth_sign_up_error"] = message
+
+            return redirect(url_for("locust_cloud_auth.signup"))
 
-            return redirect(url_for("login"))
+    environment.web_ui.app.register_blueprint(auth_blueprint)

locust_cloud/cloud.py

@@ -1,6 +1,5 @@
 import json
 import logging
-import math
 import os
 import sys
 import time
@@ -14,13 +13,6 @@ import configargparse
 import requests
 from botocore.exceptions import ClientError
 from locust_cloud import __version__
-from locust_cloud.constants import (
-    DEFAULT_CLUSTER_NAME,
-    DEFAULT_DEPLOYER_URL,
-    DEFAULT_NAMESPACE,
-    DEFAULT_REGION_NAME,
-    USERS_PER_WORKER,
-)
 from locust_cloud.credential_manager import CredentialError, CredentialManager
 
 
@@ -110,29 +102,9 @@ advanced.add_argument(
 advanced.add_argument(
     "--region",
     type=str,
-    default=os.environ.get("AWS_DEFAULT_REGION", DEFAULT_REGION_NAME),
+    default="eu-north-1",  # temp setup for pycon # os.environ.get("AWS_DEFAULT_REGION")
     help="Sets the AWS region to use for the deployed cluster, e.g. us-east-1. It defaults to use AWS_DEFAULT_REGION env var, like AWS tools.",
 )
-advanced.add_argument(
-    "--kube-cluster-name",
-    type=str,
-    default=DEFAULT_CLUSTER_NAME,
-    help=configargparse.SUPPRESS,
-    env_var="KUBE_CLUSTER_NAME",
-)
-advanced.add_argument(
-    "--kube-namespace",
-    type=str,
-    default=DEFAULT_NAMESPACE,
-    help=configargparse.SUPPRESS,
-    env_var="KUBE_NAMESPACE",
-)
-parser.add_argument(
-    "--deployer-url",
-    type=str,
-    default=DEFAULT_DEPLOYER_URL,
-    help=configargparse.SUPPRESS,
-)
 parser.add_argument(
     "--aws-access-key-id",
     type=str,
@@ -162,7 +134,7 @@ parser.add_argument(
 parser.add_argument(
     "--workers",
     type=int,
-    help=f"Number of workers to use for the deployment. Defaults to number of users divided by {USERS_PER_WORKER}.",
+    help="Number of workers to use for the deployment. Defaults to number of users divided by 500, but the default may be customized for your account.",
     default=None,
 )
 parser.add_argument(
@@ -176,6 +148,12 @@ parser.add_argument(
     default="latest",
     help=configargparse.SUPPRESS,  # overrides the locust-cloud docker image tag. for internal use
 )
+parser.add_argument(
+    "--mock-server",
+    action="store_true",
+    default=False,
+    help=configargparse.SUPPRESS,
+)
 
 options, locust_options = parser.parse_known_args()
 options: Namespace
@@ -194,25 +172,30 @@ logging.getLogger("requests").setLevel(logging.INFO)
 logging.getLogger("urllib3").setLevel(logging.INFO)
 
 
+api_url = f"https://api.{options.region}.locust.cloud/1"
+
+
 def main() -> None:
-    s3_bucket = f"{options.kube_cluster_name}-{options.kube_namespace}"
+    if not options.region:
+        logger.error(
+            "Setting a region is required to use Locust Cloud. Please ensure the AWS_DEFAULT_REGION env variable or the --region flag is set."
+        )
+        sys.exit(1)
+
+    s3_bucket = "dmdb-default" if options.region == "us-east-1" else "locust-default"
     deployments: list[Any] = []
-    worker_count: int = max(options.workers or math.ceil(options.users / USERS_PER_WORKER), 2)
-    os.environ["AWS_DEFAULT_REGION"] = options.region
 
-    try:
-        if not (
-            (options.username and options.password) or (options.aws_access_key_id and options.aws_secret_access_key)
-        ):
-            logger.error(
-                "Authentication is required to use Locust Cloud. Please ensure the LOCUST_CLOUD_USERNAME and LOCUST_CLOUD_PASSWORD environment variables are set."
-            )
-            sys.exit(1)
+    if not ((options.username and options.password) or (options.aws_access_key_id and options.aws_secret_access_key)):
+        logger.error(
+            "Authentication is required to use Locust Cloud. Please ensure the LOCUST_CLOUD_USERNAME and LOCUST_CLOUD_PASSWORD environment variables are set."
+        )
+        sys.exit(1)
 
-        logger.info(f"Authenticating ({os.environ['AWS_DEFAULT_REGION']}, v{__version__})")
-        logger.debug(f"Lambda url: {options.deployer_url}")
+    try:
+        logger.info(f"Authenticating ({options.region}, v{__version__})")
+        logger.debug(f"Lambda url: {api_url}")
         credential_manager = CredentialManager(
-            lambda_url=options.deployer_url,
+            lambda_url=api_url,
             access_key=options.aws_access_key_id,
             secret_key=options.aws_secret_access_key,
             username=options.username,
@@ -226,17 +209,18 @@ def main() -> None:
         aws_session_token = credentials.get("token", "")
 
         if options.delete:
-            delete(s3_bucket, credential_manager)
+            delete(credential_manager)
             return
 
         logger.info(f"Uploading {options.locustfile}")
         logger.debug(f"... to {s3_bucket}")
         s3 = credential_manager.session.client("s3")
         try:
-            s3.upload_file(options.locustfile, s3_bucket, os.path.basename(options.locustfile))
+            filename = options.username + "__" + os.path.basename(options.locustfile)
+            s3.upload_file(options.locustfile, s3_bucket, filename)
             locustfile_url = s3.generate_presigned_url(
                 ClientMethod="get_object",
-                Params={"Bucket": s3_bucket, "Key": os.path.basename(options.locustfile)},
+                Params={"Bucket": s3_bucket, "Key": filename},
                 ExpiresIn=3600,
             )
             logger.debug(f"Uploaded {options.locustfile} successfully")
@@ -251,10 +235,11 @@ def main() -> None:
         if options.requirements:
             logger.info(f"Uploading {options.requirements}")
             try:
-                s3.upload_file(options.requirements, s3_bucket, "requirements.txt")
+                filename = options.username + "__" + "requirements.txt"
+                s3.upload_file(options.requirements, s3_bucket, filename)
                 requirements_url = s3.generate_presigned_url(
                     ClientMethod="get_object",
-                    Params={"Bucket": s3_bucket, "Key": "requirements.txt"},
+                    Params={"Bucket": s3_bucket, "Key": filename},
                     ExpiresIn=3600,
                 )
                 logger.debug(f"Uploaded {options.requirements} successfully")
@@ -279,20 +264,22 @@ def main() -> None:
             ]
             and os.environ[env_variable]
         ]
-        deploy_endpoint = f"{options.deployer_url}/{options.kube_cluster_name}"
+        deploy_endpoint = f"{api_url}/deploy"
         payload = {
             "locust_args": [
                 {"name": "LOCUST_LOCUSTFILE", "value": locustfile_url},
                 {"name": "LOCUST_USERS", "value": str(options.users)},
                 {"name": "LOCUST_FLAGS", "value": " ".join(locust_options)},
                 {"name": "LOCUSTCLOUD_REQUIREMENTS_URL", "value": requirements_url},
-                {"name": "LOCUSTCLOUD_DEPLOYER_URL", "value": options.deployer_url},
+                {"name": "LOCUSTCLOUD_DEPLOYER_URL", "value": api_url},
                 *locust_env_variables,
             ],
-            "worker_count": worker_count,
             "user_count": options.users,
             "image_tag": options.image_tag,
+            "mock_server": options.mock_server,
         }
+        if options.workers is not None:
+            payload["worker_count"] = options.workers
         headers = {
             "Authorization": f"Bearer {cognito_client_id_token}",
             "Content-Type": "application/json",
@@ -325,7 +312,7 @@ def main() -> None:
         logger.debug("Interrupted by user")
         sys.exit(0)
 
-    log_group_name = f"/eks/{options.kube_cluster_name}-{options.kube_namespace}"
+    log_group_name = "/eks/dmdb-default" if options.region == "us-east-1" else "/eks/locust-default"
     master_pod_name = next((deployment for deployment in deployments if "master" in deployment), None)
 
     if not master_pod_name:
@@ -399,10 +386,10 @@ def main() -> None:
         logger.exception(e)
         sys.exit(1)
     finally:
-        delete(s3_bucket, credential_manager)
+        delete(credential_manager)
 
 
-def delete(s3_bucket, credential_manager):
+def delete(credential_manager):
     try:
         logger.info("Tearing down Locust cloud...")
         credential_manager.refresh_credentials()
@@ -420,9 +407,8 @@ def delete(s3_bucket, credential_manager):
             headers["AWS_SESSION_TOKEN"] = token
 
         response = requests.delete(
-            f"{options.deployer_url}/{options.kube_cluster_name}",
+            f"{api_url}/teardown",
             headers=headers,
-            params={"namespace": options.kube_namespace} if options.kube_namespace else {},
         )
 
         if response.status_code != 200:
@@ -435,9 +421,9 @@ def delete(s3_bucket, credential_manager):
 
     try:
         logger.debug("Cleaning up locustfiles")
-        s3 = credential_manager.session.resource("s3")
-        bucket = s3.Bucket(s3_bucket)
-        bucket.objects.all().delete()
+        # s3 = credential_manager.session.resource("s3")
+        # bucket = s3.Bucket(s3_bucket)
+        # bucket.objects.all().delete()
     except ClientError as e:
         logger.debug(f"Failed to clean up locust files: {e}")
         # sys.exit(1)

locust_cloud/credential_manager.py

@@ -100,13 +100,16 @@ class CredentialManager:
 
         except requests.exceptions.HTTPError as http_err:
             response = http_err.response
-            if response is not None and response.status_code == 401:
+            if response is None:
+                raise CredentialError("Response was None?!") from http_err
+
+            if response.status_code == 401:
                 raise CredentialError("Incorrect username or password.") from http_err
             else:
                 if js := response.json():
                     if message := js.get("Message"):
                         raise CredentialError(message)
-                error_info = f"HTTP {response.status_code} {response.reason}" if response else "No response received."
+                error_info = f"HTTP {response.status_code} {response.reason}"
                 raise CredentialError(f"HTTP error occurred while obtaining credentials: {error_info}") from http_err
         except requests.exceptions.RequestException as req_err:
             raise CredentialError(f"Request exception occurred while obtaining credentials: {req_err}") from req_err

locust_cloud/timescale/exporter.py

@@ -217,7 +217,7 @@ class Exporter:
         cmd = sys.argv[1:]
         with self.pool.connection() as conn:
             conn.execute(
-                "INSERT INTO testruns (id, num_users, worker_count, username, locustfile, description, arguments, customer) VALUES (%s,%s,%s,%s,%s,%s,%s,current_user)",
+                "INSERT INTO testruns (id, num_users, worker_count, username, locustfile, arguments, customer) VALUES (%s,%s,%s,%s,%s,%s,current_user)",
                 (
                     self._run_id,
                     self.env.runner.target_user_count if self.env.runner else 1,
@@ -228,8 +228,7 @@ class Exporter:
                     )
                     else 0,
                     self.env.web_ui.template_args.get("username", "") if self.env.web_ui else "",
-                    self.env.parsed_locustfiles[0].split("/")[-1],
-                    self.env.parsed_options.description,
+                    self.env.parsed_locustfiles[0].split("/")[-1].split("__")[-1],
                     " ".join(cmd),
                 ),
             )

locust_cloud/timescale/queries.py

@@ -262,7 +262,7 @@ ORDER BY a.time
 
 total_vuh = """
 SELECT
-  SUM((end_time - id) * num_users) AS "totalVuh"
+  COALESCE(SUM((end_time - id) * num_users), '0') AS "totalVuh"
 FROM testruns
 WHERE id >= date_trunc('month', NOW()) AND NOT refund
 """

locust_cloud/timescale/query.py

@@ -1,6 +1,6 @@
 import logging
 
-from flask import make_response, request
+from flask import Blueprint, make_response, request
 from flask_login import login_required
 from locust_cloud.timescale.queries import queries
 
@@ -12,7 +12,11 @@ def adapt_timestamp(result):
 
 
 def register_query(environment, pool):
-    @environment.web_ui.app.route("/cloud-stats/<query>", methods=["POST"])
+    cloud_stats_blueprint = Blueprint(
+        "locust_cloud_stats", __name__, url_prefix=environment.parsed_options.web_base_path
+    )
+
+    @cloud_stats_blueprint.route("/cloud-stats/<query>", methods=["POST"])
     @login_required
     def query(query):
         results = []
@@ -57,7 +61,9 @@ def register_query(environment, pool):
                 return results
             else:
                 logger.warning(f"Received invalid query key: '{query}'")
-                return make_response("Invalid query key", 401)
+                return make_response({"error": "Invalid query key"}, 401)
         except Exception as e:
             logger.info(f"Error executing UI query '{query}': {e}", exc_info=True)
-            return make_response("Error executing query", 401)
+            return make_response({"error": "Error executing query"}, 401)
+
+    environment.web_ui.app.register_blueprint(cloud_stats_blueprint)

locust_cloud/webui/.eslintrc

@@ -29,7 +29,7 @@
             "group": "internal",
           },
           {
-            "pattern": "{components,hooks,redux,utils}/**",
+            "pattern": "{components,hooks,redux,types,utils}/**",
             "group": "internal",
           },
         ],