coder · BrunoQuaresma · Jan 26, 2023 · Jan 18, 2023 · Jan 18, 2023 · Jan 18, 2023
diff --git a/coderd/coderd.go b/coderd/coderd.go
@@ -612,6 +612,10 @@ func New(options *Options) *API {
 				r.Get("/", api.workspaceApplicationAuth)
 			})
 		})
+		r.Route("/insights", func(r chi.Router) {
+			r.Use(apiKeyMiddleware)
+			r.Get("/daus", api.deploymentDAUs)
+		})
 	})
 
 	if options.SwaggerEndpoint {

diff --git a/coderd/database/databasefake/databasefake.go b/coderd/database/databasefake/databasefake.go
@@ -281,6 +281,42 @@ func (q *fakeQuerier) GetTemplateDAUs(_ context.Context, templateID uuid.UUID) (
 	return rs, nil
 }
 
+func (q *fakeQuerier) GetDeploymentDAUs(_ context.Context) ([]database.GetDeploymentDAUsRow, error) {
+	q.mutex.Lock()
+	defer q.mutex.Unlock()
+
+	seens := make(map[time.Time]map[uuid.UUID]struct{})
+
+	for _, as := range q.agentStats {
+		date := as.CreatedAt.Truncate(time.Hour * 24)
+
+		dateEntry := seens[date]
+		if dateEntry == nil {
+			dateEntry = make(map[uuid.UUID]struct{})
+		}
+		dateEntry[as.UserID] = struct{}{}
+		seens[date] = dateEntry
+	}
+
+	seenKeys := maps.Keys(seens)
+	sort.Slice(seenKeys, func(i, j int) bool {
+		return seenKeys[i].Before(seenKeys[j])
+	})
+
+	var rs []database.GetDeploymentDAUsRow
+	for _, key := range seenKeys {
+		ids := seens[key]
+		for id := range ids {
+			rs = append(rs, database.GetDeploymentDAUsRow{
+				Date:   key,
+				UserID: id,
+			})
+		}
+	}
+
+	return rs, nil
+}
+
 func (q *fakeQuerier) GetTemplateAverageBuildTime(ctx context.Context, arg database.GetTemplateAverageBuildTimeParams) (database.GetTemplateAverageBuildTimeRow, error) {
 	var emptyRow database.GetTemplateAverageBuildTimeRow
 	var (

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/agentstats.sql b/coderd/database/queries/agentstats.sql
@@ -13,10 +13,10 @@ VALUES
 	($1, $2, $3, $4, $5, $6, $7) RETURNING *;
 
 -- name: GetLatestAgentStat :one
-SELECT * FROM agent_stats WHERE agent_id = $1 ORDER BY created_at DESC LIMIT 1; 
+SELECT * FROM agent_stats WHERE agent_id = $1 ORDER BY created_at DESC LIMIT 1;
 
 -- name: GetTemplateDAUs :many
-SELECT 
+SELECT
 	(created_at at TIME ZONE 'UTC')::date as date,
 	user_id
 FROM
@@ -28,5 +28,16 @@ GROUP BY
 ORDER BY
 	date ASC;
 
+-- name: GetDeploymentDAUs :many
+SELECT
+	(created_at at TIME ZONE 'UTC')::date as date,
+	user_id
+FROM
+	agent_stats
+GROUP BY
+	date, user_id
+ORDER BY
+	date ASC;
+
 -- name: DeleteOldAgentStats :exec
 DELETE FROM agent_stats WHERE created_at < NOW() - INTERVAL '30 days';
diff --git a/coderd/insights.go b/coderd/insights.go
@@ -0,0 +1,26 @@
+package coderd
+
+import (
+	"net/http"
+
+	"github.com/coder/coder/coderd/httpapi"
+	"github.com/coder/coder/coderd/rbac"
+	"github.com/coder/coder/codersdk"
+)
+
+func (api *API) deploymentDAUs(rw http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	if !api.Authorize(r, rbac.ActionRead, rbac.ResourceDeploymentConfig) {
+		httpapi.Forbidden(rw)
+		return
+	}
+
+	resp, _ := api.metricsCache.DeploymentDAUs()
+	if resp == nil || resp.Entries == nil {
+		httpapi.Write(ctx, rw, http.StatusOK, &codersdk.DeploymentDAUsResponse{
+			Entries: []codersdk.DAUEntry{},
+		})
+		return
+	}
+	httpapi.Write(ctx, rw, http.StatusOK, resp)
+}
diff --git a/coderd/insights_test.go b/coderd/insights_test.go
@@ -0,0 +1,128 @@
+package coderd_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"cdr.dev/slog/sloggers/slogtest"
+	"github.com/coder/coder/agent"
+	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/coder/coder/coderd/database"
+	"github.com/coder/coder/codersdk"
+	"github.com/coder/coder/provisioner/echo"
+	"github.com/coder/coder/provisionersdk/proto"
+	"github.com/coder/coder/testutil"
+)
+
+func TestDeploymentMetrics(t *testing.T) {
+	t.Parallel()
+
+	client := coderdtest.New(t, &coderdtest.Options{
+		IncludeProvisionerDaemon:    true,
+		AgentStatsRefreshInterval:   time.Millisecond * 100,
+		MetricsCacheRefreshInterval: time.Millisecond * 100,
+	})
+
+	user := coderdtest.CreateFirstUser(t, client)
+	authToken := uuid.NewString()
+	version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, &echo.Responses{
+		Parse:         echo.ParseComplete,
+		ProvisionPlan: echo.ProvisionComplete,
+		ProvisionApply: []*proto.Provision_Response{{
+			Type: &proto.Provision_Response_Complete{
+				Complete: &proto.Provision_Complete{
+					Resources: []*proto.Resource{{
+						Name: "example",
+						Type: "aws_instance",
+						Agents: []*proto.Agent{{
+							Id: uuid.NewString(),
+							Auth: &proto.Agent_Token{
+								Token: authToken,
+							},
+						}},
+					}},
+				},
+			},
+		}},
+	})
+	template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
+	require.Equal(t, -1, template.ActiveUserCount)
+	require.Empty(t, template.BuildTimeStats[codersdk.WorkspaceTransitionStart])
+
+	coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
+	workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
+	coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)
+
+	agentClient := codersdk.New(client.URL)
+	agentClient.SetSessionToken(authToken)
+	agentCloser := agent.New(agent.Options{
+		Logger: slogtest.Make(t, nil),
+		Client: agentClient,
+	})
+	defer func() {
+		_ = agentCloser.Close()
+	}()
+	resources := coderdtest.AwaitWorkspaceAgents(t, client, workspace.ID)
+
+	ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)
+	defer cancel()
+
+	daus, err := client.DeploymentDAUs(context.Background())
+	require.NoError(t, err)
+
+	require.Equal(t, &codersdk.DeploymentDAUsResponse{
+		Entries: []codersdk.DAUEntry{},
+	}, daus, "no DAUs when stats are empty")
+
+	res, err := client.Workspaces(ctx, codersdk.WorkspaceFilter{})
+	require.NoError(t, err)
+	assert.Zero(t, res.Workspaces[0].LastUsedAt)
+
+	conn, err := client.DialWorkspaceAgent(ctx, resources[0].Agents[0].ID, &codersdk.DialWorkspaceAgentOptions{
+		Logger: slogtest.Make(t, nil).Named("tailnet"),
+	})
+	require.NoError(t, err)
+	defer func() {
+		_ = conn.Close()
+	}()
+
+	sshConn, err := conn.SSHClient(ctx)
+	require.NoError(t, err)
+	_ = sshConn.Close()
+
+	wantDAUs := &codersdk.DeploymentDAUsResponse{
+		Entries: []codersdk.DAUEntry{
+			{
+
+				Date:   time.Now().UTC().Truncate(time.Hour * 24),
+				Amount: 1,
+			},
+		},
+	}
+	require.Eventuallyf(t, func() bool {
+		daus, err = client.DeploymentDAUs(ctx)
+		require.NoError(t, err)
+		return len(daus.Entries) > 0
+	},
+		testutil.WaitShort, testutil.IntervalFast,
+		"deployment daus never loaded",
+	)
+	gotDAUs, err := client.DeploymentDAUs(ctx)
+	require.NoError(t, err)
+	require.Equal(t, gotDAUs, wantDAUs)
+
+	template, err = client.Template(ctx, template.ID)
+	require.NoError(t, err)
+	require.Equal(t, 1, template.ActiveUserCount)
+
+	res, err = client.Workspaces(ctx, codersdk.WorkspaceFilter{})
+	require.NoError(t, err)
+	assert.WithinDuration(t,
+		database.Now(), res.Workspaces[0].LastUsedAt, time.Minute,
+	)
+}
diff --git a/coderd/metricscache/metricscache.go b/coderd/metricscache/metricscache.go
@@ -27,6 +27,7 @@ type Cache struct {
 	database database.Store
 	log      slog.Logger
 
+	deploymentDAUResponses   atomic.Pointer[codersdk.DeploymentDAUsResponse]
 	templateDAUResponses     atomic.Pointer[map[uuid.UUID]codersdk.TemplateDAUsResponse]
 	templateUniqueUsers      atomic.Pointer[map[uuid.UUID]int]
 	templateAverageBuildTime atomic.Pointer[map[uuid.UUID]database.GetTemplateAverageBuildTimeRow]
@@ -110,6 +111,33 @@ func convertDAUResponse(rows []database.GetTemplateDAUsRow) codersdk.TemplateDAU
 	return resp
 }
 
+func convertDeploymentDAUResponse(rows []database.GetDeploymentDAUsRow) codersdk.DeploymentDAUsResponse {
+	respMap := make(map[time.Time][]uuid.UUID)
+	for _, row := range rows {
+		uuids := respMap[row.Date]
+		if uuids == nil {
+			uuids = make([]uuid.UUID, 0, 8)
+		}
+		uuids = append(uuids, row.UserID)
+		respMap[row.Date] = uuids
+	}
+
+	dates := maps.Keys(respMap)
+	slices.SortFunc(dates, func(a, b time.Time) bool {
+		return a.Before(b)
+	})
+
+	var resp codersdk.DeploymentDAUsResponse
+	for _, date := range fillEmptyDays(dates) {
+		resp.Entries = append(resp.Entries, codersdk.DAUEntry{
+			Date:   date,
+			Amount: len(respMap[date]),
+		})
+	}
+
+	return resp
+}
+
 func countUniqueUsers(rows []database.GetTemplateDAUsRow) int {
 	seen := make(map[uuid.UUID]struct{}, len(rows))
 	for _, row := range rows {
@@ -130,10 +158,19 @@ func (c *Cache) refresh(ctx context.Context) error {
 	}
 
 	var (
+		deploymentDAUs            = codersdk.DeploymentDAUsResponse{}
 		templateDAUs              = make(map[uuid.UUID]codersdk.TemplateDAUsResponse, len(templates))
 		templateUniqueUsers       = make(map[uuid.UUID]int)
 		templateAverageBuildTimes = make(map[uuid.UUID]database.GetTemplateAverageBuildTimeRow)
 	)
+
+	rows, err := c.database.GetDeploymentDAUs(ctx)
+	if err != nil {
+		return err
+	}
+	deploymentDAUs = convertDeploymentDAUResponse(rows)
+	c.deploymentDAUResponses.Store(&deploymentDAUs)
+
 	for _, template := range templates {
 		rows, err := c.database.GetTemplateDAUs(ctx, template.ID)
 		if err != nil {
@@ -207,6 +244,17 @@ func (c *Cache) Close() error {
 	return nil
 }
 
+func (c *Cache) DeploymentDAUs() (*codersdk.DeploymentDAUsResponse, bool) {
+	m := c.deploymentDAUResponses.Load()
+	if m == nil {
+		// Data loading.
+		return nil, false
+	}
+
+	resp := *m
+	return &resp, true
+}
+
 // TemplateDAUs returns an empty response if the template doesn't have users
 // or is loading for the first time.
 func (c *Cache) TemplateDAUs(id uuid.UUID) (*codersdk.TemplateDAUsResponse, bool) {