updated ui for 23x

.gitattributes

@@ -0,0 +1 @@
+pkg/server/static/vendor/** linguist-vendored

README.md

@@ -200,7 +200,7 @@ Set `skip_verify` to `true` to support locally signed certificates.
 
 Sends DNS queries to a specific server and validates each answer against an expected value. Supports A, AAAA, and PTR record types. Each query produces a separate data source in the RRD, rendered as colored lines on the graph. The check succeeds only if all configured queries resolve and every answer matches its expected value.
 
-PTR query names must be provided in reverse notation (e.g. `1.73.168.192.in-addr.arpa`). Expected PTR values may include or omit the trailing dot — both forms are accepted.
+PTR query names must be provided in reverse notation (e.g. `1.168.168.192.in-addr.arpa`). Expected PTR values may include or omit the trailing dot — both forms are accepted.
 
 | Option    | Type           | Default      | Description                                          |
 | --------- | -------------- | ------------ | ---------------------------------------------------- |

pkg/check/dns/dns.go

@@ -112,12 +112,9 @@ func (c *Check) Describe() check.Descriptor {
 // Success requires every query to resolve and every answer to match its expected value.
 // Each query's RTT is stored in microseconds keyed by the query name.
 func (c *Check) Run(ctx context.Context) check.Result {
-	result := check.Result{
-		Timestamp: time.Now(),
-		Metrics:   make(map[string]int64),
-	}
-
+	metrics := make(map[string]*int64, len(c.queries))
 	var lastErr error
+	succeeded := 0
 
 	for _, q := range c.queries {
 		msg := new(dns.Msg)
@@ -127,30 +124,33 @@ func (c *Check) Run(ctx context.Context) check.Result {
 		resp, rtt, err := c.client.ExchangeContext(ctx, msg, c.server)
 		if err != nil {
 			lastErr = fmt.Errorf("dns %s %s: %w", qtypeName(q.qtype), q.name, err)
+			metrics[q.resultKey] = nil
 			continue
 		}
 
 		if resp.Rcode != dns.RcodeSuccess {
 			lastErr = fmt.Errorf("dns %s %s: rcode %s", qtypeName(q.qtype), q.name, dns.RcodeToString[resp.Rcode])
+			metrics[q.resultKey] = nil
 			continue
 		}
 
 		if err := validateAnswer(resp.Answer, q.qtype, q.expect); err != nil {
 			lastErr = fmt.Errorf("dns %s %s: %w", qtypeName(q.qtype), q.name, err)
+			metrics[q.resultKey] = nil
 			continue
 		}
 
-		result.Metrics[q.resultKey] = rtt.Microseconds()
+		v := rtt.Microseconds()
+		metrics[q.resultKey] = &v
+		succeeded++
 	}
 
-	if len(result.Metrics) == len(c.queries) {
-		result.Success = true
-	} else {
-		result.Success = false
-		result.Err = lastErr
+	return check.Result{
+		Timestamp: time.Now(),
+		Success:   succeeded == len(c.queries),
+		Err:       lastErr,
+		Metrics:   metrics,
 	}
-
-	return result
 }
 
 // validateAnswer checks that at least one RR in the answer section matches

pkg/check/dns/dns_test.go

@@ -84,7 +84,7 @@ func TestNew_WithTimeoutZero(t *testing.T) {
 
 func TestDescribe_SingleQuery(t *testing.T) {
 	queries := []queryConfig{
-		{name: "router.risse.tv", qtype: dns.TypeA, expect: "192.168.73.1", resultKey: "router.risse.tv", dsName: "q0"},
+		{name: "router.example.com", qtype: dns.TypeA, expect: "192.168.168.1", resultKey: "router.example.com", dsName: "q0"},
 	}
 	chk, err := New("127.0.0.1:53", queries)
 	if err != nil {
@@ -101,8 +101,8 @@ func TestDescribe_SingleQuery(t *testing.T) {
 	if m.DSName != "q0" {
 		t.Errorf("expected DSName 'q0', got %q", m.DSName)
 	}
-	if m.ResultKey != "router.risse.tv" {
-		t.Errorf("expected ResultKey 'router.risse.tv', got %q", m.ResultKey)
+	if m.ResultKey != "router.example.com" {
+		t.Errorf("expected ResultKey 'router.example.com', got %q", m.ResultKey)
 	}
 	if m.Unit != "ms" {
 		t.Errorf("expected Unit 'ms', got %q", m.Unit)
@@ -403,9 +403,9 @@ func TestNormalizeFQDN_WithoutDot(t *testing.T) {
 
 func TestValidateAnswer_AMatch(t *testing.T) {
 	rrs := []dns.RR{
-		&dns.A{Hdr: dns.RR_Header{Rrtype: dns.TypeA}, A: net.ParseIP("192.168.73.1")},
+		&dns.A{Hdr: dns.RR_Header{Rrtype: dns.TypeA}, A: net.ParseIP("192.168.168.1")},
 	}
-	if err := validateAnswer(rrs, dns.TypeA, "192.168.73.1"); err != nil {
+	if err := validateAnswer(rrs, dns.TypeA, "192.168.168.1"); err != nil {
 		t.Errorf("expected match, got: %v", err)
 	}
 }
@@ -414,7 +414,7 @@ func TestValidateAnswer_ANoMatch(t *testing.T) {
 	rrs := []dns.RR{
 		&dns.A{Hdr: dns.RR_Header{Rrtype: dns.TypeA}, A: net.ParseIP("10.0.0.1")},
 	}
-	if err := validateAnswer(rrs, dns.TypeA, "192.168.73.1"); err == nil {
+	if err := validateAnswer(rrs, dns.TypeA, "192.168.168.1"); err == nil {
 		t.Error("expected mismatch error")
 	}
 }
@@ -430,18 +430,18 @@ func TestValidateAnswer_AAAAMatch(t *testing.T) {
 
 func TestValidateAnswer_PTRMatchWithTrailingDot(t *testing.T) {
 	rrs := []dns.RR{
-		&dns.PTR{Hdr: dns.RR_Header{Rrtype: dns.TypePTR}, Ptr: "router.risse.tv."},
+		&dns.PTR{Hdr: dns.RR_Header{Rrtype: dns.TypePTR}, Ptr: "router.example.com."},
 	}
-	if err := validateAnswer(rrs, dns.TypePTR, "router.risse.tv."); err != nil {
+	if err := validateAnswer(rrs, dns.TypePTR, "router.example.com."); err != nil {
 		t.Errorf("expected match, got: %v", err)
 	}
 }
 
 func TestValidateAnswer_PTRMatchWithoutTrailingDot(t *testing.T) {
 	rrs := []dns.RR{
-		&dns.PTR{Hdr: dns.RR_Header{Rrtype: dns.TypePTR}, Ptr: "router.risse.tv."},
+		&dns.PTR{Hdr: dns.RR_Header{Rrtype: dns.TypePTR}, Ptr: "router.example.com."},
 	}
-	if err := validateAnswer(rrs, dns.TypePTR, "router.risse.tv"); err != nil {
+	if err := validateAnswer(rrs, dns.TypePTR, "router.example.com"); err != nil {
 		t.Errorf("expected match regardless of trailing dot, got: %v", err)
 	}
 }
@@ -469,13 +469,13 @@ func TestRun_AQuery_Success(t *testing.T) {
 		m.SetReply(r)
 		m.Answer = append(m.Answer, &dns.A{
 			Hdr: dns.RR_Header{Name: r.Question[0].Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 60},
-			A:   net.ParseIP("192.168.73.1"),
+			A:   net.ParseIP("192.168.168.1"),
 		})
 		_ = w.WriteMsg(m)
 	})
 
 	queries := []queryConfig{
-		{name: "router.risse.tv", qtype: dns.TypeA, expect: "192.168.73.1", resultKey: "router.risse.tv", dsName: "q0"},
+		{name: "router.example.com", qtype: dns.TypeA, expect: "192.168.168.1", resultKey: "router.example.com", dsName: "q0"},
 	}
 	chk, err := New(addr, queries)
 	if err != nil {
@@ -486,8 +486,8 @@ func TestRun_AQuery_Success(t *testing.T) {
 	if !result.Success {
 		t.Errorf("expected success, got failure: %v", result.Err)
 	}
-	if result.Metrics["router.risse.tv"] <= 0 {
-		t.Errorf("expected positive RTT, got %d", result.Metrics["router.risse.tv"])
+	if p := result.Metrics["router.example.com"]; p == nil || *p <= 0 {
+		t.Errorf("expected positive RTT, got %v", result.Metrics["router.example.com"])
 	}
 	if result.Timestamp.IsZero() {
 		t.Error("expected non-zero timestamp")
@@ -500,13 +500,13 @@ func TestRun_PTRQuery_Success(t *testing.T) {
 		m.SetReply(r)
 		m.Answer = append(m.Answer, &dns.PTR{
 			Hdr: dns.RR_Header{Name: r.Question[0].Name, Rrtype: dns.TypePTR, Class: dns.ClassINET, Ttl: 60},
-			Ptr: "router.risse.tv.",
+			Ptr: "router.example.com.",
 		})
 		_ = w.WriteMsg(m)
 	})
 
 	queries := []queryConfig{
-		{name: "1.73.168.192.in-addr.arpa", qtype: dns.TypePTR, expect: "router.risse.tv.", resultKey: "1.73.168.192.in-addr.arpa", dsName: "q0"},
+		{name: "1.168.168.192.in-addr.arpa", qtype: dns.TypePTR, expect: "router.example.com.", resultKey: "1.168.168.192.in-addr.arpa", dsName: "q0"},
 	}
 	chk, err := New(addr, queries)
 	if err != nil {
@@ -552,20 +552,20 @@ func TestRun_MultipleQueries_AllSuccess(t *testing.T) {
 		case dns.TypeA:
 			m.Answer = append(m.Answer, &dns.A{
 				Hdr: dns.RR_Header{Name: r.Question[0].Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 60},
-				A:   net.ParseIP("192.168.73.1"),
+				A:   net.ParseIP("192.168.168.1"),
 			})
 		case dns.TypePTR:
 			m.Answer = append(m.Answer, &dns.PTR{
 				Hdr: dns.RR_Header{Name: r.Question[0].Name, Rrtype: dns.TypePTR, Class: dns.ClassINET, Ttl: 60},
-				Ptr: "router.risse.tv.",
+				Ptr: "router.example.com.",
 			})
 		}
 		_ = w.WriteMsg(m)
 	})
 
 	queries := []queryConfig{
-		{name: "router.risse.tv", qtype: dns.TypeA, expect: "192.168.73.1", resultKey: "router.risse.tv", dsName: "q0"},
-		{name: "1.73.168.192.in-addr.arpa", qtype: dns.TypePTR, expect: "router.risse.tv.", resultKey: "1.73.168.192.in-addr.arpa", dsName: "q1"},
+		{name: "router.example.com", qtype: dns.TypeA, expect: "192.168.168.1", resultKey: "router.example.com", dsName: "q0"},
+		{name: "1.168.168.192.in-addr.arpa", qtype: dns.TypePTR, expect: "router.example.com.", resultKey: "1.168.168.192.in-addr.arpa", dsName: "q1"},
 	}
 	chk, err := New(addr, queries)
 	if err != nil {
@@ -593,7 +593,7 @@ func TestRun_WrongAnswer_Failure(t *testing.T) {
 	})
 
 	queries := []queryConfig{
-		{name: "router.risse.tv", qtype: dns.TypeA, expect: "192.168.73.1", resultKey: "router.risse.tv", dsName: "q0"},
+		{name: "router.example.com", qtype: dns.TypeA, expect: "192.168.168.1", resultKey: "router.example.com", dsName: "q0"},
 	}
 	chk, err := New(addr, queries)
 	if err != nil {
@@ -640,7 +640,7 @@ func TestRun_PartialSuccess_Failure(t *testing.T) {
 		if call == 1 {
 			m.Answer = append(m.Answer, &dns.A{
 				Hdr: dns.RR_Header{Name: r.Question[0].Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 60},
-				A:   net.ParseIP("192.168.73.1"),
+				A:   net.ParseIP("192.168.168.1"),
 			})
 		} else {
 			m.Rcode = dns.RcodeNameError
@@ -649,7 +649,7 @@ func TestRun_PartialSuccess_Failure(t *testing.T) {
 	})
 
 	queries := []queryConfig{
-		{name: "router.risse.tv", qtype: dns.TypeA, expect: "192.168.73.1", resultKey: "router.risse.tv", dsName: "q0"},
+		{name: "router.example.com", qtype: dns.TypeA, expect: "192.168.168.1", resultKey: "router.example.com", dsName: "q0"},
 		{name: "missing.example.com", qtype: dns.TypeA, expect: "5.6.7.8", resultKey: "missing.example.com", dsName: "q1"},
 	}
 	chk, err := New(addr, queries)
@@ -661,8 +661,14 @@ func TestRun_PartialSuccess_Failure(t *testing.T) {
 	if result.Success {
 		t.Error("expected failure when one query fails")
 	}
-	if len(result.Metrics) != 1 {
-		t.Errorf("expected 1 successful metric, got %d", len(result.Metrics))
+	if len(result.Metrics) != 2 {
+		t.Errorf("expected 2 metrics (one nil, one non-nil), got %d", len(result.Metrics))
+	}
+	if result.Metrics["router.example.com"] == nil {
+		t.Error("expected non-nil metric for successful query")
+	}
+	if result.Metrics["missing.example.com"] != nil {
+		t.Error("expected nil metric for failed query")
 	}
 }
 

pkg/check/http/http.go

@@ -119,19 +119,17 @@ func (c *Check) Describe() check.Descriptor {
 
 // Run executes HTTP GET requests to all configured URLs and returns a Result.
 func (c *Check) Run(ctx context.Context) check.Result {
-	result := check.Result{
-		Timestamp: time.Now(),
-		Metrics:   make(map[string]int64),
-	}
-
+	metrics := make(map[string]*int64, len(c.urls))
 	var lastErr error
+	succeeded := 0
 
 	for _, url := range c.urls {
 		start := time.Now()
 
 		req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 		if err != nil {
 			lastErr = fmt.Errorf("failed to create request for %s: %w", url, err)
+			metrics[url] = nil
 			continue
 		}
 
@@ -140,21 +138,22 @@ func (c *Check) Run(ctx context.Context) check.Result {
 
 		if err != nil {
 			lastErr = fmt.Errorf("request to %s failed: %w", url, err)
+			metrics[url] = nil
 			continue
 		}
 		resp.Body.Close()
 
-		result.Metrics[url] = elapsed.Microseconds()
+		v := elapsed.Microseconds()
+		metrics[url] = &v
+		succeeded++
 	}
 
-	if len(result.Metrics) == len(c.urls) {
-		result.Success = true
-	} else {
-		result.Success = false
-		result.Err = lastErr
+	return check.Result{
+		Timestamp: time.Now(),
+		Success:   succeeded == len(c.urls),
+		Err:       lastErr,
+		Metrics:   metrics,
 	}
-
-	return result
 }
 
 // Factory creates an HTTP Check from a config map.

pkg/check/http/http_test.go

@@ -324,8 +324,8 @@ func TestRun_SingleURL_Success(t *testing.T) {
 	if !result.Success {
 		t.Errorf("expected success, got failure: %v", result.Err)
 	}
-	if result.Metrics[srv.URL] <= 0 {
-		t.Errorf("expected positive response time, got %d", result.Metrics[srv.URL])
+	if p := result.Metrics[srv.URL]; p == nil || *p <= 0 {
+		t.Errorf("expected positive response time, got %v", result.Metrics[srv.URL])
 	}
 	if result.Timestamp.IsZero() {
 		t.Error("expected non-zero timestamp")

pkg/check/ping/ping.go

@@ -131,8 +131,9 @@ func (p *Ping) Describe() check.Descriptor {
 // is stored in microseconds keyed by address string.
 func (p *Ping) Run(ctx context.Context) check.Result {
 	now := time.Now()
-	metrics := make(map[string]int64)
+	metrics := make(map[string]*int64, len(p.addresses))
 	var lastErr error
+	succeeded := 0
 
 	timeoutSec := fmt.Sprintf("%.0f", p.timeout.Seconds())
 	count := strconv.Itoa(p.count)
@@ -146,29 +147,25 @@ func (p *Ping) Run(ctx context.Context) check.Result {
 
 		if err := cmd.Run(); err != nil {
 			lastErr = fmt.Errorf("ping %s: %w", a.address, err)
+			metrics[a.resultKey] = nil
 			continue
 		}
 
 		latency, err := parseOutput(out.String())
 		if err != nil {
 			lastErr = fmt.Errorf("ping %s: %w", a.address, err)
+			metrics[a.resultKey] = nil
 			continue
 		}
 
-		metrics[a.resultKey] = int64(latency.Microseconds())
-	}
-
-	if len(metrics) == len(p.addresses) {
-		return check.Result{
-			Timestamp: now,
-			Success:   true,
-			Metrics:   metrics,
-		}
+		v := int64(latency.Microseconds())
+		metrics[a.resultKey] = &v
+		succeeded++
 	}
 
 	return check.Result{
 		Timestamp: now,
-		Success:   false,
+		Success:   succeeded == len(p.addresses),
 		Err:       lastErr,
 		Metrics:   metrics,
 	}

pkg/check/ping/ping_test.go

@@ -356,7 +356,7 @@ func TestRun_Localhost(t *testing.T) {
 	if !result.Success {
 		t.Skipf("ping failed (may not have permission): %v", result.Err)
 	}
-	if result.Metrics["127.0.0.1"] <= 0 {
-		t.Errorf("expected positive latency, got %d", result.Metrics["127.0.0.1"])
+	if p := result.Metrics["127.0.0.1"]; p == nil || *p <= 0 {
+		t.Errorf("expected positive latency, got %v", result.Metrics["127.0.0.1"])
 	}
 }

pkg/check/result.go

@@ -13,9 +13,9 @@ type Result struct {
 	Success bool
 
 	// Metrics holds named measurements from the check execution.
-	// For example, a ping check might set {"latency_us": 1234.0}.
-	// An empty or nil map is valid for checks that only report success/failure.
-	Metrics map[string]int64
+	// A nil pointer value for a key means the target was attempted but failed.
+	// An absent key or nil map means no measurement was attempted.
+	Metrics map[string]*int64
 
 	// Err holds any error encountered during check execution.
 	// A non-nil Err generally corresponds to Success being false,

pkg/check/result_test.go

@@ -22,15 +22,17 @@ func TestResult_ZeroValue(t *testing.T) {
 }
 
 func TestResult_WithMetrics(t *testing.T) {
+	v := int64(12345)
 	r := Result{
 		Timestamp: time.Now(),
 		Success:   true,
-		Metrics:   map[string]int64{"latency_us": 12345},
+		Metrics:   map[string]*int64{"latency_us": &v},
 	}
 	if !r.Success {
 		t.Error("expected success")
 	}
-	if v, ok := r.Metrics["latency_us"]; !ok || v != 12345 {
-		t.Errorf("expected latency_us=12345, got %v", v)
+	p, ok := r.Metrics["latency_us"]
+	if !ok || p == nil || *p != 12345 {
+		t.Errorf("expected latency_us=12345, got %v", p)
 	}
 }