perfharness

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

type BaselineRow struct {
	Client string `json:"client"`
	Step   string `json:"step"`
	Class  string `json:"class"`
	// Status is the HTTP status of the warm requests (of the cold one when
	// there were none); 0 when the step was skipped or failed to connect.
	Status  int    `json:"status"`
	Skipped string `json:"skipped,omitempty"`
	Error   string `json:"error,omitempty"`

	Cold      time.Duration `json:"cold"`
	ColdCPU   time.Duration `json:"coldCpu"`
	ColdRead  int64         `json:"coldReadBytes"`
	ColdWrite int64         `json:"coldWriteBytes"`

	WarmN     int           `json:"warmN"`
	WarmP50   time.Duration `json:"warmP50"`
	WarmP95   time.Duration `json:"warmP95"`
	WarmCPU   time.Duration `json:"warmCpuMedian"`
	WarmRead  int64         `json:"warmReadBytesMedian"`
	WarmWrite int64         `json:"warmWriteBytesMedian"`

	Bytes     int `json:"bytes"`
	GzipBytes int `json:"gzipBytes"`
	WireBytes int `json:"wireBytes"`
	Items     int `json:"items"`
	TotalSize int `json:"totalSize"`

	// Queries is the median statement count per request, when the server
	// wrote a perf trace (Ether only).
	Queries int64 `json:"queries,omitempty"`
}

type Budget struct {
	Warm, Cold, Loaded time.Duration
	Gated              bool
}

type CgroupProbe struct{ Dir string }

type Client struct {
	Name    string
	Surface string
	// Port offset from the base port (0 main, 1 Jellyfin, 2 Emby, 3 Silo),
	// or SharedPrefix on the main port when the runner shares one port.
	Port         int
	SharedPrefix string
	Prefix       string
	Headers      func(s *session) http.Header
	SignIn       *Step
	Steps        []Step
}

type LongTailConfig struct {
	// Titles is the number of movies plus shows in the TMDB universe.
	Titles int
	// YearCounts, when set, fixes how many movies ([0]) and shows ([1]) the
	// universe has per release year, replacing Titles and MovieShare: for
	// example TMDB's own counts, capped at the 10,000 a discover year slice
	// can return (LoadTMDBYearCounts).
	YearCounts [2]map[int]int
	// MovieShare is the movies' share of Titles (0 = 0.7).
	MovieShare float64
	Seed       uint64
	// Now is the catalogue's clock and the universe's present.
	Now time.Time
	// HideObscure keeps the default browsable bar (popularity 5 or 100
	// votes). Off is "Hide obscure titles" turned off: everything released
	// is browsable, so the catalogue details the whole universe.
	HideObscure bool
	// OpenShows is how many of the most popular shows a household opened,
	// so their seasons and episodes are stored (0 = 300, -1 = none). It
	// does not grow with the universe: viewers open what they watch.
	OpenShows int
	// SkipSync goes straight to detailing (a database a sync already filled).
	SkipSync bool
	// DetailLimit stops warming after this many detail fetches (0 = all).
	DetailLimit int
	// Progress, if set, is called as phases advance.
	Progress func(phase string, done int)
	Log      *slog.Logger
}

type LongTailReport struct {
	Universe       int
	Browsable      int // titles in the universe meeting the default bar
	Synced         time.Duration
	Filled         int // released titles detailed through Get after the sync
	FillWaited     int // of those, Gets that returned before their fetch landed
	FillTook       time.Duration
	Warmed         int
	WarmTook       time.Duration
	SeasonsOpened  int
	DetailRequests int
}

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

type ObjectSize struct {
	Name  string `json:"name"`
	Table string `json:"table"` // the table it belongs to (itself for a table)
	Index bool   `json:"index"`
	Bytes int64  `json:"bytes"`
	Rows  int64  `json:"rows,omitempty"` // tables only
}

type OffMirror struct {
	MovieExport, TVExport string
	// Movies and Shows are the most popular export ids stored (0.3.5's Off
	// mirror held about 680k movies and 120k series).
	Movies, Shows int
	// DetailMovies and DetailShows were opened or warmed (detail=1); each
	// opened show has DetailSeasons seasons of DetailEpisodes episodes.
	DetailMovies, DetailShows     int
	DetailSeasons, DetailEpisodes int
	// Viewers each watched, listed and favourited titles, a share of them
	// in the long tail.
	Viewers int
	// XtreamIDs assigns an Xtream compact id to every stored movie and
	// series, as a client that loaded the VOD lists has.
	XtreamIDs bool
	// Stride keeps every Stride-th title of the popularity-ranked export
	// (a smaller mirror with the same share of long tail); 0 or 1 keeps
	// the first Movies and Shows.
	Stride int
	Now    time.Time
}

type OffMirrorSummary struct {
	Movies, Shows, Seasons, Episodes int
	// AtFloor titles meet the Off floor on their stored values; TailTouched
	// are below it and named by a touch source.
	AtFloor, TailTouched int
	Rows                 map[string]int
}

type Probe interface {
	Sample() (Usage, error)
}

type RankBenchPage struct {
	Name       string        `json:"name"`
	Rank       bool          `json:"rank"`
	Statements int64         `json:"statements"`
	Rows       int64         `json:"rows"`
	DB         time.Duration `json:"db"`
}

type RankBenchStep struct {
	Name       string        `json:"name"`
	Took       time.Duration `json:"took"`
	WAL        int64         `json:"wal"`
	WriterWait time.Duration `json:"writerWait,omitempty"`
}

type Result struct {
	SchemaVersion int           `json:"schemaVersion,omitempty"`
	Phase         string        `json:"phase"`
	Client        string        `json:"client"`
	Surface       string        `json:"surface"`
	Step          string        `json:"step"`
	Class         string        `json:"class"`
	Viewer        string        `json:"viewer"`
	Tag           string        `json:"tag"`
	Status        int           `json:"status"`
	Bytes         int           `json:"bytes"`
	BodySHA       string        `json:"bodySha256,omitempty"`
	Dur           time.Duration `json:"dur"`
	Err           string        `json:"err,omitempty"`
	Skipped       string        `json:"skipped,omitempty"`
	// RenderedItems counts the titles a listing response rendered, by type.
	RenderedItems map[string]int `json:"renderedItems,omitempty"`
	// Set when the runner measures (Measure): the bytes on the wire, the
	// body's size gzipped at the default level, and the server's CPU time
	// and block IO while it answered.
	WireBytes  int           `json:"wireBytes,omitempty"`
	GzipBytes  int           `json:"gzipBytes,omitempty"`
	CPU        time.Duration `json:"cpu,omitempty"`
	ReadBytes  int64         `json:"readBytes,omitempty"`
	WriteBytes int64         `json:"writeBytes,omitempty"`
	Probed     bool          `json:"probed,omitempty"`
	// Items and TotalSize are a Plex MediaContainer's size and totalSize
	// (measure mode), so an empty page is not mistaken for a fast one.
	Items     int `json:"items,omitempty"`
	TotalSize int `json:"totalSize,omitempty"`
}

type Row struct {
	Client, Step, Class     string
	RowsBound, QueriesBound int
	// Export and Bytes (the median response size): an export step's work
	// is compared per response byte (Step.Export).
	Export bool
	Bytes  int64
	// WritesMax is the most statements that wrote in one request.
	WritesMax                              int64
	Cold, WarmP50, WarmP95, ConcP95, BgP95 time.Duration
	Queries, Writes, Rows                  int64
	AllocBytes, Allocs                     int64
	// The fewest and most statements and rows over the cold and warm
	// passes. A pass may or may not be answered by a cache, so the gate
	// compares the large library's least work with the small one's most.
	QueriesMin, QueriesMax, RowsMin, RowsMax int64
	DBTime, LockWait                         time.Duration
	// Cold is the owner's first pass after the start, First another
	// viewer's first pass (that viewer's caches cold, the server's warm);
	// the most work one request of each took.
	ColdWork, FirstWork Work
	// The page bound of a listing (ApplyPageBound): its worst request's
	// rows, the rows its rendered titles account for, and their number.
	PageCounted         bool
	PageRows, PageBound int64
	PageItems           int
	Status              string
	Fails               []string
	Skipped             string
	Errors              []string
	// contains filtered or unexported fields
}

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

type Scale struct {
	Movies            int
	Shows             int
	SeasonsPerShow    int
	EpisodesPerSeason int
	// EpisodeShows is how many series have their episodes stored (0: all).
	// The catalogue stores a series' seasons with its details and its
	// episodes only once a season is opened, so on a full mirror they are
	// the household's series, not the catalogue's.
	EpisodeShows int
	// Viewers beyond the owner, each with HistoryPerViewer watched titles
	// and InProgressPerViewer partly watched ones.
	Viewers             int
	HistoryPerViewer    int
	InProgressPerViewer int
}

type Shape struct {
	Type       core.MediaType
	Popularity float64
	Votes      int
	Rating     float64
	// Tier is 0 for the obscure tail and 1 for a blockbuster. It scales
	// every detail count below.
	Tier float64

	Cast, Directors, Writers, Crew int
	Keywords                       int
	Genres                         int
	AltTitles                      int
	Studios                        int
	Countries                      int
	// ReleaseCountries is how many countries list release dates (movies).
	ReleaseCountries int
	// Collection is true for a movie in a franchise collection.
	Collection bool
	// CrowdRecs is the length of the first recommendations page.
	CrowdRecs int
	// Seasons and EpisodesPerSeason describe a show.
	Seasons, EpisodesPerSeason int
	// SummaryLen is the overview's length in characters (0: none).
	SummaryLen                   int
	Poster, Backdrop, Logo, IMDB bool
	Certified                    bool
	Returning                    bool
	Language                     string
}

type Step struct {
	Name  string
	Class string
	// RowsBound, when set, is a hard bound on the rows the step reads,
	// whatever the library's size: a search reads at most its candidate
	// window, so its rows grow with the matches only until the window
	// fills. The gate checks the bound instead of comparing scales.
	RowsBound int
	// QueriesBound, when set, is a hard bound on the statements one
	// request of the step runs, whatever the library's size, and the step
	// must write nothing: a read that loops over its titles or rows, or
	// saves what it shows, breaks it before the scale comparison would.
	QueriesBound int
	// Export marks a step whose response is the whole library by design
	// (an IPTV app's VOD list): its work grows with what it renders, so
	// the gate compares work per response byte instead of per request.
	Export   bool
	Method   string
	Path     string
	Body     string
	Discover func(vars map[string]string, body []byte)
}

type SyncBenchConfig struct {
	// Titles is the universe: movies and shows the list phases store.
	Titles int
	// Details is how many of them the detail phases fetch (0 = 2,000).
	Details int
	// IDBase puts the universe's TMDB ids above every id the catalogue
	// already holds (0 = 50,000,000).
	IDBase int64
	Seed   uint64
	// Path is the SQLite file, for WAL size sampling; empty on PostgreSQL.
	Path string
	Log  *slog.Logger
	// Progress, if set, gets a line per phase as it starts.
	Progress func(string)
}

type SyncBenchOperations struct {
	Attempted int `json:"attempted"`
	Succeeded int `json:"succeeded"`
	Rejected  int `json:"rejected"`
}

type SyncBenchPhase struct {
	Name         string        `json:"name"`
	Titles       int           `json:"titles"`
	Wall         time.Duration `json:"wall"`
	TitlesPerSec float64       `json:"titlesPerSec"`
	// TMDB is time the fake TMDB spent building payloads; DBBound is
	// titles per second with it subtracted.
	TMDB       time.Duration `json:"tmdb"`
	DBBound    float64       `json:"dbBoundTitlesPerSec"`
	DBTime     time.Duration `json:"dbTime"`
	DBPerTitle time.Duration `json:"dbPerTitle"`
	Statements int64         `json:"statements"`
	StmtsTitle float64       `json:"statementsPerTitle"`
	LockWait   time.Duration `json:"lockWait"`
	// WrittenPerTitle is bytes the process wrote to disk per title (WAL
	// and checkpoints; Linux), WALPerTitle PostgreSQL's WAL bytes.
	WrittenPerTitle float64              `json:"writtenPerTitle,omitempty"`
	WALPerTitle     float64              `json:"walPerTitle,omitempty"`
	PeakWAL         int64                `json:"peakWal,omitempty"`
	Gate            store.WriteGateHolds `json:"gate"`
	// Detail operations are counted individually. List sync is one bulk call
	// and does not expose per-title outcomes, so its Operations is absent.
	Operations *SyncBenchOperations `json:"operations,omitempty"`
	Error      string               `json:"error,omitempty"`
}

type TailRow struct {
	Key           int64
	Title         string
	OriginalTitle string
	Year          int
	Poster        string
	Popularity    float64
}

type TailSearch struct {
	Query string        `json:"query"`
	Rows  int           `json:"rows"`
	Took  time.Duration `json:"took"`
}

type TailVariant struct {
	Name       string        `json:"name"`
	Bytes      int64         `json:"bytes"`
	IndexBytes int64         `json:"indexBytes"`
	Load       time.Duration `json:"load"`
	LoadWAL    int64         `json:"loadWal"`
	Searches   []TailSearch  `json:"searches"`
}

type Target struct {
	Label string
	Rows  []BaselineRow
}

type TraceRecord struct {
	Tag        string          `json:"tag"`
	Surface    string          `json:"surface"`
	Method     string          `json:"method"`
	Path       string          `json:"path"`
	Status     int             `json:"status"`
	Duration   time.Duration   `json:"duration"`
	Queries    int64           `json:"queries"`
	Writes     int64           `json:"writes"`
	Rows       int64           `json:"rows"`
	DBTime     time.Duration   `json:"dbTime"`
	LockWait   time.Duration   `json:"lockWait"`
	AllocBytes uint64          `json:"allocBytes"`
	Allocs     uint64          `json:"allocs"`
	Statements []statementStat `json:"statements"`
}

type Usage struct {
	CPU        time.Duration // user + system CPU time
	ReadBytes  int64         // bytes read from block devices
	WriteBytes int64         // bytes written to block devices
}

type Viewer struct {
	ID         int64
	Username   string
	Owner      bool
	Restricted bool
	PlexToken  string
	Stremio    string
	// Xtream is an IPTV app password (the username is derived from it);
	// MCP is a read-scoped MCP grant, minted for the owner only.
	Xtream string
	MCP    string
}

type Work struct {
	Queries, Rows int64
	DBTime        time.Duration
}