Delete logger package files for structured messaging

Author: ShocOne

logger/zaplogger_structured_messaging.go renamed to logger/zaplogger_log_levels.go

@@ -0,0 +1,72 @@
+// zaplogger_logfields.go
+package logger
+
+import (
+	"time"
+
+	"go.uber.org/zap"
+)
+
+// LogRequestStart logs the initiation of an HTTP request, including the HTTP method, URL, and headers.
+// This function is intended to be called at the beginning of an HTTP request lifecycle.
+func LogRequestStart(logger *zap.Logger, requestID string, userID string, method string, url string, headers map[string][]string) {
+	fields := []zap.Field{
+		zap.String("event", "request_start"),
+		zap.String("method", method),
+		zap.String("url", url),
+		zap.Reflect("headers", headers), // Consider sanitizing or selectively logging headers
+	}
+	logger.Info("HTTP request started", fields...)
+}
+
+// LogRequestEnd logs the completion of an HTTP request, including the HTTP method, URL, status code, and duration.
+// This function is intended to be called at the end of an HTTP request lifecycle.
+func LogRequestEnd(logger *zap.Logger, method string, url string, statusCode int, duration time.Duration) {
+	fields := []zap.Field{
+		zap.String("event", "request_end"),
+		zap.String("method", method),
+		zap.String("url", url),
+		zap.Int("status_code", statusCode),
+		zap.Duration("duration", duration),
+	}
+	logger.Info("HTTP request completed", fields...)
+}
+
+// LogError logs an error that occurs during the processing of an HTTP request, including the HTTP method, URL, status code, error message, and stack trace.
+// This function is intended to be called when an error is encountered during an HTTP request lifecycle.
+func LogError(logger *zap.Logger, method string, url string, statusCode int, err error, stacktrace string) {
+	fields := []zap.Field{
+		zap.String("event", "request_error"),
+		zap.String("method", method),
+		zap.String("url", url),
+		zap.Int("status_code", statusCode),
+		zap.String("error_message", err.Error()),
+		zap.String("stacktrace", stacktrace),
+	}
+	logger.Error("Error during HTTP request", fields...)
+}
+
+// LogRetryAttempt logs a retry attempt for an HTTP request, including the HTTP method, URL, attempt number, and reason for the retry.
+// This function is intended to be called when an HTTP request is retried.
+func LogRetryAttempt(logger *zap.Logger, method string, url string, attempt int, reason string) {
+	fields := []zap.Field{
+		zap.String("event", "retry_attempt"),
+		zap.String("method", method),
+		zap.String("url", url),
+		zap.Int("attempt", attempt),
+		zap.String("reason", reason),
+	}
+	logger.Warn("HTTP request retry", fields...)
+}
+
+// LogRateLimiting logs when an HTTP request is rate-limited, including the HTTP method, URL, and the value of the 'Retry-After' header.
+// This function is intended to be called when an HTTP request encounters rate limiting.
+func LogRateLimiting(logger *zap.Logger, method string, url string, retryAfter string) {
+	fields := []zap.Field{
+		zap.String("event", "rate_limited"),
+		zap.String("method", method),
+		zap.String("url", url),
+		zap.String("retry_after", retryAfter),
+	}
+	logger.Warn("HTTP request rate-limited", fields...)
+}

logger/zaplogger_structured_messaging_test.go renamed to logger/zaplogger_log_levels_test.go

@@ -0,0 +1,2 @@
+// zaplogger_structured_messaging_test.go
+package logger

logger/zaplogger_logfields.go

@@ -1,68 +1,12 @@
-// http_error_handling.go
+// status.go
 // This package provides utility functions and structures for handling and categorizing HTTP error responses.
-package errors
+package status
 
 import (
-	"encoding/json"
 	"fmt"
 	"net/http"
-
-	"github.com/deploymenttheory/go-api-http-client/logger"
-	"go.uber.org/zap"
 )
 
-// APIError represents a structured API error response.
-type APIError struct {
-	StatusCode int    // HTTP status code
-	Type       string // A brief identifier for the type of error (e.g., "RateLimit", "BadRequest", etc.)
-	Message    string // Human-readable message
-}
-
-// 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)
-}
-
-// HandleAPIError handles error responses from the API, converting them into a structured error if possible.
-func HandleAPIError(resp *http.Response, log logger.Logger) *APIError {
-	var structuredErr StructuredError
-	err := json.NewDecoder(resp.Body).Decode(&structuredErr)
-	if err == nil && structuredErr.Error.Message != "" {
-		// Log the structured error details
-		log.Warn("API returned structured error",
-			zap.String("status", resp.Status),
-			zap.String("error_code", structuredErr.Error.Code),
-			zap.String("error_message", structuredErr.Error.Message),
-		)
-		return &APIError{
-			StatusCode: resp.StatusCode,
-			Type:       structuredErr.Error.Code,
-			Message:    structuredErr.Error.Message,
-		}
-	}
-
-	// Default error message for non-structured responses or decode failures
-	errMsg := fmt.Sprintf("Unexpected error with status code: %d", resp.StatusCode)
-	log.Error("Failed to decode API error message, using default error message",
-		zap.String("status", resp.Status),
-		zap.String("error_message", errMsg),
-	)
-
-	return &APIError{
-		StatusCode: resp.StatusCode,
-		Type:       "UnexpectedError",
-		Message:    errMsg,
-	}
-}
-
 // TranslateStatusCode provides a human-readable message for HTTP status codes.
 func TranslateStatusCode(resp *http.Response) string {