metrics

package
v0.15.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 9, 2026 License: Apache-2.0 Imports: 23 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CPUUsage 

type CPUUsage struct {
	Log    *slog.Logger
	Writer *VictoriaMetricsWriter
	Reader *VictoriaMetricsReader
	// contains filtered or unexported fields
}

func NewCPUUsage added in v0.3.0 

func NewCPUUsage(log *slog.Logger, writer *VictoriaMetricsWriter, reader *VictoriaMetricsReader) *CPUUsage

NewCPUUsage creates a new CPUUsage with the given dependencies. Writer and Reader can be nil for environments without metrics collection.

func (*CPUUsage) CPUUsageDayAgo 

func (m *CPUUsage) CPUUsageDayAgo(entity string, day units.Days) (float64, error)

Returns the cpu usage in cores for the given entity for a specific day in the past

func (*CPUUsage) CPUUsageLastHour 

func (m *CPUUsage) CPUUsageLastHour(entity string) ([]UsageAtTime, error)

func (*CPUUsage) CPUUsageOver 

func (m *CPUUsage) CPUUsageOver(entity string, interval string) (float64, error)

Returns the cpu usage in cores for the given entity over a given interval

func (*CPUUsage) CPUUsageOverDay 

func (m *CPUUsage) CPUUsageOverDay(entity string) (float64, error)

func (*CPUUsage) CPUUsageOverLastHour 

func (m *CPUUsage) CPUUsageOverLastHour(entity string) (float64, error)

func (*CPUUsage) CurrentCPUUsage 

func (m *CPUUsage) CurrentCPUUsage(entity string) (float64, error)

Returns the cpu usage in cores for the given entity in the last minute

func (*CPUUsage) RecordUsage 

func (m *CPUUsage) RecordUsage(ctx context.Context, entity string, windowStart, windowEnd time.Time, cpuUsec units.Microseconds, attrs map[string]string) error

func (*CPUUsage) Setup 

func (m *CPUUsage) Setup() error

type Data 

type Data struct {
	ResultType string   `json:"resultType"`
	Result     []Result `json:"result"`
}

type ErrorBreakdown 

type ErrorBreakdown struct {
	StatusCode int
	Count      int64
	Percentage float64
}

ErrorBreakdown represents error counts by status code

type HTTPMetrics 

type HTTPMetrics struct {
	Log    *slog.Logger
	Writer *VictoriaMetricsWriter
	Reader *VictoriaMetricsReader
	// contains filtered or unexported fields
}

HTTPMetrics tracks HTTP request metrics for applications using VictoriaMetrics

func NewHTTPMetrics added in v0.3.0 

func NewHTTPMetrics(log *slog.Logger, writer *VictoriaMetricsWriter, reader *VictoriaMetricsReader) *HTTPMetrics

NewHTTPMetrics creates a new HTTPMetrics with the given dependencies. Writer and Reader can be nil for environments without metrics collection.

func (*HTTPMetrics) Close 

func (h *HTTPMetrics) Close() error

Close is a no-op for VictoriaMetrics (writer handles its own lifecycle)

func (*HTTPMetrics) ErrorsLastHour 

func (h *HTTPMetrics) ErrorsLastHour(app string) ([]ErrorBreakdown, error)

ErrorsLastHour returns breakdown of errors by status code for the last hour

func (*HTTPMetrics) RPSLastMinute 

func (h *HTTPMetrics) RPSLastMinute(app string) (float64, error)

RPSLastMinute returns requests per second for the last minute

func (*HTTPMetrics) RecordRequest 

func (h *HTTPMetrics) RecordRequest(ctx context.Context, req HTTPRequest) error

RecordRequest records an HTTP request as metrics in VictoriaMetrics.

Only maxPathBoundCounters counters are kept for real paths. Anything beyond that is still counted, but reported with path and method "other", so an app serving unique URLs -- or a client walking random ones -- costs a fixed amount of memory here and a fixed number of series downstream.

func (*HTTPMetrics) Setup 

func (h *HTTPMetrics) Setup() error

func (*HTTPMetrics) StatsLastHour 

func (h *HTTPMetrics) StatsLastHour(app string) ([]RequestStats, error)

StatsLastHour returns request statistics for the last hour in 1-minute buckets

func (*HTTPMetrics) TopPaths 

func (h *HTTPMetrics) TopPaths(app string, limit int) ([]PathStats, error)

TopPaths returns the busiest paths for an app over the last recentMinutes.

Served from the in-process counters rather than from VictoriaMetrics. The query it replaced asked for topk by path and then issued two more queries per path for the average duration and the error rate, all of them reading the `path` label -- the same label the cardinality cap collapses to "other". So the cap and this view could not both be right. Reading the counters directly removes the conflict, and removes 1+2N round trips per `miren app status`.

Only this node's ingress traffic is counted. That is the whole cluster today, since the ingress runs on the coordinator alone; it stops being true the day runners serve ingress, and this has to aggregate across them then.

type HTTPRequest 

type HTTPRequest struct {
	Timestamp    time.Time
	App          string
	Method       string
	Path         string
	StatusCode   int
	DurationMs   int64
	ResponseSize int64
}

HTTPRequest represents a single HTTP request for metrics

type MemoryUsage 

type MemoryUsage struct {
	Log    *slog.Logger
	Writer *VictoriaMetricsWriter
	Reader *VictoriaMetricsReader
	// contains filtered or unexported fields
}

func NewMemoryUsage added in v0.3.0 

func NewMemoryUsage(log *slog.Logger, writer *VictoriaMetricsWriter, reader *VictoriaMetricsReader) *MemoryUsage

NewMemoryUsage creates a new MemoryUsage with the given dependencies. Writer and Reader can be nil for environments without metrics collection.

func (*MemoryUsage) RecordUsage 

func (m *MemoryUsage) RecordUsage(
	ctx context.Context,
	entity string,
	ts time.Time,
	memory units.Bytes,
	attrs map[string]string,
) error

func (*MemoryUsage) Setup 

func (m *MemoryUsage) Setup() error

func (*MemoryUsage) UsageLastHour 

func (m *MemoryUsage) UsageLastHour(entity string) ([]MemoryUsageAtTime, error)

type MemoryUsageAtTime 

type MemoryUsageAtTime struct {
	Timestamp time.Time
	Memory    units.Bytes
}

type MetricPoint 

type MetricPoint struct {
	Name      string
	Labels    map[string]string
	Value     float64
	Timestamp time.Time
}

MetricPoint represents a single metric data point

type NodeUsage added in v0.15.0 

type NodeUsage struct {
	Log    *slog.Logger
	Writer *VictoriaMetricsWriter

	// NodeID is the node entity ID these series describe, and RunnerID is the
	// runner identifier for the same host. Both are emitted: the entity ID is
	// what joins to the node record, the runner ID is what an operator typed.
	NodeID   string
	RunnerID string

	// DataPath is the filesystem whose capacity is reported. Empty skips the
	// storage series rather than reporting the root filesystem, which would be
	// a different disk on most real deployments.
	DataPath string
	// contains filtered or unexported fields
}

NodeUsage records what a whole host is doing, as opposed to what any single sandbox on it is doing.

Two questions need this. First, "how much of this machine is left?" -- a workload burning 200% of a core is unremarkable on a 64-core box and an emergency on a 2-core one, and nothing in the per-sandbox series says which box it is. Second, "is the load even an app?" -- containerd, buildkit, the registry, the log pipeline and miren itself run outside every sandbox cgroup, so they are invisible in the per-sandbox series. Subtracting the sum of sandbox usage from the host total is what surfaces them, and that subtraction needs a host total to start from.

Series are labeled by node so they join against the miren.node label the sandbox collectors now attach.

func NewNodeUsage added in v0.15.0 

func NewNodeUsage(log *slog.Logger, writer *VictoriaMetricsWriter, nodeID, runnerID, dataPath string) *NodeUsage

NewNodeUsage creates a NodeUsage collector. Writer may be nil for environments without metrics collection, in which case Monitor is a no-op.

func (*NodeUsage) Monitor added in v0.15.0 

func (n *NodeUsage) Monitor(ctx context.Context)

Monitor samples host stats every defaultNodeUsageInterval and pushes one batch of points per tick until ctx is cancelled. Mirrors the cadence and lifecycle of RuntimeMemory.Monitor.

type PathStats 

type PathStats struct {
	Path          string
	Count         int64
	AvgDurationMs float64
	ErrorRate     float64
}

PathStats represents statistics for a specific path

type QueryResult 

type QueryResult struct {
	Status string `json:"status"`
	Data   Data   `json:"data"`
}

QueryResult represents the result of a MetricsQL query

type RequestStats 

type RequestStats struct {
	Time          time.Time
	Count         int64
	AvgDurationMs float64
	P95DurationMs float64
	P99DurationMs float64
	ErrorRate     float64
}

RequestStats represents aggregated request statistics

type Result 

type Result struct {
	Metric map[string]string `json:"metric"`
	Value  []any             `json:"value,omitempty"`  // For instant queries: [timestamp, value_string]
	Values [][]any           `json:"values,omitempty"` // For range queries: [[timestamp, value_string], ...]
}

type RuntimeMemory added in v0.11.1 

type RuntimeMemory struct {
	Log    *slog.Logger
	Writer *VictoriaMetricsWriter

	// Entity is the value of the "entity" label on every emitted series.
	Entity string
}

RuntimeMemory collects Go runtime memory stats for the miren control process itself and pushes them to VictoriaMetrics in the same push-only style as the per-sandbox collectors (MemoryUsage/CPUUsage). The control process is not covered by any per-sandbox cgroup, so today there is no visibility into the coordinator's own heap/RSS growth — these series are that visibility.

All series carry entity="miren/control" so they sit alongside the per-app memory_usage_bytes{entity="app/..."} series and can be compared directly. The key diagnostic is the gap between process_resident_memory_bytes (the whole control process, including off-heap: cgo, mmap'd bbolt/etcd, the buildkit content store) and go_mem_heap_inuse_bytes (Go-managed heap only):

  • both balloon together -> Go heap; a pprof heap profile names the site.
  • RSS balloons, heap flat -> off-heap; pprof can't see it, look at bbolt/buildkit.

func NewRuntimeMemory added in v0.11.1 

func NewRuntimeMemory(log *slog.Logger, writer *VictoriaMetricsWriter) *RuntimeMemory

NewRuntimeMemory creates a RuntimeMemory collector. Writer may be nil for environments without metrics collection, in which case Monitor is a no-op.

func (*RuntimeMemory) Monitor added in v0.11.1 

func (r *RuntimeMemory) Monitor(ctx context.Context)

Monitor samples runtime memory every defaultRuntimeMemoryInterval and pushes one batch of points per tick until ctx is cancelled. Mirrors the cadence and lifecycle of (*sandbox.Metrics).Monitor.

type TimeSeriesPoint 

type TimeSeriesPoint struct {
	Timestamp time.Time
	Value     float64
}

TimeSeriesPoint represents a single point in a time series

type UsageAtTime 

type UsageAtTime struct {
	Timestamp time.Time
	Cores     float64
}

type VictoriaMetricsReader 

type VictoriaMetricsReader struct {
	Log     *slog.Logger
	Address string
	Timeout time.Duration
	// contains filtered or unexported fields
}

VictoriaMetricsReader reads metrics from VictoriaMetrics using MetricsQL

func NewVictoriaMetricsReader 

func NewVictoriaMetricsReader(log *slog.Logger, address string, timeout time.Duration) *VictoriaMetricsReader

NewVictoriaMetricsReader creates a new VictoriaMetrics reader

func (*VictoriaMetricsReader) GetAverage 

func (r *VictoriaMetricsReader) GetAverage(ctx context.Context, metricName string, labels map[string]string, window string) (float64, error)

GetAverage calculates the average value over time

func (*VictoriaMetricsReader) GetLatestValue 

func (r *VictoriaMetricsReader) GetLatestValue(ctx context.Context, metricName string, labels map[string]string) (float64, error)

GetLatestValue retrieves the latest value for a metric

func (*VictoriaMetricsReader) GetQuantile 

func (r *VictoriaMetricsReader) GetQuantile(ctx context.Context, quantile float64, metricName string, labels map[string]string, window string) (float64, error)

GetQuantile calculates a quantile over time

func (*VictoriaMetricsReader) GetRate 

func (r *VictoriaMetricsReader) GetRate(ctx context.Context, metricName string, labels map[string]string, window string) (float64, error)

GetRate calculates the rate of a counter metric over a time range

func (*VictoriaMetricsReader) GetTimeSeries 

func (r *VictoriaMetricsReader) GetTimeSeries(ctx context.Context, metricName string, labels map[string]string, start, end time.Time, step string) ([]TimeSeriesPoint, error)

GetTimeSeries retrieves time series data for a metric over a time range

func (*VictoriaMetricsReader) InstantQuery 

func (r *VictoriaMetricsReader) InstantQuery(ctx context.Context, query string, ts time.Time) (*QueryResult, error)

InstantQuery executes an instant MetricsQL query (point-in-time)

func (*VictoriaMetricsReader) RangeQuery 

func (r *VictoriaMetricsReader) RangeQuery(ctx context.Context, query string, start, end time.Time, step string) (*QueryResult, error)

RangeQuery executes a range MetricsQL query (time series)

type VictoriaMetricsWriter 

type VictoriaMetricsWriter struct {
	Log     *slog.Logger
	Address string // e.g., "localhost:8428"
	Timeout time.Duration
	// contains filtered or unexported fields
}

VictoriaMetricsWriter writes metrics to VictoriaMetrics using the import API

func NewVictoriaMetricsWriter 

func NewVictoriaMetricsWriter(log *slog.Logger, address string, timeout time.Duration, opts ...WriterOption) *VictoriaMetricsWriter

NewVictoriaMetricsWriter creates a new VictoriaMetrics writer

func (*VictoriaMetricsWriter) Close 

func (w *VictoriaMetricsWriter) Close() error

Close stops the background flush routine and flushes remaining data

func (*VictoriaMetricsWriter) Flush 

func (w *VictoriaMetricsWriter) Flush()

Flush manually triggers a flush of buffered metrics

func (*VictoriaMetricsWriter) Start 

func (w *VictoriaMetricsWriter) Start()

Start begins the background flush routine. It is idempotent and safe to call multiple times.

func (*VictoriaMetricsWriter) WritePoint 

func (w *VictoriaMetricsWriter) WritePoint(ctx context.Context, point MetricPoint) error

WritePoint adds a metric point to the buffer

func (*VictoriaMetricsWriter) WritePoints 

func (w *VictoriaMetricsWriter) WritePoints(ctx context.Context, points []MetricPoint) error

WritePoints adds multiple metric points to the buffer

type WriterOption added in v0.13.0 

type WriterOption func(*VictoriaMetricsWriter)

WriterOption customizes a VictoriaMetricsWriter at construction.

func WithHTTPClient added in v0.13.0 

func WithHTTPClient(client *http.Client) WriterOption

WithHTTPClient replaces the writer's default HTTP client.

Callers that cannot reach VictoriaMetrics with a plain client supply their own. A distributed runner ships metrics through the coordinator rather than dialing VictoriaMetrics directly, which means an HTTP/3 transport carrying a credential. Putting that in the client's RoundTripper keeps this writer unaware of how it is authenticated, so the credential has one home rather than being threaded through every send.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.