feat: [CI-16291]: Add telemetry for local delegate (#50)

smjt-h · Harness · commit 630a0dc3b433 · 2025-02-28T09:31:47.000Z
* feat: [CI-16291]: Add telemetry for local delegate
* feat: [CI-16291]: Add telemetry for local delegate
diff --git a/api/api.go b/api/api.go
@@ -7,6 +7,7 @@ package api
 import (
 	"github.com/harness/harness-docker-runner/engine/spec"
 	leapi "github.com/harness/lite-engine/api"
+	"github.com/harness/ti-client/types"
 )
 
 type CommandExecutionStatus string
@@ -163,14 +164,15 @@ type (
 	}
 
 	PollStepResponse struct {
-		Exited            bool              `json:"exited,omitempty"`
-		ExitCode          int               `json:"exit_code,omitempty"`
-		Error             string            `json:"error,omitempty"`
-		OOMKilled         bool              `json:"oom_killed,omitempty"`
-		Outputs           map[string]string `json:"outputs,omitempty"`
-		Artifact          []byte            `json:"artifact,omitempty"`
-		OutputV2          []*OutputV2       `json:"outputV2,omitempty"`
-		OptimizationState string            `json:"optimization_state,omitempty"`
+		Exited            bool                 `json:"exited,omitempty"`
+		ExitCode          int                  `json:"exit_code,omitempty"`
+		Error             string               `json:"error,omitempty"`
+		OOMKilled         bool                 `json:"oom_killed,omitempty"`
+		Outputs           map[string]string    `json:"outputs,omitempty"`
+		Artifact          []byte               `json:"artifact,omitempty"`
+		OutputV2          []*OutputV2          `json:"outputV2,omitempty"`
+		OptimizationState string               `json:"optimization_state,omitempty"`
+		Telemetry         *types.TelemetryData `json:"telemetry,omitempty"`
 	}
 
 	StreamOutputRequest struct {
diff --git a/go.mod b/go.mod
@@ -42,8 +42,8 @@ require (
 	github.com/google/gops v0.3.25 // indirect
 	github.com/google/uuid v1.3.0 // indirect
 	github.com/harness/godotenv/v2 v2.0.0 // indirect
-	github.com/harness/lite-engine v0.5.89 // indirect
-	github.com/harness/ti-client v0.0.0-20240617230757-1e90e7e3ada2 // indirect
+	github.com/harness/lite-engine v0.5.96 // indirect
+	github.com/harness/ti-client v0.0.0-20250211085345-7c82b29d1b3c // indirect
 	github.com/keybase/go-ps v0.0.0-20190827175125-91aafc93ba19 // indirect
 	github.com/klauspost/compress v1.16.3 // indirect
 	github.com/klauspost/pgzip v1.2.5 // indirect
diff --git a/go.sum b/go.sum
@@ -580,10 +580,14 @@ github.com/harness/lite-engine v0.5.78 h1:6EOIlW0djiJ7a9xgWppxu+FOUiXwZFYK59sbiR
 github.com/harness/lite-engine v0.5.78/go.mod h1:07w13fj/1efZZgY78xBo+iXuZH3BiVIx44cNZkHKPlc=
 github.com/harness/lite-engine v0.5.81 h1:TUF4EJlUnbfVLKu+y+pAELXhe9HHwMH4P53Ot6oPyYo=
 github.com/harness/lite-engine v0.5.81/go.mod h1:CwyhOnIA6XDt/U02eKUXwT0hIMK4Q9uKG9LM86j7qns=
-github.com/harness/lite-engine v0.5.89 h1:4FVnnGKJUDVVDSLDbeweGtmsnj1Ia/Wpywghs8uupnU=
-github.com/harness/lite-engine v0.5.89/go.mod h1:Wf7YWBRYKvUuS5l7GrWtW0h19vhWqZDfUu3BNDyKrE0=
+github.com/harness/lite-engine v0.5.95 h1:lvw+4OCtwEPLV+Kt9EllkqE/Q0NdJjfcS8IJTPkpXP4=
+github.com/harness/lite-engine v0.5.95/go.mod h1:/6AqaF3+ibpBG/vcPIzO4qQI8QaGFX1951qh1KxYZCk=
+github.com/harness/lite-engine v0.5.96 h1:97G+uVTvP2TECBsZFGwJLBsqxJ+v2XzPcBFMupd5r7o=
+github.com/harness/lite-engine v0.5.96/go.mod h1:/6AqaF3+ibpBG/vcPIzO4qQI8QaGFX1951qh1KxYZCk=
 github.com/harness/ti-client v0.0.0-20240617230757-1e90e7e3ada2 h1:9QHzlirx9Lg77ohXYTOeC+3aDPG8ZeHTKI1iAN5+cIo=
 github.com/harness/ti-client v0.0.0-20240617230757-1e90e7e3ada2/go.mod h1:/ow4f34mPgr5KPkzKxmBUB4cC09OjzStcLX6R8+43TI=
+github.com/harness/ti-client v0.0.0-20250211085345-7c82b29d1b3c h1:fAVNZiSrO9i8lQUo1joeEiOxHyqYwRxtVQivjrMeHpE=
+github.com/harness/ti-client v0.0.0-20250211085345-7c82b29d1b3c/go.mod h1:/ow4f34mPgr5KPkzKxmBUB4cC09OjzStcLX6R8+43TI=
 github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q=
 github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
 github.com/hashicorp/errwrap v0.0.0-20141028054710-7554cd9344ce/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
diff --git a/handler/setup.go b/handler/setup.go
@@ -240,6 +240,6 @@ func setProxyEnvs(environment map[string]string) {
 
 func getTiCfg(t api.TIConfig, dataDir string) tiCfg.Cfg {
 	cfg := tiCfg.New(t.URL, t.Token, t.AccountID, t.OrgID, t.ProjectID, t.PipelineID, t.BuildID, t.StageID, t.Repo,
-		t.Sha, t.CommitLink, t.SourceBranch, t.TargetBranch, t.CommitBranch, dataDir, t.ParseSavings, false)
+		t.Sha, t.CommitLink, t.SourceBranch, t.TargetBranch, t.CommitBranch, dataDir, t.ParseSavings, false, "", "")
 	return cfg
 }
diff --git a/pipeline/runtime/run.go b/pipeline/runtime/run.go
@@ -6,6 +6,7 @@ package runtime
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"os"
@@ -24,15 +25,16 @@ import (
 )
 
 func executeRunStep(ctx context.Context, engine *engine.Engine, r *api.StartStepRequest, out io.Writer, tiConfig *tiCfg.Cfg) (
-	*runtime.State, map[string]string, []byte, []*api.OutputV2, string, error) {
+	*runtime.State, map[string]string, []byte, []*api.OutputV2, string, *types.TelemetryData, error) {
 	start := time.Now()
+	telemetry := &types.TelemetryData{}
 	step := toStep(r)
 	step.Command = r.Run.Command
 	step.Entrypoint = r.Run.Entrypoint
 
 	optimizationState := types.DISABLED
 	if (len(r.OutputVars) > 0 || len(r.Outputs) > 0) && (len(step.Entrypoint) == 0 || len(step.Command) == 0) {
-		return nil, nil, nil, nil, string(optimizationState), fmt.Errorf("output variable should not be set for unset entrypoint or command")
+		return nil, nil, nil, nil, string(optimizationState), telemetry, fmt.Errorf("output variable should not be set for unset entrypoint or command")
 	}
 
 	enablePluginOutputSecrets := IsFeatureFlagEnabled(ciEnablePluginOutputSecrets, engine, step)
@@ -69,13 +71,21 @@ func executeRunStep(ctx context.Context, engine *engine.Engine, r *api.StartStep
 	exited, err := engine.Run(ctx, step, out)
 	timeTakenMs := time.Since(start).Milliseconds()
 	logrus.WithField("step_id", r.ID).WithField("stage_id", r.StageRuntimeID).Traceln("completed step run")
-	if rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, r.Envs); rerr != nil {
+	if _, rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, &telemetry.TestIntelligenceMetaData, r.Envs); rerr != nil {
 		logrus.WithError(rerr).WithField("step", step.Name).Errorln("failed to upload report")
 	}
 
 	// Parse and upload savings to TI
 	if tiConfig.GetParseSavings() {
-		optimizationState = savings.ParseAndUploadSavings(ctx, r.WorkingDir, log, step.Name, checkStepSuccess(exited, err), timeTakenMs, tiConfig, r.Envs)
+		optimizationState = savings.ParseAndUploadSavings(ctx, r.WorkingDir, log, step.Name, checkStepSuccess(exited, err), timeTakenMs, tiConfig, r.Envs, telemetry)
+	}
+
+	//only for git-clone-step
+	if buildLangFile, found := r.Envs["PLUGIN_BUILD_TOOL_FILE"]; found {
+		err1 := parseBuildInfo(telemetry, r.WorkingDir+"/"+buildLangFile)
+		if err1 != nil {
+			logrus.WithContext(ctx).WithError(err1).Errorln("failed to parse build info")
+		}
 	}
 
 	artifact, _ := fetchArtifactDataFromArtifactFile(artifactFile, out)
@@ -151,12 +161,12 @@ func executeRunStep(ctx context.Context, engine *engine.Engine, r *api.StartStep
 				outputsV2 = append(outputsV2, summaryOutputsV2...)
 			}
 
-			return exited, outputs, artifact, outputsV2, string(optimizationState), finalErr
+			return exited, outputs, artifact, outputsV2, string(optimizationState), telemetry, finalErr
 
 		} else {
 			outputs, err := fetchOutputVariables(outputFile, out, false) // nolint:govet
 			if err != nil {
-				return exited, nil, nil, nil, string(optimizationState), err
+				return exited, nil, nil, nil, string(optimizationState), telemetry, err
 			}
 			// Delete output variable file
 			if ferr := os.Remove(outputFile); ferr != nil {
@@ -176,17 +186,38 @@ func executeRunStep(ctx context.Context, engine *engine.Engine, r *api.StartStep
 				if report.TestSummaryAsOutputEnabled(r.Envs) {
 					outputsV2 = append(outputsV2, summaryOutputsV2...)
 				}
-				return exited, outputs, artifact, outputsV2, string(optimizationState), err
+				return exited, outputs, artifact, outputsV2, string(optimizationState), telemetry, err
 			}
 			if len(summaryOutputsV2) > 0 && report.TestSummaryAsOutputEnabled(r.Envs) {
-				return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err
+				return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err
 			}
-			return exited, outputs, artifact, nil, string(optimizationState), err
+			return exited, outputs, artifact, nil, string(optimizationState), telemetry, err
 		}
 	}
 	if len(summaryOutputsV2) == 0 || !report.TestSummaryAsOutputEnabled(r.Envs) {
-		return exited, nil, artifact, nil, string(optimizationState), err
+		return exited, nil, artifact, nil, string(optimizationState), telemetry, err
+	}
+
+	return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err
+}
+
+func parseBuildInfo(telemetryData *types.TelemetryData, buildFile string) error {
+	if _, err := os.Stat(buildFile); os.IsNotExist(err) {
+		return err
+	}
+
+	// Read the JSON file containing the cache metrics.
+	data, err := os.ReadFile(buildFile)
+	if err != nil {
+		return err
+	}
+
+	// Deserialize the JSON data into the CacheMetrics struct.
+	var buildInfo types.BuildInfo
+	if err := json.Unmarshal(data, &buildInfo); err != nil {
+		return err
 	}
 
-	return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err
+	telemetryData.BuildInfo = buildInfo
+	return nil
 }
diff --git a/pipeline/runtime/runtest.go b/pipeline/runtime/runtest.go
@@ -28,22 +28,23 @@ const (
 )
 
 func executeRunTestStep(ctx context.Context, engine *engine.Engine, r *api.StartStepRequest, out io.Writer, tiConfig *tiCfg.Cfg) (
-	*runtime.State, map[string]string, []byte, []*api.OutputV2, string, error) {
+	*runtime.State, map[string]string, []byte, []*api.OutputV2, string, *types.TelemetryData, error) {
 	start := time.Now()
+	telemetry := &types.TelemetryData{}
 	log := logrus.New()
 	log.Out = out
 	optimizationState := types.DISABLED
-	cmd, err := instrumentation.GetCmd(ctx, &r.RunTest, r.Name, r.WorkingDir, log, r.Envs, tiConfig)
+	cmd, err := instrumentation.GetCmd(ctx, &r.RunTest, r.Name, r.WorkingDir, log, r.Envs, tiConfig, &telemetry.TestIntelligenceMetaData)
 	if err != nil {
-		return nil, nil, nil, nil, string(optimizationState), err
+		return nil, nil, nil, nil, string(optimizationState), telemetry, err
 	}
 
 	step := toStep(r)
 	step.Command = []string{cmd}
 	step.Entrypoint = r.RunTest.Entrypoint
 
 	if (len(r.OutputVars) > 0 || len(r.Outputs) > 0) && len(step.Entrypoint) == 0 || len(step.Command) == 0 {
-		return nil, nil, nil, nil, string(optimizationState), fmt.Errorf("output variable should not be set for unset entrypoint or command")
+		return nil, nil, nil, nil, string(optimizationState), telemetry, fmt.Errorf("output variable should not be set for unset entrypoint or command")
 	}
 
 	enablePluginOutputSecrets := IsFeatureFlagEnabled(ciEnablePluginOutputSecrets, engine, step)
@@ -66,17 +67,18 @@ func executeRunTestStep(ctx context.Context, engine *engine.Engine, r *api.Start
 
 	exited, err := engine.Run(ctx, step, out)
 	timeTakenMs := time.Since(start).Milliseconds()
-	if rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, r.Envs); rerr != nil {
+	if _, rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, &telemetry.TestIntelligenceMetaData, r.Envs); rerr != nil {
 		log.WithError(rerr).Errorln("failed to upload report")
 	}
 
-	if uerr := callgraph.Upload(ctx, step.Name, time.Since(start).Milliseconds(), log, time.Now(), tiConfig, cgDir); uerr != nil {
+	//Passing default false for failed test for now.
+	if uerr := callgraph.Upload(ctx, step.Name, time.Since(start).Milliseconds(), log, time.Now(), tiConfig, cgDir, false); uerr != nil {
 		log.WithError(uerr).Errorln("unable to collect callgraph")
 	}
 
 	// Parse and upload savings to TI
 	if tiConfig.GetParseSavings() {
-		optimizationState = savings.ParseAndUploadSavings(ctx, r.WorkingDir, log, step.Name, checkStepSuccess(exited, err), timeTakenMs, tiConfig, r.Envs)
+		optimizationState = savings.ParseAndUploadSavings(ctx, r.WorkingDir, log, step.Name, checkStepSuccess(exited, err), timeTakenMs, tiConfig, r.Envs, telemetry)
 	}
 
 	summaryOutputs := make(map[string]string)
@@ -117,10 +119,10 @@ func executeRunTestStep(ctx context.Context, engine *engine.Engine, r *api.Start
 			if report.TestSummaryAsOutputEnabled(r.Envs) {
 				outputsV2 = append(outputsV2, summaryOutputsV2...)
 			}
-			return exited, outputs, artifact, outputsV2, string(optimizationState), outputErr
+			return exited, outputs, artifact, outputsV2, string(optimizationState), telemetry, outputErr
 		}
 		if len(summaryOutputsV2) > 0 && report.TestSummaryAsOutputEnabled(r.Envs) {
-			return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err
+			return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err
 		}
 	} else if len(r.OutputVars) > 0 {
 		if exited != nil && exited.Exited && exited.ExitCode == 0 {
@@ -134,17 +136,17 @@ func executeRunTestStep(ctx context.Context, engine *engine.Engine, r *api.Start
 					outputs[k] = v
 				}
 			}
-			return exited, outputs, artifact, nil, string(optimizationState), outputErr
+			return exited, outputs, artifact, nil, string(optimizationState), telemetry, outputErr
 		}
 		if len(summaryOutputs) != 0 && len(summaryOutputsV2) != 0 && report.TestSummaryAsOutputEnabled(r.Envs) {
 			// when step has failed return the actual error
-			return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err
+			return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err
 		}
 	}
 
 	if len(summaryOutputsV2) == 0 || !report.TestSummaryAsOutputEnabled(r.Envs) {
-		return exited, nil, artifact, nil, string(optimizationState), err
+		return exited, nil, artifact, nil, string(optimizationState), telemetry, err
 	}
 
-	return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err
+	return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err
 }
diff --git a/pipeline/runtime/runtestsV2.go b/pipeline/runtime/runtestsV2.go
@@ -30,16 +30,17 @@ const (
 )
 
 func executeRunTestsV2Step(ctx context.Context, engine *engine.Engine, r *api.StartStepRequest, out io.Writer, tiConfig *tiCfg.Cfg) (
-	*runtime.State, map[string]string, []byte, []*api.OutputV2, string, error) {
+	*runtime.State, map[string]string, []byte, []*api.OutputV2, string, *types.TelemetryData, error) {
 	start := time.Now()
+	telemetry := &types.TelemetryData{}
 	log := logrus.New()
 	log.Out = out
 	step := toStep(r)
 	optimizationState := types.DISABLED
 	step.Entrypoint = r.RunTestsV2.Entrypoint
-	preCmd, err := leRuntime.SetupRunTestV2(ctx, &r.RunTestsV2, step.Name, r.WorkingDir, log, r.Envs, tiConfig)
+	preCmd, err := leRuntime.SetupRunTestV2(ctx, &r.RunTestsV2, step.Name, r.WorkingDir, log, r.Envs, tiConfig, &telemetry.TestIntelligenceMetaData)
 	if err != nil {
-		return nil, nil, nil, nil, string(optimizationState), err
+		return nil, nil, nil, nil, string(optimizationState), telemetry, err
 	}
 	command := r.RunTestsV2.Command[0]
 	if preCmd != "" {
@@ -48,7 +49,7 @@ func executeRunTestsV2Step(ctx context.Context, engine *engine.Engine, r *api.St
 	step.Command = []string{command}
 
 	if (len(r.OutputVars) > 0 || len(r.Outputs) > 0) && (len(step.Entrypoint) == 0 || len(step.Command) == 0) {
-		return nil, nil, nil, nil, string(optimizationState), fmt.Errorf("output variable should not be set for unset entrypoint or command")
+		return nil, nil, nil, nil, string(optimizationState), telemetry, fmt.Errorf("output variable should not be set for unset entrypoint or command")
 	}
 
 	enablePluginOutputSecrets := IsFeatureFlagEnabled(ciEnablePluginOutputSecrets, engine, step)
@@ -87,17 +88,18 @@ func executeRunTestsV2Step(ctx context.Context, engine *engine.Engine, r *api.St
 		// If there are no paths specified, set Paths[0] to include all XML files and all TRX files
 		r.TestReport.Junit.Paths = []string{"**/*.xml", "**/*.trx"}
 	}
-	if rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, r.Envs); rerr != nil {
+	if _, rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, &telemetry.TestIntelligenceMetaData, r.Envs); rerr != nil {
 		log.WithError(rerr).Errorln("failed to upload report")
 	}
 
-	if uerr := callgraph.Upload(ctx, step.Name, time.Since(start).Milliseconds(), log, time.Now(), tiConfig, outDir); uerr != nil {
+	//Passing default false for failed test for now
+	if uerr := callgraph.Upload(ctx, step.Name, time.Since(start).Milliseconds(), log, time.Now(), tiConfig, outDir, false); uerr != nil {
 		log.WithError(uerr).Errorln("unable to collect callgraph")
 	}
 
 	// Parse and upload savings to TI
 	if tiConfig.GetParseSavings() {
-		optimizationState = savings.ParseAndUploadSavings(ctx, r.WorkingDir, log, step.Name, checkStepSuccess(exited, err), timeTakenMs, tiConfig, r.Envs)
+		optimizationState = savings.ParseAndUploadSavings(ctx, r.WorkingDir, log, step.Name, checkStepSuccess(exited, err), timeTakenMs, tiConfig, r.Envs, telemetry)
 	}
 
 	artifact, _ := fetchArtifactDataFromArtifactFile(artifactFile, out)
@@ -170,12 +172,12 @@ func executeRunTestsV2Step(ctx context.Context, engine *engine.Engine, r *api.St
 				outputsV2 = append(outputsV2, summaryOutputsV2...)
 			}
 
-			return exited, outputs, artifact, outputsV2, string(optimizationState), finalErr
+			return exited, outputs, artifact, outputsV2, string(optimizationState), telemetry, finalErr
 
 		} else {
 			outputs, err := fetchOutputVariables(outputFile, out, false) // nolint:govet
 			if err != nil {
-				return exited, nil, nil, nil, string(optimizationState), err
+				return nil, nil, nil, nil, string(optimizationState), telemetry, err
 			}
 			// Delete output variable file
 			if ferr := os.Remove(outputFile); ferr != nil {
@@ -195,22 +197,22 @@ func executeRunTestsV2Step(ctx context.Context, engine *engine.Engine, r *api.St
 				if report.TestSummaryAsOutputEnabled(r.Envs) {
 					outputsV2 = append(outputsV2, summaryOutputsV2...)
 				}
-				return exited, outputs, artifact, outputsV2, string(optimizationState), err
+				return exited, outputs, artifact, outputsV2, string(optimizationState), telemetry, err
 			} else if len(r.OutputVars) > 0 {
 				// only return err when output vars are expected
 				if report.TestSummaryAsOutputEnabled(r.Envs) {
-					return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err
+					return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err
 				}
-				return exited, outputs, artifact, nil, string(optimizationState), err
+				return exited, outputs, artifact, nil, string(optimizationState), telemetry, err
 			}
 			if len(summaryOutputsV2) != 0 && report.TestSummaryAsOutputEnabled(r.Envs) {
-				return exited, outputs, artifact, summaryOutputsV2, string(optimizationState), nil
+				return exited, outputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, nil
 			}
-			return exited, outputs, artifact, nil, string(optimizationState), nil
+			return exited, outputs, artifact, nil, string(optimizationState), telemetry, nil
 		}
 	}
 	if len(summaryOutputsV2) != 0 && report.TestSummaryAsOutputEnabled(r.Envs) {
-		return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err
+		return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err
 	}
-	return exited, nil, artifact, nil, string(optimizationState), err
+	return exited, nil, artifact, nil, string(optimizationState), telemetry, err
 }
diff --git a/pipeline/runtime/step_executor.go b/pipeline/runtime/step_executor.go

Original file line number	Diff line number	Diff line change
`@@ -240,6 +240,6 @@ func setProxyEnvs(environment map[string]string) {`
`240`	`240`
`241`	`241`	`func getTiCfg(t api.TIConfig, dataDir string) tiCfg.Cfg {`
`242`	`242`	`cfg := tiCfg.New(t.URL, t.Token, t.AccountID, t.OrgID, t.ProjectID, t.PipelineID, t.BuildID, t.StageID, t.Repo,`
`243`		`- t.Sha, t.CommitLink, t.SourceBranch, t.TargetBranch, t.CommitBranch, dataDir, t.ParseSavings, false)`
	`243`	`+ t.Sha, t.CommitLink, t.SourceBranch, t.TargetBranch, t.CommitBranch, dataDir, t.ParseSavings, false, "", "")`
`244`	`244`	`return cfg`
`245`	`245`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,22 +28,23 @@ const (`
`28`	`28`	`)`
`29`	`29`
`30`	`30`	`func executeRunTestStep(ctx context.Context, engine engine.Engine, r api.StartStepRequest, out io.Writer, tiConfig *tiCfg.Cfg) (`
`31`		`- runtime.State, map[string]string, []byte, []api.OutputV2, string, error) {`
	`31`	`+ runtime.State, map[string]string, []byte, []api.OutputV2, string, *types.TelemetryData, error) {`
`32`	`32`	`start := time.Now()`
	`33`	`+ telemetry := &types.TelemetryData{}`
`33`	`34`	`log := logrus.New()`
`34`	`35`	`log.Out = out`
`35`	`36`	`optimizationState := types.DISABLED`
`36`		`- cmd, err := instrumentation.GetCmd(ctx, &r.RunTest, r.Name, r.WorkingDir, log, r.Envs, tiConfig)`
	`37`	`+ cmd, err := instrumentation.GetCmd(ctx, &r.RunTest, r.Name, r.WorkingDir, log, r.Envs, tiConfig, &telemetry.TestIntelligenceMetaData)`
`37`	`38`	`if err != nil {`
`38`		`- return nil, nil, nil, nil, string(optimizationState), err`
	`39`	`+ return nil, nil, nil, nil, string(optimizationState), telemetry, err`
`39`	`40`	`}`
`40`	`41`
`41`	`42`	`step := toStep(r)`
`42`	`43`	`step.Command = []string{cmd}`
`43`	`44`	`step.Entrypoint = r.RunTest.Entrypoint`
`44`	`45`
`45`	`46`	`if (len(r.OutputVars) > 0 \|\| len(r.Outputs) > 0) && len(step.Entrypoint) == 0 \|\| len(step.Command) == 0 {`
`46`		`- return nil, nil, nil, nil, string(optimizationState), fmt.Errorf("output variable should not be set for unset entrypoint or command")`
	`47`	`+ return nil, nil, nil, nil, string(optimizationState), telemetry, fmt.Errorf("output variable should not be set for unset entrypoint or command")`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`enablePluginOutputSecrets := IsFeatureFlagEnabled(ciEnablePluginOutputSecrets, engine, step)`
`@@ -66,17 +67,18 @@ func executeRunTestStep(ctx context.Context, engine engine.Engine, r api.Start`
`66`	`67`
`67`	`68`	`exited, err := engine.Run(ctx, step, out)`
`68`	`69`	`timeTakenMs := time.Since(start).Milliseconds()`
`69`		`- if rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, r.Envs); rerr != nil {`
	`70`	`+ if _, rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, &telemetry.TestIntelligenceMetaData, r.Envs); rerr != nil {`
`70`	`71`	`log.WithError(rerr).Errorln("failed to upload report")`
`71`	`72`	`}`
`72`	`73`
`73`		`- if uerr := callgraph.Upload(ctx, step.Name, time.Since(start).Milliseconds(), log, time.Now(), tiConfig, cgDir); uerr != nil {`
	`74`	`+ //Passing default false for failed test for now.`
	`75`	`+ if uerr := callgraph.Upload(ctx, step.Name, time.Since(start).Milliseconds(), log, time.Now(), tiConfig, cgDir, false); uerr != nil {`
`74`	`76`	`log.WithError(uerr).Errorln("unable to collect callgraph")`
`75`	`77`	`}`
`76`	`78`
`77`	`79`	`// Parse and upload savings to TI`
`78`	`80`	`if tiConfig.GetParseSavings() {`
`79`		`- optimizationState = savings.ParseAndUploadSavings(ctx, r.WorkingDir, log, step.Name, checkStepSuccess(exited, err), timeTakenMs, tiConfig, r.Envs)`
	`81`	`+ optimizationState = savings.ParseAndUploadSavings(ctx, r.WorkingDir, log, step.Name, checkStepSuccess(exited, err), timeTakenMs, tiConfig, r.Envs, telemetry)`
`80`	`82`	`}`
`81`	`83`
`82`	`84`	`summaryOutputs := make(map[string]string)`
`@@ -117,10 +119,10 @@ func executeRunTestStep(ctx context.Context, engine engine.Engine, r api.Start`
`117`	`119`	`if report.TestSummaryAsOutputEnabled(r.Envs) {`
`118`	`120`	`outputsV2 = append(outputsV2, summaryOutputsV2...)`
`119`	`121`	`}`
`120`		`- return exited, outputs, artifact, outputsV2, string(optimizationState), outputErr`
	`122`	`+ return exited, outputs, artifact, outputsV2, string(optimizationState), telemetry, outputErr`
`121`	`123`	`}`
`122`	`124`	`if len(summaryOutputsV2) > 0 && report.TestSummaryAsOutputEnabled(r.Envs) {`
`123`		`- return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err`
	`125`	`+ return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err`
`124`	`126`	`}`
`125`	`127`	`} else if len(r.OutputVars) > 0 {`
`126`	`128`	`if exited != nil && exited.Exited && exited.ExitCode == 0 {`
`@@ -134,17 +136,17 @@ func executeRunTestStep(ctx context.Context, engine engine.Engine, r api.Start`
`134`	`136`	`outputs[k] = v`
`135`	`137`	`}`
`136`	`138`	`}`
`137`		`- return exited, outputs, artifact, nil, string(optimizationState), outputErr`
	`139`	`+ return exited, outputs, artifact, nil, string(optimizationState), telemetry, outputErr`
`138`	`140`	`}`
`139`	`141`	`if len(summaryOutputs) != 0 && len(summaryOutputsV2) != 0 && report.TestSummaryAsOutputEnabled(r.Envs) {`
`140`	`142`	`// when step has failed return the actual error`
`141`		`- return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err`
	`143`	`+ return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err`
`142`	`144`	`}`
`143`	`145`	`}`
`144`	`146`
`145`	`147`	`if len(summaryOutputsV2) == 0 \|\| !report.TestSummaryAsOutputEnabled(r.Envs) {`
`146`		`- return exited, nil, artifact, nil, string(optimizationState), err`
	`148`	`+ return exited, nil, artifact, nil, string(optimizationState), telemetry, err`
`147`	`149`	`}`
`148`	`150`
`149`		`- return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err`
	`151`	`+ return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err`
`150`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,16 +30,17 @@ const (`
`30`	`30`	`)`
`31`	`31`
`32`	`32`	`func executeRunTestsV2Step(ctx context.Context, engine engine.Engine, r api.StartStepRequest, out io.Writer, tiConfig *tiCfg.Cfg) (`
`33`		`- runtime.State, map[string]string, []byte, []api.OutputV2, string, error) {`
	`33`	`+ runtime.State, map[string]string, []byte, []api.OutputV2, string, *types.TelemetryData, error) {`
`34`	`34`	`start := time.Now()`
	`35`	`+ telemetry := &types.TelemetryData{}`
`35`	`36`	`log := logrus.New()`
`36`	`37`	`log.Out = out`
`37`	`38`	`step := toStep(r)`
`38`	`39`	`optimizationState := types.DISABLED`
`39`	`40`	`step.Entrypoint = r.RunTestsV2.Entrypoint`
`40`		`- preCmd, err := leRuntime.SetupRunTestV2(ctx, &r.RunTestsV2, step.Name, r.WorkingDir, log, r.Envs, tiConfig)`
	`41`	`+ preCmd, err := leRuntime.SetupRunTestV2(ctx, &r.RunTestsV2, step.Name, r.WorkingDir, log, r.Envs, tiConfig, &telemetry.TestIntelligenceMetaData)`
`41`	`42`	`if err != nil {`
`42`		`- return nil, nil, nil, nil, string(optimizationState), err`
	`43`	`+ return nil, nil, nil, nil, string(optimizationState), telemetry, err`
`43`	`44`	`}`
`44`	`45`	`command := r.RunTestsV2.Command[0]`
`45`	`46`	`if preCmd != "" {`
`@@ -48,7 +49,7 @@ func executeRunTestsV2Step(ctx context.Context, engine engine.Engine, r api.St`
`48`	`49`	`step.Command = []string{command}`
`49`	`50`
`50`	`51`	`if (len(r.OutputVars) > 0 \|\| len(r.Outputs) > 0) && (len(step.Entrypoint) == 0 \|\| len(step.Command) == 0) {`
`51`		`- return nil, nil, nil, nil, string(optimizationState), fmt.Errorf("output variable should not be set for unset entrypoint or command")`
	`52`	`+ return nil, nil, nil, nil, string(optimizationState), telemetry, fmt.Errorf("output variable should not be set for unset entrypoint or command")`
`52`	`53`	`}`
`53`	`54`
`54`	`55`	`enablePluginOutputSecrets := IsFeatureFlagEnabled(ciEnablePluginOutputSecrets, engine, step)`
`@@ -87,17 +88,18 @@ func executeRunTestsV2Step(ctx context.Context, engine engine.Engine, r api.St`
`87`	`88`	`// If there are no paths specified, set Paths[0] to include all XML files and all TRX files`
`88`	`89`	`r.TestReport.Junit.Paths = []string{"*/.xml", "*/.trx"}`
`89`	`90`	`}`
`90`		`- if rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, r.Envs); rerr != nil {`
	`91`	`+ if _, rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, &telemetry.TestIntelligenceMetaData, r.Envs); rerr != nil {`
`91`	`92`	`log.WithError(rerr).Errorln("failed to upload report")`
`92`	`93`	`}`
`93`	`94`
`94`		`- if uerr := callgraph.Upload(ctx, step.Name, time.Since(start).Milliseconds(), log, time.Now(), tiConfig, outDir); uerr != nil {`
	`95`	`+ //Passing default false for failed test for now`
	`96`	`+ if uerr := callgraph.Upload(ctx, step.Name, time.Since(start).Milliseconds(), log, time.Now(), tiConfig, outDir, false); uerr != nil {`
`95`	`97`	`log.WithError(uerr).Errorln("unable to collect callgraph")`
`96`	`98`	`}`
`97`	`99`
`98`	`100`	`// Parse and upload savings to TI`
`99`	`101`	`if tiConfig.GetParseSavings() {`
`100`		`- optimizationState = savings.ParseAndUploadSavings(ctx, r.WorkingDir, log, step.Name, checkStepSuccess(exited, err), timeTakenMs, tiConfig, r.Envs)`
	`102`	`+ optimizationState = savings.ParseAndUploadSavings(ctx, r.WorkingDir, log, step.Name, checkStepSuccess(exited, err), timeTakenMs, tiConfig, r.Envs, telemetry)`
`101`	`103`	`}`
`102`	`104`
`103`	`105`	`artifact, _ := fetchArtifactDataFromArtifactFile(artifactFile, out)`
`@@ -170,12 +172,12 @@ func executeRunTestsV2Step(ctx context.Context, engine engine.Engine, r api.St`
`170`	`172`	`outputsV2 = append(outputsV2, summaryOutputsV2...)`
`171`	`173`	`}`
`172`	`174`
`173`		`- return exited, outputs, artifact, outputsV2, string(optimizationState), finalErr`
	`175`	`+ return exited, outputs, artifact, outputsV2, string(optimizationState), telemetry, finalErr`
`174`	`176`
`175`	`177`	`} else {`
`176`	`178`	`outputs, err := fetchOutputVariables(outputFile, out, false) // nolint:govet`
`177`	`179`	`if err != nil {`
`178`		`- return exited, nil, nil, nil, string(optimizationState), err`
	`180`	`+ return nil, nil, nil, nil, string(optimizationState), telemetry, err`
`179`	`181`	`}`
`180`	`182`	`// Delete output variable file`
`181`	`183`	`if ferr := os.Remove(outputFile); ferr != nil {`
`@@ -195,22 +197,22 @@ func executeRunTestsV2Step(ctx context.Context, engine engine.Engine, r api.St`
`195`	`197`	`if report.TestSummaryAsOutputEnabled(r.Envs) {`
`196`	`198`	`outputsV2 = append(outputsV2, summaryOutputsV2...)`
`197`	`199`	`}`
`198`		`- return exited, outputs, artifact, outputsV2, string(optimizationState), err`
	`200`	`+ return exited, outputs, artifact, outputsV2, string(optimizationState), telemetry, err`
`199`	`201`	`} else if len(r.OutputVars) > 0 {`
`200`	`202`	`// only return err when output vars are expected`
`201`	`203`	`if report.TestSummaryAsOutputEnabled(r.Envs) {`
`202`		`- return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err`
	`204`	`+ return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err`
`203`	`205`	`}`
`204`		`- return exited, outputs, artifact, nil, string(optimizationState), err`
	`206`	`+ return exited, outputs, artifact, nil, string(optimizationState), telemetry, err`
`205`	`207`	`}`
`206`	`208`	`if len(summaryOutputsV2) != 0 && report.TestSummaryAsOutputEnabled(r.Envs) {`
`207`		`- return exited, outputs, artifact, summaryOutputsV2, string(optimizationState), nil`
	`209`	`+ return exited, outputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, nil`
`208`	`210`	`}`
`209`		`- return exited, outputs, artifact, nil, string(optimizationState), nil`
	`211`	`+ return exited, outputs, artifact, nil, string(optimizationState), telemetry, nil`
`210`	`212`	`}`
`211`	`213`	`}`
`212`	`214`	`if len(summaryOutputsV2) != 0 && report.TestSummaryAsOutputEnabled(r.Envs) {`
`213`		`- return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), err`
	`215`	`+ return exited, summaryOutputs, artifact, summaryOutputsV2, string(optimizationState), telemetry, err`
`214`	`216`	`}`
`215`		`- return exited, nil, artifact, nil, string(optimizationState), err`
	`217`	`+ return exited, nil, artifact, nil, string(optimizationState), telemetry, err`
`216`	`218`	`}`