I'm currently looking at Bugzilla and Trac, as they seem to be the most popular (and I'm hoping that also means if there are any problems, it will be easier to get help), but I'm curious what solutions you use or have used and what your thoughts are.
I'm currently leaning toward Trac, as it's Wiki functionality can be used to support documentation. But that might not be a good enough reason to jump on Trac.
Our company uses Atlassian JIRA, and it has nice features like integration with CruiseControl, task calendars, etc aside from its excellent bug tracking system.
Footprints by Numera - not a big fan.
At a previous employer, FogBugz. I absolutely loved it.
We use Trac but I wouldn't say its wiki is a deciding factor. In fact we use MediaWiki instead of Trac's wiki due to it not being easy to use in my opinion.
Aside from the wiki I don't know how we did development without it. Browsing the source and the timeline are huge features that make development easier. Also the ease of looking at previous versions and seeing exactly what was changed and by whom is great.
I don't think you can go wrong with picking Trac.
We have a set of users that requires ease of use in order to gain their participation. I know, it's a situation that is less than ideal; however, management lets it occur. To that end we transitioned to using BugNET
The feature set is basic, but it has everything we need. The integration with Active Directory and its ease of use at least meets the requirements by the problem group.
We use OnTime, it's not great but I haven't used a ton of others so I can't really say.
We use Team Foundation Server at work, but at home I use Bugzilla.
I use FogBugz. Check the site out for all the features, but the most notable ones, besides the bug/feature tracking feature, are:
Picking really boils down to features, then money, and etc. Some people prefer it the other way around. I don't mind paying for something as long as it isn't too expensive and how bad I can live without certain features.
At my previous company we used OnTime - I was a bit surprised that it lacked what I considered basic functionality. We looked at fogbugz but never when further than that. Currently use Mercury and really don't like it because the browser interface crashes my browser each time I use it. We have TFS but don't use it for bug tracking - don't know why.
We used trac for a while, but it has rather simple functionality and we're looking to replace it. I think it's only usable when you have a small group of developers and a single project.
It was two years ago and here's a few things that were not good about it:
I had positive experience with using bugzilla, although it has quite scary interface.
As a bug reporter (and not as a developer), I have found Trac really annoying to use. Is it possible for you to use SourceForge or Launchpad?
We use DevTrack, by TechExcel. They have a good 'small business' pricing model and have all of the customizability of the largest systems out there. It does have waaay more features than we use, but does allow us the customizability that we wanted at a price our startup (12 full timers) could afford.
I've also used Jira. Jira was a pleasure to use. It's not as customizable and, given our small size, was too expensive to use where I am now.
Bugzilla may have improved, but the last time I looked at it (3 or more years ago) it was really difficult to install. Also, I've never liked the Bugzilla search interface (but that may have more to do with sifting through Mozilla's mountains of bug data).
I work with @RedWolves and second his recommendation of TRAC. It has great integration with SVN. My favorite feature is all the RSS feeds it provides. I can subscribe directly to the Timeline view and easily keep track of all changesets, new bugs, and wiki edits.
With my work with clients I've also used Bugzilla, TeamTrack, and Task Tracker. All three do a decent job, but I still prefer TRAC due to its built-in source control integration.
We use StarTeam, which we also use for our source control. I wish we could switch, but management decided they liked some of the time-tracking features of StarTeam, so that's what we went with.
At our place we use Quality Center. Well actually our test team uses it but it has the facility to manage test cases, test scripts, assign defects etc and seems to be very comprehensive.
Of course as developers we shadow any Defects with TFS work items!
We use Mantis. (Free, open source) OK I guess, but nothing special...
We use Bugzilla. I've installed and upgraded it many times, so I guess I'm over the administration learning curve. We find it quite adequate for the needs of our small-ish team (10-15 devs). I haven't attempted any integration with our source control system (svn), so I can't comment on that.
If you're on a Windows/IIS server and looking for a free solution, BugTracker.NET is very simple, quick, and easy to use. It integrates with Subversion (though not as tightly as Trac does) and is very customizable.
Trac is great for small teams and/or projects. It just isn't meant for handling multiple projects or clients.
We tried FogBugz but the somewhat slow interface and "Windows-y" feel was a turn-off for some people. (I tried my best to make it stick, but we ended up using Fog Creek's money back guarantee.)
We use Bugzilla for our team of 10 devs. It works well for us and we've been through several major upgrades, all without any problems (we currently version 3.x). We haven't done any integration with our source system (Subversion). It has worked well for us.
I'm ashamed to admit it but powerless to change it (well not entirely powerless, I could find a different job): My current employer uses an 8 year old version of TestTrack from Seapine Software. Its horrible and next to useless compared to any modern tool. Supposedly we are upgrading to Team Foundation Server "next month" but they have been saying that for almost 2 years now.
Fogbugz. Great Simple and with features you really need.
Check out the huge plugin community at edgewall and trac-hacks.org. It seems that a lot of development happens at trac-hacks and some of it is folded into the mainline, but most isn't.
I had positive experience with using bugzilla, although it has quite scary interface.
I had a very negative experience with bugzilla, primarily because of the unusable interface..
That said, I think the size, skill-level and discipline of your group are very important factors..
Trac is great for smaller groups of higher skills, that can appreciate stuff like linking file+version+line in tickets, tickets in checkins, &c, &c.
It's probably horribly bad for groups where the lack of ACL on wiki pages is a problem.
We use Bugzilla. We always thought it was bad, and we evaluated a number of other bug tracking software products. In the end, ultimately they had approximately the same features, so we stuck with Bugzilla.
Here's another FogBugz user. I bought it for myself for my side-programming work and eventually brought it into my full-time job.
One of my favorite FogBugz features is the BugzScout which lets you programmatically submit bugs from your code.
All of my PHP pages use
set_exception_handler
so that exceptions get routed to a nice little form (which I stole from FogBugz itself) that shows an error message and submits the exception details to FogBugz.
We use StarTeam for both bug tracking and source code management. Has its quirks but not too bad.
We switched from Bugzilla to Trac. Trac has very nice integration with SVN and wiki. But trac is bit light with featured related to project management. Trac has been okey so far for a small team of about 3-5 persons.
If you are looking for a robust enterprise solution, I'd recommend Atlassian Jira. It's pricey, but they offer free licenses to open-source projects.
I've always found Mantis kind of claustrophobic with its layout and billion different fields.
If you are looking for something very simple and easy-to-use, Lighthouse might be the way to go. It doesn't have all the bells and whistles of the other apps, but I enjoy its simplicity.
We use JIRA, in association with another product from the same company, FishEye. This combination lets us log jobs, resolve them, and most importantly, link the job with the SVN commit that fixed it. This makes tracking down bugs really simple, as you can look at the code, and not just find out who made some change, but why. If some code looks off, you can quickly see whether it was an odd-ball customer request, or a mistake.
JIRA, and BugZilla.
(they are actually the only 2 I have ever used - well maybe bumped into trac from time to time when logging a bug on some ruby library or something).
I've used Trac, and like what others have said, the interface is rather annoying to use. It is great since it is free, but the issue/case tracking section is not that nice on the eyes personally and it acts as a barrier for me to use it.
Also it can't really handle multiple projects at a time, which is a big deal breaker for many.
We use FogBugz which is licensed per user. They offer the option of having it hosted by FogCreek or installed on your own server. We have it installed locally on an IIS server connected to SQL Server database secured and managed in a corporate data center at a remote site. Overall, the system works great, and while the user licensing and support costs have increased for new users in recent years, it is still a great value.
We Started off on version 5.x and really liked the system, found it to be very robust and simple to use. A major philosophy of the system is to make it simple to capture/enter bugs and to keep bugs owned by a specific person who is expected to act on it next.
We recently upgraded to the 6.x system that has a whole new interface graphic design. Still getting used to the changes of the layout of things, but certainly like some of the new reporting and search/lookup features that seemed to be missing in the previous versions. I would say the new version is overall improved over 5.x, but I am not so sure the layout is quite as visually clean as the previous version - visually it seems to be a bit harder to find fields. Not sure this is because of familiarity with previous version or if the older was really better in this regard. Would be curious what other users think....
In any case, definately recommend the system as easy to buy, easy to install, easy to use, a good value, easy to upgrade, and very well supported by FogCreek.
Bugzilla version rc3.0.3 integrated with CVS. Now we intend to integrate also with our wiki. We've been using it over 4 years. At the begining, some of the business analysts became a bit resistent. Now we developers and BAs can't live without this tool. Very simple and useful.
We use Trac combined with Subversion and Eclipse Mylyn. Mylyn itself can be used with many of the other bugtrackers that were mentioned before. It's really great when you do development work with Eclipse as you can switch between different tickets fast and all your context (esp. open files) is restored, you get links to tickets in your commit messages automatically etc.
We also use the Trac wiki extensively to document ideas, concepts and track the status of milestones on the roadmap. The possibility to link to almost anything is a feature that I personally wouldn't like to live without anymore. You can describe the current state of your project including change logs with links to the tickets that were fixed in the different versions etc.
However, when you decide for Trac, you should be prepared for some configuration work that needs to be done. Check out trac-hacks for extending the functionality of the base installation.
Another Jira user here, though in the past we have used and liked fogbugz and version one.
We use Mercury Test Director. It's not horrible, but I would not recommend it to anyone. It's expensive (per user licensing) and has a high PITA factor. It's also a UI/macro test suite, so it's weakness if probably due to covering too much ground.
I've seen a couple of responses from people who do not like OnTime or think it lacks in features (but without specifics).
What specifically do you not like?
I've got the free single user version running at home with both desktop app and web versions running, and I've also been playing around with the Web SDK. To me, it is pretty easy to use, and seems to have all of the functionality I would want.
We use Mantis as well and I would say that it's solid but is certainly not on the bleeding edge of web application technology. We are being mandated to switch over to Quality Center which, I have to say, is absolutely awful. Expensive, very difficult to use and slow. It has a long feature list but what good are features when they are so very difficult to use. Not to mention that although the makers might consider it a web-based application it's actually entirely ActiveX-driven and therefore only usable with an IE-based browser. I really can't say enough bad things about that product.
We also use trac / subversion and Mylyn my blog has info on how to install SVN & Trac on Windows as some people found this quite hard to get their heads round.
With the timing and estimation plugin you can keep track of where you project is at, also you have the ability (without the plugin too) to update tickets from the commit message, and thus giving you a circular reference between code and tickets another must is master tickets so that you can have 1 larger job and split it down, then as you reference tickets correctly and link them it can help with impact analysis when you need to modify the code base etc.
We use OnTime, but our team prefers to call it Late. It's dog slow and cumbersome to use.
The best issue tracker that I've worked with so far is Jira.
Currently, Rational ClearQuest through Citrix. Layers and layers....
As a user, it was cumbersome at first. After using it for ~3 years I've gotten extremely fast with the shortcuts.
We use Numara FootPrints. Our organization has a lot of teams doing very different things, and the multiple configurations Footprints allows seems to help fulfill some of the teams needs. This 'silver bullet' approach leaves a lot to be desired though, and so for sw development, we're going to switch.
FogBugz and Bugzilla are leading the pack, and we'll probably go with FogBugz.
Instead of trying to map our processes to take advantage of every feature a tool might have (which results in a footprints ticket with over 100 fields on the screen!), we've tried reducing the process to the bare minimum to encourage use.
Fogbugz has the simplest interface by far, and the trainable email submission and semantic linking are great features we're excited to use.
We are a custom software development company ... so we figured "we'd eat our own dogfood" and wrote our own.
Based on reading this blog post http://stevenf.com/archive/bug-tracking.php by Steven Frank of Panic fame I decided to try out Redmine as our development bug tracker/project management tool.
Here is a quick quote about the project from their website:
Redmine is a flexible project management web application. Written using Ruby on Rails framework, it is cross-platform and cross-database.
Redmine is open source and released under the terms of the GNU General Public License v2 (GPL).
Feature Overview
I have also used FogBugz and I recommend it using it if you are in a position to pay for a bug tracker. FogBugz works really well and is very simple to you. It is even pretty simple to setup.
We used to use Trac, but it was crap - we then switched to an inhouse system.
Trac is still around for it's SVN timeline, but we're considering swapping that out for warehouse
I did an extensive analysis of bug tracking/project management tools around Dec 2007/Jan 2008. It came down to FogBugz (paid), or Trac (free). For our needs, FogBugz won because of:
Where Trac excelled was in the wiki. I'm sorry to say, but FB's wiki leaves a lot to be desired, especially the relationship between cases and wiki articles. I'd love to be able to have a case open for a new feature, have the spec be in the wiki, and easily link from the case to the wiki and vice versa. And then open bugs regarding the feature would be linked to the wiki as well.
Trac also had very good roadmap management. Our CEO was pushing me toward Trac because of the Roadmap feature, but I convinced him to let us use a 30 day trial of FB, and setup a filter named "Roadmap", and that pretty much settled it.
I'd suggest you go with one of these two products, depending on your needs.
Gemini is currently my favourite. It is simple, fast and well designed.
Mingle is also nice but there were a few design issues that annoyed me, and deployment is an issue.
If there isn't already enough info in the answers here, then here are some more bug tracker comparisions.
That page contains links to similar discussions, including cases where people have compared trackers head-to-head and picked a winner.
I'm the author of BugTracker.NET, mentioned among the answers. If you like FogBugz, but want something free and open source, and maybe more configurable than FogBugz, then give BugTracker.NET a try. It does NOT have a WIKI feature, however.
I'd probably be using FogBugz if I weren't using BugTracker.NET, but it does seem that Trac has a big community.
Have in the last few months being using Redmine as mentioned by Scotts above. Redmine is fantastic. It is written in Ruby on Rails and has a few bits of Ajaxy goodness in all the right places.
I have been using it in a two-man show operation and with 15-odd projects. Its got per project wiki and forum. News and some e-mail integration. (Finicky integration, I believe. I haven't used that bit)
It is a lightweight but powerful bug-tracker that also includes some time-tracking. It has some features that allow you to expose elements of projects to your customers so that they can submit a bug, browse the wiki and access forums (on their project only), but deny them access to the parts of the project where you would curse their names!
I got my first taste of it with a complete free installation stack from Bitnami (http://bitnami.org/stack/redmine). This installs Redmine, Rails, Mongrel + Apache webservers, MySql and Subversion. They can be installed as a service on Windows and Linux etc. Basically a one-click install.
For one past gig, flyspray. I liked it, but others weren't happy with it and it fell out of favor. It was a pain for the sysadmin to keep going.
We switched to a wiki. Everyone else liked it but i didn't think it was quite as practical. With wiki it's easy to describe a problem but forget to mention what operating system it appeared on, who is responsible for fixing/handling the issue, or leave something else out. Wiki isn't very good at enforcing structure, validating fields, offering drop-lists of software projects or programmers' names, reporting which tasks are assigned to a particular person, and more. Searches and categories/tags just don't do it.
I've used Bugzilla for a long time and then Trac. Bugzilla seems to be like CVS, an aging tool, it's still very used but there better alternatives now, besides having to create a new database for every (sub)project doesn't make anyones life easier.
I'm now using Mantis and loving it! It has a very active development team as well a community, and is reasonably easy to customize if required (like creating your own life-cycle states for bugs and change requests).
Internally we have used Bugzilla. We have also toyed with simple Sharepoint subsite and MS Team Foundation Server. More often we are using a client's system. Currently this means I am using TeamTrack.
As a developer thought these worked well enough. As a new QA manager, they all leave much to be desired.
We use NewFire. I won't link to it, because it's horrible. In every way. Worst application ever. Pong would make a better bug tracker, because at least then you'd know it was futile.
We use TFS as it has the following nice features:
Muhahaha, we use PVCS Tracker v7. Beat that for absolutely useless! If you ever come across a potential employer who uses this, ask them what their plans are for migration. If they have none, or its a long way off, run away!
Fresh Logic Studios - Bugs: http://www.freshlogicstudios.com/Products/Bugs/
Free, Simple, Hosted
My company required a Microsoft based solution, which would sit inside the firewall. We went with an open source .NET platform, bugtracker.net
We have over 10000 items in it now (we have many projects and developers).
I tend to prefer Bugzilla for its user interface and the code being written in Perl and not Python.
Google Code is nice, too, IMO, but that's apples-to-oranges.
My personal favourite from a lot of use (however, we ourselves use Google Code's tracker and source browser, due to our code being hosted there) is definitely Trac. The code browser, timeline and the custom query facility are killer features, in my opinion. The RSS feed is also quite useful.
FogBugz is what we are using. We looked at some of the open source stuff, like trac. Fogbugz was the only commercial solution we investigated. You can found good reasons to choose this solutio in other posts. I especially like the easy ways to integrate Fogbugz. Most of the time just by email messages. (This is how we integrate with Magic support, a system our helpdesk is using) Th REST style API akes it also very easy to integrate it with our environment.
We use Bugtracker.NET, I think it is a very good app but we are probably going to switch to Team foundation Server. We will be switching to it for source control so it seems silly not use its work/bug tracking abilities as well.
We use VersionOne, which has much more planning and reporting functionality than Trac, with the downside that it can get a little heavy to use. From a management perspective I'd rather use VersionOne. From a developer's perspective, I like the straightforwardness of Trac and the fact that it integrates well with SVN.
We've used a number of different incarnations of IBM Rational ClearQuest. Although the user interface of the Window's client is ugly, it's a powerful product with a decent and flexible API. Also, if you don't like the Window's client you can now use a web or an Eclipse based client.
We tried Mantis for some time and, in the end, dropped it. Good program, bad usability (IMHO). The problem with many of the trackers I've seen is that they're good for technical people, but not for "real" users, like our copywriter and, more importantly, our clients.
After scouring the web a bit, we wound up writing our own, which we just released as very low-cost solution (just trying to earn the hours back).
Would love some feedback: http://www.archerfishonline.com
There's a free membership as well to check it out.
At my previous employer we used IssueTrackerProduct, a Zope-based webapp.. Very elegant in my opinion :)
We use FlySpray. It's PHP web-based bug tracking tool, nothing more. There is no wiki, no versioning. The interface is horrible. but hey, it's free.
Trac is pretty sweet and nice because you can download it and install it on your server. It also supports SVN, which is very nice to have. We've been using trac in combination with pivotal tracker on one of our projects and it works well.
We use Intervals for most of our projects. It's web-based and we built it after trying to duct-tape the features we needed onto opensource tools.
Check it out at: http://www.myintervals.com
We've been very happy with TeamSupport. It's designed to work with both the customer service team and the development team (hence the name I guess). 100% hosted solution, and the first three users are free.
Noone mentioned Fixx by hedgehoglabs. The interface is well balanced between intuitive and well featured. The product is maturing rapidly and has a decent REST API for any batching you might want to do. Plus its very well priced.
I've used mantzilla firefly fogbugz trac and bugzilla in the past but none really suited my needs.
If we only consider bug-tracking solutions, Trac, Mantis and Bugzilla are imo most famous open source solutions. Jira and FogBugz are famous commercial solutions. They will all do the job.
Now, if I had to introduce a bug-tracking software somewhere, this is how I would proceed.
If there isn't any developer oriented bug-tracking in place, the goal is more to initiate a process than to learn a tool. So I'd choose an open source solution and start to use it asap. As I said, all mentioned tools would do the job but... Trac and Mantis are easy to use, Bugzilla is less user friendly and has a higher learning curve. Bugzilla eliminated. With Trac, you get everything in once: bug tracker, source repository browser, wiki, etc and can use these extra parts with no extra cost. Mantis eliminated. I'd choose Trac (or Agilo if makes sense) and introduce the wiki for free if required.
If a company is mature on bug-tracking, uses lots of tools (e.g. one for each project) and is looking for a corporate and unique solution, I'd mention Jira and FogBugz but would recommend Jira (because of Bamboo). I'm not saying FogBugz isn't good but the other Atlassian's tools are often appreciated in corporate environments too (Confluence for the wiki, Fisheye for the repo browser, Bamboo for continuous integration, Crowd for SSO between all the parts) and are a kind of standard in the enterprise (at least in my country).
We use Unfuddle with ok results. It's competent. It looks nice and does what we need, but it can sometimes feel like a lot of clicking in order to get what you want.
Recently I've been lusting after Lighthouse because Unfuddle can feel a bit pokey and I saw that Lighthouse has a desktop client application which looked speedy. Lighthouse's webapp version seems unintuitive to me though. I can never find the right thing to click on.
I use BugTracker.NET. It is a nice and simple program and very fast. With nice features like fulltext search, ...
We just implemented Bugzilla. If you're not a linux guru, you can download a VM with everything configured.
It's also possible to do Active Directory and Exchange integration if you're running it on a Windows network.
We use BugTracker.NET. It's OSS, Windows centric and easy to set up if you have any experience with Windows or SQL. Not fancy but we have never had any problems with it.
I'd never trust such a crucial workflow tool to a proprietary application, so the only things that make it to our list are free software maintained by an active community.
Of the possible offerings, I find Roundup to be the best balance between flexibility, standards compliance, and simple by default.
I haven't used this personally, but it looks awesome: JetBrains Charisma. It is still in "beta" test mode.
+1 for Gemini which liammclennan has already pointed to above. It's a great product at a hard-to-beat price. In fact Gemini worked out for us with about 30 developers in an environment that never had bug tracking before - highly recommended.
In my current organisation I am using Clear Quest and Quality centre for different projects - one is at the client end and another is at out end. Also I worked on Bugzilla in my previous organisation.
Quality Center basically gives the facility to manage test scripts, generes tracebility matrix to check the coverage area.
Bugzilla is generally used to log bugs but it can also linked with some test management tool like TestLink to manage test cases. We have done this in my previous organisation.
Both Clear Quest and Quality Center needs licensed copy whereas Buqzilla is open source so for a small organisation Bugzilla is preferable.
Thanks.
We are using informup (http://www.informup.com ). really great tool for small - mid size group including very good dashboard, customized fields, customized workflow, emai lnotification etc... Really easy to use and maintainance. In the past I used Test director, bugzilla and few more small bug tracking and really love this tool especially because you get the best solution for a very cheap price!!!
Thanks:-)
Highly recommended! Try the new issue tracker from JetBrains - YouTrack (http://www.jetbrains.com/youtrack/index.html)!
It is installed in just seconds, can be used via keyboard, and provides human-like query language for the fastest search.
A real revolution in bug tracking! :-)
http://www.countersoft.com offers Gemini. For us, it's one of the better .NET browser-based offerings.
I just their 5 user licence coz its' FREE!
+1 for Pivotal Tracker. I've tried just about everything and this is the first solution that really works both for a single developer as well as a small team. Unless you don't like seeing bugs, chores, and features mixed together, but this matches how I work.
I got my last company using Lighthouse because as far as our project managers were concerned, Trac was unusable. It's interface is just way friendlier to less skilled users. Also they seem to be upgrading functionality like CVS export and their API is improving as well. I'm still using it as an indie developer, since a broad range of designers and clients can be taught how to use it fast, unless they are on IE6...
I use rt (request tracker)
I started using it when it was used to keep track of CPAN requests.
I found the documentation to be very thorough and that attracted me to it in the first place.
It uses perl.
It can be installed on any UNIX-like environment (i.e cygwin)
It does not care about the DB backend. (installs on a large set of DBs)
There's also a [book] written on rt called "RT Essentials". (published by OReilly)
The rt website is [here]
The rt wikipedia entry is [here also]
Could you say whether you are willing to pay (FogBugz) or not, in which case it gets interesting...
I always used Bugzilla when someone else chose the problem tracker, but when I got to choose, I chose Mantis. Why? Simply because Bugzilla is written in PErl and Mantis in PHP, whcih I prefer.
Of course, you may not want to hack the code, in which case, decide which featres are important to you ... and 'll find that most problem tracking systems support them all.
Quid nunc? Well, a tool on its own is just a tool. And while all speak of a toolchain, most just mean a loose collection of tools. Why not look for a problem tracker that "plays well with other children"? That is to say, interfaces well with your IDE, your build tool, your version control system ...
In fact, I think I'll go now and ask a question about the best linked toolchain ...
At my company we are using Redmine with the Scrum Alliance Plugin. Provides most common features as bug tracking, wiki, source control and file repository. The Scrum plugin add sprints, a project backlog, a task board and a burn down chart.
http://www.fossil-scm.org/ Fossil comes with highly configurable ticket tracker.
Corey Trager's BugTracker.Net along with SVN to link code revisions to their respective issues.
I've used this combination on various projects and it works brilliantly for me.
BugTracker.Net is very easy to customise (if you know a bit of C# / SQL) and incredibily quick to mobilise from scratch. It's well supported and seems to scale up ok.
Of course as with anything it's not so much the software but the way you set it up and use it which determines success...
We use YouTrack from Jetbrains from (and used JIRA before - but YouTrack allowed us a very simple migration).
The main selling point of YouTrack for us was the smart search bar - that behaves practically like a smart IDE Editor with completion - you just have to try it to see how powerful is and how less time does one need to spend with the issue tracker this way :).
We also use YouTrack now.
We were using JIRA + JiraClient (desktop client for efficiency), but moved to YouTrack, since it seems to be by far the most productive tracker, and from the developer's perspective very, very efficient: that smart search bar with "code completion" and "code commands" was the winner for us too.
