Si bien no sé mucho sobre express , al menos puedo aclarar un concepto erróneo que tiene sobre las funciones anónimas.

Cuando crea una función y la almacena inmediatamente en una variable, el intérprete puede usar implícitamente el nombre de la variable como el nombre de la función. Eso es cierto para ambas funciones creadas con la expresión de function o con la notación de flecha.

 const foo = () => {}; foo.name; // "foo"; const bar = function () {}; bar.name; // "bar";

Pero si crea una función y luego la pasa inmediatamente como argumento o la devuelve, el intérprete no puede darle un nombre en el momento de la creación, por lo que se vuelve anónima.

Así que cuando hiciste esto:

 const namedFunction = f();

Todo lo que hizo fue almacenar la función anónima ya creada devuelta por f() dentro de la variable namedFunction . En realidad no le diste un nombre. Para hacer eso, tendrías que hacer algo así:

 const unnamedFunction = f(); const namedFunction = (...args) => unnamedFunction(...args);

Lo que simplemente envuelve la función sin nombre en una con nombre.

También puede crear una variable para almacenar una función de flecha antes de devolverla o pasarla como devolución de llamada.

 const meaningfulName = () => { ... }; return meaningfulName;

Pero a menos que realmente confíe en el comportamiento de las funciones de flecha, solo usaría una expresión de función con nombre en esos casos:

 return function meaningfulName () { ... };

En esta respuesta , se muestra un ejemplo que redefine la propiedad de nombre de una función que normalmente es de solo lectura. Esto parece funcionar bien en v8.

 // Apart from the added error so we can log a stack trace, // this is unchanged from your example: const f = () => { return async (req, res, next) => { throw new Error("Intentionally cause an error to log the function's name."); await new Promise(resolve => setTimeout(resolve, 3000)); return next(); } } const namedFunction = f();

Cuando se llama a la función y se registra su error, obtendrá un seguimiento de pila como este, como vio en su perfilador, la función no tiene nombre:

 namedFunction().catch(console.log); // Error: Intentionally cause an error to log the function's name. // at /tmp/namedfn.js:3:19 // at Object.<anonymous> (/tmp/namedfn.js:9:5)

Cambiar el nombre según la respuesta vinculada:

 Object.defineProperty(namedFunction, 'name', {value: 'someFn'}); namedFunction().catch(console.log); // Error: Intentionally cause an error to log the function's name. // at someFn (/tmp/namedfn.js:3:19) // at /tmp/namedfn.js:14:9

Ahora se llama 'someFn' y debería aparecer en su generador de perfiles como tal.

Tenga en cuenta que esta respuesta es mejor/menos hacky en los casos en que la fuente se puede editar (OP no tiene control sobre el contenido de f() según un comentario).

Después de muchos intentos de asignar un nombre, refactorizar el uso, se me ocurrió esto y, finalmente, el generador de perfiles pudo señalar que es la función envuelta la que lo está causando, así que debo crear una función de envoltorio para cada uno de los casos.

Aquí hay una muestra de lo que funcionó al final:

 const f = () => { return async (req, res, next) => { await new Promise(resolve => setTimeout(resolve, 3000)); return next(); } } const wrappedFunction = async(req, res, next) => { await new Promise(resolve => f()(req, res, resolve)); // Now since time is spent in this block that's why profiler is picking this up instead of the anonymous function as the main resource consuming function next(); } app.use(wrappedFunction);

Y así es como se ve ahora en Profiler:

Solo una nota para otros que quizás no conozcan el contexto: de forma predeterminada, los middlewares oficiales suelen tener nombres de funciones, pero algunos middleware de terceros devuelven una función anónima que el generador de perfiles/APM no puede detectar y apuntar al bloque de código desde allí. Por eso es importante tener una función con nombre en lugar de un anonymous middleware que aparece en la interfaz de usuario y no está claro dónde mirar.