keepalive/adapter/redis.go

package adapter

import (
	"context"
	"strings"

	"github.com/redis/go-redis/v9"
)

// discardRedisLogger silences go-redis's internal logger. It logs every
// failed dial attempt (several per connect), while the runner already logs
// the returned error once per retry.
type discardRedisLogger struct{}

func (discardRedisLogger) Printf(context.Context, string, ...interface{}) {}

func init() {
	redis.SetLogger(discardRedisLogger{})
	Registry["redis"] = func(cfg Config) (Adapter, error) {
		url, err := cfg.Required("url")
		if err != nil {
			return nil, err
		}
		return &redisAdapter{
			url: url,
			key: redisCounterKey(cfg.Optional("counter_key", "counter"), cfg.Optional("namespace", "")),
		}, nil
	}
}

// redisAdapter serves every RESP-compatible store: Redis, Valkey, Dragonfly,
// KeyDB, Garnet and their hosted variants.
type redisAdapter struct {
	client *redis.Client
	url    string
	key    string
}

func (a *redisAdapter) Connect(ctx context.Context) error {
	opt, err := redis.ParseURL(a.url)
	if err != nil {
		return err
	}
	client := redis.NewClient(opt)
	if err := client.Ping(ctx).Err(); err != nil {
		client.Close()
		return err
	}
	if err := client.SetNX(ctx, a.key, 0, 0).Err(); err != nil {
		client.Close()
		return err
	}
	a.client = client
	return nil
}

func (a *redisAdapter) Increment(ctx context.Context) (int64, error) {
	return a.client.Incr(ctx, a.key).Result()
}

func (a *redisAdapter) Close(_ context.Context) error {
	if a.client == nil {
		return nil
	}
	return a.client.Close()
}

func redisCounterKey(counterKey, namespace string) string {
	namespace = strings.TrimSpace(namespace)
	if namespace == "" {
		return counterKey
	}
	return namespace + ":" + counterKey
}