// run receives pubsub messages from Redis after establishing a connection.
// When a valid message is received it is broadcast to all connected websockets
func (rr *redisReceiver) run() {
conn := rr.pool.Get()
defer conn.Close()
psc := redis.PubSubConn{conn}
psc.Subscribe(CHANNEL)
for {
switch v := psc.Receive().(type) {
case redis.Message:
log.WithFields(log.Fields{
"channel": v.Channel,
"message": string(v.Data),
}).Println("Redis Message Received")
msg, err := validateMessage(v.Data)
if err != nil {
log.WithFields(log.Fields{
"err": err,
"data": v.Data,
"msg": msg,
}).Error("Error unmarshalling message from Redis")
continue
}
rr.broadcast(v.Data)
case redis.Subscription:
log.WithFields(log.Fields{
"channel": v.Channel,
"kind": v.Kind,
"count": v.Count,
}).Println("Redis Subscription Received")
case error:
log.WithField("err", v).Errorf("Error while subscribed to Redis channel %s", CHANNEL)
default:
log.WithField("v", v).Println("Unknown Redis receive during subscription")
}
}
}
// run the main redisWriter loop that publishes incoming messages to Redis.
func (rw *redisWriter) run() {
conn := rw.pool.Get()
defer conn.Close()
for data := range rw.messages {
ctx := log.Fields{"data": data}
if err := conn.Send("PUBLISH", CHANNEL, data); err != nil {
ctx["err"] = err
log.WithFields(ctx).Fatalf("Unable to publish message to Redis")
}
if err := conn.Flush(); err != nil {
ctx["err"] = err
log.WithFields(ctx).Fatalf("Unable to flush published message to Redis")
}
}
}
// handleWebsocket connection. Update to
func handleWebsocket(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
http.Error(w, "Method not allowed", 405)
return
}
ws, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.WithField("err", err).Println("Upgrading to websockets")
http.Error(w, "Error Upgrading to websockets", 400)
return
}
id := rr.register(ws)
for {
mt, data, err := ws.ReadMessage()
ctx := log.Fields{"mt": mt, "data": data, "err": err}
if err != nil {
if err == io.EOF {
log.WithFields(ctx).Info("Websocket closed!")
} else {
log.WithFields(ctx).Error("Error reading websocket message")
}
break
}
switch mt {
case websocket.TextMessage:
msg, err := validateMessage(data)
if err != nil {
ctx["msg"] = msg
ctx["err"] = err
log.WithFields(ctx).Error("Invalid Message")
break
}
rw.publish(data)
default:
log.WithFields(ctx).Warning("Unknown Message!")
}
}
rr.deRegister(id)
ws.WriteMessage(websocket.CloseMessage, []byte{})
}
// broadcast the provided message to all connected websocket connections.
// If an error occurs while writting a message to a websocket connection it is
// closed and deregistered.
func (rr *redisReceiver) broadcast(data []byte) {
rr.Mutex.Lock()
defer rr.Mutex.Unlock()
for id, conn := range rr.conns {
if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
log.WithFields(log.Fields{
"id": id,
"data": data,
"err": err,
"conn": conn,
}).Error("Error writting data to connection! Closing and removing Connection")
rr.deRegister(id)
}
}
}
func TestLogstashFormatter(t *testing.T) {
assert := assert.New(t)
lf := LogstashFormatter{Type: "abc"}
fields := logrus.Fields{
"message": "def",
"level": "ijk",
"type": "lmn",
"one": 1,
"pi": 3.14,
"bool": true,
}
entry := logrus.WithFields(fields)
entry.Message = "msg"
entry.Level = logrus.InfoLevel
b, _ := lf.Format(entry)
var data map[string]interface{}
dec := json.NewDecoder(bytes.NewReader(b))
dec.UseNumber()
dec.Decode(&data)
// base fields
assert.Equal(json.Number("1"), data["@version"])
assert.NotEmpty(data["@timestamp"])
assert.Equal("abc", data["type"])
assert.Equal("msg", data["message"])
assert.Equal("info", data["level"])
// substituted fields
assert.Equal("def", data["fields.message"])
assert.Equal("ijk", data["fields.level"])
assert.Equal("lmn", data["fields.type"])
// formats
assert.Equal(json.Number("1"), data["one"])
assert.Equal(json.Number("3.14"), data["pi"])
assert.Equal(true, data["bool"])
}