✨ Add duration

requests/helper.go

@@ -17,7 +17,7 @@ import (
 func streamProgress(
 	ctx context.Context,
 	wg *sync.WaitGroup,
-	total int64,
+	total uint,
 	message string,
 	increase <-chan int64,
 ) {
@@ -27,21 +27,26 @@ func streamProgress(
 	pw.SetStyle(progress.StyleBlocks)
 	pw.SetTrackerLength(40)
 	pw.SetUpdateFrequency(time.Millisecond * 250)
+	if total == 0 {
+		pw.Style().Visibility.Percentage = false
+	}
 	go pw.Render()
 	dodosTracker := progress.Tracker{
 		Message: message,
-		Total:   total,
+		Total:   int64(total),
 	}
 	pw.AppendTracker(&dodosTracker)
+
 	for {
 		select {
 		case <-ctx.Done():
-			if ctx.Err() != context.Canceled {
+			if err := ctx.Err(); err == context.Canceled || err == context.DeadlineExceeded {
+				dodosTracker.MarkAsDone()
+			} else {
 				dodosTracker.MarkAsErrored()
 			}
+			time.Sleep(time.Millisecond * 300)
 			fmt.Printf("\r")
-			time.Sleep(time.Millisecond * 500)
-			pw.Stop()
 			return
 
 		case value := <-increase:

requests/run.go

@@ -59,46 +59,59 @@ func releaseDodos(
 		streamWG            sync.WaitGroup
 		requestCountPerDodo uint
 		dodosCount          uint = requestConfig.GetValidDodosCountForRequests()
-		dodosCountInt       int  = int(dodosCount)
 		responses                = make([][]*Response, dodosCount)
 		increase                 = make(chan int64, requestConfig.RequestCount)
 	)
 
-	wg.Add(dodosCountInt)
+	wg.Add(int(dodosCount))
 	streamWG.Add(1)
 	streamCtx, streamCtxCancel := context.WithCancel(context.Background())
 
-	go streamProgress(streamCtx, &streamWG, int64(requestConfig.RequestCount), "Dodos Working🔥", increase)
+	go streamProgress(streamCtx, &streamWG, requestConfig.RequestCount, "Dodos Working🔥", increase)
 
-	for i := range dodosCount {
-		if i+1 == dodosCount {
-			requestCountPerDodo = requestConfig.RequestCount - (i * requestConfig.RequestCount / dodosCount)
-		} else {
-			requestCountPerDodo = ((i + 1) * requestConfig.RequestCount / dodosCount) -
-				(i * requestConfig.RequestCount / dodosCount)
+	if requestConfig.RequestCount == 0 {
+		for i := range dodosCount {
+			go sendRequest(
+				ctx,
+				newRequest(*requestConfig, clients, int64(i)),
+				requestConfig.Timeout,
+				&responses[i],
+				increase,
+				&wg,
+			)
 		}
+	} else {
+		for i := range dodosCount {
+			if i+1 == dodosCount {
+				requestCountPerDodo = requestConfig.RequestCount - (i * requestConfig.RequestCount / dodosCount)
+			} else {
+				requestCountPerDodo = ((i + 1) * requestConfig.RequestCount / dodosCount) -
+					(i * requestConfig.RequestCount / dodosCount)
+			}
 
-		go sendRequest(
-			ctx,
-			newRequest(*requestConfig, clients, int64(i)),
-			requestConfig.Timeout,
-			requestCountPerDodo,
-			&responses[i],
-			increase,
-			&wg,
-		)
+			go sendRequestByCount(
+				ctx,
+				newRequest(*requestConfig, clients, int64(i)),
+				requestConfig.Timeout,
+				requestCountPerDodo,
+				&responses[i],
+				increase,
+				&wg,
+			)
+		}
 	}
+
 	wg.Wait()
 	streamCtxCancel()
 	streamWG.Wait()
 	return utils.Flatten(responses)
 }
 
-// sendRequest sends a specified number of HTTP requests concurrently with a given timeout.
+// sendRequestByCount sends a specified number of HTTP requests concurrently with a given timeout.
 // It appends the responses to the provided responseData slice and sends the count of completed requests
 // to the increase channel. The function terminates early if the context is canceled or if a custom
 // interrupt error is encountered.
-func sendRequest(
+func sendRequestByCount(
 	ctx context.Context,
 	request *Request,
 	timeout time.Duration,
@@ -142,3 +155,50 @@ func sendRequest(
 		}()
 	}
 }
+
+// sendRequest continuously sends HTTP requests until the context is canceled.
+// It records the response status code or error message along with the response time,
+// and signals each completed request through the increase channel.
+func sendRequest(
+	ctx context.Context,
+	request *Request,
+	timeout time.Duration,
+	responseData *[]*Response,
+	increase chan<- int64,
+	wg *sync.WaitGroup,
+) {
+	defer wg.Done()
+
+	for {
+		if ctx.Err() != nil {
+			return
+		}
+
+		func() {
+			startTime := time.Now()
+			response, err := request.Send(ctx, timeout)
+			completedTime := time.Since(startTime)
+			if response != nil {
+				defer fasthttp.ReleaseResponse(response)
+			}
+
+			if err != nil {
+				if err == types.ErrInterrupt {
+					return
+				}
+				*responseData = append(*responseData, &Response{
+					Response: err.Error(),
+					Time:     completedTime,
+				})
+				increase <- 1
+				return
+			}
+
+			*responseData = append(*responseData, &Response{
+				Response: strconv.Itoa(response.StatusCode()),
+				Time:     completedTime,
+			})
+			increase <- 1
+		}()
+	}
+}