Golang Common utility functions

The errors package is a wrapper around the brilliant pkg/errors library. The major difference between pkg/errors and this library is support for the following:

• Wrapping of an error into a custom error so as to add a stacktrace.
• Allows creation of errors with a stack which have no cause(nil cause).
• Every error created supports the fatality interface which is meant to inform us if the error is fatal or not.
• Every error created supports the tagged interface which returns any tags(map[string]string) associated with an error.
• The stacktrace of the error will return the stactrace starting from the deepest cause.

This error is non-fatal. As marked by the last bool flag.

errors.NewError("Error without a cause", nil, false)

cause := errors.NewError("Error without a cause", nil, false)
errWithCause := errors.NewError("Error with a cause", cause, false)

cause := errors.NewError("Error without a cause", nil, false)
if cause.Fatal{
    fmt.Println("This error is fatal.")
}

cause := errors.NewError("Error without a cause", nil, false)
errWithCause := errors.NewError("Error with a cause", cause, false)
fmt.Println(errWithCause.Stacktrace())

Alternatively,

cause := errors.NewError("Error without a cause", nil, false)
errWithCause := errors.NewError("Error with a cause", cause, false)
errWithCause.PrintStackTrace()

The log package is a basic wrapper on the standard log package in Go's stdlib. The log package logs to STDOUT and supports log levels(int).

The log levels currently supported are:

• 0 - ERROR
• 1 - WARN
• 2 - INFO
• 3 - DEBUG
• 4 - TRACE

To log using this package, one needs to use an instance of the log.Logger struct.

The log.Logger struct supports the following methods which can be used to log messages:

• log.Trace(args ...interface{})
• log.Tracef(format string, args ...interface{})
• log.Debug(args ...interface{})
• log.Debugf(format string, args ...interface{})
• log.Info(args ...interface{})
• log.Infof(format string, args ...interface{})
• log.Warn(args ...interface{})
• log.Warnf(format string, args ...interface{})
• log.Error(err error, args ...interface{})
• log.Errorf(err error, format string, args ...interface{})

Each of these methods are wrappers that correspond to a log level. This enforces the user to take cognizance of the log level of whatever they are attempting to log.

To set the log level on a log.Logger struct, make use of the log.SetLevel(level int) function.

To quickly start logging messages, make use of the default logger(default level WARN). This can be done by simply calling the functions stated above.

Eg. To add a trace log

headers := make(map[string]string)
for k := range req.Header {
    headers[strings.ToLower(k)] = req.Header.Get(k)
}
log.SetLevel(log.DEBUG)
log.Tracef("Headers: %s", headers)

Here, we directly make use of the default logger. Please note, since the log level is set to DEBUG here, this trace message will not be logged.

customLogger := log.Logger{log.DEBUG}
customLogger.Debug("This is a debug message")

The vcore/utils package contains basic utility functions and file utilies for downloading, reading and writing to files.