kami_backend/utility/cache/cache.go

package cache

import (
	"context"
	"reflect"
	"strings"
	"time"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/glog"

	"github.com/duke-git/lancet/v2/slice"
	"github.com/gogf/gf/v2/net/gtrace"
	"github.com/gogf/gf/v2/os/gcache"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/gogf/gf/v2/util/guid"
	"go.opentelemetry.io/otel/trace"
)

type Cache struct {
	*gcache.Cache
}

type TraceContext struct {
	TraceID    string
	SpanID     string
	ParentID   string
	Attributes map[string]string
}

type PrefixEnum string

const (
	PrefixRedeemType                           PrefixEnum = "redeem_type"
	PrefixRedeemWithPaymentType                PrefixEnum = "redeem_with_payment_type"
	PrefixRedeemAppleAccountLimitedType        PrefixEnum = "redeem_apple_account_limited_type"
	PrefixAccountLimiterType                   PrefixEnum = "account_limiter_type"
	PrefixJDAccountQueryCache                  PrefixEnum = "jd_account_query_cache"
	PrefixJDAccountQueryBalanceWithCookie      PrefixEnum = "jd_account_query_cache_with_cookie"
	PrefixWalmartAccountQueryCache             PrefixEnum = "walmart_account_query_cache"
	PrefixWalmartAccountQueryBalanceWithCookie PrefixEnum = "walmart_account_query_cache_with_cookie"
	PrefixAppleMachineAccount                  PrefixEnum = "MachineCurrentAccountId"
	PrefixAppleDuplicatedOrder                 PrefixEnum = "apple_duplicated_order"
	PrefixTrace                                PrefixEnum = "trace"
)

func (e PrefixEnum) Key(key interface{}) string {
	return gconv.String(e) + ":" + gconv.String(key)
}

func NewCache() *Cache {
	if cache == nil {
		once.Do(func() {
			cache = &Cache{
				Cache: gcache.New(),
			}
			// cache.SetAdapter(gcache.NewAdapterMemory())
			cache.SetAdapter(gcache.NewAdapterRedis(g.Redis()))
		})
	}
	return cache
}

// Incr 设置计数器缓存
func (i *Cache) Incr(ctx context.Context, key string, duration time.Duration) (err error) {
	result, err := i.Get(ctx, key)
	if result == nil || result.IsNil() {
		_ = i.Set(ctx, key, 1, duration)
		return
	}
	_, _, err = i.Update(ctx, key, result.Int()+1)
	return
}

// Decr 递减缓存
func (i *Cache) Decr(ctx context.Context, key string, duration time.Duration) (err error) {
	result, err := i.Get(ctx, key)
	if result == nil || result.IsNil() {
		_ = i.Set(ctx, key, 0, duration)
		return
	}
	_, _, err = i.Update(ctx, key, result.Int()-1)
	return
}

// GetPrefixKeyNum 获取指定以键为开头的键值对个数
func (i *Cache) GetPrefixKeyNum(ctx context.Context, key interface{}) (count int) {
	keys, _ := i.Keys(ctx)
	count = slice.CountBy(keys, func(index int, item interface{}) bool {
		return strings.HasPrefix(item.(string), key.(string))
	})
	return
}

// SaveTrace 存储追踪信息到Redis中
// SaveTraceToRedis 保存追踪信息到Redis
func (i *Cache) SaveTrace(ctx context.Context, key string) error {
	spanCtx := trace.SpanContextFromContext(ctx)
	if spanCtx.IsValid() {
		return i.Set(ctx, PrefixTrace.Key(key), spanCtx, time.Minute*10)
	}
	return nil
}

// GetTrace 获取追踪信息（恢复追踪能力）
func (i *Cache) GetTrace(ctx context.Context, key string) context.Context {
	value, err := i.Get(ctx, PrefixTrace.Key(key))
	if err != nil || value == nil || value.IsNil() || reflect.TypeOf(value.Interface()) != reflect.TypeOf(trace.SpanContext{}) {
		return ctx
	}
	spanCtx, ok := value.Interface().(trace.SpanContext)
	if !ok {
		glog.Error(ctx, "获取追踪信息失败，类型错误")
		return ctx
	}
	return trace.ContextWithRemoteSpanContext(ctx, spanCtx)
}

// GetTraceID 获取追踪的唯一id
func (i *Cache) GetTraceID(ctx context.Context) string {
	return gtrace.GetSpanID(ctx) + "-" + guid.S()
}

// DeleteTrace 删除追踪信息
func (i *Cache) DeleteTrace(ctx context.Context, key string) {
	_, _ = i.Remove(ctx, PrefixTrace.Key(key))
}