audit

Documentation

Index

• func BuildAudit[T Auditable](ctx context.Context, p *BuildAuditParams[T])
• func Empty[T Auditable]() T
• func ResourceID[T Auditable](tgt T) uuid.UUID
• func ResourceTarget[T Auditable](tgt T) string
• func ResourceType[T Auditable](tgt T) database.ResourceType
• type AdditionalFields
• type Auditable
• type Auditor
  • func NewNop() Auditor
• type BuildAuditParams
• type Differ
• type Map
  • func Diff[T Auditable](a Auditor, left, right T) Map
• type MockAuditor
  • func NewMock() *MockAuditor
  • func (a *MockAuditor) AuditLogs() []database.AuditLog
  • func (a *MockAuditor) Export(_ context.Context, alog database.AuditLog) error
• type OldNew
• type Request
  • func InitRequest[T Auditable](w http.ResponseWriter, p *RequestParams) (*Request[T], func())
• type RequestParams

Functions

func BuildAudit

func BuildAudit[T Auditable](ctx context.Context, p *BuildAuditParams[T])

BuildAudit creates an audit log for a workspace build. The audit log is committed upon invocation.

func Empty

func Empty[T Auditable]() T

Empty returns a default value of type T.

func ResourceID

func ResourceID[T Auditable](tgt T) uuid.UUID

func ResourceTarget

func ResourceTarget[T Auditable](tgt T) string

func ResourceType

func ResourceType[T Auditable](tgt T) database.ResourceType

Types

type AdditionalFields

type AdditionalFields struct {
	WorkspaceName  string               `json:"workspace_name"`
	BuildNumber    string               `json:"build_number"`
	BuildReason    database.BuildReason `json:"build_reason"`
	WorkspaceOwner string               `json:"workspace_owner"`
}

type Auditable

type Auditable interface {
	database.APIKey |
		database.Template |
		database.TemplateVersion |
		database.User |
		database.Workspace |
		database.GitSSHKey |
		database.WorkspaceBuild |
		database.AuditableGroup |
		database.License |
		database.WorkspaceProxy
}

Auditable is mostly a marker interface. It contains a definitive list of all auditable types. If you want to audit a new type, first define it in AuditableResources, then add it to this interface.

type Auditor

type Auditor interface {
	Export(ctx context.Context, alog database.AuditLog) error
	// contains filtered or unexported methods
}

func NewNop

func NewNop() Auditor

type BuildAuditParams

type BuildAuditParams[T Auditable] struct {
	Audit Auditor
	Log   slog.Logger

	UserID           uuid.UUID
	JobID            uuid.UUID
	Status           int
	Action           database.AuditAction
	AdditionalFields json.RawMessage

	New T
	Old T
}

type Differ

type Differ struct {
	DiffFn func(old, new any) Map
}

Differ is used so the enterprise version can implement the diff function in the Auditor feature interface. Only types in the same package as the interface can implement unexported methods.

type Map

type Map map[string]OldNew

Map is a map of changed fields in an audited resource. It maps field names to the old and new value for that field.

func Diff

func Diff[T Auditable](a Auditor, left, right T) Map

Diff compares two auditable resources and produces a Map of the changed values.

type MockAuditor

type MockAuditor struct {
	// contains filtered or unexported fields
}

func NewMock

func NewMock() *MockAuditor

func (*MockAuditor) AuditLogs

func (a *MockAuditor) AuditLogs() []database.AuditLog

func (*MockAuditor) Export

func (a *MockAuditor) Export(_ context.Context, alog database.AuditLog) error

type OldNew

type OldNew struct {
	Old    any
	New    any
	Secret bool
}

OldNew is a pair of values representing the old value and the new value.

type Request

type Request[T Auditable] struct {
	Old T
	New T

	// This optional field can be passed in when the userID cannot be determined from the API Key
	// such as in the case of login, when the audit log is created prior the API Key's existence.
	UserID uuid.UUID

	// This optional field can be passed in if the AuditAction must be overridden
	// such as in the case of new user authentication when the Audit Action is 'register', not 'login'.
	Action database.AuditAction
	// contains filtered or unexported fields
}

func InitRequest

func InitRequest[T Auditable](w http.ResponseWriter, p *RequestParams) (*Request[T], func())

InitRequest initializes an audit log for a request. It returns a function that should be deferred, causing the audit log to be committed when the handler returns.

type RequestParams

type RequestParams struct {
	Audit Auditor
	Log   slog.Logger

	Request          *http.Request
	Action           database.AuditAction
	AdditionalFields json.RawMessage
}