package coderd_test

import (

"context"

"encoding/json"

"fmt"

"io"

"net/http"

"os"

"path/filepath"

"strings"

"testing"

"time"

"github.com/google/go-cmp/cmp"

"github.com/google/uuid"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

"cdr.dev/slog"

"cdr.dev/slog/sloggers/slogtest"

"github.com/coder/coder/v2/agent/agenttest"

agentproto "github.com/coder/coder/v2/agent/proto"

"github.com/coder/coder/v2/coderd/coderdtest"

"github.com/coder/coder/v2/coderd/database"

"github.com/coder/coder/v2/coderd/database/db2sdk"

"github.com/coder/coder/v2/coderd/database/dbauthz"

"github.com/coder/coder/v2/coderd/database/dbgen"

"github.com/coder/coder/v2/coderd/database/dbrollup"

"github.com/coder/coder/v2/coderd/database/dbtestutil"

"github.com/coder/coder/v2/coderd/rbac"

"github.com/coder/coder/v2/coderd/workspaceapps"

"github.com/coder/coder/v2/coderd/workspacestats"

"github.com/coder/coder/v2/codersdk"

"github.com/coder/coder/v2/codersdk/agentsdk"

"github.com/coder/coder/v2/codersdk/workspacesdk"

"github.com/coder/coder/v2/provisioner/echo"

"github.com/coder/coder/v2/provisionersdk/proto"

"github.com/coder/coder/v2/testutil"

)

func TestDeploymentInsights(t *testing.T) {

t.Parallel()

clientTz, err := time.LoadLocation("America/Chicago")

require.NoError(t, err)

db, ps := dbtestutil.NewDB(t, dbtestutil.WithDumpOnFailure())

logger := testutil.Logger(t)

rollupEvents := make(chan dbrollup.Event)

statsInterval := 500 * time.Millisecond

// Speed up the test by controlling batch size and interval.

batcher, closeBatcher, err := workspacestats.NewBatcher(context.Background(),

workspacestats.BatcherWithLogger(logger.Named("batcher").Leveled(slog.LevelDebug)),

workspacestats.BatcherWithStore(db),

workspacestats.BatcherWithBatchSize(1),

workspacestats.BatcherWithInterval(statsInterval),

)

require.NoError(t, err)

defer closeBatcher()

client := coderdtest.New(t, &coderdtest.Options{

Database: db,

Pubsub: ps,

Logger: &logger,

IncludeProvisionerDaemon: true,

AgentStatsRefreshInterval: statsInterval,

StatsBatcher: batcher,

DatabaseRolluper: dbrollup.New(

logger.Named("dbrollup").Leveled(slog.LevelDebug),

db,

dbrollup.WithInterval(statsInterval/2),

dbrollup.WithEventChannel(rollupEvents),

),

})

user := coderdtest.CreateFirstUser(t, client)

authToken := uuid.NewString()

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, &echo.Responses{

Parse: echo.ParseComplete,

ProvisionPlan: echo.PlanComplete,

ProvisionApply: echo.ProvisionApplyWithAgent(authToken),

})

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

require.Empty(t, template.BuildTimeStats[codersdk.WorkspaceTransitionStart])

coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, template.ID)

coderdtest.AwaitWorkspaceBuildJobCompleted(t, client, workspace.LatestBuild.ID)

ctx := testutil.Context(t, testutil.WaitSuperLong)

// Pre-check, no permission issues.

daus, err := client.DeploymentDAUs(ctx, codersdk.TimezoneOffsetHour(clientTz))

require.NoError(t, err)

_ = agenttest.New(t, client.URL, authToken)

resources := coderdtest.NewWorkspaceAgentWaiter(t, client, workspace.ID).Wait()

conn, err := workspacesdk.New(client).

DialAgent(ctx, resources[0].Agents[0].ID, &workspacesdk.DialAgentOptions{

Logger: testutil.Logger(t).Named("dialagent"),

})

require.NoError(t, err)

defer conn.Close()

sshConn, err := conn.SSHClient(ctx)

require.NoError(t, err)

defer sshConn.Close()

sess, err := sshConn.NewSession()

require.NoError(t, err)

defer sess.Close()

r, w := io.Pipe()

defer r.Close()

defer w.Close()

sess.Stdin = r

sess.Stdout = io.Discard

err = sess.Start("cat")

require.NoError(t, err)

select {

case <-ctx.Done():

require.Fail(t, "timed out waiting for initial rollup event", ctx.Err())

case ev := <-rollupEvents:

require.True(t, ev.Init, "want init event")

}

for {

select {

case <-ctx.Done():

require.Fail(t, "timed out waiting for deployment daus to update", daus)

case <-rollupEvents:

}

daus, err = client.DeploymentDAUs(ctx, codersdk.TimezoneOffsetHour(clientTz))

require.NoError(t, err)

if len(daus.Entries) > 0 && daus.Entries[len(daus.Entries)-1].Amount > 0 {

break

}

t.Logf("waiting for deployment daus to update: %+v", daus)

}

}

func TestUserActivityInsights_SanityCheck(t *testing.T) {

t.Parallel()

db, ps := dbtestutil.NewDB(t)

logger := testutil.Logger(t)

client := coderdtest.New(t, &coderdtest.Options{

Database: db,

Pubsub: ps,

Logger: &logger,

IncludeProvisionerDaemon: true,

AgentStatsRefreshInterval: time.Millisecond * 100,

DatabaseRolluper: dbrollup.New(

logger.Named("dbrollup"),

db,

dbrollup.WithInterval(time.Millisecond*100),

),

})

// Create two users, one that will appear in the report and another that

// won't (due to not having/using a workspace).

user := coderdtest.CreateFirstUser(t, client)

_, _ = coderdtest.CreateAnotherUser(t, client, user.OrganizationID)

authToken := uuid.NewString()

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, &echo.Responses{

Parse: echo.ParseComplete,

ProvisionPlan: echo.PlanComplete,

ProvisionApply: echo.ProvisionApplyWithAgent(authToken),

})

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

require.Empty(t, template.BuildTimeStats[codersdk.WorkspaceTransitionStart])

coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, template.ID)

coderdtest.AwaitWorkspaceBuildJobCompleted(t, client, workspace.LatestBuild.ID)

// Start an agent so that we can generate stats.

_ = agenttest.New(t, client.URL, authToken)

resources := coderdtest.AwaitWorkspaceAgents(t, client, workspace.ID)

// Start must be at the beginning of the day, initialize it early in case

// the day changes so that we get the relevant stats faster.

y, m, d := time.Now().UTC().Date()

today := time.Date(y, m, d, 0, 0, 0, 0, time.UTC)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitSuperLong)

defer cancel()

// Connect to the agent to generate usage/latency stats.

conn, err := workspacesdk.New(client).

DialAgent(ctx, resources[0].Agents[0].ID, &workspacesdk.DialAgentOptions{

Logger: logger.Named("client"),

})

require.NoError(t, err)

defer conn.Close()

sshConn, err := conn.SSHClient(ctx)

require.NoError(t, err)

defer sshConn.Close()

sess, err := sshConn.NewSession()

require.NoError(t, err)

defer sess.Close()

r, w := io.Pipe()

defer r.Close()

defer w.Close()

sess.Stdin = r

sess.Stdout = io.Discard

err = sess.Start("cat")

require.NoError(t, err)

var userActivities codersdk.UserActivityInsightsResponse

require.Eventuallyf(t, func() bool {

// Keep connection active.

_, err := w.Write([]byte("hello world\n"))

if !assert.NoError(t, err) {

return false

}

userActivities, err = client.UserActivityInsights(ctx, codersdk.UserActivityInsightsRequest{

StartTime: today,

EndTime: time.Now().UTC().Truncate(time.Hour).Add(time.Hour), // Round up to include the current hour.

TemplateIDs: []uuid.UUID{template.ID},

})

if !assert.NoError(t, err) {

return false

}

return len(userActivities.Report.Users) > 0 && userActivities.Report.Users[0].Seconds > 0

}, testutil.WaitSuperLong, testutil.IntervalMedium, "user activity is missing")

// We got our latency data, close the connection.

_ = sess.Close()

_ = sshConn.Close()

require.Len(t, userActivities.Report.Users, 1, "want only 1 user")

require.Equal(t, userActivities.Report.Users[0].UserID, user.UserID, "want user id to match")

assert.Greater(t, userActivities.Report.Users[0].Seconds, int64(0), "want usage in seconds to be greater than 0")

}

func TestUserLatencyInsights(t *testing.T) {

t.Parallel()

db, ps := dbtestutil.NewDB(t)

logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: true}).Leveled(slog.LevelDebug)

client := coderdtest.New(t, &coderdtest.Options{

Database: db,

Pubsub: ps,

Logger: &logger,

IncludeProvisionerDaemon: true,

AgentStatsRefreshInterval: time.Millisecond * 50,

DatabaseRolluper: dbrollup.New(

logger.Named("dbrollup"),

db,

dbrollup.WithInterval(time.Millisecond*100),

),

})

// Create two users, one that will appear in the report and another that

// won't (due to not having/using a workspace).

user := coderdtest.CreateFirstUser(t, client)

_, _ = coderdtest.CreateAnotherUser(t, client, user.OrganizationID)

authToken := uuid.NewString()

version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, &echo.Responses{

Parse: echo.ParseComplete,

ProvisionPlan: echo.PlanComplete,

ProvisionApply: echo.ProvisionApplyWithAgent(authToken),

})

template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)

require.Empty(t, template.BuildTimeStats[codersdk.WorkspaceTransitionStart])

coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)

workspace := coderdtest.CreateWorkspace(t, client, template.ID)

coderdtest.AwaitWorkspaceBuildJobCompleted(t, client, workspace.LatestBuild.ID)

// Start an agent so that we can generate stats.

_ = agenttest.New(t, client.URL, authToken)

resources := coderdtest.AwaitWorkspaceAgents(t, client, workspace.ID)

// Start must be at the beginning of the day, initialize it early in case

// the day changes so that we get the relevant stats faster.

y, m, d := time.Now().UTC().Date()

today := time.Date(y, m, d, 0, 0, 0, 0, time.UTC)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

// Connect to the agent to generate usage/latency stats.

conn, err := workspacesdk.New(client).

DialAgent(ctx, resources[0].Agents[0].ID, &workspacesdk.DialAgentOptions{

Logger: logger.Named("client"),

})

require.NoError(t, err)

defer conn.Close()

sshConn, err := conn.SSHClient(ctx)

require.NoError(t, err)

defer sshConn.Close()

sess, err := sshConn.NewSession()

require.NoError(t, err)

defer sess.Close()

r, w := io.Pipe()

defer r.Close()

defer w.Close()

sess.Stdin = r

sess.Stdout = io.Discard

err = sess.Start("cat")

require.NoError(t, err)

var userLatencies codersdk.UserLatencyInsightsResponse

require.Eventuallyf(t, func() bool {

// Keep connection active.

_, err := w.Write([]byte("hello world\n"))

if !assert.NoError(t, err) {

return false

}

userLatencies, err = client.UserLatencyInsights(ctx, codersdk.UserLatencyInsightsRequest{

StartTime: today,

EndTime: time.Now().UTC().Truncate(time.Hour).Add(time.Hour), // Round up to include the current hour.

TemplateIDs: []uuid.UUID{template.ID},

})

if !assert.NoError(t, err) {

return false

}

return len(userLatencies.Report.Users) > 0 && userLatencies.Report.Users[0].LatencyMS.P50 > 0

}, testutil.WaitMedium, testutil.IntervalFast, "user latency is missing")

// We got our latency data, close the connection.

_ = sess.Close()

_ = sshConn.Close()

require.Len(t, userLatencies.Report.Users, 1, "want only 1 user")

require.Equal(t, userLatencies.Report.Users[0].UserID, user.UserID, "want user id to match")

assert.Greater(t, userLatencies.Report.Users[0].LatencyMS.P50, float64(0), "want p50 to be greater than 0")

assert.Greater(t, userLatencies.Report.Users[0].LatencyMS.P95, float64(0), "want p95 to be greater than 0")

}

func TestUserLatencyInsights_BadRequest(t *testing.T) {

t.Parallel()

client := coderdtest.New(t, &coderdtest.Options{})

_ = coderdtest.CreateFirstUser(t, client)

y, m, d := time.Now().UTC().Date()

today := time.Date(y, m, d, 0, 0, 0, 0, time.UTC)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

_, err := client.UserLatencyInsights(ctx, codersdk.UserLatencyInsightsRequest{

StartTime: today,

EndTime: today.AddDate(0, 0, -1),

})

assert.Error(t, err, "want error for end time before start time")

}

func TestUserActivityInsights_BadRequest(t *testing.T) {

t.Parallel()

saoPaulo, err := time.LoadLocation("America/Sao_Paulo")

require.NoError(t, err)

y, m, d := time.Now().UTC().Date()

today := time.Date(y, m, d, 0, 0, 0, 0, saoPaulo)

// Prepare

client := coderdtest.New(t, &coderdtest.Options{})

_ = coderdtest.CreateFirstUser(t, client)

ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitLong)

defer cancel()

// Send insights request

_, err = client.UserActivityInsights(ctx, codersdk.UserActivityInsightsRequest{

StartTime: today,

EndTime: today.AddDate(0, 0, -1),

})

assert.Error(t, err, "want error for end time before start time")

}

func TestTemplateInsights_Golden(t *testing.T) {

t.Parallel()

// Prepare test data types.

type templateParameterOption struct {

name string

value string

}

type templateParameter struct {

name string

description string

options []templateParameterOption

}

type templateApp struct {

name string

icon string

}

type testTemplate struct {

name string

parameters []*templateParameter

apps []templateApp

// Filled later.

id uuid.UUID

}

type buildParameter struct {

templateParameter *templateParameter

value string

}

type workspaceApp templateApp

type testWorkspace struct {

name string

template *testTemplate

buildParameters []buildParameter

// Filled later.

id uuid.UUID

user any // *testUser, but it's not available yet, defined below.

agentID uuid.UUID

apps []*workspaceApp

agentClient *agentsdk.Client

}

type testUser struct {

name string

workspaces []*testWorkspace

client *codersdk.Client

sdk codersdk.User

}

// Represent agent stats, to be inserted via stats batcher.

type agentStat struct {

// Set a range via start/end, multiple stats will be generated

// within the range.

startedAt time.Time

endedAt time.Time

sessionCountVSCode int64

sessionCountJetBrains int64

sessionCountReconnectingPTY int64

sessionCountSSH int64

noConnections bool

}

// Represent app usage stats, to be inserted via stats reporter.

type appUsage struct {

app *workspaceApp

startedAt time.Time

endedAt time.Time

requests int

}

// Represent actual data being generated on a per-workspace basis.

type testDataGen struct {

agentStats []agentStat

appUsage []appUsage

}

prepareFixtureAndTestData := func(t *testing.T, makeFixture func() ([]*testTemplate, []*testUser), makeData func([]*testTemplate, []*testUser) map[*testWorkspace]testDataGen) ([]*testTemplate, []*testUser, map[*testWorkspace]testDataGen) {

var stableIDs []uuid.UUID

newStableUUID := func() uuid.UUID {

stableIDs = append(stableIDs, uuid.MustParse(fmt.Sprintf("00000000-0000-0000-0000-%012d", len(stableIDs)+1)))

stableID := stableIDs[len(stableIDs)-1]

return stableID

}

templates, users := makeFixture()

for _, template := range templates {

template.id = newStableUUID()

}

for _, user := range users {

for _, workspace := range user.workspaces {

workspace.user = user

for _, app := range workspace.template.apps {

app := workspaceApp(app)

workspace.apps = append(workspace.apps, &app)

}

for _, bp := range workspace.buildParameters {

foundBuildParam := false

for _, param := range workspace.template.parameters {

if bp.templateParameter == param {

foundBuildParam = true

break

}

}

require.True(t, foundBuildParam, "test bug: parameter not in workspace %s template %q", workspace.name, workspace.template.name)

}

}

}

testData := makeData(templates, users)

// Sanity check.

for ws, data := range testData {

for _, usage := range data.appUsage {

found := false

for _, app := range ws.apps {

if usage.app == app { // Pointer equality

found = true

break

}

}

if !found {

for _, user := range users {

for _, workspace := range user.workspaces {

for _, app := range workspace.apps {

if usage.app == app { // Pointer equality

require.True(t, found, "test bug: app %q not in workspace %q: want user=%s workspace=%s; got user=%s workspace=%s ", usage.app.name, ws.name, ws.user.(*testUser).name, ws.name, user.name, workspace.name)

break

}

}

}

}

require.True(t, found, "test bug: app %q not in workspace %q", usage.app.name, ws.name)

}

}

}

return templates, users, testData

}

prepare := func(t *testing.T, templates []*testTemplate, users []*testUser, testData map[*testWorkspace]testDataGen) (*codersdk.Client, chan dbrollup.Event) {

logger := testutil.Logger(t)

db, ps := dbtestutil.NewDB(t)

events := make(chan dbrollup.Event)

client := coderdtest.New(t, &coderdtest.Options{

Database: db,

Pubsub: ps,

Logger: &logger,

IncludeProvisionerDaemon: true,

AgentStatsRefreshInterval: time.Hour, // Not relevant for this test.

DatabaseRolluper: dbrollup.New(

logger.Named("dbrollup"),

db,

dbrollup.WithInterval(time.Millisecond*50),

dbrollup.WithEventChannel(events),

),

})

firstUser := coderdtest.CreateFirstUser(t, client)

// Prepare all test users.

for _, user := range users {

user.client, user.sdk = coderdtest.CreateAnotherUserMutators(t, client, firstUser.OrganizationID, nil, func(r *codersdk.CreateUserRequestWithOrgs) {

r.Username = user.name

})

user.client.SetLogger(logger.Named("user").With(slog.Field{Name: "name", Value: user.name}))

}

// Prepare all the templates.

for _, template := range templates {

var parameters []*proto.RichParameter

for _, parameter := range template.parameters {

var options []*proto.RichParameterOption

var defaultValue string

for _, option := range parameter.options {

if defaultValue == "" {

defaultValue = option.value

}

options = append(options, &proto.RichParameterOption{

Name: option.name,

Value: option.value,

})

}

parameters = append(parameters, &proto.RichParameter{

Name: parameter.name,

DisplayName: parameter.name,

Type: "string",

Description: parameter.description,

Options: options,

DefaultValue: defaultValue,

})

}

// Prepare all workspace resources (agents and apps).

var (

createWorkspaces []func(uuid.UUID)

waitWorkspaces []func()

)

var resources []*proto.Resource

for _, user := range users {

for _, workspace := range user.workspaces {

if workspace.template != template {

continue

}

authToken := uuid.New()

agentClient := agentsdk.New(client.URL, agentsdk.WithFixedToken(authToken.String()))

workspace.agentClient = agentClient

var apps []*proto.App

for _, app := range workspace.apps {

apps = append(apps, &proto.App{

Slug: app.name,

DisplayName: app.name,

Icon: app.icon,

SharingLevel: proto.AppSharingLevel_OWNER,

Url: "http://",

})

}

resources = append(resources, &proto.Resource{

Name: "example",

Type: "aws_instance",

Agents: []*proto.Agent{{

Id: uuid.NewString(), // Doesn't matter, not used in DB.

Name: fmt.Sprintf("dev-%d", len(resources)), // Ensure unique name per agent

Auth: &proto.Agent_Token{

Token: authToken.String(),

},

Apps: apps,

}},

})

var buildParameters []codersdk.WorkspaceBuildParameter

for _, buildParameter := range workspace.buildParameters {

buildParameters = append(buildParameters, codersdk.WorkspaceBuildParameter{

Name: buildParameter.templateParameter.name,

Value: buildParameter.value,

})

}

createWorkspaces = append(createWorkspaces, func(templateID uuid.UUID) {

// Create workspace using the users client.

createdWorkspace := coderdtest.CreateWorkspace(t, user.client, templateID, func(cwr *codersdk.CreateWorkspaceRequest) {

cwr.RichParameterValues = buildParameters

})

workspace.id = createdWorkspace.ID

waitWorkspaces = append(waitWorkspaces, func() {

coderdtest.AwaitWorkspaceBuildJobCompleted(t, user.client, createdWorkspace.LatestBuild.ID)

ctx := testutil.Context(t, testutil.WaitShort)

ws, err := user.client.Workspace(ctx, workspace.id)

require.NoError(t, err, "want no error getting workspace")

workspace.agentID = ws.LatestBuild.Resources[0].Agents[0].ID

})

})

}

}

// Create the template version and template.

version := coderdtest.CreateTemplateVersion(t, client, firstUser.OrganizationID, &echo.Responses{

Parse: echo.ParseComplete,

ProvisionPlan: []*proto.Response{

{

Type: &proto.Response_Plan{

Plan: &proto.PlanComplete{

Parameters: parameters,

},

},

},

},

ProvisionApply: []*proto.Response{{

Type: &proto.Response_Apply{

Apply: &proto.ApplyComplete{

Resources: resources,

},

},

}},

})

coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)

// Create template, essentially a modified version of CreateTemplate

// where we can control the template ID.

// createdTemplate := coderdtest.CreateTemplate(t, client, firstUser.OrganizationID, version.ID)

createdTemplate := dbgen.Template(t, db, database.Template{

ID: template.id,

ActiveVersionID: version.ID,

OrganizationID: firstUser.OrganizationID,

CreatedBy: firstUser.UserID,

UseClassicParameterFlow: true, // Required for testing classic parameter flow behavior

GroupACL: database.TemplateACL{

firstUser.OrganizationID.String(): db2sdk.TemplateRoleActions(codersdk.TemplateRoleUse),

},

})

err := db.UpdateTemplateVersionByID(context.Background(), database.UpdateTemplateVersionByIDParams{

ID: version.ID,

TemplateID: uuid.NullUUID{

UUID: createdTemplate.ID,

Valid: true,

},

})

require.NoError(t, err, "want no error updating template version")

// Create all workspaces and wait for them.

for _, createWorkspace := range createWorkspaces {

createWorkspace(template.id)

}

for _, waitWorkspace := range waitWorkspaces {

waitWorkspace()

}

}

ctx := testutil.Context(t, testutil.WaitSuperLong)

// Use agent stats batcher to insert agent stats, similar to live system.

// NOTE(mafredri): Ideally we would pass batcher as a coderd option and

// insert using the agentClient, but we have a circular dependency on

// the database.

batcher, batcherCloser, err := workspacestats.NewBatcher(

ctx,

workspacestats.BatcherWithStore(db),

workspacestats.BatcherWithLogger(logger.Named("batchstats")),

workspacestats.BatcherWithInterval(time.Hour),

)

require.NoError(t, err)

defer batcherCloser() // Flushes the stats, this is to ensure they're written.

for workspace, data := range testData {

for _, stat := range data.agentStats {

createdAt := stat.startedAt

connectionCount := int64(1)

if stat.noConnections {

connectionCount = 0

}

for createdAt.Before(stat.endedAt) {

batcher.Add(createdAt, workspace.agentID, workspace.template.id, workspace.user.(*testUser).sdk.ID, workspace.id, &agentproto.Stats{

ConnectionCount: connectionCount,

SessionCountVscode: stat.sessionCountVSCode,

SessionCountJetbrains: stat.sessionCountJetBrains,

SessionCountReconnectingPty: stat.sessionCountReconnectingPTY,

SessionCountSsh: stat.sessionCountSSH,

}, false)

createdAt = createdAt.Add(30 * time.Second)

}

}

}

// Insert app usage.

var stats []workspaceapps.StatsReport

for workspace, data := range testData {

for _, usage := range data.appUsage {

appName := usage.app.name

accessMethod := workspaceapps.AccessMethodPath

if usage.app.name == "terminal" {

appName = ""

accessMethod = workspaceapps.AccessMethodTerminal

}

stats = append(stats, workspaceapps.StatsReport{

UserID: workspace.user.(*testUser).sdk.ID,

WorkspaceID: workspace.id,

AgentID: workspace.agentID,

AccessMethod: accessMethod,

SlugOrPort: appName,

SessionID: uuid.New(),

SessionStartedAt: usage.startedAt,

SessionEndedAt: usage.endedAt,

Requests: usage.requests,

})

}

}

reporter := workspacestats.NewReporter(workspacestats.ReporterOptions{

Database: db,

AppStatBatchSize: workspaceapps.DefaultStatsDBReporterBatchSize,

})

err = reporter.ReportAppStats(dbauthz.AsSystemRestricted(ctx), stats)

require.NoError(t, err, "want no error inserting app stats")

return client, events

}

baseTemplateAndUserFixture := func() ([]*testTemplate, []*testUser) {

// Test templates and configuration to generate.

templates := []*testTemplate{

// Create two templates with near-identical apps and parameters

// to allow testing for grouping similar data.

{

name: "template1",

parameters: []*templateParameter{

{name: "param1", description: "This is first parameter"},

{name: "param2", description: "This is second parameter"},

{name: "param3", description: "This is third parameter"},

{

name: "param4",

description: "This is fourth parameter",

options: []templateParameterOption{

{name: "option1", value: "option1"},

{name: "option2", value: "option2"},

},

},

},

apps: []templateApp{

{name: "app1", icon: "/icon1.png"},

{name: "app2", icon: "/icon2.png"},

{name: "app3", icon: "/icon2.png"},

},

},

{

name: "template2",

parameters: []*templateParameter{

{name: "param1", description: "This is first parameter"},

{name: "param2", description: "This is second parameter"},

{name: "param3", description: "This is third parameter"},

},

apps: []templateApp{

{name: "app1", icon: "/icon1.png"},

{name: "app2", icon: "/icon2.png"},

{name: "app3", icon: "/icon2.png"},

},

},

// Create another template with different parameters and apps.

{

name: "othertemplate",

parameters: []*templateParameter{

{name: "otherparam1", description: "This is another parameter"},

},

apps: []templateApp{

{name: "otherapp1", icon: "/icon1.png"},

// This "special test app" will be converted into web

// terminal usage, this is not included in stats since we

// currently rely on agent stats for this data.

{name: "terminal", icon: "/terminal.png"},

},

},

}

// Users and workspaces to generate.

users := []*testUser{

{

name: "user1",

workspaces: []*testWorkspace{

{

name: "workspace1",

template: templates[0],

buildParameters: []buildParameter{

{templateParameter: templates[0].parameters[0], value: "abc"},

{templateParameter: templates[0].parameters[1], value: "123"},

{templateParameter: templates[0].parameters[2], value: "bbb"},

{templateParameter: templates[0].parameters[3], value: "option1"},

},

},

{

name: "workspace2",

template: templates[1],

buildParameters: []buildParameter{

{templateParameter: templates[1].parameters[0], value: "ABC"},

{templateParameter: templates[1].parameters[1], value: "123"},

{templateParameter: templates[1].parameters[2], value: "BBB"},

},

},

{

name: "otherworkspace3",

template: templates[2],

},

},

},

{

name: "user2",

workspaces: []*testWorkspace{

{

name: "workspace1",

template: templates[0],

buildParameters: []buildParameter{

{templateParameter: templates[0].parameters[0], value: "abc"},

{templateParameter: templates[0].parameters[1], value: "123"},

{templateParameter: templates[0].parameters[2], value: "BBB"},

{templateParameter: templates[0].parameters[3], value: "option1"},

},

},

},

},

{

name: "user3",

workspaces: []*testWorkspace{

{

name: "otherworkspace1",

template: templates[2],

buildParameters: []buildParameter{

{templateParameter: templates[2].parameters[0], value: "xyz"},

},

},

{

name: "workspace2",

template: templates[0],

buildParameters: []buildParameter{

{templateParameter: templates[0].parameters[3], value: "option2"},

},

},

},

},

}

return templates, users

}

// Time range for report, test data will be generated within and

// outside this range, but only data within the range should be

// included in the report.

frozenLastNight := time.Date(2023, 8, 22, 0, 0, 0, 0, time.UTC)

frozenWeekAgo := frozenLastNight.AddDate(0, 0, -7)

saoPaulo, err := time.LoadLocation("America/Sao_Paulo")

require.NoError(t, err)

frozenWeekAgoSaoPaulo, err := time.ParseInLocation(time.DateTime, frozenWeekAgo.Format(time.DateTime), saoPaulo)

require.NoError(t, err)

//nolint:dupl // For testing purposes

makeBaseTestData := func(templates []*testTemplate, users []*testUser) map[*testWorkspace]testDataGen {

return map[*testWorkspace]testDataGen{

users[0].workspaces[0]: {

agentStats: []agentStat{

{ // One hour of usage.

startedAt: frozenWeekAgo,

endedAt: frozenWeekAgo.Add(time.Hour),

sessionCountVSCode: 1,

sessionCountSSH: 1,

},

{ // 12 minutes of usage.

startedAt: frozenWeekAgo.AddDate(0, 0, 1),

endedAt: frozenWeekAgo.AddDate(0, 0, 1).Add(12 * time.Minute),

sessionCountSSH: 1,

},

{ // 1m30s of usage -> 2m rounded.

startedAt: frozenWeekAgo.AddDate(0, 0, 2).Add(4*time.Minute + 30*time.Second),

endedAt: frozenWeekAgo.AddDate(0, 0, 2).Add(6 * time.Minute),

sessionCountJetBrains: 1,

},

},

appUsage: []appUsage{

{ // One hour of usage.

app: users[0].workspaces[0].apps[0],

startedAt: frozenWeekAgo,

endedAt: frozenWeekAgo.Add(time.Hour),

requests: 1,

},

{ // 30s of app usage -> 1m rounded.

app: users[0].workspaces[0].apps[0],

startedAt: frozenWeekAgo.Add(2*time.Hour + 10*time.Second),

endedAt: frozenWeekAgo.Add(2*time.Hour + 40*time.Second),

requests: 1,

},

{ // 1m30s of app usage -> 2m rounded (included in São Paulo).

app: users[0].workspaces[0].apps[0],

startedAt: frozenWeekAgo.Add(3*time.Hour + 30*time.Second),

endedAt: frozenWeekAgo.Add(3*time.Hour + 90*time.Second),

requests: 1,

},

{ // used an app on the last day, counts as active user, 12m.

app: users[0].workspaces[0].apps[2],

startedAt: frozenWeekAgo.AddDate(0, 0, 6),

endedAt: frozenWeekAgo.AddDate(0, 0, 6).Add(12 * time.Minute),

requests: 1,

},

},

},

users[0].workspaces[1]: {

agentStats: []agentStat{

{

// One hour of usage in second template at the same time

// as in first template. When selecting both templates

// this user and their app usage will only be counted

// once but the template ID will show up in the data.

startedAt: frozenWeekAgo,

endedAt: frozenWeekAgo.Add(time.Hour),

sessionCountVSCode: 1,

sessionCountSSH: 1,

},

{ // One hour of usage.

startedAt: frozenWeekAgo.AddDate(0, 0, -12),

endedAt: frozenWeekAgo.AddDate(0, 0, -12).Add(time.Hour),

sessionCountSSH: 1,

sessionCountReconnectingPTY: 1,

},

{ // Another one hour of usage, but "active users" shouldn't be increased twice.

startedAt: frozenWeekAgo.AddDate(0, 0, -10),

endedAt: frozenWeekAgo.AddDate(0, 0, -10).Add(time.Hour),

sessionCountSSH: 1,

sessionCountReconnectingPTY: 1,

},

},

appUsage: []appUsage{

{ // One hour of usage, but same user and same template app, only count once.

app: users[0].workspaces[1].apps[0],

startedAt: frozenWeekAgo,

endedAt: frozenWeekAgo.Add(time.Hour),

requests: 1,

},

{

// Different templates but identical apps, apps will be

// combined and usage will be summed.

app: users[0].workspaces[1].apps[0],

startedAt: frozenWeekAgo.AddDate(0, 0, 2),

endedAt: frozenWeekAgo.AddDate(0, 0, 2).Add(6 * time.Hour),

requests: 1,

},

},

},

users[0].workspaces[2]: {

agentStats: []agentStat{},

appUsage: []appUsage{},

},

users[1].workspaces[0]: {

agentStats: []agentStat{

{ // One hour of agent usage before timeframe (exclude).

startedAt: frozenWeekAgo.Add(-time.Hour),

endedAt: frozenWeekAgo,

sessionCountVSCode: 1,

sessionCountSSH: 1,

},