EDIT: As of 2013-10, I've started an Observium fork called LibreNMS. This is just here for historical reference.
This started a discussion on the IRC channel during which numerous common misconceptions about the GNU GPL (the Free Software license under which Observium is released) were thrown around. To summarise, these were the opinions given:
Eventually the discussion degenerated into name-calling and personal insults. (Unfortunately, I was denied permission to publish a copy of the relevant IRC logs so that the above summary could be independently verified. I guess you'll just have to take my word for it. :-)
I will address some of the individual points above later, but I think most of them share a foundational assumption which drives most of the BSD-loving crowd's fear of the GPL. This assumption may be summed up as follows: the original author of a software package is the most important person or organisation in its existence. (You may substitute "project leader", "main copyright holder", or similar in place of "original author" in the cases where a project is is active but no longer maintained by its original author.)
On this point there is no question: Adam Armstrong is much more important to Observium's existence than I am. But I think the question of licensing requires a little more nuance than simply assuming that the original author's wishes trump everything. One way of thinking about this is to compare the time investment by the original author and the other parties involved. To do this, let's think about some scenarios:
Another major party with a significant time investment in Observium is its user base - the people who install it, configure it, and use it for monitoring real networks on a daily basis. I have no way of knowing or even guessing how many such people there are, but let's assume for the moment that my experience with Observium is roughly normal. Over the past two months, I have installed it on an existing VM in my client's ESX cluster, then created a new VM for it, migrated the RRD data from the original 32-bit VM to the new dedicated 64-bit VM, configured Observium to monitor the majority of my client's Linux servers (both virtual and physical) and network equipment (mostly HP ProCurve switches). I've made Observium the number one web page I visit when I arrive on site. I've submitted a few patches, some of which have added useful functionality. Overall, I would say that I've invested about 2 hours per week in Observium over the last 2 months, for a total of about 16 hours.
It should be obvious where I'm going with this: it would only take 200 users with similar experiences to mine a total of two months to roughly equal the time investment of the baseline coding of Observium. My guess is that there are a lot more users than that (probably an order of magnitude more), and that most of them have been using the product for a lot longer than I have (probably an order of magnitude longer).
Observium is not a typical end-user product - it's targeted at enterprise and service provider networks and requires some skill to implement (although not as much as some of its "competitors" in the network monitoring space). Consider the CPU scheduler of a desktop or mobile operating system kernel such as Linux, Android, Microsoft Windows, or Apple iOS. It would typically be roughly two orders of magnitude smaller than Observium (around 500 lines of code, let's say). The original developer(s) may have spent a significant length of time researching and testing it, but if a CPU scheduler doesn't have workable functionality within a few months, it would likely be considered a failure.
Compare this with the number of users who depend upon that scheduler every day, and the difference is dramatic: the overall time invested by the users (in simply operating their devices and relying on them to perform at expected levels) vastly outweighs the time investment by the developer, probably within the first week of its release.
What I'm getting at here is that for most software, the time investment on the part of the users is often roughly equal to (in the case of specialised software like Observium), and in many cases massively greater than (in the case of a generic CPU scheduler) the time investment on the part of the developers. Software developers put their time into design, programming, testing, support, project infrastructure, etc.; users invest time in installation, testing, configuration, supporting other users, promoting, etc. Both parties are major stakeholders in the software, and a good Free Software license should strike a balance between the rights of the different stakeholders.
(In this post, I'll assume use of version 3 of the GPL unless otherwise specified.)
The GPL's preamble says that its purpose is "to make sure it remains free software for all its users". The primary benefit the GPL brings to users of GPL-licensed software is the guarantee that the software they have will remain free. That is, no one can revoke their right to use the software, nor can anyone change the conditions under which they are allowed to copy and redistribute it. (It doesn't guarantee that future versions will be free, since the copyright holder might choose to relicense it, but it guarantees their access to the software they currently use.)
This offers adopters of GPL-licensed software a key advantage over proprietary software, since they know that time they invest in the software will not be wasted. No vendor can come along (like Amazon did with one of their Kindle books) and decide that all customers need to delete their copy. No copyright holder can demand additional license fees in order to maintain a customer's right to run an existing installation of the software. No party can sue them for using the software inappropriately, since the GPL explicitly excludes the executing of GPL-licensed software from its terms. [See section 2 ("This License explicitly affirms your unlimited permission to run the unmodified Program.") and section 9 ("You are not required to accept this License in order to receive or run a copy of the Program.") for further details. Incidentally, I believe this to mean that typical Windows-based installers of GPL software should NOT require the user to accept a copy of the GPL license in order to install the software. However, I am not a lawyer.]
So the GPL offers conditions which are strong incentive for users to adopt the software.
Another stakeholder in the Free Software ecosystem is the 3rd-party developer. Often these developers will be users of the software as well, and will make their own modifications, then pass on these modifications (or updated copies of the software) to others. The GPL offers such developers essentially the same benefits which it provides to users, guaranteeing that their time investment in improving, distributing and supporting the software will not be wasted. This is further enhanced if a distributed copyright model (such as that employed by the Linux kernel) is employed, because not only are currently-released copies of the software protected, but any licensing change to future versions must be approved by all copyright holders.
For me as a very part-time Free Software developer (among my other roles), this means that I'm much more likely to contribute towards a GPL-licensed project (or one using a similar license, such as the AGPL or LGPL), and also much less likely to be suspicious of the original developers' motives if they do not ask me to waive copyright on my contributions.
Now on to some of the specific issues raised in the Observium IRC channel. I am not a lawyer, so these are just my opinion. However, I hope that they are justified and well-documented opinions.
Nothing in the license requires any involvement of the FSF or Richard Stallman. The fact that Red Hat have built an incredibly successful commercial enterprise on a codebase that is allegedly more than 50% GPL-licensed should be sufficient evidence that this is not the case.
Additionally, there is nothing to prevent a copyright holder from re-releasing the same code under a different license. Licensing my code under GPL means that a large company can't come along and commercialise my code without complying with the same conditions as everyone else. To me, this is a great protection for my software and my time investment.
Where this leaves me with Observium is a little unclear. I've tried to fit in with the original developers as best I can so far (including going back to Subversion for version control, despite its annoying limitations). I've started small, but I was hoping to ramp up my contributions over the next few months. Being required to assign copyright of contributions is an enthusiasm sapper for contributions, as is the suggestion that at the first chance Adam will relicense the project to BSD or MIT.
Observium is a great piece of software: it offers killer features for minimal configuration, saving me a lot of time and effort, and it's fun and easy to hack on. So while it remains GPL-licensed, I'll probably swallow my pride and keep contributing. My contributions are only a tiny fraction of the overall project, anyway. If it all goes pear-shaped, I can always fork. ;-)