     # the request off to the service for processing it. Normally it
     # should not be used outside of the router (middleware) coding.
     streamline: (recognized, request, response, next) ->
+        ignite = "Launch the ignition sequence in %s"
+        rescue = "Setup the rescue handler in the %s"
         assert signature = _.rest arguments or Array()
+        identify = try @constructor.identify().underline
         ignition = recognized.downstream ignition: ->
             assert domain = require("domain").create()
             processor = recognized.process.bind recognized
             polished = => processor.apply this, signature
+            logger.debug ignite.cyan, identify.toString()
+            logger.debug rescue.cyan, identify.toString()
             domain.add eem for eem in [request, response]
             domain.add recognized; domain.on "error", (error) =>
                 rescuing = recognized.downstream rescuing: ->

    # If something is wrong, this method will throw an exception.
    # The method is idempotent, ergo no duplication of routables.
    register: (routable, callback) ->
        assert identify = routable.constructor.identify()
        assert inspected = try identify.toString().underline
        [matches, process] = [routable.matches, routable.process]
        goneMatches = "The #{identify} has no valid matches method"

    # transfers the control to the pre-installed, default routable.
    # A set of tests are performed to ensure the logical integrity.
    middleware: (request, response, next) ->
        assert incoming = try request.url.underline
        p = (i, c) -> i.matches request, response, c
        final = (service) -> service.abstract?() is no
        assert registry = @registry, "missing registry"
        signature = arguments if _.isArguments arguments
        implemented = _.toArray _.filter registry, final
        matching = "Incoming request %s matches %s service"
        missing = "Request %s does not match to any service"
        async.detectSeries implemented, p, (recognized) =>
            success = ok = _.isObject recognized or null
            logger.debug missing.grey, incoming unless ok
            return next undefined unless ok # shortcircuit
            assert constructor = recognized.constructor
            identify = constructor?.identify()?.underline
            @emit "recognized", recognized, signature...
