Thanks for the advice, much appreciated. If the leakage occurs within multiple requests for the same

MMitya Thanks for the advice, much appreciated. If the leakage occurs within multiple r...

H

Hello, I’m Allie!•3/4/24, 4:29 PM

You can’t be guaranteed that it will/won’t ever leak

MMitya Thanks for the advice, much appreciated. If the leakage occurs within multiple r...

I

Isaac McFadyen•3/4/24, 4:29 PM

So basically a global variable is stored per server (called a "metal"). Cloudflare has many many metals so it's unlikely that one user will hit the same metal, but it's very much possible especially in smaller datacenters with only a few metals. I'd not rely on users hitting different metals and just write any code with the idea that it might leak between users if they hit the same metal.

C

Chaika•3/4/24, 4:31 PM

(the other way I'd view it is eventually if you scale up/become big enough it's going to happen more and more, unlikely at small scale sure but still bad idea)

M

MityaOP•3/4/24, 4:32 PM

Interesting - thanks very much. So if I can't hook things onto a global object, for the reasons you guys have said, is my only remaining option to explicitly pass around info between concerns (middleware/controllers/helpers) or is there some other way I'm missing?

M

MityaOP•3/4/24, 4:32 PM

(I come from PHP land, where everything is isolated per request, even globals.)

MMitya Interesting - thanks very much. So if I can't hook things onto a global object, ...

H

Hello, I’m Allie!•3/4/24, 4:35 PM

If it is only per-request storage you need, you could use https://developers.cloudflare.com/workers/runtime-apis/nodejs/asynclocalstorage

Cloudflare Docs

AsyncLocalStorage · Cloudflare Workers docs

Cloudflare Workers provides an implementation of a subset of the Node.js AsyncLocalStorage API for creating in-memory stores that remain coherent …

M

MityaOP•3/4/24, 4:45 PM

Oh, interesting. Presumably good old, synchronous, browser-style

globalObject.localStorage

globalObject.localStorage

globalObject.localStorage

globalObject.localStorage wouldn't work? If so, using AsyncLocalStorage, am I right that it would look something like this, to store a global property for later reading downstream?
Upstream file:

import { AsyncLocalStorage } from 'node:async_hooks';
const fooStore = new AsyncLocalStorage();
fooStore.run('bar'); //<-- running in some async middleware

import { AsyncLocalStorage } from 'node:async_hooks';
const fooStore = new AsyncLocalStorage();
fooStore.run('bar'); //<-- running in some async middleware

import { AsyncLocalStorage } from 'node:async_hooks';
const fooStore = new AsyncLocalStorage();
fooStore.run('bar'); //<-- running in some async middleware

import { AsyncLocalStorage } from 'node:async_hooks';
const fooStore = new AsyncLocalStorage();
fooStore.run('bar'); //<-- running in some async middleware

Downstream file:

import { AsyncLocalStorage } from 'node:async_hooks';
const fooStore = new AsyncLocalStorage();
const fooVal = fooStore.getStore(); //"bar"

import { AsyncLocalStorage } from 'node:async_hooks';
const fooStore = new AsyncLocalStorage();
const fooVal = fooStore.getStore(); //"bar"

import { AsyncLocalStorage } from 'node:async_hooks';
const fooStore = new AsyncLocalStorage();
const fooVal = fooStore.getStore(); //"bar"

import { AsyncLocalStorage } from 'node:async_hooks';
const fooStore = new AsyncLocalStorage();
const fooVal = fooStore.getStore(); //"bar"

JJadugar_Jaggu hey guys is anyone familiar with this issue? I am facing it right after automati...

C

Chaika•3/4/24, 4:46 PM

Thanks for reporting. I would watch this incident for further updates on the issue, and try again when it is resolved:
https://www.cloudflarestatus.com/incidents/3q7sg3tpp7qv

Issues changing CPU Limit for Cloudflare Workers and Pages

MMitya Oh, interesting. Presumably good old, synchronous, browser-style `globalObject.l...

K

kian•3/4/24, 4:46 PM

import { AsyncLocalStorage } from "node:async_hooks";

const asyncLocalStorage = new AsyncLocalStorage();

async function doStuff() {
  const { req, env, ctx } = asyncLocalStorage.getStore();

  const obj = await env.KV.get("foo");

  // ...
}

export default {
  async fetch(req, env, ctx) {
    return asyncLocalStorage.run({ req, env, ctx }, async () => {
      await doStuff();

      return new Response("Hello World!");
    });
  },
};

import { AsyncLocalStorage } from "node:async_hooks";

const asyncLocalStorage = new AsyncLocalStorage();

async function doStuff() {
  const { req, env, ctx } = asyncLocalStorage.getStore();

  const obj = await env.KV.get("foo");

  // ...
}

export default {
  async fetch(req, env, ctx) {
    return asyncLocalStorage.run({ req, env, ctx }, async () => {
      await doStuff();

      return new Response("Hello World!");
    });
  },
};

import { AsyncLocalStorage } from "node:async_hooks";

const asyncLocalStorage = new AsyncLocalStorage();

async function doStuff() {
  const { req, env, ctx } = asyncLocalStorage.getStore();

  const obj = await env.KV.get("foo");

  // ...
}

export default {
  async fetch(req, env, ctx) {
    return asyncLocalStorage.run({ req, env, ctx }, async () => {
      await doStuff();

      return new Response("Hello World!");
    });
  },
};

import { AsyncLocalStorage } from "node:async_hooks";

const asyncLocalStorage = new AsyncLocalStorage();

async function doStuff() {
  const { req, env, ctx } = asyncLocalStorage.getStore();

  const obj = await env.KV.get("foo");

  // ...
}

export default {
  async fetch(req, env, ctx) {
    return asyncLocalStorage.run({ req, env, ctx }, async () => {
      await doStuff();

      return new Response("Hello World!");
    });
  },
};

K

kian•3/4/24, 4:47 PM

run

run

run

run takes the object you want to store, and then a callback

M

MityaOP•3/4/24, 4:49 PM

Thanks @kian . So I was nearly there but just need to pass an object? And presumably the callback is optional if all I'm doing is writing to the store for future use, rather than, as per the docs example, sending a response once write is complete?

K

kian•3/4/24, 4:49 PM

Doesn't necessarily have to be an object

K

kian•3/4/24, 4:49 PM

Can be a string, number, array, etc

M

MityaOP•3/4/24, 4:50 PM

Yeah... so my original effort would work? (I passed just a string value there, not an object.) But is the general flow correct? Appreciate the help.

K

kian•3/4/24, 4:50 PM

run

run

run

run requires the callback

K

kian•3/4/24, 4:50 PM

The idea is that it runs that function async within a 'context'

K

kian•3/4/24, 4:50 PM

and the store for that context is what you passed as the first arg

M

MityaOP•3/4/24, 4:51 PM

Ah... then I'm struggling a little. You're saying

mystore.run({foo: bar})

mystore.run({foo: bar})

mystore.run({foo: bar})

mystore.run({foo: bar}) is insufficient to write to the storage? If so, what would any callback I passed actually "do", if all I want to do is write for later reading?

K

kian•3/4/24, 4:58 PM

The storage is only available within the function passed to

run

run

run

run

K

kian•3/4/24, 4:59 PM

i.e in my case, I put everything inside the function I pass to

run

run

run

run and return my Response there

K

kian•3/4/24, 4:59 PM

Everything else can now do

asyncLocalStorage.getStore();

asyncLocalStorage.getStore();

asyncLocalStorage.getStore();

asyncLocalStorage.getStore(); to access req, env, ctx

M

MityaOP•3/4/24, 5:00 PM

OK, that makes sense. But does this mean that downstream files/functions in other files will not be able to access the storage value because they're not running in

run()

run()

run()

run()'s callback?

Say file A (middleware) wants to write a value to storage. That middleware then hands over to a controller (file B), which then calls a helper function in file C. Is it possible files B/C to access the storage value written by file A?

M

MityaOP•3/4/24, 5:01 PM

Sorry - this is all new to me and I'm having a little difficulty. I do appreciate the help.

K

kian•3/4/24, 5:03 PM

Do you have a minimal example of the layout/middleware? It might be easier if I adapt that to use AsyncLocalStorage and you can see how it works.

M

MityaOP•3/4/24, 5:05 PM

Sure. I'm using itty-router. So:

import fooApi from '../controllers/foo'
router.post('/foo/bar', async req => {
  const resp = fooApi.bar(); //e.g. "hello world"
  return resp;
})

import fooApi from '../controllers/foo'
router.post('/foo/bar', async req => {
  const resp = fooApi.bar(); //e.g. "hello world"
  return resp;
})

import fooApi from '../controllers/foo'
router.post('/foo/bar', async req => {
  const resp = fooApi.bar(); //e.g. "hello world"
  return resp;
})

import fooApi from '../controllers/foo'
router.post('/foo/bar', async req => {
  const resp = fooApi.bar(); //e.g. "hello world"
  return resp;
})

I'd like to be able to set a local storage value in that middleware, but have my function at

fooApi.bar()

fooApi.bar()

fooApi.bar()

fooApi.bar() (in

controllers/foo.js

controllers/foo.js

controllers/foo.js

controllers/foo.js) be able to access that stored value.

M

MityaOP•3/4/24, 5:06 PM

controllers/foo

controllers/foo

controllers/foo

controllers/foo:

export default {
  bar: () => {
    //how to access local storage value in here? I'm not in the middleware's storage.run() callback at this point...
  }
};

export default {
  bar: () => {
    //how to access local storage value in here? I'm not in the middleware's storage.run() callback at this point...
  }
};

export default {
  bar: () => {
    //how to access local storage value in here? I'm not in the middleware's storage.run() callback at this point...
  }
};

export default {
  bar: () => {
    //how to access local storage value in here? I'm not in the middleware's storage.run() callback at this point...
  }
};

K

kian•3/4/24, 5:15 PM

export const als = new AsyncLocalStorage();

router.get("/", async () => {
    return als.run("foo", async () => {
        const resp = foo.bar();
        return new Response(resp);
    });
});

export const als = new AsyncLocalStorage();

router.get("/", async () => {
    return als.run("foo", async () => {
        const resp = foo.bar();
        return new Response(resp);
    });
});

export const als = new AsyncLocalStorage();

router.get("/", async () => {
    return als.run("foo", async () => {
        const resp = foo.bar();
        return new Response(resp);
    });
});

export const als = new AsyncLocalStorage();

router.get("/", async () => {
    return als.run("foo", async () => {
        const resp = foo.bar();
        return new Response(resp);
    });
});

import { als } from ".";

export default {
    bar: () => {
        return als.getStore();
    },
};

import { als } from ".";

export default {
    bar: () => {
        return als.getStore();
    },
};

import { als } from ".";

export default {
    bar: () => {
        return als.getStore();
    },
};

import { als } from ".";

export default {
    bar: () => {
        return als.getStore();
    },
};

K

kian•3/4/24, 5:15 PM

Admittedly it's not ideal with multiple modules as you have to pass around the top-level

als

als

als

als

Kkian ```js export const als = new AsyncLocalStorage(); router.get("/", async () => {...

H

Hello, I’m Allie!•3/4/24, 5:16 PM

I forget, can’t you shim the storage onto GlobalScope?

K

kian•3/4/24, 5:17 PM

I wonder if

globalThis.als = new AsyncLocalStorage

globalThis.als = new AsyncLocalStorage

globalThis.als = new AsyncLocalStorage

globalThis.als = new AsyncLocalStorage would work

K

kian•3/4/24, 5:17 PM

:blobcatthonking:

Kkian I wonder if `globalThis.als = new AsyncLocalStorage` would work

H

Hello, I’m Allie!•3/4/24, 5:17 PM

https://tenor.com/view/great-minds-think-like-smile-smart-gif-14683105

Tenor

M

MityaOP•3/4/24, 5:17 PM

That would be great if so (but if it does, couldn't I just hook my data onto

globalThis

globalThis

globalThis

globalThis in the first place and bypass ALS?)

MMitya That would be great if so (but if it does, couldn't I just hook my data onto `gl...

H

Hello, I’m Allie!•3/4/24, 5:18 PM

You would have no guarantee that the data isn’t changed from one request to another

H

Hello, I’m Allie!•3/4/24, 5:18 PM

So you might also mix requests from multiple clients

M

MityaOP•3/4/24, 5:18 PM

Ahh, right, so that would be back to my original problem

M

MityaOP•3/4/24, 5:19 PM

Final question:

import { als } from ".";

import { als } from ".";

import { als } from ".";

import { als } from ".";

...in my controller. Could you kindly explain how that works? That seems to be importing a variable from the scope that called my controller function. Is that right? I've never seen that before - I've only ever seen

import

import

import

import reference modules/files.

K

kian•3/4/24, 5:20 PM

globalThis.als = new AsyncLocalStorage();

globalThis.als = new AsyncLocalStorage();

globalThis.als = new AsyncLocalStorage();

globalThis.als = new AsyncLocalStorage(); seems to work too

K

kian•3/4/24, 5:21 PM

K

kian•3/4/24, 5:21 PM

K

kian•3/4/24, 5:21 PM

(notice how the

d7d6d2f4

d7d6d2f4

d7d6d2f4

d7d6d2f4 isn't overwritten by

987f4e92

987f4e92

987f4e92

987f4e92 like it would be if you just stored them on

globalThis

globalThis

globalThis

globalThis)

M

MityaOP•3/4/24, 5:23 PM

Riiiiiiiiiight... this is where my behind-the-scenes Node knowledge is lacking.

So if hooking things directly onto

globalThis

globalThis

globalThis

globalThis runs the risk of multi-request leakage, how come I avoid that problem by hooking the (same) ALS onto

globalThis

globalThis

globalThis

globalThis? How does that avoid the same issue, since each request will be running that code (making a store, hooking the same property name onto it?) In other words, what guarantees that request 1 hooking

foo=1

foo=1

and request 2 hooking

foo=2

foo=2

will be preserved within the scope of their respective requests, using ALS?

K

kian•3/4/24, 5:24 PM

K

kian•3/4/24, 5:24 PM

The "why" is that it's implemented by the runtime & tracks the async context for you - that's all done in C++

magic

K

kian•3/4/24, 5:26 PM

https://github.com/cloudflare/workerd/blob/bd06b08cc729b136f4dc22e39e47b5c8ef7ecbd1/src/workerd/jsg/README.md?plain=1#L1529-L1599

M

MityaOP•3/4/24, 5:26 PM

Riiiight, thank you. So to summarise:
-

globalThis.foo

globalThis.foo

globalThis.foo

globalThis.foo set in one file and read in another file risks mutation/leakage from other requests
-

globalThis.als

globalThis.als

globalThis.als

globalThis.als, where

als

als

als

als is a store with

{foo: <something>}

{foo: <something>}

{foo: <something>}

{foo: <something>} set on it, avoids that problem

K

kian•3/4/24, 5:30 PM

Yep.

K

kian•3/4/24, 5:30 PM

https://www.youtube.com/watch?v=ukefzxZ_G9U is by James Snell, who is a NodeJS maintainer and also a Cloudflare employee who was involved in implementing AsyncLocalStorage into Workers too

YouTubeThis Dot Media

Async Context Tracking in Node with Async Local Storage API ft. Jam...

In this JS Drop, James Snell goes over how Async Local Storage API works. He goes over the drawbacks of cascading functions for attaching information the traditional way, and why using Async Local Storage API (now stable) may be a more efficient use with Async Context Tracking.

Follow James Snell on Twitter: https://twitter.com/jasnell

JS Drop...

K

kian•3/4/24, 5:31 PM

It might help explain how it works

M

MityaOP•3/4/24, 5:33 PM

Thanks, I'll give that a go. Coming from PHP, it's weird getting your head around the idea that things are not all isolated to the request only! Just needs a change in mindset. Anyway I really appreciate your guys' help and patience. You're a credit to CF. Have a good evening.

Thanks for the advice, much appreciated. If the leakage occurs within multiple requests for the same

Similar Threads

Similar Threads

Similar Threads