Merge pull request #2 from efimovalex/Improvements

Improvements: Added context to each error stack and IsNotFound function

Author: efimovalex

.gitignore

@@ -12,3 +12,5 @@
 
 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/
+
+coverage.txt

.travis.yml

@@ -11,9 +11,6 @@ go:
 before_install:
   - go get -t -v ./...
 
-script:
-  - go test -v ./...
-
 script:
   - go test -race -coverprofile=coverage.txt -covermode=atomic
 

README.md

@@ -2,7 +2,13 @@
 [![Build Status](https://travis-ci.org/efimovalex/stackerr.svg?branch=master)](https://travis-ci.org/efimovalex/stackerr)
 [![Go Report Card](https://goreportcard.com/badge/github.com/efimovalex/stackerr)](https://goreportcard.com/report/github.com/efimovalex/stackerr) [![codecov](https://codecov.io/gh/efimovalex/stackerr/branch/master/graph/badge.svg)](https://codecov.io/gh/efimovalex/stackerr) [![GoDoc](https://godoc.org/github.com/efimovalex/stackerr?status.svg)](https://godoc.org/github.com/efimovalex/stackerr)
 
-An error implementation with StatusCode and Stacktrace 
+An error implementation with StatusCode and Stacktrace
+
+It implements the Golang error interface
+
+You can use Status Code to better identify the answer you need to report to the client.
+
+Makes debugging easier by logging the functions the error passes through and by adding the ability to log context on each function pass of the error, so that you can create a path of the error through your application.  
 
 ## Install
 
@@ -15,17 +21,21 @@ $ go get github.com/efimovalex/stackerr
 ```Go
 package main
 
-import "github.com/efimovalex/stackerr"
-import "fmt"
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/efimovalex/stackerr"
+)
 
 func f1() *stackerr.Err {
-	err := stackerr.Error("message")
+	err := stackerr.NewWithStatusCode("message", http.StatusNotFound)
 	return err.Stack()
 }
 
 func f2() *stackerr.Err {
 	err := f1()
-	return err.Stack()
+	return err.StackWithContext("context")
 }
 
 type t1 struct{}
@@ -43,25 +53,36 @@ func main() {
 
 	fmt.Println(err.Error())
 
+	fmt.Println(err.StatusCode)
+
+	if err.IsNotFound() {
+		fmt.Println("Resource is not found")
+	}
+
 	err.Log()
 }
+
 ```
 Output:
 
 ```console
 Error Stacktrace:
--> github.com/efimovalex/stackerr/example/main.go:25 (main.main)
--> github.com/efimovalex/stackerr/example/main.go:19 (main.(*t1).f3)
--> github.com/efimovalex/stackerr/example/main.go:12 (main.f2)
--> github.com/efimovalex/stackerr/example/main.go:7 (main.f1)
+-> github.com/efimovalex/stackerr/example/main.go:29 (main.main)
+-> github.com/efimovalex/stackerr/example/main.go:23 (main.(*t1).f3)
+-> github.com/efimovalex/stackerr/example/main.go:16 (main.f2) context
+-> github.com/efimovalex/stackerr/example/main.go:11 (main.f1)
 
 message
 
-2017/08/31 12:13:47 Error Stacktrace:
--> github.com/efimovalex/stackerr/example/main.go:25 (main.main)
--> github.com/efimovalex/stackerr/example/main.go:19 (main.(*t1).f3)
--> github.com/efimovalex/stackerr/example/main.go:12 (main.f2)
--> github.com/efimovalex/stackerr/example/main.go:7 (main.f1)
+404
+
+Resource is not found
+
+2017/09/05 17:32:15 Error Stacktrace:
+-> github.com/efimovalex/stackerr/example/main.go:29 (main.main)
+-> github.com/efimovalex/stackerr/example/main.go:23 (main.(*t1).f3)
+-> github.com/efimovalex/stackerr/example/main.go:16 (main.f2) context
+-> github.com/efimovalex/stackerr/example/main.go:11 (main.f1)
 ```
 ## Authors
 

example/main.go

@@ -1,16 +1,20 @@
 package main
 
-import "github.com/efimovalex/stackerr"
-import "fmt"
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/efimovalex/stackerr"
+)
 
 func f1() *stackerr.Err {
-	err := stackerr.Error("message")
+	err := stackerr.NewWithStatusCode("message", http.StatusNotFound)
 	return err.Stack()
 }
 
 func f2() *stackerr.Err {
 	err := f1()
-	return err.Stack()
+	return err.StackWithContext("context")
 }
 
 type t1 struct{}
@@ -28,5 +32,15 @@ func main() {
 
 	fmt.Println(err.Error())
 
+	fmt.Println(err.StatusCode)
+
+	if err.IsNotFound() {
+		fmt.Println("Resource is not found")
+	}
+
+	newErr := stackerr.NewFromError(err)
+
 	err.Log()
+
+	newErr.Log()
 }

goerr.go

@@ -3,6 +3,7 @@ package stackerr
 import (
 	"fmt"
 	"log"
+	"net/http"
 	"os"
 	"runtime"
 	"strings"
@@ -21,24 +22,42 @@ func (e *Err) Error() string {
 	return e.Message
 }
 
-// Error - creates a new Err struct
-func Error(message string) *Err {
+// New - creates a new Err struct with 500 Error Code
+func New(message string) *Err {
 	err := Err{
-		Message: message,
+		Message:    message,
+		StatusCode: http.StatusInternalServerError,
 	}
+
 	return err.Stack()
 }
 
-// ErrorWS - creates a new Err struct
-func ErrorWS(message string, statusCode int) *Err {
+// NewWithStatusCode - creates a new Err struct with a custom Error Code
+func NewWithStatusCode(message string, statusCode int) *Err {
 	err := Err{
 		Message:    message,
 		StatusCode: statusCode,
 	}
+
+	return err.Stack()
+}
+
+// NewFromError - creates a new Err struct with a custom Error Code
+func NewFromError(e error) *Err {
+	err := Err{
+		Message:    e.Error(),
+		StatusCode: http.StatusInternalServerError,
+	}
+
 	return err.Stack()
 }
 
-// Stack - Adds the current function and link to the previous Stacktrace
+// IsNotFound - return true if the error type is resource not found.
+func (e *Err) IsNotFound() bool {
+	return e.StatusCode == http.StatusNotFound
+}
+
+// Stack - Adds the current function to Err and a link to the previous Stacktrace
 func (e *Err) Stack() *Err {
 	pc := make([]uintptr, 10) // at least 1 entry needed
 	runtime.Callers(2, pc)
@@ -49,7 +68,23 @@ func (e *Err) Stack() *Err {
 		file = strings.Replace(file, os.Getenv("GOPATH")+"/src/", "", -1)
 	}
 
-	e.stacktrace = &Stack{File: file, Function: getFunctionName(f.Name()), Line: line, CallbackStack: e.stacktrace}
+	e.stacktrace = &Stack{File: file, Function: getFunctionName(f), Line: line, CallbackStack: e.stacktrace}
+	e.stackCount++
+	return e
+}
+
+// StackWithContext - Adds the current function and context to Err and a link to the previous Stacktrace
+func (e *Err) StackWithContext(context string) *Err {
+	pc := make([]uintptr, 10) // at least 1 entry needed
+	runtime.Callers(2, pc)
+	f := runtime.FuncForPC(pc[1])
+	file, line := f.FileLine(pc[1])
+
+	if os.Getenv("GOPATH") != "" {
+		file = strings.Replace(file, os.Getenv("GOPATH")+"/src/", "", -1)
+	}
+	e.stacktrace.Context = context
+	e.stacktrace = &Stack{File: file, Function: getFunctionName(f), Line: line, CallbackStack: e.stacktrace}
 	e.stackCount++
 	return e
 }
@@ -69,8 +104,8 @@ func (e *Err) Log() {
 	log.Print(e.stacktrace.Sprint())
 }
 
-func getFunctionName(name string) string {
-	parts := strings.Split(name, "/")
+func getFunctionName(f *runtime.Func) string {
+	parts := strings.Split(f.Name(), "/")
 
 	return parts[len(parts)-1]
 }

goerr_test.go

@@ -2,21 +2,24 @@ package stackerr
 
 import (
 	"bytes"
+	"errors"
+	"io"
 	"log"
+	"net/http"
 	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
 func f1() *Err {
-	err := Error("message")
+	err := New("message")
 	return err.Stack()
 }
 
 func f2() *Err {
 	err := f1()
-	return err.Stack()
+	return err.StackWithContext("context")
 }
 
 type t1 struct{}
@@ -25,44 +28,50 @@ func (t *t1) f3() *Err {
 	err := f2()
 	return err.Stack()
 }
+
 func TestStackTrace(t *testing.T) {
 	ts := t1{}
 	err := ts.f3()
 
 	assert.NotNil(t, err)
-	assert.Equal(t, err.Error(), "message")
-	assert.Equal(t, err.Sprint(),
+	assert.Equal(t, "message", err.Error())
+	assert.Equal(t,
 		`Error Stacktrace:
--> github.com/efimovalex/stackerr/goerr_test.go:30 (stackerr.TestStackTrace)
--> github.com/efimovalex/stackerr/goerr_test.go:25 (stackerr.(*t1).f3)
--> github.com/efimovalex/stackerr/goerr_test.go:18 (stackerr.f2)
--> github.com/efimovalex/stackerr/goerr_test.go:13 (stackerr.f1)
-`)
+-> github.com/efimovalex/stackerr/goerr_test.go:34 (stackerr.TestStackTrace) 
+-> github.com/efimovalex/stackerr/goerr_test.go:28 (stackerr.(*t1).f3) 
+-> github.com/efimovalex/stackerr/goerr_test.go:21 (stackerr.f2) context
+-> github.com/efimovalex/stackerr/goerr_test.go:16 (stackerr.f1) 
+`, err.Sprint())
 }
 
-func TestError(t *testing.T) {
-	err := Error("message")
+func TestNew(t *testing.T) {
+	err := New("message")
 
 	assert.NotNil(t, err)
-	assert.Equal(t, err.Error(), "message")
-	expected := Err{
-		Message: "message",
-	}
+	assert.Equal(t, "message", err.Error())
+	assert.Equal(t, http.StatusInternalServerError, err.StatusCode)
+}
+
+func TestNewFromError(t *testing.T) {
+	e := errors.New("message")
+	err := NewFromError(e)
 
-	assert.Equal(t, err.Error(), expected.Error())
+	assert.NotNil(t, err)
+	assert.Equal(t, "message", err.Error())
+	assert.Equal(t, http.StatusInternalServerError, err.StatusCode)
+
+	errErr := NewFromError(err)
+	assert.NotNil(t, errErr)
+	assert.Equal(t, "message", errErr.Error())
+	assert.Equal(t, http.StatusInternalServerError, errErr.StatusCode)
 }
-func TestErrorWS(t *testing.T) {
-	err := ErrorWS("message", 200)
+
+func TestNewWithStatusCode(t *testing.T) {
+	err := NewWithStatusCode("message", http.StatusOK)
 
 	assert.NotNil(t, err)
-	assert.Equal(t, err.Error(), "message")
-	expected := Err{
-		Message:    "message",
-		StatusCode: 200,
-	}
-
-	assert.Equal(t, err.Error(), expected.Error())
-	assert.Equal(t, err.StatusCode, expected.StatusCode)
+	assert.Equal(t, "message", err.Error())
+	assert.Equal(t, http.StatusOK, err.StatusCode)
 }
 func TestLog(t *testing.T) {
 	var buf bytes.Buffer
@@ -72,8 +81,45 @@ func TestLog(t *testing.T) {
 	log.SetOutput(os.Stderr)
 	assert.Contains(t, buf.String(),
 		`Error Stacktrace:
--> github.com/efimovalex/stackerr/goerr_test.go:70 (stackerr.TestLog)
--> github.com/efimovalex/stackerr/goerr_test.go:18 (stackerr.f2)
--> github.com/efimovalex/stackerr/goerr_test.go:13 (stackerr.f1)
+-> github.com/efimovalex/stackerr/goerr_test.go:79 (stackerr.TestLog) 
+-> github.com/efimovalex/stackerr/goerr_test.go:21 (stackerr.f2) context
+-> github.com/efimovalex/stackerr/goerr_test.go:16 (stackerr.f1) 
+`)
+}
+
+func TestIsNotFound(t *testing.T) {
+	err := NewWithStatusCode("message", http.StatusOK)
+
+	assert.False(t, err.IsNotFound())
+
+	errNotFound := NewWithStatusCode("message", http.StatusNotFound)
+
+	assert.True(t, errNotFound.IsNotFound())
+}
+
+func TestPrint(t *testing.T) {
+	old := os.Stdout // keep backup of the real stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	outC := make(chan string)
+	// copy the output in a separate goroutine so printing can't block indefinitely
+	go func() {
+		var buf bytes.Buffer
+		io.Copy(&buf, r)
+		outC <- buf.String()
+	}()
+	err := f2()
+	err.Print()
+
+	w.Close()
+	os.Stdout = old // restoring the real stdout
+	out := <-outC
+
+	assert.Equal(t, out,
+		`Error Stacktrace:
+-> github.com/efimovalex/stackerr/goerr_test.go:112 (stackerr.TestPrint) 
+-> github.com/efimovalex/stackerr/goerr_test.go:21 (stackerr.f2) context
+-> github.com/efimovalex/stackerr/goerr_test.go:16 (stackerr.f1) 
 `)
 }