executionCtx.waitUntil on write service

I have a worker that I want to call an external api on, but I want to return a response without awaiting the the external api call. (the external api call is to just save time writing to the db on another service).

        const promise = fetch('http://localhost:3000/impression', {
            method: "POST",
            body: JSON.stringify(data),
            headers: {
                "content-type": "application/json",
            }
        });
        c.executionCtx.waitUntil(promise.then())

        flow.params = { campaignId: campaignId }
        return flow;

        const promise = fetch('http://localhost:3000/impression', {
            method: "POST",
            body: JSON.stringify(data),
            headers: {
                "content-type": "application/json",
            }
        });
        c.executionCtx.waitUntil(promise.then())

        flow.params = { campaignId: campaignId }
        return flow;

        const promise = fetch('http://localhost:3000/impression', {
            method: "POST",
            body: JSON.stringify(data),
            headers: {
                "content-type": "application/json",
            }
        });
        c.executionCtx.waitUntil(promise.then())

        flow.params = { campaignId: campaignId }
        return flow;

        const promise = fetch('http://localhost:3000/impression', {
            method: "POST",
            body: JSON.stringify(data),
            headers: {
                "content-type": "application/json",
            }
        });
        c.executionCtx.waitUntil(promise.then())

        flow.params = { campaignId: campaignId }
        return flow;

however when I am testing it local and it is not hitting the service
I am using hono
https://hono.dev/api/context#executionctx

the worker is on localhost:8787 and the write service for the impression is on localhost:3000 I am able to create the impression successfully calling it directly but the waitUntil is not hitting localhost:3000 when calling the localhost:8787 endpoint

Context - Hono

Ultrafast web framework for Cloudflare Workers, Fastly Compute, Deno, Bun, Vercel, Node.js, and others. Fast, but not only fast.

tonytheonlyOP•4/30/24, 1:48 PM

Even without the .then() the service is not being called

tonytheonlyOP•4/30/24, 2:47 PM

The wrangler endpoint (localhost:8787) is being hit fine. I have a successful log to the console of the JSON.stringify(data)
It is not however sending the POST to the http://localhost:3000/impression
But when sending a POST in postman to http://localhost:3000/impression i get a response.

tonytheonlyOP•4/30/24, 2:47 PM

@conqr

tonytheonlyOP•4/30/24, 4:09 PM

Even when not testing it locally and in a live environment it is not posting

tonytheonlyOP•4/30/24, 4:09 PM

Validated that the enpoint being sent is accepting traffic / getting a response in postman

Ttonytheonly Even when not testing it locally and in a live environment it is not posting

Chaika•4/30/24, 4:13 PM

there's port restrictions with live workers (flowchart by community mvp albert)

e9ae7e44c051cc5157a3e7ae2d30b274e6a57049_2_1035x543.png

Chaika•4/30/24, 4:14 PM

same-zone being same website in CF

Chaika•4/30/24, 4:15 PM

what are you trying to fetch? Does it work without putting it in the ctx.waitUntil? dk if it would error out in there, iirc it would log it but not change the outcome of the request

tonytheonlyOP•4/30/24, 4:33 PM

@Chaika
It does work when removing the waitUntil:

        const response = await fetch(`${DO_URL}impressions`, {
            method: "POST",
            body: JSON.stringify(data),
            headers: {
                "content-type": "application/json",
            }
        })

        const imp = await response.json();

        console.log("Impression created", JSON.stringify(imp))
        // c.executionCtx.waitUntil(promise.then(() => console.log("Impression created")))

        const response = await fetch(`${DO_URL}impressions`, {
            method: "POST",
            body: JSON.stringify(data),
            headers: {
                "content-type": "application/json",
            }
        })

        const imp = await response.json();

        console.log("Impression created", JSON.stringify(imp))
        // c.executionCtx.waitUntil(promise.then(() => console.log("Impression created")))

  "logs": [
    {
      "message": [
        "  <-- GET /c/efe826eb-5263-482a-8291-7c3052e3469c"
      ],
      "level": "log",
      "timestamp": 1714494689412
    },
    {
      "message": [
        "Impression created",
        "[object Object]"
      ],
      "level": "log",
      "timestamp": 1714494690525
    },
    {
      "message": [
        "  --> GET /c/efe826eb-5263-482a-8291-7c3052e3469c \u001b[36m301\u001b[0m 1s"
      ],
      "level": "log",
      "timestamp": 1714494690525
    }
  ]

  "logs": [
    {
      "message": [
        "  <-- GET /c/efe826eb-5263-482a-8291-7c3052e3469c"
      ],
      "level": "log",
      "timestamp": 1714494689412
    },
    {
      "message": [
        "Impression created",
        "[object Object]"
      ],
      "level": "log",
      "timestamp": 1714494690525
    },
    {
      "message": [
        "  --> GET /c/efe826eb-5263-482a-8291-7c3052e3469c \u001b[36m301\u001b[0m 1s"
      ],
      "level": "log",
      "timestamp": 1714494690525
    }
  ]

tonytheonlyOP•4/30/24, 4:42 PM

well.. it does give a log, but when stringifying it shows an empty object. investigating

CChaika what are you trying to fetch? Does it work without putting it in the ctx.waitUnt...

tonytheonlyOP•4/30/24, 4:56 PM

I am offloading a POST to another service to since it is not needed in the worker response.

tonytheonlyOP•4/30/24, 4:59 PM

got the request working updated the code in the message above.

tonytheonlyOP•4/30/24, 5:09 PM

Okay this is now working

tonytheonlyOP•4/30/24, 5:09 PM

working code:

        const promise = fetch(`${DO_URL}impressions`, {
            method: "POST",
            body: JSON.stringify(data),
            headers: {
                "content-type": "application/json",
            }
        })

        c.executionCtx.waitUntil(promise.then(async (response) => {
            const imp = await response.json()
            console.log("Impression created", JSON.stringify(imp))
        }))

        const promise = fetch(`${DO_URL}impressions`, {
            method: "POST",
            body: JSON.stringify(data),
            headers: {
                "content-type": "application/json",
            }
        })

        c.executionCtx.waitUntil(promise.then(async (response) => {
            const imp = await response.json()
            console.log("Impression created", JSON.stringify(imp))
        }))

executionCtx.waitUntil on write service

Similar Threads

Similar Threads

Similar Threads