How to use the bunyan.WARN function in bunyan

}
    else if (typeof rec === 'object') {
      const formattedMsg = this._formatter(rec);
      if (typeof formattedMsg === 'string' || formattedMsg instanceof String) {
        msg = formattedMsg;
      }
      else {
        console.error('Unable to format message %j', rec);
        return;
      }

      const logLevel = rec.level;
      if (logLevel <= bunyan.INFO) {
        console.info(msg);
      }
      else if (logLevel <= bunyan.WARN) {
        console.warn(msg);
      }
      else { // logLevel === bunyan.ERROR || bunyan.FATAL
        console.error(msg);
      }
    }
  }
};

Bunyan2Winston.prototype.write = function write(rec) {
    // Map to the appropriate Winston log level (by default 'info', 'warn'
    // or 'error') and call signature: `wlog.log(level, msg, metadata)`.
    var wlevel;
    if (rec.level <= bunyan.INFO) {
        wlevel = 'info';
    } else if (rec.level <= bunyan.WARN) {
        wlevel = 'warn';
    } else {
        wlevel = 'error';
    }

    // Note: We are *modifying* the log record here. This could be a problem
    // if our Bunyan logger had other streams. This one doesn't.
    var msg = rec.msg;
    delete rec.msg;

    // Remove internal bunyan fields that won't mean anything outside of
    // a bunyan context.
    delete rec.v;
    delete rec.level;
    // TODO: more?

Bunyan2Winston.prototype.write = function write(rec) {
  // Map to the appropriate Winston log level (by default 'info', 'warn'
  // or 'error') and call signature: `wlog.log(level, msg, metadata)`.
  var wlevel;
  if (rec.level <= bunyan.INFO) {
    wlevel = "info";
  } else if (rec.level <= bunyan.WARN) {
    wlevel = "warn";
  } else {
    wlevel = "error";
  }

  // Note: We are *modifying* the log record here. This could be a problem
  // if our Bunyan logger had other streams. This one doesn't.
  var msg = rec.msg;
  delete rec.msg;

  // Remove internal bunyan fields that won't mean anything outside of
  // a bunyan context.
  delete rec.v;
  delete rec.level;
  // TODO: more?

it('warns if time() is called twice for the same label', async () => {
      app.use(koaBunyanLogger(ringLogger));
      app.use(koaBunyanLogger.timeContext());

      app.use(ctx => {
        ctx.time('x');
        ctx.time('x');
        ctx.body = '';
      });

      await request().get('/').expect(200);
      assert.equal(ringBuffer.records[0].level, bunyan.WARN);
      assert.ok(ringBuffer.records[0].msg.match(/called for previously/));
    });

expect(outputCapture.get().level).to.equal(bunyan.TRACE);

    reset();
    rosnodejs.log.debugThrottle(1, message);
    expect(outputCapture.get().msg).to.have.string(message);
    expect(outputCapture.get().level).to.equal(bunyan.DEBUG);

    reset();
    rosnodejs.log.infoThrottle(1, message);
    expect(outputCapture.get().msg).to.have.string(message);
    expect(outputCapture.get().level).to.equal(bunyan.INFO);

    reset();
    rosnodejs.log.warnThrottle(1, message);
    expect(outputCapture.get().msg).to.have.string(message);
    expect(outputCapture.get().level).to.equal(bunyan.WARN);

    reset();
    rosnodejs.log.errorThrottle(1, message);
    expect(outputCapture.get().msg).to.have.string(message);
    expect(outputCapture.get().level).to.equal(bunyan.ERROR);

    reset();
    rosnodejs.log.fatalThrottle(1, message);
    expect(outputCapture.get().msg).to.have.string(message);
    expect(outputCapture.get().level).to.equal(bunyan.FATAL);
  });

protected toTheiaLevel(bunyanLogLevel: number | string): number {
        switch (Number(bunyanLogLevel)) {
            case bunyan.FATAL:
                return LogLevel.FATAL;
            case bunyan.ERROR:
                return LogLevel.ERROR;
            case bunyan.WARN:
                return LogLevel.WARN;
            case bunyan.INFO:
                return LogLevel.INFO;
            case bunyan.DEBUG:
                return LogLevel.DEBUG;
            case bunyan.TRACE:
                return LogLevel.TRACE;
            default:
                return LogLevel.INFO;
        }
    }

BunyanPrettyPrinter.prototype._transform = function (chunk, _, callback)
{
	var component = chunk.component || chunk.name;
	var message = chunk.msg;
	var stream = this;
	var level;

	switch (chunk.level) {
	case mod_bunyan.TRACE:		level = 'TRACE'; break;
	case mod_bunyan.DEBUG:		level = 'DEBUG'; break;
	case mod_bunyan.INFO:		level = 'INFO';  break;
	case mod_bunyan.WARN:		level = 'WARN';  break;
	case mod_bunyan.ERROR:		level = 'ERROR'; break;
	case mod_bunyan.FATAL:		level = 'FATAL'; break;
	default:			level = '?????'; break;
	}

	this.push(sprintf('[%5s] %s: %s\n', level, component, message));

	mod_jsprim.forEachKey(chunk, function (key, value) {
		if (bunyanStdKeys.hasOwnProperty(key))
			return;
		stream.push(sprintf('  %10s: %j\n', key, value));
	});

	callback();
};

protected toBunyanLevel(logLevel: number): number {
        switch (logLevel) {
            case LogLevel.FATAL:
                return bunyan.FATAL;
            case LogLevel.ERROR:
                return bunyan.ERROR;
            case LogLevel.WARN:
                return bunyan.WARN;
            case LogLevel.INFO:
                return bunyan.INFO;
            case LogLevel.DEBUG:
                return bunyan.DEBUG;
            case LogLevel.TRACE:
                return bunyan.TRACE;
            default:
                return bunyan.INFO;
        }
    }

private mapLevelToString(level: any): any {
    let response: string;
    switch (level) {
      case bunyan.TRACE: {
        response = "Trace";
        break;
      }
      case bunyan.DEBUG: {
        response = "Debug";
        break;
      }
      case bunyan.INFO: {
        response = "Information";
        break;
      }
      case bunyan.WARN: {
        response = "Warning";
        break;
      }
      case bunyan.ERROR: {
        response = "Error";
        break;
      }
      case bunyan.FATAL: {
        response = "Fatal";
        break;
      }
      default: {
        response = "Information";
      }
    }
    return response;