initial commit

Author: shayanderson

.gitignore

@@ -0,0 +1,2 @@
+bin/
+deploy.sh

Makefile

@@ -0,0 +1,23 @@
+.DEFAULT_GOAL := help
+
+PROJECT := notifymem
+SOURCES := $(wildcard *.go cmd/*/*.go)
+VERSION := $(shell git describe --tags 2>/dev/null || echo "Unknown")
+
+build: $(SOURCES) ## Build the project
+	@echo "Building $(PROJECT) ($(VERSION))"
+	CGO_ENABLED=0 go build -ldflags "-X 'main.version=$(VERSION)'" -o bin/$(PROJECT) cmd/notifymem/*.go
+
+.PHONY: help
+help: ## Display help
+	@COL_W=20
+	@grep -h '##' $(MAKEFILE_LIST) | \
+	  grep -v grep | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-'$$COL_W's\033[0m %s\n", $$1, $$2}'
+
+.PHONY: run
+run: build ## Run the project
+	./bin/$(PROJECT)
+
+.PHONY: tidy
+tidy: ## Run go mod tidy
+	go mod tidy -v

README.md

@@ -0,0 +1,57 @@
+# Notifier for High Memory Usage
+
+A simple tool to notify you when your system memory usage is too high.
+
+Features:
+
+- uses `notify-send` to send notifications when memory usage reaches a certain threshold
+- major Linux distributions are supported
+- configurable threshold, check memory usage interval and resend notification delay
+
+## Usage
+
+Example usage that monitors memory usage by checking every 2 seconds, sends a notification when memory usage is above 80% and will not send another notification until after 60 seconds.
+
+```bash
+notifymem -threshold 80 -delay 60 -interval 2
+```
+
+## Installation
+
+First, download the latest release or clone the repository and build locally using `make build`, which will create a binary in the `bin` directory. Then, copy the binary to a directory, like `/opt/notifymem/bin`, and make the file executable, like `chmod +x /opt/notifymem/bin/notifymem`.
+
+Next, create a systemd service file in `/etc/systemd/system/notifymem.service` with the following content:
+
+```ini
+[Unit]
+Description=notifymem service: notify when memory usage reaches a threshold
+After=network.target
+
+[Service]
+Type=simple
+Restart=always
+RestartSec=3
+User=your-username
+ExecStart=/opt/notifymem/bin/notifymem -threshold 80 -delay 60 -interval 2
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Make sure to:
+
+- replace `your-username` with your actual username
+- set `ExecStart` to the path where you copied the binary and use the desired options
+
+Finally, enable and start the service:
+
+```bash
+systemctl enable notifymem
+systemctl start notifymem
+```
+
+Tips:
+
+- check the status of the service using `systemctl status notifymem`
+- check the logs of the service using `journalctl -u notifymem` (follow the logs using `-f`)
+- reload the systemd daemon after making changes to the service file using `systemctl daemon-reload`

cmd/notifymem/main.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"time"
+
+	notifymem "github.com/shayanderson/notify-mem"
+)
+
+var version string // do not remove
+
+func errorExit(err error) {
+	fmt.Fprintf(os.Stderr, "[error] %s\n", err)
+	os.Exit(1)
+}
+
+func main() {
+	fmt.Printf("running notifymem (version %s)\n", version)
+
+	type flags struct {
+		debug       bool
+		interval    int
+		resendDelay int
+		threshold   int
+	}
+
+	f := flags{}
+	flag.BoolVar(&f.debug, "debug", false, "enable debug mode")
+	flag.IntVar(&f.interval, "interval", 2, "interval between memory checks in seconds")
+	flag.IntVar(&f.resendDelay, "delay", 30, "delay between notifications being sent in seconds")
+	flag.IntVar(&f.threshold, "threshold", 80, "memory threshold as a percentage")
+	flag.Parse()
+
+	n := notifymem.NewNotifier()
+	mOpts := notifymem.MonitorOptions{
+		Interval:    time.Duration(f.interval) * time.Second,
+		ResendDelay: time.Duration(f.resendDelay) * time.Second,
+		Threshold:   f.threshold,
+	}
+
+	if f.debug {
+		mOpts.DebugFunc = func(s string) { fmt.Println(s) }
+	}
+
+	m, err := notifymem.NewMonitor(n, mOpts)
+	if err != nil {
+		errorExit(err)
+	}
+
+	ctx := context.Background()
+	if err := m.Run(ctx); err != nil && err != context.Canceled {
+		errorExit(err)
+	}
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/shayanderson/notify-mem
+
+go 1.22.4

monitor.go

@@ -0,0 +1,163 @@
+package notifymem
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"runtime"
+	"time"
+)
+
+type memory struct {
+	total int
+	avail int
+}
+
+type MonitorOptions struct {
+	DebugFunc   func(string)
+	Interval    time.Duration
+	ResendDelay time.Duration
+	Threshold   int
+}
+
+type Monitor struct {
+	debugFunc   func(string)
+	interval    time.Duration
+	lastSentAt  time.Time
+	notifier    Notifier
+	resendDelay time.Duration
+	threshold   int
+}
+
+func NewMonitor(notifier Notifier, opts MonitorOptions) (*Monitor, error) {
+	if runtime.GOOS != "linux" {
+		return nil, errors.New("notifymem only supports Linux")
+	}
+
+	m := &Monitor{
+		debugFunc:   opts.DebugFunc,
+		interval:    opts.Interval,
+		notifier:    notifier,
+		resendDelay: opts.ResendDelay,
+		threshold:   opts.Threshold,
+	}
+
+	if m.interval < 100*time.Millisecond {
+		return nil, errors.New("interval must be at least 100ms")
+	}
+
+	if m.notifier == nil {
+		return nil, errors.New("notifier is required")
+	}
+
+	if m.resendDelay < 5*time.Second {
+		return nil, errors.New("resend delay must be at least 5s")
+	}
+
+	if m.threshold < 0 || m.threshold > 100 {
+		return nil, errors.New("threshold must be between 0 and 100")
+	}
+
+	return m, nil
+}
+
+func (m *Monitor) debug(msg string) {
+	if m.debugFunc != nil {
+		m.debugFunc(msg)
+	}
+}
+
+func (m *Monitor) isThresholdReached() (bool, int, error) {
+	mem, err := readMemory()
+	if err != nil {
+		return false, 0, err
+	}
+
+	usage, err := memoryUsage(mem)
+	if err != nil {
+		return false, 0, err
+	}
+
+	if usage >= m.threshold {
+		return true, usage, nil
+	}
+
+	return false, usage, nil
+}
+
+func (m *Monitor) notify(usage int) error {
+	if time.Since(m.lastSentAt) < m.resendDelay {
+		m.debug("resend delay not reached")
+		return nil
+	}
+
+	m.debug("sending notification")
+	m.lastSentAt = time.Now()
+	return m.notifier.Notify(
+		"Memory Usage Threshold Reached [notifymem]",
+		fmt.Sprintf("Memory usage at %d%%", usage),
+	)
+}
+
+func (m *Monitor) Run(ctx context.Context) error {
+	m.debug("staring monitor")
+	for {
+		select {
+		case <-ctx.Done():
+			m.debug("stopping monitor")
+			return ctx.Err()
+
+		case <-time.After(m.interval):
+			reached, usage, err := m.isThresholdReached()
+			if err != nil {
+				return err
+			}
+			m.debug(fmt.Sprintf("memory usage: %d%%", usage))
+
+			if reached {
+				m.debug(fmt.Sprintf("threshold reached: %d%%", usage))
+				if err := m.notify(usage); err != nil {
+					return err
+				}
+			}
+
+		}
+	}
+}
+
+func memoryUsage(m memory) (int, error) {
+	if m.total == 0 {
+		return 0, errors.New("total memory is 0")
+	}
+
+	return int((float64(m.total-m.avail) / float64(m.total)) * 100), nil
+}
+
+func readMemory() (memory, error) {
+	m := memory{}
+	f, err := os.Open("/proc/meminfo")
+	if err != nil {
+		return m, err
+	}
+	defer f.Close()
+
+	s := bufio.NewScanner(f)
+	for s.Scan() {
+		var k string
+		var v int
+		_, err := fmt.Sscanf(s.Text(), "%s %d", &k, &v)
+		if err != nil {
+			continue
+		}
+		switch k {
+		case "MemTotal:":
+			m.total = v
+		case "MemAvailable:":
+			m.avail = v
+		}
+	}
+
+	return m, nil
+}

notifier.go

@@ -0,0 +1,19 @@
+package notifymem
+
+import "fmt"
+
+type Notifier interface {
+	Notify(title, message string) error
+}
+
+type notifier struct {
+}
+
+func NewNotifier() *notifier {
+	return &notifier{}
+}
+
+func (n *notifier) Notify(title, message string) error {
+	fmt.Println("notify:", title, message)
+	return nil
+}