Replacing Trac with a different bug tracker

Author:David Cournapeau, Stefan van der Walt

Some release managers of both numpy and scipy are becoming more and more disatisfied with the current development workflow, in particular for bug tracking. This document is a tentative to explain some problematic scenario, current trac limitations, and what can be done about it.

Scenario

new release

The workflow for a release is roughly as follows:

• find all known regressions from last release, and fix them
• get an idea of all bugs reported since last release
• triage bugs in regressions/blocker issues/etc..., and assign them in the according roadmap, subpackage and maintainers
• pinging subpackage maintainers

Most of those tasks are quite inefficient in the current trac as used on scipy:

• it is hard to keep track of issues. In particular, everytime one goes to trac, we don’t really know what’s new from what’s not. If you think of issues as emails, the current situation would be like not having read/unread feature.
• Batch handling of issues: changing characteristics of several issues at the same time is difficult, because the only available UI is web-based. Command-line based UI are much more efficient for this kind of scenario

More generally, making useful reports is very awkward with the currently deployed trac. Trac 0.11 may solve of those problems, but it has to be much better than the actually deployed version on scipy website. Finding issues with patches, old patches, etc... and making reports has to be much more streamlined that it is now.

subcomponent maintainer

Say you are the maintainer of scipy.foo, then you are mostly interested in getting bugs concerning scipy.foo only. But it should be easy for the general team to follow your work - it should also be easy for casual users (e.g. not developers) to follow some new features development pace.

Review, newcoming code

The goal is simple: make the bar as low as possible, and make sure people know what to do at every step to contribute to numpy or scipy:

• Right now, patches languish for too long in trac. Of course, lack of time is one big reason; but the process of following new contributes could be made much simpler
• It should be possible to be pinged only for reviews one a subset of numpy/scipy.
• It should be possible for people interested in the patches to follow its progression. Comments, but also ‘mini’ timelines could be useful, particularly for massive issues (massive from a coding POV).

Current trac limitation

Note: by trac, we mean the currently deployed one. Some more recent versions may solve some of the issues.

• Multi-project support: we have three trac instances, one for scipy, one for numpy, one for scikits. Creating accounts, maintaining and updating each of them is a maintainance burden. Nobody likes to do this kind of work, so anything which can reduce the burden is a plus. Also, it happens quite frequently that a bug against numpy is filled on scipy trac and vice and versa. You have to handle this manually, currently.
• Clients not based on the web-ui. This can be made through the xmlrpc plugin + some clients. In particular, something like http://tracexplorer.devjavu.com/ can be interesting for people who like IDE. At least one person expressed his desire to have as much integration as possible with Eclipse.
• Powerful queries: it should be possible to quickly find issues between two releases, the new issues from a given date, issues with patch, issues waiting for reviews, etc... The issues data have to be customizable, because most bug-tracker do not support things like review, etc... so we need to handle this ourselves (through tags, etc...)
• Marking issues as read/unread. It should also be possible for any user to ‘mask’ issues to ignore them.
• ticket dependency. This is quite helpful in my experience for big features which can be split into several issues. Roadmap can only be created by trac admin, and they are kind of heavy-weight.

Possible candidates

Updated trac + plugins

Pros:

• Same system
• In python, so we can hack it if we want

Cons:

• Trac is aimed at being basic, and extended with plugins. But most plugins are broken, or not up to date. The information on which plugins are mature is not easily available.
• At least the scipy.org trac was slow, and needed to be restarted constantly. This is simply not acceptable.

Redmine

Pros:

• Support most features (except xmlrpc ?). Multi-project, etc...
• (subjective): I (cdavid) find the out-of-the-box experience with redmine much more enjoyable. More informations are available easily, less clicks, more streamlined. See http://www.redmine.org/wiki/redmine/TheyAreUsingRedmine for examples
• Conversion scripts from trac (no experience with it yet for numpy/scipy).
• Community seems friendly and gets a lof of features done

Cons:

• new system, less mature ?
• in Ruby: since we are a python project, most of dev are familiar with python.
• Wiki integration, etc... ?

Unknown:

• xmlrpc API
• performances
• maintenance cost

Roundup

TODO