Can we specify a pattern on shared Redis keyspace event notification that expired?

I am currently using a shared Redis server and was able to get all redis keyspace events that expired using the following configurations below.

redis.conf

# use key-space notification
notify-keyspace-events Ex

application (golang, redis/v8)

pubSub := redis.PubSub(ctx, "__keyevent@0__:expired")
for (
    msg, _ := pubSub.ReceiveMessage(ctx)

    if msg.Payload == "customkeyoncache" {
       // process
     }

)

I am just curious if we can set a pattern on the actual key-space event like?

__keyevent@0__:expired (working, but receiving all)
__customkeyoncache_*@0__:expired (not working)
__keyevent*customkeyoncache@0__:expired (not working)

Maybe someone knows?, getting all the expired events on a shared server.

Thanks

In Redis, it is not possible to directly set a pattern on the keyspace event notification. The key-space event notification system in Redis does not support wildcards or patterns for specifying events.

and you can only subscribe to specific events (e.g., expired keys, set keys, deleted keys, etc.) at a fixed keyspace level.

In your current configuration, when you subscribe to the keyevent@0:expired channel, you will receive notifications for all expired keys in the Redis database (as you mentioned, receiving all expired events). If you need to filter the events based on a specific pattern, you will need to handle the filtering on the client side after receiving the events.

For example, in your Go application, you can check the msg.Payload value (which represents the expired key name) to see if it matches your desired pattern, such as customkeyoncache. If it does match, you can then proceed with further processing.
Here's a modified version of your code snippet with basic pattern filtering:

pubSub := redis.PubSub(ctx, "__keyevent@0__:expired")
for {
    msg, _ := pubSub.ReceiveMessage(ctx)

    // Check if the expired key matches the desired pattern
    if strings.HasPrefix(msg.Payload, "__keyevent@0__:expired") {
        parts := strings.SplitN(msg.Payload, ":", 2)
        key := parts[1]

        if strings.HasPrefix(key, "customkeyoncache_") {
            // Process the expired key with the desired pattern
        }
    }
}

With this modification, you'll only process the expired keys that have the specified pattern (customkeyoncache_) in their names.

Remember that using keyspace event notifications can create some overhead, especially if you have many keys expiring frequently. So, make sure to use them judiciously and consider the impact on your Redis server's performance.