coder · kylecarbs · Feb 7, 2022 · Feb 6, 2022 · Feb 6, 2022 · Feb 6, 2022
diff --git a/.github/workflows/coder.yaml b/.github/workflows/coder.yaml
@@ -159,45 +159,27 @@ jobs:
           -covermode=atomic -coverprofile="gotests.coverage"
           -timeout=3m -count=5 -race -short -parallel=2
 
+      - name: Upload DataDog Trace
+        if: (success() || failure()) && github.actor != 'dependabot[bot]'
+        env:
+          DATADOG_API_KEY: ${{ secrets.DATADOG_API_KEY }}
+          DD_DATABASE: fake
+          GIT_COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
+        run: go run scripts/datadog-cireport/main.go gotests.xml
+
       - name: Test with PostgreSQL Database
         if: runner.os == 'Linux'
         run: DB=true gotestsum --junitfile="gotests.xml" --packages="./..." --
           -covermode=atomic -coverprofile="gotests.coverage" -timeout=3m
           -count=1 -race -parallel=2
 
-      - name: Setup Node for DataDog CLI
-        uses: actions/setup-node@v2
-        if: always() && github.actor != 'dependabot[bot]'
-        with:
-          node-version: "14"
-
-      - name: Cache DataDog CLI
-        if: always() && github.actor != 'dependabot[bot]'
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.npm
-            %LocalAppData%\npm-cache
-          key: datadogci-
-          restore-keys: datadogci-
-
       - name: Upload DataDog Trace
-        if: always() && github.actor != 'dependabot[bot]'
-        # See: https://docs.datadoghq.com/continuous_integration/setup_tests/junit_upload/#collecting-environment-configuration-metadata
+        if: (success() || failure()) && github.actor != 'dependabot[bot]'
         env:
           DATADOG_API_KEY: ${{ secrets.DATADOG_API_KEY }}
-          DD_GIT_REPOSITORY_URL: ${{ github.repositoryUrl }}
-          DD_GIT_BRANCH: ${{ github.head_ref }}
-          DD_GIT_COMMIT_SHA: ${{ github.sha }}
-          DD_GIT_COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
-          DD_GIT_COMMIT_AUTHOR_NAME: ${{ github.event.head_commit.author.name }}
-          DD_GIT_COMMIT_AUTHOR_EMAIL: ${{ github.event.head_commit.author.email }}
-          DD_GIT_COMMIT_COMMITTER_NAME: ${{ github.event.head_commit.committer.name }}
-          DD_GIT_COMMIT_COMMITTER_EMAIL: ${{ github.event.head_commit.committer.email }}
-          DD_TAGS: ${{ format('os.platform:{0},os.architecture:{1}', runner.os, runner.arch) }} 
-        run: |
-          npm install -g @datadog/datadog-ci
-          datadog-ci junit upload --service coder gotests.xml
+          DD_DATABASE: postgresql
+          GIT_COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
+        run: go run scripts/datadog-cireport/main.go gotests.xml
 
       - uses: codecov/codecov-action@v2
         if: github.actor != 'dependabot[bot]'

diff --git a/codecov.yml b/codecov.yml
@@ -31,3 +31,4 @@ ignore:
   - peerbroker/proto
   - provisionerd/proto
   - provisionersdk/proto
+  - scripts/datadog-cireport
diff --git a/coderd/projectversion.go b/coderd/projectversion.go
@@ -125,16 +125,29 @@ func (api *api) postProjectVersionByOrganization(rw http.ResponseWriter, r *http
 	var provisionerJob database.ProvisionerJob
 	var projectVersion database.ProjectVersion
 	err = api.Database.InTx(func(db database.Store) error {
-		projectVersionID := uuid.New()
+		provisionerJobID := uuid.New()
+		projectVersion, err = api.Database.InsertProjectVersion(r.Context(), database.InsertProjectVersionParams{
+			ID:            uuid.New(),
+			ProjectID:     project.ID,
+			CreatedAt:     database.Now(),
+			UpdatedAt:     database.Now(),
+			Name:          namesgenerator.GetRandomName(1),
+			StorageMethod: createProjectVersion.StorageMethod,
+			StorageSource: createProjectVersion.StorageSource,
+			ImportJobID:   provisionerJobID,
+		})
+		if err != nil {
+			return xerrors.Errorf("insert project version: %s", err)
+		}
+
 		input, err := json.Marshal(projectImportJob{
-			ProjectVersionID: projectVersionID,
+			ProjectVersionID: projectVersion.ID,
 		})
 		if err != nil {
 			return xerrors.Errorf("marshal import job: %w", err)
 		}
-
 		provisionerJob, err = db.InsertProvisionerJob(r.Context(), database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
+			ID:          provisionerJobID,
 			CreatedAt:   database.Now(),
 			UpdatedAt:   database.Now(),
 			InitiatorID: apiKey.UserID,
@@ -146,20 +159,6 @@ func (api *api) postProjectVersionByOrganization(rw http.ResponseWriter, r *http
 		if err != nil {
 			return xerrors.Errorf("insert provisioner job: %w", err)
 		}
-
-		projectVersion, err = api.Database.InsertProjectVersion(r.Context(), database.InsertProjectVersionParams{
-			ID:            projectVersionID,
-			ProjectID:     project.ID,
-			CreatedAt:     database.Now(),
-			UpdatedAt:     database.Now(),
-			Name:          namesgenerator.GetRandomName(1),
-			StorageMethod: createProjectVersion.StorageMethod,
-			StorageSource: createProjectVersion.StorageSource,
-			ImportJobID:   provisionerJob.ID,
-		})
-		if err != nil {
-			return xerrors.Errorf("insert project version: %s", err)
-		}
 		return nil
 	})
 	if err != nil {

diff --git a/coderd/provisionerdaemons.go b/coderd/provisionerdaemons.go
@@ -377,6 +377,13 @@ func (server *provisionerdServer) CancelJob(ctx context.Context, cancelJob *prot
 	if err != nil {
 		return nil, xerrors.Errorf("parse job id: %w", err)
 	}
+	job, err := server.Database.GetProvisionerJobByID(ctx, jobID)
+	if err != nil {
+		return nil, xerrors.Errorf("get provisioner job: %w", err)
+	}
+	if job.CompletedAt.Valid {
+		return nil, xerrors.Errorf("job already completed")
+	}
 	err = server.Database.UpdateProvisionerJobWithCompleteByID(ctx, database.UpdateProvisionerJobWithCompleteByIDParams{
 		ID: jobID,
 		CompletedAt: sql.NullTime{

diff --git a/coderd/workspacehistory.go b/coderd/workspacehistory.go
@@ -126,17 +126,32 @@ func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Reque
 	// This must happen in a transaction to ensure history can be inserted, and
 	// the prior history can update it's "after" column to point at the new.
 	err = api.Database.InTx(func(db database.Store) error {
-		// Generate the ID before-hand so the provisioner job is aware of it!
-		workspaceHistoryID := uuid.New()
+		provisionerJobID := uuid.New()
+		workspaceHistory, err = db.InsertWorkspaceHistory(r.Context(), database.InsertWorkspaceHistoryParams{
+			ID:               uuid.New(),
+			CreatedAt:        database.Now(),
+			UpdatedAt:        database.Now(),
+			WorkspaceID:      workspace.ID,
+			ProjectVersionID: projectVersion.ID,
+			BeforeID:         priorHistoryID,
+			Name:             namesgenerator.GetRandomName(1),
+			Initiator:        user.ID,
+			Transition:       createBuild.Transition,
+			ProvisionJobID:   provisionerJobID,
+		})
+		if err != nil {
+			return xerrors.Errorf("insert workspace history: %w", err)
+		}
+
 		input, err := json.Marshal(workspaceProvisionJob{
-			WorkspaceHistoryID: workspaceHistoryID,
+			WorkspaceHistoryID: workspaceHistory.ID,
 		})
 		if err != nil {
 			return xerrors.Errorf("marshal provision job: %w", err)
 		}
 
 		provisionerJob, err = db.InsertProvisionerJob(r.Context(), database.InsertProvisionerJobParams{
-			ID:          uuid.New(),
+			ID:          provisionerJobID,
 			CreatedAt:   database.Now(),
 			UpdatedAt:   database.Now(),
 			InitiatorID: user.ID,
@@ -149,22 +164,6 @@ func (api *api) postWorkspaceHistoryByUser(rw http.ResponseWriter, r *http.Reque
 			return xerrors.Errorf("insert provisioner job: %w", err)
 		}
 
-		workspaceHistory, err = db.InsertWorkspaceHistory(r.Context(), database.InsertWorkspaceHistoryParams{
-			ID:               workspaceHistoryID,
-			CreatedAt:        database.Now(),
-			UpdatedAt:        database.Now(),
-			WorkspaceID:      workspace.ID,
-			ProjectVersionID: projectVersion.ID,
-			BeforeID:         priorHistoryID,
-			Name:             namesgenerator.GetRandomName(1),
-			Initiator:        user.ID,
-			Transition:       createBuild.Transition,
-			ProvisionJobID:   provisionerJob.ID,
-		})
-		if err != nil {
-			return xerrors.Errorf("insert workspace history: %w", err)
-		}
-
 		if priorHistoryID.Valid {
 			// Update the prior history entries "after" column.
 			err = db.UpdateWorkspaceHistoryByID(r.Context(), database.UpdateWorkspaceHistoryByIDParams{

diff --git a/coderd/workspacehistory_test.go b/coderd/workspacehistory_test.go
@@ -59,10 +59,12 @@ func TestPostWorkspaceHistoryByUser(t *testing.T) {
 		t.Parallel()
 		client := coderdtest.New(t)
 		user := coderdtest.CreateInitialUser(t, client)
-		coderdtest.NewProvisionerDaemon(t, client)
+		closeDaemon := coderdtest.NewProvisionerDaemon(t, client)
 		project := coderdtest.CreateProject(t, client, user.Organization)
 		version := coderdtest.CreateProjectVersion(t, client, user.Organization, project.Name, nil)
 		coderdtest.AwaitProjectVersionImported(t, client, user.Organization, project.Name, version.Name)
+		// Close here so workspace history doesn't process!
+		closeDaemon.Close()
 		workspace := coderdtest.CreateWorkspace(t, client, "me", project.ID)
 		_, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
 			ProjectVersionID: version.ID,

diff --git a/codersdk/workspaces_test.go b/codersdk/workspaces_test.go
@@ -220,12 +220,13 @@ func TestFollowWorkspaceHistoryLogsAfter(t *testing.T) {
 		})
 		coderdtest.AwaitProjectVersionImported(t, client, user.Organization, project.Name, version.Name)
 		workspace := coderdtest.CreateWorkspace(t, client, "", project.ID)
+		after := database.Now()
 		history, err := client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
 			ProjectVersionID: version.ID,
 			Transition:       database.WorkspaceTransitionCreate,
 		})
 		require.NoError(t, err)
-		logs, err := client.FollowWorkspaceHistoryLogsAfter(context.Background(), "", workspace.Name, history.Name, time.Time{})
+		logs, err := client.FollowWorkspaceHistoryLogsAfter(context.Background(), "", workspace.Name, history.Name, after)
 		require.NoError(t, err)
 		_, ok := <-logs
 		require.True(t, ok)

diff --git a/rules.go b/rules.go
@@ -10,18 +10,17 @@ func xerrors(m dsl.Matcher) {
 	m.Import("errors")
 	m.Import("fmt")
 	m.Import("golang.org/x/xerrors")
-	msg := "Use xerrors to provide additional stacktrace information!"
 
 	m.Match("fmt.Errorf($*args)").
 		Suggest("xerrors.New($args)").
-		Report(msg)
+		Report("Use xerrors to provide additional stacktrace information!")
 
 	m.Match("fmt.Errorf($*args)").
 		Suggest("xerrors.Errorf($args)").
-		Report(msg)
+		Report("Use xerrors to provide additional stacktrace information!")
 
 	m.Match("errors.New($msg)").
 		Where(m["msg"].Type.Is("string")).
 		Suggest("xerrors.New($msg)").
-		Report(msg)
+		Report("Use xerrors to provide additional stacktrace information!")
 }