The errs package provides utilities for error handling, wrapping, and structured logging in Go. It enhances the standard error handling capabilities by adding additional context and structured logging options.
To install the package, run:
go get github.com/sulton0011/errs- Structured Error Handling: Create and manage errors with detailed context.
- Error Wrapping: Use
WrapandWrapFto add context to existing errors. - Custom Loggers: Support for JSON, text, and file-based logging through
LogTypeconfiguration. - Error Joining: Combine multiple errors into a single message.
- Structured Logging: Log errors in a structured manner using the
sloglibrary with various output formats.
You can create new errors using New or NewF:
package main
import "github.com/sulton0011/errs"
func main() {
err := errs.New("simple error")
errF := errs.NewF("formatted error: %s", "some detail")
println(err.Error()) // Output: simple error
println(errF.Error()) // Output: formatted error: some detail
}To add context to existing errors, use Wrap:
package main
import (
"github.com/sulton0011/errs"
"fmt"
)
func main() {
baseErr := errs.New("file not found")
wrappedErr := errs.Wrap(baseErr, "unable to process config file")
fmt.Println(wrappedErr.Error()) // Output: file not found
}For formatted context, use WrapF:
formattedErr := errs.WrapF(baseErr, "error in %s operation", "read")
fmt.Println(formattedErr.Error()) // Output: error in read operation: file not foundUse Is to compare errors:
if errs.Is(wrappedErr, baseErr) {
fmt.Println("wrappedErr is equal to baseErr")
}You can join multiple errors into a single message:
err1 := errs.New("first error")
err2 := errs.New("second error")
joinedErr := errs.Join(" | ", err1, err2)
fmt.Println(joinedErr.Error()) // Output: first error | second errorConfigure logging for JSON, text, or file-based loggers:
import "github.com/sulton0011/errs"
// Set up a JSON logger
errs.SetLogTypes(errs.LogTypeJSON)
// Set up a file logger
if err := errs.SetLogFile("logs/app.log"); err != nil {
panic(err)
}
errs.SetLogTypes(errs.LogTypeFile)The LogType enum supports three logging formats:
LogTypeJSON: JSON format logging.LogTypeText: Human-readable text format logging.LogTypeFile: Logging to a specified file.
Configure multiple logging types with:
errs.SetLogTypes(errs.LogTypeJSON, errs.LogTypeText)To specify a log file path for file-based logging:
if err := errs.SetLogFile("log/app.log"); err != nil {
panic("Failed to set log file: " + err.Error())
}func New(message string) errorCreates a new error with the specified message.
func NewF(format string, a ...any) errorCreates a new formatted error.
func SetLogTypes(types ...logType)Configures the logging types (e.g., JSON, text, file).
func SetLogFile(filePath string) errorSets the log file path for logging.
func Wrap(err error, args ...any) errorWraps an existing error with additional context.
func Wrapf(err error, format string, args ...any) errorFormats a message and wraps it around an existing error.
func Unwrap(err error) stringReturns the original error message from a wrapped error.
func UnwrapE(err error) errorReturns the original error from a wrapped error.
func Log(err error, req any, msgs ...any)Logs an error asynchronously with additional context messages.
func Join(sep string, errors ...error) errorJoins multiple errors into a single error.
func JoinMsg(sep string, a ...any) stringJoins multiple arguments into a single string.
func Is(err error, target error) boolChecks if any error in the chain matches the target error.
func IsNil(err error) boolChecks if an error is nil.