def test_debugging(self):
console_msg = (
'This should log\nSo should this\nAnd this too\nThis should log '
'also\nSo should this\nAnd this too\nBut this one should\nAnd this'
' one too')
logger = gogo.Gogo('debug.none').logger
logger.debug('This should log')
logger.info('So should this')
logger.warning('And this too')
logger = gogo.Gogo('debug.on', verbose=True).logger
logger.debug('This should log also')
logger.info('So should this')
logger.warning('And this too')
logger = gogo.Gogo('debug.off', verbose=False).logger
logger.debug("This shouldn't log")
logger.info('But this one should')
logger.warning('And this one too')
results = sys.stdout.getvalue().strip()
nt.assert_in("This should log", results)
nt.assert_not_in("This shouldn't log", results)
nt.assert_equal(console_msg, results)
def test_debugging(self):
console_msg = (
"This should log\nSo should this\nAnd this too\nThis should log "
"also\nSo should this\nAnd this too\nBut this one should\nAnd this"
" one too"
)
logger = gogo.Gogo("debug.none").logger
logger.debug("This should log")
logger.info("So should this")
logger.warning("And this too")
logger = gogo.Gogo("debug.on", verbose=True).logger
logger.debug("This should log also")
logger.info("So should this")
logger.warning("And this too")
logger = gogo.Gogo("debug.off", verbose=False).logger
logger.debug("This shouldn't log")
logger.info("But this one should")
logger.warning("And this one too")
results = sys.stdout.getvalue().strip()
nt.assert_in("This should log", results)
nt.assert_not_in("This shouldn't log", results)
nt.assert_equal(console_msg, results)
def test_formatters(self):
# basic
sys.stderr = StringIO()
logger = gogo.Gogo('stderr_if_gt_error', 'error').logger
logger.warning('stdout')
logger.error('stderr')
# json_formatter
formatter = gogo.formatters.json_formatter
json_logger = gogo.Gogo('json', low_formatter=formatter).logger
json_logger.debug('hello')
# csv_formatter
formatter = gogo.formatters.csv_formatter
csv_logger = gogo.Gogo('csv', low_formatter=formatter).logger
csv_logger.debug('hello')
# console_formatter
formatter = gogo.formatters.console_formatter
console_lggr = gogo.Gogo('console', low_formatter=formatter).logger
console_lggr.debug('hello')
console_msg = (
'stdout\nstderr\n{"time": "20...", "name": "json.base", "level": '
'"DEBUG", "message": "hello"}\n20...,csv.base,DEBUG,"hello"\n'
'console.base: DEBUG hello')
results = sys.stdout.getvalue().strip()
nt.assert_equal_ellipsis(console_msg, results)
nt.assert_equal('stderr', sys.stderr.getvalue().strip())
def test_formatters(self):
# basic
sys.stderr = StringIO()
logger = gogo.Gogo("stderr_if_gt_error", "error").logger
logger.warning("stdout")
logger.error("stderr")
# json_formatter
formatter = gogo.formatters.json_formatter
json_logger = gogo.Gogo("json", low_formatter=formatter).logger
json_logger.debug("hello")
# csv_formatter
formatter = gogo.formatters.csv_formatter
csv_logger = gogo.Gogo("csv", low_formatter=formatter).logger
csv_logger.debug('hello "world"')
# console_formatter
formatter = gogo.formatters.console_formatter
console_lggr = gogo.Gogo("console", low_formatter=formatter).logger
console_lggr.debug("hello")
console_msg = (
"stdout\n"
"stderr\n"
'{"time": "20...", "name": "js...", "level": "DEBUG", "message": "hello"}\n'
'"20...","csv.base","DEBUG","hello ""world"""\n'
"console.base: DEBUG hello"
)
results = sys.stdout.getvalue().strip()
nt.assert_equal_ellipsis(console_msg, results)
nt.assert_equal("stderr", sys.stderr.getvalue().strip())
def test_structured_logging(self):
kwargs = {"persist": True}
extra = {"additional": True}
meta = set(["level", "name", "time"])
# Basic structured logger
logger0 = gogo.Gogo("logger0").get_structured_logger("base", **kwargs)
# Structured formatter
formatter = gogo.formatters.structured_formatter
logger1 = gogo.Gogo("logger1", low_formatter=formatter).logger
# JSON formatter
formatter = gogo.formatters.json_formatter
logger2 = gogo.Gogo("logger2", low_formatter=formatter).logger
# Custom logger
logfmt = (
'{"time": "%(asctime)s.%(msecs)d", "name": "%(name)s", "level":'
' "%(levelname)s", "message": "%(message)s", '
'"persist": "%(persist)s", "additional": "%(additional)s"}'
)
fmtr = logging.Formatter(logfmt, datefmt=gogo.formatters.DATEFMT)
logger3 = gogo.Gogo("logger3", low_formatter=fmtr).get_logger(**kwargs)
# Now log some messages
for logger in [logger0, logger1, logger2, logger3]:
logger.debug("message", extra=extra)
lines = sys.stdout.getvalue().strip().split("\n")
results = [loads(i) for i in lines]
# Assert the following loggers provide the log event meta data
nt.assert_is_not_subset(meta, results[0])
nt.assert_is_subset(meta, results[1])
nt.assert_is_subset(meta, results[2])
nt.assert_is_subset(meta, results[3])
# Assert the following loggers provide the `extra` information
nt.assert_in("additional", results[0])
nt.assert_in("additional", results[1])
nt.assert_not_in("additional", results[2])
nt.assert_in("additional", results[3])
# Assert the following loggers provide the `persist` information
nt.assert_in("persist", results[0])
nt.assert_in("persist", results[1])
nt.assert_not_in("persist", results[2])
nt.assert_in("persist", results[3])
# Assert the following loggers provide the `msecs` in the time
nt.assert_false(len(results[0].get("time", [])))
nt.assert_false(len(results[1]["time"][20:]))
nt.ok_(len(results[2]["time"][20:]))
nt.ok_(len(results[3]["time"][20:]))
def run():
"""CLI runner
"""
args = parser.parse_args()
gogo_logger = gogo.Gogo(__name__, verbose=args.verbose).get_logger("run")
if args.version:
gogo_logger.info("gogo v%s" % gogo.__version__)
exit(0)
counted = {"get", "tcp"}
appended = {"filename", "subject", "url", "host", "port"}
items = args._get_kwargs()
counted_args = [i for i in items if i[0] in counted]
appended_args = [i for i in items if i[0] in appended]
high_appended_args = [(k, v[0]) for k, v in appended_args]
high_counted_args = [(k, v > 0) for k, v in counted_args]
high_kwargs = dict(it.chain(high_appended_args, high_counted_args))
low_appended_args = [(k, v[-1]) for k, v in appended_args]
low_counted_args = [(k, v > 1) for k, v in counted_args]
low_kwargs = dict(it.chain(low_appended_args, low_counted_args))
high_hdlr = getattr(gogo.handlers, "%s_hdlr" % args.high_hdlr)
low_hdlr = getattr(gogo.handlers, "%s_hdlr" % args.low_hdlr)
high_format = getattr(gogo.formatters, "%s_formatter" % args.high_format)
low_format = getattr(gogo.formatters, "%s_formatter" % args.low_format)
nkwargs = {
"verbose": args.verbose,
"high_level": args.high_level.upper(),
"low_level": args.low_level.upper(),
"high_formatter": high_format,
"low_formatter": low_format,
"monolog": args.monolog,
"high_hdlr": high_hdlr(**high_kwargs),
"low_hdlr": low_hdlr(**low_kwargs),
}
logger = gogo.Gogo(args.name, **nkwargs).get_logger("runner")
try:
message = args.message.read()
except AttributeError:
message = args.message
getattr(logger, args.level)(message)
exit(0)
def run():
"""CLI runner
"""
args = parser.parse_args()
gogo_logger = gogo.Gogo(__name__, verbose=args.verbose).get_logger('run')
if args.version:
gogo_logger.info('gogo v%s' % gogo.__version__)
exit(0)
counted = {'get', 'tcp'}
appended = {'filename', 'subject', 'url', 'host', 'port'}
items = args._get_kwargs()
counted_args = [i for i in items if i[0] in counted]
appended_args = [i for i in items if i[0] in appended]
high_appended_args = [(k, v[0]) for k, v in appended_args]
high_counted_args = [(k, v > 0) for k, v in counted_args]
high_kwargs = dict(it.chain(high_appended_args, high_counted_args))
low_appended_args = [(k, v[-1]) for k, v in appended_args]
low_counted_args = [(k, v > 1) for k, v in counted_args]
low_kwargs = dict(it.chain(low_appended_args, low_counted_args))
high_hdlr = getattr(gogo.handlers, '%s_hdlr' % args.high_hdlr)
low_hdlr = getattr(gogo.handlers, '%s_hdlr' % args.low_hdlr)
high_format = getattr(gogo.formatters, '%s_formatter' % args.high_format)
low_format = getattr(gogo.formatters, '%s_formatter' % args.low_format)
nkwargs = {
'verbose': args.verbose,
'high_level': args.high_level.upper(),
'low_level': args.low_level.upper(),
'high_formatter': high_format,
'low_formatter': low_format,
'monolog': args.monolog,
'high_hdlr': high_hdlr(**high_kwargs),
'low_hdlr': low_hdlr(**low_kwargs)
}
logger = gogo.Gogo(args.name, **nkwargs).get_logger('runner')
try:
message = args.message.read()
except AttributeError:
message = args.message
getattr(logger, args.level)(message)
exit(0)
def __init__(self):
log_format = '[%(asctime)s] [%(levelname)s] - %(name)s: %(message)s'
formatter = logging.Formatter(log_format)
self.corelogger = gogo.Gogo(
'core',
low_hdlr=gogo.handlers.file_hdlr('core.log'),
low_formatter=formatter,
high_level='info',
high_formatter=formatter).logger
self.clientlogger = gogo.Gogo(
'client',
low_hdlr=gogo.handlers.file_hdlr('client.log'),
low_formatter=formatter,
high_level='info',
high_formatter=formatter).logger
def test_extra(self):
extra = {"additional": True}
logger1 = gogo.Gogo("basic").get_structured_logger("base2", context=True)
logger1.debug("basic", extra=extra)
result = loads(sys.stdout.getvalue().strip())
nt.assert_equal(result["context"], extra["context"])
def test_structured_formatter(self):
console_msg = {
"snowman": "\u2603",
"name": "structured_formatter.base",
"level": "INFO",
"message": "log message",
"time": "20...",
"msecs": "...",
"set_value": [1, 2, 3],
}
log_format = gogo.formatters.BASIC_FORMAT
skwargs = {"datefmt": "%Y"}
formatter = gogo.formatters.StructuredFormatter(log_format, **skwargs)
kwargs = {"low_level": "info", "low_formatter": formatter}
logger = gogo.Gogo("structured_formatter", **kwargs).logger
extra = {"set_value": set([1, 2, 3]), "snowman": "\u2603"}
logger.info("log message", extra=extra)
result = loads(sys.stdout.getvalue())
result["msecs"] = str(result["msecs"])
keys = sorted(result.keys())
nt.assert_equal(sorted(console_msg.keys()), keys)
whitelist = {"msecs", "time"}
for k in keys:
f = nt.assert_equal_ellipsis if k in whitelist else nt.assert_equal
f(console_msg[k], result[k])
def main(script, tests, verbose=False, stop=True):
""" Main method
Returns 0 on success, 1 on failure
"""
failures = 0
logger = gogo.Gogo(__name__, verbose=verbose).logger
short_script = p.basename(script)
env = TestFileEnvironment('.scripttest')
start = timer()
for pos, test in enumerate(tests):
num = pos + 1
opts, arguments, expected = test
joined_opts = ' '.join(opts) if opts else ''
joined_args = '"%s"' % '" "'.join(arguments) if arguments else ''
command = "%s %s %s" % (script, joined_opts, joined_args)
short_command = "%s %s %s" % (short_script, joined_opts, joined_args)
result = env.run(command,
cwd=p.abspath(p.dirname(p.dirname(__file__))))
output = result.stdout
if isinstance(expected, bool):
text = StringIO(output).read()
outlines = [str(bool(text))]
checklines = StringIO(str(expected)).readlines()
elif p.isfile(expected):
outlines = StringIO(output).readlines()
with open(expected, encoding='utf-8') as f:
checklines = f.readlines()
else:
outlines = StringIO(output).readlines()
checklines = StringIO(expected).readlines()
args = [checklines, outlines]
kwargs = {'fromfile': 'expected', 'tofile': 'got'}
diffs = ''.join(unified_diff(*args, **kwargs))
passed = not diffs
if not passed:
failures += 1
msg = "ERROR! Output from test #%i:\n %s\n" % (num, short_command)
msg += "doesn't match:\n %s\n" % expected
msg += diffs if diffs else ''
else:
logger.debug(output)
msg = 'Scripttest #%i: %s ... ok' % (num, short_command)
logger.info(msg)
if stop and failures:
break
time = timer() - start
logger.info('%s' % '-' * 70)
end = 'FAILED (failures=%i)' % failures if failures else 'OK'
logger.info('Ran %i scripttests in %0.3fs\n\n%s' % (num, time, end))
sys.exit(failures)
def test_structured_formatter(self):
console_msg = {
'snowman': '\u2603',
'name': 'structured_formatter.base',
'level': 'INFO',
'message': 'log message',
'time': '20...',
'msecs': '...',
'set_value': [1, 2, 3]
}
log_format = gogo.formatters.BASIC_FORMAT
skwargs = {'datefmt': '%Y'}
formatter = gogo.formatters.StructuredFormatter(log_format, **skwargs)
kwargs = {'low_level': 'info', 'low_formatter': formatter}
logger = gogo.Gogo('structured_formatter', **kwargs).logger
extra = {'set_value': set([1, 2, 3]), 'snowman': '\u2603'}
logger.info('log message', extra=extra)
result = loads(sys.stdout.getvalue())
result['msecs'] = str(result['msecs'])
keys = sorted(result.keys())
nt.assert_equal(sorted(console_msg.keys()), keys)
whitelist = {'msecs', 'time'}
for k in keys:
f = nt.assert_equal_ellipsis if k in whitelist else nt.assert_equal
f(console_msg[k], result[k])
def get_logger(logger_name):
levels = ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
going = gogo.Gogo('tpod',
low_formatter=gogo.formatters.fixed_formatter,
high_level='error',
levels=levels)
return going.get_logger(logger_name)
def get_app(options):
"""Get app."""
router = SwaggerRouter(swagger_ui='/swagger/')
app = web.Application(
router=router,
middlewares=[
jsonify,
SentryMiddleware(),
log_middleware,
],
)
app['logger'] = pygogo.Gogo(
__name__,
low_formatter=pygogo.formatters.structured_formatter,
verbose=options.option('debug'))
if options.option('debug'):
logging.basicConfig(level=logging.DEBUG)
app['sessions'] = {}
app['logger'].get_logger().debug("starting")
app['config'] = configparser.ConfigParser()
app['config'].read(options.option('config') or '')
setup(app)
setup_routes(app)
return app
def main(script, tests, verbose=False, stop=True):
"""
Returns 0 on success, 1 on failure
"""
failures = 0
logger = gogo.Gogo(__name__, verbose=verbose).logger
short_script = p.basename(script)
env = TestFileEnvironment(".scripttest")
start = timer()
for pos, test in enumerate(tests):
num = pos + 1
opts, arguments, expected = test
joined_opts = " ".join(opts) if opts else ""
joined_args = '"%s"' % '" "'.join(arguments) if arguments else ""
command = "%s %s %s" % (script, joined_opts, joined_args)
short_command = "%s %s %s" % (short_script, joined_opts, joined_args)
result = env.run(command, cwd=PARENT_DIR, expect_stderr=True)
output = result.stdout
if isinstance(expected, bool):
text = StringIO(output).read()
outlines = [str(bool(text))]
checklines = StringIO(str(expected)).readlines()
elif p.isfile(expected):
outlines = StringIO(output).readlines()
with open(expected, encoding="utf-8") as f:
checklines = f.readlines()
else:
outlines = StringIO(output).readlines()
checklines = StringIO(expected).readlines()
args = [checklines, list(filter_output(outlines))]
kwargs = {"fromfile": "expected", "tofile": "got"}
diffs = "".join(unified_diff(*args, **kwargs))
if diffs:
failures += 1
msg = "ERROR! Output from test #%i:\n %s\n" % (num, short_command)
msg += "doesn't match:\n %s\n" % expected
msg += diffs if diffs else ""
else:
logger.debug(output)
msg = "Scripttest #%i: %s ... ok" % (num, short_command)
logger.info(msg)
if stop and failures:
break
time = timer() - start
logger.info("%s" % "-" * 70)
end = "FAILED (failures=%i)" % failures if failures else "OK"
logger.info("Ran %i scripttests in %0.3fs\n\n%s", num, time, end)
sys.exit(failures)
def get_logger(name, custom_formatter=None) -> pygogo.Gogo.logger:
global formatter
_formatter = formatter
if custom_formatter:
_formatter = logging.Formatter(custom_formatter)
logger = pygogo.Gogo(name,
low_formatter=_formatter,
high_level="error",
high_formatter=formatter).logger
return logger
def test_params_and_looping(self):
levels = ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
f = StringIO()
going = gogo.Gogo(low_hdlr=gogo.handlers.fileobj_hdlr(f))
logger1 = going.get_logger('area1')
logger2 = gogo.Gogo().get_logger('area2')
logger1_msg = 'A debug message\nAn info message'
logger1.debug('A debug message')
logger1.info('An info %s', 'message')
f.seek(0)
nt.assert_equal(f.read().strip(), logger1_msg)
logger2_msg = ''
for level in [getattr(logging, l) for l in levels]:
name = logging.getLevelName(level)
logger2_msg += '%s message\n' % name
logger2.log(level, '%s %s', name, 'message')
# TODO: lookup yielding from a nose test
nt.assert_equal(logger2_msg.strip(), sys.stdout.getvalue().strip())
def test_params_and_looping(self):
levels = ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
f = StringIO()
going = gogo.Gogo(low_hdlr=gogo.handlers.fileobj_hdlr(f))
logger1 = going.get_logger("area1")
logger2 = gogo.Gogo().get_logger("area2")
logger1_msg = "A debug message\nAn info message"
logger1.debug("A debug message")
logger1.info("An info %s", "message")
f.seek(0)
nt.assert_equal(f.read().strip(), logger1_msg)
logger2_msg = ""
for level in [getattr(logging, i) for i in levels]:
name = logging.getLevelName(level)
logger2_msg += "%s message\n" % name
logger2.log(level, "%s %s", name, "message")
# TODO: lookup yielding from a nose test
nt.assert_equal(logger2_msg.strip(), sys.stdout.getvalue().strip())
def _logger(log_file_name='proton_generic_logs',
log_file_path='./../../trace/proton_generic_logs.log'):
log_format = '[%(asctime)s] <---> [%(name)s] <---> [%(levelname)s] <---> [%(message)s]'
formatter = logging.Formatter(log_format)
my_logger = gogo.Gogo(
log_file_name,
low_hdlr=gogo.handlers.file_hdlr(log_file_path),
low_formatter=formatter,
high_level='error',
high_formatter=formatter,
).logger
return my_logger
def log_all(log_fo, log_object, errormsg):
# define filepath
log_file_path = "%s_%s.log" % (log_object["telco"],
log_object["scrubber_start_time"])
logger = gogo.Gogo(low_hdlr=gogo.handlers.file_hdlr(log_file_path)).logger
# define output string
formatted = "[%s] - %s - %s - %s - %s - %s" % (
datetime.datetime.utcnow().isoformat(), log_object["telco"],
log_object["file_name"], log_object["line_number"],
log_object["line_content"], errormsg)
# append output string to logfile each time log_all is called.
log_fo.write(formatted + "\r\n")
def _logger(self,
logFileName='pk_logger_genericName',
logFilePath='./logs/pk_logger_genericName.log'):
log_format = '[%(asctime)s] <---> [%(name)s] <---> [%(levelname)s] <---> [%(message)s]'
formatter = logging.Formatter(log_format)
myLogger = gogo.Gogo(
logFileName,
low_hdlr=gogo.handlers.file_hdlr(logFilePath),
low_formatter=formatter,
high_level='error',
high_formatter=formatter,
).logger
return myLogger
def __init__(self):
super(PersistApiCalls, self).__init__()
self.__log_format = '[%(asctime)s] <---> [%(name)s] <---> [%(levelname)s] <---> [%(message)s]'
self.__formatter = logging.Formatter(self.__log_format)
self.timer = {}
self.logger = gogo.Gogo(
'pk_scraperService_middleware',
low_hdlr=gogo.handlers.file_hdlr(
'./logs/pk_scraperService_middleware.log'),
low_formatter=self.__formatter,
high_level='error',
high_formatter=self.__formatter,
).logger
def test_named_loggers(self):
sys.stderr = sys.stdout
logger1 = gogo.Gogo('named').logger
logger2 = gogo.Gogo('named').logger
nt.assert_equal(logger1, logger2)
formatter = gogo.formatters.structured_formatter
going = gogo.Gogo('named2', low_formatter=formatter)
logger1 = going.get_logger('foo', test='foo')
logger2 = going.get_logger('bar', test='bar')
logger1.debug('message')
logger2.debug('message')
for h1, h2 in zip(logger1.handlers, logger2.handlers):
nt.assert_not_equal(h1, h2)
for f1, f2 in zip(h1.filters, h2.filters):
nt.assert_not_equal(f1, f2)
hdlr = gogo.handlers.stdout_hdlr()
going = gogo.Gogo('named3', low_hdlr=hdlr, low_formatter=formatter)
logger1 = going.get_logger('baz', test='baz')
logger2 = going.get_logger('buzz', test='buzz')
logger1.debug('message')
logger2.debug('message')
for h1, h2 in zip(logger1.handlers, logger2.handlers):
nt.assert_not_equal(h1, h2)
for f1, f2 in zip(h1.filters, h2.filters):
nt.assert_not_equal(f1, f2)
lines = sys.stdout.getvalue().strip().split('\n')
nt.assert_not_equal(*(loads(l)['test'] for l in lines[0:2]))
nt.assert_not_equal(*(loads(l)['test'] for l in lines[2:4]))
def test_named_loggers(self):
sys.stderr = sys.stdout
logger1 = gogo.Gogo("named").logger
logger2 = gogo.Gogo("named").logger
nt.assert_equal(logger1, logger2)
formatter = gogo.formatters.structured_formatter
going = gogo.Gogo("named2", low_formatter=formatter)
logger1 = going.get_logger("foo", test="foo")
logger2 = going.get_logger("bar", test="bar")
logger1.debug("message")
logger2.debug("message")
for h1, h2 in zip(logger1.handlers, logger2.handlers):
nt.assert_not_equal(h1, h2)
for f1, f2 in zip(h1.filters, h2.filters):
nt.assert_not_equal(f1, f2)
hdlr = gogo.handlers.stdout_hdlr()
going = gogo.Gogo("named3", low_hdlr=hdlr, low_formatter=formatter)
logger1 = going.get_logger("baz", test="baz")
logger2 = going.get_logger("buzz", test="buzz")
logger1.debug("message")
logger2.debug("message")
for h1, h2 in zip(logger1.handlers, logger2.handlers):
nt.assert_not_equal(h1, h2)
for f1, f2 in zip(h1.filters, h2.filters):
nt.assert_not_equal(f1, f2)
lines = sys.stdout.getvalue().strip().split("\n")
nt.assert_not_equal(*(loads(i)["test"] for i in lines[0:2]))
nt.assert_not_equal(*(loads(i)["test"] for i in lines[2:4]))
def test_handlers(self):
f = StringIO()
hdlr = gogo.handlers.fileobj_hdlr(f)
lggr = gogo.Gogo("test_handlers", high_hdlr=hdlr).logger
msg1 = "stdout hdlr only"
lggr.debug(msg1)
f.seek(0)
nt.assert_equal(msg1, sys.stdout.getvalue().strip())
nt.assert_false(f.read())
msg2 = "both hdlrs"
lggr.error(msg2)
f.seek(0)
nt.assert_equal("%s\n%s" % (msg1, msg2), sys.stdout.getvalue().strip())
nt.assert_equal(f.read().strip(), msg2)
def base_logger(self):
""" The base module logger vendor.
:returns: The base module logger vendor
:rtype: pygogo.Gogo
"""
if not hasattr(self, '_base_logger'):
self._base_logger = pygogo.Gogo(
self.module_name,
low_hdlr=logging.handlers.TimedRotatingFileHandler(
filename=os.path.join(
self.log_dir,
('{self.module_name}.log').format(**locals())),
when='midnight'),
low_formatter=pygogo.formatters.structured_formatter,
high_level='info',
high_formatter=pygogo.formatters.fixed_formatter)
return self._base_logger
def test_multiple_loggers(self):
f = StringIO()
going = gogo.Gogo(
"myapp",
low_hdlr=gogo.handlers.fileobj_hdlr(f),
low_formatter=gogo.formatters.fixed_formatter,
high_hdlr=gogo.handlers.stdout_hdlr(),
high_level="info",
high_formatter=gogo.formatters.console_formatter,
)
root = going.logger
logger1 = going.get_logger("area1")
logger2 = going.get_logger("area2")
root.info("Jackdaws love my big sphinx of quartz.")
logger1.debug("Quick zephyrs blow, vexing daft Jim.")
logger1.info("How quickly daft jumping zebras vex.")
logger2.warning("Jail zesty vixen who grabbed pay.")
logger2.error("The five boxing wizards jump quickly.")
console_msg = (
"myapp.base : INFO Jackdaws love my big sphinx of quartz."
"\nmyapp.area1 : INFO How quickly daft jumping zebras vex."
"\nmyapp.area2 : WARNING Jail zesty vixen who grabbed pay."
"\nmyapp.area2 : ERROR The five boxing wizards jump quickly."
)
file_msg = [
"myapp.base INFO Jackdaws love my big sphinx of quartz.\n",
"myapp.area1 DEBUG Quick zephyrs blow, vexing daft Jim.\n",
"myapp.area1 INFO How quickly daft jumping zebras vex.\n",
"myapp.area2 WARNING Jail zesty vixen who grabbed pay.\n",
"myapp.area2 ERROR The five boxing wizards jump quickly.\n",
]
f.seek(0)
nt.assert_equal(console_msg, sys.stdout.getvalue().strip())
nt.assert_equal([line[24:] for line in f], file_msg)
def create_logger(file_path):
"""
Función que crea un logger para realizar las funciones de logging del proceso. La librería utilizada es Pygogo.
:param file_path: ruta del fichero sobre el cual realizar el logging-
:return: objeto logger.
"""
# Se especifica el formato que tendrá el logging.
logging_fmt = '%(asctime)s;%(message)s'
formatter = pygogo.logging.Formatter(logging_fmt,
datefmt=pygogo.formatters.DATEFMT)
# Se especifica el archivo que contendrá el logging
fhdlr = create_file_formatter(file_path)
# Se crea el logger. No se realiza ninguna distinción entre los diferentes niveles de aviso (INFO, WARNING, etc).
# Por ello, se especifica el mismo file handler para el nivel bajo y alto de las alertas.
return pygogo.Gogo(name='',
low_hdlr=fhdlr,
low_formatter=formatter,
high_hdlr=fhdlr,
high_formatter=formatter,
monolog=True).get_logger()
def _logger(log_file_name, log_file_path):
"""
Spins up a logger.
:param log_file_name:[str] logger file name
:param log_file_path:[str] path where log file needs to be created.
:return: A valid logger on success; error message on failure.
"""
try:
if log_file_name is None or log_file_path is None:
raise Exception(
'log_file_name and log_file_path are mandatory to spawn a logger. '
'They cannot be None.')
elif type(log_file_name) is not str or type(
log_file_path) is not str:
raise Exception(
'log_file_name and log_file_path must be of type String.')
else:
dirname = os.path.dirname(log_file_path)
if os.path.exists(dirname):
log_format = '[%(asctime)s] <---> [%(name)s] <---> [%(levelname)s] <---> [%(message)s]'
formatter = logging.Formatter(log_format)
my_logger = gogo.Gogo(
log_file_name,
low_hdlr=gogo.handlers.file_hdlr(log_file_path),
low_formatter=formatter,
high_level='error',
high_formatter=formatter,
).logger
return my_logger
else:
raise Exception(
'Given path does not exist in the system. Please enter valid path. '
'PS: PROTON loggers are in ~/PROTON/trace directory')
except Exception as e:
print('Unable to spawn a logger. Stack Trace to follow.')
print(str(e))
import traceback
import pygogo as gogo
from contextlib import closing
from os.path import splitext
from builtins import *
from six.moves.urllib.request import urlopen
from . import processor
from riko.parsers import xml2etree, etree2dict, xpath, get_abspath
from riko.bado import coroutine, return_value, util, io
from meza._compat import encode
OPTS = {'ftype': 'none'}
logger = gogo.Gogo(__name__, monolog=True).logger
# TODO: convert relative links to absolute
# TODO: remove the closing tag if using an HTML tag stripped of HTML tags
# TODO: clean html with Tidy
@coroutine
def async_parser(_, objconf, skip=False, **kwargs):
""" Asynchronously parses the pipe content
Args:
_ (None): Ignored
objconf (obj): The pipe configuration (an Objectify instance)
skip (bool): Don't parse the content
kwargs (dict): Keyword arguments
