Merge pull request #83 from deploymenttheory/dev

Refactor authentication and concurrency management***

Author: ShocOne

httpclient/httpclient_auth_oauth.go

@@ -14,7 +14,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/deploymenttheory/go-api-http-client/logger"
 	"go.uber.org/zap"
 )
 
@@ -42,7 +41,8 @@ func (c *Client) SetOAuthCredentials(credentials OAuthCredentials) {
 
 // ObtainOAuthToken fetches an OAuth access token using the provided OAuthCredentials (Client ID and Client Secret).
 // It updates the client's Token and Expiry fields with the obtained values.
-func (c *Client) ObtainOAuthToken(credentials AuthConfig, log logger.Logger) error {
+func (c *Client) ObtainOAuthToken(credentials AuthConfig) error {
+	log := c.Logger
 
 	// Use the APIHandler's method to get the OAuth token endpoint
 	oauthTokenEndpoint := c.APIHandler.GetOAuthTokenEndpoint()

httpclient/httpclient_auth_token_management.go

@@ -4,7 +4,6 @@ package httpclient
 import (
 	"time"
 
-	"github.com/deploymenttheory/go-api-http-client/logger"
 	"go.uber.org/zap"
 )
 
@@ -17,22 +16,24 @@ type TokenResponse struct {
 // ValidAuthTokenCheck checks if the current token is valid and not close to expiry.
 // If the token is invalid, it tries to refresh it.
 // It returns a boolean indicating the validity of the token and an error if there's a failure.
-func (c *Client) ValidAuthTokenCheck(log logger.Logger) (bool, error) {
+func (c *Client) ValidAuthTokenCheck() (bool, error) {
+	log := c.Logger
+
 	if c.Token == "" {
-		c.Logger.Debug("No token found, attempting to obtain a new one")
+		log.Debug("No token found, attempting to obtain a new one")
 		if c.AuthMethod == "bearer" {
-			c.Logger.Info("Credential Match", zap.String("AuthMethod", c.AuthMethod))
+			log.Info("Credential Match", zap.String("AuthMethod", c.AuthMethod))
 			err := c.ObtainToken(log)
 			if err != nil {
-				return false, c.Logger.Error("Failed to obtain bearer token", zap.Error(err))
+				return false, log.Error("Failed to obtain bearer token", zap.Error(err))
 			}
 		} else if c.AuthMethod == "oauth" {
-			c.Logger.Info("Credential Match", zap.String("AuthMethod", c.AuthMethod))
-			if err := c.ObtainOAuthToken(c.clientConfig.Auth, log); err != nil {
-				return false, c.Logger.Error("Failed to obtain OAuth token", zap.Error(err))
+			log.Info("Credential Match", zap.String("AuthMethod", c.AuthMethod))
+			if err := c.ObtainOAuthToken(c.clientConfig.Auth); err != nil {
+				return false, log.Error("Failed to obtain OAuth token", zap.Error(err))
 			}
 		} else {
-			return false, c.Logger.Error("No valid credentials provided. Unable to obtain a token", zap.String("authMethod", c.AuthMethod))
+			return false, log.Error("No valid credentials provided. Unable to obtain a token", zap.String("authMethod", c.AuthMethod))
 		}
 	}
 
@@ -41,18 +42,18 @@ func (c *Client) ValidAuthTokenCheck(log logger.Logger) (bool, error) {
 		if c.BearerTokenAuthCredentials.Username != "" && c.BearerTokenAuthCredentials.Password != "" {
 			err = c.RefreshToken(log)
 		} else if c.OAuthCredentials.ClientID != "" && c.OAuthCredentials.ClientSecret != "" {
-			err = c.ObtainOAuthToken(c.clientConfig.Auth, log)
+			err = c.ObtainOAuthToken(c.clientConfig.Auth)
 		} else {
-			return false, c.Logger.Error("Unknown auth method", zap.String("authMethod", c.AuthMethod))
+			return false, log.Error("Unknown auth method", zap.String("authMethod", c.AuthMethod))
 		}
 
 		if err != nil {
-			return false, c.Logger.Error("Failed to refresh token", zap.Error(err))
+			return false, log.Error("Failed to refresh token", zap.Error(err))
 		}
 	}
 
 	if time.Until(c.Expiry) < c.clientConfig.ClientOptions.TokenRefreshBufferPeriod {
-		return false, c.Logger.Error(
+		return false, log.Error(
 			"Token lifetime setting less than buffer",
 			zap.Duration("buffer_period", c.clientConfig.ClientOptions.TokenRefreshBufferPeriod),
 			zap.Duration("time_until_expiry", time.Until(c.Expiry)),

httpclient/httpclient_concurrency_management.go

@@ -70,9 +70,6 @@ func NewConcurrencyManager(limit int, logger logger.Logger, debugMode bool) *Con
 // - ctx: The parent context from which the new context with timeout will be derived.
 // This allows for proper request cancellation and timeout handling.
 //
-// - log: An instance of a logger (conforming to the logger.Logger interface), used
-// to log relevant information and errors during the token acquisition process.
-//
 // Returns:
 // - A new context containing the acquired request ID, which should be passed to
 // subsequent operations requiring concurrency control.
@@ -84,7 +81,9 @@ func NewConcurrencyManager(limit int, logger logger.Logger, debugMode bool) *Con
 // This function should be called before making an HTTP request that needs to be
 // controlled for concurrency. The returned context should be used for the HTTP
 // request to ensure it is associated with the acquired concurrency token.
-func (c *Client) AcquireConcurrencyToken(ctx context.Context, log logger.Logger) (context.Context, error) {
+func (c *Client) AcquireConcurrencyToken(ctx context.Context) (context.Context, error) {
+	log := c.Logger
+
 	// Measure the token acquisition start time
 	tokenAcquisitionStart := time.Now()
 
@@ -263,6 +262,7 @@ func (c *ConcurrencyManager) AdjustConcurrencyLimit(newLimit int) {
 // time and decides on a new concurrency limit. The method ensures that the new
 // limit respects the minimum and maximum allowed concurrency bounds.
 func (c *Client) AdjustConcurrencyBasedOnMetrics() {
+	log := c.Logger
 	// Get average acquisition time
 	avgAcquisitionTime := c.ConcurrencyMgr.AverageAcquisitionTime()
 
@@ -295,7 +295,7 @@ func (c *Client) AdjustConcurrencyBasedOnMetrics() {
 	if newLimit != currentLimit {
 		c.ConcurrencyMgr.AdjustConcurrencyLimit(newLimit)
 
-		c.Logger.Debug("Adjusted concurrency",
+		log.Debug("Adjusted concurrency",
 			zap.Int("OldLimit", currentLimit),
 			zap.Int("NewLimit", newLimit),
 			zap.String("Reason", "Based on average acquisition time"),

httpclient/httpclient_request.go

@@ -111,13 +111,13 @@ func (c *Client) executeRequestWithRetries(method, endpoint string, body, out in
 	log.Debug("Executing request with retries", zap.String("method", method), zap.String("endpoint", endpoint))
 
 	// Auth Token validation check
-	valid, err := c.ValidAuthTokenCheck(log)
+	valid, err := c.ValidAuthTokenCheck()
 	if err != nil || !valid {
 		return nil, err
 	}
 
 	// Acquire a token for concurrency management
-	ctx, err := c.AcquireConcurrencyToken(context.Background(), log)
+	ctx, err := c.AcquireConcurrencyToken(context.Background())
 	if err != nil {
 		return nil, err
 	}
@@ -255,13 +255,13 @@ func (c *Client) executeRequest(method, endpoint string, body, out interface{})
 	log.Debug("Executing request without retries", zap.String("method", method), zap.String("endpoint", endpoint))
 
 	// Auth Token validation check
-	valid, err := c.ValidAuthTokenCheck(log)
+	valid, err := c.ValidAuthTokenCheck()
 	if err != nil || !valid {
 		return nil, err
 	}
 
 	// Acquire a token for concurrency management
-	ctx, err := c.AcquireConcurrencyToken(context.Background(), log)
+	ctx, err := c.AcquireConcurrencyToken(context.Background())
 	if err != nil {
 		return nil, err
 	}
@@ -443,8 +443,9 @@ func (c *Client) handleSuccessResponse(resp *http.Response, out interface{}, log
 // The caller should handle closing the response body when successful.
 func (c *Client) DoMultipartRequest(method, endpoint string, fields map[string]string, files map[string]string, out interface{}) (*http.Response, error) {
 	log := c.Logger
+
 	// Auth Token validation check
-	valid, err := c.ValidAuthTokenCheck(log)
+	valid, err := c.ValidAuthTokenCheck()
 	if err != nil || !valid {
 		return nil, err
 	}