goext/exerr/errinit.go

package exerr

import (
	"fmt"
	"gogs.mikescher.com/BlackForestBytes/goext/langext"
)

type ErrorPackageConfig struct {
	ZeroLogErrTraces       bool                                             // autom print zerolog logs on .Build()  (for SevErr and SevFatal)
	ZeroLogAllTraces       bool                                             // autom print zerolog logs on .Build()  (for all Severities)
	RecursiveErrors        bool                                             // errors contains their Origin-Error
	ExtendedGinOutput      bool                                             // Log extended data (trace, meta, ...) to gin in err.Output()
	IncludeMetaInGinOutput bool                                             // Log meta fields ( from e.g. `.Str(key, val).Build()` ) to gin in err.Output()
	ExtendGinOutput        func(err *ExErr, json map[string]any)            // (Optionally) extend the gin output with more fields
	ExtendGinDataOutput    func(err *ExErr, depth int, json map[string]any) // (Optionally) extend the gin `__data` output with more fields
	DisableErrorWrapping   bool                                             // Disables the exerr.Wrap()...Build() function - will always return the original error
}

type ErrorPackageConfigInit struct {
	ZeroLogErrTraces       *bool
	ZeroLogAllTraces       *bool
	RecursiveErrors        *bool
	ExtendedGinOutput      *bool
	IncludeMetaInGinOutput *bool
	ExtendGinOutput        func(err *ExErr, json map[string]any)
	ExtendGinDataOutput    func(err *ExErr, depth int, json map[string]any)
	DisableErrorWrapping   *bool
}

var initialized = false

var pkgconfig = ErrorPackageConfig{
	ZeroLogErrTraces:       true,
	ZeroLogAllTraces:       false,
	RecursiveErrors:        true,
	ExtendedGinOutput:      false,
	IncludeMetaInGinOutput: true,
	ExtendGinOutput:        func(err *ExErr, json map[string]any) {},
	ExtendGinDataOutput:    func(err *ExErr, depth int, json map[string]any) {},
	DisableErrorWrapping:   false,
}

// Init initializes the exerr packages
// Must be called at the program start, before (!) any errors
// Is not thread-safe
func Init(cfg ErrorPackageConfigInit) {
	if initialized {
		panic("Cannot re-init error package")
	}

	ego := func(err *ExErr, json map[string]any) {}
	egdo := func(err *ExErr, depth int, json map[string]any) {}

	if cfg.ExtendGinOutput != nil {
		ego = cfg.ExtendGinOutput
	}
	if cfg.ExtendGinDataOutput != nil {
		egdo = cfg.ExtendGinDataOutput
	}

	pkgconfig = ErrorPackageConfig{
		ZeroLogErrTraces:       langext.Coalesce(cfg.ZeroLogErrTraces, pkgconfig.ZeroLogErrTraces),
		ZeroLogAllTraces:       langext.Coalesce(cfg.ZeroLogAllTraces, pkgconfig.ZeroLogAllTraces),
		RecursiveErrors:        langext.Coalesce(cfg.RecursiveErrors, pkgconfig.RecursiveErrors),
		ExtendedGinOutput:      langext.Coalesce(cfg.ExtendedGinOutput, pkgconfig.ExtendedGinOutput),
		IncludeMetaInGinOutput: langext.Coalesce(cfg.IncludeMetaInGinOutput, pkgconfig.IncludeMetaInGinOutput),
		ExtendGinOutput:        ego,
		ExtendGinDataOutput:    egdo,
		DisableErrorWrapping:   langext.Coalesce(cfg.DisableErrorWrapping, pkgconfig.DisableErrorWrapping),
	}

	initialized = true
}

func Initialized() bool {
	return initialized
}

func warnOnPkgConfigNotInitialized() {
	if !initialized {
		fmt.Printf("\n")
		fmt.Printf("%s\n", langext.StrRepeat("=", 80))
		fmt.Printf("%s\n", "[WARNING] exerr package used without initializiation")
		fmt.Printf("%s\n", "          call exerr.Init() in your main() function")
		fmt.Printf("%s\n", langext.StrRepeat("=", 80))
		fmt.Printf("\n")
	}
}