This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5785

blackbox: take regex patterns for blackbox.track
AbandonedPublic

Authored by spectral on Jan 31 2019, 5:07 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

spectral created this revision.Jan 31 2019, 5:07 PM
spectral updated this revision to Diff 13658.Jan 31 2019, 5:23 PM
yuja added a subscriber: yuja.Feb 1 2019, 8:19 AM

+ track = ui.configlist('blackbox', 'track')
+ if not track:
+ self._active = False
+ elif b'*' in track:
+ self._trackedevents = re.compile(b'.*')
+ else:
+ try:
+ self._trackedevents = re.compile(b'|'.join(track))
+ except re.error as e:
+ ui.warn('invalid blackbox.track setting: %s\n' % e)
+ self._active = False

Can't we process the pattern as a glob? It's compatible with * and much
easier to write. Or do you need the power of the regexp?

spectral planned changes to this revision.Feb 4 2019, 3:42 PM
In D5785#84935, @yuja wrote:

Can't we process the pattern as a glob? It's compatible with * and much
easier to write. Or do you need the power of the regexp?

I generally prefer regex, but I might be an outlier. We do not need the power of regexp, especially if we get a negative filter (next commit), so I'll do that (eventually). Marking as "plan changes" for now...

spectral abandoned this revision.Aug 26 2019, 1:19 PM

https://www.mercurial-scm.org/repo/hg/rev/56132ebd14c6 Added blackbox.ignore, which is probably sufficient.

Revision Contents
Changeset List

PathPackages
Mhgext/blackbox.py (27 lines)
Mtests/test-blackbox.t (17 lines)

Diff 13658

hgext/blackbox.py

# blackbox.py - log repository events to a file for post-mortem debugging # blackbox.py - log repository events to a file for post-mortem debugging
# #
# Copyright 2010 Nicolas Dumazet # Copyright 2010 Nicolas Dumazet
# Copyright 2013 Facebook, Inc. # Copyright 2013 Facebook, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
"""log repository events to a blackbox for debugging """log repository events to a blackbox for debugging
Logs event information to .hg/blackbox.log to help debug and diagnose problems. Logs event information to .hg/blackbox.log to help debug and diagnose problems.
The events that get logged can be configured via the blackbox.track config key.
The events that get logged can be configured via the blackbox.track config key;
this takes a list of regular expressions. As a special rule, if any item in the
list is the string '*', everything is logged (default: '*').
Examples:: Examples::
[blackbox] [blackbox]
# log everything
track = * track = *
# dirty is *EXPENSIVE* (slow); # dirty is *EXPENSIVE* (slow);
# each log entry indicates `+` if the repository is dirty, like :hg:`id`. # each log entry indicates `+` if the repository is dirty, like :hg:`id`.
dirty = True dirty = True
# record the source of log messages # record the source of log messages
logsource = True logsource = True
[blackbox] [blackbox]
track = command, commandfinish, commandexception, exthook, pythonhook # log every event starting with 'command' (including 'command' itself), and
# everything ending with 'hook' (including 'hook' itself).
track = command.*, .*hook
[blackbox] [blackbox]
track = incoming track = incoming
[blackbox] [blackbox]
# limit the size of a log file # limit the size of a log file
maxsize = 1.5 MB maxsize = 1.5 MB
# rotate up to N log files when the current one gets too big # rotate up to N log files when the current one gets too big
default='%Y/%m/%d %H:%M:%S', default='%Y/%m/%d %H:%M:%S',
) )
_lastlogger = loggingutil.proxylogger() _lastlogger = loggingutil.proxylogger()
class blackboxlogger(object): class blackboxlogger(object):
def __init__(self, ui, repo): def __init__(self, ui, repo):
self._repo = repo self._repo = repo
self._trackedevents = set(ui.configlist('blackbox', 'track')) self._active = True
track = ui.configlist('blackbox', 'track')
if not track:
self._active = False
elif b'*' in track:
self._trackedevents = re.compile(b'.*')
else:
try:
self._trackedevents = re.compile(b'|'.join(track))
except re.error as e:
ui.warn(_('invalid blackbox.track setting: %s\n') % e)
self._active = False
self._maxfiles = ui.configint('blackbox', 'maxfiles') self._maxfiles = ui.configint('blackbox', 'maxfiles')
self._maxsize = ui.configbytes('blackbox', 'maxsize') self._maxsize = ui.configbytes('blackbox', 'maxsize')
self._inlog = False self._inlog = False
def tracked(self, event): def tracked(self, event):
return b'*' in self._trackedevents or event in self._trackedevents return self._active and self._trackedevents.match(event)
def log(self, ui, event, msg, opts): def log(self, ui, event, msg, opts):
# self._log() -> ctx.dirty() may create new subrepo instance, which # self._log() -> ctx.dirty() may create new subrepo instance, which
# ui is derived from baseui. So the recursion guard in ui.log() # ui is derived from baseui. So the recursion guard in ui.log()
# doesn't work as it's local to the ui instance. # doesn't work as it's local to the ui instance.
if self._inlog: if self._inlog:
return return
self._inlog = True self._inlog = True
fmt = '%s %s @%s%s (%s)%s> %s' fmt = '%s %s @%s%s (%s)%s> %s'
args = (date, user, rev, changed, pid, src, msg) args = (date, user, rev, changed, pid, src, msg)
with loggingutil.openlogfile( with loggingutil.openlogfile(
ui, self._repo.vfs, name='blackbox.log', ui, self._repo.vfs, name='blackbox.log',
maxfiles=self._maxfiles, maxsize=self._maxsize) as fp: maxfiles=self._maxfiles, maxsize=self._maxsize) as fp:
fp.write(fmt % args) fp.write(fmt % args)
except (IOError, OSError) as err: except (IOError, OSError) as err:
# deactivate this to avoid failed logging again # deactivate this to avoid failed logging again
self._trackedevents.clear() self._active = False
ui.debug('warning: cannot write to blackbox.log: %s\n' % ui.debug('warning: cannot write to blackbox.log: %s\n' %
encoding.strtolocal(err.strerror)) encoding.strtolocal(err.strerror))
return return
_lastlogger.logger = self _lastlogger.logger = self
def uipopulate(ui): def uipopulate(ui):
ui.setlogger(b'blackbox', _lastlogger) ui.setlogger(b'blackbox', _lastlogger)

tests/test-blackbox.t

> blackbox= > blackbox=
> mock=$TESTDIR/mockblackbox.py > mock=$TESTDIR/mockblackbox.py
> mq= > mq=
> myextension=$TESTTMP/myextension.py > myextension=$TESTTMP/myextension.py
> [alias] > [alias]
> confuse = log --limit 3 > confuse = log --limit 3
> so-confusing = confuse --style compact > so-confusing = confuse --style compact
> [blackbox] > [blackbox]
> track = backupbundle, branchcache, command, commandalias, commandexception, > track = backupbundle, branchcache, command.*,
> commandfinish, debug, exthook, incoming, pythonhook, tagscache > debug, exthook, incoming, pythonhook, tagscache
> EOF > EOF
$ hg init blackboxtest $ hg init blackboxtest
$ cd blackboxtest $ cd blackboxtest
command, exit codes, and duration command, exit codes, and duration
$ echo a > a $ echo a > a
> EOF > EOF
(only look for entries with specific logged sources, otherwise this test is (only look for entries with specific logged sources, otherwise this test is
pretty brittle) pretty brittle)
$ hg blackbox | egrep '\[command(finish)?\]' $ hg blackbox | egrep '\[command(finish)?\]'
1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000) [commandfinish]> --config 'blackbox.track=*' --config 'blackbox.logsource=True' init track_star exited 0 after * seconds (glob) 1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000) [commandfinish]> --config 'blackbox.track=*' --config 'blackbox.logsource=True' init track_star exited 0 after * seconds (glob)
1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000) [command]> blackbox 1970/01/01 00:00:00 bob @0000000000000000000000000000000000000000 (5000) [command]> blackbox
$ cd $TESTTMP $ cd $TESTTMP
invalid regex entries in blackbox.track are interpreted as log nothing
$ hg --config blackbox.track='**' init track_invalid_regex
invalid blackbox.track setting: nothing to repeat
$ cd track_invalid_regex
$ cat >> .hg/hgrc << EOF
> [blackbox]
> track = **
> EOF
$ hg blackbox
invalid blackbox.track setting: nothing to repeat
$ cd $TESTTMP
#if chg #if chg
when using chg, blackbox.log should get rotated correctly when using chg, blackbox.log should get rotated correctly
$ cat > $TESTTMP/noop.py << EOF $ cat > $TESTTMP/noop.py << EOF
> from __future__ import absolute_import > from __future__ import absolute_import
> import time > import time
> from mercurial import registrar, scmutil > from mercurial import registrar, scmutil