obsdash

type Agg = dashspec.Agg

type AlertDefaultInfo struct {
	ID       string `json:"id"`
	Alert    string `json:"alert"`
	Title    string `json:"title"`
	Severity string `json:"severity"`
	For      string `json:"for"`
	Interval string `json:"interval"`
	// Signal is where the default reads: metrics, traces, metadata (the node
	// agent's customer metadata) or platform (the control plane's own events).
	Signal string `json:"signal"`
	// Requires names the observability category whose opt-out leaves the
	// default nothing to read ("metadata"). Empty = always applicable.
	Requires string `json:"requires,omitempty"`
	// AlertNames are further rule names the default also takes, beyond Alert.
	AlertNames []string     `json:"alert_names,omitempty"`
	Params     []AlertParam `json:"params"`
}

type AlertDefaultsDoc struct {
	Version  string             `json:"version"`
	Input    AlertInput         `json:"input"`
	Defaults []AlertDefaultInfo `json:"defaults"`
}

type AlertInput struct {
	Project string `json:"project"`
	// Services are the project's services that have at least one rpc. The
	// generated file leaves them out (each is in its alertServicePart).
	Services []AlertService `json:"services,omitempty"`
	// FrontendServices are the service.names the project's web frontends'
	// browser SDK reports (naming.FrontendServiceName: "<project>-<frontend>",
	// what each otel_gen.ts bakes as SERVICE_NAME), empty when the project has
	// no web frontend. The frontend defaults fire per service.name.
	FrontendServices []string `json:"frontend_services,omitempty"`
	// UptimeChecks are the names of the env's uptime checks (the release
	// shape's uptime_checks). They are a fact about one env, not the project,
	// so the generated file never records them: the resolver sets them per
	// env. The uptime defaults apply only to an env that has checks, and read
	// only those checks' series, so a check an env opts out of cannot alert.
	UptimeChecks []string `json:"-"`
}

type AlertParam struct {
	Name    string  `json:"name"`
	Default float64 `json:"default"`
	Doc     string  `json:"doc"`
}

type AlertRule struct {
	ID          string
	Alert       string
	Expr        string
	For         string
	Interval    string
	Labels      map[string]string
	Annotations map[string]string
}

type AlertService struct {
	Name       string `json:"name"`
	RPCService string `json:"rpc_service"`
}

type AlertSkip struct{ ID, Reason string }

type AlertTuning struct {
	Enabled bool
	Labels  map[string]string
	For     string
	Params  map[string]float64
}

type Annotation = dashspec.Annotation

type AnnotationSource = dashspec.AnnotationSource

type BundleDashboard struct {
	// Name is the file name without ".json", and without "_gen" for a
	// generated one: the key a project file overrides by.
	Name   string
	Source BundleDashboardSource
	// Path is the file's path inside the bundle.
	Path string
	// Dashboard is the parsed content; Data is the exact bytes shipped.
	Dashboard Dashboard
	Data      []byte
}

type BundleDashboardSource string

type BundleFile struct {
	Path string
	Data []byte
}

type BundleSet struct {
	Dashboards []BundleDashboard
	// MetricsSchema is the raw forge.metrics/v1 document, or nil.
	MetricsSchema []byte
	// Notes are things worth telling the person cutting the release (a
	// HyperDX-only file that was not shipped).
	Notes []string
}

type BundleSetInput struct {
	// ProjectDir is the project root; the project's name is the one
	// dashboard-spec_gen.json records.
	ProjectDir string
	// MetricsSchema is the raw metrics schema the build produced, or nil.
	MetricsSchema []byte
	// Resolved is the selected environment's pure assembly. Non-nil replaces
	// disk generated dashboards, including stale process parts; owned overrides
	// still apply through the same stable filename/ID path.
	Resolved *Spec
}

type Dashboard = dashspec.Dashboard

type Filter = dashspec.Filter

type Fragments struct {
	Frontends        []string
	FrontendServices []string `json:",omitempty"`
	HasDatabase      bool
	Funnels          []FrontendFunnel
}

type FrontendFunnel struct {
	ID    string
	Title string
	Funnel
}

type Funnel = dashspec.Funnel

type FunnelBy = dashspec.FunnelBy

type Group = dashspec.Group

type HyperDXChart struct {
	Name          string            `json:"name"`
	Source        string            `json:"source"`
	DisplayType   string            `json:"displayType"`
	Select        any               `json:"select"` // []HyperDXSelect, or a column string for a search tile
	Where         string            `json:"where"`
	WhereLanguage string            `json:"whereLanguage"`
	GroupBy       string            `json:"groupBy,omitempty"`
	Granularity   string            `json:"granularity,omitempty"`
	SeriesReturn  string            `json:"seriesReturnType,omitempty"`
	NumberFormat  *HyperDXNumFormat `json:"numberFormat,omitempty"`
	Align         *bool             `json:"alignDateRangeToGranularity,omitempty"`
}

type HyperDXDashboard struct {
	Name    string          `json:"name"`
	Tags    []string        `json:"tags"`
	Tiles   []HyperDXTile   `json:"tiles"`
	Filters []HyperDXFilter `json:"filters,omitempty"`
}

type HyperDXFilter struct {
	ID            string `json:"id"`
	Type          string `json:"type"`
	Name          string `json:"name"`
	Expression    string `json:"expression"`
	Source        string `json:"source"`
	WhereLanguage string `json:"whereLanguage"`
}

type HyperDXNumFormat struct {
	Output            string `json:"output"`
	Mantissa          *int   `json:"mantissa,omitempty"`
	ThousandSeparated bool   `json:"thousandSeparated,omitempty"`
	Unit              string `json:"unit,omitempty"`
}

type HyperDXSavedSearch struct {
	Name          string   `json:"name"`
	Source        string   `json:"source"`
	Select        string   `json:"select"`
	Where         string   `json:"where"`
	WhereLanguage string   `json:"whereLanguage"`
	OrderBy       string   `json:"orderBy"`
	Tags          []string `json:"tags"`
}

type HyperDXSelect struct {
	AggFn         string            `json:"aggFn"`
	Level         float64           `json:"level,omitempty"`
	ValueExpr     string            `json:"valueExpression"`
	AggCondition  string            `json:"aggCondition,omitempty"`
	AggCondLang   string            `json:"aggConditionLanguage,omitempty"`
	Alias         string            `json:"alias,omitempty"`
	MetricName    string            `json:"metricName,omitempty"`
	MetricType    string            `json:"metricType,omitempty"`
	NumberFormatP *HyperDXNumFormat `json:"numberFormat,omitempty"`
}

type HyperDXTile struct {
	ID     string       `json:"id"`
	X      int          `json:"x"`
	Y      int          `json:"y"`
	W      int          `json:"w"`
	H      int          `json:"h"`
	Config HyperDXChart `json:"config"`
}

type Identities struct {
	ServiceNames []string
	Workloads    []string
	// RPCServiceNames are the service.names of the processes that serve RPCs:
	// the only ones an rpc.server.* panel can have data for.
	RPCServiceNames []string
	// CPULimitWorkloads and MemoryLimitWorkloads are the workloads that
	// declare that limit: the only ones a *_limit_utilization panel can have
	// data for.
	CPULimitWorkloads    []string
	MemoryLimitWorkloads []string
}

type Input struct {
	Project   string
	Services  []Service
	Processes []Process
	Frontends []string
	// FrontendServices, when set, are the service.names those frontends report
	// (a frontend built from another repository bakes its own); empty derives
	// each from the project and frontend name (naming.FrontendServiceName).
	FrontendServices []string
	// HasDatabase adds the database panels: true once the project has a
	// migration, since the panels read spans the ORM's query hook emits.
	HasDatabase bool
	// Funnels are the declared product funnels. Each becomes one panel on the
	// frontend dashboard, so they only matter when Frontends is non-empty.
	Funnels []FrontendFunnel
	// Deployed scopes the overview, together with Processes' own identities,
	// when the per-process inventory is not being built: forge generate knows
	// every environment's deployed service.names and workloads, but per-process
	// parts are the selected environment's alone (built at bundle time, see
	// ProcessPart). Without it a generate-time overview filtered on the
	// no-deployed-process sentinel and drew nothing.
	Deployed Identities
}

type Method struct {
	Name string
}

type Op = dashspec.Op

type Panel = dashspec.Panel

type PanelKind = dashspec.PanelKind

type Predicate = dashspec.Predicate

type Problem = dashspec.Problem

type Process struct {
	// Name is the forge workload name (the first, when several workloads run
	// the same executable and command): "admin-api", never the rendered
	// Kubernetes object name, the command line or a hash. It names the
	// process's dashboard ("process-<name>").
	Name string `json:"name"`
	// Kind is the forge workload kind: service, worker, operator, job or
	// cron. Empty is a service. Jobs and crons share one Jobs dashboard.
	Kind         string   `json:"kind,omitempty"`
	Binary       string   `json:"binary"`
	Args         []string `json:"args,omitempty"`
	Root         string   `json:"root,omitempty"`
	ServiceNames []string `json:"serviceNames"`
	Workloads    []string `json:"workloads"`
	RPCServices  []string `json:"rpcServices,omitempty"`
	HasDatabase  bool     `json:"hasDatabase,omitempty"`
	// CPULimit and MemoryLimit say the workload declares that resource limit,
	// the only case the node agent's *_limit_utilization series exist.
	CPULimit    bool `json:"cpuLimit,omitempty"`
	MemoryLimit bool `json:"memoryLimit,omitempty"`
	// NodeMetadata says the process runs where the node agent delivers
	// per-container metadata (a cluster or hosted runtime); a host or compose
	// process has no saturation or restart series.
	NodeMetadata bool `json:"nodeMetadata,omitempty"`
	// ServesRPCDeclared is set for a Go process forge does not build (a sibling
	// repository's, built by a ShellBuild): a service with a port is taken to
	// serve RPCs, since forge cannot read its mounts.
	ServesRPCDeclared bool `json:"servesRpcDeclared,omitempty"`
	// NonGo is set for a process forge can tell is not a Go program of this
	// project or its siblings (a third-party or Docker-built image): it has no
	// Go runtime metrics and no RPC metrics to draw.
	NonGo bool `json:"nonGo,omitempty"`
	// Replaces are the names (dashboard ids minus "process-") this process
	// was known by before dashboards were named for the workload.
	Replaces []string `json:"replaces,omitempty"`
}

type ProcessPart struct {
	Version       string        `json:"version"`
	Process       Process       `json:"process"`
	Dashboard     Dashboard     `json:"dashboard"`
	SavedSearches []SavedSearch `json:"savedSearches"`
}

type ProjectPart struct {
	// Input retains reusable generation fragments; selected-env assembly fills
	// Processes from rendered KCL, never from stale disk process parts.
	Input      *Fragments  `json:"input,omitempty"`
	Version    string      `json:"version"`
	Project    string      `json:"project"`
	Overview   Dashboard   `json:"overview"`
	Dashboards []Dashboard `json:"dashboards"`
}

type Rendered struct {
	File    string
	Content []byte
}

type SavedSearch struct {
	ID      string      `json:"id"`
	Title   string      `json:"title"`
	Signal  Signal      `json:"signal"`
	Where   []Predicate `json:"where"`
	Columns []string    `json:"columns,omitempty"`
}

type Section = dashspec.Section

type Series = dashspec.Series

type Service struct {
	// Name is the short service name used in file names and titles
	// ("orders").
	Name string
	// Package is the proto package ("orders.v1"); ProtoService the proto
	// service name ("OrdersService"). Together they give the procedure
	// "orders.v1.OrdersService/GetOrder" the RPC interceptors name spans by.
	Package      string
	ProtoService string
	Methods      []Method
}

type Signal = dashspec.Signal

type Spec struct {
	Version       string        `json:"version"`
	Project       string        `json:"project"`
	Dashboards    []Dashboard   `json:"dashboards"`
	SavedSearches []SavedSearch `json:"savedSearches"`
}

type Thresholds = dashspec.Thresholds

type Unit = dashspec.Unit