Include the request context for shelf_io errors.

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].
 ///
 /// This adapter supports request hijacking; see [Request.hijack]. It also
@@ skipping 35 matching lines @@
 /// 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) {
   catchTopLevelErrors(() {
     requests.listen((request) => handleRequest(request, handler));
   }, (error, stackTrace) {
-    _logError('Asynchronous error\n$error', stackTrace);
+    _logTopLevelError('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) {
+Future handleRequest(HttpRequest request, Handler handler) async {
   var shelfRequest;
   try {
     shelfRequest = _fromHttpRequest(request);
   } catch (error, stackTrace) {
-    var response = _logError('Error parsing request.\n$error', stackTrace);
-    return _writeResponse(response, request.response);
+    var response = _logTopLevelError(
+        'Error parsing request.\n$error', stackTrace);
+    await _writeResponse(response, request.response);
+    return;
   }
 
   // TODO(nweiz): abstract out hijack handling to make it easier to implement an
   // adapter.
-  return new Future.sync(() => handler(shelfRequest))
-      .catchError((error, stackTrace) {
-    if (error is HijackException) {
-      // A HijackException should bypass the response-writing logic entirely.
-      if (!shelfRequest.canHijack) throw error;
+  var response;
+  try {
+    response = await handler(shelfRequest);
+  } on HijackException catch (error, stackTrace) {
+    // A HijackException should bypass the response-writing logic entirely.
+    if (!shelfRequest.canHijack) return;
 
-      // If the request wasn't hijacked, we shouldn't be seeing this exception.
-      return _logError(
-          "Caught HijackException, but the request wasn't hijacked.",
-          stackTrace);
-    }
+    // If the request wasn't hijacked, we shouldn't be seeing this exception.
+    response = _logError(
+        shelfRequest,
+        "Caught HijackException, but the request wasn't hijacked.",
+        stackTrace);
+  } catch (error, stackTrace) {
+    response = _logError(
+        shelfRequest, 'Error thrown by handler.\n$error', stackTrace);
+  }
 
-    return _logError('Error thrown by handler.\n$error', stackTrace);
-  }).then((response) {
-    if (response == null) {
-      return _writeResponse(
-          _logError('null response from handler.'), request.response);
-    } else if (shelfRequest.canHijack) {
-      return _writeResponse(response, request.response);
-    }
+  if (response == null) {
+    await _writeResponse(
+        _logError(shelfRequest, 'null response from handler.'),
+        request.response);
+    return;
+  } else if (shelfRequest.canHijack) {
+    await _writeResponse(response, request.response);
+    return;
+  }
 
-    var message = new StringBuffer()
-      ..writeln("Got a response for hijacked request "
-          "${shelfRequest.method} ${shelfRequest.requestedUri}:")
-      ..writeln(response.statusCode);
-    response.headers
-        .forEach((key, value) => message.writeln("${key}: ${value}"));
-    throw new Exception(message.toString().trim());
-  }).catchError((error, stackTrace) {
-    // Ignore HijackExceptions.
-    if (error is! HijackException) throw error;
-  });
+  var message = new StringBuffer()
+    ..writeln("Got a response for hijacked request "
+        "${shelfRequest.method} ${shelfRequest.requestedUri}:")
+    ..writeln(response.statusCode);
+  response.headers
+      .forEach((key, value) => message.writeln("${key}: ${value}"));
+  throw new Exception(message.toString().trim());
 }
 
 /// Creates a new [Request] from the provided [HttpRequest].
 Request _fromHttpRequest(HttpRequest request) {
   var headers = {};
   request.headers.forEach((k, v) {
     // Multiple header values are joined with commas.
     // See http://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-21#page-22
     headers[k] = v.join(',');
   });
@@ skipping 31 matching lines @@
     httpResponse.headers.date = new DateTime.now().toUtc();
   }
 
   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, [StackTrace stackTrace]) {
+Response _logError(Request request, String message, [StackTrace stackTrace]) {
+  // Add information about the request itself.
+  var buffer = new StringBuffer();
+  buffer.write("${request.method} ${request.requestedUri.path}");
+  if (request.requestedUri.query.isNotEmpty) {
+    buffer.write("?${request.requestedUri.query}");
+  }
+  buffer.writeln();
+  buffer.write(message);
+
+  return _logTopLevelError(buffer.toString(), stackTrace);
+}
+
+Response _logTopLevelError(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();
 }