simplify probe APIs

pkg/probe/probe.go

@@ -18,7 +18,6 @@
 package probe
 
 import (
-	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -60,10 +59,10 @@ type tracePoint struct {
 
 // Error implements tracing error functionality.
 type Error struct {
-	lock        sync.RWMutex
-	e           error
-	sysInfo     map[string]string
-	tracePoints []tracePoint
+	lock      sync.RWMutex
+	Cause     error             `json:"cause"`
+	CallTrace []tracePoint      `json:"trace"`
+	SysInfo   map[string]string `json:"sysinfo"`
 }
 
 // NewError function instantiates an error probe for tracing. Original errors.error (golang's error
@@ -74,7 +73,7 @@ func NewError(e error) *Error {
 	if e == nil {
 		return nil
 	}
-	Err := Error{sync.RWMutex{}, e, GetSysInfo(), []tracePoint{}}
+	Err := Error{lock: sync.RWMutex{}, Cause: e, CallTrace: []tracePoint{}, SysInfo: GetSysInfo()}
 	return Err.trace()
 }
 
@@ -104,7 +103,7 @@ func (e *Error) trace(fields ...string) *Error {
 	} else {
 		tp = tracePoint{Line: line, Filename: file, Function: function}
 	}
-	e.tracePoints = append(e.tracePoints, tp)
+	e.CallTrace = append(e.CallTrace, tp)
 	return e
 }
 
@@ -116,101 +115,44 @@ func (e *Error) Untrace() {
 	e.lock.Lock()
 	defer e.lock.Unlock()
 
-	l := len(e.tracePoints)
+	l := len(e.CallTrace)
 	if l == 0 {
 		return
 	}
-	//	topTP := e.tracePoints[l-1]
-	e.tracePoints = e.tracePoints[:l-1]
+	e.CallTrace = e.CallTrace[:l-1]
+}
+
+// ToError returns original error message.
+func (e *Error) ToGoError() error {
+	return e.Cause
 }
 
 // String returns error message.
 func (e *Error) String() string {
-	if e == nil || e.e == nil {
+	if e == nil || e.Cause == nil {
 		return "<nil>"
 	}
 	e.lock.RLock()
 	defer e.lock.RUnlock()
 
-	if e.e != nil {
-		trace := e.e.Error() + "\n"
-		for i, tp := range e.tracePoints {
+	if e.Cause != nil {
+		str := e.Cause.Error() + "\n"
+		for i, tp := range e.CallTrace {
 			if len(tp.Env) > 0 {
-				trace += fmt.Sprintf(" (%d) %s:%d %s(..) Tags: [%s]\n", i, tp.Filename, tp.Line, tp.Function, strings.Join(tp.Env["Tags"], ", "))
+				str += fmt.Sprintf(" (%d) %s:%d %s(..) Tags: [%s]\n", i, tp.Filename, tp.Line, tp.Function, strings.Join(tp.Env["Tags"], ", "))
 			} else {
-				trace += fmt.Sprintf(" (%d) %s:%d %s(..)\n", i, tp.Filename, tp.Line, tp.Function)
+				str += fmt.Sprintf(" (%d) %s:%d %s(..)\n", i, tp.Filename, tp.Line, tp.Function)
 			}
 		}
 
-		trace += " Host:" + e.sysInfo["host.name"] + " | "
-		trace += "OS:" + e.sysInfo["host.os"] + " | "
-		trace += "Arch:" + e.sysInfo["host.arch"] + " | "
-		trace += "Lang:" + e.sysInfo["host.lang"] + " | "
-		trace += "Mem:" + e.sysInfo["mem.used"] + "/" + e.sysInfo["mem.total"] + " | "
-		trace += "Heap:" + e.sysInfo["mem.heap.used"] + "/" + e.sysInfo["mem.heap.total"]
+		str += " Host:" + e.SysInfo["host.name"] + " | "
+		str += "OS:" + e.SysInfo["host.os"] + " | "
+		str += "Arch:" + e.SysInfo["host.arch"] + " | "
+		str += "Lang:" + e.SysInfo["host.lang"] + " | "
+		str += "Mem:" + e.SysInfo["mem.used"] + "/" + e.SysInfo["mem.total"] + " | "
+		str += "Heap:" + e.SysInfo["mem.heap.used"] + "/" + e.SysInfo["mem.heap.total"]
 
-		return trace
+		return str
 	}
 	return "<nil>"
 }
-
-// JSON returns JSON formated error trace.
-func (e *Error) JSON() string {
-	if e == nil || e.e == nil {
-		return "<nil>"
-	}
-
-	e.lock.RLock()
-	defer e.lock.RUnlock()
-
-	anonError := struct {
-		SysInfo     map[string]string
-		TracePoints []tracePoint
-	}{
-		e.sysInfo,
-		e.tracePoints,
-	}
-
-	//	jBytes, err := json.Marshal(anonError)
-	jBytes, err := json.MarshalIndent(anonError, "", "\t")
-	if err != nil {
-		return ""
-	}
-	return string(jBytes)
-}
-
-// ToError returns original embedded error.
-func (e *Error) ToError() error {
-	// No need to lock. "e.e" is set once during New and never changed.
-	return e.e
-}
-
-// WrappedError implements container for *probe.Error
-type WrappedError struct {
-	err *Error
-}
-
-// NewWrappedError function wraps a *probe.Error into a 'error' compatible duck type
-func NewWrappedError(err *Error) error {
-	return &WrappedError{err: err}
-}
-
-// Error interface method
-func (w *WrappedError) Error() string {
-	return w.err.String()
-}
-
-// ToError get the *probe.Error embedded internally
-func (w *WrappedError) ToError() *Error {
-	return w.err
-}
-
-// ToWrappedError try to convert generic 'error' into typed *WrappedError, returns true if yes, false otherwise
-func ToWrappedError(err error) (*WrappedError, bool) {
-	switch e := err.(type) {
-	case *WrappedError:
-		return e, true
-	default:
-		return nil, false
-	}
-}

pkg/probe/probe_test.go

@@ -46,8 +46,8 @@ func (s *MySuite) TestProbe(c *C) {
 
 func (s *MySuite) TestWrappedError(c *C) {
 	_, e := os.Stat("this-file-cannot-exit")
-	es := probe.NewError(e)       // *probe.Error
-	e = probe.NewWrappedError(es) // *probe.WrappedError
-	_, ok := probe.ToWrappedError(e)
+	es := probe.NewError(e) // *probe.Error
+	e = probe.WrapError(es) // *probe.WrappedError
+	_, ok := probe.UnwrapError(e)
 	c.Assert(ok, Equals, true)
 }

pkg/probe/wrapper.go

@@ -0,0 +1,43 @@
+/*
+ * Minimalist Object Storage, (C) 2015 Minio, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses)/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Package probe implements a simple mechanism to trace and return errors in large programs.
+package probe
+
+// wrappedError implements a container for *probe.Error.
+type wrappedError struct {
+	err *Error
+}
+
+// WrapError function wraps a *probe.Error into a 'error' compatible duck type.
+func WrapError(err *Error) error {
+	return &wrappedError{err: err}
+}
+
+// UnwrapError tries to convert generic 'error' into typed *probe.Error and returns true, false otherwise.
+func UnwrapError(err error) (*Error, bool) {
+	switch e := err.(type) {
+	case *wrappedError:
+		return e.err, true
+	default:
+		return nil, false
+	}
+}
+
+// Error interface method.
+func (w *wrappedError) Error() string {
+	return w.err.String()
+}