Recreating an Error'd EventEmitter With NodeJS Domains

I've been struggling for sometime with the proper error handling pattern for a message bus subscriber function I have written in NodeJS.

The developer call basically looks like this:

bus.subscribe('message', function(msg) {
    console.log('I got a message');
});

And then I do some things in subscribe so that the handler function is properly hooked-up to the bus. For now, say that subscribe looks like:

function subscribe(messageType, fn) {
    //some code here to hook fn to the bus
    ...
    //execute fn, passing in the message
    ...
}

I'd like to localize errors happening within the developer created handler, to that handler, and not take the whole app down. So, I could do something like:

function subscribe(messageType, fn) {
    //some code here to hook fn to the bus
    ...
    try {
        //execute fn, passing in the message
        ...
    }
    catch(e) {
    // ???
    }
}

I guess that's ok, even though I read a lot of posts suggesting it might not be. Many of those posts point to Domains as something I should be considering. It also seems that I might be able to use Domains to restart the subscriber - for cases where maybe a bad event came in, or something. As it happens, I create an EventEmitter as part hooking the handler function to the bus, so I try something to the effect of:

function innerSubscribe(messageType, fn) {
    //some code here to hook fn to the bus
    //including creating an EventEmitter, say ee
    var ee = ...
    ...
    try {
        //execute fn, passing in the message
        ...
    }
    catch(e) {
    // ???
    }

    return ee;
}

function subscribe(messageType, fn) {
    var domain = require('domain').create();
    domain.add(innerSubscribe(messageType, fn));
    domain.on('error', subscribe.bind(null, messageType, fn));
}

Something along those lines. Then, I'd hope, if a bad message came in and the EventEmitter error'd, the domain would catch it, and resubscribe the handler.

And this does work - exactly once.

I wrote a test driver to publish a message every five seconds, then after the subscriber handles a few messages, I cause an error. The domain catches it, the handler function is "re-attached" and goes on handling messages (I put something in to make sure it's the reattached function, not the first instance). But if I do this a second time, the domain will not catch it (and the function will no reattach).

So I'm sure I've missed something, or done something wrong or... And I'm also not sure if that's even the route i should be pursuing. Maybe my try/catch is good enough? (Although restarting the subscriber would be really nice, along with some logging I'd add in).

So, I suppose I'm looking for two parts: what is the proper way to isolate the developer provided handler so it doesn't crush the whole app and, if domains are an acceptable approach (actually, even if they aren't) what am I doing wrong here?

UPDATE
It occurs to me that I seem to be creating a Domain within a Domain when the first error occurs which, as I understand it, will cause a second error to not be caught - is that right? Which would explain the behavior. Which would then seem to indicate that Domains can't be used like this for "infinite" fine-grained restarts.