Finish integrating logging.

utils/pub/curl_client.dart

 // Copyright (c) 2012, 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.
 
 library curl_client;
 
 import 'dart:io';
 
 import '../../pkg/http/lib/http.dart' as http;
 import 'io.dart';
+import 'log.dart' as log;
 import 'utils.dart';
 
 /// A drop-in replacement for [http.Client] that uses the `curl` command-line
 /// utility rather than [dart:io] to make requests. This class will only exist
 /// temporarily until [dart:io] natively supports requests over HTTPS.
 class CurlClient extends http.BaseClient {
   /// The path to the `curl` executable to run.
   ///
   /// By default on Unix-like operating systems, this will look up `curl` on the
   /// system path. On Windows, it will use the bundled `curl.exe`.
   final String executable;
 
   /// Creates a new [CurlClient] with [executable] as the path to the `curl`
   /// executable.
   ///
   /// By default on Unix-like operating systems, this will look up `curl` on the
   /// system path. On Windows, it will use the bundled `curl.exe`.
   CurlClient([String executable])
     : executable = executable == null ? _defaultExecutable : executable;
 
   /// Sends a request via `curl` and returns the response.
   Future<http.StreamedResponse> send(http.BaseRequest request) {
+    log.fine("Sending Curl request $request");
+
     var requestStream = request.finalize();
     return withTempDir((tempDir) {
       var headerFile = new Path(tempDir).append("curl-headers").toNativePath();
       var arguments = _argumentsForRequest(request, headerFile);
+      log.process(executable, arguments);
       var process;
       return Process.start(executable, arguments).chain((process_) {
         process = process_;
         if (requestStream.closed) {
           process.stdin.close();
         } else {
           requestStream.pipe(process.stdin);
         }
 
         return _waitForHeaders(process, expectBody: request.method != "HEAD");
@@ skipping 60 matching lines @@
   /// requests).
   ///
   /// Curl prints the headers to a file and then prints the body to stdout. So,
   /// in theory, we could read the headers as soon as we see anything appear
   /// in stdout. However, that seems to be too early to successfully read the
   /// file (at least on Mac). Instead, this just waits until the entire process
   /// has completed.
   Future _waitForHeaders(Process process, {bool expectBody}) {
     var completer = new Completer();
     process.onExit = (exitCode) {
+      log.io("Curl process exited with code $exitCode.");
+
       if (exitCode == 0) {
         completer.complete(null);
         return;
       }
 
       chainToCompleter(consumeInputStream(process.stderr)
             .transform((stderrBytes) {
         var message = new String.fromCharCodes(stderrBytes);
+        log.fine('Got error reading headers from curl: $message');
         if (exitCode == 47) {
           throw new RedirectLimitExceededException([]);
         } else {
           throw new HttpException(message);
         }
       }), completer);
     };
 
     // If there's not going to be a response body (e.g. for HEAD requests), curl
     // prints the headers to stdout instead of the body. We want to wait until
@@ skipping 51 matching lines @@
   /// path to the bundled `curl.exe`; elsewhere, this is just "curl", and we
   /// assume it to be installed and on the user's PATH.
   static String get _defaultExecutable {
     if (Platform.operatingSystem != 'windows') return 'curl';
     // Note: This line of code gets munged by create_sdk.py to be the correct
     // relative path to curl in the SDK.
     var pathToCurl = "../../third_party/curl/curl.exe";
     return relativeToPub(pathToCurl);
   }
 }