XINFO GROUPS can't report that Lag is invalid

[sancar]

XINFO GROUPS returns XInfoGroup.Lag field as 0 when redis reports nil for the Lag. The redis nil error seems to be ignored on purpose here. https://github.com/redis/go-redis/blob/master/command.go#L2151

This makes differentiating that actually lag is zero or it can not be computed.

Expected Behavior

I would expect to see a differentiable value from 0 when it is invalid.

Current Behavior

It returns 0 when redis reports nil for the Lag.

Possible Solution

We can return -1 instead of 0 when redis reports nil for the Lag.

Steps to Reproduce

Here you can find a description when redis reports nil for the lag.

One or more entries between the group's last-delivered-id and the stream's last-generated-id were deleted

https://redis.io/docs/latest/commands/xinfo-groups/

A code example to reproduce:

        r, err := redis.ParseURL("redis://:@127.0.0.1:6379")
    panicOnError(err)
    client := redis.NewClient(r)

    ctx := context.Background()
    client.FlushDB(ctx)

    client.XAdd(ctx, &redis.XAddArgs{Stream: "s", ID: "0-1", Values: []string{"foo", "1"}})
    client.XAdd(ctx, &redis.XAddArgs{Stream: "s", ID: "0-2", Values: []string{"foo", "2"}})
    client.XAdd(ctx, &redis.XAddArgs{Stream: "s", ID: "0-3", Values: []string{"foo", "3"}})

    err = client.XGroupCreate(ctx, "s", "g", "0").Err()
    panicOnError(err)
    err = client.XReadGroup(ctx, &redis.XReadGroupArgs{Group: "g", Consumer: "c", Streams: []string{"s", ">"}, Count: 1, Block: -1, NoAck: false}).Err()
    panicOnError(err)

    client.XDel(ctx, "s", "0-2")

    result, err := client.XInfoGroups(context.Background(), "s").Result()
    panicOnError(err)
    for _, group := range result {
        fmt.Printf("%+v\n", group)
    }

The output it prints: {Name:g Consumers:1 Pending:1 LastDeliveredID:0-1 EntriesRead:1 Lag:0}

What I expected to see: {Name:g Consumers:1 Pending:1 LastDeliveredID:0-1 EntriesRead:1 Lag:-1}

Possible Implementation

The code here can be changed to

group.Lag, err = rd.ReadInt()

// lag: the number of entries in the stream that are still waiting to be delivered
// to the group's consumers, or a NULL(Nil) when that number can't be determined.
if err != nil {
   err == Nil { 
       group.Lag = -1       
   } else {
       return err
   }   
}           

[sancar]

If anyone needs a workaround, I have implemented the following function to use until this issue is fixed:

// CustomXInfoGroup is a custom implementation of XINFO GROUPS that can report -1 for lag when the lag can not be
// computed on the Redis side(redis returns nil for this case).
// go-redis reports 0 when redis returns nil which makes it impossible to report lag correctly.
// This code can be removed once the related issue is fixed in go-redis https://github.com/redis/go-redis/issues/3185
func CustomXInfoGroup(ctx context.Context, client *redis.Client, stream string) ([]redis.XInfoGroup, error) {
    res, err := client.Do(ctx, "XINFO", "GROUPS", stream).Result()
    if err != nil {
        return nil, err
    }
    groups, valid := res.([]any)
    if !valid {
        return nil, errors.New("unexpected type from XINFO GROUPS")
    }
    infoGroups := make([]redis.XInfoGroup, len(groups))
    for i, group := range groups {
        infoGroup := &infoGroups[i]

        switch typeCastedGroup := group.(type) {
        case []any:
            nn := len(typeCastedGroup) / 2
            var key string
            for j := 0; j < nn; j++ {
                key, valid = typeCastedGroup[j*2].(string)
                if !valid {
                    return nil, errors.New("redis: unexpected type from XINFO GROUPS for GROUP key field")
                }
                value := typeCastedGroup[(j*2)+1]
                err = fillInfoGroup(infoGroup, key, value)
                if err != nil {
                    return nil, err
                }
            }
        case map[any]any:
            for key, value := range typeCastedGroup {
                err = fillInfoGroup(infoGroup, key, value)
                if err != nil {
                    return nil, err
                }
            }
        default:
            return nil, errors.New("unexpected type from XINFO GROUPS for GROUP")
        }
    }

    return infoGroups, nil
}

func fillInfoGroup(infoGroup *redis.XInfoGroup, key any, value any) error {
    var valid bool
    switch key {
    case "name":
        infoGroup.Name, valid = value.(string)
        if !valid {
            return errors.New("redis: unexpected type from XINFO GROUPS for GROUP Name field")
        }
    case "consumers":
        infoGroup.Consumers, valid = value.(int64)
        if !valid {
            return errors.New("redis: unexpected type from XINFO GROUPS for GROUP Consumers field")
        }
    case "pending":
        infoGroup.Pending, valid = value.(int64)
        if !valid {
            return errors.New("redis: unexpected type from XINFO GROUPS for GROUP Pending field")
        }
    case "last-delivered-id":
        infoGroup.LastDeliveredID, valid = value.(string)
        if !valid {
            return errors.New("redis: unexpected type from XINFO GROUPS for GROUP LastDeliveredID field")
        }
    case "entries-read":
        infoGroup.EntriesRead, valid = value.(int64)
        if !valid {
            return errors.New("redis: unexpected type from XINFO GROUPS for GROUP EntriesRead field")
        }
    case "lag":
        // lag: the number of entries in the stream that are still waiting to be delivered
        // to the group's consumers, or a NULL(Nil) when that number can't be determined.
        if value == nil {
            infoGroup.Lag = -1
        } else {
            infoGroup.Lag, valid = value.(int64)
            if !valid {
                return errors.New("redis: unexpected type from XINFO GROUPS for GROUP Lag field")
            }
        }
    default:
        return fmt.Errorf("redis: unexpected key %q in XINFO GROUPS reply", key)
    }
    return nil
}