agent-starter-pack 0.0.1b0__py3-none-any.whl

src/deployment_targets/agent_engine/tests/load_test/.results/results_exceptions.csv

@@ -0,0 +1 @@
+Count,Message,Traceback,Nodes

src/deployment_targets/agent_engine/tests/load_test/.results/results_failures.csv

@@ -0,0 +1 @@
+Method,Name,Error,Occurrences

src/deployment_targets/agent_engine/tests/load_test/.results/results_stats.csv

@@ -0,0 +1,3 @@
+Type,Name,Request Count,Failure Count,Median Response Time,Average Response Time,Min Response Time,Max Response Time,Average Content Size,Requests/s,Failures/s,50%,66%,75%,80%,90%,95%,98%,99%,99.9%,99.99%,100%
+STREAM_END,reasoning_engine_stream_end,18,0,2400.0,2360.90800497267,1843.3630466461182,2849.168300628662,1650.2222222222222,1.101276838322333,0.0,2400,2400,2500,2500,2600,2800,2800,2800,2800,2800,2800
+,Aggregated,18,0,2400.0,2360.90800497267,1843.3630466461182,2849.168300628662,1650.2222222222222,1.101276838322333,0.0,2400,2400,2500,2500,2600,2800,2800,2800,2800,2800,2800

src/deployment_targets/agent_engine/tests/load_test/.results/results_stats_history.csv

@@ -0,0 +1,22 @@
+Timestamp,User Count,Type,Name,Requests/s,Failures/s,50%,66%,75%,80%,90%,95%,98%,99%,99.9%,99.99%,100%,Total Request Count,Total Failure Count,Total Median Response Time,Total Average Response Time,Total Min Response Time,Total Max Response Time,Total Average Content Size
+1737391419,0,,Aggregated,0.000000,0.000000,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,0,0,0,0.0,0,0,0
+1737391420,1,,Aggregated,0.000000,0.000000,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,0,0,0,0.0,0,0,0
+1737391421,2,,Aggregated,0.000000,0.000000,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,N/A,0,0,0,0.0,0,0,0
+1737391422,2,,Aggregated,0.000000,0.000000,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,1,0,2390.5889987945557,2390.5889987945557,2390.5889987945557,2390.5889987945557,1637.0
+1737391423,3,,Aggregated,0.000000,0.000000,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,2,0,1900.0,2129.990339279175,1869.391679763794,2390.5889987945557,1641.5
+1737391424,3,,Aggregated,0.000000,0.000000,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,2,0,1900.0,2129.990339279175,1869.391679763794,2390.5889987945557,1641.5
+1737391425,4,,Aggregated,0.000000,0.000000,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,2,0,1900.0,2129.990339279175,1869.391679763794,2390.5889987945557,1641.5
+1737391426,4,,Aggregated,0.400000,0.000000,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,4,0,2400.0,2269.8291540145874,1869.391679763794,2444.993019104004,1643.75
+1737391427,5,,Aggregated,0.400000,0.000000,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,2400,4,0,2400.0,2269.8291540145874,1869.391679763794,2444.993019104004,1643.75
+1737391428,5,,Aggregated,0.285714,0.000000,2400,2400,2400,2400,2500,2500,2500,2500,2500,2500,2500,6,0,2400.0,2324.6165911356607,1869.391679763794,2451.6820907592773,1644.5
+1737391429,6,,Aggregated,0.285714,0.000000,2400,2400,2400,2400,2500,2500,2500,2500,2500,2500,2500,6,0,2400.0,2324.6165911356607,1869.391679763794,2451.6820907592773,1644.5
+1737391430,6,,Aggregated,0.444444,0.000000,2400,2400,2400,2400,2500,2500,2500,2500,2500,2500,2500,9,0,2400.0,2345.083819495307,1869.391679763794,2451.6820907592773,1645.0
+1737391431,7,,Aggregated,0.444444,0.000000,2400,2400,2400,2400,2500,2500,2500,2500,2500,2500,2500,9,0,2400.0,2345.083819495307,1869.391679763794,2451.6820907592773,1645.0
+1737391432,7,,Aggregated,0.600000,0.000000,2400,2400,2400,2400,2500,2500,2500,2500,2500,2500,2500,12,0,2400.0,2364.6987676620483,1869.391679763794,2516.0341262817383,1646.8333333333333
+1737391433,8,,Aggregated,0.600000,0.000000,2400,2400,2400,2400,2500,2500,2500,2500,2500,2500,2500,12,0,2400.0,2364.6987676620483,1869.391679763794,2516.0341262817383,1646.8333333333333
+1737391434,8,,Aggregated,0.900000,0.000000,2400,2400,2500,2500,2500,2800,2800,2800,2800,2800,2800,14,0,2400.0,2411.8646723883494,1869.391679763794,2849.168300628662,1651.4285714285713
+1737391435,9,,Aggregated,1.100000,0.000000,2400,2400,2500,2500,2500,2800,2800,2800,2800,2800,2800,16,0,2400.0,2379.8188269138336,1869.391679763794,2849.168300628662,1650.75
+1737391437,9,,Aggregated,1.000000,0.000000,2400,2400,2500,2500,2600,2800,2800,2800,2800,2800,2800,18,0,2400.0,2360.90800497267,1843.3630466461182,2849.168300628662,1650.2222222222222
+1737391438,10,,Aggregated,1.000000,0.000000,2400,2400,2500,2500,2600,2800,2800,2800,2800,2800,2800,18,0,2400.0,2360.90800497267,1843.3630466461182,2849.168300628662,1650.2222222222222
+1737391439,10,,Aggregated,1.000000,0.000000,2400,2400,2500,2500,2600,2800,2800,2800,2800,2800,2800,18,0,2400.0,2360.90800497267,1843.3630466461182,2849.168300628662,1650.2222222222222
+1737391440,10,,Aggregated,1.000000,0.000000,2400,2400,2500,2500,2600,2800,2800,2800,2800,2800,2800,18,0,2400.0,2360.90800497267,1843.3630466461182,2849.168300628662,1650.2222222222222

src/deployment_targets/agent_engine/tests/load_test/README.md

@@ -0,0 +1,42 @@
+# Robust Load Testing for Generative AI Applications
+
+This directory provides a comprehensive load testing framework for your Generative AI application, leveraging the power of [Locust](http://locust.io), a leading open-source load testing tool.
+
+##  Load Testing
+
+Before running load tests, ensure you have deployed the backend remotely.
+
+Follow these steps to execute load tests:
+
+**1. Deploy the Backend Remotely:**
+   ```bash
+   gcloud config set project <your-dev-project-id>
+   make backend
+   ```
+
+**2. Create a Virtual Environment for Locust:**
+   It's recommended to use a separate terminal tab and create a virtual environment for Locust to avoid conflicts with your application's Python environment.
+
+   ```bash
+   # Create and activate virtual environment
+   python3 -m venv locust_env
+   source locust_env/bin/activate
+   
+   # Install required packages
+   pip install locust==2.31.1 "google-cloud-aiplatform[langchain,reasoningengine]>=1.77.0"
+   ```
+
+**3. Execute the Load Test:**
+   Trigger the Locust load test with the following command:
+
+   ```bash
+   export _AUTH_TOKEN=$(gcloud auth print-access-token -q)
+   locust -f tests/load_test/load_test.py \
+   --headless \
+   -t 30s -u 5 -r 2 \
+   --csv=tests/load_test/.results/results \
+   --html=tests/load_test/.results/report.html
+   ```
+
+   This command initiates a 30-second load test, simulating 2 users spawning per second, reaching a maximum of 10 concurrent users.
+

src/deployment_targets/agent_engine/tests/load_test/load_test.py

@@ -0,0 +1,100 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import logging
+import os
+import time
+
+from locust import HttpUser, between, task
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Initialize Vertex AI and load agent config
+with open("deployment_metadata.json") as f:
+    remote_agent_engine_id = json.load(f)["remote_agent_engine_id"]
+
+parts = remote_agent_engine_id.split("/")
+project_id = parts[1]
+location = parts[3]
+engine_id = parts[5]
+
+# Convert remote agent engine ID to streaming URL.
+base_url = f"https://{location}-aiplatform.googleapis.com"
+url_path = f"/v1beta1/projects/{project_id}/locations/{location}/reasoningEngines/{engine_id}:streamQuery"
+
+logger.info("Using remote agent engine ID: %s", remote_agent_engine_id)
+logger.info("Using base URL: %s", base_url)
+logger.info("Using URL path: %s", url_path)
+
+
+class ChatStreamUser(HttpUser):
+    """Simulates a user interacting with the chat stream API."""
+
+    wait_time = between(1, 3)  # Wait 1-3 seconds between tasks
+    host = base_url  # Set the base host URL for Locust
+
+    @task
+    def chat_stream(self) -> None:
+        """Simulates a chat stream interaction."""
+        headers = {"Content-Type": "application/json"}
+        headers["Authorization"] = f"Bearer {os.environ['_AUTH_TOKEN']}"
+
+        data = {
+            "input": {
+                "input": {
+                    "messages": [
+                        {"type": "human", "content": "Hello, AI!"},
+                        {"type": "ai", "content": "Hello!"},
+                        {"type": "human", "content": "How are you?"},
+                    ]
+                },
+                "config": {
+                    "metadata": {"user_id": "test-user", "session_id": "test-session"}
+                },
+            }
+        }
+
+        start_time = time.time()
+        with self.client.post(
+            url_path,
+            headers=headers,
+            json=data,
+            catch_response=True,
+            name="/stream_messages first message",
+            stream=True,
+            params={"alt": "sse"},
+        ) as response:
+            if response.status_code == 200:
+                events = []
+                for line in response.iter_lines():
+                    if line:
+                        event = json.loads(line)
+                        events.append(event)
+                end_time = time.time()
+                total_time = end_time - start_time
+                self.environment.events.request.fire(
+                    request_type="POST",
+                    name="/stream_messages end",
+                    response_time=total_time * 1000,  # Convert to milliseconds
+                    response_length=len(json.dumps(events)),
+                    response=response,
+                    context={},
+                )
+            else:
+                response.failure(f"Unexpected status code: {response.status_code}")

src/deployment_targets/agent_engine/tests/unit/test_dummy.py

@@ -0,0 +1,22 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+You can add your unit tests here.
+"""
+
+
+def test_dummy() -> None:
+    """Placeholder - replace with real tests."""
+    assert 1 == 1

src/deployment_targets/cloud_run/Dockerfile

@@ -0,0 +1,29 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FROM python:3.11-slim
+
+RUN pip install --no-cache-dir uv
+
+WORKDIR /code
+
+COPY ./pyproject.toml ./README.md ./uv.lock* ./
+
+COPY ./app ./app
+
+RUN uv sync --frozen
+
+EXPOSE 8080
+
+CMD ["uv", "run", "uvicorn", "app.server:app", "--host", "0.0.0.0", "--port", "8080"]

src/deployment_targets/cloud_run/app/server.py

@@ -0,0 +1,128 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import os
+from collections.abc import Generator
+
+from fastapi import FastAPI
+from fastapi.responses import RedirectResponse, StreamingResponse
+from google.cloud import logging as google_cloud_logging
+from langchain_core.runnables import RunnableConfig
+from traceloop.sdk import Instruments, Traceloop
+
+from app.agent import agent
+from app.utils.tracing import CloudTraceLoggingSpanExporter
+from app.utils.typing import Feedback, InputChat, Request, dumps, ensure_valid_config
+
+# Initialize FastAPI app and logging
+app = FastAPI(
+    title="{{cookiecutter.project_name}}",
+    description="API for interacting with the Agent {{cookiecutter.project_name}}",
+)
+logging_client = google_cloud_logging.Client()
+logger = logging_client.logger(__name__)
+
+# Initialize Telemetry
+try:
+    Traceloop.init(
+        app_name=app.title,
+        disable_batch=False,
+        exporter=CloudTraceLoggingSpanExporter(),
+        instruments={% raw %}{{% endraw %}{%- for instrumentation in cookiecutter.otel_instrumentations %}{{ instrumentation }}{% if not loop.last %}, {% endif %}{%- endfor %}{% raw %}}{% endraw %},
+    )
+except Exception as e:
+    logging.error("Failed to initialize Telemetry: %s", str(e))
+
+
+def set_tracing_properties(config: RunnableConfig) -> None:
+    """Sets tracing association properties for the current request.
+
+    Args:
+        config: Optional RunnableConfig containing request metadata
+    """
+    Traceloop.set_association_properties(
+        {
+            "log_type": "tracing",
+            "run_id": str(config.get("run_id", "None")),
+            "user_id": config["metadata"].pop("user_id", "None"),
+            "session_id": config["metadata"].pop("session_id", "None"),
+            "commit_sha": os.environ.get("COMMIT_SHA", "None"),
+        }
+    )
+
+
+def stream_messages(
+    input: InputChat,
+    config: RunnableConfig | None = None,
+) -> Generator[str, None, None]:
+    """Stream events in response to an input chat.
+
+    Args:
+        input: The input chat messages
+        config: Optional configuration for the runnable
+
+    Yields:
+        JSON serialized event data
+    """
+    config = ensure_valid_config(config=config)
+    set_tracing_properties(config)
+    input_dict = input.model_dump()
+
+    for data in agent.stream(input_dict, config=config, stream_mode="messages"):
+        yield dumps(data) + "\n"
+
+
+# Routes
+@app.get("/", response_class=RedirectResponse)
+def redirect_root_to_docs() -> RedirectResponse:
+    """Redirect the root URL to the API documentation."""
+    return RedirectResponse(url="/docs")
+
+
+@app.post("/feedback")
+def collect_feedback(feedback: Feedback) -> dict[str, str]:
+    """Collect and log feedback.
+
+    Args:
+        feedback: The feedback data to log
+
+    Returns:
+        Success message
+    """
+    logger.log_struct(feedback.model_dump(), severity="INFO")
+    return {"status": "success"}
+
+
+@app.post("/stream_messages")
+def stream_chat_events(request: Request) -> StreamingResponse:
+    """Stream chat events in response to an input request.
+
+    Args:
+        request: The chat request containing input and config
+
+    Returns:
+        Streaming response of chat events
+    """
+    return StreamingResponse(
+        stream_messages(input=request.input, config=request.config),
+        media_type="text/event-stream",
+    )
+
+
+# Main execution
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

src/deployment_targets/cloud_run/deployment/terraform/artifact_registry.tf

@@ -0,0 +1,22 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+resource "google_artifact_registry_repository" "repo-artifacts-genai" {
+  location      = var.region
+  repository_id = var.artifact_registry_repo_name
+  description   = "Repo for Generative AI applications"
+  format        = "DOCKER"
+  project       = var.cicd_runner_project_id
+  depends_on    = [resource.google_project_service.cicd_services, resource.google_project_service.shared_services]
+}

src/deployment_targets/cloud_run/deployment/terraform/dev/service_accounts.tf

@@ -0,0 +1,20 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+resource "google_service_account" "cloud_run_app_sa" {
+  account_id   = var.cloud_run_app_sa_name
+  display_name = "Cloud Run Generative AI app SA"
+  project      = var.dev_project_id
+  depends_on   = [resource.google_project_service.services]
+}

src/deployment_targets/cloud_run/tests/integration/test_server_e2e.py

@@ -0,0 +1,192 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import logging
+import os
+import subprocess
+import sys
+import threading
+import time
+import uuid
+from collections.abc import Iterator
+from typing import Any
+
+import pytest
+import requests
+from requests.exceptions import RequestException
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+BASE_URL = "http://127.0.0.1:8000/"
+STREAM_URL = BASE_URL + "stream_messages"
+FEEDBACK_URL = BASE_URL + "feedback"
+
+HEADERS = {"Content-Type": "application/json"}
+
+
+def log_output(pipe: Any, log_func: Any) -> None:
+    """Log the output from the given pipe."""
+    for line in iter(pipe.readline, ""):
+        log_func(line.strip())
+
+
+def start_server() -> subprocess.Popen[str]:
+    """Start the FastAPI server using subprocess and log its output."""
+    command = [
+        sys.executable,
+        "-m",
+        "uvicorn",
+        "app.server:app",
+        "--host",
+        "0.0.0.0",
+        "--port",
+        "8000",
+    ]
+    env = os.environ.copy()
+    env["INTEGRATION_TEST"] = "TRUE"
+    process = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=1,
+        env=env,
+    )
+
+    # Start threads to log stdout and stderr in real-time
+    threading.Thread(
+        target=log_output, args=(process.stdout, logger.info), daemon=True
+    ).start()
+    threading.Thread(
+        target=log_output, args=(process.stderr, logger.error), daemon=True
+    ).start()
+
+    return process
+
+
+def wait_for_server(timeout: int = 60, interval: int = 1) -> bool:
+    """Wait for the server to be ready."""
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        try:
+            response = requests.get("http://127.0.0.1:8000/docs", timeout=10)
+            if response.status_code == 200:
+                logger.info("Server is ready")
+                return True
+        except RequestException:
+            pass
+        time.sleep(interval)
+    logger.error(f"Server did not become ready within {timeout} seconds")
+    return False
+
+
+@pytest.fixture(scope="session")
+def server_fixture(request: Any) -> Iterator[subprocess.Popen[str]]:
+    """Pytest fixture to start and stop the server for testing."""
+    logger.info("Starting server process")
+    server_process = start_server()
+    if not wait_for_server():
+        pytest.fail("Server failed to start")
+    logger.info("Server process started")
+
+    def stop_server() -> None:
+        logger.info("Stopping server process")
+        server_process.terminate()
+        server_process.wait()
+        logger.info("Server process stopped")
+
+    request.addfinalizer(stop_server)
+    yield server_process
+
+
+def test_chat_stream(server_fixture: subprocess.Popen[str]) -> None:
+    """Test the chat stream functionality."""
+    logger.info("Starting chat stream test")
+
+    data = {
+        "input": {
+            "messages": [
+                {"type": "human", "content": "Hello, AI!"},
+                {"type": "ai", "content": "Hello!"},
+                {"type": "human", "content": "What is the weather in NY?"},
+            ]
+        },
+        "config": {"metadata": {"user_id": "test-user", "session_id": "test-session"}},
+    }
+
+    response = requests.post(
+        STREAM_URL, headers=HEADERS, json=data, stream=True, timeout=10
+    )
+    assert response.status_code == 200
+
+    events = [json.loads(line) for line in response.iter_lines() if line]
+    assert events, "No events received from stream"
+
+    # Verify each event is a tuple of message and metadata
+    for event in events:
+        assert isinstance(event, list), "Event should be a list"
+        assert len(event) == 2, "Event should contain message and metadata"
+        message, _ = event
+
+        # Verify message structure
+        assert isinstance(message, dict), "Message should be a dictionary"
+        assert message["type"] == "constructor"
+        assert "kwargs" in message, "Constructor message should have kwargs"
+
+    # Verify at least one message has content
+    has_content = False
+    for event in events:
+        message = event[0]
+        if message.get("type") == "constructor" and "content" in message["kwargs"]:
+            has_content = True
+            break
+    assert has_content, "At least one message should have content"
+
+
+def test_chat_stream_error_handling(server_fixture: subprocess.Popen[str]) -> None:
+    """Test the chat stream error handling."""
+    logger.info("Starting chat stream error handling test")
+
+    data = {
+        "input": {"messages": [{"type": "invalid_type", "content": "Cause an error"}]}
+    }
+    response = requests.post(
+        STREAM_URL, headers=HEADERS, json=data, stream=True, timeout=10
+    )
+
+    assert response.status_code == 422, (
+        f"Expected status code 422, got {response.status_code}"
+    )
+    logger.info("Error handling test completed successfully")
+
+
+def test_collect_feedback(server_fixture: subprocess.Popen[str]) -> None:
+    """
+    Test the feedback collection endpoint (/feedback) to ensure it properly
+    logs the received feedback.
+    """
+    # Create sample feedback data
+    feedback_data = {
+        "score": 4,
+        "run_id": str(uuid.uuid4()),
+        "text": "Great response!",
+    }
+
+    response = requests.post(
+        FEEDBACK_URL, json=feedback_data, headers=HEADERS, timeout=10
+    )
+    assert response.status_code == 200

src/deployment_targets/cloud_run/tests/load_test/README.md

@@ -0,0 +1,79 @@
+# Robust Load Testing for Generative AI Applications
+
+This directory provides a comprehensive load testing framework for your Generative AI application, leveraging the power of [Locust](http://locust.io), a leading open-source load testing tool.
+
+## Local Load Testing
+
+Follow these steps to execute load tests on your local machine:
+
+**1. Start the FastAPI Server:**
+
+Launch the FastAPI server in a separate terminal:
+
+```bash
+poetry run uvicorn app.server:app --host 0.0.0.0 --port 8000 --reload
+```
+
+**2. (In another tab) Create virtual environment with Locust**
+Using another terminal tab, This is suggested to avoid conflicts with the existing application python environment.
+
+```commandline
+python3 -m venv locust_env && source locust_env/bin/activate && pip install locust==2.31.1
+```
+
+**3. Execute the Load Test:**
+Trigger the Locust load test with the following command:
+
+```bash
+locust -f tests/load_test/load_test.py \
+-H http://127.0.0.1:8000 \
+--headless \
+-t 30s -u 60 -r 2 \
+--csv=tests/load_test/.results/results \
+--html=tests/load_test/.results/report.html
+```
+
+This command initiates a 30-second load test, simulating 2 users spawning per second, reaching a maximum of 60 concurrent users.
+
+**Results:**
+
+Comprehensive CSV and HTML reports detailing the load test performance will be generated and saved in the `tests/load_test/.results` directory.
+
+## Remote Load Testing (Targeting Cloud Run)
+
+This framework also supports load testing against remote targets, such as a staging Cloud Run instance. This process is seamlessly integrated into the Continuous Delivery pipeline via Cloud Build, as defined in the [pipeline file](cicd/cd/staging.yaml).
+
+**Prerequisites:**
+
+- **Dependencies:** Ensure your environment has the same dependencies required for local testing.
+- **Cloud Run Invoker Role:** You'll need the `roles/run.invoker` role to invoke the Cloud Run service.
+
+**Steps:**
+
+**1. Obtain Cloud Run Service URL:**
+
+Navigate to the Cloud Run console, select your service, and copy the URL displayed at the top. Set this URL as an environment variable:
+
+```bash
+export RUN_SERVICE_URL=https://your-cloud-run-service-url.run.app
+```
+
+**2. Obtain ID Token:**
+
+Retrieve the ID token required for authentication:
+
+```bash
+export _ID_TOKEN=$(gcloud auth print-identity-token -q)
+```
+
+**3. Execute the Load Test:**
+The following command executes the same load test parameters as the local test but targets your remote Cloud Run instance.
+
+```bash
+poetry run locust -f tests/load_test/load_test.py \
+-H $RUN_SERVICE_URL \
+--headless \
+-t 30s -u 60 -r 2 \
+--csv=tests/load_test/.results/results \
+--html=tests/load_test/.results/report.html
+```