describe('with Winston', function(){
var winstonLogger = winston.createLogger({
level: 'debug',
format: winston.format.combine(
winston.format((info) => {
info.level = info.level.toUpperCase();
return info;
})(),
winston.format.json()
),
transports: [new winston.transports.Console()]
});
dbWinston.setLogger(winstonLogger);
it('should write Winston string entries', function(done){
var captured = [];
var unhook = intercept(function(txt) {
captured.push(txt);
});
dbWinston.config.serverprops.read().result(function(response) {
unhook();
JSON.parse(captured[0]).level.should.eql('DEBUG');
done();
}, done);
});
});
module.exports = function(program, customLogger) {
if (logger) return logger;
// Custom logger.
if (customLogger) {
logger = customLogger;
}
// Default logger.
else {
const { createLogger, format, transports } = require('winston');
const { combine, timestamp, label, printf } = format;
program = program || {};
logger = createLogger();
logger.add(new transports.Console({
level: program.quiet ? 'error' : 'silly',
format: combine(
format.colorize(),
format.simple()
)
}));
logger.add(new transports.File({
filename: path.join('log', 'nodegame-mturk.log'),
level: 'silly'
}));
}
return logger;
};
/**
* Create Winston instance with a custom configuration.
* @constructor
*/
constructor() {
colors.setTheme(winston.config.npm.colors);
const customFilter = winston.format((info) => {
const pattern = /(\[[A-Za-z]+])/g;
info.message = info.message.replace(pattern, (str, p1) => p1.white);
return info;
});
this.logger = winston.createLogger({
level: 'silly',
levels: winston.config.npm.levels,
format: winston.format.combine(
winston.format.splat(),
customFilter(),
winston.format.timestamp({
format: 'YYYY-MM-DD hh:mm:ss',
}),
winston.format.printf((info) => `${info.timestamp.grey} ${this.constructor.formatLevel(info)} ${info.message} ${this.constructor.formatMeta(info)}`),
),
transports: [
new winston.transports.Console({
stderrLevels: ['error', 'debug'],
}),
],
});
}
function createLogger (options) {
const winston = require('winston'),
format = winston.format,
consoleFormat = format.printf(info => `${info.level}: ${info.message}`),
winstonLogger = winston.createLogger({
level: options.loglevel,
transports: [new winston.transports.Console({
format: format.combine(format.colorize(), consoleFormat)
})]
}),
ScopedLogger = require('./util/scopedLogger'),
logger = ScopedLogger.create(winstonLogger, `[mb:${options.port}] `);
if (!options.nologfile) {
initializeLogfile(options.logfile);
winstonLogger.add(new winston.transports.File({
filename: options.logfile,
maxsize: '20m',
maxFiles: 5,
tailable: true,
format: format.combine(format.timestamp(), format.json())
}));
}
return logger;
}
module.exports = function logger(loggersConfig) {
const transports = [];
for (const key in loggersConfig) {
if (!loggersConfig[key]) continue;
transports.push(new (winston.transports[key])(loggersConfig[key]));
}
return winston.createLogger({ transports });
}
/**
* Creates a logger using winston
*/
function createLogger({ logLevel = defaultLogLevel } = {}) {
const { format } = winston;
return winston.createLogger({
transports: [
new winston.transports.Console({
level: logLevel,
format: format.combine(winston.format.colorize(), format.splat(), format.simple()),
}),
],
});
}
// Sets up winston to give us request logging on the main App server.
function createLogger() {
return winston.createLogger({
format: winston.format.combine(winston.format.timestamp(), winston.format.json()),
transports: [
new WinstonDailyRotateFile({
name: 'app',
filename: path.resolve(process.cwd(), 'logs', 'app-%DATE%.log'),
zippedArchive: true,
}),
],
});
}
function getLogger(module) {
const path = module.filename.split('/').slice(-2).join('/');
return winston.createLogger({
transport: [
new winston.transports.Console({
colorize: true,
level: ENV == 'development' ? 'debug' : 'error',
label: path
})
]
});
}
/**
* Enables logging, optionally through a custom logging function.
*
* @param {Object|Function} opts An options object or logging function.
* @param {string} opts.colorize What to colorize in the console output.
* @param {string} opts.level Minimum level to log.
* @param {string} opts.filename The file path you wish to log to.
* @param {boolean} opts.console Whether to log to the console.
*/
function enableLogging(opts) {
if (!opts) {
opts = {};
}
if (opts instanceof Function) {
_loggingFunc = opts;
return;
}
if (opts instanceof Object) {
var level = 'info';
if (opts.level) {
level = opts.level;
}
var consoleLogOpts = {};
if (opts.colorize) {
consoleLogOpts.colorize = opts.colorize;
}
var transports = [];
if (opts.console === undefined || opts.console) {
transports.push(new(winston.transports.Console)(consoleLogOpts));
}
if (opts.filename) {
transports.push(new(winston.transports.File)({
filename: opts.filename
}));
}
if (transports.length === 0) {
// if no transports are defined, create a /dev/null transport
// to stop winston from complaining about no transports.
transports.push(new(winstonNull.NullTransport)());
}
var logger = winston.createLogger({
level: level,
transports: transports
});
_loggingFunc = logger.log.bind(logger);
return;
}
_loggingFunc = null;
}
static get(prefix) {
return winston.createLogger({
format: winston.format.simple(),
transports: [
new winston_console_for_electron_1.ConsoleForElectron({
level: configuration_1.configuration.debug.loggingLevelForConsole,
silent: configuration_1.configuration.debug.silent,
prefix: prefix,
}),
new VsCodeMessage({
level: configuration_1.configuration.debug.loggingLevelForAlert,
prefix: prefix,
}),
],
});
}
constructor(opts) {
if (!opts) throw new Error('Options are missing');
// Set up logging
winston.log.namespaces = true;
let transportsCount = 0;
const transports = [];
Object.keys(opts).forEach((transport) => {
switch (transport) {
case 'console': {
transportsCount += 1;
const consoleOpts = Object.assign({}, opts[transport], {
format: winston.format.combine(
winston.format.colorize(),
winston.format.simple()
)
});
transports.push(new (winston.transports.Console)(consoleOpts));
break;
}
case 'file': {
transportsCount += 1;
transports.push(new (winston.transports.File)(opts[transport]));
break;
}
case 'elasticsearch': {
transportsCount += 1;
const esTransportOpts = opts.elasticsearch;
esTransportOpts.mappingTemplate = mappingTemplate;
transformer.source = opts.elasticsearch.source;
esTransportOpts.transformer = transformer;
transports.push(new Elasticsearch(esTransportOpts));
break;
}
default:
// ignore
}
});
if (transportsCount <= 0) {
throw new Error('Provide at least one supported transport');
}
return winston.createLogger({ transports });
}
init: function(opts){
//Logger.settings = _.defaults(opts, Logger.defaults);
const myFormat = format.printf(info => {
return Logger.colors.time('['+info.timestamp+']') + ` ${info.level}: ${info.message}`;
});
// Get the service name
try {
Logger.serviceName = path.basename(process.argv[1], path.extname(process.argv[1]))
}
catch (e){
}
const myCloudFormat = format.printf(info => {
return `[${info.timestamp}, ${Logger.serviceName}] ${info.level}: ${info.message}`;
});
let transports = [
new winston.transports.Console({
level: 'debug',
// See https://github.com/winstonjs/logform
format: format.combine(
format.timestamp({
//format: 'ddd MMM DD h:mm:ss YYYY'
format: 'ddd MMM DD h:mm:ss'
}),
format.colorize(),
myFormat
)
})
]
Logger._logger = winston.createLogger({
transports: transports
});
},
module.exports = function(app) {
var TransportLogger = require('./transport-logger')(app);
var logOptions = {
handleExceptions: true,
prettyPrint: true,
json: false
};
const logger = createLogger({
exitOnError: false,
transports: [new TransportLogger(logOptions)]
});
//------------------------------------------------
//------------------------------------------------
if (!processListening) {
processListening = true;
process.on('exit', function(code) {
logger.warn('About to exit with code:', code);
});
process.on('warning', function(warning) {
logger.warn(warning);
});
process.on('unhandledRejection', function(reason, p) {
logger.error('Unhandled Rejection at: Promise ', p, ' reason: ', reason);
});
}
app.logger = logger;
return logger;
};
const getLogger = () => {
if (!logger) {
const { enableSyslog } = getConfig();
logger = winston.createLogger({
format: winston.format.simple(),
transports: [
new winston.transports.Console({
format: stdFormat,
}),
...(enableSyslog ? [
new Syslog({
app_name: LOGGER_CATEGORY,
facility: 'user',
protocol: 'unix',
path: '/dev/log',
}),
] : []),
],
levels: winston.config.syslog.levels,
});
}
return logger;
};
module.exports = function createLogger(loggersConfig) {
const transports = []
getTransports(loggersConfig).forEach(({ type, options }) => {
const transport = Transports[type](options)
if (transport) {
transports.push(transport)
}
})
if (transports.length) {
transports.unshift(new winston.transports.Console())
const logger = winston.createLogger({
format: winston.format.printf(({ message }) => message),
transports
})
logger.createLogStream = level => new LogStream({ level })
return logger
}
}
api.loggers = api.config.logger.loggers.map((loggerBuilder) => {
const resolvedLogger = loggerBuilder(api)
return winston.createLogger(resolvedLogger)
})
const express = require('express');
const router = express.Router();
const pg = require('pg');
const md5 = require('md5');
const request = require('request');
const winstonLogger = require('winston');
const fileLoggertTransport = new winstonLogger.transports.File({ filename: 'users.log' });
const consoleLoggerTransport = new winstonLogger.transports.Console();
const logger = winstonLogger.createLogger({
format: winstonLogger.format.printf(info => `${info.level}: ${info.message}`),
transports: [
fileLoggertTransport
]
});
var connection = pg.createConnection({
host : 'dockerhost',
user : '******',
password : '******',
database : 'users'
});
connection.connect(function(err) {
if (err) {
logger.error('error connecting to db: ' + err.stack);
return;
}
logger.info('connected to db ');
});
/**
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
'use strict';
const winston = require('winston');
const logger = winston.createLogger({
transports: [new winston.transports.Console()],
});
test('using winston should not fail', () => {
logger.log('info', 'Log message from winston');
logger.info('Info message from winston');
logger.warn('Warn message from winston');
logger.error('Error message from winston');
});
'use strict';
const winston = require('winston');
const logger = module.exports = winston.createLogger({
level: 'info',
format: winston.format.json(),
transports: [
new winston.transports.File({ filename: `${new Date().toDateString().replace(/ /g, '-')}.log`, level: 'verbose' }),
new winston.transports.Console({ format: winston.format.simple(), level: 'info' }),
],
});
logger.INFO = 'info';
logger.ERROR = 'error';
import { Meteor } from 'meteor/meteor';
import { createLogger, format, transports } from 'winston';
const Logger = createLogger({
format: format.combine(
format.colorize({ level: true }),
format.splat(),
format.simple(),
),
});
Meteor.startup(() => {
const LOG_CONFIG = Meteor.settings.private.serverLog || {};
const { level } = LOG_CONFIG;
// console logging
Logger.add(new transports.Console(), {
prettyPrint: false,
humanReadableUnhandledException: true,
colorize: true,
handleExceptions: true,
level,
});
});
export default Logger;
export const logger = Logger;
let nconf_config = nconf.get('config');
if (nconf_config) {
if (!require('fs').existsSync(nconf_config)) {
console.error(`[global]: config file "${nconf_config}" does not exist. exiting.`);
process.exit(1);
}
nconf.file(nconf_config);
} else {
nconf.use('memory');
}
nconf.defaults(require(`${__dirname}/../src/default_config.js`));
let logLevel = nconf.get('logLevel');
/**
* Instnace of `winston.Logger`
* @type {Logger}
*/
let logger = winston.createLogger({
level: logLevel,
format: winston.format.simple(),
silent: (logLevel === 'null'),
transports: [ new (winston.transports.Console)({ level: (logLevel !== 'null' ? logLevel : void(0)), silent: (logLevel === 'null') }) ]
});
/**
* Exports the main function for the application, a configured `nconf.Provider` instance and a winston logger
* @module tor-router/launch
*/
module.exports = { main, nconf, logger };
const winston = require('winston');
const LeNode = require('le_node');
console.dir(winston.transports);
const token = [
'aaaaaaaa-',
'aaaa-'.repeat(3),
'aaaaaaaaaaaa'
].join('')
const logger = winston.createLogger({
transports: [
new winston.transports.Logentries({ token })
]
});
* Copyright 2013-2018 the original author or authors from the JHipster project.
*
* This file is part of the JHipster project, see http://www.jhipster.tech/
* for more information.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
const winston = require('winston');
const transports = winston.transports;
const format = winston.format;
const myFormat = format.printf(info => `${info.level}: ${info.message}`);
module.exports = winston.createLogger({
transports: [new transports.Console()],
format: format.combine(myFormat),
handleExceptions: true
});
var express = require('express');
var router = express.Router();
// get runtime configuration
var config = require('../config/config.js').get(process.env.NODE_ENV);
// setup logging
const expressWinston = require('express-winston');
const winston = require('winston');
const level = process.env.LOG_LEVEL || 'debug';
var logger = winston.createLogger({
level: level,
transports: [
//new winston.transports.File(options.file),
//new winston.transports.Console(options.console)
new winston.transports.Console()
],
exitOnError: false, // do not exit on handled exceptions
});
// Add package to read json files
//var jsonfile = require('jsonfile');
var fs = require('fs');
// Add package for AWS node sdk
var AWS = require('aws-sdk');
//choose region in config
AWS.config.update(config.DynamoDB.region); //choose region in config
// create a DynamoDB document client to allow using JSON directly
var docClient = new AWS.DynamoDB.DocumentClient();
var attr = require('dynamodb-data-types').AttributeValue;
},
timestamp () {
return moment().format('Y-MM-DD HH:mm:ss')
}
}
const logger = module.exports = winston.createLogger({
exitOnError: false,
transports: [
new (winston.transports.DailyRotateFile)(_.extend(defaultOption, {
name: 'all-log',
filename: `${config.path.log}/${config.logName}.log`,
datePattern: 'yyyy-MM-dd',
prepend: true,
level: 'info'
})),
new (winston.transports.File)(_.extend(defaultOption, {
name: 'error-log',
level: 'error',
filename: `${config.path.log}/${config.logName}-error.log`,
maxsize: 1024 * 1024 * 25 // 25MB
// maxFiles: 10,
}))
]
})
// 콘솔 출력 추가
if (config.env === 'development') {
logger.add(
new (winston.transports.Console)(_.extend(defaultOption, {
level: 'info',
const config = require('../config');
const { createLogger, format, transports } = require('winston');
const { combine, timestamp, printf } = format;
const loggerFormat = printf(info => {
return `${info.timestamp} | ${info.level}: ${info.message}`;
});
const logger = createLogger({
level: config.loggerLevel,
format: combine(
format.colorize(),
timestamp(),
loggerFormat
),
transports: [
new transports.Console()
]
});
module.exports = logger;
global.log = winston.createLogger({
exitOnError: true,
json: false,
levels: levels,
level: logLevel,
format: format.combine(
format.printf(info => {
let level
if (info.level === 'error') level = '!!! ERROR !!!'
if (info.level === 'debug') level = chalk.bgRed.bold('DEBUG:')
if (info.level === 'chatIn') level = '<<<'
if (info.level === 'chatOut') level = '>>>'
if (info.level === 'whisperIn') level = '<w<'
if (info.level === 'whisperOut') level = '>w>'
if (info.level === 'info') level = '|'
if (info.level === 'warning') level = '|!'
if (info.level === 'timeout') level = '+timeout'
if (info.level === 'ban') level = '+ban'
if (info.level === 'follow') level = '+follow'
if (info.level === 'host') level = '+host'
if (info.level === 'raid') level = '+raid'
if (info.level === 'unfollow') level = '-follow'
if (info.level === 'cheer') level = '+cheer'
if (info.level === 'tip') level = '+tip'
if (info.level === 'sub') level = '+sub'
if (info.level === 'subgift') level = '+subgift'
if (info.level === 'subcommunitygift') level = '+subcommunitygift'
if (info.level === 'resub') level = '+resub'
if (info.level === 'start') level = '== STREAM STARTED =>'
if (info.level === 'stop') level = '== STREAM STOPPED'
if (typeof info.message === 'object') info.message = JSON.stringify(info.message, null, 4)
const timestamp = moment().tz(config.timezone).format('YYYY-MM-DD[T]HH:mm:ss.SSS')
if (info.level === 'debug') {
return `${timestamp} ${level} ${chalk.yellow(info.category)} ${info.message} ${info.username ? `[${info.username}]` : ''}`
} else return `${timestamp} ${level} ${info.message} ${info.username ? `[${info.username}]` : ''}`
})
),
exceptionHandlers: [
new winston.transports.File({ filename: logDir + '/exceptions.log', colorize: false, maxsize: 5242880 }),
new winston.transports.Console()
],
transports: [
new winston.transports.File({ filename: logDir + '/sogebot.log', colorize: false, maxsize: 5242880, maxFiles: 5, tailable: true }),
new winston.transports.File({ filename: logDir + '/debug.log', colorize: true, maxsize: 5242880, maxFiles: 5, level: 'debug', tailable: true }),
new winston.transports.Console()
]
})
const config = require('./config');
const specification = Specification.getDefaultSpecification();
const logger = winston.createLogger({
transports: [
new winston.transports.Console({
level: 'debug',
format: winston.format.combine(
winston.format.colorize(),
winston.format.simple()
),
}),
],
});
const connectionClassByName = {
SerialConnection,
TcpConnection,
};
const headerSetConsolidator = new HeaderSetConsolidator({
interval: config.loggingInterval,
/**
* Creates the mountebank server
* @param {object} options - The command line options
* @returns {Object} An object with a close method to stop the server
*/
function create (options) {
const Q = require('q'),
express = require('express'),
cors = require('cors'),
errorHandler = require('errorhandler'),
path = require('path'),
middleware = require('./util/middleware'),
HomeController = require('./controllers/homeController'),
ImpostersController = require('./controllers/impostersController'),
ImposterController = require('./controllers/imposterController'),
LogsController = require('./controllers/logsController'),
ConfigController = require('./controllers/configController'),
FeedController = require('./controllers/feedController'),
Imposter = require('./models/imposter'),
winston = require('winston'),
format = winston.format,
consoleFormat = format.printf(info => `${info.level}: ${info.message}`),
winstonLogger = winston.createLogger({
level: options.loglevel,
transports: [new winston.transports.Console({
format: format.combine(format.colorize(), consoleFormat)
})]
}),
thisPackage = require('../package.json'),
releases = require('../releases.json'),
ScopedLogger = require('./util/scopedLogger'),
logger = ScopedLogger.create(winstonLogger, `[mb:${options.port}] `),
helpers = require('./util/helpers'),
deferred = Q.defer(),
app = express(),
imposters = options.imposters || {},
builtInProtocols = {
tcp: require('./models/tcp/tcpServer'),
http: require('./models/http/httpServer'),
https: require('./models/https/httpsServer'),
smtp: require('./models/smtp/smtpServer')
},
customProtocols = loadCustomProtocols(options.protofile, logger),
hostname = options.host || 'localhost',
baseURL = `http://${hostname}:${options.port}`,
protocols = require('./models/protocols').load(builtInProtocols, customProtocols,
{ loglevel: options.loglevel, callbackURLTemplate: `${baseURL}/imposters/:port/_requests` }),
homeController = HomeController.create(releases),
impostersController = ImpostersController.create(protocols, imposters, Imposter, logger, {
allowInjection: options.allowInjection,
recordRequests: options.mock,
recordMatches: options.debug,
port: options.port
}),
imposterController = ImposterController.create(imposters),
logsController = LogsController.create(options.logfile),
configController = ConfigController.create(thisPackage.version, options),
feedController = FeedController.create(releases, options),
validateImposterExists = middleware.createImposterValidator(imposters),
localIPs = getLocalIPs(),
allowedIPs = localIPs;
if (!options.localOnly) {
options.ipWhitelist.forEach(ip => { allowedIPs.push(ip); });
}
if (!options.nologfile) {
initializeLogfile(options.logfile);
winstonLogger.add(new winston.transports.File({
filename: options.logfile,
maxsize: '20m',
maxFiles: 5,
tailable: true,
format: format.combine(format.timestamp(), format.json())
}));
}
app.use(middleware.useAbsoluteUrls(options.port));
app.use(middleware.logger(logger, ':method :url'));
app.use(middleware.globals({ heroku: options.heroku, port: options.port, version: thisPackage.version }));
app.use(middleware.defaultIEtoHTML);
app.use(middleware.json(logger));
app.use(express.static(path.join(__dirname, 'public')));
app.use(express.static(path.join(__dirname, '../node_modules')));
app.use(errorHandler());
app.use(cors());
app.disable('etag');
app.disable('x-powered-by');
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
app.set('json spaces', 2);
app.get('/', homeController.get);
app.get('/imposters', impostersController.get);
app.post('/imposters', impostersController.post);
app.delete('/imposters', impostersController.del);
app.put('/imposters', impostersController.put);
app.get('/imposters/:id', validateImposterExists, imposterController.get);
app.delete('/imposters/:id', imposterController.del);
app.delete('/imposters/:id/savedProxyResponses', imposterController.resetProxies);
app.delete('/imposters/:id/requests', imposterController.resetProxies); // deprecated but saved for backwards compatibility
// Protocol implementation APIs
app.post('/imposters/:id/_requests', imposterController.postRequest);
app.post('/imposters/:id/_requests/:proxyResolutionKey', imposterController.postProxyResponse);
app.get('/logs', logsController.get);
app.get('/config', configController.get);
app.get('/feed', feedController.getFeed);
app.get('/releases', feedController.getReleases);
app.get('/releases/:version', feedController.getRelease);
app.get('/sitemap', (request, response) => {
response.type('text/plain');
response.render('sitemap', { releases: releases });
});
[
'/support',
'/license',
'/faqs',
'/thoughtworks',
'/docs/gettingStarted',
'/docs/install',
'/docs/mentalModel',
'/docs/commandLine',
'/docs/clientLibraries',
'/docs/security',
'/docs/api/overview',
'/docs/api/contracts',
'/docs/api/mocks',
'/docs/api/stubs',
'/docs/api/predicates',
'/docs/api/xpath',
'/docs/api/json',
'/docs/api/jsonpath',
'/docs/api/proxies',
'/docs/api/injection',
'/docs/api/behaviors',
'/docs/api/errors',
'/docs/protocols/http',
'/docs/protocols/https',
'/docs/protocols/tcp',
'/docs/protocols/smtp'
].forEach(endpoint => {
app.get(endpoint, (request, response) => {
response.render(endpoint.substring(1));
});
});
function isAllowedConnection (ipAddress) {
return allowedIPs.some(allowedIP => allowedIP === '*' || allowedIP.toLowerCase() === ipAddress.toLowerCase());
}
const connections = {},
server = app.listen(options.port, options.host, () => {
logger.info(`mountebank v${thisPackage.version} now taking orders - point your browser to ${baseURL}/ for help`);
logger.debug(`config: ${JSON.stringify({
options: options,
process: {
nodeVersion: process.version,
architecture: process.arch,
platform: process.platform
}
})}`);
if (options.allowInjection) {
logger.warn(`Running with --allowInjection set. See ${baseURL}/docs/security for security info`);
}
server.on('connection', socket => {
const name = helpers.socketName(socket),
ipAddress = socket.remoteAddress;
connections[name] = socket;
socket.on('close', () => {
delete connections[name];
});
socket.on('error', error => {
logger.error('%s transmission error X=> %s', name, JSON.stringify(error));
});
if (!isAllowedConnection(ipAddress)) {
logger.warn('Blocking incoming connection from %s. Turn off --localOnly or add to --ipWhitelist to allow',
ipAddress);
socket.end();
}
});
deferred.resolve({
close: callback => {
server.close(() => {
logger.info('Adios - see you soon?');
callback();
});
// Force kill any open connections to prevent process hanging
Object.keys(connections).forEach(socket => {
connections[socket].destroy();
});
}
});
});
process.once('exit', () => {
Object.keys(imposters).forEach(port => {
imposters[port].stop();
});
});
return deferred.promise;
}
const { createLogger, format, transports } = require('winston')
const { combine, timestamp, printf, label } = format
require('winston-daily-rotate-file')
const moment = require('moment')
const chalk = require('chalk')
let logger = createLogger({
exitOnError: false
})
let styleText = function (text, meta) {
if (meta) {
let result = eval(meta) // eslint-disable-line
text = result(text)
}
return text
}
// CONSOLE
const customFormat = printf(info => {
let formattedDate = moment(info.timestamp).format('YYYY-MM-DD HH:mm:ss.SSS')
let level = info.level.toUpperCase()
let chalkMessageBuild = ['chalk']
switch (level) {
case 'SILLY':
level = chalk.cyanBright(level)
chalkMessageBuild.push('cyanBright')
break
case 'DEBUG':
level = chalk.blueBright(level)