/brz/remove-bazaar

# Copyright (C) 2005-2010 Canonical Ltd

They can be sent to two places: to stderr, and to ~/.bzr.log.  For purposes

~/.bzr.log gets all messages, and full tracebacks for uncaught exceptions.

import codecs

from bzrlib.lazy_import import lazy_import

from cStringIO import StringIO

import errno

import locale

import bzrlib

 

from bzrlib.symbol_versioning import (

    deprecated_function,

    deprecated_in,

    )

from bzrlib import (

    plugin,

    symbol_versioning,

 

# global verbosity for bzrlib; controls the log level for stderr; 0=normal; <0

# Absolute path for ~/.bzr.log.  Not changed even if the log/trace output is

_bzr_log_filename = None

_bzr_log_start_time = bzrlib._start_time

_bzr_logger = logging.getLogger('bzr')

    # FIXME note always emits utf-8, regardless of the terminal encoding

    #

    import bzrlib.ui

    bzrlib.ui.ui_factory.clear_term()

    _bzr_logger.info(*args, **kwargs)

    import bzrlib.ui

    bzrlib.ui.ui_factory.clear_term()

    _bzr_logger.warning(*args, **kwargs)

 

 

@deprecated_function(deprecated_in((2, 1, 0)))

def info(*args, **kwargs):

    """Deprecated: use trace.note instead."""

    note(*args, **kwargs)

 

 

@deprecated_function(deprecated_in((2, 1, 0)))

def log_error(*args, **kwargs):

    """Deprecated: use bzrlib.trace.show_error instead"""

    _bzr_logger.error(*args, **kwargs)

 

 

@deprecated_function(deprecated_in((2, 1, 0)))

def error(*args, **kwargs):

    """Deprecated: use bzrlib.trace.show_error instead"""

    _bzr_logger.error(*args, **kwargs)

    _bzr_logger.error(*args, **kwargs)

    if isinstance(fmt, unicode):

        fmt = fmt.encode('utf8')

    if len(args) > 0:

        # It seems that if we do ascii % (unicode, ascii) we can

        # get a unicode cannot encode ascii error, so make sure that "fmt"

        # is a unicode string

        real_args = []

        for arg in args:

            if isinstance(arg, unicode):

                arg = arg.encode('utf8')

            real_args.append(arg)

        out = fmt % tuple(real_args)

    timestamp = '%0.3f  ' % (now - _bzr_log_start_time,)

    out = timestamp + out + '\n'

    _trace_file.write(out)

def _get_bzr_log_filename():

    bzr_log = os.environ.get('BZR_LOG')

    if bzr_log:

        return bzr_log

    home = os.environ.get('BZR_HOME')

        if sys.platform == 'win32':

            from bzrlib import win32utils

            home = win32utils.get_home_location()

        else:

            home = os.path.expanduser('~')

    return os.path.join(home, '.bzr.log')

 

 

def _open_bzr_log():

    """Open the .bzr.log trace file.

    .bzr.log.old and a new file is started.  Otherwise, we append to the

    This sets the global _bzr_log_filename.

    global _bzr_log_filename

            except OSError, e:

                fd = os.open(filename, flags | os.O_CREAT | os.O_EXCL, 0666)

            except OSError, e:

        return os.fdopen(fd, 'at', 0) # unbuffered

 

 

    _bzr_log_filename = _get_bzr_log_filename()

    _rollover_trace_maybe(_bzr_log_filename)

        bzr_log_file = _open_or_create_log_file(_bzr_log_filename)

        bzr_log_file.write('\n')

        if bzr_log_file.tell() <= 2:

            bzr_log_file.write("this is a debug log for diagnosing/reporting problems in bzr\n")

            bzr_log_file.write("you can delete or truncate this file, or include sections in\n")

            bzr_log_file.write("bug reports to https://bugs.launchpad.net/bzr/+filebug\n\n")

 

        return bzr_log_file

 

    except EnvironmentError, e:

        # handlers registered for "bzr"' when something goes wrong on the

    """Configure default logging: messages to stderr and debug to .bzr.log

    Non-command-line programs embedding bzrlib do not need to call this.  They

    logging.getLogger("bzr").

    # Do this before we open the log file, so we prevent

    # get_terminal_encoding() from mutter()ing multiple times

    term_encoding = osutils.get_terminal_encoding()

    start_time = osutils.format_local_date(_bzr_log_start_time,

    # create encoded wrapper around stderr

    bzr_log_file = _open_bzr_log()

    if bzr_log_file is not None:

        bzr_log_file.write(start_time.encode('utf-8') + '\n')

    push_log_file(bzr_log_file,

    # after hooking output into bzr_log, we also need to attach a stderr

    writer_factory = codecs.getwriter(term_encoding)

    encoded_stderr = writer_factory(sys.stderr, errors='replace')

    stderr_handler = logging.StreamHandler(encoded_stderr)

    stderr_handler.setLevel(logging.INFO)

    logging.getLogger('bzr').addHandler(stderr_handler)

    previously active logging.

    new_handler = logging.StreamHandler(to_file)

    new_handler.setLevel(logging.DEBUG)

    bzr_logger = logging.getLogger('bzr')

    old_handlers = bzr_logger.handlers[:]

    del bzr_logger.handlers[:]

    bzr_logger.addHandler(new_handler)

    bzr_logger.setLevel(logging.DEBUG)

    # TODO: also probably need to save and restore the level on bzr_logger.

    result = new_handler, _trace_file

def pop_log_file((magic, old_handlers, new_handler, old_trace_file, new_trace_file)):

    This flushes, but does not close the trace file.

    bzr_logger = logging.getLogger('bzr')

    bzr_logger.removeHandler(new_handler)

    # must be closed, otherwise logging will try to close it atexit, and the

    bzr_logger.handlers = old_handlers

    new_trace_file.flush()

        _bzr_logger.setLevel(logging.WARNING)

        _bzr_logger.setLevel(logging.INFO)

        from bzrlib import win32utils

        status_file = file('/proc/%s/status' % os.getpid(), 'rb')

    """Report an exception to err_file (typically stderr) and to .bzr.log.

    # Log the full traceback to ~/.bzr.log

    if (isinstance(exc_object, IOError)

        and getattr(exc_object, 'errno', None) == errno.EPIPE):

        err_file.write("bzr: broken pipe\n")

        return errors.EXIT_ERROR

    elif isinstance(exc_object, KeyboardInterrupt):

        err_file.write("bzr: interrupted\n")

        err_file.write("bzr: out of memory\n")

        and str(exc_object).startswith("No module named "):

        report_user_error(exc_info, err_file,

    elif isinstance(exc_object, (OSError, IOError)):

    err_file.write("bzr: ERROR: %s.%s: %s\n" % (

        exc_type.__module__, exc_type.__name__, exc_object))

    err_file.write("bzr: ERROR: %s\n" % (exc_info[1],))

        err_file.write("%s\n" % (advice,))

    """Report an exception that probably indicates a bug in bzr"""

    from bzrlib.crash import report_bug

    # installed into an atexit hook by bzrlib.initialize()

    except IOError, e:

    # run from atexit hook