PSUBSCRIBE

PSUBSCRIBE events:*

import Redis from "ioredis";

const subscriber = new Redis(process.env.REDIS_URL!);
await subscriber.psubscribe("events:*");
subscriber.on("message", (channel, message) => console.log(channel, message));

import { createClient } from "redis";

const subscriber = await createClient({ url: process.env.REDIS_URL }).connect();
await subscriber.pSubscribe("events:*", (message, channel) => {
  console.log(channel, message);
});

import os
import redis

client = redis.from_url(os.environ["REDIS_URL"])
pubsub = client.pubsub()
pubsub.psubscribe("events:*")
for message in pubsub.listen():
    print(message)

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/redis/go-redis/v9"
)

func main() {
    ctx := context.Background()
    opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
    if err != nil {
        panic(err)
    }
    client := redis.NewClient(opts)
    pubsub := client.PSubscribe(ctx, "events:*")
    for message := range pubsub.Channel() {
        fmt.Println(message.Channel, message.Payload)
    }
}

import java.net.URI;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub;

try (Jedis jedis = new Jedis(new URI(System.getenv("REDIS_URL")))) {
  jedis.psubscribe(new JedisPubSub() {
    @Override
    public void onPMessage(String pattern, String channel, String message) {
      System.out.println(channel + ": " + message);
    }
  }, "events:*");
}

fn main() -> redis::RedisResult<()> {
    let url = std::env::var("REDIS_URL").expect("REDIS_URL is not set");
    let client = redis::Client::open(url)?;
    let mut connection = client.get_connection()?;
    let mut pubsub = connection.as_pubsub();
    pubsub.psubscribe("events:*")?;
    loop {
        let message = pubsub.get_message()?;
        let payload: String = message.get_payload()?;
        println!("{payload}");
    }
    #[allow(unreachable_code)]
    Ok(())
}