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);
});
});
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
}
});
/**
* 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'],
}),
],
});
}
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;
};
constructor(program) {
this.files = [];
this.program = program;
logger.configure({
level: this.program.loglevel,
format: winston.format.combine(winston.format.colorize(), winston.format.timestamp(), winston.format.splat(), winston.format.simple()),
transports: [
new winston.transports.Console()
]
});
}
// 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,
}),
],
});
}
exports.init = function({host, port}) {
if (host && port) {
log.add(new log.transports.Papertrail({
format: formatLogs(),
level: config.log.level,
host,
port
}));
return;
}
if (process.env.NODE_ENV !== 'production') {
log.add(new log.transports.Console({
format: log.format.combine(
formatLogs(),
log.format.simple()
)
}));
}
};
/**
* 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()),
}),
],
});
}
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
});
},
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,
}),
],
});
}
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
}
}
}
if (info instanceof Error) {
return Object.assign({
message: info.message,
stack: info.stack
}, info);
}
return info;
});
const logger = createLogger({
format: format.combine(
enumerateErrorFormat(),
format.splat(),
format.simple()
),
transports: [
new transports.Console({
// change level if in dev environment versus production
level: env === 'development' ? 'debug' : 'info',
format: format.combine(
// https://github.com/winstonjs/winston/issues/1345
format(info => {
info.level = info.level.toUpperCase();
return info;
})(),
format.colorize(),
format.timestamp({
format: 'YYYY-MM-DD HH:mm:ss',
import winston from 'winston';
import { Syslog } from 'winston-syslog';
import { getConfig } from '../config';
const LOGGER_CATEGORY = 'caliopen-frontend';
const stdFormat = winston.format.combine(
winston.format.colorize(),
winston.format.timestamp(),
winston.format.align(),
winston.format.label({ label: LOGGER_CATEGORY }),
winston.format.printf(info => `${info.timestamp} ${info.level} ${info.label} - ${info.message}`),
);
let 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',
}),
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 ');
});
'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';
Dota2.Dota2Client = function Dota2Client(steamClient, debug, debugMore) {
EventEmitter.call(this);
this.debug = debug || false;
this.debugMore = debugMore || false;
/**
* The logger used to write debug messages. This is a WinstonJS logger,
* feel free to configure it as you like
* @type {winston.Logger}
*/
this.Logger = createLogger({
transports: [new transports.Console()],
format: format.combine(
format.colorize(),
format.timestamp({
format: 'D MMM HH:mm:ss'
}),
format.printf(nfo => {
return `${nfo.timestamp} - ${nfo.message}`
})
)
});
if(debug) this.Logger.level = "debug";
if(debugMore) this.Logger.level = "silly";
/** The current state of the bot's inventory. Contains cosmetics, player cards, ...
* @type {CSOEconItem[]}
*/
this.Inventory = [];
/** The chat channels the bot has joined
* @type {CMsgDOTAJoinChatChannelResponse[]}
*/
this.chatChannels = []; // Map channel names to channel data.
/** The lobby the bot is currently in. Falsy if the bot isn't in a lobby.
* @type {CSODOTALobby}
*/
this.Lobby = null;
/** The currently active lobby invitation. Falsy if the bot has not been invited.
* @type {CSODOTALobbyInvite}
*/
this.LobbyInvite = null;
/** The party the bot is currently in. Falsy if the bot isn't in a party.
* @type {CSODOTAParty}
*/
this.Party = null;
/** The currently active party invitation. Falsy if the bot has not been invited.
* @type {CSODOTAPartyInvite}
*/
this.PartyInvite = null;
var steamUser = new steam.SteamUser(steamClient);
this._user = steamUser;
this._client = steamClient;
this._gc = new steam.SteamGameCoordinator(steamClient, DOTA_APP_ID);
this._appid = DOTA_APP_ID;
this._gcReady = false;
this._gcClientHelloIntervalId = null;
this._gcConnectionStatus = Dota2.schema.GCConnectionStatus.GCConnectionStatus_NO_SESSION;
// node-steam wants this as a simple object, so we can't use CMsgProtoBufHeader
this._protoBufHeader = {
"msg": "",
"proto": {
"client_steam_id": this._client.steamID,
"source_app_id": this._appid
}
};
var self = this;
this._gc.on("message", function fromGC(header, body, callback) {
/* Routes messages from Game Coordinator to their handlers. */
callback = callback || null;
var kMsg = header.msg;
self.Logger.silly("Dota2 fromGC: " + Dota2._getMessageName(kMsg));
if (kMsg in self._handlers) {
if (callback) {
self._handlers[kMsg].call(self, body, callback);
} else {
self._handlers[kMsg].call(self, body);
}
} else {
self.emit("unhandled", kMsg, Dota2._getMessageName(kMsg));
}
});
this._sendClientHello = function() {
if (self._gcReady) {
if (self._gcClientHelloIntervalId) {
clearInterval(self._gcClientHelloIntervalId);
self._gcClientHelloIntervalId = null;
}
return;
}
if (self._gcClientHelloCount > 10) {
self.Logger.warn("ClientHello has taken longer than 30 seconds! Reporting timeout...")
self._gcClientHelloCount = 0;
self.emit("hellotimeout");
}
self.Logger.debug("Sending ClientHello");
if (!self._gc) {
self.Logger.error("Where the f**k is _gc?");
} else {
self._gc.send(
{msg: Dota2.schema.EGCBaseClientMsg.k_EMsgGCClientHello, proto: {}},
new Dota2.schema.CMsgClientHello({}).toBuffer()
);
}
self._gcClientHelloCount++;
};
};
var express = require('express');
var bodyParser = require('body-parser');
var fs = require('fs');
var path = require('path');
var childProcess = require('child_process');
var less = require('less');
var async = require('async');
var uglify = require('uglify-es');
var nconf = require('nconf');
var Benchpress = require('benchpressjs');
var app = express();
var server;
var formats = [
winston.format.colorize(),
];
const timestampFormat = winston.format((info) => {
var dateString = new Date().toISOString() + ' [' + global.process.pid + ']';
info.level = dateString + ' - ' + info.level;
return info;
});
formats.push(timestampFormat());
formats.push(winston.format.splat());
formats.push(winston.format.simple());
winston.configure({
level: 'verbose',
format: winston.format.combine.apply(null, formats),
transports: [
//
// Logs are saved in the appropriate log folder for the current OS and rotated daily.
//
// Electron's getPath helper isn't working for Ubuntu Linux right now:
// https://github.com/electron/electron/issues/15877
// So we manually configure the ~/.config/Stele/ folder the standard app logging folder.
//
const baseLogPath = process.platform === 'linux'
? path.join(os.homedir(), '.config', app.getName())
: app.getPath('logs');
const logger = createLogger({
level: 'info',
format: format.combine(
format.timestamp(),
format.printf(
info => `${info.timestamp} ${info.level}: ${info.message}`,
),
),
transports: [
new DailyRotateFile({
filename: path.join(baseLogPath, 'log-%DATE%.log'),
datePattern: 'YYYY-MM-DD-HH',
maxSize: '20m',
maxFiles: '90d',
}),
],
});
export default logger;
/*
* Genius.com scraper
* Artist name, Genius iq, followers, and annotation count
*/
const puppeteer = require('puppeteer')
const cheerio = require('cheerio')
const config = require('./config.json')
const dbService = require('./mongoService')
const { createLogger, format, transports } = require('winston');
const { combine, timestamp, printf } = format;
const logger = createLogger({
format: combine(
format.colorize(),
format.simple()
),
transports: [
new transports.Console(),
new transports.File({ filename: 'error.log', level: 'error' }),
new transports.File({ filename: 'server.log' })
]
});
async function scrollToBottom(page, prevHeight) {
const pageHeight = await page.evaluate('document.body.scrollHeight')
if (prevHeight < pageHeight) {
await page.evaluate('window.scrollTo(0, document.body.scrollHeight)');
}
await page.waitFor(1000)
return pageHeight
}
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;
return logDateKeeper.info;
default:
return logDateKeeper.debug;
}
break;
default:
return logDateKeeper.debug;
}
}
if (useJsonLogging) {
makeLog = makeLogJson;
consoleLogger = winston.createLogger({
level: logLevel,
format: winston.format.json(),
transports: [new winston.transports.Console()]
});
} else {
makeLog = makeLogPlain;
consoleLogger = winston.createLogger({
level: logLevel,
format: winston.format.simple(),
transports: [new winston.transports.Console()]
});
}
if (remarkPlainLogging) {
consoleLogger.info(makeLog('portal-env:logger', 'Using plain logging format on non-containerized OS; override with LOG_PLAIN=false'));
}
consoleLogger.info(makeLog('portal-env:logger', `Setting up logging with log level "${logLevel}" (override with LOG_LEVEL)`));
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,
timeToLive: config.loggingTimeToLive,
this.init = function () {
this.level = this.parseLevel('info');
if(config.log.global != null) {
this.level = this.parseLevel(config.log.global)
}
// config.js에 filepath에 해당하는 loglevel 설정이 있으면 설정
var filename = `${path.basename(filepath)}`;
filename = filename.split(".")[0];
const loglevel = config.log[filename];
// console.info(filename, loglevel);
if (loglevel != null) {
this.level = this.parseLevel(loglevel);
}
// // loglevel에따라 로그 타이틀(파일)명을 fullpath or filename으로 설정
// if (this.level <= 1) {
// this.name = filename;
// } else {
// this.name = `${filepath}`;
// }
// var log = `current [${filepath}] log level(config.loglevel) = ${this.getLogLevelType()}`;
// if (config.log.global != null) {
// this.setLogLevel(config.log.global);
// } else {
// this.setLogLevel(this.level);
// log = `current [${filepath}] log level = ${this.getLogLevelType()}`;
// }
if(this.level <= 1) {
this.name = `${path.basename(filepath)}`;
} else {
this.name = `${filepath}`;
}
this.setLogLevel(this.level);
var log = `current [${filepath}] log level = ${this.getLogLevelType()}`;
if (this.isProdMode) {
// 실행모드에서 파일에 로그를 남기기 위한 설정
this.logger = createLogger({
level: 'debug', // 최소 레벨
// 파일저장
transports: [
new transports.DailyRotateFile({
filename: 'log/system.log', // log 폴더에 system.log 이름으로 저장
zippedArchive: true, // 압축여부
format: format.combine(format.splat(), format.simple()),
}),
// // 콘솔 출력
// new winston.transports.Console({
// format: winston.format.printf(
// info => `${timeStampFormat()} [${info.level.toUpperCase()}] - ${info.message}`)
// })
]
});
this.logger.info(log);
this.logger.error(log);
this.logger.warn(log);
}
return this;
},
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 };
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;