Basic pulse schema

Signed-off-by: Vishal Rana <vr@labstack.com>

Author: vishr

Gopkg.lock

@@ -48,3 +48,7 @@
 [prune]
   go-tests = true
   unused-packages = true
+
+[[constraint]]
+  name = "github.com/go-errors/errors"
+  version = "1.0.1"

Gopkg.toml

@@ -0,0 +1,72 @@
+package pulse
+
+import "github.com/go-errors/errors"
+
+type (
+	Event struct {
+		*Context
+		App       *App       `json:"app" db:"app"`
+		Device    *Device    `json:"device" db:"device"`
+		Exception *Exception `json:"exception" db:"exception"`
+	}
+
+	Context struct {
+		Severity severity `json:"severity" db:"severity"`
+		User     *User    `json:"user" db:"user"`
+		Request  *Request `json:"request" db:"request"`
+		Data     Data     `json:"data" db:"data"`
+	}
+
+	severity string
+
+	User struct {
+		ID string `json:"id"`
+	}
+
+	Request struct {
+	}
+
+	Data map[string]interface{}
+
+	Exception struct {
+		Class      string        `json:"class"`
+		Message    string        `json:"message"`
+		StackTrace []*StackFrame `json:"stack_trace"`
+	}
+
+	StackFrame struct {
+		File     string         `json:"file"`
+		Line     int            `json:"line"`
+		Column   int            `json:"column"`
+		Function string         `json:"function"`
+		Code     map[int]string `json:"code"`
+	}
+)
+
+func newEvent(err *errors.Error, ctx *Context) (e *Event) {
+	e = &Event{
+		Context: ctx,
+		App:     p.App,
+		Device:  p.Device,
+		Exception: &Exception{
+			Class:      err.TypeName(),
+			Message:    err.Error(),
+			StackTrace: make([]*StackFrame, len(err.StackFrames())),
+		},
+	}
+
+	// Defaults
+	if e.Severity == "" {
+		e.Severity = SeverityWarn
+	}
+
+	for i, f := range err.StackFrames() {
+		e.Exception.StackTrace[i] = &StackFrame{
+			File:     f.File,
+			Line:     f.LineNumber,
+			Function: f.Name,
+		}
+	}
+
+	return
+}

pulse/event.go

@@ -1,6 +1,10 @@
 package pulse
 
 import (
+	"fmt"
+	"os"
+
+	"github.com/go-errors/errors"
 	"github.com/go-resty/resty"
 	"github.com/labstack/gommon/log"
 )
@@ -14,88 +18,108 @@ type (
 	}
 
 	Options struct {
+		App    *App
 		Device *Device
 	}
 
-	User struct {
+	App struct {
+		Version string
 	}
 
 	Device struct {
+		Hostname string
 	}
+)
 
-	Data struct {
-	}
-
-	Context struct {
-		user *User
-		data *Data
-	}
-
-	// APIError struct {
-	// 	Code    int    `json:"code"`
-	// 	Message string `json:"message"`
-	// }
+var (
+	p *Pulse
 )
 
+// Severity
 var (
-	global *Pulse
+	SeverityInfo  = severity("info")
+	SeverityWarn  = severity("warn")
+	SeverityError = severity("error")
 )
 
 func Register(apiKey string) {
 	RegisterWithOptions(apiKey, Options{})
 }
 
 func RegisterWithOptions(apiKey string, options Options) {
-	global = &Pulse{
+	p = &Pulse{
 		client: resty.New().
 			SetHostURL("https://api.labstack.com").
 			SetAuthToken(apiKey).
 			SetHeader("User-Agent", "labstack/pulse"),
 		logger: log.New("pulse"),
 	}
-	global.Options = options
+	p.Options = options
 
 	// Defaults
+	if p.Device == nil {
+		p.Device = new(Device)
+	}
+	if p.Device.Hostname == "" {
+		p.Device.Hostname, _ = os.Hostname()
+	}
 }
 
-func (p *Pulse) Report() *Context {
-	return new(Context)
+func (p *Pulse) dispatch(err *errors.Error, ctx *Context) {
+	fmt.Println(err.ErrorStack())
+	// event := newEvent(err, ctx)
+	// b, _ := json.MarshalIndent(event, "", " ")
+	// fmt.Printf("%s", b)
+	// for _, f := range e.StackFrames() {
+	// 	fmt.Println(f.File, f.LineNumber, f.Name)
+	// }
+	// res, err := p.client.R().
+	// 	SetBody(event).
+	// 	// SetError(err).
+	// 	Post("/pulse")
+	// if err != nil {
+	// 	p.logger.Error(err)
+	// 	return
+	// }
+	// if res.StatusCode() < 200 || res.StatusCode() >= 300 {
+	// 	p.logger.Error(res.Body())
+	// }
 }
 
-func (p *Pulse) AutoReport() {
+func Report(err error) {
+	ReportWithContext(err, new(Context))
+}
+
+func ReportWithContext(err error, ctx *Context) {
+	if ee, ok := err.(*errors.Error); ok {
+		p.dispatch(ee, ctx)
+	} else {
+		p.dispatch(errors.Wrap(err, 1), ctx)
+	}
 }
 
-func (p *Pulse) Recover() {
+func AutoReport() {
+	if err := recover(); err != nil {
+		ReportWithContext(errors.Wrap(err, 1), new(Context))
+		panic(err)
+	}
 }
 
-func (c *Context) SetUser(u *User) *Context {
-	c.user = u
-	return c
+func AutoReportWithContext(ctx *Context) {
+	if err := recover(); err != nil {
+		ReportWithContext(errors.Wrap(err, 1), ctx)
+		panic(err)
+	}
 }
 
-func (c *Context) SetData(d *Data) *Context {
-	c.data = d
-	return c
+func Recover() {
+	if err := recover(); err != nil {
+		ReportWithContext(errors.Wrap(err, 1), new(Context))
+	}
 }
 
-// // Dispatch dispatches the requests batch.
-// func (c *Cube) Dispatch() {
-// 	if len(c.requests) == 0 {
-// 		return
-// 	}
-
-// 	// err := new(APIError)
-// 	res, err := c.client.R().
-// 		SetBody(c.readRequests()).
-// 		// SetError(err).
-// 		Post("/cube")
-// 	if err != nil {
-// 		c.logger.Error(err)
-// 		return
-// 	}
-// 	if res.StatusCode() < 200 || res.StatusCode() >= 300 {
-// 		c.logger.Error(res.Body())
-// 	}
-
-// 	c.resetRequests()
-// }
+func RecoverWithContext(ctx *Context) {
+	if err := recover(); err != nil {
+		ReportWithContext(errors.Wrap(err, 1), ctx)
+	}
+}