Golang: how to ensure redis subscribers receive all messages from redis pubsub?

I am trying to publish messages to dynamically generated channels in redis while subscribing all messages from the existing channels.
The following seems to work, but it fails to receive some messages depending on the timing of requests from the client (browser).

I tried "fan-in" for the two go channels in the select statement, but it did not work well.

package main

import (
    ...
	"github.com/go-redis/redis/v8"
	"github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}
var rd = redis.NewClient(&redis.Options{
	Addr: "localhost:6379",
})
var ctx = context.Background()

func echo(w http.ResponseWriter, r *http.Request) {
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Println("websocket connection err:", err)
		return
	}
	defer conn.Close()

	room := make(chan string)
	start := make(chan string)

	go func() {
	loop:
		for {
			sub := rd.Subscribe(ctx)
			defer sub.Close()
            
   			channels := []string{}

			for {
				select {
                //it seems that messages are not received when executing this case sometimes
				case channel := <-room:
					log.Println("channel", channel)
					channels = append(channels, channel)
					sub = rd.Subscribe(ctx, channels...)
					start <- "ok"
				case msg := <-sub.Channel():
					log.Println("msg", msg)
					err := conn.WriteMessage(websocket.TextMessage, []byte(msg.Payload))
					if err != nil {
						log.Println("websocket write err:", err)
						break loop
					}
				}
			}

		}
	}()

	for {
		_, msg, err := conn.ReadMessage()
		if err != nil {
			log.Println("websocket read err:", err)
			break
		}
		log.Println(string(msg))

		chPrefix := strings.Split(string(msg), ":")[0]
		ch := chPrefix + "-channel"
		if string(msg) == "test" || string(msg) == "yeah" {
			room <- ch
			log.Println(ch)
			log.Println(<-start)
		}

		if err := rd.Publish(ctx, ch, msg).Err(); err != nil {
			log.Println("redis publish err:", err)
			break
		}
	}

}

func main() {
	http.Handle("/", http.FileServer(http.Dir("./js")))
	http.HandleFunc("/ws", echo)

	log.Println("server starting...", "http://localhost:5000")
	log.Fatal(http.ListenAndServe("localhost:5000", nil))
}

If by all messages, you mean you do not wish to lose any messages, I would recommend using Redis Streams instead of pub/sub. This will ensure you are not missing messages and can go back on the stream history if necessary.

This is an example of using Go, Streams and websockets that should get you started in that direction