coder · ammario · Sep 11, 2022 · Sep 11, 2022 · Sep 11, 2022 · Sep 12, 2022
diff --git a/coderd/database/databasefake/databasefake.go b/coderd/database/databasefake/databasefake.go
@@ -235,6 +235,35 @@ func (q *fakeQuerier) GetTemplateDAUs(_ context.Context, templateID uuid.UUID) (
 	return rs, nil
 }
 
+func (q *fakeQuerier) GetTemplateAverageBuildTime(ctx context.Context, arg database.GetTemplateAverageBuildTimeParams) (float64, error) {
+	var times []float64
+	for _, wb := range q.workspaceBuilds {
+		if wb.Transition != database.WorkspaceTransitionStart {
+			continue
+		}
+		version, err := q.GetTemplateVersionByID(ctx, wb.TemplateVersionID)
+		if err != nil {
+			return -1, err
+		}
+		if version.TemplateID != arg.TemplateID {
+			continue
+		}
+
+		job, err := q.GetProvisionerJobByID(ctx, wb.JobID)
+		if err != nil {
+			return -1, err
+		}
+		if job.CompletedAt.Valid {
+			times = append(times, job.CompletedAt.Time.Sub(job.StartedAt.Time).Seconds())
+		}
+	}
+	sort.Float64s(times)
+	if len(times) == 0 {
+		return -1, nil
+	}
+	return times[len(times)/2], nil
+}
+
 func (q *fakeQuerier) ParameterValue(_ context.Context, id uuid.UUID) (database.ParameterValue, error) {
 	q.mutex.Lock()
 	defer q.mutex.Unlock()

diff --git a/coderd/database/querier.go b/coderd/database/querier.go
diff --git a/coderd/database/queries.sql.go b/coderd/database/queries.sql.go
diff --git a/coderd/database/queries/templates.sql b/coderd/database/queries/templates.sql
@@ -105,3 +105,26 @@ WHERE
 	id = $1
 RETURNING
 	*;
+
+-- name: GetTemplateAverageBuildTime :one
+WITH build_times AS (
+SELECT
+	EXTRACT(EPOCH FROM (pj.completed_at - pj.started_at)) AS exec_time_sec
+FROM
+	workspace_builds
+JOIN template_versions ON
+	workspace_builds.template_version_id = template_versions.id
+JOIN provisioner_jobs pj ON
+	workspace_builds.job_id = pj.id
+WHERE
+	template_versions.template_id = @template_id AND
+		(workspace_builds.transition = 'start') AND
+		(pj.completed_at IS NOT NULL) AND (pj.started_at IS NOT NULL) AND
+		(pj.started_at > @start_time) AND
+		(pj.canceled_at IS NULL) AND
+		((pj.error IS NULL) OR (pj.error = ''))
+ORDER BY
+	workspace_builds.created_at DESC
+)
+SELECT CAST(PERCENTILE_DISC(0.5) WITHIN GROUP(ORDER BY exec_time_sec) AS FLOAT) FROM build_times
+;
diff --git a/coderd/metricscache/metricscache.go b/coderd/metricscache/metricscache.go
@@ -2,6 +2,7 @@ package metricscache
 
 import (
 	"context"
+	"database/sql"
 	"sync/atomic"
 	"time"
 
@@ -17,7 +18,7 @@ import (
 	"github.com/coder/retry"
 )
 
-// Cache holds the template DAU cache.
+// Cache holds the template metrics.
 // The aggregation queries responsible for these values can take up to a minute
 // on large deployments. Even in small deployments, aggregation queries can
 // take a few hundred milliseconds, which would ruin page load times and
@@ -26,8 +27,9 @@ type Cache struct {
 	database database.Store
 	log      slog.Logger
 
-	templateDAUResponses atomic.Pointer[map[uuid.UUID]codersdk.TemplateDAUsResponse]
-	templateUniqueUsers  atomic.Pointer[map[uuid.UUID]int]
+	templateDAUResponses     atomic.Pointer[map[uuid.UUID]codersdk.TemplateDAUsResponse]
+	templateUniqueUsers      atomic.Pointer[map[uuid.UUID]int]
+	templateAverageBuildTime atomic.Pointer[map[uuid.UUID]time.Duration]
 
 	done   chan struct{}
 	cancel func()
@@ -128,8 +130,9 @@ func (c *Cache) refresh(ctx context.Context) error {
 	}
 
 	var (
-		templateDAUs        = make(map[uuid.UUID]codersdk.TemplateDAUsResponse, len(templates))
-		templateUniqueUsers = make(map[uuid.UUID]int)
+		templateDAUs                = make(map[uuid.UUID]codersdk.TemplateDAUsResponse, len(templates))
+		templateUniqueUsers         = make(map[uuid.UUID]int)
+		templateAverageBuildTimeSec = make(map[uuid.UUID]time.Duration)
 	)
 	for _, template := range templates {
 		rows, err := c.database.GetTemplateDAUs(ctx, template.ID)
@@ -138,9 +141,24 @@ func (c *Cache) refresh(ctx context.Context) error {
 		}
 		templateDAUs[template.ID] = convertDAUResponse(rows)
 		templateUniqueUsers[template.ID] = countUniqueUsers(rows)
+		avgBuildTime, err := c.database.GetTemplateAverageBuildTime(ctx, database.GetTemplateAverageBuildTimeParams{
+			TemplateID: uuid.NullUUID{
+				UUID:  template.ID,
+				Valid: true,
+			},
+			StartTime: sql.NullTime{
+				Time:  database.Time(time.Now().AddDate(0, -30, 0)),
+				Valid: true,
+			},
+		})
+		if err != nil {
+			return err
+		}
+		templateAverageBuildTimeSec[template.ID] = time.Duration(float64(time.Second) * avgBuildTime)
 	}
 	c.templateDAUResponses.Store(&templateDAUs)
 	c.templateUniqueUsers.Store(&templateUniqueUsers)
+	c.templateAverageBuildTime.Store(&templateAverageBuildTimeSec)
 
 	return nil
 }
@@ -220,3 +238,18 @@ func (c *Cache) TemplateUniqueUsers(id uuid.UUID) (int, bool) {
 	}
 	return resp, true
 }
+
+func (c *Cache) TemplateAverageBuildTime(id uuid.UUID) (time.Duration, bool) {
+	m := c.templateAverageBuildTime.Load()
+	if m == nil {
+		// Data loading.
+		return -1, false
+	}
+
+	resp, ok := (*m)[id]
+	if !ok || resp <= 0 {
+		// No data or not enough builds.
+		return -1, false
+	}
+	return resp, true
+}
diff --git a/coderd/metricscache/metricscache_test.go b/coderd/metricscache/metricscache_test.go
@@ -2,6 +2,7 @@ package metricscache_test
 
 import (
 	"context"
+	"database/sql"
 	"testing"
 	"time"
 
@@ -20,7 +21,7 @@ func date(year, month, day int) time.Time {
 	return time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
 }
 
-func TestCache(t *testing.T) {
+func TestCache_TemplateUsers(t *testing.T) {
 	t.Parallel()
 
 	var (
@@ -197,3 +198,153 @@ func TestCache(t *testing.T) {
 		})
 	}
 }
+
+func clockTime(t time.Time, hour, minute, sec int) time.Time {
+	return time.Date(t.Year(), t.Month(), t.Day(), hour, minute, sec, t.Nanosecond(), t.Location())
+}
+
+func TestCache_BuildTime(t *testing.T) {
+	t.Parallel()
+
+	someDay := date(2022, 10, 1)
+
+	type jobParams struct {
+		startedAt   time.Time
+		completedAt time.Time
+	}
+
+	type args struct {
+		rows []jobParams
+	}
+	type want struct {
+		buildTime time.Duration
+	}
+	tests := []struct {
+		name string
+		args args
+		want want
+	}{
+		{"empty", args{}, want{-1}},
+		{"one", args{
+			rows: []jobParams{
+				{
+					startedAt:   clockTime(someDay, 10, 1, 0),
+					completedAt: clockTime(someDay, 10, 1, 10),
+				},
+			},
+		}, want{time.Second * 10},
+		},
+		{"two", args{
+			rows: []jobParams{
+				{
+					startedAt:   clockTime(someDay, 10, 1, 0),
+					completedAt: clockTime(someDay, 10, 1, 10),
+				},
+				{
+					startedAt:   clockTime(someDay, 10, 1, 0),
+					completedAt: clockTime(someDay, 10, 1, 50),
+				},
+			},
+		}, want{time.Second * 50},
+		},
+		{"three", args{
+			rows: []jobParams{
+				{
+					startedAt:   clockTime(someDay, 10, 1, 0),
+					completedAt: clockTime(someDay, 10, 1, 10),
+				},
+				{
+					startedAt:   clockTime(someDay, 10, 1, 0),
+					completedAt: clockTime(someDay, 10, 1, 50),
+				}, {
+					startedAt:   clockTime(someDay, 10, 1, 0),
+					completedAt: clockTime(someDay, 10, 1, 20),
+				},
+			},
+		}, want{time.Second * 20},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			ctx := context.Background()
+
+			var (
+				db    = databasefake.New()
+				cache = metricscache.New(db, slogtest.Make(t, nil), testutil.IntervalFast)
+			)
+
+			defer cache.Close()
+
+			template, err := db.InsertTemplate(ctx, database.InsertTemplateParams{
+				ID: uuid.New(),
+			})
+			require.NoError(t, err)
+
+			templateVersion, err := db.InsertTemplateVersion(ctx, database.InsertTemplateVersionParams{
+				ID:         uuid.New(),
+				TemplateID: uuid.NullUUID{UUID: template.ID, Valid: true},
+			})
+			require.NoError(t, err)
+
+			gotBuildTime, ok := cache.TemplateAverageBuildTime(template.ID)
+			require.False(t, ok, "template shouldn't have loaded yet")
+			require.EqualValues(t, -1, gotBuildTime)
+
+			for _, row := range tt.args.rows {
+				_, err := db.InsertProvisionerJob(ctx, database.InsertProvisionerJobParams{
+					ID:          uuid.New(),
+					Provisioner: database.ProvisionerTypeEcho,
+				})
+				require.NoError(t, err)
+
+				job, err := db.AcquireProvisionerJob(ctx, database.AcquireProvisionerJobParams{
+					StartedAt: sql.NullTime{Time: row.startedAt, Valid: true},
+					Types: []database.ProvisionerType{
+						database.ProvisionerTypeEcho,
+					},
+				})
+				require.NoError(t, err)
+
+				_, err = db.InsertWorkspaceBuild(ctx, database.InsertWorkspaceBuildParams{
+					TemplateVersionID: templateVersion.ID,
+					JobID:             job.ID,
+					Transition:        database.WorkspaceTransitionStart,
+				})
+				require.NoError(t, err)
+
+				err = db.UpdateProvisionerJobWithCompleteByID(ctx, database.UpdateProvisionerJobWithCompleteByIDParams{
+					ID:          job.ID,
+					CompletedAt: sql.NullTime{Time: row.completedAt, Valid: true},
+				})
+				require.NoError(t, err)
+			}
+
+			if tt.want.buildTime > 0 {
+				require.Eventuallyf(t, func() bool {
+					_, ok := cache.TemplateAverageBuildTime(template.ID)
+					return ok
+				}, testutil.WaitShort, testutil.IntervalMedium,
+					"TemplateDAUs never populated",
+				)
+
+				gotBuildTime, ok = cache.TemplateAverageBuildTime(template.ID)
+				require.True(t, ok)
+				require.Equal(t, tt.want.buildTime, gotBuildTime)
+			} else {
+				require.Never(t, func() bool {
+					_, ok := cache.TemplateAverageBuildTime(template.ID)
+					return ok
+				}, testutil.WaitShort/2, testutil.IntervalMedium,
+					"TemplateDAUs never populated",
+				)
+
+				gotBuildTime, ok = cache.TemplateAverageBuildTime(template.ID)
+				require.False(t, ok)
+				require.Less(t, gotBuildTime, time.Duration(0))
+			}
+		})
+	}
+}
diff --git a/coderd/templates.go b/coderd/templates.go
@@ -773,6 +773,15 @@ func (api *API) convertTemplate(
 	template database.Template, workspaceOwnerCount uint32, createdByName string,
 ) codersdk.Template {
 	activeCount, _ := api.metricsCache.TemplateUniqueUsers(template.ID)
+
+	var averageBuildTimeMillis int64
+	averageBuildTime, ok := api.metricsCache.TemplateAverageBuildTime(template.ID)
+	if !ok {
+		averageBuildTimeMillis = -1
+	} else {
+		averageBuildTimeMillis = int64(averageBuildTime / time.Millisecond)
+	}
+
 	return codersdk.Template{
 		ID:                         template.ID,
 		CreatedAt:                  template.CreatedAt,
@@ -783,6 +792,7 @@ func (api *API) convertTemplate(
 		ActiveVersionID:            template.ActiveVersionID,
 		WorkspaceOwnerCount:        workspaceOwnerCount,
 		ActiveUserCount:            activeCount,
+		AverageBuildTimeMillis:     averageBuildTimeMillis,
 		Description:                template.Description,
 		Icon:                       template.Icon,
 		MaxTTLMillis:               time.Duration(template.MaxTtl).Milliseconds(),