How to use the pino.levels function in pino

function statTokens(tokens, group) {
    // Do nothing if loglevel is higher than info
    if (log.levelVal > pino.levels.values.info) {
        return;
    }

    setInterval(() => {
        const tokensUsage = Object.values(tokenDealer.getTokensUsage(tokens, { group }));
        const usableTokensUsage = tokensUsage.filter((entry) => !entry.exhausted);

        if (usableTokensUsage.length) {
            log.info(`${usableTokensUsage.length} out of ${tokensUsage.length} tokens are usable (${group})`);

            return;
        }
        if (tokensUsage.length < 1) {
            log.info(`No tokens (${group})`);

            return;

module.exports = (env) => {
  assert(typeof env === 'object', 'config.js requires a process.env argument')

  const { get } = from(env)

  return {
    HTTP_PORT: get('HTTP_PORT', 8080).asPortNumber(),

    NODE_ENV: get('NODE_ENV').asString(),

    LOG_LEVEL: get('LOG_LEVEL', 'info').asEnum(Object.values(pino.levels.labels)),

    // Can be set to valid keycloak config for a "public" client
    KEYCLOAK_CONFIG: get('KEYCLOAK_CONFIG').asJsonObject(),

    // If keycloak is configured we also need a session secret.
    // This will default to a random hex string if not set
    SESSION_SECRET: get('SESSION_SECRET', randomSessionSecret).asString(),

    // Ordering HTTP API base url, e.g http://orders.svc.local:8080/
    ORDERS_REST_BASE_URL: get('ORDERS_REST_BASE_URL').asUrlString(),

    // Ordering HTTP API base url, e.g http://orders.svc.local:8080/
    ORDERS_EVENT_BASE_URL: get('ORDERS_EVENT_BASE_URL').asUrlString()
  }
}

function statProgress(npmNano, npmsNano) {
    // Do nothing if loglevel is higher than info
    if (log.levelVal > pino.levels.values.info) {
        return;
    }

    let pending = false;

    setInterval(() => {
        if (pending) {
            log.info('Progress stat is still being retrieved..');

            return;
        }

        pending = true;

        Promise.props({
            npmDocsCount: npmNano.infoAsync().then((res) => res.doc_count),

function statQueue(queue) {
    // Do nothing if loglevel is higher than info
    if (log.levelVal > pino.levels.values.info) {
        return;
    }

    let pending = false;

    setInterval(() => {
        if (pending) {
            log.info('Queue stat is still being retrieved..');

            return;
        }

        pending = true;

        queue.stat()
        .finally(() => { pending = false; })

var lugg = require('..'),
    debug = require('../lib/debug-env.js'),
    assert = require('assert'),
    pino = require('pino'),
    hasChinding = require('./helper').hasChinding,
    sink = require('./helper').sink,
    once = require('./helper').once;

var levels = pino.levels.values;
describe('lugg.init()', function() {
  it('with no options', function() {
    var stream = sink();
    lugg.init(stream);
    lugg().info('hello world');
    return once(stream, 'data').then(function (log) {
      assert.equal(log.name, 'app');
    });
  });
  it('with options', function() {
    var stream = sink();
    lugg.init({
      name: 'theName',
      stream: process.stderr
    }, stream);
    lugg().info('hello world');

write(log: Pino.LogDescriptor) {
		if (!core.json.is(log)) {
			return console.error('log not parsable ->', log)
		}
		log = JSON.parse(log as any)
		log.label = Pino.levels.labels[log.level]

		if (DEVELOPMENT) {
			if (log.req) reqs[log.reqId] = log.req;
			else if (reqs[log.reqId]) {
				log.req = reqs[log.reqId]
				recycle(log.reqId)
			}
		}

		let message = _.omit(log, ['level', 'time', 'pid', 'hostname', 'v', 'label', 'reqId', 'responseTime'])
		if (message.req) message.req = _.omit(message.req, ['id', 'remoteAddress', 'remotePort']) as any;

		if (log.err && log.err.stack) {
			if (log.err.isGot) {
				return console.error('ERROR ->', _.omit(message, ['err.stack']))
			}

function buildFilter (filter) {
  if (typeof filter === 'string') {
    const num = pino.levels.values[filter]

    if (typeof num === 'number' && isFinite(num)) {
      filter = function (v) { return v.level >= num }
    } else {
      throw new Error('no such level')
    }
  }

  return split(function (line) {
    const res = new Parse(line)
    if (res.value && filter(res.value)) {
      return JSON.stringify(res.value) + '\n'
    } else {
      return undefined
    }
  })

switch (label) {
    case 'ERROR':
    case 'STACK':
    case 'DATA':
    case 'FATAL':
      return chalk.red(`[${label}]`);
    case 'WARN':
      return chalk.yellow(`[${label}]`);
    case 'INFO':
      return chalk.blue(`[${label}]`);
    default:
      return chalk.green(`[${label}]`);
  }
}

const LEVELS = new Map(Object.keys(pino.levels.values)
  .map((key) => [pino.levels.values[key], key.toUpperCase()]));

const prettyOptions = {
  crlf: EOL === '\r\n',
  forceColor: true,
  formatter(obj) {
    const level = LEVELS.get(obj.level);
    let timestamp = '';
    if (obj.showTime) {
      timestamp = `[${new Date(obj.time).toISOString()}] `;
    }
    if (level === 'ERROR') {
      let data;
      if (obj.data !== undefined) {
        data = JSON.stringify(obj.data, null, 2).replace(/\n/g, EOL);
      }

assign('level', (data, colors, field) => {
  if (field === 'code') {
    return colors.level(data.level)
  }

  return colors.level(pino.levels.labels[data.level])
})

  .map((key) => [pino.levels.values[key], key.toUpperCase()]));