xcache

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/actforgood/xcache"
)

func main() {
	cache := xcache.NewMemory(10 * 1024 * 1024) // 10 Mb

	ctx := context.Background()
	key := "example-memory"
	value := []byte("Hello Memory Cache")
	ttl := 10 * time.Minute

	// save a key for 10 minutes
	if err := cache.Save(ctx, key, value, ttl); err != nil {
		fmt.Println("could not save Memory cache key: " + err.Error())
	}

	// load the key's value
	if value, err := cache.Load(ctx, key); err != nil {
		fmt.Println("could not get Memory cache key: " + err.Error())
	} else {
		fmt.Println(string(value))
	}

}

Output:

Hello Memory Cache

package main

import (
	"context"
	"fmt"
	"os"
	"time"

	"github.com/actforgood/xcache"
	"github.com/actforgood/xconf"
)

func main() {
	// Setup an env (assuming your application configuration comes from env,
	// it's not mandatory to be env, you can use any source loader you want)
	_ = os.Setenv("MY_APP_CACHE_MEM_SIZE", "1048576")
	defer os.Unsetenv("MY_APP_CACHE_MEM_SIZE")

	// Initialize config, we set an alias, as example, as our config key is custom ("MY_APP_CACHE_MEM_SIZE").
	config, err := xconf.NewDefaultConfig(
		xconf.AliasLoader(
			xconf.EnvLoader(),
			xcache.MemoryCfgKeyMemorySize, "MY_APP_CACHE_MEM_SIZE",
		),
		xconf.DefaultConfigWithReloadInterval(2*time.Second),
	)
	if err != nil {
		panic(err)
	}
	defer config.Close()

	// Initialize the cache our application will use.
	cache := xcache.NewMemoryWithConfig(config)

	// From this point forward you can use the cache object however you want.

	// Let's print some stats to see the memory size.
	stats, err := cache.Stats(context.Background())
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(stats)
	}

	// Let's assume we monitor our cache - see StatsWatcher for that,
	// and we notice existing keys count is kind of constant and an increase in evictions,
	// meaning our memory cache is probably full.

	// We decide to increase the memory size.
	_ = os.Setenv("MY_APP_CACHE_MEM_SIZE", "5242880")
	time.Sleep(2500 * time.Millisecond) // wait for config to reload

	// Print again the stats, we can see that memory was changed,
	// without the need of restarting/redeploying our application.
	stats, err = cache.Stats(context.Background())
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(stats)
	}

}

Output:

mem=1M maxMem=1M memUsage=100.00% hits=0 misses=0 hitRate=100.00% keys=0 expired=0 evicted=0
mem=5M maxMem=5M memUsage=100.00% hits=0 misses=0 hitRate=100.00% keys=0 expired=0 evicted=0

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/actforgood/xcache"
)

func main() {
	// create a frontend - backend multi cache.
	frontCache := xcache.NewMemory(10 * 1024 * 1024) // 10 Mb
	backCache := xcache.NewRedis6(xcache.RedisConfig{
		Addrs: []string{"127.0.0.1:6379"},
	})
	defer backCache.Close()
	cache := xcache.NewMulti(frontCache, backCache)

	ctx := context.Background()
	key := "example-multi"
	value := []byte("Hello Multi Cache")
	ttl := 10 * time.Minute

	// save a key for 10 minutes
	if err := cache.Save(ctx, key, value, ttl); err != nil {
		fmt.Println("could not save Multi cache key: " + err.Error())
	}

	// load the key's value
	if value, err := cache.Load(ctx, key); err != nil {
		fmt.Println("could not get Multi cache key: " + err.Error())
	} else {
		fmt.Println(string(value))
	}

	// should output:
	// Hello Multi Cache
}

Output:

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/actforgood/xcache"
)

func main() {
	cache := xcache.NewRedis6(xcache.RedisConfig{
		Addrs: []string{"127.0.0.1:6379"},
	})

	ctx := context.Background()
	key := "example-redis"
	value := []byte("Hello Redis Cache")
	ttl := 10 * time.Minute

	// save a key for 10 minutes
	if err := cache.Save(ctx, key, value, ttl); err != nil {
		fmt.Println("could not save Redis cache key: " + err.Error())
	}

	// load the key's value
	if value, err := cache.Load(ctx, key); err != nil {
		fmt.Println("could not get Redis cache key: " + err.Error())
	} else {
		fmt.Println(string(value))
	}

	// close the cache when no needed anymore/at your application shutdown.
	if err := cache.Close(); err != nil {
		fmt.Println("could not close Redis cache: " + err.Error())
	}

	// should output:
	// Hello Redis Cache
}

Output:

package main

import (
	"bytes"
	"time"

	"github.com/actforgood/xcache"
	"github.com/actforgood/xconf"
)

func main() {
	// Setup the config our application will use (here used a NewFlattenLoader over a json source)
	// You can use whatever config loader suits you as long as needed xcache keys are present.
	config, err := xconf.NewDefaultConfig(
		xconf.NewFlattenLoader(xconf.JSONReaderLoader(bytes.NewReader([]byte(`{
			"xcache": {
			  "redis": {
				"addrs": [
				  "127..0.0.1:6379"
				],
				"db": 0,
				"auth": {
				  "username": "",
				  "password": ""
				},
				"timeout": {
				  "dial": "5s",
				  "read": "6s",
				  "write": "10s"
				},
				"cluster": {
				  "readonly": true
				},
				"failover": {
				  "mastername": "mymaster",
				  "auth": {
					"username": "",
					"password": ""
				  }
				}
			  }
			}
		  }`)))),
		xconf.DefaultConfigWithReloadInterval(5*time.Minute),
	)
	if err != nil {
		panic(err)
	}
	defer config.Close()

	// Initialize the cache our application will use.
	cache := xcache.NewRedis6WithConfig(config)
	defer cache.Close()

	// From this point forward you can do whatever you want with the cache.
	// Any config that gets changed, cache will reconfigure itself in a time up to reload interval (5 mins here)
	// without the need of restarting/redeploying our application.
	// For example, let's assume we notice a lot of timeout errors,
	// until we figure it out what's happening with our Redis server,
	// we can increase read/write timeouts.
}

Output:

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/actforgood/xcache"
)

func main() {
	cache := xcache.NewRedis7(xcache.RedisConfig{
		Addrs: []string{"127.0.0.1:6379"},
	})

	ctx := context.Background()
	key := "example-redis"
	value := []byte("Hello Redis Cache")
	ttl := 10 * time.Minute

	// save a key for 10 minutes
	if err := cache.Save(ctx, key, value, ttl); err != nil {
		fmt.Println("could not save Redis cache key: " + err.Error())
	}

	// load the key's value
	if value, err := cache.Load(ctx, key); err != nil {
		fmt.Println("could not get Redis cache key: " + err.Error())
	} else {
		fmt.Println(string(value))
	}

	// close the cache when no needed anymore/at your application shutdown.
	if err := cache.Close(); err != nil {
		fmt.Println("could not close Redis cache: " + err.Error())
	}

	// should output:
	// Hello Redis Cache
}

Output:

package main

import (
	"bytes"
	"time"

	"github.com/actforgood/xcache"
	"github.com/actforgood/xconf"
)

func main() {
	// Setup the config our application will use (here used a NewFlattenLoader over a json source)
	// You can use whatever config loader suits you as long as needed xcache keys are present.
	config, err := xconf.NewDefaultConfig(
		xconf.NewFlattenLoader(xconf.JSONReaderLoader(bytes.NewReader([]byte(`{
			"xcache": {
			  "redis": {
				"addrs": [
				  "127..0.0.1:6379"
				],
				"db": 0,
				"auth": {
				  "username": "",
				  "password": ""
				},
				"timeout": {
				  "dial": "5s",
				  "read": "6s",
				  "write": "10s"
				},
				"cluster": {
				  "readonly": true
				},
				"failover": {
				  "mastername": "mymaster",
				  "auth": {
					"username": "",
					"password": ""
				  }
				}
			  }
			}
		  }`)))),
		xconf.DefaultConfigWithReloadInterval(5*time.Minute),
	)
	if err != nil {
		panic(err)
	}
	defer config.Close()

	// Initialize the cache our application will use.
	cache := xcache.NewRedis7WithConfig(config)
	defer cache.Close()

	// From this point forward you can do whatever you want with the cache.
	// Any config that gets changed, cache will reconfigure itself in a time up to reload interval (5 mins here)
	// without the need of restarting/redeploying our application.
	// For example, let's assume we notice a lot of timeout errors,
	// until we figure it out what's happening with our Redis server,
	// we can increase read/write timeouts.
}

Output:

package main

import (
	"os"

	"github.com/actforgood/xcache"
	"github.com/actforgood/xlog"
)

func main() {
	// somewhere in your bootstrap process...

	// initialize an xlog.Logger
	loggerOpts := xlog.NewCommonOpts()
	loggerOpts.MinLevel = xlog.FixedLevelProvider(xlog.LevelInfo)
	loggerOpts.Source = xlog.SourceProvider(5, 1)
	logger := xlog.NewSyncLogger(os.Stdout, xlog.SyncLoggerWithOptions(loggerOpts))
	// set the xlog.Logger Redis adapter
	redisLogger := xcache.NewRedisXLogger(logger)
	xcache.SetRedis6Logger(redisLogger) // or xcache.SetRedis7Logger(redisLogger),
	// depending which ver. of Redis you're using.

	// somewhere in your shutdown process ...
	_ = logger.Close()
}

Output:

package main

import (
	"context"
	"fmt"
	"math/rand"
	"strconv"
	"sync"
	"time"

	"github.com/actforgood/xcache"
)

func main() {
	// initialize our application cache...
	cache := xcache.NewMemory(10 * 1024 * 1024) // 10 Mb
	ctx, cancelCtx := context.WithCancel(context.Background())

	// perform some operations upon cache to have some data...
	var wg sync.WaitGroup
	wg.Add(1)
	go generateRandomStats(ctx, cache, &wg)

	// initialize our stats watcher, which will execute a logging callback every second.
	subject := xcache.NewStatsWatcher(cache, time.Second)
	defer subject.Close() // close your watcher! (at your app shutdown eventually)

	// start watching
	subject.Watch(
		context.Background(),
		func(_ context.Context, stats xcache.Stats, err error) {
			if err != nil {
				fmt.Println("could not get cache stats:" + err.Error())
			} else { // do something useful with stats, log / sent it to a metrics system...
				fmt.Println(stats)
			}
		},
	)

	time.Sleep(3 * time.Second)
	cancelCtx() // cancel data generator goroutine
	wg.Wait()   // wait for data generator goroutine to finish

	// should output periodically something like:
	// mem=10M maxMem=10M memUsage=100.00% hits=10 misses=1 hitRate=90.91% keys=10 expired=0 evicted=0
}

func generateRandomStats(ctx context.Context, cache xcache.Cache, wg *sync.WaitGroup) {
	defer wg.Done()

	keyPrefix := "example-stats-watcher-"
	value := []byte("Hello Memory Cache")
	ttl := 5 * time.Minute

	for {
		select {
		case <-ctx.Done():
			return
		default:
			randLoop := rand.Intn(10)
			for i := 0; i <= randLoop; i++ {
				key := keyPrefix + strconv.FormatInt(time.Now().UnixNano(), 10)
				_ = cache.Save(ctx, key, value, ttl)
				_, _ = cache.Load(ctx, key)
			}
			_, _ = cache.Load(ctx, keyPrefix+"miss")
			time.Sleep(100 * time.Millisecond)
		}
	}
}

Output: