medir - calcular tiempo transcurrido javascript

Cómo medir el tiempo de ejecución de código javascript con devoluciones de llamada

Question

Tengo una pieza de código javascript que estoy ejecutando usando el intérprete node.js.

for(var i = 1; i < LIMIT; i++){
    db.users.save({id : i, name : "MongoUser [" + i + "]"}, function(err, saved) {
          if( err || !saved ) console.log("Error");
          else console.log("Saved");
    });
}

Quiero saber cómo medir el tiempo que tardan estas operaciones de inserción de db. Podría calcular la diferencia de los valores de fecha después y antes de este fragmento de código, pero eso sería incorrecto debido a la naturaleza asíncrona del código.

Answer 1

Al invocar console.time(''label'') registrará la hora actual en milisegundos, luego, al llamar a console.timeEnd(''label'') se mostrará la duración desde ese punto.

El tiempo en milisegundos se imprimirá automáticamente junto con la etiqueta, por lo que no tiene que hacer una llamada por separado a console.log para imprimir una etiqueta:

console.time(''test'');
//some code
console.timeEnd(''test''); //Prints something like that-> test: 11374.004ms

Para obtener más información, consulte los documentos del desarrollador de Mozilla en console.time .

Answer 2

Hay un método que está diseñado para esto. Echa un vistazo a process.hrtime(); .

Así que, básicamente, puse esto en la parte superior de mi aplicación.

var start = process.hrtime();

var elapsed_time = function(note){
    var precision = 3; // 3 decimal places
    var elapsed = process.hrtime(start)[1] / 1000000; // divide by a million to get nano to milli
    console.log(process.hrtime(start)[0] + " s, " + elapsed.toFixed(precision) + " ms - " + note); // print message + time
    start = process.hrtime(); // reset the timer
}

Luego lo uso para ver cuánto tardan las funciones. Aquí hay un ejemplo básico que imprime el contenido de un archivo de texto llamado "output.txt":

var debug = true;
http.createServer(function(request, response) {

    if(debug) console.log("----------------------------------");
    if(debug) elapsed_time("recieved request");

    var send_html = function(err, contents) {
        if(debug) elapsed_time("start send_html()");
        response.writeHead(200, {''Content-Type'': ''text/html'' } );
        response.end(contents);
        if(debug) elapsed_time("end send_html()");
    }

    if(debug) elapsed_time("start readFile()");
    fs.readFile(''output.txt'', send_html);
    if(debug) elapsed_time("end readFile()");

}).listen(8080);

Aquí hay una prueba rápida que puede ejecutar en un terminal (shell BASH):

for i in {1..100}; do echo $i; curl http://localhost:8080/; done

Answer 3

Podrías darle una oportunidad a Benchmark.js . Soporta muchas plataformas entre ellas también node.js.

Answer 4

Pregunta antigua, pero para una API simple y una solución liviana; puede usar perfy que usa tiempo real de alta resolución ( process.hrtime ) internamente.

var perfy = require(''perfy'');

function end(label) {
    return function (err, saved) {
        console.log(err ? ''Error'' : ''Saved''); 
        console.log( perfy.end(label).time ); // <——— result: seconds.milliseconds
    };
}

for (var i = 1; i < LIMIT; i++) {
    var label = ''db-save-'' + i;
    perfy.start(label); // <——— start and mark time
    db.users.save({ id: i, name: ''MongoUser ['' + i + '']'' }, end(label));
}

Tenga en cuenta que cada vez que se perfy.end(label) , esa instancia se destruye automáticamente.

Revelación: Escribió este módulo, inspirado en la respuesta de D.Deriso . Docs perfy

Answer 5

Recomendaría probar NodeTime que parece ser una buena NodeTime para lo que estás tratando de hacer.

Answer 6

Sorprendido nadie ha mencionado aún las nuevas bibliotecas integradas:

Disponible en Nodo> = 8.5, y debería estar en Modern Browers

https://developer.mozilla.org/en-US/docs/Web/API/Performance

https://nodejs.org/docs/latest-v8.x/api/perf_hooks.html#

Nodo 8.5 ~ 9.x

const { performance } = require(''perf_hooks'');
const delay = time => new Promise(res=>setTimeout(res,time))
async function doSomeLongRunningProcess(){
  await delay(1000);
}
performance.mark(''A'');
(async ()=>{
  await doSomeLongRunningProcess();
  performance.mark(''B'');
  performance.measure(''A to B'', ''A'', ''B'');
  const measure = performance.getEntriesByName(''A to B'')[0];
  console.log(measure.duration);
  // Prints the number of milliseconds between Mark ''A'' and Mark ''B''
})();

https://repl.it/repls/OptimalOvercookedBusinesses

Nodo 10.x

https://nodejs.org/docs/latest-v10.x/api/perf_hooks.html

const { PerformanceObserver, performance } = require(''perf_hooks'');
const delay = time => new Promise(res => setTimeout(res, time))
async function doSomeLongRunningProcess() {
    await delay(1000);
}
const obs = new PerformanceObserver((items) => {
    console.log(''PerformanceObserver A to B'',items.getEntries()[0].duration);
    performance.clearMarks();
});
obs.observe({ entryTypes: [''measure''] });

performance.mark(''A'');

(async function main(){
    try{
        await performance.timerify(doSomeLongRunningProcess)();
        performance.mark(''B'');
        performance.measure(''A to B'', ''A'', ''B'');
    }catch(e){
        console.log(''main() error'',e);
    }
})();

Answer 7

También exectimer probar exectimer . Te da retroalimentación como:

var t = require("exectimer");

var myFunction() {
   var tick = new t.tick("myFunction");
   tick.start();
   // do some processing and end this tick
   tick.stop();
}

// Display the results
console.log(t.timers.myFunction.duration()); // total duration of all ticks
console.log(t.timers.myFunction.min()); // minimal tick duration
console.log(t.timers.myFunction.max()); // maximal tick duration
console.log(t.timers.myFunction.mean()); // mean tick duration
console.log(t.timers.myFunction.median()); // median tick duration

[editar] Hay incluso una forma más sencilla de usar exectimer porque ahora puede ajustar el código que se va a medir. Su código podría envolverse así:

var t = require(''exectimer''),
Tick = t.Tick;

for(var i = 1; i < LIMIT; i++){
    Tick.wrap(function saveUsers(done) {
        db.users.save({id : i, name : "MongoUser [" + i + "]"}, function(err, saved) {
            if( err || !saved ) console.log("Error");
            else console.log("Saved");
            done();
        });
    });
}

// Display the results
console.log(t.timers.myFunction.duration()); // total duration of all ticks
console.log(t.timers.saveUsers.min()); // minimal tick duration
console.log(t.timers.saveUsers.max()); // maximal tick duration
console.log(t.timers.saveUsers.mean()); // mean tick duration
console.log(t.timers.saveUsers.median()); // median tick duration

Answer 8

Tuve el mismo problema al pasar de AWS a Azure

Para Express & aws, ya puede usar, time () y timeEnd () existentes

Para Azure, use esto: https://github.com/manoharreddyporeddy/my-nodejs-notes/blob/master/performance_timers_helper_nodejs_azure_aws.js

Estos time () y timeEnd () utilizan la función hrtime () existente, que proporciona tiempo real de alta resolución.

Espero que esto ayude.

Answer 9

Utilice Node.js console.time() y console.timeEnd() :

var i;
console.time("dbsave");

for(i = 1; i < LIMIT; i++){
    db.users.save({id : i, name : "MongoUser [" + i + "]"}, end);
}

end = function(err, saved) {
    console.log(( err || !saved )?"Error":"Saved");
    if(--i === 1){console.timeEnd("dbsave");}
};

Answer 10

Y otra opción es usar la herramienta de express-debug :

Express-debug es una herramienta de desarrollo para Express. Es un middleware simple que inyecta resultados de depuración útiles en su html, de una manera no obstructiva.

Convenientemente ofrece un panel de perfilado:

tiempo de procesamiento total requerido. Middleware, param, y tiempos de ruta.

También. para agregar a las respuestas anteriores, puede verificar esta respuesta para habilitar cualquier código de perfil solo para el entorno de desarrollo.

Answer 11

Para cualquier persona que desee obtener el valor del tiempo transcurrido en lugar de la salida de la consola:

use process.hrtime() como sugerencia de @ D.Deriso, a continuación se encuentra mi enfoque más simple:

function functionWantToMeasure() {
    var startTime = process.hrtime();
    //do some task...
    var elapsedSeconds = parseHrtimeToSeconds(process.hrtime(startTime));
    console.log(''functionWantToMeasure takes '' + elapsedSeconds + ''seconds'');
}

function parseHrtimeToSeconds(hrtime) {
    var seconds = (hrtime[0] + (hrtime[1] / 1e9)).toFixed(3);
    return seconds;
}

Answer 12

var start = +new Date();
var counter = 0;
for(var i = 1; i < LIMIT; i++){
    ++counter;
    db.users.save({id : i, name : "MongoUser [" + i + "]"}, function(err, saved) {
          if( err || !saved ) console.log("Error");
          else console.log("Saved");
          if (--counter === 0) 
          {
              var end = +new Date();
              console.log("all users saved in " + (end-start) + " milliseconds");
          }
    });
}