v0.0.3 - fix payload shape, to conform to opbeat api

Author: xentek

logbeat.go

@@ -5,7 +5,7 @@ import (
 )
 
 // LogbeatVersion is used to identify notifications sent by Logbeat.
-const LogbeatVersion string = "0.0.2"
+const LogbeatVersion string = "0.0.3"
 
 // LogbeatHook delivers logs to the Opbeat service.
 type LogbeatHook struct {

logbeat_test.go

@@ -26,6 +26,8 @@ type LogbeatTestSuite struct {
 	Entry         *logrus.Entry
 	OpbeatHook    *LogbeatHook
 	OpbeatClient  *OpbeatClient
+	OpbeatExtra   OpbeatExtra
+	OpbeatMachine OpbeatMachine
 	OpbeatPayload *OpbeatPayload
 	OpbeatJSON    *bytes.Buffer
 	OpbeatRequest *http.Request
@@ -45,7 +47,7 @@ func (suite *LogbeatTestSuite) SetupTest() {
 	suite.Token = "TEST_TOKEN"
 
 	suite.Entry = &logrus.Entry{
-		Level:   logrus.ErrorLevel,
+		Level:   logrus.PanicLevel,
 		Message: "Example Logbeat Log Entry",
 		Data:    logrus.Fields{"example": "true"},
 		Time:    time.Date(1955, time.November, 05, 9, 11, 12, 13, time.UTC),
@@ -67,12 +69,18 @@ func (suite *LogbeatTestSuite) SetupTest() {
 
 	hostname, _ := os.Hostname()
 	suite.Hostname = hostname
+	suite.OpbeatMachine = NewOpbeatMachine()
+	suite.OpbeatExtra = NewOpbeatExtra(suite.Entry)
 }
 
 func (suite *LogbeatTestSuite) TestLogbeatHookType() {
 	suite.IsType(&LogbeatHook{}, suite.Hook, "expects an instance of LogbeatHook")
 }
 
+func (suite *LogbeatTestSuite) TestLogbeatHookInterface() {
+	suite.Implements((*logrus.Hook)(nil), new(LogbeatHook), "expects OpbeatHook to implment logrus.Hook interface")
+}
+
 func (suite *LogbeatTestSuite) TestNewOpbeatHook() {
 	suite.IsType(&LogbeatHook{}, suite.OpbeatHook, "expects an instance of LogbeatHook.")
 	suite.Equal(suite.OpbeatHook.AppId, "TEST_APP_ID", "expects the correct Opbeat App ID.")

opbeat.go

@@ -24,17 +24,22 @@ type OpbeatClient struct {
 
 // OpbeatPayload structures log entries for Opbeat's API.
 type OpbeatPayload struct {
-	Extra     OpbeatExtra `json:"extra,omitempty"`
-	Level     string      `json:"level"`
-	Logger    string      `json:"logger"`
-	Machine   string      `json:"machine,omitempty"`
-	Message   string      `json:"message"`
-	Timestamp string      `json:"timestamp"`
+	Extra     OpbeatExtra   `json:"extra,omitempty"`
+	Level     string        `json:"level"`
+	Logger    string        `json:"logger"`
+	Machine   OpbeatMachine `json:"machine,omitempty"`
+	Message   string        `json:"message"`
+	Timestamp string        `json:"timestamp"`
 }
 
-// OpbeatExtra structures Logrus Fields for for Opbeat's API.
+// OpbeatExtra structures Logrus Fields for Opbeat's API.
 type OpbeatExtra map[string]interface{}
 
+// OpbeatMachine represents the hostname of the Machine the error occured on to Opbeat's API.
+type OpbeatMachine struct {
+	Hostname string `json:"hostname"`
+}
+
 // NewOpbeatClient returns an OpbeatClient used for commnicating with Opbeat's API.
 func NewOpbeatClient(org, app, token string) *OpbeatClient {
 	client := &http.Client{
@@ -54,20 +59,42 @@ func NewOpbeatClient(org, app, token string) *OpbeatClient {
 	}
 }
 
-// NewOpbeatPayload returns an OpbeatPayload for the given log entry.
-func NewOpbeatPayload(entry *logrus.Entry) *OpbeatPayload {
+// NewOpbeatMachine returns an OpbeatMachine for the current machine.
+func NewOpbeatMachine() OpbeatMachine {
+	var machine = OpbeatMachine{}
+	hostname, err := os.Hostname()
+	if err != nil {
+		return machine
+	}
+	machine.Hostname = hostname
+	return machine
+}
+
+// OpbeatLevel returns the logrus.Level, as a string that Opbeat will accept, for the given logrus.Entry.
+func OpbeatLevel(entry *logrus.Entry) string {
+	level := entry.Level.String()
+	if level == "panic" {
+		level = "critical"
+	}
+	return level
+}
+
+// NewOpbeatExtra returns an OpbeatExtra for the given logrus.Entry.
+func NewOpbeatExtra(entry *logrus.Entry) OpbeatExtra {
 	var extra = OpbeatExtra{}
 	for k, v := range entry.Data {
 		extra[k] = v
 	}
+	return extra
+}
 
-	hostname, _ := os.Hostname()
-
+// NewOpbeatPayload returns an OpbeatPayload for the given logrus.Entry.
+func NewOpbeatPayload(entry *logrus.Entry) *OpbeatPayload {
 	return &OpbeatPayload{
-		Extra:     extra,
-		Level:     entry.Level.String(),
+		Extra:     NewOpbeatExtra(entry),
+		Level:     OpbeatLevel(entry),
 		Logger:    fmt.Sprintf("logbeat-%s", LogbeatVersion),
-		Machine:   hostname,
+		Machine:   NewOpbeatMachine(),
 		Message:   entry.Message,
 		Timestamp: entry.Time.UTC().Format(ISO8601),
 	}

opbeat_test.go

@@ -26,13 +26,27 @@ func (suite *LogbeatTestSuite) TestNewOpbeatClient() {
 	suite.Equal(suite.OpbeatClient.Token, "TEST_TOKEN", "expects the correct Opbeat Token")
 }
 
+func (suite *LogbeatTestSuite) TestNewOpbeatMachine() {
+	suite.IsType(OpbeatMachine{}, NewOpbeatMachine(), "expects an instance of OpbeatMachine")
+	suite.Equal(suite.OpbeatMachine.Hostname, suite.Hostname, "expects the correct hostname")
+}
+
+func (suite *LogbeatTestSuite) TestNewOpbeatExtra() {
+	suite.IsType(OpbeatExtra{}, NewOpbeatExtra(suite.Entry), "expects an instance of OpbeatExtra")
+	suite.Equal(suite.OpbeatExtra["example"], suite.Entry.Data["example"], "expects OpbeatExtra to be the same as Log Entry Data")
+}
+
+func (suite *LogbeatTestSuite) TestOpbeatLevel() {
+	suite.Equal(OpbeatLevel(suite.Entry), "critical", "expects the correct OpbeatLevel")
+}
+
 func (suite *LogbeatTestSuite) TestNewOpbeatPayload() {
 	suite.IsType(&OpbeatPayload{}, suite.OpbeatPayload, "expects an instance of OpbeatPayload")
 	suite.IsType(OpbeatExtra{}, suite.OpbeatPayload.Extra, "expects an instance of OpbeatExtra")
 	suite.Equal(suite.OpbeatPayload.Extra["example"], suite.Entry.Data["example"], "expects OpbeatPayload Extra to be the same as Log Entry Data")
-	suite.Equal(suite.OpbeatPayload.Level, suite.Entry.Level.String(), "expects OpbeatPayload Message to be the same as Log Entry")
+	suite.Equal(suite.OpbeatPayload.Level, "critical", "expects OpbeatPayload Level to be correct")
 	suite.Contains(suite.OpbeatPayload.Logger, LogbeatVersion, "expects OpbeatPayload Logger to contain Logbeat Version")
-	suite.Equal(suite.OpbeatPayload.Machine, suite.Hostname, "expects OpbeatPayload Machine to be the Hostname")
+	suite.Equal(suite.OpbeatPayload.Machine, suite.OpbeatMachine, "expects OpbeatPayload Machine to be the OpbeatMachine")
 	suite.Equal(suite.OpbeatPayload.Message, suite.Entry.Message, "expects OpbeatPayload Message to be the same as Log Entry")
 	suite.Equal(suite.OpbeatPayload.Timestamp, suite.Entry.Time.Format(ISO8601), "expects OpbeatPayload Timestamp to be the same as Log Entry")
 }