fix: address load test review feedback

Author: lsy1307

scripts/load_test/README.md

@@ -53,7 +53,8 @@ Start workflow 동작:
    - datasource username/password는 Parameter Store에 복사하지 않습니다.
 5. load-test MySQL EC2 user data가 prod MySQL 백업 S3 bucket의 최신 dump를 내려받아 복원합니다.
 6. `scripts/load_test/start.sh`가 Terraform output에서 필요한 값을 읽습니다.
-7. `switch_stage_to_loadtest=true`이면 stage 앱을 `dev,loadtest` profile로 재기동합니다. username/password는 앱의 Parameter Store 연동이 loadtest 경로에서 읽습니다.
+7. `scripts/load_test/start.sh`가 SSM으로 load-test MySQL EC2의 `cloud-init` 완료와 `/opt/solid-connection/load-test-db-ready` marker 생성을 확인합니다. 기본 대기 시간은 3600초입니다.
+8. `switch_stage_to_loadtest=true`이면 stage 앱을 `dev,loadtest` profile로 재기동합니다. username/password는 앱의 Parameter Store 연동이 loadtest 경로에서 읽습니다.
 
 Start workflow는 load-generator EC2를 만들지 않습니다. 부하 생성용 EC2는 비용 누수를 막기 위해 Run workflow에서만 생성합니다.
 

scripts/load_test/generate_bruno_k6.py

@@ -12,14 +12,17 @@
 
 
 def brace_delta(line):
+    """Return the net brace balance contributed by a single Bruno line."""
     return line.count("{") - line.count("}")
 
 
 def read_text(path):
+    """Read a Bruno file while tolerating invalid byte sequences."""
     return path.read_text(encoding="utf-8", errors="replace")
 
 
 def collect_blocks(text):
+    """Collect top-level Bruno blocks keyed by block name."""
     lines = text.splitlines()
     blocks = {}
     index = 0
@@ -52,6 +55,7 @@ def collect_blocks(text):
 
 
 def parse_fields(block):
+    """Parse simple Bruno key-value fields from a block body."""
     fields = {}
     for line in block.splitlines():
         match = re.match(r"^\s*(~?[^:]+):\s*(.*)$", line)
@@ -63,6 +67,7 @@ def parse_fields(block):
 
 
 def parse_meta(blocks):
+    """Extract display metadata and sort order from parsed Bruno blocks."""
     meta = parse_fields(blocks.get("meta", [""])[0])
     seq = meta.get("seq", "999999")
     try:
@@ -76,6 +81,7 @@ def parse_meta(blocks):
 
 
 def parse_vars(blocks):
+    """Extract pre-request variables defined in Bruno request blocks."""
     variables = {}
     for block in blocks.get("vars:pre-request", []):
         for key, value in parse_fields(block).items():
@@ -84,10 +90,12 @@ def parse_vars(blocks):
 
 
 def clean_body_json(block):
+    """Return the JSON body text exactly as k6 should send it."""
     return block.strip()
 
 
 def parse_multipart(block):
+    """Parse Bruno multipart form fields into k6-friendly metadata."""
     fields = []
     for line in block.splitlines():
         match = re.match(r"^\s*(~?[^:]+):\s*(.*?)\s*$", line)
@@ -133,6 +141,7 @@ def parse_multipart(block):
 
 
 def parse_request(path, collection_dir):
+    """Parse one Bruno request file into the intermediate request model."""
     text = read_text(path)
     blocks = collect_blocks(text)
     method = next((name for name in HTTP_METHODS if name in blocks), None)
@@ -171,6 +180,7 @@ def parse_request(path, collection_dir):
 
 
 def order_key(request):
+    """Sort auth-ending requests after regular requests and login first."""
     url = request["url"]
     if LOGIN_PATH in url:
         return (0, request["relativePath"], request["seq"])
@@ -180,6 +190,7 @@ def order_key(request):
 
 
 def load_requests(collection_dir, include_external, include_destructive):
+    """Load and filter HTTP requests from a Bruno collection directory."""
     requests = []
     for path in sorted(collection_dir.rglob("*.bru")):
         if path.name in ("collection.bru", "folder.bru"):
@@ -201,6 +212,7 @@ def load_requests(collection_dir, include_external, include_destructive):
 
 
 def render_k6(requests):
+    """Render parsed Bruno requests as a self-contained k6 JavaScript file."""
     regular_requests = [request for request in requests if LOGIN_PATH not in request["url"]]
     payload = json.dumps(regular_requests, ensure_ascii=True, indent=2)
 
@@ -400,6 +412,7 @@ def render_k6(requests):
 
 
 def main():
+    """Parse CLI arguments and write the generated k6 script."""
     parser = argparse.ArgumentParser(description="Generate a k6 script from a Bruno collection.")
     parser.add_argument("--collection-dir", required=True, type=Path)
     parser.add_argument("--output", required=True, type=Path)

scripts/load_test/run_k6.sh

@@ -253,7 +253,7 @@ fi
 while IFS= read -r -d '' source_path; do
   relative_path="${source_path#"$LOCAL_K6_DIR"/}"
   sync_file "$load_generator_instance_id" "$load_generator_k6_dir" "$relative_path"
-done < <(find "$LOCAL_K6_DIR" -type f -print0)
+done < <(find "$LOCAL_K6_DIR" -type f \( -name '*.js' -o -name '*.ts' -o -name '*.json' -o -name '*.sh' \) -print0)
 
 run_commands_json="$(jq -cn \
   --arg k6_dir "$load_generator_k6_dir" \

scripts/load_test/start.sh

@@ -7,7 +7,7 @@ DATABASE_NAME=""
 SWITCH_STAGE_TO_LOADTEST="false"
 STAGE_APP_DIR="/home/ubuntu/solid-connection-dev"
 STAGE_COMPOSE_FILE="docker-compose.dev.yml"
-SSM_COMMAND_TIMEOUT_SECONDS="${SSM_COMMAND_TIMEOUT_SECONDS:-1800}"
+SSM_COMMAND_TIMEOUT_SECONDS="${SSM_COMMAND_TIMEOUT_SECONDS:-3600}"
 SKIP_TERRAFORM_APPLY="false"
 
 usage() {
@@ -21,7 +21,7 @@ Options:
   --switch-stage-to-loadtest    Restart stage app through SSM with dev,loadtest profiles
   --stage-app-dir PATH          Default: /home/ubuntu/solid-connection-dev
   --stage-compose-file VALUE    Default: docker-compose.dev.yml
-  --ssm-command-timeout-seconds Default: 1800
+  --ssm-command-timeout-seconds Default: 3600
   --skip-terraform-apply
   -h, --help
 EOF
@@ -115,19 +115,66 @@ send_ssm_command() {
   done
 }
 
+wait_for_ssm() {
+  local instance_id="$1"
+  local started_at
+  started_at="$(date +%s)"
+
+  while true; do
+    local ping_status
+    ping_status="$(aws ssm describe-instance-information \
+      --filters "Key=InstanceIds,Values=${instance_id}" \
+      --query "InstanceInformationList[0].PingStatus" \
+      --output text 2>/dev/null || true)"
+
+    if [[ "$ping_status" == "Online" ]]; then
+      break
+    fi
+
+    if (( $(date +%s) - started_at > SSM_COMMAND_TIMEOUT_SECONDS )); then
+      echo "SSM agent did not become online after ${SSM_COMMAND_TIMEOUT_SECONDS}s: ${instance_id}" >&2
+      exit 1
+    fi
+
+    sleep 10
+  done
+}
+
+wait_for_load_test_db_restore() {
+  local instance_id="$1"
+  local commands_json
+
+  commands_json="$(jq -cn \
+    '{
+      commands: [
+        "set -euo pipefail",
+        "READY_FILE=/opt/solid-connection/load-test-db-ready",
+        "cloud-init status --wait --long || { journalctl -u cloud-final --no-pager -n 200 || true; exit 1; }",
+        "test -f \"$READY_FILE\" || { echo \"Load-test DB ready marker was not created: $READY_FILE\" >&2; journalctl -u cloud-final --no-pager -n 200 || true; exit 1; }",
+        "cat \"$READY_FILE\""
+      ]
+    }')"
+
+  wait_for_ssm "$instance_id"
+  send_ssm_command "$instance_id" "Wait for load-test DB restore" "$commands_json"
+}
+
 if [[ "$SKIP_TERRAFORM_APPLY" != "true" ]]; then
   terraform -chdir="$TERRAFORM_DIR" init
   terraform -chdir="$TERRAFORM_DIR" apply -auto-approve -var-file="$VAR_FILE"
 fi
 
 stage_instance_id="$(tf_output stage_api_instance_id)"
 stage_public_ip="$(tf_output stage_api_public_ip)"
+loadtest_db_instance_id="$(tf_output load_test_db_instance_id)"
 loadtest_endpoint="$(tf_output load_test_db_endpoint)"
 loadtest_port="$(tf_output load_test_db_port)"
 loadtest_db_name="$(tf_output load_test_db_name)"
 
 DATABASE_NAME="${DATABASE_NAME:-$loadtest_db_name}"
 
+wait_for_load_test_db_restore "$loadtest_db_instance_id"
+
 if [[ "$SWITCH_STAGE_TO_LOADTEST" == "true" ]]; then
   stage_commands_json="$(jq -cn \
     --arg app_dir "$STAGE_APP_DIR" \

scripts/load_test/tests/test_generate_bruno_k6.py

@@ -6,13 +6,17 @@
 
 
 class GenerateBrunoK6Test(unittest.TestCase):
+    """Tests for Bruno request parsing and k6 rendering."""
+
     def write_bru(self, root, relative_path, content):
+        """Write a Bruno fixture file under a temporary collection root."""
         path = root / relative_path
         path.parent.mkdir(parents=True, exist_ok=True)
         path.write_text(content.strip() + "\n", encoding="utf-8")
         return path
 
     def test_load_requests_filters_external_and_destructive_requests(self):
+        """Only internal non-destructive Bruno requests should be loaded by default."""
         with tempfile.TemporaryDirectory() as tmp:
             root = Path(tmp)
             self.write_bru(
@@ -87,6 +91,7 @@ def test_load_requests_filters_external_and_destructive_requests(self):
             self.assertEqual(requests[1]["vars"], {"email": "user1@example.com"})
 
     def test_render_k6_excludes_login_request_and_keeps_request_metadata(self):
+        """The generated script should log in separately and retain request tags."""
         requests = [
             {
                 "name": "POST /auth/email/sign-in",