How to use the @mojaloop/central-services-logger.debug function in @mojaloop/central-services-logger

const handler = {
        type: 'bulkprepare',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.bulkfulfil) {
      Logger.debug('CLI: Executing --bulkfulfil')
      const handler = {
        type: 'bulkfulfil',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.bulkprocessing) {
      Logger.debug('CLI: Executing --bulkprocessing')
      const handler = {
        type: 'bulkprocessing',
        enabled: true
      }
      handlerList.push(handler)
    }

    module.exports = Setup.initialize({
      service: 'handler',
      port: Config.PORT,
      modules: [Plugin, MetricPlugin],
      runMigrations: false,
      handlers: handlerList,
      runHandlers: true
    })
    // } else {

const toTransfer = (t) => {
  // TODO: Validate 't' to confirm if its from the DB transferReadModel or from the saveTransferPrepare
  if (t.isTransferReadModel) {
    Logger.debug('In aggregate transfer transform for isTransferReadModel')
    return Util.omitNil(fromTransferReadModel(t)) // TODO: Remove this once the DB validation is done for 't'
  } else if (t.isSaveTransferPrepared) {
    Logger.debug('In aggregate transfer transform for isSaveTransferPrepared')
    return Util.omitNil(fromSaveTransferPrepared(t)) // TODO: Remove this once the DB validation is done for 't'
  } else if (t.savePayeeTransferResponseExecuted) {
    Logger.debug('In aggregate transfer transform for isSavePayeeTransferResponseExecuted')
    return Util.omitNil(fromSavePayeeTransferResponseExecuted(t)) // TODO: Remove this once the DB validation is done for 't'
  } else throw ErrorHandler.Factory.createFSPIOPError(ErrorHandler.Enums.FSPIOPErrorCodes.INTERNAL_SERVER_ERROR, `Unable to transform to transfer: ${t}`)
}

const create = async (stateChange) => {
  Logger.debug('save bulkTransferStateChange' + stateChange.toString())
  try {
    return await Db.bulkTransferStateChange.insert(stateChange)
  } catch (err) {
    Logger.error(err)
    throw err
  }
}

const handler = {
        type: 'get',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.fulfil) {
      Logger.debug('CLI: Executing --fulfil')
      const handler = {
        type: 'fulfil',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.timeout) {
      Logger.debug('CLI: Executing --timeout')
      const handler = {
        type: 'timeout',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.admin) {
      Logger.debug('CLI: Executing --admin')
      const handler = {
        type: 'admin',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.bulkprepare) {
      Logger.debug('CLI: Executing --bulkprepare')

const saveTransferFulfilment = async (record) => {
  Logger.debug('save transferFulfilment ' + record.toString())
  try {
    return await Db.transferFulfilment.insert(record)
  } catch (err) {
    Logger.error(err)
    throw ErrorHandler.Factory.reformatFSPIOPError(err)
  }
}

connect () {
    Logger.debug('Sidecar disabled: connecting in NullClient')
    return Promise.resolve(this)
  }

.action(async (args) => {
    const handlerList = []
    if (args.prepare) {
      Logger.debug('CLI: Executing --prepare')
      const handler = {
        type: 'prepare',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.position) {
      Logger.debug('CLI: Executing --position')
      const handler = {
        type: 'position',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.get) {
      Logger.debug('CLI: Executing --get')
      const handler = {
        type: 'get',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.fulfil) {
      Logger.debug('CLI: Executing --fulfil')

const saveTransferStateChange = async (stateChange) => {
  Logger.debug('save transferStateChange' + stateChange.toString())
  try {
    return Db.transferStateChange.insert(stateChange)
  } catch (err) {
    Logger.error(err)
    throw err
  }
}

.action(async (args) => {
    const handlerList = []
    if (args.prepare) {
      Logger.debug('CLI: Executing --prepare')
      const handler = {
        type: 'prepare',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.position) {
      Logger.debug('CLI: Executing --position')
      const handler = {
        type: 'position',
        enabled: true
      }
      handlerList.push(handler)
    }
    if (args.get) {
      Logger.debug('CLI: Executing --get')

}
        if (isFulfilment) {
          await knex('transferFulfilment').transacting(trx).insert(transferFulfilmentRecord)
          result.transferFulfilmentRecord = transferFulfilmentRecord
          Logger.debug('savePayeeTransferResponse::transferFulfilment')
        }
        if (transferExtensionRecordsList.length > 0) {
          for (const transferExtension of transferExtensionRecordsList) {
            await knex('transferExtension').transacting(trx).insert(transferExtension)
          }
          result.transferExtensionRecordsList = transferExtensionRecordsList
          Logger.debug('savePayeeTransferResponse::transferExtensionRecordsList')
        }
        await knex('transferStateChange').transacting(trx).insert(transferStateChangeRecord)
        result.transferStateChangeRecord = transferStateChangeRecord
        Logger.debug('savePayeeTransferResponse::transferStateChange')
        if (fspiopError) {
          const insertedTransferStateChange = await knex('transferStateChange').transacting(trx)
            .where({ transferId })
            .forUpdate().first().orderBy('transferStateChangeId', 'desc')
          transferStateChangeRecord.transferStateChangeId = insertedTransferStateChange.transferStateChangeId
          transferErrorRecord.transferStateChangeId = insertedTransferStateChange.transferStateChangeId
          await knex('transferError').transacting(trx).insert(transferErrorRecord)
          result.transferErrorRecord = transferErrorRecord
          Logger.debug('savePayeeTransferResponse::transferError')
        }
        await trx.commit
        result.savePayeeTransferResponseExecuted = true
        Logger.debug('savePayeeTransferResponse::success')
      } catch (err) {
        await trx.rollback
        Logger.error('savePayeeTransferResponse::failure')