14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
from __future__ import absolute_import
17
19
"""Messages and logging.
19
21
Messages are supplied by callers as a string-formatting template, plus values
113
108
def note(*args, **kwargs):
114
# FIXME note always emits utf-8, regardless of the terminal encoding
109
"""Output a note to the user.
111
Takes the same parameters as logging.info.
116
115
# FIXME: clearing the ui and then going through the abstract logging
117
116
# framework is whack; we should probably have a logging Handler that
118
117
# deals with terminal output if needed.
120
bzrlib.ui.ui_factory.clear_term()
118
ui.ui_factory.clear_term()
121
119
_bzr_logger.info(*args, **kwargs)
124
122
def warning(*args, **kwargs):
126
bzrlib.ui.ui_factory.clear_term()
123
ui.ui_factory.clear_term()
127
124
_bzr_logger.warning(*args, **kwargs)
130
@deprecated_function(deprecated_in((2, 1, 0)))
131
def info(*args, **kwargs):
132
"""Deprecated: use trace.note instead."""
133
note(*args, **kwargs)
136
@deprecated_function(deprecated_in((2, 1, 0)))
137
def log_error(*args, **kwargs):
138
"""Deprecated: use bzrlib.trace.show_error instead"""
139
_bzr_logger.error(*args, **kwargs)
142
@deprecated_function(deprecated_in((2, 1, 0)))
143
def error(*args, **kwargs):
144
"""Deprecated: use bzrlib.trace.show_error instead"""
145
_bzr_logger.error(*args, **kwargs)
148
127
def show_error(*args, **kwargs):
149
128
"""Show an error message to the user.
300
279
logging.getLogger("bzr").
302
281
Output can be redirected away by calling _push_log_file.
283
:return: A memento from push_log_file for restoring the log state.
304
# Do this before we open the log file, so we prevent
305
# get_terminal_encoding() from mutter()ing multiple times
306
term_encoding = osutils.get_terminal_encoding()
307
285
start_time = osutils.format_local_date(_bzr_log_start_time,
308
286
timezone='local')
309
# create encoded wrapper around stderr
310
287
bzr_log_file = _open_bzr_log()
311
288
if bzr_log_file is not None:
312
289
bzr_log_file.write(start_time.encode('utf-8') + '\n')
313
push_log_file(bzr_log_file,
290
memento = push_log_file(bzr_log_file,
314
291
r'[%(process)5d] %(asctime)s.%(msecs)03d %(levelname)s: %(message)s',
315
292
r'%Y-%m-%d %H:%M:%S')
316
293
# after hooking output into bzr_log, we also need to attach a stderr
317
294
# handler, writing only at level info and with encoding
318
writer_factory = codecs.getwriter(term_encoding)
319
encoded_stderr = writer_factory(sys.stderr, errors='replace')
320
stderr_handler = logging.StreamHandler(encoded_stderr)
321
stderr_handler.setLevel(logging.INFO)
295
stderr_handler = EncodedStreamHandler(sys.stderr,
296
osutils.get_terminal_encoding(), 'replace', level=logging.INFO)
322
297
logging.getLogger('bzr').addHandler(stderr_handler)
325
301
def push_log_file(to_file, log_format=None, date_format=None):
328
304
:param to_file: A file-like object to which messages will be sent.
330
306
:returns: A memento that should be passed to _pop_log_file to restore the
331
previously active logging.
307
previously active logging.
333
309
global _trace_file
334
310
# make a new handler
335
new_handler = logging.StreamHandler(to_file)
336
new_handler.setLevel(logging.DEBUG)
311
new_handler = EncodedStreamHandler(to_file, "utf-8", level=logging.DEBUG)
337
312
if log_format is None:
338
313
log_format = '%(levelname)8s %(message)s'
339
314
new_handler.setFormatter(logging.Formatter(log_format, date_format))
361
336
def pop_log_file((magic, old_handlers, new_handler, old_trace_file, new_trace_file)):
362
337
"""Undo changes to logging/tracing done by _push_log_file.
364
This flushes, but does not close the trace file.
339
This flushes, but does not close the trace file (so that anything that was
366
342
Takes the memento returned from _push_log_file."""
367
343
global _trace_file
368
344
_trace_file = old_trace_file
369
345
bzr_logger = logging.getLogger('bzr')
370
346
bzr_logger.removeHandler(new_handler)
371
# must be closed, otherwise logging will try to close it atexit, and the
347
# must be closed, otherwise logging will try to close it at exit, and the
372
348
# file will likely already be closed underneath.
373
349
new_handler.close()
374
350
bzr_logger.handlers = old_handlers
375
new_trace_file.flush()
351
if new_trace_file is not None:
352
new_trace_file.flush()
378
355
def log_exception_quietly():
440
def _dump_memory_usage(err_file):
443
fd, name = tempfile.mkstemp(prefix="bzr_memdump", suffix=".json")
444
dump_file = os.fdopen(fd, 'w')
445
from meliae import scanner
446
scanner.dump_gc_objects(dump_file)
447
err_file.write("Memory dumped to %s\n" % name)
449
err_file.write("Dumping memory requires meliae module.\n")
450
log_exception_quietly()
452
err_file.write("Exception while dumping memory.\n")
453
log_exception_quietly()
455
if dump_file is not None:
461
def _qualified_exception_name(eclass, unqualified_bzrlib_errors=False):
462
"""Give name of error class including module for non-builtin exceptions
464
If `unqualified_bzrlib_errors` is True, errors specific to bzrlib will
465
also omit the module prefix.
467
class_name = eclass.__name__
468
module_name = eclass.__module__
469
if module_name in ("exceptions", "__main__") or (
470
unqualified_bzrlib_errors and module_name == "bzrlib.errors"):
472
return "%s.%s" % (module_name, class_name)
464
475
def report_exception(exc_info, err_file):
465
476
"""Report an exception to err_file (typically stderr) and to .bzr.log.
474
485
print_exception(exc_info, err_file)
475
486
return errors.EXIT_ERROR
476
487
exc_type, exc_object, exc_tb = exc_info
477
if (isinstance(exc_object, IOError)
478
and getattr(exc_object, 'errno', None) == errno.EPIPE):
479
err_file.write("bzr: broken pipe\n")
480
return errors.EXIT_ERROR
481
elif isinstance(exc_object, KeyboardInterrupt):
488
if isinstance(exc_object, KeyboardInterrupt):
482
489
err_file.write("bzr: interrupted\n")
483
490
return errors.EXIT_ERROR
484
491
elif isinstance(exc_object, MemoryError):
485
492
err_file.write("bzr: out of memory\n")
493
if 'mem_dump' in debug.debug_flags:
494
_dump_memory_usage(err_file)
496
err_file.write("Use -Dmem_dump to dump memory to a file.\n")
486
497
return errors.EXIT_ERROR
487
498
elif isinstance(exc_object, ImportError) \
488
499
and str(exc_object).startswith("No module named "):
492
503
elif not getattr(exc_object, 'internal_error', True):
493
504
report_user_error(exc_info, err_file)
494
505
return errors.EXIT_ERROR
495
elif isinstance(exc_object, (OSError, IOError)):
506
elif osutils.is_environment_error(exc_object):
507
if getattr(exc_object, 'errno', None) == errno.EPIPE:
508
err_file.write("bzr: broken pipe\n")
509
return errors.EXIT_ERROR
496
510
# Might be nice to catch all of these and show them as something more
497
511
# specific, but there are too many cases at the moment.
498
512
report_user_error(exc_info, err_file)
547
565
def _flush_trace():
548
# run from atexit hook
566
# called from the bzrlib library finalizer returned by bzrlib.initialize()
549
567
global _trace_file
551
569
_trace_file.flush()
572
class EncodedStreamHandler(logging.Handler):
573
"""Robustly write logging events to a stream using the specified encoding
575
Messages are expected to be formatted to unicode, but UTF-8 byte strings
576
are also accepted. An error during formatting or a str message in another
577
encoding will be quitely noted as an error in the Bazaar log file.
579
The stream is not closed so sys.stdout or sys.stderr may be passed.
582
def __init__(self, stream, encoding=None, errors='strict', level=0):
583
logging.Handler.__init__(self, level)
586
encoding = getattr(stream, "encoding", "ascii")
587
self.encoding = encoding
591
flush = getattr(self.stream, "flush", None)
592
if flush is not None:
595
def emit(self, record):
597
line = self.format(record)
598
if not isinstance(line, unicode):
599
line = line.decode("utf-8")
600
self.stream.write(line.encode(self.encoding, self.errors) + "\n")
602
log_exception_quietly()
603
# Try saving the details that would have been logged in some form
604
msg = args = "<Unformattable>"
606
msg = repr(record.msg).encode("ascii")
607
args = repr(record.args).encode("ascii")
610
# Using mutter() bypasses the logging module and writes directly
611
# to the file so there's no danger of getting into a loop here.
612
mutter("Logging record unformattable: %s %% %s", msg, args)
615
class Config(object):
616
"""Configuration of message tracing in bzrlib.
618
This implements the context manager protocol and should manage any global
619
variables still used. The default config used is DefaultConfig, but
620
embedded uses of bzrlib may wish to use a custom manager.
624
return self # This is bound to the 'as' clause in a with statement.
626
def __exit__(self, exc_type, exc_val, exc_tb):
627
return False # propogate exceptions.
630
class DefaultConfig(Config):
631
"""A default configuration for tracing of messages in bzrlib.
633
This implements the context manager protocol.
637
self._original_filename = _bzr_log_filename
638
self._original_state = enable_default_logging()
639
return self # This is bound to the 'as' clause in a with statement.
641
def __exit__(self, exc_type, exc_val, exc_tb):
642
pop_log_file(self._original_state)
643
global _bzr_log_filename
644
_bzr_log_filename = self._original_filename
645
return False # propogate exceptions.
added
removed
bzrlib/trace.py
