Merge pull request #97 from deploymenttheory/dev

Refactor retry logic in executeRequestWithRetries function

Author: ShocOne

httpclient/httpclient_error_response.go

@@ -0,0 +1,102 @@
+// httpclient_error_response.go
+// This package provides utility functions and structures for handling and categorizing HTTP error responses.
+package httpclient
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/deploymenttheory/go-api-http-client/logger"
+	"go.uber.org/zap"
+)
+
+// APIError represents a more flexible structure for API error responses.
+type APIError struct {
+	StatusCode int                    // HTTP status code
+	Type       string                 // A brief identifier for the type of error
+	Message    string                 // Human-readable message
+	Detail     string                 // Detailed error message
+	Errors     map[string]interface{} // A map to hold various error fields
+	Raw        string                 // Raw response body for unstructured errors
+}
+
+// StructuredError represents a structured error response from the API.
+type StructuredError struct {
+	Error struct {
+		Code    string `json:"code"`
+		Message string `json:"message"`
+	} `json:"error"`
+}
+
+// Error returns a string representation of the APIError.
+func (e *APIError) Error() string {
+	return fmt.Sprintf("API Error (Type: %s, Code: %d): %s", e.Type, e.StatusCode, e.Message)
+}
+
+// handleAPIErrorResponse attempts to parse the error response from the API and logs using zap logger.
+func handleAPIErrorResponse(resp *http.Response, log logger.Logger) *APIError {
+	apiError := &APIError{StatusCode: resp.StatusCode}
+
+	// Attempt to parse the response into a StructuredError
+	var structuredErr StructuredError
+	if err := json.NewDecoder(resp.Body).Decode(&structuredErr); err == nil && structuredErr.Error.Message != "" {
+		apiError.Type = structuredErr.Error.Code
+		apiError.Message = structuredErr.Error.Message
+
+		// Log the structured error details with zap logger
+		log.Warn("API returned structured error",
+			zap.String("error_code", structuredErr.Error.Code),
+			zap.String("error_message", structuredErr.Error.Message),
+			zap.Int("status_code", resp.StatusCode),
+		)
+
+		return apiError
+	}
+
+	// If the structured error parsing fails, attempt a more generic parsing
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		// If reading the response body fails, store the error message and log the error
+		apiError.Raw = "Failed to read API error response body"
+		apiError.Message = err.Error()
+		apiError.Type = "ReadError"
+
+		log.Error("Failed to read API error response body",
+			zap.Error(err),
+		)
+
+		return apiError
+	}
+
+	if err := json.Unmarshal(bodyBytes, &apiError.Errors); err != nil {
+		// If generic parsing also fails, store the raw response body and log the error
+		apiError.Raw = string(bodyBytes)
+		apiError.Message = "Failed to parse API error response"
+		apiError.Type = "UnexpectedError"
+
+		log.Error("Failed to parse API error response",
+			zap.String("raw_response", apiError.Raw),
+		)
+
+		return apiError
+	}
+
+	// Extract fields from the generic error map and log the error with extracted details
+	if msg, ok := apiError.Errors["message"].(string); ok {
+		apiError.Message = msg
+	}
+	if detail, ok := apiError.Errors["detail"].(string); ok {
+		apiError.Detail = detail
+	}
+
+	log.Error("API error",
+		zap.Int("status_code", apiError.StatusCode),
+		zap.String("type", apiError.Type),
+		zap.String("message", apiError.Message),
+		zap.String("detail", apiError.Detail),
+	)
+
+	return apiError
+}

httpclient/httpclient_request.go

@@ -153,66 +153,71 @@ func (c *Client) executeRequestWithRetries(method, endpoint string, body, out in
 	headerManager.SetRequestHeaders(endpoint)
 	headerManager.LogHeaders(c)
 
-	// Calculate the deadline for all retry attempts based on the client configuration.
+	// Define a retry deadline based on the client's total retry duration configuration
 	totalRetryDeadline := time.Now().Add(c.clientConfig.ClientOptions.TotalRetryDuration)
 
-	// Execute the HTTP request with retries
 	var resp *http.Response
 	var retryCount int
-	var requestStartTime = time.Now()
-
-	for time.Now().Before(totalRetryDeadline) {
+	for time.Now().Before(totalRetryDeadline) { // Check if the current time is before the total retry deadline
+		req = req.WithContext(ctx)
 		resp, err = c.do(req, log, method, endpoint)
-
-		// Successful response handling
-		if err == nil && resp.StatusCode >= 200 && resp.StatusCode < 300 {
-			log.LogRequestEnd(method, endpoint, resp.StatusCode, time.Since(requestStartTime))
+		// Check for successful status code
+		if err == nil && resp.StatusCode >= 200 && resp.StatusCode < 400 {
+			if resp.StatusCode >= 300 {
+				log.Warn("Redirect response received", zap.Int("status_code", resp.StatusCode), zap.String("location", resp.Header.Get("Location")))
+			}
+			// Handle the response as successful, even if it's a redirect.
 			return resp, c.handleSuccessResponse(resp, out, log, method, endpoint)
 		}
 
-		// Log and handle non-retryable errors immediately without retrying
+		// Leverage TranslateStatusCode for more descriptive error logging
+		statusMessage := status.TranslateStatusCode(resp)
+
+		// Check for non-retryable errors
 		if resp != nil && status.IsNonRetryableStatusCode(resp) {
-			log.LogError(method, endpoint, resp.StatusCode, err, status.TranslateStatusCode(resp))
-			return resp, err
+			log.Warn("Non-retryable error received", zap.Int("status_code", resp.StatusCode), zap.String("status_message", statusMessage))
+			return resp, handleAPIErrorResponse(resp, log)
 		}
 
-		// Handle rate-limiting errors by parsing the 'Retry-After' header and waiting before the next retry
+		// Parsing rate limit headers if a rate-limit error is detected
 		if status.IsRateLimitError(resp) {
 			waitDuration := parseRateLimitHeaders(resp, log)
-			log.LogRateLimiting(method, endpoint, resp.Header.Get("Retry-After"), waitDuration)
-			time.Sleep(waitDuration)
-			continue
+			if waitDuration > 0 {
+				log.Warn("Rate limit encountered, waiting before retrying", zap.Duration("waitDuration", waitDuration))
+				time.Sleep(waitDuration)
+				continue // Continue to next iteration after waiting
+			}
 		}
 
-		// Retry the request for transient errors using exponential backoff with jitter
+		// Handling retryable errors with exponential backoff
 		if status.IsTransientError(resp) {
 			retryCount++
 			if retryCount > c.clientConfig.ClientOptions.MaxRetryAttempts {
-				// Log max retry attempts reached with structured logging
-				log.LogError(method, endpoint, resp.StatusCode, err, "Max retry attempts reached")
-				break
+				log.Warn("Max retry attempts reached", zap.String("method", method), zap.String("endpoint", endpoint))
+				break // Stop retrying if max attempts are reached
 			}
 			waitDuration := calculateBackoff(retryCount)
-			log.LogRetryAttempt(method, endpoint, retryCount, "Transient error", waitDuration, err)
-			time.Sleep(waitDuration)
-			continue
+			log.Warn("Retrying request due to transient error", zap.String("method", method), zap.String("endpoint", endpoint), zap.Int("retryCount", retryCount), zap.Duration("waitDuration", waitDuration), zap.Error(err))
+			time.Sleep(waitDuration) // Wait before retrying
+			continue                 // Continue to next iteration after waiting
 		}
 
-		// Log non-retryable API errors and break the retry loop
+		// Handle error responses
 		if err != nil || !status.IsRetryableStatusCode(resp.StatusCode) {
+			if apiErr := handleAPIErrorResponse(resp, log); apiErr != nil {
+				err = apiErr
+			}
 			log.LogError(method, endpoint, resp.StatusCode, err, status.TranslateStatusCode(resp))
 			break
 		}
 	}
 
-	// Final error handling after all retries are exhausted
+	// Handles final non-API error.
 	if err != nil {
-		// Log the final error after retries with structured logging
-		log.LogError(method, endpoint, 0, err, "Final error after retries")
 		return nil, err
 	}
 
-	return resp, nil
+	return resp, handleAPIErrorResponse(resp, log)
 }
 
 // executeRequest executes an HTTP request using the specified method, endpoint, and request body without implementing