Announcing Chaos Proxy API: Automate Network Chaos in CI/CD 🚀

Source: Dev.to

Moving Beyond “Localhost” Testing

Until now, Debuggo has been a fantastic tool for manual testing. You spin up a proxy, connect your phone, and verify how your app handles a 503 error or high latency. It works great for ad‑hoc debugging.

But manual testing doesn’t scale.

You cannot ask your QA team to manually verify Offline Mode handling on every single Pull Request. You cannot manually check if your payment gateway handles double‑clicks correctly before every deploy.

To build truly resilient apps, you need Continuous Chaos.

Today, we are launching the Chaos Proxy API. Now you can programmatically create proxies, configure chaos rules, and tear them down—all within your CI/CD pipeline (GitHub Actions, GitLab CI, Jenkins).

Architecture: How it works in CI

The API gives you full control over the lifecycle of a Chaos Proxy directly from your pipeline scripts:

Real‑World Example: GitHub Actions

Below is a complete workflow. It spins up a proxy, injects a 3‑second latency to simulate a slow network, runs tests to ensure the UI handles “Rage Clicks” correctly, and then shuts everything down.

name: 🧪 Chaos E2E Tests
on: [push]

jobs:
  chaos-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      # 1. Start the Proxy
      - name: 🚀 Start Debuggo Proxy
        id: start_proxy
        run: |
          RESPONSE=$(curl -s -X POST https://chaos-proxy.debuggo.app/api/v1/sessions \
            -H "Authorization: Bearer ${{ secrets.DEBUGGO_API_KEY }}")

          # Extract and save details to ENV
          echo "PROXY_ID=$(echo $RESPONSE | jq -r .id)" >> $GITHUB_ENV
          echo "PROXY_HOST=$(echo $RESPONSE | jq -r .host)" >> $GITHUB_ENV
          echo "PROXY_PORT=$(echo $RESPONSE | jq -r .port)" >> $GITHUB_ENV
          echo "PROXY_AUTH=$(echo $RESPONSE | jq -r .auth)" >> $GITHUB_ENV

      # 2. Configure Chaos (The "Bad 3G" Simulation)
      - name: 💣 Configure Chaos Rules
        run: |
          curl -X PUT https://chaos-proxy.debuggo.app/api/v1/sessions/$PROXY_ID/rules \
            -H "Authorization: Bearer ${{ secrets.DEBUGGO_API_KEY }}" \
            -H "Content-Type: application/json" \
            -d '{
              "rules": [
                {
                  "url_pattern": "*/api/checkout",
                  "delay": 3000,
                  "error_code": null
                }
              ]
            }'

      # 3. Run Tests
      - name: 🧪 Run Playwright Tests
        run: |
          # Route traffic through the authenticated proxy
          export HTTPS_PROXY="http://$PROXY_AUTH@$PROXY_HOST:$PROXY_PORT"
          npx playwright test

      # 4. Cleanup (Always run this, even if tests fail)
      - name: 🧹 Cleanup
        if: always()
        run: |
          curl -X DELETE https://chaos-proxy.debuggo.app/api/v1/sessions/$PROXY_ID \
            -H "Authorization: Bearer ${{ secrets.DEBUGGO_API_KEY }}"

API Reference

Use these endpoints to integrate Chaos Proxy into your custom scripts.

Authentication

All requests must include your API key in the Authorization header. Generate a key in your Dashboard Settings.

Authorization: Bearer dbg_ci_YOUR_KEY

Start Proxy Session

Creates a new isolated proxy container. Returns the host, port, and credentials.

Endpoint: POST /api/v1/sessions

Response Example:

{
  "id": "sess_abc123",
  "host": "proxy-us-east.debuggo.app",
  "port": 10245,
  "auth": "user:pass"
}

Configure Rules

Updates the chaos logic in real‑time. You can change rules mid‑test (e.g., test success first, then inject failure).

Endpoint: PUT /api/v1/sessions/{session_id}/rules

Body Example:

{
  "rules": [
    {
      "url_pattern": "*/api/v1/checkout",
      "failure_rate": 100,
      "error_code": 503,
      "delay": 0
    },
    {
      "url_pattern": "*/api/v1/search",
      "delay": 2000
    }
  ]
}

Download CA Certificate

Retrieves the Root CA certificate. Essential for automated setup of Android Emulators or iOS Simulators in CI.

Endpoint: GET /api/v1/certs/ca.pem

Usage Example:

curl -O https://chaos-proxy.debuggo.app/api/v1/certs/ca.pem
# Then install via adb, etc.

Stop Session

Stops the proxy and releases the port.

Endpoint: DELETE /api/v1/sessions/{session_id}

Why automate Chaos?

Catch regressions in “unhappy paths.”
Developers often break error‑handling logic because they focus on the happy path. Automated chaos testing ensures that edge‑case failures are caught early, keeping your app resilient in production.

You rarely see errors locally. Automating a 500 Error test ensures your “Something went wrong” screen never breaks.

Validate Idempotency
By injecting latency into your payment endpoints during CI, you can verify that your backend correctly handles duplicate requests (Rage Clicks) before they reach production.

Native Mobile Testing
Unlike Playwright’s built‑in page.route (which only works in a browser context), Debuggo works at the system level. This allows you to test native Android and iOS apps running in emulators within your CI pipeline.

Ready to break your build (on purpose)? Get your API Key.