Fix del.icio.us/post ignore
Ignore dead Yahoo domain
Ignore /quote-comment-\d+/
Ignore reCAPTCHAs
Ignore infinite loop on facebook.com
Ignore some common infinite loops
Ignore some more common infinite loops
Ignore pattern reports may now be suppressed or shown.

Suppressing ignores can be useful when a job has many matching URLs.  In
this situation, reporting every ignore:

1. results in quite a bit of network traffic
2. causes the job log to scroll too fast for most humans to understand

In cases like this, the log becomes more useful when ignore pattern
matches are not logged.  The old "show ignores" function attempted to do
this, but ignores were still present in the dashboard log -- they were
just CSS-hidden.  As a result, it was possible for a large stream of
ignores to boot useful log data out of the job's log buffer.

Suppressing ignores can also improve job speed: there's a small but
significant amount of time eaten up by ZADDing an ignore message to the
job log and waiting for a response.
Remove "show ignores" checkbox from dashboard.

The effect of this is duplicated by !suppressignores/!showignores; also,
the latter actually has an effect on the number of messages processed
per second, so it can make jobs less (or more) taxing on the client
machine.
Display ignore report suppression status on dashboard.
Replace LogAnalyzer with a few smaller scripts.

The cogs program is suffering from inexplicable memory leaks and/or
process bloat.  (I can't tell which one is actually happening.  Hell,
both might be occurring.)

This commit, and indeed this branch, are an attempt to rewrite cogs in a
memory-conscious way.  The programs here are meant to be glued together
with e.g. socat, ucspi-{tcp,unix,...} and operate on streams without
uncontrolled object instantiation.  (Possible exception: the
zrangebyscore call in analyze-logs.)

I've run these programs on the production ArchiveBot Redis updates
channel, and have noticed much more acceptable memory usage over time.
Next step: disable the LogAnalyzer actor, replace its duties, and see
just how we do.
Remove unused stringio import.
A simpler LogTrimmer.
Remove superfluous subdirectories.
Remove old log analyzer and log trimmer cogs.
Remove unnecessary signal traps.
Reimplement JobRecorder.
We don't need to use tcpserver/tcpclient.

Originally, I thought that I could get away with using one Redis
subscription and attach all the cogs processors to that.  Then I
realized:

1) If I wanted to use tcpserver, that wouldn't be possible: the only
   shared state between connections is whatever shared state separate
   instances of a given program have.

2) I really didn't want to write my own server.

3) It doesn't matter: 4-5 subscribers is really not noticably slower
   than one or two.

The server/client bits are therefore relics of premature optimization,
and you know what everyone says about that.
Disable old JobRecorder.
Introduce log-firehose, a utility to spit out job logs.

This seems to exhibit saner memory usage patterns than the dashboard's log
broadcaster.  (And if it doesn't, there's a lot less going on, which
should make it easier to understand.)