Update logging to the common logging format for all the projects.

In high frequency environment the allegro bigcache caused significant
memory usage overhead. This commit replaces it with something much lighter.

README.md

@@ -9,6 +9,7 @@ Ps. It's Hasura friendly.
   - [Features](#features)
   - [Usage example](#usage-example)
     - [Environment variables](#environment-variables)
+    - [Modifiers on the fly](#modifiers-on-the-fly)
     - [Cache](#cache)
     - [Example reader code](#example-reader-code)
     - [Tips](#tips)
@@ -40,6 +41,11 @@ Therefore, I present you the simple client to which you can copy & paste your gr
 * `GRAPHQL_RETRIES_NUMBER` - Number of retries: Default: `1`
 * `GRAPHQL_RETRIES_DELAY` - Delay in retries in milliseconds. Default: `250`
 
+### Modifiers on the fly
+
+* `gql.SetEndpoint('your-endpoint-url')` - modifies endpoint, without the need to set the environment variable
+* `gql.SetOutput('byte')` - modifies output format, without the need to set the environment variable
+
 ### Cache
 
 You have two options to enable the cache:

base.go

@@ -2,34 +2,25 @@ package gql
 
 import (
 	"crypto/tls"
+	"fmt"
 	"time"
 
-	"github.com/lukaszraczylo/go-simple-graphql/utils/concurrency"
-	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
+	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
+	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 
 	"golang.org/x/net/http2"
 
-	"log"
 	"net/http"
-	"os"
 	"strings"
 
-	"github.com/allegro/bigcache"
 	"github.com/gookit/goutil/envutil"
 )
 
 func NewConnection() *BaseClient {
 
 	b := &BaseClient{
-		client:             &http.Client{},
-		concurrencyManager: concurrency.NewPool(-1),
-		MaxGoRoutines:      -1,
-		LoggingLevel:       logger.Warn,
-		LoggerColorful:     true,
-	}
-
-	if b.LoggerWriter == nil {
-		b.LoggerWriter = log.New(os.Stdout, "", log.LstdFlags)
+		client:        &http.Client{},
+		MaxGoRoutines: -1,
 	}
 
 	b.endpoint = envutil.Getenv("GRAPHQL_ENDPOINT", "https://api.github.com/graphql")
@@ -42,38 +33,27 @@ func NewConnection() *BaseClient {
 	b.retries.max = envutil.GetInt("GRAPHQL_RETRIES_MAX", 1)
 	b.retries.delay = envutil.GetInt("GRAPHQL_RETRIES_DELAY", 300)
 
-	if b.cache.enabled {
-		var err error
-		b.cache.client, err = bigcache.NewBigCache(bigcache.DefaultConfig(time.Duration(b.cache.ttl) * time.Second))
-		if err != nil {
-			b.Logger.Error(b, "Error while creating cache client;", "error", err.Error())
-		}
-	}
+	b.enableCache()
 
 	b_tmp_log_level := envutil.Getenv("LOG_LEVEL", "info")
 
-	switch b_tmp_log_level {
-	case "silent":
-		b.LoggingLevel = logger.Silent
-	case "error":
-		b.LoggingLevel = logger.Error
-	case "warn":
-		b.LoggingLevel = logger.Warn
-	case "info":
-		b.LoggingLevel = logger.Info
-	case "debug":
-		b.LoggingLevel = logger.Debug
-	}
-
-	b.Logger = NewLogger(b.LoggerWriter, logger.Config{
-		Colorful: b.LoggerColorful,
-		LogLevel: b.LoggingLevel,
-	})
+	b.Logger = libpack_logging.NewLogger()
 
 	var httpClient *http.Client
+
+	httpTransport := &http.Transport{
+		MaxIdleConns:          10,
+		IdleConnTimeout:       15 * time.Second,
+		ResponseHeaderTimeout: 15 * time.Second,
+		DisableKeepAlives:     false,
+	}
+
 	if strings.HasPrefix(b.endpoint, "http://") {
 		httpClient = &http.Client{
-			Transport: http.DefaultTransport,
+			Transport: httpTransport,
+			CheckRedirect: func(req *http.Request, via []*http.Request) error {
+				return http.ErrUseLastResponse
+			},
 		}
 	} else {
 		tlsClientConfig := &tls.Config{}
@@ -83,6 +63,8 @@ func NewConnection() *BaseClient {
 		http2Transport := &http2.Transport{
 			AllowHTTP:       true,
 			TLSClientConfig: tlsClientConfig,
+			ReadIdleTimeout: 15 * time.Second,
+			PingTimeout:     15 * time.Second,
 		}
 		httpClient = &http.Client{
 			Transport: http2Transport,
@@ -90,8 +72,8 @@ func NewConnection() *BaseClient {
 	}
 	b.client = httpClient
 
-	b.Logger.Debug(b, "graphQL client initialized;", "endpoint", b.endpoint, "responseType", b.responseType, "validate", b.validate, "cache", b.cache.enabled, "cacheTTL", b.cache.ttl, "maxGoRoutines", b.MaxGoRoutines, "loggingLevel", b_tmp_log_level, "loggerColorful", b.LoggerColorful)
-	b.Logger.Info(b, "graphQL client initialized;")
+	b.Logger.Debug("GraphQL client initialized", map[string]interface{}{"endpoint": b.endpoint, "responseType": b.responseType, "validate": b.validate, "cache": b.cache.enabled, "cacheTTL": b.cache.ttl, "maxGoRoutines": b.MaxGoRoutines, "loggingLevel": b_tmp_log_level})
+	b.Logger.Info("GraphQL client initialized")
 	return b
 }
 
@@ -102,3 +84,17 @@ func (b *BaseClient) SetEndpoint(endpoint string) {
 func (b *BaseClient) SetOutput(output string) {
 	b.responseType = output
 }
+
+func (b *BaseClient) enableCache() {
+	var err error
+	b.cache.client = libpack_cache.New(time.Duration(b.cache.ttl) * time.Second * 2)
+	if err != nil {
+		fmt.Println(">> Error while creating cache client;", "error", err.Error())
+		panic(err)
+	}
+}
+
+func (b *BaseClient) disableCache() {
+	b.Logger.Debug("Disabling cache")
+	b.cache.enabled = false
+}

base_test.go

@@ -4,22 +4,37 @@ import (
 	"os"
 	"testing"
 
-	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestNewConnection(t *testing.T) {
 	tests := []struct {
-		want *BaseClient
-		name string
+		want     *BaseClient
+		cache    bool
+		endpoint string
+		output   string
+		name     string
 	}{
 		{
-			name: "Test NewConnection",
+			name:     "Test NewConnection https",
+			endpoint: "https://api.github.com/graphql",
+			output:   "string",
+			cache:    true,
 			want: &BaseClient{
 				endpoint:     "https://api.github.com/graphql",
 				responseType: "string",
 			},
 		},
+		{
+			name:     "Test NewConnection http",
+			endpoint: "http://api.github.com/graphql",
+			output:   "mapstring",
+			cache:    false,
+			want: &BaseClient{
+				endpoint:     "http://api.github.com/graphql",
+				responseType: "mapstring",
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -27,76 +42,19 @@ func TestNewConnection(t *testing.T) {
 			// and GRAPHQL_OUTPUT to string
 			current := os.Getenv("GRAPHQL_ENDPOINT")
 			defer os.Setenv("GRAPHQL_ENDPOINT", current)
-			os.Setenv("GRAPHQL_ENDPOINT", "https://api.github.com/graphql")
-
+			os.Setenv("GRAPHQL_ENDPOINT", tt.endpoint)
 			got := NewConnection()
+			got.SetEndpoint(tt.endpoint)
+			got.SetOutput(tt.output)
+			if tt.cache {
+				got.enableCache()
+			} else {
+				got.disableCache()
+			}
+
 			assert.Equal(t, tt.want.endpoint, got.endpoint)
 			assert.Equal(t, tt.want.responseType, got.responseType)
-		})
-	}
-}
-
-func TestNewConnectionLogLevels(t *testing.T) {
-	tests := []struct {
-		want *BaseClient
-		name string
-		env  string
-	}{
-		{
-			name: "Test NewConnection with log level set to debug",
-			env:  "debug",
-			want: &BaseClient{
-				endpoint:     "https://api.github.com/graphql",
-				responseType: "string",
-				LoggingLevel: logger.Debug,
-			},
-		},
-
-		{
-			name: "Test NewConnection with log level set to info",
-			env:  "info",
-			want: &BaseClient{
-				endpoint:     "https://api.github.com/graphql",
-				responseType: "string",
-				LoggingLevel: logger.Info,
-			},
-		},
-
-		{
-			name: "Test NewConnection with log level set to warn",
-			env:  "warn",
-			want: &BaseClient{
-				endpoint:     "https://api.github.com/graphql",
-				responseType: "string",
-				LoggingLevel: logger.Warn,
-			},
-		},
-
-		{
-			name: "Test NewConnection with log level set to error",
-			env:  "error",
-			want: &BaseClient{
-				endpoint:     "https://api.github.com/graphql",
-				responseType: "string",
-				LoggingLevel: logger.Error,
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// temporarily set GRAPHQL_ENDPOINT env variable to https://api.github.com/graphql
-			// and GRAPHQL_OUTPUT to string
-			current := os.Getenv("GRAPHQL_ENDPOINT")
-			defer os.Setenv("GRAPHQL_ENDPOINT", current)
-			os.Setenv("GRAPHQL_ENDPOINT", "https://api.github.com/graphql")
-			current_log_level := os.Getenv("LOG_LEVEL")
-			defer os.Setenv("LOG_LEVEL", current_log_level)
-			os.Setenv("LOG_LEVEL", tt.env)
-
-			got := NewConnection()
-			assert.Equal(t, tt.want.endpoint, got.endpoint)
-			assert.Equal(t, tt.want.responseType, got.responseType)
-			assert.Equal(t, tt.want.LoggingLevel, got.LoggingLevel)
+			assert.Equal(t, tt.cache, got.cache.enabled)
 		})
 	}
 }

cache.go

@@ -2,13 +2,13 @@ package gql
 
 func (c *BaseClient) cacheLookup(hash string) []byte {
 	if c.cache.client != nil {
-		g, err := c.cache.client.Get(hash)
-		if err == nil {
-			c.Logger.Debug(c, "Cache hit;", "hash", hash)
-			return g
+		obj, found := c.cache.client.Get(hash)
+		if found {
+			c.Logger.Debug("Cache hit", map[string]interface{}{"hash": hash})
+			return obj
 		}
 		// if error is not nil it means that hash is not present in cache
-		c.Logger.Debug(c, "Cache miss;", "hash", hash)
+		c.Logger.Debug("Cache miss", map[string]interface{}{"hash": hash})
 	}
 	return nil
 }

go.mod

@@ -1,29 +1,30 @@
 module github.com/lukaszraczylo/go-simple-graphql
 
-go 1.20
+go 1.21
 
 require (
-	github.com/allegro/bigcache v1.2.1
-	github.com/avast/retry-go/v4 v4.3.3
-	github.com/gookit/goutil v0.6.8
+	github.com/avast/retry-go/v4 v4.5.0
+	github.com/gookit/goutil v0.6.14
 	github.com/json-iterator/go v1.1.12
-	github.com/stretchr/testify v1.8.2
-	golang.org/x/net v0.9.0
+	github.com/lukaszraczylo/graphql-monitoring-proxy v0.5.23
+	github.com/stretchr/testify v1.8.4
+	golang.org/x/net v0.17.0
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/gookit/color v1.5.3 // indirect
-	github.com/kr/pretty v0.3.0 // indirect
+	github.com/gookit/color v1.5.4 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rs/zerolog v1.31.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	golang.org/x/exp v0.0.0-20221126150942-6ab00d035af9 // indirect
-	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/sys v0.7.0 // indirect
-	golang.org/x/term v0.7.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+	golang.org/x/sync v0.4.0 // indirect
+	golang.org/x/sys v0.13.0 // indirect
+	golang.org/x/term v0.13.0 // indirect
+	golang.org/x/text v0.13.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,61 +1,68 @@
-github.com/allegro/bigcache v1.2.1 h1:hg1sY1raCwic3Vnsvje6TT7/pnZba83LeFck5NrFKSc=
-github.com/allegro/bigcache v1.2.1/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
-github.com/avast/retry-go/v4 v4.3.3 h1:G56Bp6mU0b5HE1SkaoVjscZjlQb0oy4mezwY/cGH19w=
-github.com/avast/retry-go/v4 v4.3.3/go.mod h1:rg6XFaiuFYII0Xu3RDbZQkxCofFwruZKW8oEF1jpWiU=
+github.com/avast/retry-go/v4 v4.5.0 h1:QoRAZZ90cj5oni2Lsgl2GW8mNTnUCnmpx/iKpwVisHg=
+github.com/avast/retry-go/v4 v4.5.0/go.mod h1:7hLEXp0oku2Nir2xBAsg0PTphp9z71bN5Aq1fboC3+I=
+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/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 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=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/gookit/color v1.5.3 h1:twfIhZs4QLCtimkP7MOxlF3A0U/5cDPseRT9M/+2SCE=
-github.com/gookit/color v1.5.3/go.mod h1:NUzwzeehUfl7GIb36pqId+UGmRfQcU/WiiyTTeNjHtE=
-github.com/gookit/goutil v0.6.8 h1:B2XXSCGav5TXWtKRT9i/s/owOLXXB7sY6UsfqeSLroE=
-github.com/gookit/goutil v0.6.8/go.mod h1:u+Isykc6RQcZ4GQzulsaGm+Famd97U5Tzp3aQyo+jyA=
+github.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=
+github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=
+github.com/gookit/goutil v0.6.14 h1:96elyOG4BvVoDaiT7vx1vHPrVyEtFfYlPPBODR0/FGQ=
+github.com/gookit/goutil v0.6.14/go.mod h1:YyDBddefmjS+mU2PDPgCcjVzTDM5WgExiDv5ZA/b8I8=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
-github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/lukaszraczylo/graphql-monitoring-proxy v0.5.23 h1:MKrrnlXqqcsdlXyJ00CDZQOis7nTtoNMInM5P0VAhks=
+github.com/lukaszraczylo/graphql-monitoring-proxy v0.5.23/go.mod h1:81HTNAtartVlKdlSplx1dl1cSQbWYkxSOIYjNFjtVnI=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rogpeppe/go-internal v1.6.1 h1:/FiVV8dS/e+YqF2JvO3yXRFbBLTIuSDkuC7aBOAvL+k=
-github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.31.0 h1:FcTR3NnLWW+NnTwwhFWiJSZr4ECLpqCm6QsEnyvbV4A=
+github.com/rs/zerolog v1.31.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 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-20221126150942-6ab00d035af9 h1:yZNXmy+j/JpX19vZkVktWqAo7Gny4PBWYYK3zskGpx4=
-golang.org/x/exp v0.0.0-20221126150942-6ab00d035af9/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
-golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
-golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.7.0 h1:BEvjmm5fURWqcfbSKTdpkDXYBrUS1c0m8agp14W48vQ=
-golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
+golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
+golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
+golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ=
+golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+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.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
+golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.13.0 h1:bb+I9cTfFazGW51MZqBVmZy7+JEJMouUHTUSKVQLBek=
+golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
+golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

logger.go

@@ -1,141 +0,0 @@
-package gql
-
-import (
-	"fmt"
-	"reflect"
-	"time"
-
-	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
-
-	"github.com/gookit/goutil/timex"
-)
-
-func NewLogger(writer Writer, config logger.Config) Logger {
-	colorfulPrint := "%s[%s]%s %%s %%s"
-	closeColor, debugColor, infoColor, warnColor, errorColor := "\033[0m", "\033[1;34m", "\033[1;32m", "\033[1;33m", "\033[1;31m"
-	if !config.Colorful {
-		closeColor, debugColor, infoColor, warnColor, errorColor = "", "", "", "", ""
-	}
-	debugStr := fmt.Sprintf(colorfulPrint, debugColor, "DEBUG", closeColor)
-	infoStr := fmt.Sprintf(colorfulPrint, infoColor, "INFO", closeColor)
-	warnStr := fmt.Sprintf(colorfulPrint, warnColor, "WARN", closeColor)
-	errStr := fmt.Sprintf(colorfulPrint, errorColor, "ERROR", closeColor)
-
-	return &logging{
-		Writer:   writer,
-		Config:   config,
-		infoStr:  infoStr,
-		warnStr:  warnStr,
-		errStr:   errStr,
-		debugStr: debugStr,
-	}
-}
-
-func setDate() string {
-	tx := time.Now()
-	return timex.DateFormat(tx, "Y-m-d H:I:S")
-}
-
-func (l logging) Debug(client *BaseClient, msg string, data ...any) {
-	if l.LogLevel >= logger.Debug {
-		t := setDate()
-		msg, data = censorSensitiveInfo(client, msg, data...)
-		if client != nil {
-			l.Printf(l.debugStr, fmt.Sprintf("[%s] %s", t, msg), sprint(data...))
-		} else {
-			l.Printf(l.debugStr, msg, sprint(data...))
-		}
-	}
-}
-
-func (l logging) Info(client *BaseClient, msg string, data ...any) {
-	if l.LogLevel >= logger.Info {
-		t := setDate()
-		msg, data = censorSensitiveInfo(client, msg, data...)
-		if client != nil {
-			l.Printf(l.infoStr, fmt.Sprintf("[%s] %s", t, msg), sprint(data...))
-		} else {
-			l.Printf(l.infoStr, msg, sprint(data...))
-		}
-	}
-}
-
-func (l logging) Warn(client *BaseClient, msg string, data ...any) {
-	if l.LogLevel >= logger.Warn {
-		t := setDate()
-		msg, data = censorSensitiveInfo(client, msg, data...)
-		if client != nil {
-			l.Printf(l.warnStr, fmt.Sprintf("[%s] %s", t, msg), sprint(data...))
-		} else {
-			l.Printf(l.warnStr, msg, sprint(data...))
-		}
-	}
-}
-
-func (l logging) Error(client *BaseClient, msg string, data ...any) {
-	if l.LogLevel >= logger.Error {
-		t := setDate()
-		msg, data = censorSensitiveInfo(client, msg, data...)
-		if client != nil {
-			l.Printf(l.errStr, fmt.Sprintf("[%s] %s", t, msg), sprint(data...))
-		} else {
-			l.Printf(l.errStr, msg, sprint(data...))
-		}
-	}
-}
-
-type Logger interface {
-	Debug(*BaseClient, string, ...any)
-	Info(*BaseClient, string, ...any)
-	Warn(*BaseClient, string, ...any)
-	Error(*BaseClient, string, ...any)
-}
-
-type Writer interface {
-	Printf(string, ...any)
-}
-
-type logging struct {
-	Writer
-	debugStr string
-	infoStr  string
-	warnStr  string
-	errStr   string
-	logger.Config
-}
-
-func censorSensitiveInfo(client *BaseClient, a string, b ...any) (string, []any) {
-	// if client == nil || client.Token == "" {
-	// 	return a, b
-	// }
-	// tokenFixed := strings.Split(client.Token, ":")[1]
-	// for t := range b {
-	// 	if b[t] != nil {
-	// 		rV := reflect.TypeOf(b[t]).Kind()
-	// 		if rV == reflect.String {
-	// 			b[t] = strings.ReplaceAll(b[t].(string), tokenFixed, strings.Repeat("X", len(tokenFixed)))
-	// 		}
-	// 	}
-	// }
-	// a = strings.ReplaceAll(a, tokenFixed, strings.Repeat("X", len(tokenFixed)))
-	// return a, b
-	return a, b
-}
-
-func sprint(a ...any) string {
-	for t := range a {
-		if a[t] != nil {
-			rV := reflect.TypeOf(a[t]).Kind()
-			if rV == reflect.Ptr {
-				a[t] = reflect.ValueOf(a[t]).Elem().Interface()
-			}
-			rV = reflect.TypeOf(a[t]).Kind()
-			if rV == reflect.Struct || rV == reflect.Map || rV == reflect.Slice {
-				a[t], _ = logger.Serialize(a[t])
-			}
-		}
-	}
-	r := fmt.Sprintln(a...)
-	r = r[:len(r)-1]
-	return r
-}

query.go

@@ -3,12 +3,10 @@ package gql
 import (
 	"context"
 	"fmt"
-	"reflect"
 	"strconv"
 
-	"github.com/lukaszraczylo/go-simple-graphql/utils/helpers"
-
 	"github.com/gookit/goutil/strutil"
+	"github.com/lukaszraczylo/go-simple-graphql/utils/helpers"
 
 	jsoniter "github.com/json-iterator/go"
 )
@@ -18,7 +16,7 @@ var json = jsoniter.ConfigCompatibleWithStandardLibrary
 func (c *BaseClient) convertToJson(v any) []byte {
 	json, err := json.Marshal(v)
 	if err != nil {
-		c.Logger.Error(c, "Can't convert to json;", "error", err.Error())
+		c.Logger.Error("Can't convert to json;", map[string]interface{}{"error": err.Error()})
 		return nil
 	}
 	return json
@@ -45,7 +43,7 @@ func (c *BaseClient) NewQuery(q ...any) *Query {
 		Variables: query.variables,
 	})
 
-	c.Logger.Debug(c, "Clearing previously prepared variables and query")
+	c.Logger.Debug("Clearing previously prepared variables and query")
 	query.variables = nil
 
 	if query.context == nil {
@@ -53,11 +51,11 @@ func (c *BaseClient) NewQuery(q ...any) *Query {
 	}
 
 	if c.validate {
-		c.Logger.Warn(c, "Validating query is not active")
+		c.Logger.Warning("Validating query is active")
 	}
 
 	query.query = ""
-	c.Logger.Debug(c, "Query prepared;", "query", helpers.BytesToString(query.compiledQuery))
+	c.Logger.Debug("Query prepared", map[string]interface{}{"query": query.compiledQuery})
 
 	return query
 }
@@ -70,52 +68,45 @@ func (c *BaseClient) NewQuery(q ...any) *Query {
 // It looks a bit weird because of the backward compatibility
 
 func (c *BaseClient) Query(queryContent string, queryVariables interface{}, queryHeaders map[string]interface{}) (any, error) {
-	query := c.NewQuery(queryContent, queryVariables)
 
+	compiledQuery := c.NewQuery(queryContent, queryVariables)
+	parseQueryHeaders, enabledCache, headersModified, enabledRetries := compiledQuery.parseQueryHeaders(queryHeaders)
+
+	var should_cache, retries_enabled bool
 	var queryHash string
-	var cachedResponse []byte
-	var cacheBaseClient BaseClient
 
-	// Check for library specific headers
-	if len(queryHeaders) > 0 {
-		cacheBaseClient = reflect.ValueOf(*c).Interface().(BaseClient)
-		queryHeaders = c.parseQueryHeaders(queryHeaders)
+	if headersModified {
+		should_cache = enabledCache
+		retries_enabled = enabledRetries
+	} else {
+		should_cache = c.cache.enabled
+		retries_enabled = c.retries.enabled
 	}
 
-	if c.cache.enabled {
-		queryHash = strutil.Md5(query.compiledQuery)
-		c.Logger.Debug(c, "Hash calculated;", "hash:", queryHash)
-
-		cachedResponse = c.cacheLookup(queryHash)
-		if cachedResponse != nil {
-			c.Logger.Debug(c, "Found cached response")
-			return c.decodeResponse(cachedResponse), nil
-		} else {
-			c.Logger.Debug(c, "No cached response found")
-		}
+	// if queryContent does not start with `query` then we don't want to cache it
+	// because it's probably a mutation or subscription.
+	if !strutil.HasPrefix(queryContent, "query") {
+		should_cache = false
 	}
 
-	response, err := c.executeQuery(query.compiledQuery, queryHeaders)
-	if err != nil {
-		c.Logger.Error(c, "Error while executing query;", "error", err.Error())
-		return nil, err
+	if should_cache {
+		queryHash = strutil.Md5(fmt.Sprintf("%s-%+v", compiledQuery.compiledQuery, queryHeaders))
 	}
 
-	jsonData, err := json.Marshal(response)
-	if err != nil {
-		c.Logger.Error(c, "Error while converting to json;", "error", err.Error())
-		return nil, err
+	q := &queryExecutor{
+		client:          c,
+		query:           compiledQuery.compiledQuery,
+		headers:         parseQueryHeaders,
+		context:         context.Background(),
+		should_cache:    should_cache,
+		retries_enabled: retries_enabled,
+		hash:            queryHash,
 	}
 
-	if c.cache.enabled {
-		c.cache.client.Set(queryHash, jsonData)
-	}
+	q.execute()
+	defer q.done()
 
-	if len(queryHeaders) > 0 {
-		*c = cacheBaseClient
-	}
-
-	return c.decodeResponse(jsonData), err
+	return q.result.data, q.result.errors
 }
 
 func (c *BaseClient) decodeResponse(jsonData []byte) any {
@@ -124,7 +115,7 @@ func (c *BaseClient) decodeResponse(jsonData []byte) any {
 		var response map[string]interface{}
 		err := json.Unmarshal(jsonData, &response)
 		if err != nil {
-			c.Logger.Error(c, "Error while converting to map[string]interface{};", "error", err.Error())
+			c.Logger.Error("Error while converting to map[string]interface{};", map[string]interface{}{"error": err.Error()})
 			return nil
 		}
 		return response
@@ -133,23 +124,29 @@ func (c *BaseClient) decodeResponse(jsonData []byte) any {
 	case "byte":
 		return jsonData
 	default:
-		c.Logger.Error(c, "Unknown response type", "response", c.responseType)
+		c.Logger.Error("Unknown response type", map[string]interface{}{"response": c.responseType})
 		return nil
 	}
 }
 
-func (c *BaseClient) parseQueryHeaders(queryHeaders map[string]interface{}) (returnHeaders map[string]interface{}) {
+func (q *Query) parseQueryHeaders(queryHeaders map[string]interface{}) (returnHeaders map[string]interface{}, cache_enabled bool, headers_modified bool, retries_enabled bool) {
 	returnHeaders = make(map[string]interface{})
+	var err error
+
 	for k, v := range queryHeaders {
 		if k == "gqlcache" {
-			c.cache.enabled, _ = strconv.ParseBool(fmt.Sprintf("%v", v))
+			cache_enabled, err = strconv.ParseBool(fmt.Sprintf("%v", v))
+			if err != nil {
+				panic(fmt.Sprintf("Unable to parse gqlcache value %s", err.Error()))
+			}
+			headers_modified = true
 			continue
 		}
 		if k == "gqlretries" {
-			c.retries.enabled, _ = strconv.ParseBool(fmt.Sprintf("%v", v))
+			retries_enabled, _ = strconv.ParseBool(fmt.Sprintf("%v", v))
 			continue
 		}
 		returnHeaders[k] = v
 	}
-	return returnHeaders
+	return returnHeaders, cache_enabled, headers_modified, retries_enabled
 }

query_test.go

@@ -1,6 +1,7 @@
 package gql
 
 import (
+	"math/rand"
 	"reflect"
 	"testing"
 
@@ -40,6 +41,17 @@ func TestBaseClient_convertToJson(t *testing.T) {
 			},
 			want: []byte(`{"query":"query { hello }","variables":{"name":"John"}}`),
 		},
+		{
+			name:   "Test NewQuery with modifier",
+			fields: fields{},
+			args: args{
+				v: map[string]interface{}{
+					"query":     "query @cached(ttl: 120) { hello }",
+					"variables": map[string]interface{}{"name": "John"},
+				},
+			},
+			want: []byte(`{"query":"query @cached(ttl: 120) { hello }","variables":{"name":"John"}}`),
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -88,6 +100,19 @@ func TestBaseClient_NewQuery(t *testing.T) {
 				compiledQuery: []byte(`{"variables":{"name":"John"},"query":"query { hello }"}`),
 			},
 		},
+		{
+			name:   "Test NewQuery with modifier",
+			fields: fields{},
+			args: args{
+				q: []any{
+					"query @cached(ttl: 120) { hello }",
+					map[string]interface{}{"name": "John"},
+				},
+			},
+			want: &Query{
+				compiledQuery: []byte(`{"variables":{"name":"John"},"query":"query @cached(ttl: 120) { hello }"}`),
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -133,6 +158,20 @@ func TestBaseClient_decodeResponse(t *testing.T) {
 			},
 			want: []byte(`{"data":{"hello":"world"}}`),
 		},
+		{
+			name: "Test decodeResponse - mapstring",
+			fields: fields{
+				responseType: "mapstring",
+			},
+			args: args{
+				jsonData: []byte(`{"data":{"hello":"world"}}`),
+			},
+			want: map[string]interface{}{
+				"data": map[string]interface{}{
+					"hello": "world",
+				},
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -297,10 +336,10 @@ func TestBaseClient_parseQueryHeaders(t *testing.T) {
 		queryHeaders map[string]interface{}
 	}
 	tests := []struct {
-		name              string
 		fields            fields
 		args              args
 		wantReturnHeaders map[string]interface{}
+		name              string
 	}{
 		{
 			name:   "Test parseQueryHeaders - no change",
@@ -332,10 +371,200 @@ func TestBaseClient_parseQueryHeaders(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := NewConnection()
-			if gotReturnHeaders := c.parseQueryHeaders(tt.args.queryHeaders); !reflect.DeepEqual(gotReturnHeaders, tt.wantReturnHeaders) {
+			q := &Query{}
+			if gotReturnHeaders, _, _, _ := q.parseQueryHeaders(tt.args.queryHeaders); !reflect.DeepEqual(gotReturnHeaders, tt.wantReturnHeaders) {
 				t.Errorf("BaseClient.parseQueryHeaders() = %v, want %v", gotReturnHeaders, tt.wantReturnHeaders)
 			}
 		})
 	}
 }
+
+func TestBaseClient_QueryCache(t *testing.T) {
+	type fields struct {
+		graphql_endpoint string
+		cache_enabled    bool
+	}
+	type args struct {
+		queryVariables interface{}
+		queryHeaders   map[string]interface{}
+		queryContent   string
+	}
+	tests := []struct {
+		want    any
+		args    args
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "Test QueryCache - enabled",
+			fields: fields{
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
+				cache_enabled:    true,
+			},
+			args: args{
+				queryContent: `query Dragons {
+					dragons {
+						name
+					}
+				}`,
+				queryHeaders: map[string]interface{}{
+					"x-apollo-operation-name": "Missions-Potato-Test-Golang",
+					"content-type":            "application/json",
+				},
+			},
+		},
+		{
+			name: "Test QueryCache - disabled",
+			fields: fields{
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
+				cache_enabled:    false,
+			},
+			args: args{
+				queryContent: `query Dragons {
+					dragons {
+						name
+					}
+				}`,
+				queryHeaders: map[string]interface{}{
+					"x-apollo-operation-name": "Missions-Potato-Test-Golang",
+					"content-type":            "application/json",
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := NewConnection()
+			c.cache.enabled = tt.fields.cache_enabled
+
+			if tt.fields.graphql_endpoint != "" {
+				c.endpoint = tt.fields.graphql_endpoint
+			}
+
+			_, err := c.Query(tt.args.queryContent, tt.args.queryVariables, tt.args.queryHeaders)
+			if !tt.wantErr {
+				assert.NoError(t, err)
+			} else {
+				assert.Error(t, err)
+			}
+		})
+	}
+}
+
+func TestBaseClient_QueryCacheRandomizedRace(t *testing.T) {
+	type fields struct {
+		graphql_endpoint string
+		cache_enabled    bool
+	}
+	type args struct {
+		queryVariables interface{}
+		queryHeaders   map[string]interface{}
+		queryContent   string
+	}
+	tests := []struct {
+		want    any
+		args    args
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "Test QueryCache - enabled",
+			fields: fields{
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
+			},
+			args: args{
+				queryContent: `query Dragons {
+					dragons {
+						name
+					}
+				}`,
+				queryHeaders: map[string]interface{}{
+					"x-apollo-operation-name": "Missions-Potato-Test-Golang",
+					"content-type":            "application/json",
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := NewConnection()
+			if tt.fields.graphql_endpoint != "" {
+				c.endpoint = tt.fields.graphql_endpoint
+			}
+
+			for i := 0; i < 10; i++ {
+				c.cache.enabled = rand.Intn(2) == 0
+				go func() {
+					_, err := c.Query(tt.args.queryContent, tt.args.queryVariables, tt.args.queryHeaders)
+					if !tt.wantErr {
+						assert.NoError(t, err)
+					} else {
+						assert.Error(t, err)
+					}
+				}()
+			}
+		})
+	}
+}
+
+func TestBaseClient_QueryCacheRandomizedRaceViaHeader(t *testing.T) {
+	type fields struct {
+		graphql_endpoint string
+		cache_enabled    bool
+	}
+	type args struct {
+		queryVariables interface{}
+		queryHeaders   map[string]interface{}
+		queryContent   string
+	}
+	tests := []struct {
+		want    any
+		args    args
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "Test QueryCache - enabled",
+			fields: fields{
+				graphql_endpoint: "https://spacex-production.up.railway.app/",
+			},
+			args: args{
+				queryContent: `query Dragons {
+					dragons {
+						name
+					}
+				}`,
+				queryHeaders: map[string]interface{}{
+					"x-apollo-operation-name": "Missions-Potato-Test-Golang",
+					"content-type":            "application/json",
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := NewConnection()
+			if tt.fields.graphql_endpoint != "" {
+				c.endpoint = tt.fields.graphql_endpoint
+			}
+
+			for i := 0; i < 10; i++ {
+				go func() {
+					tt.args.queryHeaders["gqlcache"] = rand.Intn(2) == 0
+					_, err := c.Query(tt.args.queryContent, tt.args.queryVariables, tt.args.queryHeaders)
+					if !tt.wantErr {
+						assert.NoError(t, err)
+					} else {
+						assert.Error(t, err)
+					}
+				}()
+			}
+		})
+	}
+}

request.go

@@ -3,8 +3,9 @@ package gql
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
+	"time"
 
 	"github.com/avast/retry-go/v4"
 )
@@ -13,7 +14,7 @@ func (c *BaseClient) executeQuery(query []byte, headers any) (result any, err er
 	var queryResult queryResults
 	httpRequest, err := http.NewRequest("POST", c.endpoint, bytes.NewBuffer(query))
 	if err != nil {
-		c.Logger.Error(c, "Error while creating http request;", "error", err.Error())
+		c.Logger.Error("Error while creating http request;", map[string]interface{}{"error": err.Error()})
 		return
 	}
 
@@ -21,35 +22,48 @@ func (c *BaseClient) executeQuery(query []byte, headers any) (result any, err er
 		httpRequest.Header.Add(key, fmt.Sprintf("%s", value))
 	}
 
+	var retries_available = c.retries.max
+	if !c.retries.enabled {
+		retries_available = 1
+	}
+
 	var httpResponse *http.Response
 
 	err = retry.Do(
 		func() error {
 			httpResponse, err = c.client.Do(httpRequest)
 			if err != nil {
-				c.Logger.Error(c, "Error while executing http request;", "error", err.Error())
+				c.Logger.Error("Error while executing http request;", map[string]interface{}{"error": err.Error()})
 				return err
 			}
+			defer io.Copy(io.Discard, httpResponse.Body) // equivalent to `cp body /dev/null`
 			defer httpResponse.Body.Close()
 
 			if httpResponse.StatusCode <= 200 && httpResponse.StatusCode >= 204 {
 				return err
 			}
 
-			body, err := ioutil.ReadAll(httpResponse.Body)
+			body, err := io.ReadAll(httpResponse.Body)
 			if err != nil {
-				c.Logger.Error(c, "Error while reading http response;", "error", err.Error())
+				c.Logger.Error("Error while reading http response;", map[string]interface{}{"error": err.Error()})
 				return err
 			}
 
 			err = json.Unmarshal(body, &queryResult)
 			if err != nil {
-				c.Logger.Error(c, "Error while unmarshalling http response;", "error", err.Error())
+				c.Logger.Error("Error while unmarshalling http response;", map[string]interface{}{"error": err.Error()})
 				return err
 			}
 
 			return nil
 		},
+		retry.OnRetry(func(n uint, err error) {
+			c.Logger.Error("Retrying query", map[string]interface{}{"error": err.Error()})
+		}),
+		retry.Attempts(uint(retries_available)),
+		retry.DelayType(retry.BackOffDelay),
+		retry.Delay(time.Duration(c.retries.delay)*time.Second),
+		retry.LastErrorOnly(true),
 	)
 
 	if len(queryResult.Errors) > 0 {
@@ -57,3 +71,45 @@ func (c *BaseClient) executeQuery(query []byte, headers any) (result any, err er
 	}
 	return queryResult.Data, nil
 }
+
+func (q *queryExecutor) execute() {
+	if q.should_cache {
+		cachedResponse := q.client.cacheLookup(q.hash)
+		if cachedResponse != nil {
+			q.client.Logger.Debug("Found cached response", map[string]interface{}{"hash": q.hash})
+			q.result.data = q.client.decodeResponse(cachedResponse)
+			return // return cached response
+		} else {
+			q.client.Logger.Debug("Cache miss", map[string]interface{}{"hash": q.hash})
+		}
+	}
+
+	if q.retries_enabled {
+		q.client.Logger.Debug("Retries enabled")
+		q.client.retries.enabled = true
+	}
+
+	response, err := q.client.executeQuery(q.query, q.headers)
+	if err != nil {
+		q.client.Logger.Error("Error while executing query;", map[string]interface{}{"error": err.Error()})
+		q.result.errors = err
+		return
+	}
+
+	jsonData, err := json.Marshal(response)
+	if err != nil {
+		q.client.Logger.Error("Error while converting to json;", map[string]interface{}{"error": err.Error()})
+		q.result.errors = err
+		return
+	}
+
+	if q.should_cache {
+		q.client.cache.client.Set(q.hash, jsonData, time.Duration(q.client.cache.ttl)*time.Second)
+	}
+
+	q.result.data = q.client.decodeResponse(jsonData)
+}
+
+func (q *queryExecutor) done() {
+	q = nil
+}

structs.go

@@ -4,14 +4,12 @@ import (
 	"context"
 	"net/http"
 
-	"github.com/lukaszraczylo/go-simple-graphql/utils/concurrency"
-	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
-
-	"github.com/allegro/bigcache"
+	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
+	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 )
 
 type cacheStore struct {
-	client  *bigcache.BigCache
+	client  *libpack_cache.Cache
 	ttl     int
 	enabled bool
 }
@@ -23,18 +21,14 @@ type retriesConfig struct {
 }
 
 type BaseClient struct {
-	Logger             Logger
-	LoggerWriter       Writer
-	client             *http.Client
-	concurrencyManager *concurrency.Pool
-	endpoint           string
-	responseType       string
-	cache              cacheStore
-	MaxGoRoutines      int
-	LoggingLevel       logger.LogLevel
-	LoggerColorful     bool
-	validate           bool
-	retries            retriesConfig
+	Logger        *libpack_logging.LogConfig
+	client        *http.Client
+	endpoint      string
+	responseType  string
+	cache         cacheStore
+	MaxGoRoutines int
+	validate      bool
+	retries       retriesConfig
 }
 
 type Query struct {
@@ -44,6 +38,22 @@ type Query struct {
 	compiledQuery []byte         `json:"compiledQuery"`
 }
 
+type queryExecutor struct {
+	result          queryExecutorResult
+	context         context.Context
+	client          *BaseClient
+	headers         map[string]interface{}
+	hash            string
+	query           []byte
+	should_cache    bool
+	retries_enabled bool
+}
+
+type queryExecutorResult struct {
+	data   interface{}
+	errors error
+}
+
 type request struct {
 	Variables any    `json:"variables"`
 	Query     string `json:"query"`

utils/concurrency/concurrency.go

@@ -1,30 +0,0 @@
-package concurrency
-
-type Pool struct {
-	queue chan struct{}
-	jobs  int
-}
-
-func NewPool(size int) *Pool {
-	if size < 0 {
-		size = 0
-	}
-	return &Pool{
-		jobs:  size,
-		queue: make(chan struct{}, size),
-	}
-}
-
-func (p *Pool) Enqueue(job func(params ...any), params ...any) {
-	if p.jobs == 0 {
-		go job(params...)
-		return
-	}
-	p.queue <- struct{}{}
-	go func() {
-		defer func() {
-			<-p.queue
-		}()
-		job(params...)
-	}()
-}

utils/concurrency/concurrency_test.go

@@ -1,74 +0,0 @@
-package concurrency
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewPool(t *testing.T) {
-	type args struct {
-		size int
-	}
-	tests := []struct {
-		want *Pool
-		name string
-		args args
-	}{
-		{
-			name: "TestNewPool",
-			args: args{
-				size: 0,
-			},
-			want: &Pool{
-				jobs:  0,
-				queue: make(chan struct{}, 0),
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := NewPool(tt.args.size)
-			assert.Equal(t, got.jobs, tt.want.jobs)
-			assert.Equal(t, cap(got.queue), cap(tt.want.queue))
-		})
-	}
-}
-
-func TestPool_Enqueue(t *testing.T) {
-	type fields struct {
-		queue chan struct{}
-		jobs  int
-	}
-	type args struct {
-		job    func(params ...any)
-		params []any
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		{
-			name: "TestPool_Enqueue",
-			fields: fields{
-				queue: make(chan struct{}, 0),
-				jobs:  0,
-			},
-			args: args{
-				job: func(params ...any) {
-					return
-				},
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			p := &Pool{
-				queue: tt.fields.queue,
-				jobs:  tt.fields.jobs,
-			}
-			p.Enqueue(tt.args.job, tt.args.params...)
-		})
-	}
-}

utils/logger/logger.go

@@ -1,72 +0,0 @@
-package logger
-
-import (
-	"reflect"
-
-	"github.com/lukaszraczylo/go-simple-graphql/utils/helpers"
-	"github.com/lukaszraczylo/go-simple-graphql/utils/ordered_map"
-
-	jsoniter "github.com/json-iterator/go"
-)
-
-var json = jsoniter.ConfigCompatibleWithStandardLibrary
-
-const (
-	reset      = "\033[0m"
-	redBold    = "\033[1;31m"
-	greenBold  = "\033[1;32m"
-	yellowBold = "\033[1;33m"
-	blueBold   = "\033[1;34m"
-)
-
-type LogLevel int
-
-const (
-	Silent LogLevel = iota
-	Error
-	Warn
-	Info
-	Debug
-)
-
-type Config struct {
-	Colorful bool
-	LogLevel LogLevel
-}
-
-func Serialize(v any) (string, error) {
-	marshal, err := json.Marshal(internalSerialize(v))
-	if err != nil {
-		return "", err
-	}
-	return helpers.BytesToString(marshal), nil
-}
-
-func internalSerialize(v any) any {
-	if v != nil {
-		switch reflect.TypeOf(v).Kind() {
-		case reflect.Struct:
-			r := ordered_map.New()
-			name := reflect.TypeOf(v).Name()
-			if name != "" {
-				r.Set("_", reflect.TypeOf(v).String())
-			}
-			for i := 0; i < reflect.ValueOf(v).NumField(); i++ {
-				r.Set(reflect.TypeOf(v).Field(i).Name, internalSerialize(reflect.ValueOf(v).Field(i).Interface()))
-			}
-			return r
-		case reflect.Ptr:
-			if !reflect.ValueOf(v).IsNil() {
-				return internalSerialize(reflect.ValueOf(v).Elem().Interface())
-			}
-		case reflect.Slice:
-			var r []any
-			tmpSlice := reflect.ValueOf(v)
-			for i := 0; i < tmpSlice.Len(); i++ {
-				r = append(r, internalSerialize(tmpSlice.Index(i).Interface()))
-			}
-			return r
-		}
-	}
-	return v
-}

utils/logger/logger_test.go

@@ -1,84 +0,0 @@
-package logger
-
-import "testing"
-
-type Person struct {
-	Name string
-	Age  int
-}
-
-func TestSerializeStruct(t *testing.T) {
-	person := Person{Name: "Alice", Age: 30}
-	expected := `{"_":"logger.Person","Name":"Alice","Age":30}`
-	actual, err := Serialize(person)
-	if err != nil {
-		t.Errorf("Error: %v", err)
-	}
-	if actual != expected {
-		t.Errorf("Expected: %v\nActual: %v", expected, actual)
-	}
-}
-
-func TestSerializeNilPointer(t *testing.T) {
-	var person *Person
-	expected := `null`
-	actual, err := Serialize(person)
-	if err != nil {
-		t.Errorf("Error: %v", err)
-	}
-	if actual != expected {
-		t.Errorf("Expected: %v\nActual: %v", expected, actual)
-	}
-}
-
-func TestSerializeNonNilPointer(t *testing.T) {
-	person := &Person{Name: "Alice", Age: 30}
-	expected := `{"_":"logger.Person","Name":"Alice","Age":30}`
-	actual, err := Serialize(person)
-	if err != nil {
-		t.Errorf("Error: %v", err)
-	}
-	if actual != expected {
-		t.Errorf("Expected: %v\nActual: %v", expected, actual)
-	}
-}
-
-func TestSerializeSlice(t *testing.T) {
-	people := []Person{
-		{Name: "Alice", Age: 30},
-		{Name: "Bob", Age: 40},
-	}
-	expected := `[{"_":"logger.Person","Name":"Alice","Age":30},{"_":"logger.Person","Name":"Bob","Age":40}]`
-	actual, err := Serialize(people)
-	if err != nil {
-		t.Errorf("Error: %v", err)
-	}
-	if actual != expected {
-		t.Errorf("Expected: %v\nActual: %v", expected, actual)
-	}
-}
-
-func TestSerializeSliceOfPointers(t *testing.T) {
-	people := []*Person{
-		{Name: "Alice", Age: 30},
-		{Name: "Bob", Age: 40},
-	}
-	expected := `[{"_":"logger.Person","Name":"Alice","Age":30},{"_":"logger.Person","Name":"Bob","Age":40}]`
-
-	actual, err := Serialize(people)
-	if err != nil {
-		t.Errorf("Error: %v", err)
-	}
-	if actual != expected {
-		t.Errorf("Expected: %v\nActual: %v", expected, actual)
-	}
-}
-
-func TestSerializeUnsupportedType(t *testing.T) {
-	type UnsupportedType chan int
-	unsupportedType := make(UnsupportedType)
-	_, err := Serialize(unsupportedType)
-	if err == nil {
-		t.Errorf("Expected an error, but got nil")
-	}
-}

utils/ordered_map/ordered_map.go

@@ -55,10 +55,67 @@ type customJsonEncoder struct {
 }
 
 func (e *customJsonEncoder) Encode(v interface{}) error {
-	data, err := json.Marshal(v)
+	if v == nil {
+		e.buf.WriteString("null")
+		return nil
+	}
+
+	switch val := v.(type) {
+	case *OrderedMap:
+		data, err := json.Marshal(val.values)
+		if err != nil {
+			return err
+		}
+		e.buf.Write(data)
+	default:
+		data, err := json.Marshal(val)
+		if err != nil {
+			return err
+		}
+		e.buf.Write(data)
+	}
+	return nil
+}
+
+func (o OrderedMap) Keys() []string {
+	return o.keys
+}
+
+func (o OrderedMap) Values() []interface{} {
+	var values []interface{}
+	for _, k := range o.keys {
+		values = append(values, o.values[k])
+	}
+	return values
+}
+
+func (o *OrderedMap) Delete(key string) {
+	delete(o.values, key)
+	for i, k := range o.keys {
+		if k == key {
+			o.keys = append(o.keys[:i], o.keys[i+1:]...)
+			break
+		}
+	}
+}
+
+func (o OrderedMap) Exists(key string) bool {
+	_, exists := o.values[key]
+	return exists
+}
+
+func (o *OrderedMap) UnmarshalJSON(data []byte) error {
+	var values map[string]interface{}
+	err := json.Unmarshal(data, &values)
 	if err != nil {
 		return err
 	}
-	e.buf.Write(data)
+
+	o.keys = []string{}
+	o.values = map[string]interface{}{}
+	for k, v := range values {
+		o.Set(k, v)
+	}
+
 	return nil
 }