# Upgrade RQ 1.x to RQ 3 in a Flask App

Yes. An agent replaces the removed Connection context manager and job.get_id calls, moves redis-py with RQ, runs a real job through a worker and opens a PR.

[Run this on Rush](https://cloud.getrush.ai/run/upgrade-rq/rq/). Opens the console with this prompt ready to send, in a Project that has your repository.

## What the agent does

The agent reads what the app imports from RQ before it touches a version number. In an app like mjhea0/flask-redis-queue, `requirements.txt` pins `rq==1.10.1` and `redis==4.1.1` beside `Flask==2.0.2`, and `.python-version` says 3.10.2. Both `manage.py` and `project/server/main/views.py` import `Connection` from `rq` and wrap their work in `with Connection(...)`: the `run_worker` command builds `Worker(app.config["QUEUES"])` inside it, and the two routes build a bare `Queue()` inside it to enqueue `create_task` and to fetch a job by id. The routes then call `task.get_id()`, `task.get_status()` and `task.result`.

Every one of those lines is affected. RQ deprecated the `Connection` context manager in 1.12 and 2.0 no longer has it, so on a current release `manage.py` fails at its import line with `cannot import name 'Connection' from 'rq'`, and that takes `python manage.py test` down with it even though the tests never use a queue. `Queue()` with no connection raises a `TypeError` that asks for the `connection` argument. The current `Job` has no `get_id` method, only the `id` property, so `POST /tasks` would answer 500 after the import is fixed. `job.result` still works but warns that it is deprecated in favour of `job.return_value()`. RQ 3.0 also requires redis-py 5.0.1 or later, so pip refuses it beside `redis==4.1.1`, and the two pins move together. The agent passes `connection=` to `Queue` and `Worker`, switches to `task.id` and `task.return_value()`, and checks that `get_status()` still serialises to the plain strings `finished` and `failed` that `project/client/static/main.js` compares against.

Before any of that it has to get a baseline, and the baseline is already broken. `requirements.txt` pins Flask but not Werkzeug, so a fresh install resolves Werkzeug 3 and `import flask` fails with `cannot import name 'url_quote' from 'werkzeug.urls'`. The agent adds a Werkzeug pin below 2.1, the range Flask 2.0.2's test client still works with, as its own commit, and keeps a Flask upgrade out of this pull request. The three existing tests also need `FLASK_DEBUG=1` and `APP_SETTINGS=project.server.config.DevelopmentConfig`, the values `docker-compose.yml` sets, because two of them assert that `DEBUG` is true.

Those tests cover configuration and the index page, so they prove nothing about a queue. The README starts everything with `docker-compose up`, and the sandbox has no Docker, so the agent runs the three processes directly: Redis from `sudo apt-get install -y redis-server`, the web app with `python manage.py run`, and a worker with `python manage.py run_worker`. `project/server/config.py` hard-codes `redis://redis:6379/0`, the compose service name, so it maps the name `redis` to localhost in the sandbox's hosts file and leaves the config alone. Then it posts to `/tasks`, polls `/tasks/<task_id>` until the status is `finished`, and reads the worker log for the same job id.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "Upgrade RQ in this Flask app from the pinned 1.x release to the current major and open a pull request. Read requirements.txt, .python-version, manage.py, project/server/config.py, project/server/main/views.py, project/server/main/tasks.py, project/client/static/main.js, docker-compose.yml, both Dockerfiles and project/tests first. First install the pinned requirements unchanged and run python manage.py test with the environment docker-compose.yml sets; if the baseline fails for a reason unrelated to RQ, fix only that in a separate commit and explain it. Then upgrade rq, and upgrade redis only as far as RQ requires. Read RQ's CHANGES.md from the pinned version to the new one. Replace the Connection context manager with an explicit connection argument on Queue and Worker, and replace any Job method or property the new release removed or deprecated. Keep the JSON the two task routes return identical, including the status strings main.js compares. Do not use Docker: install redis-server with apt, run Redis, the web app and python manage.py run_worker as processes, make the redis hostname in config.py resolve locally without editing it, start one task of each length, poll each status URL until it finishes, and paste the responses and the worker log. Note anything in docker-compose.yml or project/dashboard/Dockerfile that the upgrade affects but that you could not run. Do not upgrade Flask.",
  "resources": [
    {
      "url": "https://github.com/your-org/your-app"
    }
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

The pull request has two commits. The first pins Werkzeug so the unchanged app imports again, with the `url_quote` error quoted as the reason. The second changes `requirements.txt`, `manage.py` and `views.py`: the new `rq` and `redis` pins, the removed `Connection` imports, the explicit `connection=` arguments and the two job accessors. The description lists each changed call with the RQ release note or source line that made it necessary, and says which were removals and which only deprecations.

Its evidence is the queue working. It shows the 202 from `POST /tasks` with a task id, a status response while the job is `started`, the final one with `finished` and a result of true, and the worker's log lines for that job. It includes the error response for an id that was never issued, to show the route's other branch still answers as before, and the output of the three existing tests.

It also lists what it could not run. The `worker` service in `docker-compose.yml` uses the same image and command, so the code change covers it, but the compose stack itself was not started. `project/dashboard/Dockerfile` installs `rq-dashboard` with no version and pins click to 7.1.2 for an old RQ issue, so that image resolves its own RQ independently of `requirements.txt`. A reviewer builds the compose stack once, opens the dashboard on port 9181 and checks that it still lists the jobs a worker on the new version writes.

## Run it on every new RQ release

RQ ships often enough that a schedule suits it. An automation in the Project that holds the repository, with a `schedule` trigger on a weekly `cron` such as `0 7 * * 2` and a `timezone`, starts one run a week with a shorter prompt: compare the pinned `rq` and `redis` with the newest releases, read the changelog entries in between, upgrade, run a task through a real worker in the sandbox and open a pull request, or end with one line when the pins are current.

A team that runs several services on RQ can start them from its own code instead. Send one `POST /o/{org}/sessions` per repository with this prompt and that repository in `resources`. A key runs at most its `max_concurrent` runs at once and the rest answer 202 as `queued` and start as slots free, so the batch needs no retry loop. Give the key a `webhook_url` and each run it starts posts `run.completed` or `run.failed` there when its turn ends.

## Why run it on Rush?

A queue upgrade is proven by a job going in one side and coming out the other. This app's own tests would pass on a version of RQ that could not enqueue anything, because none of them touches Redis. In a Rush sandbox the agent starts Redis, a web process and a worker on its own machine, sends real requests, and keeps every command, response and log line in the run's record. The reviewer reads a worker log, not a claim that the imports look right.

It also separates the causes. The app is already uninstallable today for a reason that has nothing to do with RQ, and an upgrade done by hand on a laptop with an old virtualenv would never notice. Starting from a clean machine each time means the agent meets the same install a new teammate or a CI job would, and the pull request records which failure belonged to which package.

## Frequently asked questions

### What replaces `with Connection(...)` in RQ 2 and later?

An explicit argument. Create the Redis client once and pass it as `connection=` to `Queue`, `Worker` and `Job.fetch`. The context manager was deprecated in RQ 1.12 and is absent from 2.0 onward, and a `Queue()` built without a connection now raises a `TypeError`.

### Do I have to upgrade redis-py as well?

For RQ 3.0, yes: it requires redis-py 5.0.1 or later, and pip will not install it next to an older pin. The agent moves `redis` only as far as RQ needs and says so, so the client upgrade is visible in the diff and not a side effect.

### Will jobs already in Redis survive the upgrade?

The agent tests jobs created and run on the new version only. Whether jobs enqueued by 1.x are picked up cleanly by a newer worker depends on what is in your queues, so the pull request recommends draining them before deploy, or testing against a copy of the data, and does not claim compatibility it did not test.

### Does it need Docker to test this?

No. The sandbox has no Docker, and the three processes in `docker-compose.yml` run directly: Redis from apt, the Flask app and the worker from `manage.py`. The compose file and the dashboard image are read and reported on, and a reviewer starts them once before merging.

## More RQ jobs

- [Add Job Timeouts to a Flask RQ App](https://getrush.ai/run/add-job-timeouts/rq/)
- [Add a Scheduled Job to a Flask App That Uses RQ](https://getrush.ai/run/add-periodic-tasks/rq/)
- [Add a Scheduled Job to a Flask App with RQ](https://getrush.ai/run/add-scheduled-job/rq/)

## More jobs like this: Upgrade dependencies weekly

- [Upgrade a Scrapy Project to the Latest Scrapy](https://getrush.ai/run/upgrade-scrapy/scrapy/)
- [Upgrade Python Selenium Tests to Selenium 4 (find_element_by_* and PhantomJS Removed)](https://getrush.ai/run/upgrade-selenium/selenium/)
- [Upgrade SQLx From 0.5 to the Current Release in a Rust API](https://getrush.ai/run/upgrade-sqlx/sqlx/)

## Keep reading

- [How a Rush run works on your repository, from request to pull request](https://getrush.ai/cloud/)
- [Compare cloud agents, agent sandboxes and AI code review](https://getrush.ai/compare/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
