Files
archie/internal/infrastructure/staterpc/audit.go
T

231 lines
6.7 KiB
Go

// Audit: the org-scoped feed RPCs. The State Store derives the org from the
// authenticated caller's context; no request field names one.
package staterpc
import (
"context"
"strconv"
"strings"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/audit"
)
var errAuditUnavailable = status.Error(codes.Unavailable, "audit feed unavailable")
// withInstanceAdmin marks whether the authenticated principal administers the
// whole instance. The feed uses it instead of the org id: a viewer confined to
// the system org is not an instance administrator.
func withInstanceAdmin(ctx context.Context) context.Context {
principal, ok := access.PrincipalFromContext(ctx)
return audit.WithInstanceAdmin(ctx, ok && principal.InstanceAdmin())
}
type auditServer struct {
pb.UnimplementedAuditServiceServer
*server
}
func auditFilterValue(f *pb.AuditFilter) audit.Filter {
filter := audit.Filter{
Categories: f.GetCategories(),
Actions: f.GetActions(),
Kinds: f.GetKinds(),
Actor: f.GetActor(),
TargetKinds: f.GetTargetKinds(),
TargetIDs: f.GetTargetIds(),
Severities: f.GetSeverities(),
Outcomes: f.GetOutcomes(),
Query: f.GetQ(),
}
if from := f.GetFrom(); from != nil {
filter.From = from.AsTime()
}
if to := f.GetTo(); to != nil {
filter.To = to.AsTime()
}
return filter
}
func auditFilterProto(f audit.Filter) *pb.AuditFilter {
out := &pb.AuditFilter{
Categories: f.Categories,
Actions: f.Actions,
Kinds: f.Kinds,
Actor: f.Actor,
TargetKinds: f.TargetKinds,
TargetIds: f.TargetIDs,
Severities: f.Severities,
Outcomes: f.Outcomes,
Q: f.Query,
}
if !f.From.IsZero() {
out.From = timestamp(f.From)
}
if !f.To.IsZero() {
out.To = timestamp(f.To)
}
return out
}
func auditEntryProto(e audit.Entry) *pb.AuditEntry {
fields := make([]*pb.AuditField, len(e.Fields))
for i, field := range e.Fields {
fields[i] = &pb.AuditField{
Field: field.Name,
OldValueJson: string(field.Old),
NewValueJson: string(field.New),
}
}
return &pb.AuditEntry{
Id: e.ID(),
Category: string(e.Category),
At: timestamp(e.At),
Actor: e.Actor,
ActorKind: e.ActorKind,
PrincipalId: e.PrincipalID,
TargetKind: e.TargetKind,
TargetId: e.TargetID,
Kind: e.Kind,
RecordVersion: e.RecordVersion,
RequestId: e.RequestID,
Source: e.Source,
Fields: fields,
Action: e.Action,
Severity: string(e.Severity),
Outcome: string(e.Outcome),
Detail: e.Detail,
WorkspaceId: e.WorkspaceID,
TaskId: e.TaskID,
DataJson: string(e.Data),
}
}
func auditEntryValue(e *pb.AuditEntry) audit.Entry {
fields := make([]audit.Field, len(e.GetFields()))
for i, field := range e.GetFields() {
fields[i] = audit.Field{
Name: field.GetField(),
Old: []byte(field.GetOldValueJson()),
New: []byte(field.GetNewValueJson()),
}
}
entry := audit.Entry{
Category: audit.Category(e.GetCategory()),
At: timeValue(e.GetAt()),
Actor: e.GetActor(),
ActorKind: e.GetActorKind(),
PrincipalID: e.GetPrincipalId(),
TargetKind: e.GetTargetKind(),
TargetID: e.GetTargetId(),
Kind: e.GetKind(),
RecordVersion: e.GetRecordVersion(),
RequestID: e.GetRequestId(),
Source: e.GetSource(),
Fields: fields,
Action: e.GetAction(),
Severity: audit.Severity(e.GetSeverity()),
Outcome: audit.Outcome(e.GetOutcome()),
Detail: e.GetDetail(),
WorkspaceID: e.GetWorkspaceId(),
TaskID: e.GetTaskId(),
}
if data := e.GetDataJson(); data != "" {
entry.Data = []byte(data)
}
entry.Rank, entry.SourceID = auditRankAndID(e.GetId())
return entry
}
// auditRankAndID restores the feed position a remote entry was read at, so
// the entry's stable id survives the wire unchanged.
func auditRankAndID(id string) (int, int64) {
rankText, idText, ok := strings.Cut(id, ":")
if !ok {
return 0, 0
}
rank, err := strconv.Atoi(rankText)
if err != nil {
return 0, 0
}
sourceID, err := strconv.ParseInt(idText, 10, 64)
if err != nil {
return 0, 0
}
return rank, sourceID
}
func (s *auditServer) ListAudit(ctx context.Context, request *pb.ListAuditRequest) (*pb.ListAuditResponse, error) {
if s.deps.Audit == nil {
return nil, errAuditUnavailable
}
filter := auditFilterValue(request.GetFilter())
if err := filter.Normalize(); err != nil {
return nil, validationFailure(err)
}
cursor := audit.Cursor{}
if raw := strings.TrimSpace(request.GetCursor()); raw != "" {
// A malformed cursor means newest; a well-formed one reused with
// other filters is refused rather than resuming somewhere else.
if parsed, ok := audit.ParseCursor(raw); ok {
if !parsed.MatchesFilter(filter) {
return nil, status.Error(codes.InvalidArgument, "cursor does not match the requested filter")
}
cursor = parsed
}
}
page, err := s.deps.Audit.ListAudit(withInstanceAdmin(ctx), filter, cursor, int(request.GetLimit()))
if err != nil {
return nil, s.logErr("ListAudit", err)
}
entries := make([]*pb.AuditEntry, len(page.Entries))
for i := range page.Entries {
entries[i] = auditEntryProto(page.Entries[i])
}
return &pb.ListAuditResponse{
Entries: entries,
NextCursor: page.NextCursor,
HasMore: page.HasMore,
}, nil
}
func (s *auditServer) GetAuditHead(ctx context.Context, _ *pb.GetAuditHeadRequest) (*pb.GetAuditHeadResponse, error) {
if s.deps.Audit == nil {
return nil, errAuditUnavailable
}
token, err := s.deps.Audit.AuditHead(withInstanceAdmin(ctx))
if err != nil {
return nil, s.logErr("GetAuditHead", err)
}
return &pb.GetAuditHeadResponse{Token: token}, nil
}
func (s *auditServer) CountAudit(ctx context.Context, request *pb.CountAuditRequest) (*pb.CountAuditResponse, error) {
if s.deps.Audit == nil {
return nil, errAuditUnavailable
}
filter := auditFilterValue(request.GetFilter())
if err := filter.Normalize(); err != nil {
return nil, validationFailure(err)
}
count, err := s.deps.Audit.CountAudit(withInstanceAdmin(ctx), filter)
if err != nil {
return nil, s.logErr("CountAudit", err)
}
return &pb.CountAuditResponse{Count: count}, nil
}
func (s *auditServer) RecordAuditExport(ctx context.Context, request *pb.RecordAuditExportRequest) (*pb.RecordAuditExportResponse, error) {
if s.deps.Audit == nil {
return nil, errAuditUnavailable
}
if err := s.deps.Audit.RecordAuditExport(ctx, request.GetFormat(), request.GetFiltersHash(), request.GetRows()); err != nil {
return nil, s.logErr("RecordAuditExport", err)
}
return &pb.RecordAuditExportResponse{}, nil
}