How to use the pidusage.stat function in pidusage

this.getStatus = function(request,callback) {
        pusage.stat(process.pid, function(err, stat) {
            if (err) {
                callback(err);
            } else {
                if (stat.memory === undefined) {
                    callback('Memory status not found!');
                } else {
                    let memoryUsed = round( (stat.memory / 1024) / 1024 );
                    let memoryTotal = round( (os.totalmem() / 1024) / 1024 );

                    /* Unmonitor process */
                    pusage.unmonitor(process.pid);

                    callback(undefined,[
                        [memoryUsed],
                        [memoryTotal]
                    ]);

function runTimer () {
      pidusage.stat(pid, function (err, stat) {
        if (err) {
          clearInterval(self._usages[pidStr])
          delete self._usages[pidStr]
          return emitError.call(self, err, pid)
        }
        stat.memory = stat.memory * 100 / totalmem

        var data = {
          pid: pid,
          time: Date.now(),
          usage: stat
        }
        self._broadcast.call(self, 'proc', data, conf.NSP.PROC) // eslint-disable-line no-useless-call
      })
    }

return new Promise(function(resolve, reject) {
    pusage.stat(process.pid, function(err, stat) {
      if (err) {
        console.log('[Error]');
        console.log(err);
        console.log('*** If you got an error on Windows, you may try succeed if you execute this benchmark several times.');
        process.exit(0);
      }

      cpuLoads[type].push(stat.cpu);
      resolve();
    });
  });
}

const interval = setInterval(function() {
	testCount += 1;

	pidusage.stat(process.pid, function(err, result) {
		totalCpu += result.cpu;

		if (testCount == 10) {
			let avgDelta = totalDelta / testRuns;
			let targetDelta =
			console.log(`Test runs: ${testRuns}`);
			console.log(`target delta : ${intervalMs/1000}s`);
			console.log(`average delta: ${avgDelta}s`);
			console.log(`average cpu over ${testCount} seconds: ${totalCpu / testCount}%`);

			gameloop.clearGameLoop(loop);
			clearInterval(interval);
		}
	});
}, 1000);

function checkCPU() {
        pidusage.stat(process.pid, function(err, pidStats) {
          if (err) {
            debug(err);
            return;
          }

          if (pidStats && pidStats.cpu && pidStats.cpu >= MELTING_POINT) {
            mpe++;
          }

          if (mpe * CPU_CHECK_INTERVAL_MS >= CPU_HOT_BEFORE_WARN) {
            self.events.emit('highcpu', [process.pid]);
            mpe = 0;
          }
        });
      },
      CPU_CHECK_INTERVAL_MS).unref();

checkJediMemoryFootprint() {
        if (!this.proc || this.proc.killed) {
            return;
        }
        pidusage.stat(this.proc.pid, (err, result) => __awaiter(this, void 0, void 0, function* () {
            if (err) {
                return console.error('Python Extension: (pidusage)', err);
            }
            const limit = Math.min(Math.max(this.pythonSettings.jediMemoryLimit, 1024), 8192);
            if (result && result.memory > limit * 1024 * 1024) {
                this.logger.logWarning(`IntelliSense process memory consumption exceeded limit of ${limit} MB and process will be restarted.\nThe limit is controlled by the 'python.jediMemoryLimit' setting.`);
                yield this.restartLanguageServer();
            }
        }));
    }
    pythonSettingsChangeHandler() {

App.trackCPU = function () {
    var pid;

    if (settings.lightWallet == 1) {
      pid = rendererPid;
    } else if (server && server.pid) {
      pid = server.pid;
    }

    if (pid) {
      pusage.stat(pid, function (err, stat) {
        if (err) {
          App.updateStatusBar({ "cpu": "" });
        } else {
          App.updateStatusBar({ "cpu": Math.round(stat.cpu).toFixed(2) });
        }
      });

      pusage.unmonitor(pid);
    } else {
      console.log("Track CPU: No server PID");
      if (cpuTrackInterval) {
        console.log("Clear the interval");
        clearInterval(cpuTrackInterval);
      }
    }
  }

return new Promise(resolve => {
      pusage.stat(process.pid, function(err, stat) {
        resolve({
          cpu: stat.cpu,
          memory: 1 - stat.memory / os.totalmem()
        });
      });
    });
  }

return new Promise( ( resolve, reject ) => {
            pidusage.stat( process.pid, ( err, stat ) => {
                if ( err ) {
                    return reject( err );
                }

                resolve( {
                    own: pid == process.pid,
                    pid: pid,
                    cpu: stat.cpu,
                    memory: stat.memory
                } );
            } );
        } );
    }