Adding goroutine concurrency to make code efficient

func sendCallback(status string, sender string, recipient string, gatewayMessageId string) *http.Response{
    // data massaging
	response, err := http.Post(postURL, "application/json", responseBody)
	if err != nil{
		panic(err)
	}
	fmt.Printf("POST : %s\n", status)
	return response
}

func callback(rdb *redis.Client) {
	for {
		data, err := rdb.RPop(ctx, "callback").Result()
		if err == redis.Nil {
			fmt.Println("Sleeping")
			time.Sleep(2 * time.Second) // sleep for 2s
			continue
		}

		// more work

       sendCallback(status, sender, recipient, gatewayMessageId)
	}

}



func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1:6379",
		Password: "",
		DB:       0,
	})
	callback(rdb)
}

I understand that the above code is flawed as I'm waiting for "data" to be processed. However, I want it to be non-blocking, and as soon as data is present, I want it to be processed. I have been consuming tutorials on goroutines, but I'm unable to wrap my head around it.

EDIT

Based on @torek explanation, if I take the infinite loop out of the callback function, do it in the main function, and let the callback focus on its part, is this how goroutines should work?

func sendCallback(status string, sender string, recipient string, gatewayMessageId string) *http.Response{
    // data massaging
    response, err := http.Post(postURL, "application/json", responseBody)
    if err != nil{
        panic(err)
    }
    fmt.Printf("POST : %s\n", status)
    return response
}

func callback(data string) {

	parsedData := make(map[string]interface{})
	err := json.Unmarshal([]byte(data), &parsedData)
	if err != nil {
		panic(err)
	}

	sender := parsedData["sender"].(string)
	recipient := parsedData["recipient"].(string)
	gatewayMessageId := parsedData["gateway_message_id"].(string)
  
    sendCallback("sent", sender, recipient, gatewayMessageId)
    sendCallback("delivered", sender, recipient, gatewayMessageId)
}

func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1:6379",
		Password: "",
		DB:       0,
	})
	for {
		data, err := rdb.RPop(ctx, "callback").Result()
		if err == redis.Nil {
			fmt.Println("Sleeping")
			time.Sleep(2 * time.Second) // sleep for 2s
			continue
		}
		go callback(data)
	}
}

I suggest a worker pool solution. The worker pool should help control CPU and memory usage. Big number of goroutines making CPU intensive operation are not optimal due to context switch overhead. But the most important benefit is having the http client under control. Your code creates a goroutine for each message received from redis. These goroutines then make a HTTP request. If the number of messages received from redis is higher than the number of HTTP requests that can be handled by the target service in a period of time, the target service will crash. Alternatively, the application may crash if it reaches a memory limit due to a large number of goroutines. You can set MaxConnsPerHost which will prevent uncontrolled connection creation, but it will not prevent the creation of new goroutines. In my proposal, the application adapts the processing speed to the capabilities of the target service by leveraging the channel. You can increase the number of workers if you find that the target service can handle more requests and you have spare CPU power.

type message struct {
Sender           string `json:"sender"`
Recipient        string `json:"recipient"`
GatewayMessageID string `json:"gateway_message_id"`
}
func sendCallback(status string, m message) *http.Response {
// data massaging
...
response, err := http.Post(postURL, "application/json", responseBody)
if err != nil {
log.Fatal(err)
}
fmt.Printf("POST : %s\n", status)
return response
}
func worker(messages chan []byte) {
for rawMessage := range  messages {
m := message{}
err := json.Unmarshal(rawMessage, &m)
if err != nil {
log.Fatal(err)
}
sendCallback("sent", m)
sendCallback("delivered", m)
}
}
const numberOfWorkers = 10
func main() {
rdb := redis.NewClient(&redis.Options{
Addr:     "127.0.0.1:6379",
Password: "",
DB:       0,
})
messages := make(chan []byte, numberOfWorkers)
for i := 0; i < numberOfWorkers; i++ {
go worker(messages)
}
for {
data, err := rdb.RPop(ctx, "callback").Result()
if err == redis.Nil {
fmt.Println("Sleeping")
time.Sleep(2 * time.Second) // sleep for 2s
continue
} else if err != nil {
log.Fatal(err)
}
messages <- []byte(data)
}
}