Add health check and self reporting of health

This avoids panicing and instead provides an HTTP endpoint to report health

.drone.yml

@@ -4,7 +4,7 @@ name: test
 
 steps:
   - name: test
-    image: golang:1.17
+    image: golang:1.20
     environment:
       VERSION: ${DRONE_TAG:-${DRONE_COMMIT}}
     commands:
@@ -30,7 +30,7 @@ trigger:
 
 steps:
   - name: build all binaries
-    image: golang:1.17
+    image: golang:1.20
     environment:
       VERSION: ${DRONE_TAG:-${DRONE_COMMIT}}
     commands:

Dockerfile

@@ -1,11 +1,11 @@
 ARG REPO=library
-FROM ${REPO}/alpine:3.12
+FROM ${REPO}/alpine:3.18
 
 RUN mkdir /app
 WORKDIR /app/
 
 # Add common checking tools
-RUN apk --no-cache add bash=~5.0 curl=~7.79 jq=~1.6 bind-tools=~9.16
+RUN apk --no-cache add bash=~5 curl=~8 jq=~1 bind-tools=~9 tzdata~=2023c
 
 # Add minitor user for running as non-root
 RUN addgroup -S minitor && adduser -S minitor -G minitor

Dockerfile.multi-stage

@@ -1,5 +1,5 @@
 ARG REPO=library
-FROM golang:1.17 AS builder
+FROM golang:1.20 AS builder
 
 RUN mkdir /app
 WORKDIR /app
@@ -14,7 +14,7 @@ ARG VERSION=dev
 ENV CGO_ENABLED=0 GOOS=linux GOARCH=${ARCH}
 RUN go build -ldflags "-X main.version=${VERSION}" -a -installsuffix nocgo -o minitor .
 
-FROM ${REPO}/alpine:3.12
+FROM ${REPO}/alpine:3.18
 RUN mkdir /app
 WORKDIR /app/
 
@@ -22,7 +22,7 @@ WORKDIR /app/
 COPY --from=builder /app/minitor .
 
 # Add common checking tools
-RUN apk --no-cache add bash=~5.0 curl=~7.79 jq=~1.6 bind-tools=~9.16
+RUN apk --no-cache add bash=~5 curl=~8 jq=~1 bind-tools=~9 tzdata~=2023c
 
 # Add minitor user for running as non-root
 RUN addgroup -S minitor && adduser -S minitor -G minitor

README.md

@@ -46,6 +46,8 @@ docker run -v $PWD/config.yml:/app/config.yml iamthefij/minitor-go:latest
 
 Images are provided for `amd64`, `arm`, and `arm64` architechtures.
 
+Timezone configuration for the container is set by passing the `TZ` env variable. Eg. `TZ=America/Los_Angeles`.
+
 ## Configuring
 
 In this repo, you can explore the `sample-config.yml` file for an example, but the general structure is as follows. It should be noted that environment variable interpolation happens on load of the YAML file.
@@ -94,10 +96,28 @@ Also, when alerts are executed, they will be passed through Go's format function
 |`{{.AlertCount}}`|Number of times this monitor has alerted|
 |`{{.FailureCount}}`|The total number of sequential failed checks for this monitor|
 |`{{.LastCheckOutput}}`|The last returned value from the check command to either stderr or stdout|
-|`{{.LastSuccess}}`|The ISO datetime of the last successful check|
+|`{{.LastSuccess}}`|The datetime of the last successful check as a go Time struct|
 |`{{.MonitorName}}`|The name of the monitor that failed and triggered the alert|
 |`{{.IsUp}}`|Indicates if the monitor that is alerting is up or not. Can be used in a conditional message template|
 
+To provide flexible formatting, the following non-standard functions are available in templates:
+
+|func|description|
+|---|---|
+|`ANSIC <Time>`|Formats provided time in ANSIC format|
+|`UnixDate <Time>`|Formats provided time in UnixDate format|
+|`RubyDate <Time>`|Formats provided time in RubyDate format|
+|`RFC822Z <Time>`|Formats provided time in RFC822Z format|
+|`RFC850 <Time>`|Formats provided time in RFC850 format|
+|`RFC1123 <Time>`|Formats provided time in RFC1123 format|
+|`RFC1123Z <Time>`|Formats provided time in RFC1123Z format|
+|`RFC3339 <Time>`|Formats provided time in RFC3339 format|
+|`RFC3339Nano <Time>`|Formats provided time in RFC3339Nano format|
+|`FormatTime <Time> <string template>`|Formats provided time according to provided template|
+|`InTZ <Time> <string timezone name>`|Converts provided time to parsed timezone from the provided name|
+
+For more information, check out the [Go documentation for the time module](https://pkg.go.dev/time@go1.20.7#pkg-constants).
+
 ### Metrics
 
 Minitor supports exporting metrics for [Prometheus](https://prometheus.io/). Prometheus is an open source tool for reading and querying metrics from different sources. Combined with another tool, [Grafana](https://grafana.com/), it allows building of charts and dashboards. You could also opt to just use Minitor to log check results, and instead do your alerting with Grafana.

alert.go

@@ -57,6 +57,37 @@ func (alert *Alert) BuildTemplates() error {
 
 	slog.Debugf("Building template for alert %s", alert.Name)
 
+	// Time format func factory
+	tff := func(formatString string) func(time.Time) string {
+		return func(t time.Time) string {
+			return t.Format(formatString)
+		}
+	}
+
+	// Create some functions for formatting datetimes in popular formats
+	timeFormatFuncs := template.FuncMap{
+		"ANSIC":       tff(time.ANSIC),
+		"UnixDate":    tff(time.UnixDate),
+		"RubyDate":    tff(time.RubyDate),
+		"RFC822Z":     tff(time.RFC822Z),
+		"RFC850":      tff(time.RFC850),
+		"RFC1123":     tff(time.RFC1123),
+		"RFC1123Z":    tff(time.RFC1123Z),
+		"RFC3339":     tff(time.RFC3339),
+		"RFC3339Nano": tff(time.RFC3339Nano),
+		"FormatTime": func(t time.Time, timeFormat string) string {
+			return t.Format(timeFormat)
+		},
+		"InTZ": func(t time.Time, tzName string) (time.Time, error) {
+			tz, err := time.LoadLocation(tzName)
+			if err != nil {
+				return t, fmt.Errorf("failed to convert time to specified tz: %w", err)
+			}
+
+			return t.In(tz), nil
+		},
+	}
+
 	switch {
 	case alert.commandTemplate == nil && alert.Command.Command != nil:
 		alert.commandTemplate = []*template.Template{}
@@ -66,7 +97,7 @@ func (alert *Alert) BuildTemplates() error {
 			}
 
 			alert.commandTemplate = append(alert.commandTemplate, template.Must(
-				template.New(alert.Name+fmt.Sprint(i)).Parse(cmdPart),
+				template.New(alert.Name+fmt.Sprint(i)).Funcs(timeFormatFuncs).Parse(cmdPart),
 			))
 		}
 	case alert.commandShellTemplate == nil && alert.Command.ShellCommand != "":
@@ -77,7 +108,7 @@ func (alert *Alert) BuildTemplates() error {
 		}
 
 		alert.commandShellTemplate = template.Must(
-			template.New(alert.Name).Parse(shellCmd),
+			template.New(alert.Name).Funcs(timeFormatFuncs).Parse(shellCmd),
 		)
 	default:
 		return fmt.Errorf("No template provided for alert %s: %w", alert.Name, errNoTemplate)
@@ -137,7 +168,7 @@ func (alert Alert) Send(notice AlertNotice) (outputStr string, err error) {
 
 	if err != nil {
 		err = fmt.Errorf(
-			"Alert '%s' failed to send. Returned %v: %w",
+			"Alert %s failed to send. Returned %w: %w",
 			alert.Name,
 			err,
 			ErrAlertFailed,

go.mod

@@ -1,6 +1,6 @@
 module git.iamthefij.com/iamthefij/minitor-go
 
-go 1.17
+go 1.20
 
 require (
 	git.iamthefij.com/iamthefij/slog v1.3.0

health.go

@@ -0,0 +1,72 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+)
+
+type HealthCheckHandler struct {
+	isMinitorHealthy bool
+	monitors         []*Monitor
+}
+
+func NewHealthCheckHandler(monitors []*Monitor) *HealthCheckHandler {
+	return &HealthCheckHandler{
+		false,
+		monitors,
+	}
+}
+
+func (hch *HealthCheckHandler) MinitorHealthy(healthy bool) {
+	hch.isMinitorHealthy = healthy
+}
+
+func (hch HealthCheckHandler) MinitorHealthCheck() (bool, string) {
+	if hch.isMinitorHealthy {
+		return true, "OK"
+	} else {
+		return false, "UNHEALTHY"
+	}
+}
+
+func (hch HealthCheckHandler) MonitorsHealthCheck() (bool, string) {
+	downMonitors := []string{}
+
+	for _, monitor := range hch.monitors {
+		if !monitor.IsUp() {
+			downMonitors = append(downMonitors, monitor.Name)
+		}
+	}
+
+	if len(downMonitors) == 0 {
+		return true, "OK"
+	} else {
+		return false, fmt.Sprintf("UNHEALTHY: The following monitors are unhealthy: %s", strings.Join(downMonitors, ", "))
+	}
+}
+
+func (hch HealthCheckHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	var healthy bool
+
+	var body string
+
+	if monitors := r.URL.Query().Get("monitors"); monitors != "" {
+		healthy, body = hch.MonitorsHealthCheck()
+	} else {
+		healthy, body = hch.MinitorHealthCheck()
+	}
+
+	if healthy {
+		w.WriteHeader(http.StatusOK)
+	} else {
+		w.WriteHeader(http.StatusServiceUnavailable)
+	}
+
+	_, _ = io.WriteString(w, body)
+}
+
+func HandleHealthCheck() {
+	http.Handle("/metrics", HealthChecks)
+}

health_test.go

@@ -0,0 +1,79 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestNewHealthCheck(t *testing.T) {
+	monitors := []*Monitor{
+		{Name: "Test Monitor"},
+	}
+	hc := NewHealthCheckHandler(monitors)
+
+	monitors[0].alertCount++
+
+	if healthy, _ := hc.MinitorHealthCheck(); healthy {
+		t.Errorf("Initial hc state should be unhealthy until some successful alert is sent")
+	}
+
+	if healthy, _ := hc.MonitorsHealthCheck(); healthy {
+		t.Errorf("Faking an alert on the monitor pointer should make this unhealthy")
+	}
+}
+
+func TestMinitorHealthCheck(t *testing.T) {
+	monitors := []*Monitor{
+		{Name: "Test Monitor"},
+	}
+	hc := NewHealthCheckHandler(monitors)
+
+	t.Run("MinitorHealthCheck(healthy)", func(t *testing.T) {
+		hc.MinitorHealthy(true)
+		healthy, body := hc.MinitorHealthCheck()
+		if !healthy {
+			t.Errorf("Expected healthy check")
+		}
+		if body != "OK" {
+			t.Errorf("Expected OK response")
+		}
+	})
+
+	t.Run("MinitorHealthCheck(unhealthy)", func(t *testing.T) {
+		hc.MinitorHealthy(false)
+		healthy, body := hc.MinitorHealthCheck()
+		if healthy {
+			t.Errorf("Expected healthy check")
+		}
+		if body != "UNHEALTHY" {
+			t.Errorf("Expected UNHEALTHY response")
+		}
+	})
+}
+
+func TestMonitorsHealthCheck(t *testing.T) {
+	monitors := []*Monitor{
+		{Name: "Test Monitor"},
+	}
+	hc := NewHealthCheckHandler(monitors)
+
+	t.Run("MonitorsHealthCheck(healthy)", func(t *testing.T) {
+		healthy, body := hc.MonitorsHealthCheck()
+		if !healthy {
+			t.Errorf("Expected healthy check")
+		}
+		if body != "OK" {
+			t.Errorf("Expected OK response")
+		}
+	})
+
+	t.Run("MonitorsHealthCheck(unhealthy)", func(t *testing.T) {
+		monitors[0].alertCount++
+		healthy, body := hc.MonitorsHealthCheck()
+		if healthy {
+			t.Errorf("Expected healthy check")
+		}
+		if body != "UNHEALTHY: The following monitors are unhealthy: Test Monitor" {
+			t.Errorf("Expected UNHEALTHY response")
+		}
+	})
+}

main.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"net/http"
 	"time"
 
 	"git.iamthefij.com/iamthefij/slog"
@@ -16,6 +17,10 @@ var (
 	MetricsPort = 8080
 	// Metrics contains all active metrics
 	Metrics = NewMetrics()
+	// Self monitor rather than panicing
+	SelfMonitor = false
+	// HealthChecks contains health check values
+	HealthChecks *HealthCheckHandler = nil
 
 	// PyCompat enables support for legacy Python templates
 	PyCompat = false
@@ -51,7 +56,13 @@ func sendAlerts(config *Config, monitor *Monitor, alertNotice *AlertNotice) erro
 					output,
 				)
 
+				if SelfMonitor {
+					Metrics.SetMonitorStatus(fmt.Sprintf("Alert %s", alertName), false)
+				}
+
 				return err
+			} else {
+				Metrics.SetMonitorStatus(fmt.Sprintf("Alert %s", alertName), true)
 			}
 
 			// Count alert metrics
@@ -69,6 +80,8 @@ func sendAlerts(config *Config, monitor *Monitor, alertNotice *AlertNotice) erro
 
 func checkMonitors(config *Config) error {
 	// TODO: Run this in goroutines and capture exceptions
+	healthy := true
+
 	for _, monitor := range config.Monitors {
 		if monitor.ShouldCheck() {
 			success, alertNotice := monitor.Check()
@@ -80,17 +93,32 @@ func checkMonitors(config *Config) error {
 
 			if alertNotice != nil {
 				err := sendAlerts(config, monitor, alertNotice)
-				// If there was an error in sending an alert, exit early and bubble it up
+				// If there was an error in sending an alert, mark as unhealthy or bubble up
 				if err != nil {
-					return err
+					if SelfMonitor {
+						healthy = false
+					} else {
+						return err
+					}
 				}
 			}
 		}
 	}
 
+	if HealthChecks != nil {
+		HealthChecks.MinitorHealthy(healthy)
+	}
+
 	return nil
 }
 
+// ServeMetricsAndHealth starts the default http server
+func ServeMetricsAndHealth() {
+	host := fmt.Sprintf(":%d", MetricsPort)
+
+	_ = http.ListenAndServe(host, nil)
+}
+
 func main() {
 	showVersion := flag.Bool("version", false, "Display the version of minitor and exit")
 	configPath := flag.String("config", "config.yml", "Alternate configuration path (default: config.yml)")
@@ -98,7 +126,9 @@ func main() {
 	flag.BoolVar(&slog.DebugLevel, "debug", false, "Enables debug logs (default: false)")
 	flag.BoolVar(&ExportMetrics, "metrics", false, "Enables prometheus metrics exporting (default: false)")
 	flag.BoolVar(&PyCompat, "py-compat", false, "Enables support for legacy Python Minitor config. Will eventually be removed. (default: false)")
-	flag.IntVar(&MetricsPort, "metrics-port", MetricsPort, "The port that Prometheus metrics should be exported on, if enabled. (default: 8080)")
+	flag.IntVar(&MetricsPort, "metrics-port", MetricsPort, "The port that Prometheus metrics and healthchecks should be exported on, if enabled. (default: 8080)")
+	flag.BoolVar(&SelfMonitor, "self-monitor", false, "Enables self-monitoring. Export metrics rather than panic when alerts fail. (default: false)")
+
 	flag.Parse()
 
 	// Print version if flag is provided
@@ -115,8 +145,19 @@ func main() {
 	// Serve metrics exporter, if specified
 	if ExportMetrics {
 		slog.Infof("Exporting metrics to Prometheus on port %d", MetricsPort)
+		HandleMetrics()
+	}
 
-		go ServeMetrics()
+	if SelfMonitor {
+		slog.Infof("Starting healthcheck endpoint on port %d", MetricsPort)
+
+		HealthChecks = NewHealthCheckHandler(config.Monitors)
+
+		HandleHealthCheck()
+	}
+
+	if ExportMetrics || SelfMonitor {
+		go ServeMetricsAndHealth()
 	}
 
 	// Start main loop

main_test.go

@@ -4,9 +4,10 @@ import "testing"
 
 func TestCheckMonitors(t *testing.T) {
 	cases := []struct {
-		config    Config
+		config      Config
-		expectErr bool
+		expectErr   bool
-		name      string
+		name        string
+		selfMonitor bool
 	}{
 		{
 			config:    Config{},
@@ -22,8 +23,9 @@ func TestCheckMonitors(t *testing.T) {
 					},
 				},
 			},
-			expectErr: false,
+			expectErr:   false,
-			name:      "Monitor success, no alerts",
+			name:        "Monitor success, no alerts",
+			selfMonitor: false,
 		},
 		{
 			config: Config{
@@ -35,8 +37,9 @@ func TestCheckMonitors(t *testing.T) {
 					},
 				},
 			},
-			expectErr: false,
+			expectErr:   false,
-			name:      "Monitor failure, no alerts",
+			name:        "Monitor failure, no alerts",
+			selfMonitor: false,
 		},
 		{
 			config: Config{
@@ -48,8 +51,9 @@ func TestCheckMonitors(t *testing.T) {
 					},
 				},
 			},
-			expectErr: false,
+			expectErr:   false,
-			name:      "Monitor recovery, no alerts",
+			name:        "Monitor recovery, no alerts",
+			selfMonitor: false,
 		},
 		{
 			config: Config{
@@ -62,8 +66,9 @@ func TestCheckMonitors(t *testing.T) {
 					},
 				},
 			},
-			expectErr: true,
+			expectErr:   true,
-			name:      "Monitor failure, unknown alerts",
+			name:        "Monitor failure, unknown alerts",
+			selfMonitor: false,
 		},
 		{
 			config: Config{
@@ -76,8 +81,24 @@ func TestCheckMonitors(t *testing.T) {
 					},
 				},
 			},
-			expectErr: true,
+			expectErr:   true,
-			name:      "Monitor recovery, unknown alerts",
+			name:        "Monitor recovery, unknown alerts",
+			selfMonitor: false,
+		},
+		{
+			config: Config{
+				Monitors: []*Monitor{
+					{
+						Name:       "Success",
+						Command:    CommandOrShell{Command: []string{"true"}},
+						AlertUp:    []string{"unknown"},
+						alertCount: 1,
+					},
+				},
+			},
+			expectErr:   false,
+			name:        "Monitor recovery, unknown alerts, with Health Check",
+			selfMonitor: true,
 		},
 		{
 			config: Config{
@@ -95,8 +116,9 @@ func TestCheckMonitors(t *testing.T) {
 					},
 				},
 			},
-			expectErr: false,
+			expectErr:   false,
-			name:      "Monitor failure, successful alert",
+			name:        "Monitor failure, successful alert",
+			selfMonitor: false,
 		},
 		{
 			config: Config{
@@ -115,12 +137,36 @@ func TestCheckMonitors(t *testing.T) {
 					},
 				},
 			},
-			expectErr: true,
+			expectErr:   true,
-			name:      "Monitor failure, bad alert",
+			name:        "Monitor failure, bad alert",
+			selfMonitor: false,
+		},
+		{
+			config: Config{
+				Monitors: []*Monitor{
+					{
+						Name:       "Failure",
+						Command:    CommandOrShell{Command: []string{"false"}},
+						AlertDown:  []string{"bad"},
+						AlertAfter: 1,
+					},
+				},
+				Alerts: map[string]*Alert{
+					"bad": {
+						Name:    "bad",
+						Command: CommandOrShell{Command: []string{"false"}},
+					},
+				},
+			},
+			expectErr:   false,
+			name:        "Monitor failure, bad alert, with Health Check",
+			selfMonitor: true,
 		},
 	}
 
 	for _, c := range cases {
+		SelfMonitor = c.selfMonitor
+
 		err := c.config.Init()
 		if err != nil {
 			t.Errorf("checkMonitors(%s): unexpected error reading config: %v", c.name, err)

metrics.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"net/http"
 
 	"github.com/prometheus/client_golang/prometheus"
@@ -107,11 +106,7 @@ func (metrics *MinitorMetrics) CountAlert(monitor string, alert string) {
 	).Inc()
 }
 
-// ServeMetrics starts an http server with a Prometheus metrics handler
+// HandleMetrics add Prometheus metrics handler to default http server
-func ServeMetrics() {
+func HandleMetrics() {
 	http.Handle("/metrics", promhttp.Handler())
-
-	host := fmt.Sprintf(":%d", MetricsPort)
-
-	_ = http.ListenAndServe(host, nil)
 }