Speeding the queries up.

execute_query.go

@@ -3,6 +3,7 @@ package gql
 import (
 	"bytes"
 	"compress/gzip"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -13,111 +14,104 @@ import (
 )
 
 func (qe *QueryExecutor) executeQuery() ([]byte, error) {
-	httpRequest, err := http.NewRequest("POST", qe.endpoint, bytes.NewBuffer(qe.Query))
+	httpRequest, err := http.NewRequest(http.MethodPost, qe.endpoint, bytes.NewBuffer(qe.Query))
 	if err != nil {
-		qe.Logger.Error("Can't create HTTP request;", map[string]interface{}{"error": err})
+		qe.Logger.Error("Can't create HTTP request", map[string]interface{}{"error": err})
 		return nil, err
 	}
 
 	for key, value := range qe.Headers {
-		strValue, ok := value.(string)
+		httpRequest.Header.Set(key, fmt.Sprint(value))
-		if !ok {
-			strValue = fmt.Sprintf("%v", value)
-		}
-		httpRequest.Header.Set(key, strValue)
 	}
 
-	var retries_max int
+	retriesMax := 1
-
 	if qe.Retries {
-		qe.Logger.Debug("Retries enabled - setting max retries", map[string]interface{}{"retries": qe.retries_number})
+		qe.Logger.Debug("Retries enabled", map[string]interface{}{"retries": qe.retries_number})
-		retries_max = qe.retries_number
+		retriesMax = qe.retries_number
 	} else {
-		qe.Logger.Debug("Retries disabled - setting max retries", map[string]interface{}{"retries": 1})
+		qe.Logger.Debug("Retries disabled", map[string]interface{}{"retries": 1})
-		retries_max = 1
 	}
 
-	var httpResponse *http.Response
 	var queryResult queryResults
-
 	err = retry.Do(
 		func() error {
-			httpResponse, err = qe.client.Do(httpRequest)
+			httpResponse, err := qe.client.Do(httpRequest)
 			if err != nil {
-				qe.Logger.Debug("Error while executing http request", map[string]interface{}{"error": err.Error()})
+				qe.Logger.Debug("Error executing HTTP request", map[string]interface{}{"error": err.Error()})
 				return err
 			}
 			defer func() {
 				_, err := io.Copy(io.Discard, httpResponse.Body)
 				if err != nil {
-					qe.Logger.Debug("Error while discarding http response body;", map[string]interface{}{"error": err.Error()})
+					qe.Logger.Debug("Error discarding HTTP response body", map[string]interface{}{"error": err.Error()})
 				}
 				httpResponse.Body.Close()
 			}()
 
-			if httpResponse.StatusCode < 200 || httpResponse.StatusCode >= 204 {
+			if httpResponse.StatusCode < http.StatusOK || httpResponse.StatusCode >= http.StatusNoContent {
-				return fmt.Errorf("HTTP error - unacceptable status code: \"%s\" for \"%s\"", httpResponse.Status, httpRequest.URL)
+				return fmt.Errorf("HTTP error - status code: %s for %s", httpResponse.Status, httpRequest.URL)
 			}
 
 			var reader io.ReadCloser
 			encoding := httpResponse.Header.Get("Content-Encoding")
-			if encoding == "gzip" {
+			switch encoding {
+			case "gzip":
 				reader, err = gzip.NewReader(httpResponse.Body)
 				if err != nil {
-					qe.Logger.Debug("Error while creating gzip reader;", map[string]interface{}{"error": err.Error()})
+					qe.Logger.Debug("Error creating gzip reader", map[string]interface{}{"error": err.Error()})
-					return fmt.Errorf("Error while creating gzip reader: %s", err.Error())
+					return fmt.Errorf("error creating gzip reader: %w", err)
 				}
 				defer reader.Close()
-			} else {
+			default:
 				reader = httpResponse.Body
 			}
 
 			body, err := io.ReadAll(reader)
 			if err != nil {
-				qe.Logger.Debug("Error while reading http response;", map[string]interface{}{"error": err.Error()})
+				qe.Logger.Debug("Error reading HTTP response", map[string]interface{}{"error": err.Error()})
-				return fmt.Errorf("Error while reading http response: %s", err.Error())
+				return fmt.Errorf("error reading HTTP response: %w", err)
 			}
 
 			err = json.Unmarshal(body, &queryResult)
 			if err != nil {
-				qe.Logger.Debug("Error while unmarshalling http response;", map[string]interface{}{"error": err.Error()})
+				qe.Logger.Debug("Error unmarshalling HTTP response", map[string]interface{}{"error": err.Error()})
-				return fmt.Errorf("Error while unmarshalling http response: %s", err.Error())
+				return fmt.Errorf("error unmarshalling HTTP response: %w", err)
 			}
+
 			return nil
 		},
 		retry.OnRetry(func(n uint, err error) {
 			qe.Logger.Warning("Retrying query", map[string]interface{}{"error": err.Error(), "attempt": n})
 		}),
-		retry.Attempts(uint(retries_max)),
+		retry.Attempts(uint(retriesMax)),
 		retry.DelayType(retry.BackOffDelay),
 		retry.Delay(time.Duration(qe.retries_delay)),
 		retry.LastErrorOnly(true),
 	)
-
 	if err != nil {
-		qe.Logger.Debug("Error while executing http request - target server", map[string]interface{}{"error": err.Error()})
+		qe.Logger.Debug("Error executing HTTP request", map[string]interface{}{"error": err.Error()})
 		return nil, err
 	}
 
 	if len(queryResult.Errors) > 0 {
-		qe.Logger.Debug("Error while executing query;", map[string]interface{}{"error": queryResult.Errors})
+		qe.Logger.Debug("Error executing query", map[string]interface{}{"error": queryResult.Errors})
-		return nil, fmt.Errorf("Error while executing query: %s", queryResult.Errors)
+		return nil, fmt.Errorf("error executing query: %s", queryResult.Errors)
 	}
 
 	if queryResult.Data == nil {
-		qe.Logger.Debug("Error while executing query", map[string]interface{}{"error": "no data"})
+		qe.Logger.Debug("Error executing query", map[string]interface{}{"error": "no data"})
-		return nil, fmt.Errorf("Error while executing query: no data")
+		return nil, errors.New("error executing query: no data")
 	}
 
-	json_data, err := json.Marshal(queryResult.Data)
+	jsonData, err := json.Marshal(queryResult.Data)
 	if err != nil {
-		qe.Logger.Debug("Error while marshalling query result;", map[string]interface{}{"error": err.Error(), "data": queryResult.Data})
+		qe.Logger.Debug("Error marshalling query result", map[string]interface{}{"error": err.Error(), "data": queryResult.Data})
-		return nil, fmt.Errorf("Error while marshalling query result: %s. Data: %s", err.Error(), queryResult.Data)
+		return nil, fmt.Errorf("error marshalling query result: %w. Data: %s", err, queryResult.Data)
 	}
 
 	if qe.CacheKey != "no-cache" {
-		qe.cache.Set(qe.CacheKey, json_data, qe.CacheTTL)
+		qe.cache.Set(qe.CacheKey, jsonData, qe.CacheTTL)
 	}
 
-	return json_data, nil
+	return jsonData, nil
 }

go.mod

@@ -3,12 +3,13 @@ module github.com/lukaszraczylo/go-simple-graphql
 go 1.21
 
 require (
-	github.com/avast/retry-go/v4 v4.5.1
+	github.com/avast/retry-go/v4 v4.6.0
+	github.com/buger/jsonparser v1.1.1
 	github.com/goccy/go-json v0.10.2
 	github.com/gookit/goutil v0.6.15
 	github.com/rs/zerolog v1.32.0
-	github.com/stretchr/testify v1.8.4
+	github.com/stretchr/testify v1.9.0
-	golang.org/x/net v0.20.0
+	golang.org/x/net v0.24.0
 )
 
 require (
@@ -18,9 +19,9 @@ require (
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	golang.org/x/sync v0.6.0 // indirect
+	golang.org/x/sync v0.7.0 // indirect
-	golang.org/x/sys v0.16.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
-	golang.org/x/term v0.16.0 // indirect
+	golang.org/x/term v0.19.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,5 +1,7 @@
-github.com/avast/retry-go/v4 v4.5.1 h1:AxIx0HGi4VZ3I02jr78j5lZ3M6x1E0Ivxa6b0pUUh7o=
+github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA=
-github.com/avast/retry-go/v4 v4.5.1/go.mod h1:/sipNsvNB3RRuT5iNcb6h73nw3IBmXJ/H3XrCQYSOpc=
+github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE=
+github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
+github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -22,25 +24,25 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.32.0 h1:keLypqrlIjaFsbmJOBdB/qvyF8KEtCWHwobLp5l/mQ0=
 github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
 github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
 golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561 h1:MDc5xs78ZrZr3HMQugiXOAkSZtfTpbJLDr/lwfgO53E=
 golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
-golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.24.0 h1:1PcaxkF854Fu3+lvBIx5SYn9wRlBzzcnHZSiaFFAb0w=
-golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8=
-golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.16.0 h1:m+B6fahuftsE9qjo0VWp2FW0mB3MTJvR0BaMQrq0pmE=
+golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q=
-golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
+golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

helpers_test.go

@@ -50,12 +50,12 @@ func (suite *Tests) TestBaseClient_decodeResponse() {
 		response []byte
 	}
 	tests := []struct {
-		name     string
-		args     args
 		want     any
-		wantErr  bool
+		name     string
 		setType  string
 		wantType string
+		args     args
+		wantErr  bool
 	}{
 		{
 			name: "TestBaseClient_decodeResponse_mapstring",

logging/logging.go

@@ -1,9 +1,8 @@
 package libpack_logging
 
 import (
+	"io"
 	"os"
-	"strings"
-	"sync"
 	"time"
 
 	"github.com/gookit/goutil/envutil"
@@ -11,83 +10,40 @@ import (
 )
 
 type LogConfig struct {
-	baseLogger  zerolog.Logger
+	logger zerolog.Logger
-	errorLogger zerolog.Logger
-	nopLogger   zerolog.Logger
-	mu          sync.Mutex
-	minLevel    zerolog.Level
 }
 
+var baseLogger zerolog.Logger
+
 func init() {
 	zerolog.TimeFieldFormat = time.RFC3339
-	zerolog.MessageFieldName = "msg"
+	zerolog.MessageFieldName = "short_message"
-	zerolog.TimestampFieldName = "ts"
+	zerolog.TimestampFieldName = "timestamp"
 	zerolog.LevelFieldName = "level"
 	zerolog.LevelFatalValue = "critical"
-}
+	baseLogger = zerolog.New(os.Stdout).With().Timestamp().Logger()
-
-func getMinLogLevel() zerolog.Level {
-	levelStr := strings.ToLower(envutil.Getenv("LOG_LEVEL", "info"))
-	return matchLogLevel(levelStr)
-}
-
-// Add function set the minimum log level instead of using environment variable
-func (lc *LogConfig) SetLogLevel(level string) {
-	lc.mu.Lock()
-	defer lc.mu.Unlock()
-	lc.minLevel = matchLogLevel(level)
-}
-
-// Match the log level provided as string with the log level provided as zerolog.Level
-func matchLogLevel(level string) zerolog.Level {
-	switch level {
-	case "debug":
-		return zerolog.DebugLevel
-	case "warn":
-		return zerolog.WarnLevel
-	case "error":
-		return zerolog.ErrorLevel
-	case "critical":
-		return zerolog.FatalLevel
-	default:
-		return zerolog.InfoLevel
-	}
 }
 
 func NewLogger() *LogConfig {
-	zl := zerolog.New(os.Stdout).With().Timestamp().Logger()
+	switch logLevel := envutil.Getenv("LOG_LEVEL", "info"); logLevel {
-	// Determine the minimum log level from environment variable
+	case "debug":
-	return &LogConfig{
+		baseLogger = baseLogger.Level(zerolog.DebugLevel)
-		baseLogger:  zl,
+	case "warn":
-		errorLogger: zl.Output(os.Stderr),
+		baseLogger = baseLogger.Level(zerolog.WarnLevel)
-		nopLogger:   zerolog.Nop(),
+	case "error":
-		minLevel:    getMinLogLevel(),
+		baseLogger = baseLogger.Level(zerolog.ErrorLevel)
+	default:
+		baseLogger = baseLogger.Level(zerolog.InfoLevel)
 	}
+
+	return &LogConfig{logger: baseLogger}
 }
 
-func (lc *LogConfig) getLogger(level zerolog.Level) zerolog.Logger {
+func (lw *LogConfig) log(w io.Writer, level zerolog.Level, message string, v map[string]interface{}) {
-	if level >= zerolog.ErrorLevel {
+	e := lw.logger.With().Logger()
-		return lc.errorLogger
+	e = e.Output(w)
-	}
+	event := e.WithLevel(level).CallerSkipFrame(3)
-	if level < lc.minLevel {
+	for k, val := range v {
-		return lc.nopLogger
-	}
-	return lc.baseLogger
-}
-
-func (lc *LogConfig) Log(level zerolog.Level, message string, fields []map[string]interface{}) {
-	if level < lc.minLevel {
-		return
-	}
-	logger := lc.getLogger(level)
-	event := logger.WithLevel(level).CallerSkipFrame(3)
-	if len(fields) == 0 {
-		event.Msg(message)
-		return
-	}
-
-	field := fields[0]
-	for k, val := range field {
 		switch v := val.(type) {
 		case string:
 			event.Str(k, v)
@@ -96,39 +52,45 @@ func (lc *LogConfig) Log(level zerolog.Level, message string, fields []map[strin
 		case float64:
 			event.Float64(k, v)
 		default:
-			event.Interface(k, v)
+			event.Interface(k, val)
 		}
 	}
 	event.Msg(message)
 }
 
-func (lc *LogConfig) Info(message string, fields ...map[string]interface{}) {
+func (lw *LogConfig) Debug(message string, v ...map[string]interface{}) {
-	lc.Log(zerolog.InfoLevel, message, fields)
+	if !lw.logger.Debug().Enabled() {
+		return
+	}
+	lw.log(os.Stdout, zerolog.DebugLevel, message, mergeMaps(v))
 }
 
-func (lc *LogConfig) Debug(message string, fields ...map[string]interface{}) {
+func (lw *LogConfig) Info(message string, v ...map[string]interface{}) {
-	lc.Log(zerolog.DebugLevel, message, fields)
+	if !lw.logger.Info().Enabled() {
+		return
+	}
+	lw.log(os.Stdout, zerolog.InfoLevel, message, mergeMaps(v))
 }
 
-func (lc *LogConfig) Warn(message string, fields ...map[string]interface{}) {
+func (lw *LogConfig) Warning(message string, v ...map[string]interface{}) {
-	lc.Log(zerolog.WarnLevel, message, fields)
+	lw.log(os.Stdout, zerolog.WarnLevel, message, mergeMaps(v))
 }
 
-// alias Warning to Warn
+func (lw *LogConfig) Error(message string, v ...map[string]interface{}) {
-func (lc *LogConfig) Warning(message string, fields ...map[string]interface{}) {
+	lw.log(os.Stderr, zerolog.ErrorLevel, message, mergeMaps(v))
-	lc.Warn(message, fields...)
 }
 
-func (lc *LogConfig) Error(message string, fields ...map[string]interface{}) {
+func (lw *LogConfig) Critical(message string, v ...map[string]interface{}) {
-	lc.Log(zerolog.ErrorLevel, message, fields)
+	lw.log(os.Stderr, zerolog.FatalLevel, message, mergeMaps(v))
-}
-
-func (lc *LogConfig) Critical(message string, fields ...map[string]interface{}) {
-	lc.Log(zerolog.FatalLevel, message, fields)
 	os.Exit(1)
 }
 
-// alias Fatal to Critical
+func mergeMaps(maps []map[string]interface{}) map[string]interface{} {
-func (lc *LogConfig) Fatal(message string, fields ...map[string]interface{}) {
+	result := make(map[string]interface{})
-	lc.Critical(message, fields...)
+	for _, m := range maps {
+		for k, v := range m {
+			result[k] = v
+		}
+	}
+	return result
 }

logging/logging_bench_test.go

@@ -25,7 +25,6 @@ func BenchmarkInfoLog(b *testing.B) {
 	}()
 
 	testsLogger := NewLogger()
-	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		testsLogger.Info("test", map[string]interface{}{"test": "test"})
 	}

logging/logging_test.go

@@ -0,0 +1,373 @@
+package libpack_logging
+
+import (
+	"errors"
+	"io"
+	"os"
+	"reflect"
+	"testing"
+
+	"github.com/buger/jsonparser"
+	"github.com/stretchr/testify/suite"
+)
+
+type LoggingTestSuite struct {
+	suite.Suite
+}
+
+var (
+	testsLogger *LogConfig
+)
+
+type stdoutCapture struct {
+	oldStdout *os.File
+	readPipe  *os.File
+}
+
+func (sc *stdoutCapture) StartCapture() {
+	sc.oldStdout = os.Stdout
+	sc.readPipe, os.Stdout, _ = os.Pipe()
+}
+
+func (sc *stdoutCapture) StopCapture() (string, error) {
+	if sc.oldStdout == nil || sc.readPipe == nil {
+		return "", errors.New("StartCapture not called before StopCapture on Stdout")
+	}
+	os.Stdout.Close()
+	os.Stdout = sc.oldStdout
+	bytes, err := io.ReadAll(sc.readPipe)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+type stderrCapture struct {
+	oldStderr *os.File
+	readPipe  *os.File
+}
+
+func (sc *stderrCapture) StartCapture() {
+	sc.oldStderr = os.Stderr
+	sc.readPipe, os.Stderr, _ = os.Pipe()
+}
+
+func (sc *stderrCapture) StopCapture() (string, error) {
+	if sc.oldStderr == nil || sc.readPipe == nil {
+		return "", errors.New("StartCapture not called before StopCapture on Stderr")
+	}
+	os.Stderr.Close()
+	os.Stderr = sc.oldStderr
+	bytes, err := io.ReadAll(sc.readPipe)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+func (suite *LoggingTestSuite) SetupTest() {
+}
+
+func TestLoggingTestSuite(t *testing.T) {
+	suite.Run(t, new(LoggingTestSuite))
+}
+
+func (suite *LoggingTestSuite) TestLogConfig_AllHandlers() {
+	type args struct {
+		message string
+	}
+	tests := []struct {
+		name           string
+		args           args
+		wantLevel      string
+		wantMessage    string
+		envMinLogLevel string
+		loggerType     string
+		stdOutExpect   bool
+		stdErrExpect   bool
+	}{
+		{
+			name:       "Test log: Error",
+			loggerType: "Error",
+			args: args{
+				message: "This is a error message",
+			},
+			wantLevel:    "error",
+			wantMessage:  "This is a error message",
+			stdErrExpect: true,
+			stdOutExpect: false,
+		},
+		{
+			name:       "Test log: Warning",
+			loggerType: "Warning",
+			args: args{
+				message: "This is a warning message",
+			},
+			wantLevel:      "warn",
+			wantMessage:    "This is a warning message",
+			stdErrExpect:   false,
+			stdOutExpect:   true,
+			envMinLogLevel: "info",
+		},
+		{
+			name:       "Test log: Warning | Min level: Debug",
+			loggerType: "Warning",
+			args: args{
+				message: "This is a warning message",
+			},
+			wantLevel:      "warn",
+			wantMessage:    "This is a warning message",
+			stdErrExpect:   false,
+			stdOutExpect:   true,
+			envMinLogLevel: "debug",
+		},
+		{
+			name:       "Test log: Info",
+			loggerType: "Info",
+			args: args{
+				message: "This is a info message",
+			},
+			wantLevel:    "info",
+			wantMessage:  "This is a info message",
+			stdErrExpect: false,
+			stdOutExpect: true,
+		},
+		{
+			name:       "Test log: Info | Min level: Warn",
+			loggerType: "Info",
+			args: args{
+				message: "This is a info message",
+			},
+			wantLevel:      "",
+			wantMessage:    "",
+			stdErrExpect:   false,
+			stdOutExpect:   false,
+			envMinLogLevel: "warn",
+		},
+		{
+			name:       "Test log: Warning | Min level: Warn",
+			loggerType: "Warning",
+			args: args{
+				message: "This is a warning message",
+			},
+			wantLevel:      "warn",
+			wantMessage:    "This is a warning message",
+			stdErrExpect:   false,
+			stdOutExpect:   true,
+			envMinLogLevel: "warn",
+		},
+		{
+			name:       "Test log: Warning | Min level: Error",
+			loggerType: "Warning",
+			args: args{
+				message: "This is an error message",
+			},
+			wantLevel:      "",
+			wantMessage:    "",
+			stdErrExpect:   false,
+			stdOutExpect:   false,
+			envMinLogLevel: "error",
+		},
+		{
+			name:       "Test log: Debug | Min level: Debug",
+			loggerType: "Debug",
+			args: args{
+				message: "This is a debug message",
+			},
+			wantLevel:      "debug",
+			wantMessage:    "This is a debug message",
+			stdErrExpect:   false,
+			stdOutExpect:   true,
+			envMinLogLevel: "debug",
+		},
+	}
+
+	for _, tt := range tests {
+		suite.Run(tt.name, func() {
+			if tt.envMinLogLevel != "" {
+				os.Setenv("LOG_LEVEL", tt.envMinLogLevel)
+				defer os.Unsetenv("LOG_LEVEL")
+			}
+			testsLogger = NewLogger()
+
+			captureStdout := stdoutCapture{}
+			captureStdout.StartCapture()
+			captureStderr := stderrCapture{}
+			captureStderr.StartCapture()
+
+			reflect.ValueOf(testsLogger).MethodByName(tt.loggerType).Call([]reflect.Value{reflect.ValueOf(tt.args.message)})
+
+			stdoutOut, err := captureStdout.StopCapture()
+			if err != nil {
+				suite.T().Fatal(err)
+			}
+
+			stderrOut, err := captureStderr.StopCapture()
+			if err != nil {
+				suite.T().Fatal(err)
+			}
+
+			if tt.stdErrExpect && !tt.stdOutExpect {
+				gotLvl, gotMsg, err := getResponseValues(stderrOut, "short_message")
+				suite.NoError(err, "Failed in [STDERR]: "+tt.name)
+				suite.Equal(tt.wantLevel, gotLvl, "Failed in [STDERR]: "+tt.name)
+				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDERR]: "+tt.name)
+				suite.Equal("", stdoutOut, "Failed in [STDERR]: "+tt.name)
+			}
+			if tt.stdOutExpect && !tt.stdErrExpect {
+				gotLvl, gotMsg, err := getResponseValues(stdoutOut, "short_message")
+				suite.NoError(err, "Failed in [STDOUT]: "+tt.name)
+				suite.Equal(tt.wantLevel, gotLvl, "Failed in [STDOUT]: "+tt.name)
+				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDOUT]: "+tt.name)
+				suite.Equal("", stderrOut, "Failed in [STDOUT]: "+tt.name)
+			}
+			if !tt.stdErrExpect && !tt.stdOutExpect {
+				suite.Equal("", stderrOut, "Failed in [NEITHER]: "+tt.name)
+				suite.Equal("", stdoutOut, "Failed in [NEITHER]: "+tt.name)
+			}
+			os.Unsetenv("LOG_LEVEL")
+		})
+	}
+}
+
+func (suite *LoggingTestSuite) TestFullMessage() {
+	type args struct {
+		extraFields map[string]interface{}
+		message     string
+	}
+	extraFields := make(map[string]interface{})
+	extraFields["_full_message"] = "full message"
+
+	tests := []struct {
+		args           args
+		name           string
+		wantLevel      string
+		wantMessage    string
+		envMinLogLevel string
+		loggerType     string
+		stdOutExpect   bool
+		stdErrExpect   bool
+	}{
+		{
+			name:       "Test log: Error",
+			loggerType: "Error",
+			args: args{
+				message:     "This is a error message",
+				extraFields: extraFields,
+			},
+			wantLevel:    "error",
+			wantMessage:  extraFields["_full_message"].(string),
+			stdErrExpect: true,
+			stdOutExpect: false,
+		},
+		{
+			name:       "Test log: Info",
+			loggerType: "Info",
+			args: args{
+				message:     "This is a info message",
+				extraFields: extraFields,
+			},
+			wantMessage:  extraFields["_full_message"].(string),
+			stdErrExpect: false,
+			stdOutExpect: true,
+		},
+	}
+
+	for _, tt := range tests {
+		suite.Run(tt.name, func() {
+			if tt.envMinLogLevel != "" {
+				os.Setenv("LOG_LEVEL", tt.envMinLogLevel)
+				defer os.Unsetenv("LOG_LEVEL")
+			}
+			testsLogger = NewLogger()
+
+			captureStdout := stdoutCapture{}
+			captureStdout.StartCapture()
+			captureStderr := stderrCapture{}
+			captureStderr.StartCapture()
+
+			reflect.ValueOf(testsLogger).MethodByName(tt.loggerType).Call([]reflect.Value{
+				reflect.ValueOf(tt.args.message),
+				reflect.ValueOf(tt.args.extraFields),
+			})
+
+			stdoutOut, err := captureStdout.StopCapture()
+			if err != nil {
+				suite.T().Fatal(err)
+			}
+
+			stderrOut, err := captureStderr.StopCapture()
+			if err != nil {
+				suite.T().Fatal(err)
+			}
+
+			if tt.stdErrExpect && !tt.stdOutExpect {
+				_, gotMsg, err := getResponseValues(stderrOut, "_full_message")
+				suite.NoError(err, "Failed in [STDERR]: "+tt.name)
+				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDERR]: "+tt.name)
+			}
+			if tt.stdOutExpect && !tt.stdErrExpect {
+				_, gotMsg, err := getResponseValues(stdoutOut, "_full_message")
+				suite.NoError(err, "Failed in [STDOUT]: "+tt.name)
+				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDOUT]: "+tt.name)
+			}
+			os.Unsetenv("LOG_LEVEL")
+		})
+	}
+}
+
+func Test_getResponseValues(t *testing.T) {
+	type args struct {
+		sourceJson string
+	}
+	tests := []struct {
+		name       string
+		args       args
+		wantGotLvl string
+		wantGotMsg string
+		wantErr    bool
+	}{
+		{
+			name: "Test with json",
+			args: args{
+				sourceJson: `{"level": "debug", "short_message": "hello world"`,
+			},
+			wantGotLvl: "debug",
+			wantGotMsg: "hello world",
+			wantErr:    false,
+		},
+		{
+			name: "Test with json, wrong message field",
+			args: args{
+				sourceJson: `{"level": "debug", "message": "hello world"`,
+			},
+			wantGotLvl: "debug",
+			wantGotMsg: "",
+			wantErr:    true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotGotLvl, gotGotMsg, err := getResponseValues(tt.args.sourceJson, "short_message")
+			if (err != nil) != tt.wantErr {
+				t.Errorf("getResponseValues() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if gotGotLvl != tt.wantGotLvl {
+				t.Errorf("getResponseValues() gotGotLvl = %v, want %v", gotGotLvl, tt.wantGotLvl)
+			}
+			if gotGotMsg != tt.wantGotMsg {
+				t.Errorf("getResponseValues() gotGotMsg = %v, want %v", gotGotMsg, tt.wantGotMsg)
+			}
+		})
+	}
+}
+
+func getResponseValues(sourceJson string, key string) (gotLvl, gotMsg string, err error) {
+	gotLvl, err = jsonparser.GetString([]byte(sourceJson), "level")
+	if err != nil {
+		return
+	}
+	gotMsg, err = jsonparser.GetString([]byte(sourceJson), key)
+	return
+}

query.go

@@ -11,15 +11,15 @@ import (
 func (b *BaseClient) convertToJSON(v any) []byte {
 	jsonData, err := json.Marshal(v)
 	if err != nil {
-		b.Logger.Error("Can't convert to json;", map[string]interface{}{"error": err.Error()})
+		b.Logger.Error("Can't convert to JSON", map[string]interface{}{"error": err.Error()})
 		return nil
 	}
 	return jsonData
 }
 
-func (b *BaseClient) compileQuery(query_partials ...any) *Query {
+func (b *BaseClient) compileQuery(queryPartials ...any) *Query {
-	q := new(Query)
+	q := &Query{}
-	for _, partial := range query_partials {
+	for _, partial := range queryPartials {
 		switch val := partial.(type) {
 		case string:
 			q.Query = val
@@ -28,42 +28,39 @@ func (b *BaseClient) compileQuery(query_partials ...any) *Query {
 		}
 	}
 	if q.Query == "" {
-		b.Logger.Error("Can't compile query;", map[string]interface{}{"error": "query is empty"})
+		b.Logger.Error("Can't compile query", map[string]interface{}{"error": "query is empty"})
 		return nil
 	}
 	q.JsonQuery = b.convertToJSON(q)
 	return q
 }
 
-func (b *BaseClient) Query(query string, variables map[string]interface{}, headers map[string]interface{}) (returned_value any, err error) {
+func (b *BaseClient) Query(query string, variables map[string]interface{}, headers map[string]interface{}) (any, error) {
 	compiledQuery := b.compileQuery(query, variables)
 	if compiledQuery.JsonQuery == nil {
-		b.Logger.Error("Can't compile query;", map[string]interface{}{"error": "query is empty"})
+		b.Logger.Error("Can't compile query", map[string]interface{}{"error": "query is empty"})
-		return nil, fmt.Errorf("Can't compile query")
+		return nil, fmt.Errorf("can't compile query")
 	}
+	b.Logger.Debug("Compiled query", map[string]interface{}{"query": compiledQuery})
 
-	b.Logger.Debug("Compiled query;", map[string]interface{}{"query": compiledQuery})
+	enableCache, enableRetries, recompileRequired := compiledQuery.parseHeadersAndVariables(headers)
-	enable_cache, enable_retries, recompile_required := compiledQuery.parseHeadersAndVariables(headers)
+	if recompileRequired {
-
-	if recompile_required {
 		compiledQuery = b.compileQuery(query, variables)
 	}
 
 	var queryHash string
-
+	if (enableCache || b.cache_global) && strutil.HasPrefix(compiledQuery.Query, "query") {
-	if (enable_cache || b.cache_global) && strutil.HasPrefix(compiledQuery.Query, "query") {
 		b.Logger.Debug("Cache enabled")
 		queryHash = calculateHash(compiledQuery)
-		cached_value := b.cacheLookup(queryHash)
+		cachedValue := b.cacheLookup(queryHash)
-		if cached_value != nil {
+		if cachedValue != nil {
 			b.Logger.Debug("Cache hit", map[string]interface{}{"query": compiledQuery})
-			return cached_value, nil
+			return cachedValue, nil
-		} else {
-			b.Logger.Debug("Cache miss", map[string]interface{}{"query": compiledQuery})
 		}
+		b.Logger.Debug("Cache miss", map[string]interface{}{"query": compiledQuery})
 	}
 
-	if enable_retries || b.retries_enable {
+	if enableRetries || b.retries_enable {
 		b.Logger.Debug("Retries enabled")
 	}
 
@@ -74,33 +71,36 @@ func (b *BaseClient) Query(query string, variables map[string]interface{}, heade
 		CacheKey: func() string {
 			if queryHash != "" {
 				return queryHash
-			} else {
-				return "no-cache"
 			}
+			return "no-cache"
 		}(),
-		Retries: enable_retries || b.retries_enable,
+		Retries: enableRetries || b.retries_enable,
 	}
 	defer func() { q = nil }()
+
 	rv, err := q.executeQuery()
 	if err != nil {
-		b.Logger.Error("Error while executing query;", map[string]interface{}{"error": err.Error()})
+		b.Logger.Error("Error executing query", map[string]interface{}{"error": err.Error()})
 		return nil, err
 	}
-	returned_value, err = q.decodeResponse(rv)
+
-	return returned_value, err
+	returnedValue, err := q.decodeResponse(rv)
+	return returnedValue, err
 }
 
-func (q *Query) parseHeadersAndVariables(headers map[string]interface{}) (enable_cache bool, enable_retries bool, recompile_required bool) {
+func (q *Query) parseHeadersAndVariables(headers map[string]interface{}) (enableCache, enableRetries, recompileRequired bool) {
-	if headers != nil {
+	enableCache, _ = goutil.ToBool(searchForKeysInMapStringInterface(headers, "gqlcache"))
-		enable_cache, _ = goutil.ToBool(searchForKeysInMapStringInterface(headers, "gqlcache"))
+	enableRetries, _ = goutil.ToBool(searchForKeysInMapStringInterface(headers, "gqlretries"))
-		enable_retries, _ = goutil.ToBool(searchForKeysInMapStringInterface(headers, "gqlretries"))
+
-	}
 	if q.Variables != nil {
-		enable_cache, _ = goutil.ToBool(searchForKeysInMapStringInterface(q.Variables, "gqlcache"))
+		varEnableCache, _ := goutil.ToBool(searchForKeysInMapStringInterface(q.Variables, "gqlcache"))
-		enable_retries, _ = goutil.ToBool(searchForKeysInMapStringInterface(q.Variables, "gqlretries"))
+		varEnableRetries, _ := goutil.ToBool(searchForKeysInMapStringInterface(q.Variables, "gqlretries"))
+		enableCache = enableCache || varEnableCache
+		enableRetries = enableRetries || varEnableRetries
 		delete(q.Variables, "gqlcache")
 		delete(q.Variables, "gqlretries")
-		recompile_required = true
+		recompileRequired = true
 	}
-	return
+
+	return enableCache, enableRetries, recompileRequired
 }