Merge pull request #167 from deploymenttheory/dev

Introduced a dynamic sized semaphore into http client

Author: ShocOne

concurrency/const.go

@@ -0,0 +1,25 @@
+// concurrency/const.go
+package concurrency
+
+import "time"
+
+const (
+	// MaxAcceptableTTFB represents the maximum acceptable Time to First Byte (TTFB) in milliseconds.
+	// TTFB is the time taken for the server to start sending the first byte of data in response to a request.
+	// Adjustments in concurrency will be made if the TTFB exceeds this threshold.
+	MaxAcceptableTTFB = 300 * time.Millisecond
+
+	// MaxAcceptableThroughput represents the maximum acceptable network throughput in bytes per second.
+	// Throughput is the amount of data transferred over the network within a specific time interval.
+	// Adjustments in concurrency will be made if the network throughput exceeds this threshold.
+	MaxAcceptableThroughput = 5 * 1024 * 1024
+
+	// MaxAcceptableResponseTimeVariability represents the maximum acceptable variability in response times.
+	// It is used as a threshold to dynamically adjust concurrency based on fluctuations in response times.
+	MaxAcceptableResponseTimeVariability = 500 * time.Millisecond
+
+	// ErrorRateThreshold represents the threshold for error rate above which concurrency will be adjusted.
+	// Error rate is calculated as (TotalRateLimitErrors + 5xxErrors) / TotalRequests.
+	// Adjustments in concurrency will be made if the error rate exceeds this threshold. A threshold of 0.1 (or 10%) is common.
+	ErrorRateThreshold = 0.1
+)

concurrency/dynamic_token_adjustment.go

@@ -27,12 +27,33 @@ type ConcurrencyHandler struct {
 
 // ConcurrencyMetrics captures various metrics related to managing concurrency for the client's interactions with the API.
 type ConcurrencyMetrics struct {
-	TotalRequests        int64
-	TotalRetries         int64
-	TotalRateLimitErrors int64
-	TotalResponseTime    time.Duration
-	TokenWaitTime        time.Duration
-	Lock                 sync.Mutex // Protects performance metrics fields
+	TotalRequests        int64         // Total number of requests made
+	TotalRetries         int64         // Total number of retry attempts
+	TotalRateLimitErrors int64         // Total number of rate limit errors encountered
+	TokenWaitTime        time.Duration // Total time spent waiting for tokens
+	TTFB                 struct {      // Metrics related to Time to First Byte (TTFB)
+		Total time.Duration // Total Time to First Byte (TTFB) for all requests
+		Count int64         // Count of requests used for calculating TTFB
+		Lock  sync.Mutex    // Lock for TTFB metrics
+	}
+	Throughput struct { // Metrics related to network throughput
+		Total float64    // Total network throughput for all requests
+		Count int64      // Count of requests used for calculating throughput
+		Lock  sync.Mutex // Lock for throughput metrics/
+	}
+	ResponseTimeVariability struct { // Metrics related to response time variability
+		Total           time.Duration // Total response time for all requests
+		Average         time.Duration // Average response time across all requests
+		Variance        float64       // Variance of response times
+		Count           int64         // Count of responses used for calculating response time variability
+		Lock            sync.Mutex    // Lock for response time variability metrics
+		StdDevThreshold float64       // Maximum acceptable standard deviation for adjusting concurrency
+	}
+	ResponseCodeMetrics struct {
+		ErrorRate float64    // Error rate calculated as (TotalRateLimitErrors + 5xxErrors) / TotalRequests
+		Lock      sync.Mutex // Lock for response code metrics
+	}
+	Lock sync.Mutex // Lock for overall metrics fields
 }
 
 // NewConcurrencyHandler initializes a new ConcurrencyHandler with the given