backend renaming and more docs

coadler · coadler · commit a60c1f7263e0 · 2022-05-09T16:48:06.000-05:00
diff --git a/coderd/audit/backends/postgres.go b/coderd/audit/backends/postgres.go
@@ -9,7 +9,7 @@ import (
 	"github.com/coder/coder/coderd/database"
 )
 
-type pgBackend struct {
+type postgresBackend struct {
 	// internal indicates if the exporter is exporting to the Postgres database
 	// that the rest of Coderd uses. Since this is a generic Postgres exporter,
 	// we make different decisions to store the audit log based on if it's
@@ -18,19 +18,19 @@ type pgBackend struct {
 	db       database.Store
 }
 
-func NewPGBackend(db database.Store, internal bool) audit.Backend {
-	return &pgBackend{db: db, internal: internal}
+func NewPostgres(db database.Store, internal bool) audit.Backend {
+	return &postgresBackend{db: db, internal: internal}
 }
 
-func (b *pgBackend) Decision() audit.FilterDecision {
+func (b *postgresBackend) Decision() audit.FilterDecision {
 	if b.internal {
 		return audit.FilterDecisionStore
 	}
 
 	return audit.FilterDecisionExport
 }
 
-func (b *pgBackend) Export(ctx context.Context, alog database.AuditLog) error {
+func (b *postgresBackend) Export(ctx context.Context, alog database.AuditLog) error {
 	_, err := b.db.InsertAuditLog(ctx, database.InsertAuditLogParams{
 		ID:             alog.ID,
 		Time:           alog.Time,
diff --git a/coderd/audit/backends/postgres_test.go b/coderd/audit/backends/postgres_test.go
@@ -24,7 +24,7 @@ func TestPostgresBackend(t *testing.T) {
 		var (
 			ctx, cancel = context.WithCancel(context.Background())
 			db          = databasefake.New()
-			pgb         = backends.NewPGBackend(db, true)
+			pgb         = backends.NewPostgres(db, true)
 			alog        = randomAuditLog()
 		)
 		defer cancel()
diff --git a/coderd/audit/backends/slog.go b/coderd/audit/backends/slog.go
@@ -14,7 +14,7 @@ type slogBackend struct {
 	log slog.Logger
 }
 
-func NewSlogBackend(logger slog.Logger) audit.Backend {
+func NewSlog(logger slog.Logger) audit.Backend {
 	return slogBackend{log: logger}
 }
 
diff --git a/coderd/audit/backends/slog_test.go b/coderd/audit/backends/slog_test.go
@@ -21,7 +21,7 @@ func TestSlogBackend(t *testing.T) {
 
 			sink    = &fakeSink{}
 			logger  = slog.Make(sink)
-			backend = backends.NewSlogBackend(logger)
+			backend = backends.NewSlog(logger)
 
 			alog = randomAuditLog()
 		)
diff --git a/coderd/audit/exporter.go b/coderd/audit/exporter.go
@@ -8,27 +8,31 @@ import (
 	"github.com/coder/coder/coderd/database"
 )
 
-// Backends can accept and store or send audit logs elsewhere.
+// Backends can store or send audit logs to arbitrary locations.
 type Backend interface {
 	// Decision determines the FilterDecisions that the backend tolerates.
 	Decision() FilterDecision
 	// Export sends an audit log to the backend.
 	Export(ctx context.Context, alog database.AuditLog) error
 }
 
-// Exporter exports audit logs to an arbitrary amount of backends.
+// Exporter exports audit logs to an arbitrary list of backends.
 type Exporter struct {
 	filter   Filter
 	backends []Backend
 }
 
+// NewExporter creates an exporter from the given filter and backends.
 func NewExporter(filter Filter, backends ...Backend) *Exporter {
 	return &Exporter{
 		filter:   filter,
 		backends: backends,
 	}
 }
 
+// Export exports and audit log. Before exporting to a backend, it uses the
+// filter to determine if the backend tolerates the audit log. If not, it is
+// dropped.
 func (e *Exporter) Export(ctx context.Context, alog database.AuditLog) error {
 	for _, backend := range e.backends {
 		decision, err := e.filter.Check(ctx, alog)

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ import (`
`9`	`9`	`"github.com/coder/coder/coderd/database"`
`10`	`10`	`)`
`11`	`11`
`12`		`-type pgBackend struct {`
	`12`	`+type postgresBackend struct {`
`13`	`13`	`// internal indicates if the exporter is exporting to the Postgres database`
`14`	`14`	`// that the rest of Coderd uses. Since this is a generic Postgres exporter,`
`15`	`15`	`// we make different decisions to store the audit log based on if it's`
`@@ -18,19 +18,19 @@ type pgBackend struct {`
`18`	`18`	`db database.Store`
`19`	`19`	`}`
`20`	`20`
`21`		`-func NewPGBackend(db database.Store, internal bool) audit.Backend {`
`22`		`- return &pgBackend{db: db, internal: internal}`
	`21`	`+func NewPostgres(db database.Store, internal bool) audit.Backend {`
	`22`	`+ return &postgresBackend{db: db, internal: internal}`
`23`	`23`	`}`
`24`	`24`
`25`		`-func (b *pgBackend) Decision() audit.FilterDecision {`
	`25`	`+func (b *postgresBackend) Decision() audit.FilterDecision {`
`26`	`26`	`if b.internal {`
`27`	`27`	`return audit.FilterDecisionStore`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`return audit.FilterDecisionExport`
`31`	`31`	`}`
`32`	`32`
`33`		`-func (b *pgBackend) Export(ctx context.Context, alog database.AuditLog) error {`
	`33`	`+func (b *postgresBackend) Export(ctx context.Context, alog database.AuditLog) error {`
`34`	`34`	`_, err := b.db.InsertAuditLog(ctx, database.InsertAuditLogParams{`
`35`	`35`	`ID: alog.ID,`
`36`	`36`	`Time: alog.Time,`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ func TestPostgresBackend(t *testing.T) {`
`24`	`24`	`var (`
`25`	`25`	`ctx, cancel = context.WithCancel(context.Background())`
`26`	`26`	`db = databasefake.New()`
`27`		`- pgb = backends.NewPGBackend(db, true)`
	`27`	`+ pgb = backends.NewPostgres(db, true)`
`28`	`28`	`alog = randomAuditLog()`
`29`	`29`	`)`
`30`	`30`	`defer cancel()`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ type slogBackend struct {`
`14`	`14`	`log slog.Logger`
`15`	`15`	`}`
`16`	`16`
`17`		`-func NewSlogBackend(logger slog.Logger) audit.Backend {`
	`17`	`+func NewSlog(logger slog.Logger) audit.Backend {`
`18`	`18`	`return slogBackend{log: logger}`
`19`	`19`	`}`
`20`	`20`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ func TestSlogBackend(t *testing.T) {`
`21`	`21`
`22`	`22`	`sink = &fakeSink{}`
`23`	`23`	`logger = slog.Make(sink)`
`24`		`- backend = backends.NewSlogBackend(logger)`
	`24`	`+ backend = backends.NewSlog(logger)`
`25`	`25`
`26`	`26`	`alog = randomAuditLog()`
`27`	`27`	`)`