How to use npmlog - 10 common examples

const npmBin = execSync('npm bin', {encoding: 'utf8'}).trimRight();
  logger.info('TestRunnerCli.Run', `(3/5) Retrieving npm bin folder... DONE, folder: ${npmBin}`);

  if (args.env === 'node') {
    // STEP 4. use tsc to build ONNX.js
    logger.info('TestRunnerCli.Run', '(4/5) Running tsc...');
    const tscCommand = path.join(npmBin, 'tsc');
    const tsc = spawnSync(tscCommand, {shell: true, stdio: 'inherit'});
    if (tsc.status !== 0) {
      console.error(tsc.error);
      process.exit(tsc.status);
    }
    logger.info('TestRunnerCli.Run', '(4/5) Running tsc... DONE');

    // STEP 5. run mocha
    logger.info('TestRunnerCli.Run', '(5/5) Running mocha...');
    const mochaCommand = path.join(npmBin, 'mocha');
    const mochaArgs = [path.join(TEST_ROOT, 'test-main'), '--timeout 60000'];
    logger.info('TestRunnerCli.Run', `CMD: ${mochaCommand} ${mochaArgs.join(' ')}`);
    const mocha = spawnSync(mochaCommand, mochaArgs, {shell: true, stdio: 'inherit'});
    if (mocha.status !== 0) {
      console.error(mocha.error);
      process.exit(mocha.status);
    }
    logger.info('TestRunnerCli.Run', '(5/5) Running mocha... DONE');

  } else {
    // STEP 4. use webpack to generate ONNX.js
    logger.info('TestRunnerCli.Run', '(4/5) Running webpack to generate ONNX.js...');
    const webpackCommand = path.join(npmBin, 'webpack');
    const webpackArgs = [`--bundle-mode=${args.bundleMode}`];
    logger.info('TestRunnerCli.Run', `CMD: ${webpackCommand} ${webpackArgs.join(' ')}`);

function loggingOutput(minLevel = "info") {
  // returns an array of log messages at or above the prescribed minLevel
  return (
    log.record
      // select all non-empty info, warn, or error logs
      .filter(m => log.levels[m.level] >= log.levels[minLevel] && m.message)
      // return just the normalized message content
      .map(m =>
        normalizeNewline(m.message)
          .split("\n")
          .map(line => line.trimRight())
          .join("\n")
      )
  );
}

// helpers
import callsBack from "./helpers/callsBack";
import initFixture from "./helpers/initFixture";
import normalizeRelativeDir from "./helpers/normalizeRelativeDir";
import yargsRunner from "./helpers/yargsRunner";

// file under test
import * as commandModule from "../src/commands/RunCommand";

const run = yargsRunner(commandModule);

jest.mock("../src/NpmUtilities");
jest.mock("../src/utils/output");

// silence logs
log.level = "silent";

const ranInPackages = testDir =>
  NpmUtilities.runScriptInDir.mock.calls.reduce((arr, [script, cfg]) => {
    const { args, directory } = cfg;
    const dir = normalizeRelativeDir(testDir, directory);
    arr.push([dir, script].concat(args).join(" "));
    return arr;
  }, []);

const ranInPackagesStreaming = testDir =>
  NpmUtilities.runScriptInPackageStreaming.mock.calls.reduce((arr, [script, cfg]) => {
    const { args, pkg } = cfg;
    const dir = normalizeRelativeDir(testDir, pkg.location);
    arr.push([dir, script].concat(args).join(" "));
    return arr;
  }, []);

function errorHandler (er) {
  log.disableProgress()
  if (!npm.config || !npm.config.loaded) {
    // logging won't work unless we pretend that it's ready
    er = er || new Error('Exit prior to config file resolving.')
    console.error(er.stack || er.message)
  }

  if (cbCalled) {
    er = er || new Error('Callback called more than once.')
  }

  cbCalled = true
  if (!er) return exit(0)
  if (typeof er === 'string') {
    log.error('', er)
    return exit(1, true)
  } else if (!(er instanceof Error)) {

var req = null
    var requestOpts = {
        uri: url
      , headers: {
          'User-Agent': 'node-gyp v' + gyp.version + ' (node ' + process.version + ')'
        }
    }

    // basic support for a proxy server
    var proxyUrl = gyp.opts.proxy
                || process.env.http_proxy
                || process.env.HTTP_PROXY
                || process.env.npm_config_proxy
    if (proxyUrl) {
      if (/^https?:\/\//i.test(proxyUrl)) {
        log.verbose('download', 'using proxy url: "%s"', proxyUrl)
        requestOpts.proxy = proxyUrl
      } else {
        log.warn('download', 'ignoring invalid "proxy" config setting: "%s"', proxyUrl)
      }
    }
    try {
      // The "request" constructor can throw sometimes apparently :(
      // See: https://github.com/TooTallNate/node-gyp/issues/114
      req = request(requestOpts)
    } catch (e) {
      cb(e)
    }
    if (req) {
      req.on('response', function (res) {
        log.http(res.statusCode, url)
      })

return function resolver (what, cb) {
    if (!alreadyInstalledManually) return setTimeout(function () {
      resolver(what, cb)
    }, to++)

    // now we know what's been installed here manually,
    // or tampered with in some way that npm doesn't want to overwrite.
    if (alreadyInstalledManually.indexOf(what.split("@").shift()) !== -1) {
      log.verbose("already installed", "skipping %s %s", what, where)
      return cb(null, [])
    }

    // check for a version installed higher in the tree.
    // If installing from a shrinkwrap, it must match exactly.
    if (context.family[what]) {
      if (wrap && wrap[what].version === context.family[what]) {
        log.verbose("shrinkwrap", "use existing", what)
        return cb(null, [])
      }
    }

    // if it's identical to its parent, then it's probably someone
    // doing `npm install foo` inside of the foo project.  Print
    // a warning, and skip it.
    if (parent && parent.name === what && !npm.config.get("force")) {

} else if (parsed.type === "git" && parsed.hosted && parsed.hosted.default === "shortcut") {
      // probably a shorthand subpath, e.g. "foo/bar"
      parsed.name = parsed.raw;
    }

    // Maybe it doesn't need an implicit 'conventional-changelog-' prefix?
    try {
      config = resolveConfigPromise(presetPackageName);

      cfgCache.set(changelogPreset, config);

      // early exit, yay
      return Promise.resolve(config);
    } catch (err) {
      log.verbose("getChangelogConfig", err.message);
      log.info("getChangelogConfig", "Auto-prefixing conventional-changelog preset %j", changelogPreset);

      // probably a deep shorthand subpath :P
      parsed.name = parsed.raw;
    }

    if (parsed.name.indexOf("conventional-changelog-") < 0) {
      // implicit 'conventional-changelog-' prefix
      const parts = parsed.name.split("/");
      const start = parsed.scope ? 1 : 0;

      //        foo =>        conventional-changelog-foo
      // @scope/foo => @scope/conventional-changelog-foo
      parts.splice(start, 1, `conventional-changelog-${parts[start]}`);

      // _technically_ supports 'foo/lib/bar.js', but that's gross
      presetPackageName = parts.join("/");

,"including the npm and node versions, at:"
                  ,"    "
                  ].join("\n"))
    printStack = false
    break
  }

  var os = require("os")
  // just a line break
  if (log.levels[log.level] <= log.levels.error) console.error("")
  log.error("System", os.type() + " " + os.release())
  log.error("command", process.argv
            .map(JSON.stringify).join(" "))
  log.error("cwd", process.cwd())
  log.error("node -v", process.version)
  log.error("npm -v", npm.version)

  ; [ "file"
    , "path"
    , "type"
    , "syscall"
    , "fstream_path"
    , "fstream_unc_path"
    , "fstream_type"
    , "fstream_class"
    , "fstream_finish_call"
    , "fstream_linkpath"
    , "code"
    , "errno"
    , "stack"
    , "fstream_stack"
    ].forEach(function (k) {

, headers: {
          'User-Agent': 'node-gyp v' + gyp.version + ' (node ' + process.version + ')'
        }
    }

    // basic support for a proxy server
    var proxyUrl = gyp.opts.proxy
                || process.env.http_proxy
                || process.env.HTTP_PROXY
                || process.env.npm_config_proxy
    if (proxyUrl) {
      if (/^https?:\/\//i.test(proxyUrl)) {
        log.verbose('download', 'using proxy url: "%s"', proxyUrl)
        requestOpts.proxy = proxyUrl
      } else {
        log.warn('download', 'ignoring invalid "proxy" config setting: "%s"', proxyUrl)
      }
    }
    try {
      // The "request" constructor can throw sometimes apparently :(
      // See: https://github.com/TooTallNate/node-gyp/issues/114
      req = request(requestOpts)
    } catch (e) {
      cb(e)
    }
    if (req) {
      req.on('response', function (res) {
        log.http(res.statusCode, url)
      })
    }
    return req
  }

if (!cbCalled) {
      log.error('', 'cb() never called!')
      console.error('')
      log.error('', 'This is an error with npm itself. Please report this error at:')
      log.error('', '    ')
      writeLogFile()
    }

    if (code) {
      log.verbose('code', code)
    }
  }
  if (npm.config.loaded && npm.config.get('timing') && !wroteLogFile) writeLogFile()
  if (wroteLogFile) {
    // just a line break
    if (log.levels[log.level] <= log.levels.error) console.error('')

    log.error(
      '',
      [
        'A complete log of this run can be found in:',
        '    ' + getLogFile()
      ].join('\n')
    )
    wroteLogFile = false
  }

  var doExit = npm.config.loaded && npm.config.get('_exit')
  if (doExit) {
    // actually exit.
    if (exitCode === 0 && !itWorked) {
      exitCode = 1