Refactor APIHandler and Client struct***

***Update APIHandler interface and its implementations in APIHandler.go.***
***Update Client struct and its methods in http_client.go.***
***Update DoRequest and DoMultipartRequest methods in http_request.go.***
***Add logger package and use logger.Logger interface in http_client.go.

Author: ShocOne

internal/apihandlers/jamfpro/jamfpro_api_handler.go

@@ -48,8 +48,6 @@ import (
 	"strings"
 
 	_ "embed"
-
-	"github.com/deploymenttheory/go-api-http-client/internal/httpclient"
 )
 
 // Endpoint constants represent the URL suffixes used for Jamf API token interactions.
@@ -104,9 +102,15 @@ type EndpointConfig struct {
 
 // JamfAPIHandler implements the APIHandler interface for the Jamf Pro API.
 type JamfAPIHandler struct {
-	logger             httpclient.Logger // logger is used to output logs for the API handling processes.
-	OverrideBaseDomain string            // OverrideBaseDomain is used to override the base domain for URL construction.
-	InstanceName       string            // InstanceName is the name of the Jamf instance.
+	OverrideBaseDomain string // OverrideBaseDomain is used to override the base domain for URL construction.
+	InstanceName       string // InstanceName is the name of the Jamf instance.
+}
+
+type Logger interface {
+	Debug(msg string, keysAndValues ...interface{})
+	Info(msg string, keysAndValues ...interface{})
+	Warn(msg string, keysAndValues ...interface{})
+	Error(msg string, keysAndValues ...interface{})
 }
 
 // Functions
@@ -121,18 +125,18 @@ func (j *JamfAPIHandler) GetBaseDomain() string {
 }
 
 // ConstructAPIResourceEndpoint returns the full URL for a Jamf API resource endpoint path.
-func (j *JamfAPIHandler) ConstructAPIResourceEndpoint(endpointPath string) string {
+func (j *JamfAPIHandler) ConstructAPIResourceEndpoint(endpointPath string, logger Logger) string {
 	baseDomain := j.GetBaseDomain()
 	url := fmt.Sprintf("https://%s%s%s", j.InstanceName, baseDomain, endpointPath)
-	j.logger.Info("Request will be made to API   URL:", "URL", url)
+	logger.Info("Request will be made to API   URL:", "URL", url)
 	return url
 }
 
 // ConstructAPIAuthEndpoint returns the full URL for a Jamf API auth endpoint path.
-func (j *JamfAPIHandler) ConstructAPIAuthEndpoint(endpointPath string) string {
+func (j *JamfAPIHandler) ConstructAPIAuthEndpoint(endpointPath string, logger Logger) string {
 	baseDomain := j.GetBaseDomain()
 	url := fmt.Sprintf("https://%s%s%s", j.InstanceName, baseDomain, endpointPath)
-	j.logger.Info("Request will be made to API authentication URL:", "URL", url)
+	logger.Info("Request will be made to API authentication URL:", "URL", url)
 	return url
 }
 
@@ -144,36 +148,36 @@ func (j *JamfAPIHandler) ConstructAPIAuthEndpoint(endpointPath string) string {
 // - For url endpoints starting with "/api", it defaults to "application/json" for the JamfPro API.
 // If the endpoint does not match any of the predefined patterns, "application/json" is used as a fallback.
 // This method logs the decision process at various stages for debugging purposes.
-func (u *JamfAPIHandler) GetContentTypeHeader(endpoint string) string {
+func (u *JamfAPIHandler) GetContentTypeHeader(endpoint string, logger Logger) string {
 	// Dynamic lookup from configuration should be the first priority
 	for key, config := range configMap {
 		if strings.HasPrefix(endpoint, key) {
 			if config.ContentType != nil {
-				u.logger.Debug("Content-Type for endpoint found in configMap", "endpoint", endpoint, "content_type", *config.ContentType)
+				logger.Debug("Content-Type for endpoint found in configMap", "endpoint", endpoint, "content_type", *config.ContentType)
 				return *config.ContentType
 			}
-			u.logger.Debug("Content-Type for endpoint is nil in configMap, handling as special case", "endpoint", endpoint)
+			logger.Debug("Content-Type for endpoint is nil in configMap, handling as special case", "endpoint", endpoint)
 			// If a nil ContentType is an expected case, do not set Content-Type header.
 			return "" // Return empty to indicate no Content-Type should be set.
 		}
 	}
 
 	// If no specific configuration is found, then check for standard URL patterns.
 	if strings.Contains(endpoint, "/JSSResource") {
-		u.logger.Debug("Content-Type for endpoint defaulting to XML for Classic API", "endpoint", endpoint)
+		logger.Debug("Content-Type for endpoint defaulting to XML for Classic API", "endpoint", endpoint)
 		return "application/xml" // Classic API uses XML
 	} else if strings.Contains(endpoint, "/api") {
-		u.logger.Debug("Content-Type for endpoint defaulting to JSON for JamfPro API", "endpoint", endpoint)
+		logger.Debug("Content-Type for endpoint defaulting to JSON for JamfPro API", "endpoint", endpoint)
 		return "application/json" // JamfPro API uses JSON
 	}
 
 	// Fallback to JSON if no other match is found.
-	u.logger.Debug("Content-Type for endpoint not found in configMap or standard patterns, using default JSON", "endpoint", endpoint)
+	logger.Debug("Content-Type for endpoint not found in configMap or standard patterns, using default JSON", "endpoint", endpoint)
 	return "application/json"
 }
 
 // MarshalRequest encodes the request body according to the endpoint for the API.
-func (u *JamfAPIHandler) MarshalRequest(body interface{}, method string, endpoint string) ([]byte, error) {
+func (u *JamfAPIHandler) MarshalRequest(body interface{}, method string, endpoint string, logger Logger) ([]byte, error) {
 	var (
 		data []byte
 		err  error
@@ -195,26 +199,26 @@ func (u *JamfAPIHandler) MarshalRequest(body interface{}, method string, endpoin
 		}
 
 		if method == "POST" || method == "PUT" {
-			u.logger.Trace("XML Request Body:", "Body", string(data))
+			logger.Debug("XML Request Body:", "Body", string(data))
 		}
 
 	case "json":
 		data, err = json.Marshal(body)
 		if err != nil {
-			u.logger.Error("Failed marshaling JSON request", "error", err)
+			logger.Error("Failed marshaling JSON request", "error", err)
 			return nil, err
 		}
 
 		if method == "POST" || method == "PUT" || method == "PATCH" {
-			u.logger.Debug("JSON Request Body:", string(data))
+			logger.Debug("JSON Request Body:", string(data))
 		}
 	}
 
 	return data, nil
 }
 
 // UnmarshalResponse decodes the response body from XML or JSON format depending on the Content-Type header.
-func (u *JamfAPIHandler) UnmarshalResponse(resp *http.Response, out interface{}) error {
+func (u *JamfAPIHandler) UnmarshalResponse(resp *http.Response, out interface{}, logger Logger) error {
 	// Handle DELETE method
 	if resp.Request.Method == "DELETE" {
 		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
@@ -226,16 +230,16 @@ func (u *JamfAPIHandler) UnmarshalResponse(resp *http.Response, out interface{})
 
 	bodyBytes, err := io.ReadAll(resp.Body)
 	if err != nil {
-		u.logger.Error("Failed reading response body", "error", err)
+		logger.Error("Failed reading response body", "error", err)
 		return err
 	}
 
 	// Log the raw response body and headers
-	u.logger.Trace("Raw HTTP Response:", string(bodyBytes))
-	u.logger.Debug("Unmarshaling response", "status", resp.Status)
+	logger.Trace("Raw HTTP Response:", string(bodyBytes))
+	logger.Debug("Unmarshaling response", "status", resp.Status)
 
 	// Log headers when in debug mode
-	u.logger.Debug("HTTP Response Headers:", resp.Header)
+	logger.Debug("HTTP Response Headers:", resp.Header)
 
 	// Check the Content-Type and Content-Disposition headers
 	contentType := resp.Header.Get("Content-Type")
@@ -249,7 +253,7 @@ func (u *JamfAPIHandler) UnmarshalResponse(resp *http.Response, out interface{})
 	// If content type is HTML, extract the error message
 	if strings.Contains(contentType, "text/html") {
 		errMsg := ExtractErrorMessageFromHTML(string(bodyBytes))
-		u.logger.Warn("Received HTML content", "error_message", errMsg, "status_code", resp.StatusCode)
+		logger.Warn("Received HTML content", "error_message", errMsg, "status_code", resp.StatusCode)
 		return &APIError{
 			StatusCode: resp.StatusCode,
 			Message:    errMsg,
@@ -289,12 +293,12 @@ func (u *JamfAPIHandler) UnmarshalResponse(resp *http.Response, out interface{})
 		// If unmarshalling fails, check if the content might be HTML
 		if strings.Contains(string(bodyBytes), "<html>") {
 			errMsg := ExtractErrorMessageFromHTML(string(bodyBytes))
-			u.logger.Warn("Received HTML content instead of expected format", "error_message", errMsg, "status_code", resp.StatusCode)
+			logger.Warn("Received HTML content instead of expected format", "error_message", errMsg, "status_code", resp.StatusCode)
 			return fmt.Errorf(errMsg)
 		}
 
 		// Log the error and return it
-		u.logger.Error("Failed to unmarshal response", "error", err)
+		logger.Error("Failed to unmarshal response", "error", err)
 		return fmt.Errorf("failed to unmarshal response: %v", err)
 	}
 

internal/httpclient/api_handler.go

@@ -13,12 +13,12 @@ import (
 type APIHandler interface {
 	GetBaseDomain() string
 	ConstructAPIResourceEndpoint(endpointPath string) string
-	ConstructAPIAuthEndpoint(endpointPath string) string
-	MarshalRequest(body interface{}, method string, endpoint string) ([]byte, error)
-	MarshalMultipartRequest(fields map[string]string, files map[string]string) ([]byte, string, error) // New method for multipart
-	UnmarshalResponse(resp *http.Response, out interface{}) error
-	GetContentTypeHeader(method string) string
-	GetAcceptHeader() string
+	ConstructAPIAuthEndpoint(endpointPath string, logger Logger) string
+	MarshalRequest(body interface{}, method string, endpoint string, logger Logger) ([]byte, error)
+	MarshalMultipartRequest(fields map[string]string, files map[string]string, logger Logger) ([]byte, string, error)
+	UnmarshalResponse(resp *http.Response, out interface{}, logger Logger) error
+	GetContentTypeHeader(method string, logger Logger) string
+	GetAcceptHeader(logger Logger) string
 }
 
 // LoadAPIHandler returns an APIHandler based on the provided API type.

internal/httpclient/http_client.go

@@ -13,6 +13,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/deploymenttheory/go-api-http-client/internal/logger"
 	"go.uber.org/zap"
 )
 
@@ -23,11 +24,10 @@ type Config struct {
 	Auth         AuthConfig // User can either supply these values manually or pass from LoadAuthConfig/Env vars
 	APIType      string     `json:"apiType"`
 	// Optional
-	LogLevel                  LogLevel // Field for defining tiered logging level.
-	MaxRetryAttempts          int      // Config item defines the max number of retry request attempts for retryable HTTP methods.
+	LogLevel                  logger.LogLevel // Field for defining tiered logging level.
+	MaxRetryAttempts          int             // Config item defines the max number of retry request attempts for retryable HTTP methods.
 	EnableDynamicRateLimiting bool
-	Logger                    Logger // Field for the packages initailzed logger
-	MaxConcurrentRequests     int    // Field for defining the maximum number of concurrent requests allowed in the semaphore
+	MaxConcurrentRequests     int // Field for defining the maximum number of concurrent requests allowed in the semaphore
 	TokenRefreshBufferPeriod  time.Duration
 	TotalRetryDuration        time.Duration
 	CustomTimeout             time.Duration
@@ -67,15 +67,15 @@ type Client struct {
 	httpClient                 *http.Client
 	tokenLock                  sync.Mutex
 	config                     Config
-	logger                     Logger
+	logger                     logger.Logger
 	ConcurrencyMgr             *ConcurrencyManager
 	PerfMetrics                PerformanceMetrics
 }
 
 // BuildClient creates a new HTTP client with the provided configuration.
 func BuildClient(config Config) (*Client, error) {
 	// Use the Logger interface type for the logger variable
-	var logger Logger
+	var logger logger.Logger
 	if config.Logger == nil {
 		logger = NewDefaultLogger()
 	} else {

internal/httpclient/http_request.go

@@ -67,17 +67,16 @@ func (c *Client) DoRequest(method, endpoint string, body, out interface{}) (*htt
 	ctx = context.WithValue(ctx, requestIDKey{}, requestID)
 
 	// Determine which set of encoding and content-type request rules to use
-	//handler := GetAPIHandler(endpoint, c.config.LogLevel)
-	handler := GetAPIHandler(c.config)
+	apiHandler := c.APIHandler
 
 	// Marshal Request with correct encoding
-	requestData, err := handler.MarshalRequest(body, method, endpoint)
+	requestData, err := apiHandler.MarshalRequest(body, method, endpoint, c.logger)
 	if err != nil {
 		return nil, err
 	}
 
 	// Construct URL using the ConstructAPIResourceEndpoint function
-	url := c.ConstructAPIResourceEndpoint(endpoint)
+	url := apiHandler.ConstructAPIResourceEndpoint(endpoint)
 
 	// Initialize total request counter
 	c.PerfMetrics.lock.Lock()
@@ -91,9 +90,9 @@ func (c *Client) DoRequest(method, endpoint string, body, out interface{}) (*htt
 	}
 
 	// Define header content type based on url and http method
-	contentType := handler.GetContentTypeHeader(endpoint)
+	contentType := apiHandler.GetContentTypeHeader(endpoint, c.logger)
 	// Define Request Headers dynamically based on handler logic
-	acceptHeader := handler.GetAcceptHeader()
+	acceptHeader := apiHandler.GetAcceptHeader(c.logger)
 
 	// Set Headers
 	req.Header.Add("Authorization", "Bearer "+c.Token)
@@ -151,7 +150,7 @@ func (c *Client) DoRequest(method, endpoint string, body, out interface{}) (*htt
 			}
 
 			// Handle (unmarshal) response with API Handler
-			if err := handler.UnmarshalResponse(resp, out); err != nil {
+			if err := apiHandler.UnmarshalResponse(resp, out, c.logger); err != nil {
 				switch e := err.(type) {
 				case *APIError: // Assuming APIError is a type that includes StatusCode and Message
 					// Log the API error with structured logging
@@ -258,7 +257,7 @@ func (c *Client) DoRequest(method, endpoint string, body, out interface{}) (*htt
 		CheckDeprecationHeader(resp, c.logger)
 
 		// Handle (unmarshal) response with API Handler
-		if err := handler.UnmarshalResponse(resp, out); err != nil {
+		if err := apiHandler.UnmarshalResponse(resp, out, c.logger); err != nil {
 			switch e := err.(type) {
 			case *APIError: // Assuming APIError is a type that includes StatusCode and Message
 				// Log the API error with structured logging
@@ -338,17 +337,16 @@ func (c *Client) DoMultipartRequest(method, endpoint string, fields map[string]s
 	}
 
 	// Determine which set of encoding and content-type request rules to use
-	//handler := GetAPIHandler(endpoint, c.config.LogLevel)
-	handler := GetAPIHandler(c.config)
+	apiHandler := c.APIHandler
 
 	// Marshal the multipart form data
-	requestData, contentType, err := handler.MarshalMultipartRequest(fields, files)
+	requestData, contentType, err := apiHandler.MarshalMultipartRequest(fields, files, c.logger)
 	if err != nil {
 		return nil, err
 	}
 
 	// Construct URL using the ConstructAPIResourceEndpoint function
-	url := c.ConstructAPIResourceEndpoint(endpoint)
+	url := apiHandler.ConstructAPIResourceEndpoint(endpoint)
 
 	// Create the request
 	req, err := http.NewRequest(method, url, bytes.NewBuffer(requestData))
@@ -392,7 +390,7 @@ func (c *Client) DoMultipartRequest(method, endpoint string, fields map[string]s
 	}
 
 	// Unmarshal the response
-	if err := handler.UnmarshalResponse(resp, out); err != nil {
+	if err := apiHandler.UnmarshalResponse(resp, out, c.logger); err != nil {
 		c.logger.Error("Failed to unmarshal HTTP response",
 			"method", method,
 			"endpoint", endpoint,

internal/httpclient/http_logger.go internal/logger/logger.gointernal/httpclient/http_logger.go renamed to internal/logger/logger.go

@@ -1,4 +1,4 @@
-package httpclient
+package logger
 
 import (
 	"go.uber.org/zap"