Throw error from Response

sdk/core/Azure.Core/src/Pipeline/HttpPipeline.cs

@@ -70,7 +70,9 @@ public ValueTask SendAsync(HttpMessage message, CancellationToken cancellationTo
         {
             message.CancellationToken = cancellationToken;
             AddHttpMessageProperties(message);
-            return _pipeline.Span[0].ProcessAsync(message, _pipeline.Slice(1));
+            var value = _pipeline.Span[0].ProcessAsync(message, _pipeline.Slice(1));
+            message.Response.Message = message;
+            return value;
         }
 
         /// <summary>
@@ -83,6 +85,7 @@ public void Send(HttpMessage message, CancellationToken cancellationToken)
             message.CancellationToken = cancellationToken;
             AddHttpMessageProperties(message);
             _pipeline.Span[0].Process(message, _pipeline.Slice(1));
+            message.Response.Message = message;
         }
         /// <summary>
         /// Invokes the pipeline asynchronously with the provided request.

sdk/core/Azure.Core/src/Response.cs

@@ -5,7 +5,9 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Threading.Tasks;
 using Azure.Core;
+using Azure.Core.Pipeline;
 
 namespace Azure
 {
@@ -111,6 +113,34 @@ public virtual BinaryData Content
         /// <returns>The <see cref="IEnumerable{T}"/> enumerating <see cref="HttpHeader"/> in the response.</returns>
         protected internal abstract IEnumerable<HttpHeader> EnumerateHeaders();
 
+        internal HttpMessage? Message { get; set; }
+
+        /// <summary>
+        /// </summary>
+        /// <returns></returns>
+        public bool IsError()
+        {
+            return this.Message!.ResponseClassifier.IsErrorResponse(this.Message);
+        }
+
+        /// <summary>
+        /// Throw a RequestFailedException appropriate to the Response.
+        /// </summary>
+        public void Throw()
+        {
+            throw this.Message!.ResponseClassifier.CreateRequestFailedException(this);
+            //throw new RequestFailedException("<error message>");
+        }
+
+        /// <summary>
+        /// Throw a RequestFailedException appropriate to the Response.
+        /// </summary>
+        public async Task ThrowAsync()
+        {
+             throw await this.Message!.ResponseClassifier.CreateRequestFailedExceptionAsync(this).ConfigureAwait(false);
+            //throw new RequestFailedException("<error message>");
+        }
+
         /// <summary>
         /// Creates a new instance of <see cref="Response{T}"/> with the provided value and HTTP response.
         /// </summary>

sdk/core/Azure.Core/src/ResponseClassifier.cs

@@ -2,7 +2,14 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Azure.Core.Pipeline;
 
 namespace Azure.Core
 {
@@ -11,6 +18,30 @@ namespace Azure.Core
     /// </summary>
     public class ResponseClassifier
     {
+        private const string DefaultFailureMessage = "Service request failed.";
+
+        private readonly HttpMessageSanitizer _sanitizer;
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="ResponseClassifier"/>.
+        /// </summary>
+        public ResponseClassifier() : this(new DefaultClientOptions())
+        {
+        }
+
+        /// <summary>
+        /// </summary>
+
+        /// <summary>
+        /// Initializes a new instance of <see cref="ResponseClassifier"/>.
+        /// </summary>
+        public ResponseClassifier(ClientOptions options)
+        {
+            _sanitizer = new HttpMessageSanitizer(
+                options?.Diagnostics.LoggedQueryParameters.ToArray() ?? Array.Empty<string>(),
+                options?.Diagnostics.LoggedHeaderNames.ToArray() ?? Array.Empty<string>());
+        }
+
         /// <summary>
         /// Specifies if the request contained in the <paramref name="message"/> should be retried.
         /// </summary>
@@ -57,5 +88,165 @@ public virtual bool IsErrorResponse(HttpMessage message)
             var statusKind = message.Response.Status / 100;
             return statusKind == 4 || statusKind == 5;
         }
+
+        /// <summary>
+        /// </summary>
+        public async ValueTask<RequestFailedException> CreateRequestFailedExceptionAsync(Response response, string? message = null, string? errorCode = null, IDictionary<string, string>? additionalInfo = null, Exception? innerException = null)
+        {
+            var content = await ReadContentAsync(response, true).ConfigureAwait(false);
+            ExtractFailureContent(content, ref message, ref errorCode);
+            return CreateRequestFailedExceptionWithContent(response, message, content, errorCode, additionalInfo, innerException);
+        }
+
+        /// <summary>
+        /// </summary>
+        public RequestFailedException CreateRequestFailedException(Response response, string? message = null, string? errorCode = null, IDictionary<string, string>? additionalInfo = null, Exception? innerException = null)
+        {
+            string? content = ReadContentAsync(response, false).EnsureCompleted();
+            ExtractFailureContent(content, ref message, ref errorCode);
+            return CreateRequestFailedExceptionWithContent(response, message, content, errorCode, additionalInfo, innerException);
+        }
+
+        private static async ValueTask<string?> ReadContentAsync(Response response, bool async)
+        {
+            string? content = null;
+
+            if (response.ContentStream != null &&
+                ContentTypeUtilities.TryGetTextEncoding(response.Headers.ContentType, out var encoding))
+            {
+                using (var streamReader = new StreamReader(response.ContentStream, encoding))
+                {
+                    content = async ? await streamReader.ReadToEndAsync().ConfigureAwait(false) : streamReader.ReadToEnd();
+                }
+            }
+
+            return content;
+        }
+
+        private static void ExtractFailureContent(
+            string? content,
+            ref string? message,
+            ref string? errorCode)
+        {
+            try
+            {
+                // Optimistic check for JSON object we expect
+                if (content == null ||
+                    !content.StartsWith("{", StringComparison.OrdinalIgnoreCase))
+                    return;
+
+                string? parsedMessage = null;
+                using JsonDocument document = JsonDocument.Parse(content);
+                if (document.RootElement.TryGetProperty("error", out var errorProperty))
+                {
+                    if (errorProperty.TryGetProperty("code", out var codeProperty))
+                    {
+                        errorCode = codeProperty.GetString();
+                    }
+                    if (errorProperty.TryGetProperty("message", out var messageProperty))
+                    {
+                        parsedMessage = messageProperty.GetString();
+                    }
+                }
+
+                // Make sure we parsed a message so we don't overwrite the value with null
+                if (parsedMessage != null)
+                {
+                    message = parsedMessage;
+                }
+            }
+            catch (Exception)
+            {
+                // Ignore any failures - unexpected content will be
+                // included verbatim in the detailed error message
+            }
+        }
+
+        private RequestFailedException CreateRequestFailedExceptionWithContent(
+            Response response,
+            string? message = null,
+            string? content = null,
+            string? errorCode = null,
+            IDictionary<string, string>? additionalInfo = null,
+            Exception? innerException = null)
+        {
+            var formatMessage = CreateRequestFailedMessageWithContent(response, message, content, errorCode, additionalInfo);
+            var exception = new RequestFailedException(response.Status, formatMessage, errorCode, innerException);
+
+            if (additionalInfo != null)
+            {
+                foreach (KeyValuePair<string, string> keyValuePair in additionalInfo)
+                {
+                    exception.Data.Add(keyValuePair.Key, keyValuePair.Value);
+                }
+            }
+
+            return exception;
+        }
+
+        private string CreateRequestFailedMessageWithContent(
+            Response response,
+            string? message,
+            string? content,
+            string? errorCode,
+            IDictionary<string, string>? additionalInfo)
+        {
+            StringBuilder messageBuilder = new StringBuilder()
+                .AppendLine(message ?? DefaultFailureMessage)
+                .Append("Status: ")
+                .Append(response.Status.ToString(CultureInfo.InvariantCulture));
+
+            if (!string.IsNullOrEmpty(response.ReasonPhrase))
+            {
+                messageBuilder.Append(" (")
+                    .Append(response.ReasonPhrase)
+                    .AppendLine(")");
+            }
+            else
+            {
+                messageBuilder.AppendLine();
+            }
+
+            if (!string.IsNullOrWhiteSpace(errorCode))
+            {
+                messageBuilder.Append("ErrorCode: ")
+                    .Append(errorCode)
+                    .AppendLine();
+            }
+
+            if (additionalInfo != null && additionalInfo.Count > 0)
+            {
+                messageBuilder
+                    .AppendLine()
+                    .AppendLine("Additional Information:");
+                foreach (KeyValuePair<string, string> info in additionalInfo)
+                {
+                    messageBuilder
+                        .Append(info.Key)
+                        .Append(": ")
+                        .AppendLine(info.Value);
+                }
+            }
+
+            if (content != null)
+            {
+                messageBuilder
+                    .AppendLine()
+                    .AppendLine("Content:")
+                    .AppendLine(content);
+            }
+
+            messageBuilder
+                .AppendLine()
+                .AppendLine("Headers:");
+
+            foreach (HttpHeader responseHeader in response.Headers)
+            {
+                string headerValue = _sanitizer.SanitizeHeader(responseHeader.Name, responseHeader.Value);
+                messageBuilder.AppendLine($"{responseHeader.Name}: {headerValue}");
+            }
+
+            return messageBuilder.ToString();
+        }
     }
 }