Replace allegro/bigcache with something lighter.

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,8 +2,10 @@ package gql
 
 import (
 	"crypto/tls"
+	"fmt"
 	"time"
 
+	"github.com/akyoto/cache"
 	"github.com/lukaszraczylo/go-simple-graphql/utils/concurrency"
 	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
 
@@ -14,7 +16,6 @@ import (
 	"os"
 	"strings"
 
-	"github.com/allegro/bigcache"
 	"github.com/gookit/goutil/envutil"
 )
 
@@ -42,13 +43,7 @@ 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 {
+	b.enableCache()
-		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_tmp_log_level := envutil.Getenv("LOG_LEVEL", "info")
 
@@ -71,9 +66,20 @@ func NewConnection() *BaseClient {
 	})
 
 	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 +89,8 @@ func NewConnection() *BaseClient {
 		http2Transport := &http2.Transport{
 			AllowHTTP:       true,
 			TLSClientConfig: tlsClientConfig,
+			ReadIdleTimeout: 15 * time.Second,
+			PingTimeout:     15 * time.Second,
 		}
 		httpClient = &http.Client{
 			Transport: http2Transport,
@@ -102,3 +110,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 = 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(b, "Disabling cache")
+	b.cache.enabled = false
+}

cache.go

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

go.mod

@@ -3,7 +3,7 @@ module github.com/lukaszraczylo/go-simple-graphql
 go 1.20
 
 require (
-	github.com/allegro/bigcache v1.2.1
+	github.com/akyoto/cache v1.0.6
 	github.com/avast/retry-go/v4 v4.3.3
 	github.com/gookit/goutil v0.6.8
 	github.com/json-iterator/go v1.1.12

go.sum

@@ -1,5 +1,5 @@
-github.com/allegro/bigcache v1.2.1 h1:hg1sY1raCwic3Vnsvje6TT7/pnZba83LeFck5NrFKSc=
+github.com/akyoto/cache v1.0.6 h1:5XGVVYoi2i+DZLLPuVIXtsNIJ/qaAM16XT0LaBaXd2k=
-github.com/allegro/bigcache v1.2.1/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
+github.com/akyoto/cache v1.0.6/go.mod h1:WfxTRqKhfgAG71Xh6E3WLpjhBtZI37O53G4h5s+3iM4=
 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/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=

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"
 )
@@ -70,52 +68,36 @@ 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 := c.parseQueryHeaders(queryHeaders)
+
+	var should_cache bool
 	var queryHash string
-	var cachedResponse []byte
-	var cacheBaseClient BaseClient
 
-	// Check for library specific headers
+	if headersModified {
-	if len(queryHeaders) > 0 {
+		should_cache = enabledCache
-		cacheBaseClient = reflect.ValueOf(*c).Interface().(BaseClient)
+	} else {
-		queryHeaders = c.parseQueryHeaders(queryHeaders)
+		should_cache = c.cache.enabled
 	}
 
-	if c.cache.enabled {
+	if should_cache {
-		queryHash = strutil.Md5(query.compiledQuery)
+		queryHash = strutil.Md5(fmt.Sprintf("%s-%+v", compiledQuery.compiledQuery, queryHeaders))
-		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")
-		}
 	}
 
-	response, err := c.executeQuery(query.compiledQuery, queryHeaders)
+	q := &queryExecutor{
-	if err != nil {
+		client:       c,
-		c.Logger.Error(c, "Error while executing query;", "error", err.Error())
+		query:        compiledQuery.compiledQuery,
-		return nil, err
+		headers:      parseQueryHeaders,
+		context:      context.Background(),
+		should_cache: should_cache,
+		hash:         queryHash,
 	}
 
-	jsonData, err := json.Marshal(response)
+	q.execute()
-	if err != nil {
+	defer q.done()
-		c.Logger.Error(c, "Error while converting to json;", "error", err.Error())
-		return nil, err
-	}
 
-	if c.cache.enabled {
+	return q.result.data, q.result.errors
-		c.cache.client.Set(queryHash, jsonData)
-	}
-
-	if len(queryHeaders) > 0 {
-		*c = cacheBaseClient
-	}
-
-	return c.decodeResponse(jsonData), err
 }
 
 func (c *BaseClient) decodeResponse(jsonData []byte) any {
@@ -138,11 +120,19 @@ func (c *BaseClient) decodeResponse(jsonData []byte) any {
 	}
 }
 
-func (c *BaseClient) parseQueryHeaders(queryHeaders map[string]interface{}) (returnHeaders map[string]interface{}) {
+func (c *BaseClient) parseQueryHeaders(queryHeaders map[string]interface{}) (returnHeaders map[string]interface{}, cache_enabled bool, headers_modified 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 {
+				c.Logger.Error(c, "Can't parse gqlcache header", "error", err.Error())
+			}
+			if cache_enabled != c.cache.enabled {
+				headers_modified = true
+			}
 			continue
 		}
 		if k == "gqlretries" {
@@ -151,5 +141,5 @@ func (c *BaseClient) parseQueryHeaders(queryHeaders map[string]interface{}) (ret
 		}
 		returnHeaders[k] = v
 	}
-	return returnHeaders
+	return returnHeaders, cache_enabled, headers_modified
 }

query_test.go

@@ -1,6 +1,7 @@
 package gql
 
 import (
+	"math/rand"
 	"reflect"
 	"testing"
 
@@ -297,10 +298,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",
@@ -333,9 +334,199 @@ 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) {
+			if gotReturnHeaders, _, _ := c.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,6 +3,7 @@ package gql
 import (
 	"bytes"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"net/http"
 	"time"
@@ -31,6 +32,7 @@ func (c *BaseClient) executeQuery(query []byte, headers any) (result any, err er
 				c.Logger.Error(c, "Error while executing http request;", "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 {
@@ -65,3 +67,40 @@ 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(q.client, "Found cached response")
+			q.result.data = q.client.decodeResponse(cachedResponse)
+			return // return cached response
+		} else {
+			q.client.Logger.Debug(q.client, "No cached response found")
+		}
+	}
+
+	response, err := q.client.executeQuery(q.query, q.headers)
+	if err != nil {
+		q.client.Logger.Error(q.client, "Error while executing query;", "error", err.Error())
+		q.result.errors = err
+		return
+	}
+
+	jsonData, err := json.Marshal(response)
+	if err != nil {
+		q.client.Logger.Error(q.client, "Error while converting to json;", "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,13 @@ import (
 	"context"
 	"net/http"
 
+	"github.com/akyoto/cache"
 	"github.com/lukaszraczylo/go-simple-graphql/utils/concurrency"
 	"github.com/lukaszraczylo/go-simple-graphql/utils/logger"
-
-	"github.com/allegro/bigcache"
 )
 
 type cacheStore struct {
-	client  *bigcache.BigCache
+	client  *cache.Cache
 	ttl     int
 	enabled bool
 }
@@ -44,6 +43,21 @@ 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
+}
+
+type queryExecutorResult struct {
+	data   interface{}
+	errors error
+}
+
 type request struct {
 	Variables any    `json:"variables"`
 	Query     string `json:"query"`

utils/logger/logger.go

@@ -1,16 +1,10 @@
 package logger
 
 import (
+	"encoding/json"
 	"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"
@@ -34,25 +28,25 @@ type Config struct {
 	LogLevel LogLevel
 }
 
-func Serialize(v any) (string, error) {
+func Serialize(v interface{}) ([]byte, error) {
-	marshal, err := json.Marshal(internalSerialize(v))
+	b, err := json.Marshal(internalSerialize(v))
 	if err != nil {
-		return "", err
+		return nil, err
 	}
-	return helpers.BytesToString(marshal), nil
+	return b, nil
 }
 
-func internalSerialize(v any) any {
+func internalSerialize(v interface{}) interface{} {
 	if v != nil {
 		switch reflect.TypeOf(v).Kind() {
 		case reflect.Struct:
-			r := ordered_map.New()
+			r := make(map[string]interface{})
 			name := reflect.TypeOf(v).Name()
 			if name != "" {
-				r.Set("_", reflect.TypeOf(v).String())
+				r["_"] = 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()))
+				r[reflect.TypeOf(v).Field(i).Name] = internalSerialize(reflect.ValueOf(v).Field(i).Interface())
 			}
 			return r
 		case reflect.Ptr:
@@ -60,7 +54,7 @@ func internalSerialize(v any) any {
 				return internalSerialize(reflect.ValueOf(v).Elem().Interface())
 			}
 		case reflect.Slice:
-			var r []any
+			var r []interface{}
 			tmpSlice := reflect.ValueOf(v)
 			for i := 0; i < tmpSlice.Len(); i++ {
 				r = append(r, internalSerialize(tmpSlice.Index(i).Interface()))

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
 }