Should things like an app's mailer system run in a separate channel as shown in this example?

Imagine a web service with a fair amount of different routes. Some of them trigger transactional emails being sent to the user. It seems weird to initialise a mailer instance, for instance something using github.com/aws/aws-sdk-go/service/sns every time a request wants to send something.

Instead I'd assume there's one mailer instance and everything happens on a separate channel to which a message gets posted to.

Example

I created a simple example illustrating the problem. A global Mailer instance gets configured once, the Index handler asks for a channel and passes a Message.

package main
import (
"fmt"
"log"
"net/http"
"os"
)
// Message is the custom type used to pass the channel
type Message struct {
To      string
Subject string
Body    string
}
// Mailer is responsible to send out emails
type Mailer struct{}
// send sends out the email
func (m *Mailer) send(message Message) {
fmt.Printf("Sending email to:`%s`\nSubject: %s\n%s\n\n", message.To, message.Subject, message.Body)
}
// Messages returns the channel to which messages can be passed
func (m *Mailer) Messages() chan<- Message {
cm := make(chan Message)
go func() {
msg := <-cm
m.send(msg)
close(cm)
}()
return cm
}
// mailer is a global var in this example, would probably be part of some
// sort of app context that's accessible from any handler.
//
// Note the mailer is NOT handler-scoped.
var mailer = Mailer{} // would this be thread-safe?
// Index handler
func Index(w http.ResponseWriter, r *http.Request) {
m := Message{"email@example.com", fmt.Sprintf("visited `%s`", r.URL.Path[1:]), "Lorem ipsum"}
mailer.Messages() <- m
fmt.Fprintf(w, "Sent out email with subject line `%s`\n", m.Subject)
}
func main() {
http.HandleFunc("/", Index)
port := os.Getenv("PORT")
if port == "" {
port = "8080"
}
if err := http.ListenAndServe(":"+port, nil); err != nil {
log.Fatal("ListenAndServe: ", err)
}
}

Output

Visting http://localhost:8080/hello-world will render…

> Sent out email with subject line `visited `hello-world``

… and log

> sending email to `email@example.com`:
> visited `hello-world`
> Lorem ipsum

Questions

1. Is this the right approach?
2. Is it thread-safe – if not how to get it thread-safe?

You're not really doing anything in this example, but passing message over channels is always safe -- channels are one of the basic concurrency primitives in the language. You are leaving yourself open to the possibility of race conditions, depending on what send actually ends up doing. Another way to handle this is to have send receive from a single channel.

type Mailer struct{
Messages chan Message
}
func (m *Mailer) send() {
for message := range m.Messages {
fmt.Printf("Sending email to:`%s`\nSubject: %s\n%s\n\n", message.To, message.Subject, message.Body)
}
}
var mailer *Mailer
func Index(w http.ResponseWriter, r *http.Request) {
m := Message{"email@example.com", fmt.Sprintf("visited `%s`", r.URL.Path[1:]), "Lorem ipsum"}
mailer.Messages <- m
fmt.Fprintf(w, "Sent out email with subject line `%s`\n", m.Subject)
}
func main() {
mailer = &Mailer{
// buffer up to 100 message to be sent before blocking
Messages: make(chan Message, 100),
}
// start the mailer send loop
go mailer.send()
...