How to use the lighthouse-logger.time function in lighthouse-logger

static async beforePass(passContext, gathererResults) {
    const bpStatus = {msg: `Running beforePass methods`, id: `lh:gather:beforePass`};
    log.time(bpStatus, 'verbose');
    const blockedUrls = (passContext.passConfig.blockedUrlPatterns || [])
      .concat(passContext.settings.blockedUrlPatterns || []);

    // Set request blocking before any network activity
    // No "clearing" is done at the end of the pass since blockUrlPatterns([]) will unset all if
    // neccessary at the beginning of the next pass.
    await passContext.driver.blockUrlPatterns(blockedUrls);
    await passContext.driver.setExtraHTTPHeaders(passContext.settings.extraHeaders);

    for (const gathererDefn of passContext.passConfig.gatherers) {
      const gatherer = gathererDefn.instance;
      // Abuse the passContext to pass through gatherer options
      passContext.options = gathererDefn.options || {};
      const status = {
        msg: `Retrieving setup: ${gatherer.name}`,
        id: `lh:gather:beforePass:${gatherer.name}`,

async getBrowserVersion() {
    const status = {msg: 'Getting browser version', id: 'lh:gather:getVersion'};
    log.time(status, 'verbose');
    const version = await this.sendCommand('Browser.getVersion');
    const match = version.product.match(/\/(\d+)/); // eg 'Chrome/71.0.3577.0'
    const milestone = match ? parseInt(match[1]) : 0;
    log.timeEnd(status);
    return Object.assign(version, {milestone});
  }

async cleanBrowserCaches() {
    const status = {msg: 'Cleaning browser cache', id: 'lh:driver:cleanBrowserCaches'};
    log.time(status);

    // Wipe entire disk cache
    await this.sendCommand('Network.clearBrowserCache');
    // Toggle 'Disable Cache' to evict the memory cache
    await this.sendCommand('Network.setCacheDisabled', {cacheDisabled: true});
    await this.sendCommand('Network.setCacheDisabled', {cacheDisabled: false});

    log.timeEnd(status);
  }

static async pass(passContext, gathererResults) {
    const config = passContext.passConfig;
    const gatherers = config.gatherers;

    const pStatus = {msg: `Running pass methods`, id: `lh:gather:pass`};
    log.time(pStatus, 'verbose');

    for (const gathererDefn of gatherers) {
      const gatherer = gathererDefn.instance;
      // Abuse the passContext to pass through gatherer options
      passContext.options = gathererDefn.options || {};
      const status = {
        msg: `Gathering in-page: ${gatherer.name}`,
        id: `lh:gather:pass:${gatherer.name}`,
      };
      log.time(status);
      const artifactPromise = Promise.resolve().then(_ => gatherer.pass(passContext));

      const gathererResult = gathererResults[gatherer.name] || [];
      gathererResult.push(artifactPromise);
      gathererResults[gatherer.name] = gathererResult;
      await artifactPromise.catch(() => {});

async getBrowserVersion() {
    const status = {msg: 'Getting browser version', id: 'lh:gather:getVersion'};
    log.time(status, 'verbose');
    const version = await this.sendCommand('Browser.getVersion');
    const match = version.product.match(/\/(\d+)/); // eg 'Chrome/71.0.3577.0'
    const milestone = match ? parseInt(match[1]) : 0;
    log.timeEnd(status);
    return Object.assign(version, {milestone});
  }

static async afterPass(passContext, loadData, gathererResults) {
    const driver = passContext.driver;
    const config = passContext.passConfig;
    const gatherers = config.gatherers;

    const apStatus = {msg: `Running afterPass methods`, id: `lh:gather:afterPass`};
    log.time(apStatus, 'verbose');

    // Some gatherers scroll the page which can cause unexpected results for other gatherers.
    // We reset the scroll position in between each gatherer.
    const scrollPosition = await driver.getScrollPosition();

    for (const gathererDefn of gatherers) {
      const gatherer = gathererDefn.instance;
      const status = {
        msg: `Gathering: ${gatherer.name}`,
        id: `lh:gather:afterPass:${gatherer.name}`,
      };
      log.time(status);

      // Add gatherer options to the passContext.
      passContext.options = gathererDefn.options || {};
      const artifactPromise = Promise.resolve()

static requireAudits(audits, configDir) {
    const status = {msg: 'Requiring audits', id: 'lh:config:requireAudits'};
    log.time(status, 'verbose');
    const auditDefns = requireAudits(audits, configDir);
    log.timeEnd(status);
    return auditDefns;
  }

static async loadBlank(driver, url = constants.defaultPassConfig.blankPage) {
    const status = {msg: 'Resetting state with about:blank', id: 'lh:gather:loadBlank'};
    log.time(status);
    await driver.gotoURL(url, {waitForNavigated: true});
    log.timeEnd(status);
  }

static requireGatherers(passes, configDir) {
    if (!passes) {
      return null;
    }
    const status = {msg: 'Requiring gatherers', id: 'lh:config:requireGatherers'};
    log.time(status, 'verbose');

    const coreList = Runner.getGathererList();
    const fullPasses = passes.map(pass => {
      const gathererDefns = Config.expandGathererShorthand(pass.gatherers).map(gathererDefn => {
        if (gathererDefn.instance) {
          return {
            instance: gathererDefn.instance,
            implementation: gathererDefn.implementation,
            path: gathererDefn.path,
            options: gathererDefn.options || {},
          };
        } else if (gathererDefn.implementation) {
          const GathererClass = gathererDefn.implementation;
          return {
            instance: new GathererClass(),
            implementation: gathererDefn.implementation,

async connect() {
    const status = {msg: 'Connecting to browser', id: 'lh:init:connect'};
    log.time(status);
    await this._connection.connect();
    log.timeEnd(status);
  }