Aug 30, 2024 · Aug 27, 2024 · Aug 27, 2024 · Aug 27, 2024
diff --git a/cli/server.go b/cli/server.go
 defer shutdownConns()

 // Ensures that old database entries are cleaned up over time!
 purger := dbpurge.New(ctx, logger.Named("dbpurge"), options.Database)
 purger := dbpurge.New(ctx, logger.Named("dbpurge"), options.Database, quartz.NewReal())
 defer purger.Close()

 // Updates workspace usage
diff --git a/coderd/database/dbauthz/dbauthz.go b/coderd/database/dbauthz/dbauthz.go
 return q.db.DeleteOldProvisionerDaemons(ctx)
 }

 func (q *querier) DeleteOldWorkspaceAgentLogs(ctx context.Context) error {
 func (q *querier) DeleteOldWorkspaceAgentLogs(ctx context.Context, threshold time.Time) error {
 if err := q.authorizeContext(ctx, policy.ActionDelete, rbac.ResourceSystem); err != nil {
 return err
 }
 return q.db.DeleteOldWorkspaceAgentLogs(ctx)
 return q.db.DeleteOldWorkspaceAgentLogs(ctx, threshold)
 }

 func (q *querier) DeleteOldWorkspaceAgentStats(ctx context.Context) error {
diff --git a/coderd/database/dbauthz/dbauthz_test.go b/coderd/database/dbauthz/dbauthz_test.go
 }).Asserts(rbac.ResourceSystem, policy.ActionCreate)
 }))
 s.Run("DeleteOldWorkspaceAgentLogs", s.Subtest(func(db database.Store, check *expects) {
 check.Args().Asserts(rbac.ResourceSystem, policy.ActionDelete)
 check.Args(time.Time{}).Asserts(rbac.ResourceSystem, policy.ActionDelete)
 }))
 s.Run("InsertWorkspaceAgentStats", s.Subtest(func(db database.Store, check *expects) {
 check.Args(database.InsertWorkspaceAgentStatsParams{}).Asserts(rbac.ResourceSystem, policy.ActionCreate).Errors(errMatchAny)
diff --git a/coderd/database/dbmem/dbmem.go b/coderd/database/dbmem/dbmem.go
 return nil
 }

 func (q *FakeQuerier) DeleteOldWorkspaceAgentLogs(_ context.Context) error {
 func (q *FakeQuerier) DeleteOldWorkspaceAgentLogs(_ context.Context, threshold time.Time) error {
 q.mutex.Lock()
 defer q.mutex.Unlock()

 now := dbtime.Now()
 weekInterval := 7 * 24 * time.Hour
 weekAgo := now.Add(-weekInterval)

 var validLogs []database.WorkspaceAgentLog
 for _, log := range q.workspaceAgentLogs {
 var toBeDeleted bool
 for _, agent := range q.workspaceAgents {
 if agent.ID == log.AgentID && agent.LastConnectedAt.Valid && agent.LastConnectedAt.Time.Before(weekAgo) {
 if agent.ID == log.AgentID && agent.LastConnectedAt.Valid && agent.LastConnectedAt.Time.Before(threshold) {
 toBeDeleted = true
 break
 }
diff --git a/coderd/database/dbmetrics/dbmetrics.go b/coderd/database/dbmetrics/dbmetrics.go
diff --git a/coderd/database/dbmock/dbmock.go b/coderd/database/dbmock/dbmock.go
diff --git a/coderd/database/dbpurge/dbpurge.go b/coderd/database/dbpurge/dbpurge.go

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

 const (
 delay = 10 * time.Minute
 delay          = 10 * time.Minute
 maxAgentLogAge = 7 * 24 * time.Hour
 )

 // New creates a new periodically purging database instance.
 // It is the caller's responsibility to call Close on the returned instance.
 //
 // This is for cleaning up old, unused resources from the database that take up space.
 func New(ctx context.Context, logger slog.Logger, db database.Store) io.Closer {
 func New(ctx context.Context, logger slog.Logger, db database.Store, clk quartz.Clock) io.Closer {
 closed := make(chan struct{})

 ctx, cancelFunc := context.WithCancel(ctx)
 //nolint:gocritic // The system purges old db records without user input.
 ctx = dbauthz.AsSystemRestricted(ctx)

 // Use time.Nanosecond to force an initial tick. It will be reset to the
 // correct duration after executing once.
 ticker := time.NewTicker(time.Nanosecond)
 doTick := func() {
 ticker := clk.NewTicker(time.Nanosecond)
 doTick := func(start time.Time) {
 defer ticker.Reset(delay)

 start := time.Now()
 // Start a transaction to grab advisory lock, we don't want to run
 // multiple purges at the same time (multiple replicas).
 if err := db.InTx(func(tx database.Store) error {
 return nil
 }

 if err := tx.DeleteOldWorkspaceAgentLogs(ctx); err != nil {
 if err := tx.DeleteOldWorkspaceAgentLogs(ctx, start.Add(-maxAgentLogAge)); err != nil {
 return xerrors.Errorf("failed to delete old workspace agent logs: %w", err)
 }
 if err := tx.DeleteOldWorkspaceAgentStats(ctx); err != nil {
 return xerrors.Errorf("failed to delete old notification messages: %w", err)
 }

 logger.Info(ctx, "purged old database entries", slog.F("duration",time.Since(start)))
 logger.Info(ctx, "purged old database entries", slog.F("duration",clk.Since(start)))

 return nil
 }, nil); err != nil {
 select {
 case <-ctx.Done():
 return
 case <-ticker.C:
 casetick :=<-ticker.C:
 ticker.Stop()
 doTick()
 doTick(tick)
 }
 }
 }()
Original file line number	Diff line number	Diff line change
Expand Up		@@ -985,7 +985,7 @@ func (r RootCmd) Server(newAPI func(context.Context, coderd.Options) (*coderd.
		defer shutdownConns()

		// Ensures that old database entries are cleaned up over time!
		purger := dbpurge.New(ctx, logger.Named("dbpurge"), options.Database)
		purger := dbpurge.New(ctx, logger.Named("dbpurge"), options.Database, quartz.NewReal())
		defer purger.Close()

		// Updates workspace usage
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1144,11 +1144,11 @@ func (q *querier) DeleteOldProvisionerDaemons(ctx context.Context) error {
		return q.db.DeleteOldProvisionerDaemons(ctx)
		}

		func (q *querier) DeleteOldWorkspaceAgentLogs(ctx context.Context) error {
		func (q *querier) DeleteOldWorkspaceAgentLogs(ctx context.Context, threshold time.Time) error {
		if err := q.authorizeContext(ctx, policy.ActionDelete, rbac.ResourceSystem); err != nil {
		return err
		}
		return q.db.DeleteOldWorkspaceAgentLogs(ctx)
		return q.db.DeleteOldWorkspaceAgentLogs(ctx, threshold)
		}

		func (q *querier) DeleteOldWorkspaceAgentStats(ctx context.Context) error {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2517,7 +2517,7 @@ func (s *MethodTestSuite) TestSystemFunctions() {
		}).Asserts(rbac.ResourceSystem, policy.ActionCreate)
		}))
		s.Run("DeleteOldWorkspaceAgentLogs", s.Subtest(func(db database.Store, check *expects) {
		check.Args().Asserts(rbac.ResourceSystem, policy.ActionDelete)
		check.Args(time.Time{}).Asserts(rbac.ResourceSystem, policy.ActionDelete)
		}))
		s.Run("InsertWorkspaceAgentStats", s.Subtest(func(db database.Store, check *expects) {
		check.Args(database.InsertWorkspaceAgentStatsParams{}).Asserts(rbac.ResourceSystem, policy.ActionCreate).Errors(errMatchAny)
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -1706,19 +1706,15 @@ func (q *FakeQuerier) DeleteOldProvisionerDaemons(_ context.Context) error {
		return nil
		}

		func (q *FakeQuerier) DeleteOldWorkspaceAgentLogs(_ context.Context) error {
		func (q *FakeQuerier) DeleteOldWorkspaceAgentLogs(_ context.Context, threshold time.Time) error {
		q.mutex.Lock()
		defer q.mutex.Unlock()

		now := dbtime.Now()
		weekInterval := 7 * 24 * time.Hour
		weekAgo := now.Add(-weekInterval)

		var validLogs []database.WorkspaceAgentLog
		for _, log := range q.workspaceAgentLogs {
		var toBeDeleted bool
		for _, agent := range q.workspaceAgents {
		if agent.ID == log.AgentID && agent.LastConnectedAt.Valid && agent.LastConnectedAt.Time.Before(weekAgo) {
		if agent.ID == log.AgentID && agent.LastConnectedAt.Valid && agent.LastConnectedAt.Time.Before(threshold) {
		toBeDeleted = true
		break
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -11,30 +11,28 @@ import (

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

		const (
		delay = 10 * time.Minute
		delay = 10 * time.Minute
		maxAgentLogAge = 7 * 24 * time.Hour
		)

		// New creates a new periodically purging database instance.
		// It is the caller's responsibility to call Close on the returned instance.
		//
		// This is for cleaning up old, unused resources from the database that take up space.
		func New(ctx context.Context, logger slog.Logger, db database.Store) io.Closer {
		func New(ctx context.Context, logger slog.Logger, db database.Store, clk quartz.Clock) io.Closer {
		closed := make(chan struct{})

		ctx, cancelFunc := context.WithCancel(ctx)
		//nolint:gocritic // The system purges old db records without user input.
		ctx = dbauthz.AsSystemRestricted(ctx)

		// Use time.Nanosecond to force an initial tick. It will be reset to the
		// correct duration after executing once.
		ticker := time.NewTicker(time.Nanosecond)
		doTick := func() {
		ticker := clk.NewTicker(time.Nanosecond)
		doTick := func(start time.Time) {
		defer ticker.Reset(delay)

		start := time.Now()
		// Start a transaction to grab advisory lock, we don't want to run
		// multiple purges at the same time (multiple replicas).
		if err := db.InTx(func(tx database.Store) error {
Expand All		@@ -49,7 +47,7 @@ func New(ctx context.Context, logger slog.Logger, db database.Store) io.Closer {
		return nil
		}

		if err := tx.DeleteOldWorkspaceAgentLogs(ctx); err != nil {
		if err := tx.DeleteOldWorkspaceAgentLogs(ctx, start.Add(-maxAgentLogAge)); err != nil {
		return xerrors.Errorf("failed to delete old workspace agent logs: %w", err)
		}
		if err := tx.DeleteOldWorkspaceAgentStats(ctx); err != nil {
Expand All		@@ -62,7 +60,7 @@ func New(ctx context.Context, logger slog.Logger, db database.Store) io.Closer {
		return xerrors.Errorf("failed to delete old notification messages: %w", err)
		}

		logger.Info(ctx, "purged old database entries", slog.F("duration",time.Since(start)))
		logger.Info(ctx, "purged old database entries", slog.F("duration",clk.Since(start)))

		return nil
		}, nil); err != nil {
Expand All		@@ -78,9 +76,9 @@ func New(ctx context.Context, logger slog.Logger, db database.Store) io.Closer {
		select {
		case <-ctx.Done():
		return
		case <-ticker.C:
		casetick :=<-ticker.C:
		ticker.Stop()
		doTick()
		doTick(tick)
		}
		}
		}()
Expand Down