locust read load testing (#1055)

* starting locust load test

* locust is working

* clean up kubernetes config files for testing locust

* add locust dev dep, and update locust readme

* add a better locust simulator, trying to get the api key working

* fix typo in docs

* add test_locust.py because I am getting auth errors

* update header

* Update the ReadingUser, need to figure out how to get the WritingUser working

* Add draft of writing user

* found out that tiled-dev doesn't support writing

* only load test reading in this PR

* locust reading test are working well now

* add locust tasks for the remaining GET endpoints

* locust remove redendant debug logs

* undo pyarrow version updates because it is being addressed in another pr

* locust touchup

* touch up locust README

* default to localhost if --host is not given

* locust reader touch up

* add a task for each search type

* get the search tasks working

* add --container-name arg, and create the container if it doesn't exist

* touch up

Author: gwbischof

docs/source/how-to/api-keys.md

@@ -72,7 +72,7 @@ This text is the API key. **It should be handled as a secret.**
 We can use it in the Python client:
 
 ```py
->>> from tiled.client import from_url
+>>> from tiled.client import from_uri
 >>> API_KEY = "YOUR_KEY_HERE"
 >>> c = from_uri("http://localhost:8000", api_key=API_KEY)
 ```
@@ -88,7 +88,7 @@ and then start Python (or IPython, or Jupyter, or...). The Python client will
 use that, unless it is explicitly passed different credentials.
 
 ```py
->>> from tiled.client import from_url
+>>> from tiled.client import from_uri
 >>> c = from_uri("http://localhost:8000")  # uses TILED_API_KEY, if set
 ```
 

docs/source/reference/http-api-overview.md

@@ -44,7 +44,7 @@ nested under `/api/v1/auth/`.
 
 To view and try the *interactive* docs, visit
 
-[http://tiled-demoblueskyproject.io/docs](http://tiled-demoblueskyproject.io/docs)
+[http://tiled-demo.blueskyproject.io/docs](http://tiled-demo.blueskyproject.io/docs)
 
 or, to work fully locally, start the Tiled server with the demo
 Tree from a Terminal

locust/README.md

@@ -0,0 +1,35 @@
+# Tiled Load Testing with Locust
+
+Simple load testing for Tiled using the `reader.py` file.
+
+## Quick Start
+
+```bash
+# Install dependencies (dev environment includes locust)
+pixi install -e dev
+```
+
+### Examples
+Run with default localhost server (uses default API key 'secret'):
+```bash
+pixi run -e dev locust -f reader.py --host http://localhost:8000
+```
+
+Run with custom API key:
+```bash
+pixi run -e dev locust -f reader.py --host http://localhost:8000 --api-key your-api-key
+```
+
+Run with custom container name (defaults to locust_testing):
+```bash
+pixi run -e dev locust -f reader.py --host http://localhost:8000 --container-name my_test_container
+```
+
+## Headless Mode
+Run without the web interface:
+```bash
+pixi run -e dev locust -f reader.py --headless -u 100 -r 10 -t 60s
+```
+- `-u 100`: 100 concurrent users
+- `-r 10`: Spawn 10 users per second
+- `-t 60s`: Run for 60 seconds

locust/reader.py

@@ -0,0 +1,253 @@
+import json
+import logging
+
+import numpy as np
+import pyarrow
+
+from locust import HttpUser, between, events, task
+from tiled.client import from_uri
+
+
+@events.init_command_line_parser.add_listener
+def _(parser):
+    parser.add_argument(
+        "--api-key",
+        type=str,
+        default="secret",
+        help="API key for Tiled authentication (default: secret)",
+    )
+    parser.add_argument(
+        "--container-name",
+        type=str,
+        default="locust_testing",
+        help="Container name for test data (default: locust_testing)",
+    )
+
+
+@events.init.add_listener
+def on_locust_init(environment, **kwargs):
+    if environment.host is None:
+        raise ValueError(
+            "Host must be specified with --host argument, or through the web-ui."
+        )
+
+    environment.container_name = environment.parsed_options.container_name
+    environment.known_dataset_key = create_test_dataset(
+        environment.host, environment.parsed_options.api_key, environment.container_name
+    )
+
+
+def create_test_dataset(host, api_key, container_name):
+    """Create a test dataset using Tiled client for reading tasks"""
+
+    # Connect to Tiled server using client
+    root_client = from_uri(host, api_key=api_key)
+
+    # Create container if it doesn't exist
+    if container_name not in root_client:
+        root_client.create_container(container_name)
+    client = root_client[container_name]
+
+    rng = np.random.default_rng(seed=42)
+    rng.integers(10, size=100, dtype=np.dtype("uint8"))
+
+    # Write and read tabular data to the SQL storage
+    table = pyarrow.Table.from_pydict({"a": rng.random(100), "b": rng.random(100)})
+
+    table_client = client.create_appendable_table(table.schema)
+    table_client.append_partition(table, 0)
+
+    # Verify we can read it back
+    result = table_client.read()
+    logging.debug(f"Created and verified dataset: {result}")
+
+    dataset_id = table_client.item["id"]
+    client.logout()
+    return dataset_id
+
+
+class ReadingUser(HttpUser):
+    """User that reads data from Tiled using HTTP API"""
+
+    wait_time = between(0.5, 2)
+
+    def on_start(self):
+        self.client.headers = {
+            "Authorization": f"Apikey {self.environment.parsed_options.api_key}"
+        }
+
+    @task(1)
+    def read_table_data(self):
+        """Read table data from our known dataset"""
+        # Read the table data we created
+        self.client.get(
+            f"/api/v1/table/full/{self.environment.container_name}/{self.environment.known_dataset_key}",
+        )
+
+    @task(1)
+    def read_metadata(self):
+        """Read metadata from our known dataset"""
+        self.client.get(
+            f"/api/v1/metadata/{self.environment.container_name}/{self.environment.known_dataset_key}",
+        )
+
+    @task(1)
+    def root_endpoint(self):
+        """Test root endpoint performance"""
+        self.client.get("/")
+
+    @task(1)
+    def metadata_root(self):
+        """Test metadata root endpoint"""
+        self.client.get("/api/v1/metadata/")
+
+    @task(1)
+    def read_table_partition(self):
+        """Read specific partition from our known dataset"""
+        url = (
+            f"/api/v1/table/partition/{self.environment.container_name}/"
+            f"{self.environment.known_dataset_key}?partition=0"
+        )
+        self.client.get(url)
+
+    @task(1)
+    def healthz_endpoint(self):
+        """Test health check endpoint"""
+        self.client.get("/healthz")
+
+    @task(1)
+    def metrics_endpoint(self):
+        """Test Prometheus metrics endpoint"""
+        self.client.get("/api/v1/metrics")
+
+    @task(1)
+    def about_endpoint(self):
+        """Test API information endpoint"""
+        self.client.get("/api/v1/")
+
+    @task(1)
+    def search_root(self):
+        """Test search at root level"""
+        self.client.get("/api/v1/search/")
+
+    @task(1)
+    def container_full_endpoint(self):
+        """Test container full data endpoint"""
+        self.client.get(f"/api/v1/container/full/{self.environment.container_name}")
+
+    @task(1)
+    def whoami_endpoint(self):
+        """Test user identity endpoint"""
+        self.client.get("/api/v1/auth/whoami")
+
+    @task(1)
+    def search_fulltext(self):
+        """Test fulltext search queries"""
+        params = {"filter[fulltext][condition][text]": "test"}
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_with_limit(self):
+        """Test search with limit parameter"""
+        params = {"page[limit]": 5}
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_with_pagination(self):
+        """Test search with offset and limit parameters"""
+        params = {"page[offset]": 10, "page[limit]": 5}
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_with_sort(self):
+        """Test search with sort parameter"""
+        params = {"sort": "key"}
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_with_max_depth(self):
+        """Test search with max_depth parameter"""
+        params = {"max_depth": 1}
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_structure_family(self):
+        """Test structure family search queries"""
+        params = {"filter[structure_family][condition][value]": ["table"]}
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_with_omit_links(self):
+        """Test search with omit_links parameter"""
+        params = {"omit_links": "true"}
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_with_data_sources(self):
+        """Test search with include_data_sources parameter"""
+        params = {"include_data_sources": "true"}
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_eq(self):
+        """Test equality search queries"""
+        params = {
+            "filter[eq][condition][key]": "structure_family",
+            "filter[eq][condition][value]": json.dumps("table"),
+        }
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_noteq(self):
+        """Test not equal search queries"""
+        params = {
+            "filter[noteq][condition][key]": "structure_family",
+            "filter[noteq][condition][value]": json.dumps("array"),
+        }
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_comparison(self):
+        """Test comparison search queries"""
+        params = {
+            "filter[comparison][condition][operator]": "gt",
+            "filter[comparison][condition][key]": "id",
+            "filter[comparison][condition][value]": json.dumps(0),
+        }
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_like(self):
+        """Test like search queries"""
+        params = {
+            "filter[like][condition][key]": "key",
+            "filter[like][condition][pattern]": json.dumps("%"),
+        }
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_contains(self):
+        """Test contains search queries"""
+        params = {
+            "filter[contains][condition][key]": "key",
+            "filter[contains][condition][value]": json.dumps("locust"),
+        }
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_in(self):
+        """Test in search queries"""
+        params = {
+            "filter[in][condition][key]": "structure_family",
+            "filter[in][condition][value]": '["table", "array"]',
+        }
+        self.client.get("/api/v1/search/", params=params)
+
+    @task(1)
+    def search_notin(self):
+        """Test not in search queries"""
+        params = {
+            "filter[notin][condition][key]": "structure_family",
+            "filter[notin][condition][value]": '["sparse"]',
+        }
+        self.client.get("/api/v1/search/", params=params)

pyproject.toml

@@ -150,6 +150,7 @@ dev = [
     "importlib_resources;python_version < \"3.9\"",
     "ipython",
     "ldap3",
+    "locust",
     "matplotlib",
     "mistune",
     "myst-parser",