auditor

type ActorType ¶

type ActorType string

ActorType is the type for the actor of a log entry, meaning the user or service that performed the action.

const (
	// ActorTypeUser is the type for a user actor.
	ActorTypeUser ActorType = "USER"
	// ActorTypeAPIToken is the type for am API Token actor.
	ActorTypeAPIToken ActorType = "API_TOKEN"
	// ActorTypeSystem is the type for a system actor.
	ActorTypeSystem = "SYSTEM"
)

type AuditEventPayload ¶

type AuditEventPayload struct {
	ActionType  string
	TargetType  TargetType
	TargetID    *uuid.UUID
	ActorType   ActorType
	ActorID     *uuid.UUID
	ActorEmail  string
	ActorName   string
	OrgID       *uuid.UUID
	Description string
	Info        json.RawMessage
	Digest      *cr_v1.Hash
}

type AuditLogPublisher ¶

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

func NewAuditLogPublisher(ctx context.Context, rc *natsconn.ReloadableConnection, logger log.Logger) (*AuditLogPublisher, error)

func NewPublishOnlyAuditLogPublisher(rc *natsconn.ReloadableConnection, logger log.Logger) (*AuditLogPublisher, error)

func (p *AuditLogPublisher) Publish(data *EventPayload) error

type DescriptionVariables ¶

type DescriptionVariables struct {
	ActorType  ActorType
	ActorID    *uuid.UUID
	ActorEmail string
	ActorName  string
	OrgID      *uuid.UUID
}

type Dispatcher ¶ added in v1.100.10

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

Dispatcher centralizes the generate -> publish -> error-reporting flow shared by every component that emits audit events (e.g. the control plane's biz.AuditorUseCase and the Artifact CAS). Callers resolve the actor and organization themselves and pass them as GeneratorOptions, so each component keeps its own actor/org policy (request context vs JWT claims) while sharing the common dispatch machinery.

func NewDispatcher(publisher Publisher, logger log.Logger) *Dispatcher

func (d *Dispatcher) Dispatch(entry LogEntry, opts ...GeneratorOption)

func (d *Dispatcher) Enabled() bool

type EventPayload ¶

type EventPayload struct {
	EventType string // AUDIT_EVENT
	Timestamp time.Time
	Data      *AuditEventPayload
}

func GenerateAuditEvent(entry LogEntry, opts ...GeneratorOption) (*EventPayload, error)

func (e *EventPayload) ToJSON() ([]byte, error)

type GeneratorOption ¶

type GeneratorOption func(*GeneratorOptions) error

func WithActor(actorType ActorType, actorID uuid.UUID, email, name string) GeneratorOption

func WithOrgID(orgID uuid.UUID) GeneratorOption

type GeneratorOptions ¶

type GeneratorOptions struct {
	ActorType  ActorType
	ActorID    *uuid.UUID
	ActorEmail string
	ActorName  string
	OrgID      *uuid.UUID
}

type LogEntry ¶

type LogEntry interface {
	// ActionType returns the type of the action performed.
	ActionType() string
	// ActionInfo returns the information about the action performed.
	ActionInfo() (json.RawMessage, error)
	// TargetType returns the type of the target of the action.
	TargetType() TargetType
	// TargetID returns the ID of the target of the action.
	TargetID() *uuid.UUID
	// Description returns a templatable string, see the DescriptionVariables struct.
	Description() string
	RequiresActor() bool
}

LogEntry is the interface for all log entries. All events should implement this interface to be able to be logged.

type Publisher ¶ added in v1.100.10

type Publisher interface {
	Publish(data *EventPayload) error
}

Publisher publishes generated audit event payloads to the event bus. Implemented by *AuditLogPublisher; abstracted so it can be faked in tests and so a nil publisher can act as a no-op (NATS not configured).

type TargetType ¶

type TargetType string

TargetType is the type for the target of a log entry, aka the resource acted upon.