Added comments for better readability and fixed probabistic patterns

lib/metrics.go

@@ -10,71 +10,105 @@ import (
 	"time"
 )
 
+// Global metrics instance to track performance during load testing
 var metrics = PerformanceMetrics{
-	MinLatency:       time.Duration(math.MaxInt64),
+	// Initialize MinLatency to the maximum possible duration
+	MinLatency: time.Duration(math.MaxInt64),
+	// Initialize response counters map
 	ResponseCounters: make(map[int]int32),
 }
 
+// UpdateMetrics synchronously updates performance metrics for each request
+//   - duration: time taken to complete the request
+//   - resp: HTTP response from the request
+//   - second: elapsed seconds since the start of the test
 func UpdateMetrics(duration time.Duration, resp *http.Response, second int) {
 	metrics.Mu.Lock()
 	defer metrics.Mu.Unlock()
 
-	fmt.Printf("Updating metrics - Duration: %v, Status: %d\n", duration, resp.StatusCode) // Debug log
-
+	// Increment total requests
 	metrics.TotalRequests++
+	// Add current request's latency to total
 	metrics.TotalLatency += duration
 
+	// Update maximum latency if current duration is higher
 	if duration > metrics.MaxLatency {
 		metrics.MaxLatency = duration
 	}
+	// Update minimum latency if current duration is lower
 	if duration < metrics.MinLatency {
 		metrics.MinLatency = duration
 	}
 
+	// Track successful responses
 	if resp.StatusCode == http.StatusOK {
 		metrics.TotalResponses++
 		metrics.ResponseCounters[second]++
 	}
 
-	// Debug log
+	// Debug log of current metrics
 	fmt.Printf("Current metrics - Total Requests: %d, Total Responses: %d\n",
 		metrics.TotalRequests, metrics.TotalResponses)
 }
 
+// CalculateAndPrintMetrics generates a comprehensive report of load test performance
+// Parameters:
+//   - startTime: when the load test began
+//   - requestsPerSecond: target request rate
+//   - endpoint: URL being tested
+//   - patterns: request patterns used in the test
 func CalculateAndPrintMetrics(startTime time.Time, requestsPerSecond float64, endpoint string, patterns []RequestPattern) {
+	// Small delay to ensure all metrics are captured
 	time.Sleep(100 * time.Millisecond)
 
 	metrics.Mu.Lock()
 	defer metrics.Mu.Unlock()
 
+	// Calculate average latency
 	averageLatency := time.Duration(0)
 	if metrics.TotalRequests > 0 {
 		averageLatency = metrics.TotalLatency / time.Duration(metrics.TotalRequests)
 	}
 
+	// Calculate total test duration and total responses
 	totalDuration := time.Since(startTime).Seconds()
 	totalResponses := int32(0)
 	for _, count := range metrics.ResponseCounters {
 		totalResponses += count
 	}
 
+	// Ensure MinLatency is not left at its initial max value
 	if metrics.MinLatency == time.Duration(math.MaxInt64) {
 		metrics.MinLatency = 0
 	}
 
+	// Build detailed results string
 	results := fmt.Sprintf("Load Test Report\n")
 	results += fmt.Sprintf("=============\n\n")
 
+	// Report endpoint and request pattern
 	results += fmt.Sprintf("Endpoint: %s\n", endpoint)
 	results += fmt.Sprintf("Pattern: ")
+
 	for i, p := range patterns {
 		if i > 0 {
 			results += " → "
 		}
-		results += fmt.Sprintf("%d%s", p.Sequence, strings.ToLower(p.Verb[:1]))
+
+		var patternDesc string
+		if p.Percentage > 0 && p.Percentage < 100 {
+			// Probabilistic pattern (e.g., "20%p80%g")
+			patternDesc = fmt.Sprintf("%.0f%%%s", p.Percentage, strings.ToLower(p.Verb[:1]))
+		} else {
+			// Simple or sequential pattern (e.g., "5p", "3g", "1p5g")
+			patternDesc = fmt.Sprintf("%d%s", p.Sequence, strings.ToLower(p.Verb[:1]))
+		}
+
+		results += patternDesc
 	}
 	results += "\n\n"
 
+	// Detailed performance metrics
 	results += fmt.Sprintf("Performance Metrics\n")
 	results += fmt.Sprintf("-----------------\n")
 	results += fmt.Sprintf("Total Requests Sent: %d\n", metrics.TotalRequests)
@@ -86,15 +120,23 @@ func CalculateAndPrintMetrics(startTime time.Time, requestsPerSecond float64, en
 	results += fmt.Sprintf("Requests/sec (Actual): %.2f\n", float64(metrics.TotalRequests)/totalDuration)
 	results += fmt.Sprintf("Responses/sec: %.2f\n", float64(totalResponses)/totalDuration)
 
+	// Print and save the report
 	fmt.Println(results)
 	saveReport(results)
 }
 
+// saveReport writes the load test results to a timestamped file in the .reports directory
+// Parameters:
+//   - results: formatted results string to be saved
 func saveReport(results string) {
+	// Ensure .reports directory exists
 	resultsDir := ".reports"
 	os.MkdirAll(resultsDir, os.ModePerm)
 
+	// Create a unique filename based on current timestamp
 	resultsFile := filepath.Join(resultsDir, fmt.Sprintf("%d.txt", time.Now().Unix()))
+
+	// Write results to file
 	if err := os.WriteFile(resultsFile, []byte(results), 0644); err != nil {
 		fmt.Println("Error saving report:", err)
 		return

lib/requests.go

@@ -6,17 +6,24 @@ import (
 	"math"
 	"math/rand/v2"
 	"net/http"
-	"sync"
-	"sync/atomic"
 	"time"
 )
 
+// Global HTTP client for reuse across requests
 var client = &http.Client{}
 
+// Error returns a formatted error string for RequestError
 func (e *RequestError) Error() string {
 	return fmt.Sprintf("error making %s request to %s: %v", e.Verb, e.URL, e.Err)
 }
 
+// makeRequest performs a single HTTP request and records its metrics
+// Parameters:
+//   - verb: HTTP method (GET/POST)
+//   - url: target endpoint
+//   - token: optional bearer token for authorization
+//   - jsonData: optional request body
+//   - second: current test duration in seconds (for metrics)
 func makeRequest(verb, url, token string, jsonData []byte, second int) error {
 	startTime := time.Now()
 
@@ -44,44 +51,56 @@ func makeRequest(verb, url, token string, jsonData []byte, second int) error {
 
 	duration := time.Since(startTime)
 
+	// Log request details with millisecond precision
+	timeStr := time.Now().Format("15:04:05.000")
+	fmt.Printf("[%s] %s - Status: %d - Duration: %s\n",
+		timeStr,
+		verb,
+		resp.StatusCode,
+		duration.Round(time.Millisecond))
+
 	UpdateMetrics(duration, resp, second)
 
 	return nil
 }
 
+// SendRequests executes the load test according to specified parameters
+// Parameters:
+//   - url: target endpoint
+//   - patterns: array of request patterns (sequential or probabilistic)
+//   - maxRequests: total number of requests to send
+//   - requestsPerSecond: target request rate
+//   - token: optional bearer token for authorization
+//   - jsonData: optional request body
 func SendRequests(url string, patterns []RequestPattern, maxRequests int, requestsPerSecond float64, token string, jsonData []byte) {
+	// Initialize metrics tracking
 	metrics = PerformanceMetrics{
 		MinLatency:       time.Duration(math.MaxInt64),
 		ResponseCounters: make(map[int]int32),
 	}
 
 	startTime := time.Now()
-	rateLimit := time.Second / time.Duration(requestsPerSecond)
-	ticker := time.NewTicker(rateLimit)
-	defer ticker.Stop()
-
-	var requestCount int32
-	var wg sync.WaitGroup
+	// Calculate time interval between requests based on desired rate
+	interval := time.Duration(float64(time.Second) / requestsPerSecond)
+	nextRequestTime := startTime
 
+	requestCount := 0
 	patternIndex := 0
 	sequenceCount := 0
 
-	for range ticker.C {
-		if int(requestCount) >= maxRequests {
-			break
+	// Determine pattern type based on first pattern's configuration
+	isProbabilistic := patterns[0].Percentage > 0
+
+	for requestCount < maxRequests {
+		// Maintain request rate by waiting until next scheduled time
+		now := time.Now()
+		if now.Before(nextRequestTime) {
+			time.Sleep(nextRequestTime.Sub(now))
 		}
 
 		var selectedVerb string
-		if patterns[0].Sequence > 0 {
-			currentPattern := patterns[patternIndex]
-			selectedVerb = currentPattern.Verb
-
-			sequenceCount++
-			if sequenceCount >= currentPattern.Sequence {
-				sequenceCount = 0
-				patternIndex = (patternIndex + 1) % len(patterns)
-			}
-		} else {
+		if isProbabilistic {
+			// Select verb based on percentage distribution
 			rand := rand.Float64() * 100
 			cumulative := 0.0
 			for _, p := range patterns {
@@ -91,22 +110,31 @@ func SendRequests(url string, patterns []RequestPattern, maxRequests int, reques
 					break
 				}
 			}
+		} else {
+			// Select verb based on sequential pattern
+			currentPattern := patterns[patternIndex]
+			selectedVerb = currentPattern.Verb
+
+			sequenceCount++
+			if sequenceCount >= currentPattern.Sequence {
+				sequenceCount = 0
+				patternIndex = (patternIndex + 1) % len(patterns)
+			}
 		}
 
-		wg.Add(1)
-		go func(verb string) {
-			defer wg.Done()
+		// Launch request asynchronously to maintain timing
+		go func(verb string, requestTime time.Time) {
 			err := makeRequest(verb, url, token, jsonData, int(time.Since(startTime).Seconds()))
 			if err != nil {
 				fmt.Printf("Error making request: %v\n", err)
 			}
-			atomic.AddInt32(&requestCount, 1)
-		}(selectedVerb)
+		}(selectedVerb, nextRequestTime)
+
+		requestCount++
+		nextRequestTime = nextRequestTime.Add(interval)
 	}
 
-	wg.Wait()
-
-	time.Sleep(100 * time.Millisecond)
-
+	// Allow time for final requests to complete
+	time.Sleep(interval * 2)
 	CalculateAndPrintMetrics(startTime, requestsPerSecond, url, patterns)
 }

lib/types.go

@@ -5,6 +5,8 @@ import (
 	"time"
 )
 
+// PerformanceMetrics represents a thread-safe container for tracking
+// performance statistics during load testing
 type PerformanceMetrics struct {
 	Mu               sync.Mutex
 	TotalRequests    int32
@@ -15,12 +17,14 @@ type PerformanceMetrics struct {
 	ResponseCounters map[int]int32
 }
 
+// RequestError represents a detailed error that occurs during an HTTP request
 type RequestError struct {
 	Verb string
 	URL  string
 	Err  error
 }
 
+// RequestPattern defines the characteristics of requests to be sent during load testing
 type RequestPattern struct {
 	Verb       string
 	Percentage float64