Merge branch 'main' into wrong-range-judgement

Author: mrproliu

commands/run/run.go

@@ -91,7 +91,7 @@ func runAccordingE2E() error {
 		if err != nil {
 			return err
 		}
-		logger.Log.Infof("trigger part finished successfully")
+		logger.Log.Infof("trigger part started successfully")
 	} else {
 		logger.Log.Infof("no trigger need to execute")
 	}

commands/verify/verify.go

@@ -20,6 +20,7 @@ package verify
 import (
 	"context"
 	"fmt"
+	"github.com/apache/skywalking-infra-e2e/internal/constant"
 	"sync"
 	"time"
 
@@ -53,7 +54,8 @@ var Verify = &cobra.Command{
 	Short: "verify if the actual data match the expected data",
 	RunE: func(cmd *cobra.Command, args []string) error {
 		if expected != "" {
-			return verifySingleCase(expected, actual, query)
+			_, err := verifySingleCase(expected, actual, query)
+			return err
 		}
 
 		// If there is no given flags.
@@ -69,34 +71,34 @@ type verifyInfo struct {
 	failFast   bool
 }
 
-func verifySingleCase(expectedFile, actualFile, query string) error {
+func verifySingleCase(expectedFile, actualFile, query string) (string, error) {
 	expectedData, err := util.ReadFileContent(expectedFile)
 	if err != nil {
-		return fmt.Errorf("failed to read the expected data file: %v", err)
+		return "", fmt.Errorf("failed to read the expected data file: %v", err)
 	}
 
 	var actualData, sourceName, stderr string
 	if actualFile != "" {
 		sourceName = actualFile
 		actualData, err = util.ReadFileContent(actualFile)
 		if err != nil {
-			return fmt.Errorf("failed to read the actual data file: %v", err)
+			return "", fmt.Errorf("failed to read the actual data file: %v", err)
 		}
 	} else if query != "" {
 		sourceName = query
 		actualData, stderr, err = util.ExecuteCommand(query)
 		if err != nil {
-			return fmt.Errorf("failed to execute the query: %s, output: %s, error: %v", query, actualData, stderr)
+			return "", fmt.Errorf("failed to execute the query: %s, output: %s, error: %v", query, actualData, stderr)
 		}
 	}
 
 	if err = verifier.Verify(actualData, expectedData); err != nil {
 		if me, ok := err.(*verifier.MismatchError); ok {
-			return fmt.Errorf("failed to verify the output: %s, error:\n%v", sourceName, me.Error())
+			return actualData, fmt.Errorf("failed to verify the output: %s, error:\n%v", sourceName, me.Error())
 		}
-		return fmt.Errorf("failed to verify the output: %s, error:\n%v", sourceName, err)
+		return actualData, fmt.Errorf("failed to verify the output: %s, error:\n%v", sourceName, err)
 	}
-	return nil
+	return actualData, nil
 }
 
 // concurrentlyVerifySingleCase verifies a single case in concurrency mode,
@@ -127,7 +129,7 @@ func concurrentlyVerifySingleCase(
 			res.Skip = true
 			return res
 		default:
-			if err := verifySingleCase(v.GetExpected(), v.GetActual(), v.Query); err == nil {
+			if d, err := verifySingleCase(v.GetExpected(), v.GetActual(), v.Query); err == nil {
 				if current == 0 {
 					res.Msg = fmt.Sprintf("verified %v\n", caseName(v))
 				} else {
@@ -138,6 +140,9 @@ func concurrentlyVerifySingleCase(
 				time.Sleep(verifyInfo.interval)
 			} else {
 				res.Msg = fmt.Sprintf("failed to verify %v, retried %d time(s):", caseName(v), current)
+				if d != "" {
+					res.Msg += fmt.Sprintf(" the actual data is:\n%s\n", d)
+				}
 				res.Err = err
 			}
 		}
@@ -215,7 +220,7 @@ func verifyCasesSerially(verify *config.Verify, verifyInfo *verifyInfo) (err err
 
 		if v.GetExpected() == "" {
 			res[idx].Skip = false
-			res[idx].Msg = fmt.Sprintf("failed to verify %v", caseName(v))
+			res[idx].Msg = fmt.Sprintf("%s failed to verify %v", formatVerificationTime(), caseName(v))
 			res[idx].Err = fmt.Errorf("the expected data file for %v is not specified", caseName(v))
 
 			printer.Warning(res[idx].Msg)
@@ -227,11 +232,11 @@ func verifyCasesSerially(verify *config.Verify, verifyInfo *verifyInfo) (err err
 		}
 
 		for current := 0; current <= verifyInfo.retryCount; current++ {
-			if e := verifySingleCase(v.GetExpected(), v.GetActual(), v.Query); e == nil {
+			if d, e := verifySingleCase(v.GetExpected(), v.GetActual(), v.Query); e == nil {
 				if current == 0 {
-					res[idx].Msg = fmt.Sprintf("verified %v \n", caseName(v))
+					res[idx].Msg = fmt.Sprintf("%s verified %v \n", formatVerificationTime(), caseName(v))
 				} else {
-					res[idx].Msg = fmt.Sprintf("verified %v, retried %d time(s)\n", caseName(v), current)
+					res[idx].Msg = fmt.Sprintf("%s verified %v, retried %d time(s)\n", formatVerificationTime(), caseName(v), current)
 				}
 				res[idx].Skip = false
 				printer.Success(res[idx].Msg)
@@ -240,11 +245,15 @@ func verifyCasesSerially(verify *config.Verify, verifyInfo *verifyInfo) (err err
 				if current == 0 {
 					printer.UpdateText(fmt.Sprintf("failed to verify %v, will continue retry:", caseName(v)))
 				} else {
-					printer.UpdateText(fmt.Sprintf("failed to verify %v, retry [%d/%d]", caseName(v), current, verifyInfo.retryCount))
+					printer.UpdateText(fmt.Sprintf("failed to verify %v, retry [%d/%d]", caseName(v), current,
+						verifyInfo.retryCount))
 				}
 				time.Sleep(verifyInfo.interval)
 			} else {
-				res[idx].Msg = fmt.Sprintf("failed to verify %v, retried %d time(s)", caseName(v), current)
+				res[idx].Msg = fmt.Sprintf("%s failed to verify %v, retried %d time(s)", formatVerificationTime(), caseName(v), current)
+				if d != "" {
+					res[idx].Msg += fmt.Sprintf(", the actual data is:\n%s\n", d)
+				}
 				res[idx].Err = e
 				res[idx].Skip = false
 				printer.UpdateText(fmt.Sprintf("failed to verify %v, retry [%d/%d]", caseName(v), current, verifyInfo.retryCount))
@@ -260,6 +269,10 @@ func verifyCasesSerially(verify *config.Verify, verifyInfo *verifyInfo) (err err
 	return nil
 }
 
+func formatVerificationTime() string {
+	return time.Now().Format(constant.LogTimestampFormat)
+}
+
 func caseName(v *config.VerifyCase) string {
 	if v.Name == "" {
 		if v.Actual != "" {

docs/en/setup/Configuration-File.md

@@ -144,7 +144,7 @@ After the `Setup` step is finished, use the `Trigger` step to generate traffic.
 trigger:
   action: http      # The action of the trigger. support HTTP invoke.
   interval: 3s      # Trigger the action every 3 seconds.
-  times: 5          # The retry count before the request success.
+  times: 5          # The retry count before the request success.A non-positive number implies an infinite loop.This property defaults to 0
   url: http://apache.skywalking.com/ # Http trigger url link.
   method: GET       # Http trigger method.
   headers:

internal/components/trigger/http.go

@@ -21,6 +21,7 @@ package trigger
 import (
 	"fmt"
 	"io"
+	"math"
 	"net/http"
 	"os"
 	"strings"
@@ -51,6 +52,12 @@ func NewHTTPAction(intervalStr string, times int, url, method, body string, head
 		return nil, fmt.Errorf("trigger interval should be > 0, but was %s", interval)
 	}
 
+	if times <= 0 {
+		logger.Log.Warnf("trigger times (%d) is invalid (<=0). It has been set to a large number (%d) to simulate infinite runs. "+
+			"consider using a positive value.", times, math.MaxInt32)
+		times = math.MaxInt32
+	}
+
 	// there can be env variables in url, say, "http://${GATEWAY_HOST}:${GATEWAY_PORT}/test"
 	url = os.ExpandEnv(url)
 
@@ -62,19 +69,26 @@ func NewHTTPAction(intervalStr string, times int, url, method, body string, head
 		body:          body,
 		headers:       headers,
 		executedCount: 0,
-		stopCh:        make(chan struct{}),
+		stopCh:        make(chan struct{}, 1),
 		client:        &http.Client{},
 	}, nil
 }
 
 func (h *httpAction) Do() chan error {
 	t := time.NewTicker(h.interval)
 
-	logger.Log.Infof("trigger will request URL %s %d times with interval %s.", h.url, h.times, h.interval)
+	var timesInfo string
+	if h.times == math.MaxInt32 {
+		timesInfo = "a very large number of times (practically until stopped)"
+	} else {
+		timesInfo = fmt.Sprintf("%d times", h.times)
+	}
+	logger.Log.Infof("trigger will request URL %s %s with interval %s.", h.url, timesInfo, h.interval)
 
 	result := make(chan error)
 	sent := false
 	go func() {
+		defer t.Stop()
 		for {
 			select {
 			case <-t.C:
@@ -85,10 +99,14 @@ func (h *httpAction) Do() chan error {
 				if !sent && (err == nil || h.times == h.executedCount) {
 					result <- err
 					sent = true
+					logger.Log.Infof("trigger has sent result after executed %d requests with err: %v", h.executedCount, err)
+				}
+				if h.times != math.MaxInt32 && h.executedCount >= h.times {
+					logger.Log.Infof("trigger has completed %d requests and will stop.", h.executedCount)
+					return
 				}
 			case <-h.stopCh:
-				t.Stop()
-				result <- nil
+				logger.Log.Infof("trigger was stopped manually after %d executions.", h.executedCount)
 				return
 			}
 		}

internal/constant/log.go

@@ -0,0 +1,23 @@
+// Licensed to Apache Software Foundation (ASF) under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Apache Software Foundation (ASF) licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+//
+
+package constant
+
+const (
+	LogTimestampFormat = "2006-01-02 15:04:05"
+)

internal/logger/log.go

@@ -18,6 +18,7 @@
 package logger
 
 import (
+	"github.com/apache/skywalking-infra-e2e/internal/constant"
 	"os"
 
 	"github.com/sirupsen/logrus"
@@ -32,7 +33,9 @@ func init() {
 	Log.Level = logrus.InfoLevel
 	Log.SetOutput(os.Stdout)
 	Log.SetFormatter(&logrus.TextFormatter{
-		DisableTimestamp:       true,
+		DisableTimestamp:       false,
+		FullTimestamp:          true,
+		TimestampFormat:        constant.LogTimestampFormat,
 		DisableLevelTruncation: true,
 		ForceColors:            true,
 	})