Commits

Searching for commits

Mercurial supports a functional language for selecting a set of
revisions.

The language supports a number of predicates which are joined by
infix operators. Parenthesis can be used for grouping.

Identifiers such as branch names must be quoted with single
or double quotes if they contain characters outside of
[._a-zA-Z0-9\x80-\xff] or if they match one of the
predefined predicates.

Prefix operators

not x

Changesets not in x. Short form is ! x.

Infix operators

x::y

A DAG range, meaning all changesets that are descendants
of x and ancestors of y, including x and y themselves.
If the first endpoint is left out, this is equivalent to
ancestors(y), if the second is left out it
is equivalent to descendants(x).

An alternative syntax is x..y.

x:y

All changesets with revision numbers between x and y, both
inclusive. Either endpoint can be left out, they default to
0 and tip.

x and y

The intersection of changesets in x and y. Short form is
x & y.

x or y

The union of changesets in x and y. There are two alternative
short forms: x | y and x + y.

x - y

Changesets in x but not in y.

Predicates

all()

All changesets, the same as 0:tip.

ancestor(single, single)

Greatest common ancestor of the two changesets.

ancestors(set)

Changesets that are ancestors of a changeset in set.

author(string)

Alias for user(string).

bookmark([name])

The named bookmark or all bookmarks.

branch(set)

All changesets belonging to the branches of changesets in set.

children(set)

Child changesets of changesets in set.

closed()

Changeset is closed.

date(interval)

Changesets within the interval, see hg help dates.

descendants(set)

Changesets which are descendants of changesets in set.

file(pattern)

Changesets affecting files matched by pattern.

follow()

An alias for ::. (ancestors of the working copy's
first parent).

grep(regex)

Like keyword(string) but accepts a regex. Use
grep(r'...') to ensure special escape characters
are handled correctly.

Bugfix: logview was unreasonably slow in the presence of may log messages.
Turns out the slowdown was in re.sub() with a long replacement string; I
rewrote the code to use re.split() instead and now it's fast.

Make it possible to specify cutoff point for culling dot graph nodes.
Dozer writes the call graph to a file for each request, in Graphviz .dot
format. That graph isn't complete; by default all functions that take less
than 0.2 ms to run are hidden. This change makes that cutoff point
configurable, e.g. like this in a PasteDeploy .ini file:
[filter:profiler]
use = egg:Dozer#profile
profile_dir = ./profiles/
dot_graph_cutoff = 0.2

Coloring for tracebacks; somewhat hacky.
Uses the same syntax as log coloring:
traceback.pattern = #rrggbb
The intent was to match filename patterns, maybe function names too. The
implementation matches arbitrary substrings in the whole
File "filename", line 42, in funcname
line of source code
littany, so be careful.

New settings: keep_tracebacks_limit (default to 20), skip_last_n_frames.
The first setting is needed because extracting and rendering every traceback
makes things unbearably slow if there are a lot of log messages. To clarify
"unbearably": a request with ~500 logging calls takes 1 second. Without
a traceback limit it took more than 10 minutes, at which point I gave up
and killed the server process. With the traceback limit it once again took
about 1 second.
The sec…

Accept colors from local config too.
Makes this work:
[filter-app:logview]
egg = Dozer#logview
logview.sqlalchemy = #faa
(Previously you had to put the color config into [DEFAULT], if I understand
things correctly.)

Stick the thread id into the environment.
It's useful to see if two requests were processed by the same thread or not.
I'm not very happy about abusing the environment thus, but I'm not sure where
else to stick it.