Make sure handler errors won't bring down a shelf server.

pkg/shelf/lib/shelf_io.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// A Shelf adapter for handling [HttpRequest] objects from `dart:io`.
 ///
 /// One can provide an instance of [HttpServer] as the `requests` parameter in
 /// [serveRequests].
+///
+/// The `dart:io` adapter supports request hijacking; see [Request.hijack].

[kevmoo, 2014/04/25 13:13:06]

Not yet?

[nweiz, 2014/04/25 18:18:13]

Merge error, removed.

 library shelf.io;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:stack_trace/stack_trace.dart';
 
 import 'shelf.dart';
 import 'src/util.dart';
 
 /// Starts an [HttpServer] that listens on the specified [address] and
 /// [port] and sends requests to [handler].
 ///
 /// See the documentation for [HttpServer.bind] for more details on [address],
 /// [port], and [backlog].
 Future<HttpServer> serve(Handler handler, address, int port,
     {int backlog}) {
   if (backlog == null) backlog = 0;
   return HttpServer.bind(address, port, backlog: backlog).then((server) {
     serveRequests(server, handler);
     return server;
   });
 }
 
 /// Serve a [Stream] of [HttpRequest]s.
 ///
 /// [HttpServer] implements [Stream<HttpRequest>] so it can be passed directly
 /// to [serveRequests].
+///
+/// Errors thrown by [handler] while serving a request will be printed to the
+/// console and cause a 500 response with no body. Errors thrown asynchronously
+/// by [handler] will be printed to the console or, if there's an active error
+/// zone, passed to that zone.
 void serveRequests(Stream<HttpRequest> requests, Handler handler) {
-  requests.listen((request) => handleRequest(request, handler));
+  catchTopLevelErrors(() {
+    requests.listen((request) => handleRequest(request, handler));
+  }, (error, stackTrace) {
+    _logError('Asynchronous error\n$error', stackTrace);
+  });
 }
 
 /// Uses [handler] to handle [request].
 ///
 /// Returns a [Future] which completes when the request has been handled.
 Future handleRequest(HttpRequest request, Handler handler) {
   var shelfRequest = _fromHttpRequest(request);
 
   return syncFuture(() => handler(shelfRequest))
       .catchError((error, stackTrace) {
-    var chain = new Chain.current();
-    if (stackTrace != null) {
-      chain = new Chain.forTrace(stackTrace)
-          .foldFrames((frame) => frame.isCore || frame.package == 'shelf')
-          .terse;
-    }
-
-    return _logError('Error thrown by handler\n$error\n$chain');
+    return _logError('Error thrown by handler\n$error', stackTrace);
   }).then((response) {
     if (response == null) {
       response = _logError('null response from handler');
     }
 
     return _writeResponse(response, request.response);
   });
 }
 
 /// Creates a new [Request] from the provided [HttpRequest].
@@ skipping 21 matching lines @@
   if (response.headers[HttpHeaders.SERVER] == null) {
     var value = httpResponse.headers.value(HttpHeaders.SERVER);
     httpResponse.headers.set(HttpHeaders.SERVER, '$value with Shelf');
   }
   return httpResponse.addStream(response.read())
       .then((_) => httpResponse.close());
 }
 
 // TODO(kevmoo) A developer mode is needed to include error info in response
 // TODO(kevmoo) Make error output plugable. stderr, logging, etc
-Response _logError(String message) {
+Response _logError(String message, [StackTrace stackTrace]) {
+  var chain = new Chain.current();
+  if (stackTrace != null) {
+    chain = new Chain.forTrace(stackTrace);
+  }
+  chain = chain
+      .foldFrames((frame) => frame.isCore || frame.package == 'shelf')
+      .terse;
+
   stderr.writeln('ERROR - ${new DateTime.now()}');
   stderr.writeln(message);
+  stderr.writeln(chain);
   return new Response.internalServerError();
 }