~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/trace.py

• browse files at revision 6591.1.1
• compare with another revision
• download diff
• download tarball
• view history from revision 6591.1.1

• reverse the comparison (6591.1.1 to 6079)
• stop comparing with revision 6079

Show diffs side-by-side

added

removed

bzrlib/trace.py

45

45

form.

46

46

"""

47

47

 

 

48

from __future__ import absolute_import

 

49

 

48

50

# FIXME: Unfortunately it turns out that python's logging module

49

51

# is quite expensive, even when the message is not printed by any handlers.

50

52

# We should perhaps change back to just simply doing it here.

54

56

# increased cost of logging.py is not so bad, and we could standardize on

55

57

# that.

56

58

 

57

 

import codecs

58

59

import logging

59

60

import os

60

61

import sys

111

112

 

112

113

    :return: None

113

114

    """

114

 

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

115

 

    #

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.

195

194

 

196

195

 

197

196

def _get_bzr_log_filename():

198

 

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

 

197

    bzr_log = osutils.path_from_environ('BZR_LOG')

199

198

    if bzr_log:

200

199

        return bzr_log

201

 

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

 

200

    home = osutils.path_from_environ('BZR_HOME')

202

201

    if home is None:

203

 

        if sys.platform == 'win32':

204

 

            from bzrlib import win32utils

205

 

            home = win32utils.get_home_location()

206

 

        else:

207

 

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

 

202

        # GZ 2012-02-01: Logging to the home dir is bad, but XDG is unclear

 

203

        #                over what would be better. On windows, bug 240550

 

204

        #                suggests LOCALAPPDATA be used instead.

 

205

        home = osutils._get_home_dir()

208

206

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

209

207

 

210

208

 

285

283

    """

286

284

    start_time = osutils.format_local_date(_bzr_log_start_time,

287

285

                                           timezone='local')

288

 

    # create encoded wrapper around stderr

289

286

    bzr_log_file = _open_bzr_log()

290

287

    if bzr_log_file is not None:

291

288

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

294

291

        r'%Y-%m-%d %H:%M:%S')

295

292

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

296

293

    # handler, writing only at level info and with encoding

297

 

    term_encoding = osutils.get_terminal_encoding()

298

 

    writer_factory = codecs.getwriter(term_encoding)

299

 

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

300

 

    stderr_handler = logging.StreamHandler(encoded_stderr)

301

 

    stderr_handler.setLevel(logging.INFO)

 

294

    stderr_handler = EncodedStreamHandler(sys.stderr,

 

295

        osutils.get_terminal_encoding(), 'replace', level=logging.INFO)

302

296

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

303

297

    return memento

304

298

 

313

307

    """

314

308

    global _trace_file

315

309

    # make a new handler

316

 

    new_handler = logging.StreamHandler(to_file)

317

 

    new_handler.setLevel(logging.DEBUG)

 

310

    new_handler = EncodedStreamHandler(to_file, "utf-8", level=logging.DEBUG)

318

311

    if log_format is None:

319

312

        log_format = '%(levelname)8s  %(message)s'

320

313

    new_handler.setFormatter(logging.Formatter(log_format, date_format))

491

484

        print_exception(exc_info, err_file)

492

485

        return errors.EXIT_ERROR

493

486

    exc_type, exc_object, exc_tb = exc_info

494

 

    if (isinstance(exc_object, IOError)

495

 

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

496

 

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

497

 

        return errors.EXIT_ERROR

498

 

    elif isinstance(exc_object, KeyboardInterrupt):

 

487

    if isinstance(exc_object, KeyboardInterrupt):

499

488

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

500

489

        return errors.EXIT_ERROR

501

490

    elif isinstance(exc_object, MemoryError):

513

502

    elif not getattr(exc_object, 'internal_error', True):

514

503

        report_user_error(exc_info, err_file)

515

504

        return errors.EXIT_ERROR

516

 

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

517

 

        # GZ 2010-05-20: Like (exc_type is pywintypes.error) but avoid import

518

 

        exc_type.__name__ == "error" and exc_type.__module__ == "pywintypes"):

 

505

    elif osutils.is_environment_error(exc_object):

 

506

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

 

507

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

 

508

            return errors.EXIT_ERROR

519

509

        # Might be nice to catch all of these and show them as something more

520

510

        # specific, but there are too many cases at the moment.

521

511

        report_user_error(exc_info, err_file)

559

549

    try:

560

550

        sys.stdout.flush()

561

551

        sys.stderr.flush()

 

552

    except ValueError, e:

 

553

        # On Windows, I get ValueError calling stdout.flush() on a closed

 

554

        # handle

 

555

        pass

562

556

    except IOError, e:

563

557

        import errno

564

558

        if e.errno in [errno.EINVAL, errno.EPIPE]:

574

568

        _trace_file.flush()

575

569

 

576

570

 

 

571

class EncodedStreamHandler(logging.Handler):

 

572

    """Robustly write logging events to a stream using the specified encoding

 

573

 

 

574

    Messages are expected to be formatted to unicode, but UTF-8 byte strings

 

575

    are also accepted. An error during formatting or a str message in another

 

576

    encoding will be quitely noted as an error in the Bazaar log file.

 

577

 

 

578

    The stream is not closed so sys.stdout or sys.stderr may be passed.

 

579

    """

 

580

 

 

581

    def __init__(self, stream, encoding=None, errors='strict', level=0):

 

582

        logging.Handler.__init__(self, level)

 

583

        self.stream = stream

 

584

        if encoding is None:

 

585

            encoding = getattr(stream, "encoding", "ascii")

 

586

        self.encoding = encoding

 

587

        self.errors = errors

 

588

 

 

589

    def flush(self):

 

590

        flush = getattr(self.stream, "flush", None)

 

591

        if flush is not None:

 

592

            flush()

 

593

 

 

594

    def emit(self, record):

 

595

        try:

 

596

            line = self.format(record)

 

597

            if not isinstance(line, unicode):

 

598

                line = line.decode("utf-8")

 

599

            self.stream.write(line.encode(self.encoding, self.errors) + "\n")

 

600

        except Exception:

 

601

            log_exception_quietly()

 

602

            # Try saving the details that would have been logged in some form

 

603

            msg = args = "<Unformattable>"

 

604

            try:

 

605

                msg = repr(record.msg).encode("ascii")

 

606

                args = repr(record.args).encode("ascii")

 

607

            except Exception:

 

608

                pass

 

609

            # Using mutter() bypasses the logging module and writes directly

 

610

            # to the file so there's no danger of getting into a loop here.

 

611

            mutter("Logging record unformattable: %s %% %s", msg, args)

 

612

 

 

613

 

577

614

class Config(object):

578

615

    """Configuration of message tracing in bzrlib.

579

616

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1