JavaScript promise resolve duration

Question

what is the correct way to calculate the duration of a promise?

const startTm = Date.now();
p1(params).then(
    (o)=> {
        Log.debug(startTm);
        Log.debug(JSON.stringify(o));
        return o;
    });
const runTm = Date.now() - startTm;

The startTm is invisible inside then().

UPDATE:

my bad. startTm is visible. So is there any other ways?

 const startTm = Date.now();

 p1(params).then((o)=> {
    output = o
    console.log(startTm);
    Log.debug(JSON.stringify(o));
    let runTm = Date.now() - startTm;
    Log.debug('duration: ' + runTm + 'ms');
    return o;
});

"The startTm is invisible inside then()." — [No, it isn't](https://jsbin.com/wazavoteve/1/edit?js,console) — Quentin, May 06 '19 at 20:34
after then the promise has been resolved so you should log the start time before and in the then it's the end of your promise — Aziz.G, May 06 '19 at 20:35
You'll want to do the calculation of `runTm` inside the `then` handler, btw. — Bergi, May 06 '19 at 20:38
There is a nice answer here, using performance.now() https://stackoverflow.com/questions/313893/how-to-measure-time-taken-by-a-function-to-execute — Esger, May 06 '19 at 20:43
Just for completion, there's a library for this: https://github.com/sindresorhus/p-time . Take a look at the source code. It's quite simple how he does it. — NickHTTPS, May 06 '19 at 20:54

Timofey Goncharov · Answer 1 · 2019-05-06T20:57:17.600

3

All what you need:

const p1 = () => new Promise((resolve) => setTimeout(() => { resolve() }, 2000))

const test = async () => {
  const startTm = Date.now();
  const result = await p1();
  const runTm = Date.now() - startTm;
  console.log(runTm);
}

test();

In const 'result' you get result promise as you get it in 'then' callback.

Without async/awaut:

const startTm = Date.now();
p1(params).then((result)=> {
  Log.debug(startTm);
  Log.debug(JSON.stringify(result));
  const runTm = Date.now() - startTm; // only available here
  return o;
});

edited May 06 '19 at 20:57

answered May 06 '19 at 20:35

Timofey Goncharov

1,023
1
6
14

Please [edit] your answer to include how that works differently from the code in the OP. – Bergi May 06 '19 at 20:38
Also it does not do anything. (the first one) – Jonas Wilms May 06 '19 at 20:49
@JonasWilms I expanded my example. – Timofey Goncharov May 06 '19 at 20:56

score 3 · Accepted Answer · answered May 06 '19 at 20:38

You need to ensure that the duration calculation happens after all prior promises are resolved, which in your case would mean calculating runTm after your Log.debug() statements, or creating a new then() block like so:

/* Mocking p1 to demonstrate technique */
function p1() {
  return new Promise(r => setTimeout(() => r('I took 2 seconds to resolve'), 2000));
}
/* Mock params data */
const params = {};

/* Record start time */
const startTm = Date.now();

p1(params).then((o) => {
    console.log(startTm);
    console.log(JSON.stringify(o));
    return o;
})
.then((o) => {

    /* Calculate duration and log it */
    const runTm = Date.now() - startTm;
    console.log(`Duration was: ${runTm}ms`);

    /* Pass result "o" through */
    return o;
})

score 0 · Answer 3 · answered May 06 '19 at 20:43

let p1 = new Promise(function(resolve, reject){
  setTimeout(function(){    
    resolve('pass');
  }, 3000);
});

let runTm;
const startTm = Date.now();

p1.then(
    (o)=> {          
        runTm = Date.now() - startTm;
        console.log(runTm)
        return o;
});

JavaScript promise resolve duration

3 Answers3