Add Redis check type (PING/AUTH over raw protocol)

Author: brvier

CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to Gjallar are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.5.0] - 2026-07-05
+
+### Added
+
+- Redis check type (`type: redis`): TCP connect, optional `AUTH`, `PING`
+  must answer `+PONG`. Fields: `host`, `port` (default 6379), `password`.
+
 ## [0.4.0] - 2026-07-05
 
 ### Added

README.md

@@ -15,6 +15,7 @@ HTMX-refreshed), and alerts you when something goes down — and when it recover
 | `postgres` | SQL query result against a rule (pure-Go pgx driver) |
 | `oracle` | SQL query result against a rule (pure-Go go-ora driver, no Oracle client needed) |
 | `ping` | ICMP echo (privileged or unprivileged) |
+| `redis` | TCP connect + optional `AUTH` + `PING`/`+PONG` |
 | `prometheus` | Fetches a `/metrics` route and evaluates a rule against metric values, with optional label selectors |
 
 Rules: `> N`, `>= N`, `< N`, `<= N`, `== x`, `!= x`, `~ regex`, `rows > 0` (row count).

gjallar.example.yaml

@@ -89,6 +89,13 @@ monitors:
     interval: 15s
     timeout: 5s
 
+  # --- Redis: connect + optional AUTH + PING ---
+  - name: cache
+    type: redis
+    host: "10.0.0.5"
+    port: 6379            # default 6379
+    password: "${REDIS_PASSWORD}"   # omit if no AUTH
+
   # --- Prometheus metrics: rule must hold for every matching series ---
   - name: node1-disk
     type: prometheus

internal/check/check.go

@@ -39,6 +39,8 @@ func New(m config.Monitor) (Checker, error) {
 		c, err = newSQLCheck("oracle", m)
 	case "ping":
 		c, err = newPingCheck(m)
+	case "redis":
+		c, err = newRedisCheck(m)
 	case "prometheus":
 		c, err = newPromCheck(m)
 	default:

internal/check/redis.go

@@ -0,0 +1,67 @@
+package check
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+
+	"gjallar/internal/config"
+)
+
+// redisCheck connects to a Redis server, optionally authenticates, and
+// expects +PONG to a PING. No client library — the protocol is two lines.
+type redisCheck struct {
+	addr     string
+	password string
+}
+
+func newRedisCheck(m config.Monitor) (*redisCheck, error) {
+	port := m.Port
+	if port == 0 {
+		port = 6379
+	}
+	return &redisCheck{
+		addr:     net.JoinHostPort(m.Host, strconv.Itoa(port)),
+		password: m.Password,
+	}, nil
+}
+
+func (c *redisCheck) Check(ctx context.Context) (bool, string) {
+	var d net.Dialer
+	conn, err := d.DialContext(ctx, "tcp", c.addr)
+	if err != nil {
+		return false, err.Error()
+	}
+	defer conn.Close()
+	if deadline, ok := ctx.Deadline(); ok {
+		conn.SetDeadline(deadline)
+	}
+	r := bufio.NewReader(conn)
+
+	if c.password != "" {
+		if err := redisCommand(conn, r, "AUTH "+c.password, "+OK"); err != nil {
+			return false, fmt.Sprintf("auth: %v", err)
+		}
+	}
+	if err := redisCommand(conn, r, "PING", "+PONG"); err != nil {
+		return false, err.Error()
+	}
+	return true, ""
+}
+
+func redisCommand(conn net.Conn, r *bufio.Reader, cmd, want string) error {
+	if _, err := fmt.Fprintf(conn, "%s\r\n", cmd); err != nil {
+		return err
+	}
+	line, err := r.ReadString('\n')
+	if err != nil {
+		return err
+	}
+	if line = strings.TrimSpace(line); line != want {
+		return fmt.Errorf("unexpected reply %q", line)
+	}
+	return nil
+}

internal/check/redis_test.go

@@ -0,0 +1,104 @@
+package check
+
+import (
+	"bufio"
+	"context"
+	"net"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"gjallar/internal/config"
+)
+
+// fakeRedis answers PING/AUTH like a real server; password "" = no auth needed.
+func fakeRedis(t *testing.T, password string) (host string, port int) {
+	t.Helper()
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { ln.Close() })
+	go func() {
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				return
+			}
+			go func(c net.Conn) {
+				defer c.Close()
+				r := bufio.NewReader(c)
+				authed := password == ""
+				for {
+					line, err := r.ReadString('\n')
+					if err != nil {
+						return
+					}
+					switch cmd := strings.TrimSpace(line); {
+					case strings.HasPrefix(cmd, "AUTH "):
+						if strings.TrimPrefix(cmd, "AUTH ") == password {
+							authed = true
+							c.Write([]byte("+OK\r\n"))
+						} else {
+							c.Write([]byte("-ERR invalid password\r\n"))
+						}
+					case cmd == "PING" && authed:
+						c.Write([]byte("+PONG\r\n"))
+					default:
+						c.Write([]byte("-NOAUTH Authentication required.\r\n"))
+					}
+				}
+			}(conn)
+		}
+	}()
+	addr := ln.Addr().(*net.TCPAddr)
+	return addr.IP.String(), addr.Port
+}
+
+func redisMonitor(host string, port int, password string) config.Monitor {
+	return config.Monitor{
+		Name: "t", Type: "redis", Host: host, Port: port, Password: password,
+		Timeout: config.Duration(3 * time.Second),
+	}
+}
+
+func TestRedisCheck(t *testing.T) {
+	host, port := fakeRedis(t, "")
+	c, _ := newRedisCheck(redisMonitor(host, port, ""))
+	if ok, msg := c.Check(context.Background()); !ok {
+		t.Errorf("expected ok, got %q", msg)
+	}
+}
+
+func TestRedisCheckAuth(t *testing.T) {
+	host, port := fakeRedis(t, "s3cret")
+	c, _ := newRedisCheck(redisMonitor(host, port, "s3cret"))
+	if ok, msg := c.Check(context.Background()); !ok {
+		t.Errorf("expected ok, got %q", msg)
+	}
+
+	bad, _ := newRedisCheck(redisMonitor(host, port, "wrong"))
+	if ok, msg := bad.Check(context.Background()); ok || !strings.Contains(msg, "auth") {
+		t.Errorf("got ok=%v msg=%q", ok, msg)
+	}
+
+	noauth, _ := newRedisCheck(redisMonitor(host, port, ""))
+	if ok, _ := noauth.Check(context.Background()); ok {
+		t.Error("expected NOAUTH failure")
+	}
+}
+
+func TestRedisCheckDown(t *testing.T) {
+	c, _ := newRedisCheck(redisMonitor("127.0.0.1", 1, ""))
+	if ok, _ := c.Check(context.Background()); ok {
+		t.Error("expected connection failure")
+	}
+}
+
+func TestRedisDefaultPort(t *testing.T) {
+	c, _ := newRedisCheck(config.Monitor{Host: "h"})
+	if c.addr != "h:"+strconv.Itoa(6379) {
+		t.Errorf("addr = %q", c.addr)
+	}
+}

internal/config/config.go

@@ -81,18 +81,20 @@ type Monitor struct {
 	Query string `yaml:"query"`
 	Rule  string `yaml:"rule"` // also used by prometheus
 
-	// ping
+	// ping / redis
 	Host       string `yaml:"host"`
 	Count      int    `yaml:"count"`
 	Privileged bool   `yaml:"privileged"`
+	Port       int    `yaml:"port"`     // redis; default 6379
+	Password   string `yaml:"password"` // redis; empty = no AUTH
 
 	// prometheus
 	Metric string            `yaml:"metric"`
 	Labels map[string]string `yaml:"labels"`
 }
 
 var monitorTypes = map[string]bool{
-	"http": true, "postgres": true, "oracle": true, "ping": true, "prometheus": true,
+	"http": true, "postgres": true, "oracle": true, "ping": true, "prometheus": true, "redis": true,
 }
 
 // envRe matches ${VAR} only; a bare $ is left alone so regex rules like
@@ -236,7 +238,7 @@ func (c *Config) Validate() error {
 
 func (m *Monitor) validate() error {
 	if !monitorTypes[m.Type] {
-		return fmt.Errorf("unknown type %q (supported: http, postgres, oracle, ping, prometheus)", m.Type)
+		return fmt.Errorf("unknown type %q (supported: http, postgres, oracle, ping, prometheus, redis)", m.Type)
 	}
 	switch m.Type {
 	case "http":
@@ -258,7 +260,7 @@ func (m *Monitor) validate() error {
 		if m.Rule == "" {
 			return fmt.Errorf("rule is required")
 		}
-	case "ping":
+	case "ping", "redis":
 		if m.Host == "" {
 			return fmt.Errorf("host is required")
 		}