feat: Add ACLLog to rueidiscompat

Author: blueBlue0102

message.go

@@ -487,6 +487,15 @@ func (r RedisResult) AsClientInfo() (v *ClientInfo, err error) {
 	return
 }
 
+func (r RedisResult) AsACLLogEntry() (v []*ACLLogEntry, err error) {
+	if r.err != nil {
+		err = r.err
+	} else {
+		v, err = r.val.AsACLLogEntry()
+	}
+	return
+}
+
 // IsCacheHit delegates to RedisMessage.IsCacheHit
 func (r RedisResult) IsCacheHit() bool {
 	return r.val.IsCacheHit()
@@ -1557,6 +1566,73 @@ func (m *RedisMessage) AsClientInfo() (*ClientInfo, error) {
 	return info, nil
 }
 
+type ACLLogEntry struct {
+	Count                int64
+	Reason               string
+	Context              string
+	Object               string
+	Username             string
+	AgeSeconds           float64
+	ClientInfo           *ClientInfo
+	EntryID              int64
+	TimestampCreated     int64
+	TimestampLastUpdated int64
+}
+
+func (m *RedisMessage) AsACLLogEntry() ([]*ACLLogEntry, error) {
+	arr, err := m.ToArray()
+	if err != nil {
+		return nil, err
+
+	}
+	logEntries := make([]*ACLLogEntry, 0, len(arr))
+
+	for _, msg := range arr {
+		log, err := msg.AsMap()
+		if err != nil {
+			return nil, err
+		}
+		entry := ACLLogEntry{}
+
+		if attr, ok := log["count"]; ok {
+			entry.Count, err = attr.AsInt64()
+		}
+		if attr, ok := log["reason"]; ok {
+			entry.Reason, err = attr.ToString()
+		}
+		if attr, ok := log["context"]; ok {
+			entry.Context, err = attr.ToString()
+		}
+		if attr, ok := log["object"]; ok {
+			entry.Object, err = attr.ToString()
+		}
+		if attr, ok := log["username"]; ok {
+			entry.Username, err = attr.ToString()
+		}
+		if attr, ok := log["age-seconds"]; ok {
+			entry.AgeSeconds, err = attr.AsFloat64()
+		}
+		if attr, ok := log["client-info"]; ok {
+			entry.ClientInfo, err = attr.AsClientInfo()
+		}
+		if attr, ok := log["entry-id"]; ok {
+			entry.EntryID, err = attr.AsInt64()
+		}
+		if attr, ok := log["timestamp-created"]; ok {
+			entry.TimestampCreated, err = attr.AsInt64()
+		}
+		if attr, ok := log["timestamp-last-updated"]; ok {
+			entry.TimestampLastUpdated, err = attr.AsInt64()
+		}
+
+		if err != nil {
+			return nil, err
+		}
+		logEntries = append(logEntries, &entry)
+	}
+	return logEntries, nil
+}
+
 // ToMap check if message is a redis RESP3 map response, and return it
 func (m *RedisMessage) ToMap() (map[string]RedisMessage, error) {
 	if m.IsMap() {

rueidiscompat/adapter.go

@@ -415,7 +415,7 @@ type CoreCmdable interface {
 	GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd
 
 	ACLDryRun(ctx context.Context, username string, command ...any) *StringCmd
-	// TODO ACLLog(ctx context.Context, count int64) *ACLLogCmd
+	ACLLog(ctx context.Context, count int64) *ACLLogCmd
 	// TODO ACLLogReset(ctx context.Context) *StatusCmd
 
 	ModuleLoadex(ctx context.Context, conf *ModuleLoadexConfig) *StringCmd
@@ -3202,6 +3202,12 @@ func (c *Compat) ACLDryRun(ctx context.Context, username string, command ...any)
 	return newStringCmd(resp)
 }
 
+func (c *Compat) ACLLog(ctx context.Context, count int64) *ACLLogCmd {
+	cmd := c.client.B().AclLog().Count(count).Build()
+	resp := c.client.Do(ctx, cmd)
+	return newACLLogCmd(resp)
+}
+
 func (c *Compat) doPrimaries(ctx context.Context, fn func(c rueidis.Client) error) error {
 	if c.pOnly {
 		return fn(c.client)

rueidiscompat/command.go

@@ -4611,6 +4611,25 @@ func (cmd *ClientInfoCmd) from(res rueidis.RedisResult) {
 	cmd.SetVal(info)
 }
 
+type ACLLogCmd struct {
+	baseCmd[[]*rueidis.ACLLogEntry]
+}
+
+func (cmd *ACLLogCmd) from(res rueidis.RedisResult) {
+	log, err := res.AsACLLogEntry()
+	if err != nil {
+		cmd.SetErr(err)
+		return
+	}
+	cmd.SetVal(log)
+}
+
+func newACLLogCmd(res rueidis.RedisResult) *ACLLogCmd {
+	cmd := &ACLLogCmd{}
+	cmd.from(res)
+	return cmd
+}
+
 // ModuleLoadexConfig struct is used to specify the arguments for the MODULE LOADEX command of redis.
 // `MODULE LOADEX path [CONFIG name value [CONFIG name value ...]] [ARGS args [args ...]]`
 type ModuleLoadexConfig struct {

rueidiscompat/pipeline.go

@@ -2089,6 +2089,12 @@ func (c *Pipeline) ACLDryRun(ctx context.Context, username string, command ...an
 	return ret
 }
 
+func (c *Pipeline) ACLLog(ctx context.Context, count int64) *ACLLogCmd {
+	ret := c.comp.ACLLog(ctx, count)
+	c.rets = append(c.rets, ret)
+	return ret
+}
+
 func (c *Pipeline) TFunctionLoad(ctx context.Context, lib string) *StatusCmd {
 	ret := c.comp.TFunctionLoad(ctx, lib)
 	c.rets = append(c.rets, ret)