metrics

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

type Error struct {
	// Kind selects the status code.
	Kind ErrorKind
	// Msg is the client-visible message.
	Msg string
	// Resource and Name name the missing object on a KindNotFound.
	Resource schema.GroupResource
	Name     string
	// contains filtered or unexported fields
}

type ErrorKind int

type Measures = metricsv1alpha1.Measures

type MetricsMap = metricsv1alpha1.MetricsMap

type OwnerChecker interface {
	// OwnerExists reports whether the object the scope names is in the store.
	OwnerExists(ctx context.Context, scope Scope) (bool, error)
}

type Recipe struct {
	// Name is the recipe name.
	Name string
	// Source is the resolved source.
	Source Source
	// Keys are the valid groupBy values, from MetricSource.
	Keys []string
	// Measures are the recipe's output columns.
	Measures []string
	// DefaultColumns are the measures a client shows first. The first entry is
	// the default orderBy.
	DefaultColumns []string
	// Units maps a measure name to its display unit, echoed in a response.
	Units map[string]string
	// Compiled reports whether the recipe still compiles. A recipe that does
	// not is a 422 from series.
	Compiled bool
	// CompileMessage is the sanitized reason a recipe does not compile.
	CompileMessage string
}

type RecipeResolver interface {
	// Recipe returns the compiled recipe named name.
	Recipe(ctx context.Context, name string) (Recipe, error)
}

type Scope struct {
	// Kind is the owner kind. Project means the whole project.
	Kind ScopeKind
	// Name is the owner name. It is empty for a Project scope.
	Name string
	// Listener narrows a Gateway scope to one listener.
	Listener string
}

type ScopeKind string

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

type SeriesOptions struct {
	// Reader runs the query. A nil Reader makes every read a 501 that names
	// the missing configuration, so the path stays in discovery.
	Reader SeriesReader
	// Recipes resolves the recipe named by the path element.
	Recipes RecipeResolver
	// Owners is optional. When it is set, a scoped read over a missing owner
	// is a 404 before the backend is touched.
	Owners OwnerChecker
	// Cache is optional. When it is set, responses are cached under a
	// step-aligned key and the response advertises its max-age.
	Cache *Cache
	// GroupResource names the resource in a NotFound status.
	GroupResource schema.GroupResource
	// MissingFlags are named in the 501 a build with no backend returns.
	MissingFlags []string
	// Now anchors the default window. It defaults to time.Now.
	Now func() time.Time
	// Log receives the unsanitized failure next to the request id. It
	// defaults to the process default logger.
	Log *slog.Logger
}

type SeriesQuery struct {
	ScopeKind     string `json:"scopeKind,omitempty"`
	ScopeName     string `json:"scopeName,omitempty"`
	ScopeListener string `json:"scopeListener,omitempty"`
	GroupBy       string `json:"groupBy,omitempty"`
	OrderBy       string `json:"orderBy,omitempty"`
	Top           int    `json:"top,omitempty"`
	Since         string `json:"since,omitempty"`
	Until         string `json:"until,omitempty"`
	Window        string `json:"window,omitempty"`
	Step          string `json:"step,omitempty"`
}

type SeriesReader interface {
	// ReadSeries returns the series set for req. A backend that cannot be
	// reached must return Unavailable, so the client sees 503 and not 500.
	ReadSeries(ctx context.Context, req *SeriesRequest) (*metricsv1alpha1.MetricSeriesSet, error)
}

type SeriesRequest struct {
	// Metric is the recipe name.
	Metric string
	// Recipe is the compiled recipe the request resolved to.
	Recipe Recipe
	// Scope is the server-enforced read scope.
	Scope Scope
	// GroupBy is one role: key field of the source, or empty.
	GroupBy string
	// OrderBy is the measure the top-N ranks by.
	OrderBy string
	// Top bounds the series count.
	Top int
	// Since and Until are the half-open [since, until) window bounds.
	Since time.Time
	Until time.Time
	// Step is the applied bucket width, rounded up to the source granularity.
	Step time.Duration
	// Buckets is how many buckets the window yields at Step.
	Buckets int
	// DataUpTo is the end of the last complete bucket.
	DataUpTo time.Time
}

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

type SnapshotKind string

type SnapshotOptions struct {
	// Kind selects the response kind and the legal include tokens.
	Kind SnapshotKind
	// Source is the table the snapshot reads, which sets the window cap and
	// the cache alignment.
	Source Source
	// Reader builds the snapshot. A nil Reader makes every read a 501.
	Reader SnapshotReader
	// Decorate is optional. When it is set, it runs on a freshly read snapshot
	// before the snapshot is cached, so a decoration that comes from outside
	// the read model — such as the replica gauges off the owner status — is
	// carried by the cached object too and is not recomputed per cache hit. An
	// error from it fails the read through the same mapper as a backend error.
	Decorate func(ctx context.Context, req *SnapshotRequest, obj runtime.Object) error
	// Owners is optional. When it is set, a read over a missing owner is a 404
	// before the backend is touched.
	Owners OwnerChecker
	// Cache is optional.
	Cache *Cache
	// GroupResource names the resource in a NotFound status.
	GroupResource schema.GroupResource
	// MissingFlags are named in the 501 a build with no backend returns.
	MissingFlags []string
	// Now anchors the default window. It defaults to time.Now.
	Now func() time.Time
	// Log receives the unsanitized failure next to the request id.
	Log *slog.Logger
}

type SnapshotQuery struct {
	ScopeListener string   `json:"scopeListener,omitempty"`
	Include       []string `json:"include,omitempty"`
	OrderBy       string   `json:"orderBy,omitempty"`
	Top           int      `json:"top,omitempty"`
	Since         string   `json:"since,omitempty"`
	Until         string   `json:"until,omitempty"`
	Window        string   `json:"window,omitempty"`
	Metrics       []string `json:"metric,omitempty"`
}

type SnapshotReader interface {
	// ReadSnapshot returns the snapshot for req.
	ReadSnapshot(ctx context.Context, req *SnapshotRequest) (runtime.Object, error)
}

type SnapshotRequest struct {
	// Kind is the snapshot kind the connecter serves.
	Kind SnapshotKind
	// Name is the owner name from the request path.
	Name string
	// Scope is the owner scope, derived from the path.
	Scope Scope
	// Since and Until are the half-open [since, until) window bounds.
	Since time.Time
	Until time.Time
	// Window is Until minus Since.
	Window time.Duration
	// DataUpTo is the end of the last complete bucket.
	DataUpTo time.Time
	// Granularity is the source bucket width. A snapshot has no step of its
	// own, so this is the unit the response cache aligns the window to and the
	// max-age the response advertises.
	Granularity time.Duration
	// Include are the resolved nesting tokens, already expanded from all.
	Include []string
	// Top bounds each cut leaf list.
	Top int
	// OrderBy is the measure the leaf list ranks by.
	OrderBy string
	// Metrics restricts the recipes evaluated. An empty list means every
	// managed recipe.
	Metrics []string
}

type Source struct {
	// Name is the source name a recipe writes in spec.source.
	Name string
	// Granularity is the bucket width. It is one second for raw logs, which
	// have no bucket of their own.
	Granularity time.Duration
	// MaxWindow is the widest window this source serves.
	MaxWindow time.Duration
	// Raw is true for a source of individual log rows, which is bounded by the
	// concurrency cap and by MaxRawGroupByWindow rather than by bucket count.
	Raw bool
}

type Window struct {
	Since    time.Time
	Until    time.Time
	DataUpTo time.Time
}