Sounds Great but when?

Aandifined.dev Sounds Great but when?

A

andifined.devOP•5/16/25, 6:55 PM

Think I have to integrate some Kind of sharding here

P

planet•5/16/25, 11:44 PM

do workflows have unlimited subrequests

O

oof2win2•5/18/25, 12:23 PM

hey there, i've previously created workflows on DB changes with CDC and i created them based on some form of unique ID within the DB that I always knew was going to be unique. previously, when i backfilled CDC (say due to an outage etc), the old workflows just didn't get created but the new ones did - which is what i wanted. now when i do that though the worker errors as it can't create the workflow. is this an intended breaking change or no?

N

Nimesh•5/19/25, 5:22 AM

Hi, is there a way to get the statuses of multiple workflows in a single request? We have a number of workflows that we’d like to be able to get the statuses of, without making multiple parallel calls.

J

johtso•5/19/25, 3:08 PM

how would I run a workflow when another workflow fails for whatever reason?

J

johtso•5/19/25, 3:09 PM

is there a concept of some kind of "finally" task?

Jjohtso how would I run a workflow when another workflow fails for whatever reason?

K

koraytaylan•5/20/25, 7:58 AM

i think you could implement an abstract base class (which your actual workflow inherits) and then you could encapsulate the logic to capture error in this base class and add a message into a queue. then another worker would trigger and start that other workflow.

Kkoraytaylan i think you could implement an abstract base class (which your actual workflow i...

J

johtso•5/20/25, 8:01 AM

I don't think that works for the case of retry limits being reached

Aandifined.dev Hey guys I‘ve got a question regardinhg sub request Limits within workflows: I...

K

koraytaylan•5/20/25, 8:02 AM

it is interesting. i didn't know about such limitation. how about:
your current workflow would just be a proxy that adds those 600ids into a queue as 600 messages. then you could configure a worker that would trigger for those messages and create a separate workflow that only work for an individual image instead of trying to process all 600 in one workflow.

Jjohtso I don't think that works for the case of retry limits being reached

K

koraytaylan•5/20/25, 8:10 AM

i have what i described in a simpler way to log detailed error messages on what went wrong. so, from the highest level if i am able catch an error and process it, then i guess it should be possible to trigger another workflow. now that i also realize you might not even need that queue because you could consider this part as a separate step to just trigger that other workflow.

Kkoraytaylan i have what i described in a simpler way to log detailed error messages on what ...

J

johtso•5/20/25, 8:13 AM

I'm thinking for example sending a customer an email if the order workflow terminates unsuccessful, and maybe refunding their payment. Catching errors doesn't let me know if the workflow was about to terminate / if there were still retries remaining. I could of course catch any unrecoverable errors, but that would still leave the retries exhausted case

K

koraytaylan•5/20/25, 8:14 AM

i have an idea, i have been working with workflows and one thing that i keep thinking is how great it would be to have a tab called "Logs" inside workflow instance that displays

console.log

console.log

messages emitted during that workflow run.

Jjohtso I'm thinking for example sending a customer an email if the order workflow termi...

K

koraytaylan•5/20/25, 8:17 AM

i believe there are two different scopes at play here. step scoped code gets retried when an error happens. but workflow scoped code does not have this. below is the abstract class i am talking about and the catch part here works only once.

`
export abstract class AbstractWorkflow<T, R> extends WorkflowEntrypoint<Env, T> {
  protected abstract getName(): string;
  protected abstract validateInput(input: T): void;
  protected abstract runStep(event: WorkflowEvent<T>, step: WorkflowStep): Promise<R>;

  async run(event: WorkflowEvent<T>, step: WorkflowStep): Promise<unknown> {
    console.log({
      message: `${this.getName()} started.`,
      level: "info",
      event,
    });
    try {
      this.validateInput(event.payload);
      const output = await this.runStep(event, step);
      console.log({
        message: `${this.getName()} completed.`,
        level: "info",
        event,
        output,
      });
      return output;
    } catch (error) {
      console.log({
        message: `${this.getName()} failed.`,
        level: "error",
        event,
        error,
      });
      throw error;
    }
  }
}

`
export abstract class AbstractWorkflow<T, R> extends WorkflowEntrypoint<Env, T> {
  protected abstract getName(): string;
  protected abstract validateInput(input: T): void;
  protected abstract runStep(event: WorkflowEvent<T>, step: WorkflowStep): Promise<R>;

  async run(event: WorkflowEvent<T>, step: WorkflowStep): Promise<unknown> {
    console.log({
      message: `${this.getName()} started.`,
      level: "info",
      event,
    });
    try {
      this.validateInput(event.payload);
      const output = await this.runStep(event, step);
      console.log({
        message: `${this.getName()} completed.`,
        level: "info",
        event,
        output,
      });
      return output;
    } catch (error) {
      console.log({
        message: `${this.getName()} failed.`,
        level: "error",
        event,
        error,
      });
      throw error;
    }
  }
}

`
export abstract class AbstractWorkflow<T, R> extends WorkflowEntrypoint<Env, T> {
  protected abstract getName(): string;
  protected abstract validateInput(input: T): void;
  protected abstract runStep(event: WorkflowEvent<T>, step: WorkflowStep): Promise<R>;

  async run(event: WorkflowEvent<T>, step: WorkflowStep): Promise<unknown> {
    console.log({
      message: `${this.getName()} started.`,
      level: "info",
      event,
    });
    try {
      this.validateInput(event.payload);
      const output = await this.runStep(event, step);
      console.log({
        message: `${this.getName()} completed.`,
        level: "info",
        event,
        output,
      });
      return output;
    } catch (error) {
      console.log({
        message: `${this.getName()} failed.`,
        level: "error",
        event,
        error,
      });
      throw error;
    }
  }
}

`
export abstract class AbstractWorkflow<T, R> extends WorkflowEntrypoint<Env, T> {
  protected abstract getName(): string;
  protected abstract validateInput(input: T): void;
  protected abstract runStep(event: WorkflowEvent<T>, step: WorkflowStep): Promise<R>;

  async run(event: WorkflowEvent<T>, step: WorkflowStep): Promise<unknown> {
    console.log({
      message: `${this.getName()} started.`,
      level: "info",
      event,
    });
    try {
      this.validateInput(event.payload);
      const output = await this.runStep(event, step);
      console.log({
        message: `${this.getName()} completed.`,
        level: "info",
        event,
        output,
      });
      return output;
    } catch (error) {
      console.log({
        message: `${this.getName()} failed.`,
        level: "error",
        event,
        error,
      });
      throw error;
    }
  }
}

Kkoraytaylan it is interesting. i didn't know about such limitation. how about: your current...

A

andifined.devOP•5/20/25, 8:22 AM

But for my understanding that‘s the whole Point of using workflows. A Workflow has steps which get retried automatically on failure und I can define some Kind of process where each step depends on the steps before. So I don‘t unterstand why it‘s necessary to implement a workaround for functionality the product itself provides

Already implemented some Kind of workaround on my own to get around those Limits, but currently I‘m just waiting for Container compatibility because it‘s solving so much additional Problems I‘m having with workflows right know IMHO

Aandifined.dev But for my understanding that‘s the whole Point of using workflows. A Workflow h...

K

koraytaylan•5/20/25, 8:25 AM

i totally agree. what appealed me in the beginning was pretty much the point i could have code that can run for weeks if necessary. so it is for sure limiting to have only x amount of requests etc.

Kkoraytaylan i believe there are two different scopes at play here. step scoped code gets ret...

J

johtso•5/20/25, 9:25 AM

Do you know if reaching retry limit results in an error that can be caught? Also, if I run a "cleanup" step, and then rethrow the original error, will the workflow history correctly show the step as having failed?

J

johtso•5/20/25, 10:50 AM

Awesome, it works exactly how I hoped it would! the workflow is marked as errored, but it also has a successful "cleanup" step after the errored step

B

Ben•5/20/25, 2:35 PM

Hello! I’m wondering if anyone else is running into a similar issue that we’re having. We’ve set up a workflow which has a

waitForEvent

waitForEvent

step, but when we use

sendEvent

sendEvent

in our route to continue the workflow, we are sometimes waiting up to 45 minutes for the workflow to continue. Some extra info:

The route where
```
sendEvent
```
```
sendEvent
```
is being called is deployed to a Cloudflare Worker.
No errors are being thrown when
```
sendEvent
```
```
sendEvent
```
is called, and the types match.
The issue seems to happen when the workflow has been idle for at least 20 minutes, if the
```
waitForEvent
```
```
waitForEvent
```
step has only been waiting for a few minutes I haven’t recreated the issue yet, but when the
```
waitForEvent
```
```
waitForEvent
```
step has been waiting 20+ minutes we run into the issue the majority of the time.
We haven’t changed any of the default retry logic in the workflow.

Any ideas? My understanding is that this isn’t the expected behaviour in a Cloudflare Workflow.

J

johtso•5/20/25, 2:55 PM

Are errors not recorded if they're in the top level of a workflow?

J

johtso•5/20/25, 4:05 PM

how do I see logs from a workflow?

Jjohtso Are errors not recorded if they're in the top level of a workflow?

K

koraytaylan•5/20/25, 5:21 PM

they show up in workflow instance details page but top level errors are not retried.

Jjohtso how do I see logs from a workflow?

K

koraytaylan•5/20/25, 5:22 PM

you see them from the observability page where you track your worker logs also.

Kkoraytaylan they show up in workflow instance details page but top level errors are not retr...

J

johtso•5/20/25, 5:51 PM

they don't seem to appear on the workflow instance details page, the instance is marked as errored, but there are no steps to attach the error to so it isn't shown

J

johtso•5/20/25, 5:51 PM

my solution was to wrap everything in a top level step with no retries

Jjohtso they don't seem to appear on the workflow instance details page, the instance is...

K

koraytaylan•5/20/25, 5:54 PM

i am able to see the top level errors' messages on that page which i thought it would work the same for you sorry about that

Kkoraytaylan i am able to see the top level errors' messages on that page which i thought it ...

J

johtso•5/20/25, 5:59 PM

oh right, I do actually see something, but it just says "The execution of the Workflow instance was terminated, as a step threw an NonRetryableError and it was not handled"

J

johtso•5/20/25, 5:59 PM

it doesn't give me the error's message

C

charl.dev•5/21/25, 8:12 PM

On my paid workers account, it seems I can’t deploy a worker with workflows. When I try publish the worker, the worker does get deployed but wrangler throws error for the ../workflows api.

Auth error

I also get an error if I try wrangler workflows list

C

charl.dev•5/21/25, 8:12 PM

I’ve tried logging in and out

C

charl.dev•5/21/25, 8:12 PM

Do I need to be enabled for workflows?

B

Boragorn•5/22/25, 1:45 AM

@moonage.dev not sure if this is what you're looking for, but that's how I deploy workers with workflows:

// src/workers/my.worker.ts

import { MyWorkflow } from "../workflows/my.workflow";

export {
   MyWorkflow
};


type Bindings = {
  MY_WORKFLOW: Workflow;
};

const app = new Hono<{ Bindings: Bindings }>();

app.post('/', async (c) => {
  return c.env.MY_WORKFLOW.create(..);
}) 

export default {
  fetch: app.fetch,
};

// src/workers/my.worker.ts

import { MyWorkflow } from "../workflows/my.workflow";

export {
   MyWorkflow
};


type Bindings = {
  MY_WORKFLOW: Workflow;
};

const app = new Hono<{ Bindings: Bindings }>();

app.post('/', async (c) => {
  return c.env.MY_WORKFLOW.create(..);
}) 

export default {
  fetch: app.fetch,
};

// src/workers/my.worker.ts

import { MyWorkflow } from "../workflows/my.workflow";

export {
   MyWorkflow
};


type Bindings = {
  MY_WORKFLOW: Workflow;
};

const app = new Hono<{ Bindings: Bindings }>();

app.post('/', async (c) => {
  return c.env.MY_WORKFLOW.create(..);
}) 

export default {
  fetch: app.fetch,
};

// src/workers/my.worker.ts

import { MyWorkflow } from "../workflows/my.workflow";

export {
   MyWorkflow
};


type Bindings = {
  MY_WORKFLOW: Workflow;
};

const app = new Hono<{ Bindings: Bindings }>();

app.post('/', async (c) => {
  return c.env.MY_WORKFLOW.create(..);
}) 

export default {
  fetch: app.fetch,
};

C

charl.dev•5/22/25, 6:30 AM

It’s not a problem with the worker, tried to deploy a fresh workflow starter and same issue:

workflows-starter2 % npm run deploy

workflows-starter@0.0.1 deploy
wrangler deploy

wrangler 4.16.0
-------------------

Total Upload: 2.20 KiB / gzip: 1.02 KiB
Your Worker has access to the following bindings:

Workflows:
- MY_WORKFLOW: MyWorkflow
  Uploaded workflows-starter2 (8.26 sec)

✘ [ERROR] A request to the Cloudflare API (/accounts/xxx/workflows/workflows-starter) failed.

Authentication error [code: 10000]

Getting User settings...

You are logged in with an OAuth Token, associated with the email xxx@gmail.com.
┌───────────────────────────────┬──────────────────────────────────┐
│ Account Name │ Account ID │
├───────────────────────────────┼──────────────────────────────────┤
│ xxx@gmail.com's Account │ xxx │
└───────────────────────────────┴──────────────────────────────────┘

Token Permissions: If scopes are missing, you may need to logout and re-login.
Scope (Access)

account (read)
user (read)
workers (write)
workers_kv (write)
workers_routes (write)
workers_scripts (write)
workers_tail (read)
d1 (write)
pages (write)
zone (read)
ssl_certs (write)
ai (write)
queues (write)
pipelines (write)
secrets_store (write)
offline_access
Membership roles in "xxx@gmail.com's Account": Contact account super admin to change your permissions.
Super Administrator - All Privileges

S

Stupefystar•5/22/25, 6:33 AM

Can someone please tell me why my workflows are running multiples times in parallel?

export default {
    async fetch(req: Request, env: Env): Promise<Response> {
        let instance = await env.DATA_WORKFLOW.create();
        return Response.json({
            id: instance.id,
            details: await instance.status(),
        });
    },
};

export default {
    async fetch(req: Request, env: Env): Promise<Response> {
        let instance = await env.DATA_WORKFLOW.create();
        return Response.json({
            id: instance.id,
            details: await instance.status(),
        });
    },
};

export default {
    async fetch(req: Request, env: Env): Promise<Response> {
        let instance = await env.DATA_WORKFLOW.create();
        return Response.json({
            id: instance.id,
            details: await instance.status(),
        });
    },
};

export default {
    async fetch(req: Request, env: Env): Promise<Response> {
        let instance = await env.DATA_WORKFLOW.create();
        return Response.json({
            id: instance.id,
            details: await instance.status(),
        });
    },
};

I will have

do something with ids

do something with ids

run multiple times even tho it doesn't fail or anything

async run(event: WorkflowEvent<Params>, step: WorkflowStep) {
        const storageKey = `instructions-${event.instanceId}.json`;
        const defaultConfig = {retries: { limit: 1, delay: 1000 }};

        try {
            const ids = await step.do('download ids', defaultConfig, async () => {
                //
            });

            await step.do('do something with ids', defaultConfig, async () => {
                //
            });

            await step.do('do something with ids', defaultConfig, async () => {
                //
            });

            // Cleanup after successful completion
            await this.env.TEMP_STORAGE.delete(storageKey);
        } catch (error) {
            // Cleanup on failure
            await this.env.TEMP_STORAGE.delete(storageKey);
            throw new NonRetryableError("Unknown error");
        }

        let workflow = await this.env.DATA_WORKFLOW.get(event.instanceId);
        await workflow.terminate();
    }

async run(event: WorkflowEvent<Params>, step: WorkflowStep) {
        const storageKey = `instructions-${event.instanceId}.json`;
        const defaultConfig = {retries: { limit: 1, delay: 1000 }};

        try {
            const ids = await step.do('download ids', defaultConfig, async () => {
                //
            });

            await step.do('do something with ids', defaultConfig, async () => {
                //
            });

            await step.do('do something with ids', defaultConfig, async () => {
                //
            });

            // Cleanup after successful completion
            await this.env.TEMP_STORAGE.delete(storageKey);
        } catch (error) {
            // Cleanup on failure
            await this.env.TEMP_STORAGE.delete(storageKey);
            throw new NonRetryableError("Unknown error");
        }

        let workflow = await this.env.DATA_WORKFLOW.get(event.instanceId);
        await workflow.terminate();
    }

async run(event: WorkflowEvent<Params>, step: WorkflowStep) {
        const storageKey = `instructions-${event.instanceId}.json`;
        const defaultConfig = {retries: { limit: 1, delay: 1000 }};

        try {
            const ids = await step.do('download ids', defaultConfig, async () => {
                //
            });

            await step.do('do something with ids', defaultConfig, async () => {
                //
            });

            await step.do('do something with ids', defaultConfig, async () => {
                //
            });

            // Cleanup after successful completion
            await this.env.TEMP_STORAGE.delete(storageKey);
        } catch (error) {
            // Cleanup on failure
            await this.env.TEMP_STORAGE.delete(storageKey);
            throw new NonRetryableError("Unknown error");
        }

        let workflow = await this.env.DATA_WORKFLOW.get(event.instanceId);
        await workflow.terminate();
    }

async run(event: WorkflowEvent<Params>, step: WorkflowStep) {
        const storageKey = `instructions-${event.instanceId}.json`;
        const defaultConfig = {retries: { limit: 1, delay: 1000 }};

        try {
            const ids = await step.do('download ids', defaultConfig, async () => {
                //
            });

            await step.do('do something with ids', defaultConfig, async () => {
                //
            });

            await step.do('do something with ids', defaultConfig, async () => {
                //
            });

            // Cleanup after successful completion
            await this.env.TEMP_STORAGE.delete(storageKey);
        } catch (error) {
            // Cleanup on failure
            await this.env.TEMP_STORAGE.delete(storageKey);
            throw new NonRetryableError("Unknown error");
        }

        let workflow = await this.env.DATA_WORKFLOW.get(event.instanceId);
        await workflow.terminate();
    }

Ccharl.dev It’s not a problem with the worker, tried to deploy a fresh workflow starter and...

C

charl.dev•5/22/25, 6:35 AM

Magically working now to deploy

Original message was deleted

S

Stupefystar•5/22/25, 9:19 AM

I simplified it for the demo, but each one has their own unique name.

S

Stupefystar•5/22/25, 9:20 AM

ie first step runs this command where it runs 3 times all at once but this should only be run once.

S

Stupefystar•5/22/25, 9:20 AM

Sometime it'll run once, sometimes three times

S

Stupefystar•5/22/25, 9:59 AM

S

Stupefystar•5/22/25, 9:59 AM

just within the closure of the first step

S

Stupefystar•5/22/25, 10:57 AM

AHHH i am an idiot.. so because the web server is calling

fetch(req: Request, env: Env): Promise<Response>

fetch(req: Request, env: Env): Promise<Response>

for the root, and the favicon requests that explains why each step is being called multiple times.

WWallslide Is it the env.WORKFLOW.create call that is failing? Is it in the workflow's run(...

C

Chaika•5/22/25, 7:26 PM

nothing's failing, it's just the way workflow runs show in logs

C

Chaika•5/22/25, 7:28 PM

team said they working on fixing workflows
https://discord.com/channels/595317990191398933/1303411588929294358/1303488051917492318

S

scook•5/22/25, 11:50 PM

^ Does this mean there's an ongoing incident right now? Because some of my workflow invocations failed to call

await env.WORKFLOW_NAME.create()

await env.WORKFLOW_NAME.create()

with an ambiguous "internal error", whereas some succeeded.

Similar Threads