Hash, Set чи Sorted set. Який тип даних вибрати для збереження стану онлайну користувача в Redis

package research_online_redis_go

import (
	"context"
)

type OnlineStorage interface {
	Store(ctx context.Context, pair UserOnlinePair) error
	BatchStore(ctx context.Context, pairs []UserOnlinePair) error
	Count(ctx context.Context) (int64, error)
	GetAndClear(ctx context.Context) ([]UserOnlinePair, error)
}

package research_online_redis_go

import (
	"context"
	"testing"
	"time"

	"github.com/redis/go-redis/v9"
	"github.com/stretchr/testify/require"
)

func benchmarkOnlineStorage(
	b *testing.B,
	addr string,
	constructor func(client *redis.Client) OnlineStorage,
) {
	b.Helper()

	ctx := context.Background()

	client, err := Client(ctx, addr)
	require.NoError(b, err)
	require.NoError(b, client.FlushDB(ctx).Err())

	storage := constructor(client)

	startTimestamp := time.Now().Unix()

	b.ResetTimer()
	for index := 0; index < b.N; index++ {
		err := storage.Store(ctx, UserOnlinePair{
			UserID:    1e7 + int64(index),
			Timestamp: startTimestamp + int64(index),
		})

		require.NoError(b, err)
	}

	count, err := storage.Count(ctx)
	require.NoError(b, err)
	require.Equal(b, int64(b.N), count)
}

package research_online_redis_go

import (
	"testing"

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

var hashConstructor = func(client *redis.Client) OnlineStorage {
	return NewHashOnlineStorage(client)
}

func BenchmarkRedisHashOnlineStorage(b *testing.B) {
	benchmarkOnlineStorage(b, "redis1:6379", hashConstructor)
}

func BenchmarkKeydbHashOnlineStorage(b *testing.B) {
	benchmarkOnlineStorage(b, "keydb1:6379", hashConstructor)
}

func BenchmarkDragonflydbHashOnlineStorage(b *testing.B) {
	benchmarkOnlineStorage(b, "dragonflydb1:6379", hashConstructor)
}

package research_online_redis_go

import (
	"testing"

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

var sortedSetConstructor = func(client *redis.Client) OnlineStorage {
	return NewSortedSetOnlineStorage(client)
}

func BenchmarkRedisSortedSetOnlineStorage(b *testing.B) {
	benchmarkOnlineStorage(b, "redis1:6379", sortedSetConstructor)
}

func BenchmarkKeydbSortedSetOnlineStorage(b *testing.B) {
	benchmarkOnlineStorage(b, "keydb1:6379", sortedSetConstructor)
}

func BenchmarkDragonflydbSortedSetOnlineStorage(b *testing.B) {
	benchmarkOnlineStorage(b, "dragonflydb1:6379", sortedSetConstructor)
}

package research_online_redis_go

import (
	"testing"

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

var (
	setConstructor = func(client *redis.Client) OnlineStorage {
		return NewSetOnlineStorage(client, 1800)
	}
)

func BenchmarkRedisSetOnlineStorage(b *testing.B) {
	benchmarkOnlineStorage(b, "redis1:6379", setConstructor)
}

func BenchmarkKeydbSetOnlineStorage(b *testing.B) {
	benchmarkOnlineStorage(b, "keydb1:6379", setConstructor)
}

func BenchmarkDragonflydbSetOnlineStorage(b *testing.B) {
	benchmarkOnlineStorage(b, "dragonflydb1:6379", setConstructor)
}

package research_online_redis_go

import (
	"context"
	"os"
	"strconv"
	"sync/atomic"
	"testing"
	"time"

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

	"github.com/stretchr/testify/require"
)

// ...

func benchmarkOnlineStorage(
	b *testing.B,
	addr string,
	constructor func(client *redis.Client) OnlineStorage,
) {
	// ...

	var (
		expectedCount  = int64(b.N)
		startTimestamp = time.Now().Unix()
		startUserID    = int64(1e7)
	)

	b.ResetTimer()

	if os.Getenv("MODE") == "parallel" {
		var (
			counter = int64(0)
		)

		if os.Getenv("BATCH") == "" {
			// ...
		} else {
			batch, err := strconv.ParseInt(os.Getenv("BATCH"), 10, 64)
			require.NoError(b, err)
			require.True(b, batch >= 1)

			expectedCount *= batch

			b.RunParallel(func(pb *testing.PB) {
				pairs := make([]UserOnlinePair, batch)

				for pb.Next() {
					index := atomic.AddInt64(&counter, batch)

					for i := int64(0); i < batch; i++ {
						pairs[i] = UserOnlinePair{
							UserID:    startUserID + index + i,
							Timestamp: startTimestamp + index + i,
						}
					}

					err := storage.BatchStore(ctx, pairs)

					require.NoError(b, err)
				}
			})
		}
	} else {
		// ...
	}

	actualCount, err := storage.Count(ctx)
	require.NoError(b, err)
	require.Equal(b, expectedCount, actualCount)
}