event tracker

Author: Andrea Falzetti

components/gitpod-cli/cmd/rebuild.go

@@ -48,18 +48,19 @@ var buildCmd = &cobra.Command{
 			return
 		}
 
-		event := &utils.TrackCommandUsageParams{
+		event := utils.TrackEvent(ctx, client, &utils.TrackCommandUsageParams{
 			Command: cmd.Name(),
-		}
+		})
 
 		ctx = context.Background()
+
 		gitpodConfig, err := util.ParseGitpodConfig(wsInfo.CheckoutLocation)
 		if err != nil {
 			fmt.Println("The .gitpod.yml file cannot be parsed: please check the file and try again")
 			fmt.Println("")
 			fmt.Println("For help check out the reference page:")
 			fmt.Println("https://www.gitpod.io/docs/references/gitpod-yml#gitpodyml")
-			utils.TrackUsage()
+			event.Set("ErrorCode", utils.RebuildErrorCode_MalformedGitpodYaml).Send(ctx)
 			return
 		}
 
@@ -70,6 +71,7 @@ var buildCmd = &cobra.Command{
 			fmt.Println("")
 			fmt.Println("Alternatively, check out the following docs for getting started configuring your project")
 			fmt.Println("https://www.gitpod.io/docs/configure#configure-gitpod")
+			event.Set("ErrorCode", utils.RebuildErrorCode_MissingGitpodYaml).Send(ctx)
 			return
 		}
 
@@ -84,6 +86,7 @@ var buildCmd = &cobra.Command{
 
 			if _, err := os.Stat(dockerfilePath); os.IsNotExist(err) {
 				fmt.Println("Your .gitpod.yml points to a Dockerfile that doesn't exist: " + dockerfilePath)
+				event.Set("ErrorCode", utils.RebuildErrorCode_DockerfileNotFound).Send(ctx)
 				return
 			}
 			dockerfile, err := os.ReadFile(dockerfilePath)
@@ -98,15 +101,18 @@ var buildCmd = &cobra.Command{
 				fmt.Println("https://www.gitpod.io/docs/configure/workspaces/workspace-image#use-a-custom-dockerfile")
 				fmt.Println("")
 				fmt.Println("Once you configure your Dockerfile, re-run this command to validate your changes")
+				event.Set("ErrorCode", utils.RebuildErrorCode_DockerfileEmpty).Send(ctx)
 				return
 			}
 			baseimage = "\n" + string(dockerfile) + "\n"
 		default:
 			fmt.Println("Check your .gitpod.yml and make sure the image property is configured correctly")
+			event.Set("ErrorCode", utils.RebuildErrorCode_MalformedGitpodYaml).Send(ctx)
 			return
 		}
 
 		if baseimage == "" {
+			// TODO: should this fallback to workspace full?
 			fmt.Println("Your project is not using any custom Docker image.")
 			fmt.Println("Check out the following docs, to know how to get started")
 			fmt.Println("")
@@ -126,6 +132,7 @@ var buildCmd = &cobra.Command{
 		dockerPath, err := exec.LookPath("docker")
 		if err != nil {
 			fmt.Println("Docker is not installed in your workspace")
+			event.Set("ErrorCode", utils.RebuildErrorCode_DockerNotFound).Send(ctx)
 			return
 		}
 
@@ -148,13 +155,13 @@ var buildCmd = &cobra.Command{
 		// TODO: duration
 		err = dockerCmd.Run()
 		if _, ok := err.(*exec.ExitError); ok {
-			// event.Duration = time.Since(startTime).Seconds()
-			utils.TrackUsage(ctx, client, event)
 			fmt.Println("Image Build Failed")
+			event.Set("ErrorCode", utils.RebuildErrorCode_DockerBuildFailed).Send(ctx)
 			log.Fatal(err)
 			return
 		} else if err != nil {
 			fmt.Println("Docker error")
+			event.Set("ErrorCode", utils.RebuildErrorCode_DockerErr).Send(ctx)
 			log.Fatal(err)
 			return
 		}

components/gitpod-cli/pkg/utils/trackEvent.go

@@ -6,6 +6,8 @@ package utils
 
 import (
 	"context"
+	"fmt"
+	"time"
 
 	gitpod "github.com/gitpod-io/gitpod/gitpod-cli/pkg/gitpod"
 	"github.com/gitpod-io/gitpod/gitpod-cli/pkg/supervisor"
@@ -14,41 +16,100 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
+const (
+	// Rebuild
+	RebuildErrorCode_MalformedGitpodYaml = "rebuild_malformed_gitpod_yaml"
+	RebuildErrorCode_MissingGitpodYaml   = "rebuild_missing_gitpod_yaml"
+	RebuildErrorCode_DockerfileNotFound  = "rebuild_dockerfile_not_found"
+	RebuildErrorCode_DockerfileEmpty     = "rebuild_dockerfile_empty"
+	RebuildErrorCode_DockerNotFound      = "rebuild_docker_not_found"
+	RebuildErrorCode_DockerBuildFailed   = "rebuild_docker_build_failed"
+	RebuildErrorCode_DockerErr           = "rebuild_docker_err"
+)
+
 type TrackCommandUsageParams struct {
 	Command             string `json:"command,omitempty"`
-	DurationMs          int64  `json:"duration,omitempty"`
+	DurationMs          int64  `json:"durationMs,omitempty"`
+	Success             bool   `json:"success,omitempty"`
+	ErrorCode           string `json:"errorCode,omitempty"`
 	WorkspaceId         string `json:"workspaceId,omitempty"`
 	WorkspaceInstanceId string `json:"workspaceInstanceId,omitempty"`
 	Timestamp           int64  `json:"timestamp,omitempty"`
 }
 
-func TrackUsage(ctx context.Context, supervisorClient *supervisor.SupervisorClient, cmdParams *TrackCommandUsageParams) {
+type EventTracker struct {
+	data             *TrackCommandUsageParams
+	startTime        time.Time
+	serverClient     *serverapi.APIoverJSONRPC
+	supervisorClient *supervisor.SupervisorClient
+}
+
+func TrackEvent(ctx context.Context, supervisorClient *supervisor.SupervisorClient, cmdParams *TrackCommandUsageParams) *EventTracker {
+	tracker := &EventTracker{
+		startTime:        time.Now(),
+		supervisorClient: supervisorClient,
+	}
+
 	wsInfo, err := supervisorClient.Info.WorkspaceInfo(ctx, &api.WorkspaceInfoRequest{})
 	if err != nil {
 		LogError(ctx, err, "Could not fetch the workspace info", supervisorClient)
-		return
+		return nil
 	}
 
-	client, err := gitpod.ConnectToServer(ctx, wsInfo, []string{"function:trackEvent"})
+	serverClient, err := gitpod.ConnectToServer(ctx, wsInfo, []string{"function:trackEvent"})
 	if err != nil {
 		log.WithError(err).Fatal("error connecting to server")
+		return nil
 	}
-	defer client.Close()
+	defer serverClient.Close()
 
-	params := &TrackCommandUsageParams{
+	tracker.serverClient = serverClient
+	tracker.data = &TrackCommandUsageParams{
 		Command:             cmdParams.Command,
-		DurationMs:          cmdParams.DurationMs,
-		WorkspaceId:         "",
-		WorkspaceInstanceId: "",
-		Timestamp:           0,
+		DurationMs:          0,
+		WorkspaceId:         wsInfo.WorkspaceId,
+		WorkspaceInstanceId: wsInfo.InstanceId,
+		ErrorCode:           "",
+		Timestamp:           time.Now().UnixMilli(),
+	}
+
+	return tracker
+}
+
+func (t *EventTracker) Set(key string, value interface{}) *EventTracker {
+	switch key {
+	case "Command":
+		t.data.Command = value.(string)
+	case "Success":
+		t.data.Success = value.(bool)
+	case "ErrorCode":
+		t.data.ErrorCode = value.(string)
+		t.data.Success = false
+	case "DurationMs":
+		t.data.DurationMs = value.(int64)
+	case "WorkspaceId":
+		t.data.WorkspaceId = value.(string)
+	case "WorkspaceInstanceId":
+		t.data.WorkspaceInstanceId = value.(string)
+	default:
+		log.Warnf("Field not allowed: '%s'", key)
 	}
+	return t
+}
+
+func (t *EventTracker) Send(ctx context.Context) {
+	t.Set("DurationMs", time.Since(t.startTime).Milliseconds())
+
 	event := &serverapi.RemoteTrackMessage{
 		Event:      "gp_command",
-		Properties: *params,
+		Properties: t.data,
 	}
 
-	err = client.TrackEvent(ctx, event)
+	err := t.serverClient.TrackEvent(ctx, event)
 	if err != nil {
-		LogError(ctx, err, "Could not track gp command event", supervisorClient)
+		LogError(ctx, err, "Could not track gp command event", t.supervisorClient)
+		return
 	}
+
+	fmt.Println("EVENT SENT TO SERVER")
 }