Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
11 changes: 7 additions & 4 deletions internal/dashboard/defaults_sql.go
Original file line number Diff line number Diff line change
Expand Up @@ -57,7 +57,8 @@ func capacityCTE(containers bool) string {
entity = "to_json([host,container_id])::VARCHAR"
priority = "CASE name WHEN 'container.cpu.utilization' THEN 1 WHEN 'container.memory.usage.total' THEN 2 ELSE 3 END"
}
return `WITH raw AS (SELECT *,resource['host.name']::VARCHAR AS host,resource['container.id']::VARCHAR AS container_id,
return `WITH raw AS MATERIALIZED (SELECT series_id,ingested_unix_nano,namespace,time,value,type,name,start_time,temporality,unit,
resource['host.name']::VARCHAR AS host,resource['container.id']::VARCHAR AS container_id,
resource['container.name']::VARCHAR AS container_name,attributes['state']::VARCHAR AS state,
attributes['mountpoint']::VARCHAR AS mountpoint,attributes['device']::VARCHAR AS device
FROM metrics WHERE time >= make_timestamp_ns(epoch_ns($__from::TIMESTAMP_NS)-600000000000)::TIMESTAMPTZ_NS AND time < $__to::TIMESTAMP_NS::TIMESTAMPTZ_NS AND name IN (` + names + `)),
Expand Down Expand Up @@ -106,6 +107,8 @@ func containerCapacitySQL() string {
FROM results ORDER BY (reporting<>'reporting') DESC,status DESC NULLS LAST,namespace,host,container`
}

const versionObservationsSQL = `SELECT namespace,service,resource['service.version']::VARCHAR AS version,resource['process.runtime.name']::VARCHAR AS runtime_name,resource['process.runtime.version']::VARCHAR AS runtime_version,resource['telemetry.sdk.language']::VARCHAR AS sdk_language,resource['telemetry.sdk.version']::VARCHAR AS sdk_version,start_time AS seen FROM spans WHERE $__window(start_time)
UNION ALL SELECT namespace,service,resource['service.version']::VARCHAR,resource['process.runtime.name']::VARCHAR,resource['process.runtime.version']::VARCHAR,resource['telemetry.sdk.language']::VARCHAR,resource['telemetry.sdk.version']::VARCHAR,time FROM logs WHERE $__window(time)
UNION ALL SELECT namespace,service,resource['service.version']::VARCHAR,resource['process.runtime.name']::VARCHAR,resource['process.runtime.version']::VARCHAR,resource['telemetry.sdk.language']::VARCHAR,resource['telemetry.sdk.version']::VARCHAR,time FROM metrics WHERE $__window(time)`
const versionObservationsSQL = `WITH resources AS MATERIALIZED (
SELECT namespace,service,resource,min(start_time) AS seen FROM spans WHERE $__window(start_time) GROUP BY namespace,service,resource
UNION ALL SELECT namespace,service,resource,min(time) AS seen FROM logs WHERE $__window(time) GROUP BY namespace,service,resource
UNION ALL SELECT namespace,service,resource,min(time) AS seen FROM metrics WHERE $__window(time) GROUP BY namespace,service,resource)
SELECT namespace,service,resource['service.version']::VARCHAR AS version,resource['process.runtime.name']::VARCHAR AS runtime_name,resource['process.runtime.version']::VARCHAR AS runtime_version,resource['telemetry.sdk.language']::VARCHAR AS sdk_language,resource['telemetry.sdk.version']::VARCHAR AS sdk_version,seen FROM resources`
213 changes: 213 additions & 0 deletions internal/dashboard/defaults_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@ package dashboard

import (
"fmt"
"math"
"reflect"
"strings"
"testing"
Expand Down Expand Up @@ -201,3 +202,215 @@ func TestDefaultSystemPanelsShowCapacitySilenceVantageAndVersions(t *testing.T)
}
}
}

func TestDefaultVersionsPreserveFirstSeenAndRuntimeSDKTuples(t *testing.T) {
e, repo := defaultFixture(t)
start := time.Date(2026, 10, 1, 12, 0, 0, 0, time.UTC)
end := start.Add(2 * time.Minute)
base := map[string]any{"service.version": "v1", "process.runtime.name": "Go", "process.runtime.version": "1.27", "telemetry.sdk.language": "go", "telemetry.sdk.version": "1.40"}
keys := []string{"process.runtime.name", "process.runtime.version", "telemetry.sdk.language", "telemetry.sdk.version"}
alternatives := []string{"Other", "1.28", "other", "1.41"}
var spans []telemetry.Span
var logs []telemetry.Log
var metrics []telemetry.Metric
var want [][]any
for i := 0; i < 8; i++ {
resource := make(map[string]any)
for k, v := range base {
resource[k] = v
}
if i >= 1 && i <= 4 {
resource[keys[i-1]] = alternatives[i-1]
}
if i == 5 {
for _, k := range keys {
delete(resource, k)
}
}
namespace, service := "test", "svc"
if i == 6 {
namespace = "other"
}
if i == 7 {
service = "other"
}
first := start.Add(time.Duration(i) * time.Second)
want = append([][]any{{namespace, service, "v1", first.UnixMilli(), resource[keys[0]], resource[keys[1]], resource[keys[2]], resource[keys[3]]}}, want...)
// The earliest signal rotates. Every signal repeats the same resource,
// and an unrelated resource field must not split the final version row.
for j, offset := range []time.Duration{30 * time.Second, 0, 20 * time.Second} {
for signal := 0; signal < 3; signal++ {
at := first.Add(offset + time.Duration((signal+i)%3)*time.Second)
r := resource
if j == 2 {
r = make(map[string]any)
for k, v := range resource {
r[k] = v
}
r["host.name"] = "another host"
}
switch signal {
case 0:
spans = append(spans, telemetry.Span{Namespace: namespace, ServiceName: service, TraceID: fmt.Sprintf("trace-%d-%d", i, j), SpanID: "span", StartUnixNanos: at.UnixNano(), EndUnixNanos: at.Add(time.Millisecond).UnixNano(), Resource: r})
case 1:
logs = append(logs, telemetry.Log{Namespace: namespace, ServiceName: service, TimeUnixNanos: at.UnixNano(), EventUnixNanos: at.UnixNano(), Resource: r})
case 2:
m := telemetry.Metric{Namespace: namespace, ServiceName: service, Name: "version", Type: "gauge", Value: 1, TimeUnixNanos: at.UnixNano(), EventUnixNanos: at.UnixNano(), Resource: r}
m.SeriesID = telemetry.MetricSeriesID(m)
metrics = append(metrics, m)
}
}
}
}
// Out-of-window observations must not lower first_seen or add a row.
for _, at := range []time.Time{start.Add(-time.Nanosecond), end} {
resource := base
if at.Equal(end) {
resource = map[string]any{"service.version": "outside"}
}
spans = append(spans, telemetry.Span{Namespace: "test", ServiceName: "svc", TraceID: at.String(), SpanID: "boundary", StartUnixNanos: at.UnixNano(), EndUnixNanos: at.Add(time.Millisecond).UnixNano(), Resource: resource})
logs = append(logs, telemetry.Log{Namespace: "test", ServiceName: "svc", TimeUnixNanos: at.UnixNano(), EventUnixNanos: at.UnixNano(), Resource: resource})
m := telemetry.Metric{Namespace: "test", ServiceName: "svc", Name: "version", Type: "gauge", Value: 1, TimeUnixNanos: at.UnixNano(), EventUnixNanos: at.UnixNano(), Resource: resource}
m.SeriesID = telemetry.MetricSeriesID(m)
metrics = append(metrics, m)
}
if err := repo.Commit(t.Context(), telemetrystore.Batch{ID: "version-tuples", Spans: spans, Logs: logs, Metrics: metrics}); err != nil {
t.Fatal(err)
}
spec := DefaultSpec()
spec.Time = panel.Time{From: &start, To: &end}
results, err := e.Run(t.Context(), panel.RunRequest{Dashboard: spec, Panels: []string{"versions"}})
if err != nil {
t.Fatal(err)
}
result := results[0]
columns := []string{"namespace", "service", "version", "first_seen", "runtime_name", "runtime_version", "sdk_language", "sdk_version"}
for col, name := range columns {
var values []any
for _, row := range want {
values = append(values, row[col])
}
if got := defaultValues(t, result, name); !reflect.DeepEqual(got, values) {
t.Fatalf("%s: got %v, want %v", name, got, values)
}
}
}

func TestDefaultCapacityPreservesRetriesCountersNamespacesAndFreshness(t *testing.T) {
e, repo := defaultFixture(t)
start := time.Date(2026, 10, 1, 12, 0, 0, 0, time.UTC)
for i, offset := range []time.Duration{-time.Minute, 0, time.Minute} {
at := start.Add(offset)
var metrics []telemetry.Metric
for _, namespace := range []string{"alpha", "beta"} {
metric := func(name string, value float64, attrs map[string]any) telemetry.Metric {
return telemetry.Metric{Namespace: namespace, Name: name, Type: "gauge", Unit: "1", Value: value, Attributes: attrs, Resource: map[string]any{"host.name": "shared", "container.id": "shared-id"}, TimeUnixNanos: at.UnixNano(), EventUnixNanos: at.UnixNano(), IngestedAt: at.UnixNano()}
}
for _, state := range []string{"idle", "user"} {
// Alpha's cumulative counter resets at the last point. Beta
// reports deltas, so its last interval must use the point value.
value := []float64{100, 160, 10}[i]
if state == "user" {
value = []float64{100, 280, 30}[i]
}
if namespace == "beta" {
value = 30
if state == "user" {
value = 10
}
}
m := metric("system.cpu.time", value, map[string]any{"state": state})
m.Type, m.Monotonic, m.Temporality, m.Unit = "sum", true, "cumulative", "s"
if namespace == "beta" {
m.Temporality, m.StartTimeUnixNanos = "delta", at.Add(-time.Minute).UnixNano()
}
metrics = append(metrics, m)
}
if offset < 0 {
continue
}
used := 80.0
if namespace == "beta" {
used = 20
}
metrics = append(metrics,
metric("system.memory.usage", used, map[string]any{"state": "used"}),
metric("system.memory.usage", 100-used, map[string]any{"state": "free"}),
metric("container.cpu.utilization", used/100, nil),
metric("container.memory.usage.total", used, nil),
metric("container.memory.usage.limit", 100, nil))
// Missing host/container identities must not become extra entities.
missingHost := metric("system.memory.usage", 999, nil)
missingHost.Resource = map[string]any{"container.id": "orphan"}
missingContainer := metric("container.cpu.utilization", 999, nil)
missingContainer.Resource = map[string]any{"host.name": "shared"}
metrics = append(metrics, missingHost, missingContainer)
}
for j := range metrics {
metrics[j].SeriesID = telemetry.MetricSeriesID(metrics[j])
}
// Retry copies live in another immutable file. Older ingestions lose
// even with a larger value; equal ingestions use descending value.
var retries, tiedPoints []telemetry.Metric
for _, m := range metrics {
older := m
older.Value = 9999
tied := m
tied.Value = 0
retries = append(retries, older)
tiedPoints = append(tiedPoints, tied)
}
// Commit assigns ingestion timestamps per batch, so publish old copies
// first and publish equal-ingestion copies with the real points.
for j, points := range [][]telemetry.Metric{retries, append(metrics, tiedPoints...)} {
if err := repo.Commit(t.Context(), telemetrystore.Batch{ID: fmt.Sprintf("capacity-%d-%d", i, j), Metrics: points}); err != nil {
t.Fatal(err)
}
}
}
for _, offset := range []time.Duration{2 * time.Minute, 3*time.Minute - time.Nanosecond, 3 * time.Minute, 6 * time.Minute, 6*time.Minute + time.Nanosecond} {
end := start.Add(offset)
spec := DefaultSpec()
spec.Time = panel.Time{From: &start, To: &end}
results, err := e.Run(t.Context(), panel.RunRequest{Dashboard: spec, Panels: []string{"hosts", "containers"}})
if err != nil {
t.Fatal(err)
}
for _, result := range results {
if got := defaultValues(t, result, "namespace"); !reflect.DeepEqual(got, []any{"alpha", "beta"}) {
t.Fatalf("%s at %s: namespaces %v", result.ID, offset, got)
}
state := "reporting"
if offset >= 3*time.Minute {
state = "not reporting"
if got := defaultValues(t, result, "status"); !reflect.DeepEqual(got, []any{100.0, 100.0}) {
t.Fatalf("%s at %s: status %v", result.ID, offset, got)
}
}
if got := defaultValues(t, result, "reporting"); !reflect.DeepEqual(got, []any{state, state}) {
t.Fatalf("%s at %s: reporting %v", result.ID, offset, got)
}
cpu := []any{75.0, 25.0}
if result.ID == "containers" {
cpu = []any{80.0, 20.0}
}
memory := []any{80.0, 20.0}
if offset > 6*time.Minute {
cpu, memory = []any{nil, nil}, []any{nil, nil}
}
for column, want := range map[string][]any{"cpu_percent": cpu, "memory_percent": memory} {
got := defaultValues(t, result, column)
for i, expected := range want {
if number, ok := expected.(float64); ok {
if value, ok := got[i].(float64); ok && math.Abs(value-number) <= 1e-12 {
continue
}
} else if got[i] == expected {
continue
}
t.Fatalf("%s at %s: %s got %v, want %v", result.ID, offset, column, got, want)
}
}
}
}
}
Loading