Christian Vestre
05/07/2026, 1:25 PM"resource": {
"prefect.resource.id": "prefect.flow-run.069fc8e6-1d41-78ea-8000-9ab38a61f8ad",
"prefect.resource.name": "nebulous-seahorse",
"prefect.run-count": "0",
"prefect.state-message": "Process exited with status code: 1. Process exited with a general error.",
"prefect.state-name": "Crashed",
"prefect.state-timestamp": "2026-05-07T13:07:34.470503+00:00",
"prefect.state-type": "CRASHED",
"prefect.audit": "false"
},Marvin
05/07/2026, 1:25 PMMarvin
05/07/2026, 1:28 PMstatus code: 1 with no flow logs usually means the flow process is dying very early — often before Prefect finishes initializing run logging.
So the most important place to look first is the worker logs, not the flow-run logs.
What this usually means
- The worker successfully picked up the run
- It launched the flow subprocess
- That subprocess exited almost immediately with a general error
- Because it died early, nothing got emitted to the flow-run log stream
Most common causes
1. Import / startup failure in the flow environment
- missing package
- broken dependency
- syntax/import error in code imported at module load time
- environment drift on the worker host/container
2. API connectivity/auth issue from the execution environment
- PREFECT_API_URL unreachable
- expired/changed PREFECT_API_KEY
- DNS / proxy / firewall issue
3. Infrastructure/environment issue on the worker machine
- disk full
- memory pressure
- broken Python environment / venv
- changed filesystem path / working directory not available
4. A bad deployment/runtime config
- invalid entrypoint
- pull step failure
- code path no longer available from the worker
Since you said this started yesterday with no changes from your side, my strongest suspicions would be:
- worker host/container environment drift
- API/auth/connectivity problem
- filesystem/network-mounted code path became unavailable
- package/env issue due to a rebuilt image / restarted host / changed mount
What to check right now
1. Open the worker logs for one crashed run
In Prefect Cloud, the run event usually links to the worker. Look for anything just before the run is submitted/opened.
2. Turn on subprocess output streaming if not already enabled
If you're using a process work pool, set:
yaml
job_variables:
stream_output: true
That can surface stderr/stdout from the subprocess instead of leaving you with only the crash event.
3. Run the worker with more internal logging
Start/restart the worker with:
bash
export PREFECT_LOGGING_INTERNAL_LEVEL=DEBUG
prefect worker start --pool <your-pool-name>
4. Try executing one failed run manually from the same worker environment
On the worker machine/container, with the same env:
bash
python -m prefect.engine 069fc8e6-1d41-78ea-8000-9ab38a61f8ad
If this is an import/startup problem, this often reveals the real traceback immediately.
5. Verify API connectivity from the worker environment
bash
echo $PREFECT_API_URL
curl -I $PREFECT_API_URL/health
And confirm the API key is present in the worker environment.
6. Check the worker runtime itself
bash
python --version
which python
pip list
df -h
free -h
If this is containerized, also confirm the current image digest/tag is what you expect.
7. If your deployment uses pull steps or a working directory, verify that path still exists and is readable from the worker host/container.
One important clue
If all flows across the same worker pool started failing at once, that strongly points to a shared worker environment problem, not a bug in one flow.
So I’d focus on:
- worker restart/redeployment yesterday
- image/package changes
- expired credentials
- broken network mount / repo checkout path
- API connectivity from that worker environment
Relevant references
- Workers concept: docs.prefect.io/v3/concepts/workers
- Work pools concept: docs.prefect.io/v3/concepts/work-pools
- Running flows in local processes: run flows in local processes
There are also related bug reports around generic exit-code-1 crashes where the underlying issue was only visible in worker-side logs:Marvin
05/07/2026, 1:28 PMprocess, Docker, Kubernetes, etc.)
- whether worker logs show anything right before/after Opening process
- whether these deployments use pull steps / mounted code / .from_source(...)
and I can help narrow this down fast.Christian Vestre
05/07/2026, 1:37 PMMarvin
05/07/2026, 1:37 PMMarvin
05/07/2026, 1:37 PM.from_source(...)
- same pull steps
If yes, a code fetch/auth issue is very likely.
2. Did a secret/token used for source access expire yesterday?
Common examples:
- GitHub token rotated/expired
- cloud storage credentials changed
- private package index credentials changed
3. Did the repo contents change even if “you changed nothing” operationally?
For example:
- default branch updated
- dependency version drift
- package removed from lockfile/image install step
- import-time error introduced in shared module
4. Try one very simple test deployment in the same managed pool
A trivial flow with no external imports and no private source dependency:
python
from prefect import flow
@flow
def smoke_test():
print("hello")
if __name__ == "__main__":
smoke_test.serve(name="smoke-test")
If that also crashes in the same managed pool, it strongly suggests a managed-execution/platform issue rather than your code.
5. Compare one failing deployment’s source setup
I’d specifically look for:
- private repo access
- pull steps
- custom package install at runtime
- env vars/secrets required before import
Important note on logs
With managed workers, if the process dies before Prefect engine logging is initialized or before code-fetch/import fully succeeds, you can end up with exactly what you’re seeing: just a crash event and no normal run logs.
What I’d do immediately
- launch a minimal smoke-test deployment into the same managed pool
- check whether all broken deployments share the same source/auth pattern
- check whether any secret/token used for source retrieval changed/expired yesterday
If the smoke test also fails, this is very likely not your flow code.
Since I can’t escalate on your behalf, the right path for a likely managed-platform issue is:
- contact Prefect here: prefect.io/contact
If you want, send me:
- how these deployments are sourced (from_source, Git repo, S3, etc.)
- whether the code source is private
- whether a trivial smoke-test flow in the same managed pool also crashes
and I can help you determine if this is source/auth related vs managed infrastructure related.Christian Vestre
05/07/2026, 1:39 PMChristian Vestre
05/07/2026, 1:39 PMMarvin
05/07/2026, 1:39 PMMarvin
05/07/2026, 1:41 PMdeploy, not serve.
Important caveat for managed pools: your code needs to be available to Prefect-managed infrastructure, typically via .from_source(...) from a Git repo or other remote source. A managed pool cannot use code sitting only on your laptop.
Minimal smoke test example
Create a file like `smoke_test.py`:
python
from prefect import flow
@flow(log_prints=True)
def smoke_test():
print("smoke test ran successfully")
if __name__ == "__main__":
flow.from_source(
source="<https://github.com/<your-org>/<your-repo>.git>",
entrypoint="smoke_test.py:smoke_test",
).deploy(
name="smoke-test",
work_pool_name="<your-managed-pool-name>",
)
Then run:
bash
python smoke_test.py
That creates a deployment named smoke-test in the same pool.
Then trigger it from the UI or CLI.
If you want to run it from CLI:
bash
prefect deployment run "smoke-test/smoke-test"
How to find the deployment name
The full deployment name is generally:
text
<flow-name>/<deployment-name>
So in the example above:
- flow name = smoke_test
- deployment name = smoke-test
which usually becomes:
text
smoke_test/smoke-test
If you want to confirm, check in the Deployments page in Prefect Cloud.
If your repo is private
You’ll need the managed environment to be able to access it. If your normal deployments already use the same private source successfully, reuse that same source/auth pattern for the smoke test.
Even simpler diagnostic variant
If your existing deployments already come from the same repo, add this tiny file to that repo and deploy from the same source mechanism. That helps isolate whether:
- the pool/platform is broken, or
- your existing flow code/imports are broken
What the result means
- If the smoke test succeeds: the managed pool itself is probably okay, and the issue is likely in your shared code source, imports, secrets, or deployment config.
- If the smoke test also crashes with no logs: that strongly suggests a managed execution/platform issue or a common source-fetch/auth problem.
UI option
You can also create a deployment from code you already have in a repo and then run it from the Prefect Cloud UI:
- open Deployments
- select the new deployment
- click Run
Docs
- Work pools
- Workers
If you want, I can give you a copy-paste exact version of this for:
- a public GitHub repo
- a private GitHub repo
- or based on how your current deployments are created nowChristian Vestre
05/07/2026, 1:44 PMMarvin
05/07/2026, 1:44 PMMarvin
05/07/2026, 1:44 PMfrom_source(...) clones the repo and then tries to load:
text
smoke_test.py:smoke_test
But after cloning <https://github.com/Amundsen-Sports/integrations.git>, Prefect could not find smoke_test.py in that repo snapshot:
text
FileNotFoundError: .../integrations/smoke_test.py
So the issue is just that the entrypoint path does not exist in the cloned repo.
Why this happened
Most likely one of these:
- smoke_test.py is only on your laptop and has not been committed/pushed
- the file is in a subdirectory, not repo root
- the branch you cloned doesn’t contain the file
- the repo default branch is not the branch where the file lives
How to fix it
Option 1: commit and push smoke_test.py to the repo root
If the file should be at the top level of the repo, make sure it is pushed, then keep:
python
entrypoint="smoke_test.py:smoke_test"
Option 2: use the correct relative path
If the file is in a folder, use that path instead, for example:
python
entrypoint="flows/smoke_test.py:smoke_test"
or
python
entrypoint="src/smoke_test.py:smoke_test"
Option 3: pin the branch explicitly
If the file is on a non-default branch:
python
flow.from_source(
source="<https://github.com/Amundsen-Sports/integrations.git@your-branch>",
entrypoint="smoke_test.py:smoke_test",
).deploy(
name="smoke-test",
work_pool_name="<your-managed-pool-name>",
)
Recommended exact next step
First verify the file exists in the remote repo path you reference.
For example, if the file is in repo root, then after pushing it, use:
python
from prefect import flow
@flow(log_prints=True)
def smoke_test():
print("smoke test ran successfully")
if __name__ == "__main__":
flow.from_source(
source="<https://github.com/Amundsen-Sports/integrations.git>",
entrypoint="smoke_test.py:smoke_test",
).deploy(
name="smoke-test",
work_pool_name="<your-managed-pool-name>",
)
If it’s in a subfolder, change only the entrypoint.
How to sanity check before rerunning
Make sure the file is actually in GitHub at the path you use. The important rule is:
text
entrypoint = <path inside repo>:<flow function name>
So if GitHub shows:
- repo root: smoke_test.py → smoke_test.py:smoke_test
- prefect/smoke_test.py → prefect/smoke_test.py:smoke_test
What this means diagnostically
This does not yet tell us whether the managed pool is healthy. It only tells us the deployment script hasn’t successfully created the test deployment yet.
Once you fix the repo path and deploy successfully, then run the smoke test in the managed pool:
- if it succeeds, the managed pool likely works
- if it crashes the same way, that’s a strong signal of a managed execution or shared source issue
If you want, paste:
- the repo-relative location of smoke_test.py
- the pool name
and I’ll give you the exact corrected from_source(...).deploy(...) snippet.Christian Vestre
05/07/2026, 1:50 PMMarvin
05/07/2026, 1:50 PMMarvin
05/07/2026, 1:50 PMChristian Vestre
05/07/2026, 1:51 PMMarvin
05/07/2026, 1:51 PMMarvin
05/07/2026, 1:51 PMdeploy() is trying to use a work pool named:
text
worker
and that work pool does not exist in your current workspace.
So the smoke test hasn’t been deployed yet.
What this means
Your code is reaching Prefect Cloud successfully now, but the work_pool_name you passed is wrong.
The key line is:
text
ValueError: Could not find work pool 'worker'
So somewhere you have:
python
work_pool_name="worker"
but worker is not the actual pool name.
How to fix it
Use the exact name of the Prefect-managed work pool that your failing deployments are using.
If you don’t know it, find it in either place:
1. Prefect Cloud UI
- go to Work Pools
- copy the exact pool name
2. CLI
Run:
bash
prefect work-pool ls
Then update your smoke test to use that exact name:
python
from prefect import flow
@flow(log_prints=True)
def smoke_test():
print("smoke test ran successfully")
if __name__ == "__main__":
flow.from_source(
source="<https://github.com/Amundsen-Sports/integrations.git>",
entrypoint="smoke_test.py:smoke_test",
).deploy(
name="smoke-test",
work_pool_name="<actual-pool-name>",
)
Example
If the real pool is called managed-prod, then:
python
from prefect import flow
@flow(log_prints=True)
def smoke_test():
print("smoke test ran successfully")
if __name__ == "__main__":
flow.from_source(
source="<https://github.com/Amundsen-Sports/integrations.git>",
entrypoint="smoke_test.py:smoke_test",
).deploy(
name="smoke-test",
work_pool_name="managed-prod",
)
Then run:
bash
uv run python smoke_test.py
After it deploys successfully, trigger it from the UI or:
bash
prefect deployment run "smoke_test/smoke-test"
Why the URL looked weird
This part:
text
<https://api.prefect.cloud/work_pools/worker>
suggests your client is trying to read the work pool by name and got a 404 because that pool name doesn’t exist in the current workspace/account context.
Two things to double-check
1. You’re in the right workspace/profile
bash
prefect profile ls
prefect config view
Make sure your PREFECT_API_URL points to the workspace where that managed pool exists.
2. The pool name matches exactly, including spaces/case.
Next best step
Run:
bash
prefect work-pool ls
and paste the output here if you want — I can tell you exactly which name to use.Christian Vestre
05/07/2026, 1:53 PMMarvin
05/07/2026, 1:53 PMMarvin
05/07/2026, 1:54 PMtext
<https://api.prefect.cloud>
but Prefect expects PREFECT_API_URL to include your account/workspace API path, something like:
text
<https://api.prefect.cloud/api/accounts/<account-id>/workspaces/<workspace-id>>
That’s why commands like work-pool ls are hitting:
text
<https://api.prefect.cloud/work_pools/filter>
and getting 404. They should be hitting the workspace-scoped API path instead.
So right now your local client is misconfigured.
Fix it
Run:
bash
prefect cloud login
and select the correct workspace.
That should set the proper workspace-scoped API URL for your active profile.
Then verify with:
bash
prefect config view
You want to see something like:
text
PREFECT_API_URL='<https://api.prefect.cloud/api/accounts/<account-id>/workspaces/<workspace-id>>'
Not just:
text
<https://api.prefect.cloud>
After that, retry:
bash
prefect work-pool ls
or with uv if that’s how you’re running Prefect:
bash
uv run prefect work-pool ls
If you want to set it directly
You can also do:
bash
prefect config set PREFECT_API_URL="<https://api.prefect.cloud/api/accounts/<account-id>/workspaces/<workspace-id>>"
and ensure your API key is set too:
bash
prefect config set PREFECT_API_KEY="<your-api-key>"
But prefect cloud login is usually easiest.
Why this matters for your original crash issue
This misconfiguration is local to your CLI/deploy commands, so it may or may not be related to the managed-pool crashes themselves.
But it does explain:
- why work-pool ls fails
- why deploy couldn’t find the work pool
- why your smoke test deployment hasn’t been created yet
Recommended next steps
1. Run:
bash
prefect cloud login
2. Confirm:
bash
prefect config view
3. List pools:
bash
prefect work-pool ls
4. Update work_pool_name in smoke_test.py to the exact managed pool name
5. Deploy again:
bash
uv run python smoke_test.py
6. Run the smoke test deployment
If you paste the output of:
bash
prefect config view
after login, I can confirm whether it’s fixed before you try again.Christian Vestre
05/07/2026, 1:59 PMMarvin
05/07/2026, 1:59 PMMarvin
05/07/2026, 1:59 PMprefect.yaml, or
- whether you use:
- public GitHub
- private GitHub with token
- Prefect Git block / credentials
- another storage source
One important note
If this is Prefect 3.x, don’t switch to old 2.x-style GitHub storage block patterns. For 3.x, the recommended pattern is using .from_source(...) with a reachable source, plus the correct credentials/access arrangement where needed.
Also, if your local CLI is still pointed at the wrong API URL, fix that first with:
bash
prefect cloud login
Then inspect one existing deployment in the UI and compare its source configuration to the smoke test.
My recommendation
Yes:
1. fix local Cloud login/profile
2. make the smoke test use the same private repo auth/source mechanism as the failing deployments
3. rerun it
If you paste your current deployment code, I’ll rewrite the smoke test so it matches exactly.Christian Vestre
05/07/2026, 2:01 PMpython
from prefect import flow
@flow(log_prints=True)
def smoke_test():
print("smoke test ran successfully")
if __name__ == "__main__":
flow.from_source(
source="<https://github.com/Amundsen-Sports/integrations.git>",
entrypoint="smoke_test.py:smoke_test",
).deploy(
name="smoke-test",
work_pool_name="<actual-pool-name>",
)Marvin
05/07/2026, 2:01 PMMarvin
05/07/2026, 2:01 PMpython
from prefect import flow
@flow(log_prints=True)
def smoke_test():
print("smoke test ran successfully")
if __name__ == "__main__":
flow.from_source(
source="<https://github.com/Amundsen-Sports/integrations.git>",
entrypoint="smoke_test.py:smoke_test",
).deploy(
name="smoke-test",
work_pool_name="YOUR_ACTUAL_POOL_NAME",
)
But the key question is: how do your existing deployments authenticate to that private repo?
Because the smoke test should use the same mechanism.
If your existing deployments already work by embedding auth in the source URL
It might look like this pattern:
python
flow.from_source(
source="https://<token>@github.com/Amundsen-Sports/integrations.git",
entrypoint="smoke_test.py:smoke_test",
).deploy(
name="smoke-test",
work_pool_name="YOUR_ACTUAL_POOL_NAME",
)
But I do not recommend hardcoding a token directly in code unless that is truly temporary for debugging.
Better approach
Use the same secret/env-var pattern your real deployment uses.
For example, if you already inject a GitHub token as an environment variable during deployment creation, you may build the URL from that:
python
import os
from prefect import flow
@flow(log_prints=True)
def smoke_test():
print("smoke test ran successfully")
if __name__ == "__main__":
github_token = os.environ["GITHUB_TOKEN"]
flow.from_source(
source=f"https://{github_token}@github.com/Amundsen-Sports/integrations.git",
entrypoint="smoke_test.py:smoke_test",
).deploy(
name="smoke-test",
work_pool_name="YOUR_ACTUAL_POOL_NAME",
)
Important caveat
This only helps if Prefect uses that authenticated source definition when creating/running the deployment. The core issue is that the managed execution environment must be able to fetch the repo too.
So the real test is:
- does one of your existing deployments already have working private-repo access configured?
- if yes, mirror that exactly
What I would do here
Take one currently failing deployment that already points at this repo and copy:
- its source
- its branch/ref
- any auth pattern
- its pool name
Then change only:
- flow entrypoint → smoke_test.py:smoke_test
- deployment name → smoke-test
That gives you a true apples-to-apples test.
Two common gotchas
1. Wrong entrypoint path
If smoke_test.py is not at repo root, use the repo-relative path:
python
entrypoint="path/to/smoke_test.py:smoke_test"
2. Wrong branch
If the file exists only on a branch, specify it in the source URL:
python
source="<https://github.com/Amundsen-Sports/integrations.git@your-branch>"
So the minimal final form is probably something like:
python
import os
from prefect import flow
@flow(log_prints=True)
def smoke_test():
print("smoke test ran successfully")
if __name__ == "__main__":
github_token = os.environ["GITHUB_TOKEN"]
flow.from_source(
source=f"https://{github_token}@github.com/Amundsen-Sports/integrations.git@main",
entrypoint="smoke_test.py:smoke_test",
).deploy(
name="smoke-test",
work_pool_name="YOUR_ACTUAL_POOL_NAME",
)
But only use that if this matches how your existing deployments access GitHub.
If you want, paste one real deployment snippet you currently use for this repo, and I’ll convert it into the exact smoke-test version.