콜백을 사용하여 JavaScript 코드의 실행 시간을 어떻게 측정합니까?

node.js인터프리터를 사용하여 실행하는 JavaScript 코드가 있습니다.

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

이러한 데이터베이스 삽입 작업에 걸리는 시간을 어떻게 측정 할 수 있습니까? 이 코드 조각 전후에 날짜 값의 차이를 계산할 수 있지만 코드의 비동기 특성으로 인해 올바르지 않습니다.

Node.js를 사용 console.time()및 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");}
};

이를 위해 설계된 방법이 있습니다. process.hrtime ()을 확인하십시오 . .

그래서 나는 기본적으로 이것을 내 앱의 맨 위에 놓았습니다.

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
}

그런 다음 함수를 사용하는 데 시간이 얼마나 걸리는지 확인합니다. 다음은 "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);

다음은 터미널 (BASH 셸)에서 실행할 수있는 빠른 테스트입니다.

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

호출하면 console.time('label')현재 시간이 밀리 초로 기록되고 나중에 호출 console.timeEnd('label')하면 해당 시점부터 지속 시간이 표시됩니다.

레이블과 함께 밀리 초 단위의 시간이 자동으로 인쇄되므로 레이블을 인쇄하기 위해 console.log를 별도로 호출 할 필요가 없습니다.

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

자세한 내용은에 대한 Mozilla 개발자 문서를console.time 참조하십시오 .

아직 새로운 내장 라이브러리를 언급 한 사람이 아무도 없습니다.

Node> = 8.5에서 사용 가능하며 Modern Browers에 있어야합니다.

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

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

노드 8.5 ~ 9.x (Firefox, Chrome)

// const { performance } = require('perf_hooks'); // enable for node
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];
  // firefox appears to only show second precision.
  console.log(measure.duration);
  performance.clearMeasures(); // apparently you should remove entries...
  // Prints the number of milliseconds between Mark 'A' and Mark 'B'
})();

https://repl.it/@CodyGeisler/NodeJsPerformanceHooks

노드 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);
    }
})();

누구나 콘솔 출력 대신 시간 경과 값을 얻으려고합니다.

@ D.Deriso 제안으로 process.hrtime () 을 사용하십시오 . 아래는 더 간단한 접근법입니다.

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

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

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");
          }
    });
}

오래된 API이지만 간단한 API 및 경량 솔루션입니다. 내부에서 고해상도 실시간 ( ) 을 사용 하는 perfy 를 사용할 수 있습니다 process.hrtime.

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));
}

perfy.end(label)호출 될 때마다 해당 인스턴스가 자동으로 파괴됩니다.

공개 : D.Deriso의 답변 에서 영감을 얻은이 모듈을 작성했습니다 . 여기에 문서가 있습니다 .

당신은 줄 수 Benchmark.js을 시도합니다. node.js 중에서도 많은 플랫폼을 지원합니다.

exectimer 시도 할 수도 있습니다 . 다음과 같은 피드백을 제공합니다.

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

[편집] 이제 exectimer를 사용하는 간단한 방법이 있습니다. 이제 측정 할 코드를 감쌀 수 있기 때문입니다. 코드는 다음과 같이 감쌀 수 있습니다.

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

AWS에서 Azure로 이동하는 동안 동일한 문제가 발생했습니다.

Express & AWS의 경우 기존 time () 및 timeEnd ()를 이미 사용할 수 있습니다.

Azure의 경우 다음을 사용하십시오. https://github.com/manoharreddyporeddy/my-nodejs-notes/blob/master/performance_timers_helper_nodejs_azure_aws.js

이러한 time () 및 timeEnd ()는 기존의 hrtime () 함수를 사용하여 고해상도 실시간을 제공합니다.

도움이 되었기를 바랍니다.

또 다른 옵션은 express-debug 도구 를 사용하는 것입니다 .

express-debug는 express를위한 개발 도구입니다. 유용한 디버깅 출력을 방해받지 않는 방식으로 HTML에 삽입하는 간단한 미들웨어입니다.

편리하게 프로파일 링 패널을 제공합니다.

총 요청 처리 시간. 미들웨어, 매개 변수 및 경로 타이밍.

또한. 위의 답변에 추가하려면 이 답변 을 확인 하여 개발 환경에서만 프로파일 링 코드를 활성화 할 수 있습니다 .