Add Test Proxy logging to local runs (Azure#36953)

Add Test Proxy logging to local runs

Author: alzimmermsft

sdk/core/azure-core-test/src/main/java/com/azure/core/test/policy/TestProxyRecordPolicy.java

@@ -32,6 +32,7 @@
 import java.util.List;
 import java.util.Queue;
 
+import static com.azure.core.test.utils.TestProxyUtils.checkForTestProxyErrors;
 import static com.azure.core.test.utils.TestProxyUtils.createAddSanitizersRequest;
 import static com.azure.core.test.utils.TestProxyUtils.getAssetJsonFile;
 import static com.azure.core.test.utils.TestProxyUtils.loadSanitizers;
@@ -81,6 +82,8 @@ public void startRecording(File recordFile, Path testClassPath) {
                 .setHeader(HttpHeaderName.CONTENT_TYPE, "application/json");
 
             try (HttpResponse response = client.sendSync(request, Context.NONE)) {
+                checkForTestProxyErrors(response);
+
                 this.xRecordingId = response.getHeaderValue(X_RECORDING_ID);
             }
 

sdk/core/azure-core-test/src/main/java/com/azure/core/test/utils/TestProxyManager.java

@@ -8,10 +8,14 @@
 import com.azure.core.http.HttpResponse;
 import com.azure.core.util.Configuration;
 import com.azure.core.util.Context;
+import com.azure.core.util.CoreUtils;
 import com.azure.core.util.logging.ClientLogger;
 
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.time.Duration;
@@ -46,40 +50,70 @@ public TestProxyManager(Path testClassPath) {
     public void startProxy() {
         try {
             // if we're not running in CI we will check to see if someone has started the proxy, and start one if not.
-            if (runningLocally() && !checkAlive(1, Duration.ofSeconds(1))) {
+            if (runningLocally() && !checkAlive(1, Duration.ofSeconds(1), null)) {
                 String commandLine = Paths.get(TestProxyDownloader.getProxyDirectory().toString(),
                     TestProxyUtils.getProxyProcessName()).toString();
 
-                ProcessBuilder builder = new ProcessBuilder(commandLine,
-                    "--storage-location",
-                    TestUtils.getRepoRootResolveUntil(testClassPath, "eng").toString());
+                Path repoRoot = TestUtils.getRepoRootResolveUntil(testClassPath, "eng");
+
+                // Resolve the path to the repo root 'target' folder and create the folder if it doesn't exist.
+                // This folder will be used to store the 'test-proxy.log' file to enable simpler debugging of Test Proxy
+                // locally. This is similar to what CI does, but CI uses a PowerShell process to run the Test Proxy
+                // where running locally uses a Java ProcessBuilder.
+                Path repoRootTarget = repoRoot.resolve("target");
+                if (!Files.exists(repoRootTarget)) {
+                    Files.createDirectory(repoRootTarget);
+                }
+
+                ProcessBuilder builder = new ProcessBuilder(commandLine, "--storage-location", repoRoot.toString())
+                    .redirectOutput(repoRootTarget.resolve("test-proxy.log").toFile());
                 Map<String, String> environment = builder.environment();
-                environment.put("LOGGING__LOGLEVEL", "Information");
-                environment.put("LOGGING__LOGLEVEL__MICROSOFT", "Warning");
-                environment.put("LOGGING__LOGLEVEL__DEFAULT", "Information");
+                environment.put("LOGGING__LOGLEVEL", "Debug");
+                environment.put("LOGGING__LOGLEVEL__MICROSOFT", "Debug");
+                environment.put("LOGGING__LOGLEVEL__DEFAULT", "Debug");
                 proxy = builder.start();
             }
             // in either case the proxy should now be started, so let's wait to make sure.
-            if (checkAlive(10, Duration.ofSeconds(6))) {
+            if (checkAlive(10, Duration.ofSeconds(6), proxy)) {
                 return;
             }
-            throw new RuntimeException("Test proxy did not initialize.");
 
+            // If the Test Proxy process doesn't start within the timeout period read the error stream of the Process
+            // for any additional details that could help determine why the Test Proxy process didn't start.
+            // Include this additional information in the exception message.
+            ByteArrayOutputStream errorLog = new ByteArrayOutputStream();
+            byte[] buffer = new byte[4096];
+            int read;
+            while ((read = proxy.getErrorStream().read(buffer)) != -1) {
+                errorLog.write(buffer, 0, read);
+            }
+
+            String errorLogString = new String(errorLog.toByteArray(), StandardCharsets.UTF_8);
+            if (CoreUtils.isNullOrEmpty(errorLogString)) {
+                throw new RuntimeException("Test proxy did not initialize.");
+            } else {
+                throw new RuntimeException("Test proxy did not initialize. Error log: " + errorLogString);
+            }
         } catch (IOException e) {
             throw LOGGER.logExceptionAsError(new UncheckedIOException(e));
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
     }
 
-    private boolean checkAlive(int loops, Duration waitTime) throws InterruptedException {
+    private static boolean checkAlive(int loops, Duration waitTime, Process proxy) throws InterruptedException {
         HttpURLConnectionHttpClient client = new HttpURLConnectionHttpClient();
         HttpRequest request = new HttpRequest(HttpMethod.GET,
             String.format("%s/admin/isalive", TestProxyUtils.getProxyUrl()));
         for (int i = 0; i < loops; i++) {
-            HttpResponse response = null;
+            // If the proxy isn't alive and the exit value isn't 0, then the proxy process has exited with an error
+            // and stop waiting.
+            if (proxy != null && !proxy.isAlive() && proxy.exitValue() != 0) {
+                return false;
+            }
+
             try {
-                response = client.sendSync(request, Context.NONE);
+                HttpResponse response = client.sendSync(request, Context.NONE);
                 if (response != null && response.getStatusCode() == 200) {
                     return true;
                 }