Fixes the issue with case comparison.

Signed-off-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.github/workflows/autoupdate.yaml

@@ -1,4 +1,4 @@
-name: Test and release
+name: Autoupdate go.mod and go.sum
 
 on:
   workflow_dispatch:
@@ -34,15 +34,16 @@ jobs:
   # This job is responsible for running tests and linting the codebase
   test:
     name: "Unit testing"
-    # needs: [prepare]
     runs-on: ubuntu-latest
     container: golang:1
-    # container: github/super-linter:v4
     needs: [prepare]
 
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Ensure full history is checked out
+          token: ${{ secrets.GHCR_TOKEN }}
 
       - name: Install Go
         uses: actions/setup-go@v5
@@ -56,18 +57,17 @@ jobs:
           apt-get install ca-certificates make -y
           update-ca-certificates
           go mod tidy
-          get -u -v ./...
+          go get -u -v ./...
           go mod tidy -v
 
       - name: Run unit tests
         run: |
           CI_RUN=${CI} make test
+          git config --global --add safe.directory /__w/graphql-monitoring-proxy/graphql-monitoring-proxy
 
-      # if go.mod or go.sum have changed then commit the changes to the repository
       - name: Commit changes
-        run: |
-          git config --global user.email "github-actions[bot]@users.noreply.github.com"
-          git config --global user.name "github-actions[bot]"
-          git add go.mod go.sum
-          git commit -m "Update go.mod and go.sum"
-          git push
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "Update go.mod and go.sum"
+          commit_options: "--no-verify --signoff"
+          file_pattern: "go.mod go.sum"

.github/workflows/pr.yaml

@@ -15,6 +15,12 @@ on:
 env:
   GO_VERSION: ">=1.21"
 
+permissions:
+  # deployments permission to deploy GitHub pages website
+  deployments: write
+  # contents permission to update benchmark contents in gh-pages branch
+  contents: write
+
 jobs:
   # This job is responsible for preparation of the build
   # environment variables.
@@ -78,7 +84,26 @@ jobs:
           apt-get install ca-certificates make -y
           update-ca-certificates
           go mod tidy
+          git config --global --add safe.directory "$GITHUB_WORKSPACE"
 
       - name: Run unit tests
         run: |
           CI_RUN=${CI} make test
+
+      - name: Run benchmark
+        run: |
+          go test -bench=. -benchmem ./... -run=^# | tee output.txt
+
+      - name: Store benchmark result
+        uses: benchmark-action/github-action-benchmark@v1
+        with:
+          tool: "go"
+          output-file-path: output.txt
+          fail-on-alert: true
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          comment-on-alert: true
+          summary-always: true
+          # auto-push only if it's on main branch
+          auto-push: false
+          gh-pages-branch: "gh-pages"
+          benchmark-data-dir-path: "docs"

.github/workflows/test.yaml

@@ -10,6 +10,15 @@ on:
     branches:
       - "main"
 
+env:
+  GO_VERSION: ">=1.21"
+
+permissions:
+  # deployments permission to deploy GitHub pages website
+  deployments: write
+  # contents permission to update benchmark contents in gh-pages branch
+  contents: write
+
 jobs:
   shared:
     uses: telegram-bot-app/ci-scripts/.github/workflows/build-test-publish-inject.yaml@main
@@ -18,3 +27,46 @@ jobs:
       should-deploy: false
     secrets:
       ghcr-token: ${{ secrets.GHCR_TOKEN }}
+
+  test:
+    name: "Benchmarking the results"
+    needs: [shared]
+    runs-on: ubuntu-latest
+    container: golang:1
+    # container: github/super-linter:v4
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{env.GO_VERSION}}
+          cache-dependency-path: "**/*.sum"
+
+      - name: Install dependencies
+        run: |
+          apt-get update
+          apt-get install ca-certificates make -y
+          update-ca-certificates
+          go mod tidy
+          git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+      - name: Run benchmark
+        run: |
+          go test -bench=. -benchmem ./... -run=^# | tee output.txt
+
+      - name: Store benchmark result
+        uses: benchmark-action/github-action-benchmark@v1
+        with:
+          tool: "go"
+          output-file-path: output.txt
+          fail-on-alert: true
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          comment-on-alert: true
+          summary-always: true
+          # auto-push only if it's on main branch
+          auto-push: true
+          gh-pages-branch: "gh-pages"
+          benchmark-data-dir-path: "docs"

.gitignore

@@ -1,3 +1,4 @@
 graphql-proxy
 test.sh
-banned.json*
+banned.json*
+dist/

Makefile

@@ -1,4 +1,6 @@
 CI_RUN?=false
+TIMESTAMP := $(shell date +%Y%m%d-%H%M%S)
+
 # ADDITIONAL_BUILD_FLAGS=""
 
 # ifeq ($(CI_RUN), true)
@@ -32,3 +34,25 @@ all: test-packages test
 update: ## update dependencies
 	@go get -u -v ./...
 	@go mod tidy -v
+
+.PHONY: build-amd64
+build-amd64: ## build the Linux AMD64 binary
+	GOOS=linux GOARCH=amd64 go build -o graphql-proxy-amd64 *.go
+
+.PHONY: build-arm64
+build-arm64: ## build the Linux ARM64 binary
+	GOOS=linux GOARCH=arm64 go build -o graphql-proxy-arm64 *.go
+
+.PHONY: build-all
+build-all: build-amd64 build-arm64 ## build both AMD64 and ARM64 binaries
+
+.PHONY: docker
+docker: build-all ## build multi-arch (AMD64 and ARM64) docker image
+	@mkdir -p dist
+	@mv graphql-proxy-amd64 dist/bot-linux-amd64
+	@mv graphql-proxy-arm64 dist/bot-linux-arm64
+	@docker buildx build --push \
+		--platform linux/amd64,linux/arm64 \
+		-t ghcr.io/lukaszraczylo/graphql-monitoring-proxy:local-test-build-$(TIMESTAMP) \
+		.
+

README.md

@@ -2,12 +2,13 @@
 
 Creates a passthrough proxy to a graphql endpoint(s), allowing you to analyse the queries and responses, producing the Prometheus metrics at a fraction of the cost - because, as we know - $0 is a fair price.
 
-This project is in active use by [telegram-bot.app](https://telegram-bot.app), and was tested with 30k queries per second on a single instance, consuming 10 MB of RAM and 0.1% CPU.
+This project is in active use by [telegram-bot.app](https://telegram-bot.app), and was tested with 30k queries per second on a single instance, consuming 10 MB of RAM and 0.1% CPU. [Benchmarks](https://lukaszraczylo.github.io/graphql-monitoring-proxy/dev/bench/) are available.
 
 ![Example of monitoring dashboard](static/monitoring-at-glance.png?raw=true)
 
 - [graphql monitoring proxy](#graphql-monitoring-proxy)
   - [Why this project exists](#why-this-project-exists)
+  - [Important releases](#important-releases)
   - [How to deploy](#how-to-deploy)
     - [Note on websocket support](#note-on-websocket-support)
   - [Endpoints](#endpoints)
@@ -35,13 +36,23 @@ This project is in active use by [telegram-bot.app](https://telegram-bot.app), a
 
 I wanted to monitor the queries and responses of our graphql endpoint. Still, we didn't want to pay the price of the graphql server itself ( and I will not point fingers at a particular well-known project), as monitoring and basic security features should be a standard, free functionality.
 
+### Important releases
+
+You should always try to stick to the latest and greatest version of the graphql-proxy to ensure that it's as much bug-free as possible. Following list will be kept to the maximum of five "most important" bugs and enhancements included in the latest versions.
+
+* **06/12/2024 - 0.24.2** - Fixes the bug where deeply nested introspection queries were blocked despite of being present on the whitelist. GraphQL proxy will now inspect the queries in depth to find any possible nested introspections.
+
+* **20/08/2024 - 0.23.21+** - Fixes the bug when timeouts were not respected on proxy-graphql line. Affected versions before that were timeouting after 30 seconds which was set as default ( thanks to Jurica Železnjak for reporting ). It also provides a temporary fix for running within kubernetes deployment, when graphql server ( for example - hasura ) took more time to start than the proxy, causing avalanche of errors with "can't proxy the request".
+
+* **19/08/2024 - 0.21.82+** - Fixed the issue when proxy failed to start if global cache was disabled, therefore not initialized and proxy tried to perform the cache operations during normal query operations.
+
 ### How to deploy
 
 You can find the example of the Kubernetes manifest in the [example standalone deployment](static/kubernetes-deployment.yaml) or [example combined deployment](static/kubernetes-single-deployment.yaml) files. Observed advantage of multideployment is that it allows the network requests to travel via localhost, without leaving the deployment which brings quite significant network performance boost.
 
 #### Note on websocket support
 
-Proxy in its current version 0.5.30 does not support websockets. If you need to proxy the websocket requests - you can use following trick whilst setting up the proxy. As I'm a big fan of Traefik - there's an example which works with the mentioned above combined deployment.
+Proxy in its current version 0.23.3 does not support websockets. If you need to proxy the websocket requests - you can use following trick whilst setting up the proxy. As I'm a big fan of Traefik - there's an example which works with the mentioned above combined deployment.
 
 <details>
   <summary>Click to show working Traefik Ingress Route example.</summary>
@@ -103,7 +114,7 @@ In this case, both proxy and websockets will be available under the `/v1/graphql
 | security   | Blocking mutations in read-only mode                                  |
 | security   | Allow access only to listed URLs                                      |
 | security   | Ban / unban specific user from accessing the application              |
-| maintenance | Hasura event cleaner                                                 |
+| maintenance | Hasura events cleaner                                                 |
 
 
 ### Configuration

api.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"sync"
 	"time"
 
 	"github.com/goccy/go-json"
@@ -13,55 +14,66 @@ import (
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 )
 
-var bannedUsersIDs map[string]string = make(map[string]string)
+var (
+	bannedUsersIDs      = make(map[string]string)
+	bannedUsersIDsMutex sync.RWMutex
+)
 
 func enableApi() {
-	if cfg.Server.EnableApi {
-		apiserver := fiber.New(fiber.Config{
-			DisableStartupMessage: true,
-			AppName:               fmt.Sprintf("GraphQL Monitoring Proxy - %s v%s", libpack_config.PKG_NAME, libpack_config.PKG_VERSION),
+	if !cfg.Server.EnableApi {
+		return
+	}
+
+	apiserver := fiber.New(fiber.Config{
+		DisableStartupMessage: true,
+		AppName:               fmt.Sprintf("GraphQL Monitoring Proxy - %s v%s", libpack_config.PKG_NAME, libpack_config.PKG_VERSION),
+	})
+
+	api := apiserver.Group("/api")
+	api.Post("/user-ban", apiBanUser)
+	api.Post("/user-unban", apiUnbanUser)
+	api.Post("/cache-clear", apiClearCache)
+	api.Get("/cache-stats", apiCacheStats)
+
+	go periodicallyReloadBannedUsers()
+
+	if err := apiserver.Listen(fmt.Sprintf(":%d", cfg.Server.ApiPort)); err != nil {
+		cfg.Logger.Critical(&libpack_logger.LogMessage{
+			Message: "Can't start the service",
+			Pairs:   map[string]interface{}{"port": cfg.Server.ApiPort},
 		})
-
-		api := apiserver.Group("/api")
-		api.Post("/user-ban", apiBanUser)
-		api.Post("/user-unban", apiUnbanUser)
-		api.Post("/cache-clear", apiClearCache)
-		api.Get("/cache-stats", apiCacheStats)
-
-		go periodicallyReloadBannedUsers()
-		err := apiserver.Listen(fmt.Sprintf(":%d", cfg.Server.ApiPort))
-		if err != nil {
-			cfg.Logger.Critical(&libpack_logger.LogMessage{
-				Message: "Can't start the service",
-				Pairs:   map[string]interface{}{"port": cfg.Server.ApiPort},
-			})
-		}
 	}
 }
 
 func periodicallyReloadBannedUsers() {
-	for {
+	ticker := time.NewTicker(10 * time.Second)
+	defer ticker.Stop()
+
+	for range ticker.C {
 		loadBannedUsers()
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
 			Message: "Banned users reloaded",
 			Pairs:   map[string]interface{}{"users": bannedUsersIDs},
 		})
-		<-time.After(10 * time.Second)
 	}
 }
 
 func checkIfUserIsBanned(c *fiber.Ctx, userID string) bool {
+	bannedUsersIDsMutex.RLock()
 	_, found := bannedUsersIDs[userID]
+	bannedUsersIDsMutex.RUnlock()
+
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Checking if user is banned",
-		Pairs:   map[string]interface{}{"user_id": userID, "found": found},
+		Pairs:   map[string]interface{}{"user_id": userID, "banned": found},
 	})
+
 	if found {
 		cfg.Logger.Info(&libpack_logger.LogMessage{
 			Message: "User is banned",
 			Pairs:   map[string]interface{}{"user_id": userID},
 		})
-		c.Status(403).SendString("User is banned")
+		c.Status(fiber.StatusForbidden).SendString("User is banned")
 	}
 	return found
 }
@@ -69,28 +81,16 @@ func checkIfUserIsBanned(c *fiber.Ctx, userID string) bool {
 func apiClearCache(c *fiber.Ctx) error {
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Clearing cache via API",
-		Pairs:   nil,
 	})
 	libpack_cache.CacheClear()
 	cfg.Logger.Info(&libpack_logger.LogMessage{
 		Message: "Cache cleared via API",
-		Pairs:   nil,
 	})
-	c.Status(200).SendString("OK: cache cleared")
-	return nil
+	return c.SendString("OK: cache cleared")
 }
 
 func apiCacheStats(c *fiber.Ctx) error {
-	stats := libpack_cache.GetCacheStats()
-	err := c.JSON(stats)
-	if err != nil {
-		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "Can't marshal cache stats",
-			Pairs:   map[string]interface{}{"error": err.Error()},
-		})
-		return err
-	}
-	return nil
+	return c.JSON(libpack_cache.GetCacheStats())
 }
 
 type apiBanUserRequest struct {
@@ -100,71 +100,92 @@ type apiBanUserRequest struct {
 
 func apiBanUser(c *fiber.Ctx) error {
 	var req apiBanUserRequest
-	err := c.BodyParser(&req)
-	if err != nil {
+	if err := c.BodyParser(&req); err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't parse the ban user request",
 			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return err
+		return c.Status(fiber.StatusBadRequest).SendString("Invalid request payload")
 	}
+
+	if req.UserID == "" || req.Reason == "" {
+		return c.Status(fiber.StatusBadRequest).SendString("user_id and reason are required")
+	}
+
+	bannedUsersIDsMutex.Lock()
 	bannedUsersIDs[req.UserID] = req.Reason
+	bannedUsersIDsMutex.Unlock()
+
 	cfg.Logger.Info(&libpack_logger.LogMessage{
 		Message: "Banned user",
 		Pairs:   map[string]interface{}{"user_id": req.UserID, "reason": req.Reason},
 	})
-	storeBannedUsers()
-	c.Status(200).SendString("OK: user banned")
-	return nil
+
+	if err := storeBannedUsers(); err != nil {
+		return c.Status(fiber.StatusInternalServerError).SendString("Failed to store banned users")
+	}
+
+	return c.SendString("OK: user banned")
 }
 
 func apiUnbanUser(c *fiber.Ctx) error {
 	var req apiBanUserRequest
-	err := c.BodyParser(&req)
-	if err != nil {
+	if err := c.BodyParser(&req); err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't parse the unban user request",
 			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return err
+		return c.Status(fiber.StatusBadRequest).SendString("Invalid request payload")
 	}
+
+	if req.UserID == "" {
+		return c.Status(fiber.StatusBadRequest).SendString("user_id is required")
+	}
+
+	bannedUsersIDsMutex.Lock()
 	delete(bannedUsersIDs, req.UserID)
+	bannedUsersIDsMutex.Unlock()
+
 	cfg.Logger.Info(&libpack_logger.LogMessage{
 		Message: "Unbanned user",
 		Pairs:   map[string]interface{}{"user_id": req.UserID},
 	})
-	storeBannedUsers()
-	c.Status(200).SendString("OK: user unbanned")
-	return nil
+
+	if err := storeBannedUsers(); err != nil {
+		return c.Status(fiber.StatusInternalServerError).SendString("Failed to store banned users")
+	}
+
+	return c.SendString("OK: user unbanned")
 }
 
-func storeBannedUsers() {
+func storeBannedUsers() error {
 	fileLock := flock.New(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-	err := fileLock.Lock()
-	if err != nil {
-		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "Can't lock the file",
-			Pairs:   map[string]interface{}{"error": err.Error()},
-		})
-		return
+	if err := lockFile(fileLock); err != nil {
+		return err
 	}
 	defer fileLock.Unlock()
+
+	bannedUsersIDsMutex.RLock()
 	data, err := json.Marshal(bannedUsersIDs)
+	bannedUsersIDsMutex.RUnlock()
+
 	if err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't marshal banned users",
 			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return
+		return err
 	}
-	err = os.WriteFile(cfg.Api.BannedUsersFile, data, 0644)
-	if err != nil {
+
+	if err := os.WriteFile(cfg.Api.BannedUsersFile, data, 0644); err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't write banned users to file",
 			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return
+		return err
 	}
+
+	return nil
 }
 
 func loadBannedUsers() {
@@ -173,19 +194,9 @@ func loadBannedUsers() {
 			Message: "Banned users file doesn't exist - creating it",
 			Pairs:   map[string]interface{}{"file": cfg.Api.BannedUsersFile},
 		})
-		_, err := os.Create(cfg.Api.BannedUsersFile)
-		if err != nil {
+		if err := os.WriteFile(cfg.Api.BannedUsersFile, []byte("{}"), 0644); err != nil {
 			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Can't create the file",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-			return
-		}
-		// write empty json to the file
-		err = os.WriteFile(cfg.Api.BannedUsersFile, []byte("{}"), 0644)
-		if err != nil {
-			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Can't write to the file",
+				Message: "Can't create and write to the file",
 				Pairs:   map[string]interface{}{"error": err.Error()},
 			})
 			return
@@ -193,8 +204,7 @@ func loadBannedUsers() {
 	}
 
 	fileLock := flock.New(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-	err := fileLock.RLock() // Use RLock for read lock
-	if err != nil {
+	if err := lockFileRead(fileLock); err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't lock the file [load]",
 			Pairs:   map[string]interface{}{"error": err.Error()},
@@ -211,12 +221,39 @@ func loadBannedUsers() {
 		})
 		return
 	}
-	err = json.Unmarshal(data, &bannedUsersIDs)
-	if err != nil {
+
+	var newBannedUsers map[string]string
+	if err := json.Unmarshal(data, &newBannedUsers); err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't unmarshal banned users",
 			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
 		return
 	}
+
+	bannedUsersIDsMutex.Lock()
+	bannedUsersIDs = newBannedUsers
+	bannedUsersIDsMutex.Unlock()
+}
+
+func lockFile(fileLock *flock.Flock) error {
+	if err := fileLock.Lock(); err != nil {
+		cfg.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't lock the file",
+			Pairs:   map[string]interface{}{"error": err.Error()},
+		})
+		return err
+	}
+	return nil
+}
+
+func lockFileRead(fileLock *flock.Flock) error {
+	if err := fileLock.RLock(); err != nil {
+		cfg.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't lock the file for reading",
+			Pairs:   map[string]interface{}{"error": err.Error()},
+		})
+		return err
+	}
+	return nil
 }

cache/cache.go

@@ -1,6 +1,9 @@
 package libpack_cache
 
 import (
+	"bytes"
+	"compress/gzip"
+	"io"
 	"sync/atomic"
 	"time"
 
@@ -15,10 +18,10 @@ type CacheConfig struct {
 	Logger *libpack_logger.Logger
 	Client CacheClient
 	Redis  struct {
-		Enable   bool   `json:"enable"`
 		URL      string `json:"url"`
 		Password string `json:"password"`
 		DB       int    `json:"db"`
+		Enable   bool   `json:"enable"`
 	}
 	TTL int `json:"ttl"`
 }
@@ -55,7 +58,7 @@ func EnableCache(cfg *CacheConfig) {
 	}
 	cacheStats = &CacheStats{}
 	if ShouldUseRedisCache(cfg) {
-		cfg.Logger.Info(&libpack_logger.LogMessage{
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
 			Message: "Using Redis cache",
 		})
 		cfg.Client = libpack_cache_redis.New(&libpack_cache_redis.RedisClientConfig{
@@ -64,7 +67,7 @@ func EnableCache(cfg *CacheConfig) {
 			RedisPassword: cfg.Redis.Password,
 		})
 	} else {
-		cfg.Logger.Info(&libpack_logger.LogMessage{
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
 			Message: "Using in-memory cache",
 		})
 		cfg.Client = libpack_cache_memory.New(time.Duration(cfg.TTL) * time.Second)
@@ -73,9 +76,35 @@ func EnableCache(cfg *CacheConfig) {
 }
 
 func CacheLookup(hash string) []byte {
+	if !IsCacheInitialized() {
+		return nil
+	}
+
 	obj, found := config.Client.Get(hash)
 	if found {
 		atomic.AddInt64(&cacheStats.CacheHits, 1)
+		// If the cached data is compressed, decompress it
+		if len(obj) > 2 && obj[0] == 0x1f && obj[1] == 0x8b {
+			reader, err := gzip.NewReader(bytes.NewReader(obj))
+			if err != nil {
+				config.Logger.Error(&libpack_logger.LogMessage{
+					Message: "Failed to create gzip reader for cached data",
+					Pairs:   map[string]interface{}{"error": err.Error(), "hash": hash},
+				})
+				return nil
+			}
+			defer reader.Close()
+
+			decompressed, err := io.ReadAll(reader)
+			if err != nil {
+				config.Logger.Error(&libpack_logger.LogMessage{
+					Message: "Failed to decompress cached data",
+					Pairs:   map[string]interface{}{"error": err.Error(), "hash": hash},
+				})
+				return nil
+			}
+			return decompressed
+		}
 		return obj
 	}
 	atomic.AddInt64(&cacheStats.CacheMisses, 1)
@@ -83,6 +112,9 @@ func CacheLookup(hash string) []byte {
 }
 
 func CacheDelete(hash string) {
+	if !IsCacheInitialized() {
+		return
+	}
 	config.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Deleting data from cache",
 		Pairs:   map[string]interface{}{"hash": hash},
@@ -92,6 +124,12 @@ func CacheDelete(hash string) {
 }
 
 func CacheStore(hash string, data []byte) {
+	if !IsCacheInitialized() {
+		config.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Cache not initialized",
+		})
+		return
+	}
 	config.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Storing data in cache",
 		Pairs:   map[string]interface{}{"hash": hash},
@@ -101,6 +139,9 @@ func CacheStore(hash string, data []byte) {
 }
 
 func CacheStoreWithTTL(hash string, data []byte, ttl time.Duration) {
+	if !IsCacheInitialized() {
+		return
+	}
 	config.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Storing data in cache with TTL",
 		Pairs:   map[string]interface{}{"hash": hash, "ttl": ttl},
@@ -110,6 +151,9 @@ func CacheStoreWithTTL(hash string, data []byte, ttl time.Duration) {
 }
 
 func CacheGetQueries() int64 {
+	if !IsCacheInitialized() {
+		return 0
+	}
 	config.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Counting cache queries",
 	})
@@ -122,6 +166,9 @@ func CacheClear() {
 }
 
 func GetCacheStats() *CacheStats {
+	if !IsCacheInitialized() {
+		return &CacheStats{}
+	}
 	config.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Getting cache stats",
 	})
@@ -132,3 +179,7 @@ func GetCacheStats() *CacheStats {
 func ShouldUseRedisCache(cfg *CacheConfig) bool {
 	return cfg.Redis.Enable
 }
+
+func IsCacheInitialized() bool {
+	return config != nil && config.Client != nil
+}

cache/cache_bench_test.go

@@ -4,8 +4,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/alicebob/miniredis/v2"
 	libpack_cache_memory "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/memory"
-	libpack_cache_redis "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/redis"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 )
 
@@ -20,6 +20,7 @@ func BenchmarkCacheLookupInMemory(b *testing.B) {
 		Client: libpack_cache_memory.New(5 * time.Minute),
 		TTL:    5,
 	}
+	EnableCache(config)
 
 	hash := "00000000000000000000000000000000001337"
 	data := []byte("it's fine.")
@@ -36,16 +37,18 @@ func BenchmarkCacheLookupInMemory(b *testing.B) {
 }
 
 func BenchmarkCacheLookupRedis(b *testing.B) {
-	mockedCache := libpack_cache_redis.New(&libpack_cache_redis.RedisClientConfig{
-		RedisServer: redisMockServer.Addr(),
-		RedisDB:     0,
-	})
-
+	redis_server, err := miniredis.Run()
+	if err != nil {
+		panic(err)
+	}
 	config = &CacheConfig{
 		Logger: libpack_logger.New(),
-		Client: mockedCache,
 		TTL:    5,
 	}
+	config.Redis.DB = 0
+	config.Redis.URL = redis_server.Addr()
+	config.Redis.Enable = true
+	EnableCache(config)
 
 	hash := "00000000000000000000000000000000001337"
 	data := []byte("it's fine.")
@@ -67,6 +70,7 @@ func BenchmarkCacheStoreInMemory(b *testing.B) {
 		Client: libpack_cache_memory.New(5 * time.Minute),
 		TTL:    5,
 	}
+	EnableCache(config)
 
 	hash := "00000000000000000000000000000000001337"
 	data := []byte("it's fine.")
@@ -82,16 +86,19 @@ func BenchmarkCacheStoreInMemory(b *testing.B) {
 }
 
 func BenchmarkCacheStoreRedis(b *testing.B) {
-	mockedCache := libpack_cache_redis.New(&libpack_cache_redis.RedisClientConfig{
-		RedisServer: redisMockServer.Addr(),
-		RedisDB:     0,
-	})
+	redis_server, err := miniredis.Run()
+	if err != nil {
+		panic(err)
+	}
 
 	config = &CacheConfig{
 		Logger: libpack_logger.New(),
-		Client: mockedCache,
 		TTL:    5,
 	}
+	config.Redis.DB = 0
+	config.Redis.URL = redis_server.Addr()
+	config.Redis.Enable = true
+	EnableCache(config)
 
 	hash := "00000000000000000000000000000000001337"
 	data := []byte("it's fine.")

cache/cache_test.go

@@ -1,10 +1,12 @@
 package libpack_cache
 
 import (
+	"fmt"
+	"sync"
 	"time"
 
+	"github.com/alicebob/miniredis/v2"
 	libpack_cache_memory "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/memory"
-	libpack_cache_redis "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/redis"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 )
 
@@ -58,23 +60,15 @@ func (suite *Tests) Test_cacheLookupInmemory() {
 }
 
 func (suite *Tests) Test_cacheLookupRedis() {
-	// redis_server := envutil.Getenv("REDIS_SERVER", "localhost:6379")
-	// config.Client = libpack_cache_redis.NewClient(&libpack_cache_redis.RedisClientConfig{
-	// 	RedisServer:   redis_server,
-	// 	RedisPassword: "",
-	// 	RedisDB:       0,
-	// })
-
-	mockedCache := libpack_cache_redis.New(&libpack_cache_redis.RedisClientConfig{
-		RedisServer: redisMockServer.Addr(),
-		RedisDB:     0,
-	})
 
 	config = &CacheConfig{
 		Logger: libpack_logger.New(),
-		Client: mockedCache,
 		TTL:    5,
 	}
+	config.Redis.DB = 0
+	config.Redis.URL = redisMockServer.Addr()
+	config.Redis.Enable = true
+	EnableCache(config)
 
 	type args struct {
 		hash string
@@ -117,3 +111,96 @@ func (suite *Tests) Test_cacheLookupRedis() {
 		})
 	}
 }
+
+func (suite *Tests) Test_cacheConcurrency() {
+	config = &CacheConfig{
+		Logger: libpack_logger.New(),
+		Client: libpack_cache_memory.New(5 * time.Second),
+		TTL:    5,
+	}
+
+	const numGoroutines = 10
+	const numOperations = 1000
+
+	var wg sync.WaitGroup
+	wg.Add(numGoroutines)
+
+	for i := 0; i < numGoroutines; i++ {
+		go func(id int) {
+			defer wg.Done()
+			for j := 0; j < numOperations; j++ {
+				key := fmt.Sprintf("key-%d-%d", id, j)
+				value := []byte(fmt.Sprintf("value-%d-%d", id, j))
+				CacheStore(key, value)
+				retrieved := CacheLookup(key)
+				assert.Equal(string(value), string(retrieved), "Concurrent cache operation failed")
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+// func (suite *Tests) Test_cacheEviction() {
+// 	config = &CacheConfig{
+// 		Logger: libpack_logger.New(),
+// 		Client: libpack_cache_memory.New(3 * time.Second), // 3 seconds TTL
+// 		TTL:    3,
+// 	}
+
+// 	// Fill the cache
+// 	for i := 0; i < 20; i++ {
+// 		key := fmt.Sprintf("key-%d", i)
+// 		value := []byte(fmt.Sprintf("value-%d", i))
+// 		CacheStore(key, value)
+// 		time.Sleep(100 * time.Millisecond) // Ensure different creation times
+// 	}
+
+// 	// Wait for the TTL to expire for the first half of the items
+// 	time.Sleep(3100 * time.Millisecond)
+
+// 	// Check that the oldest items have been evicted
+// 	for i := 0; i < 10; i++ {
+// 		key := fmt.Sprintf("key-%d", i)
+// 		retrieved := CacheLookup(key)
+// 		assert.Nil(retrieved, fmt.Sprintf("Old item %s should have been evicted", key))
+// 	}
+
+// 	// Check that the newer items are still in the cache
+// 	for i := 10; i < 20; i++ {
+// 		key := fmt.Sprintf("key-%d", i)
+// 		expected := []byte(fmt.Sprintf("value-%d", i))
+// 		retrieved := CacheLookup(key)
+// 		assert.Equal(expected, retrieved, fmt.Sprintf("Recent item %s should be in cache", key))
+// 	}
+// }
+
+func (suite *Tests) Test_cacheRedisFailure() {
+	mr, err := miniredis.Run()
+	if err != nil {
+		suite.T().Fatal(err)
+	}
+	defer mr.Close()
+
+	config = &CacheConfig{
+		Logger: libpack_logger.New(),
+		TTL:    5,
+	}
+	config.Redis.DB = 0
+	config.Redis.URL = mr.Addr()
+	config.Redis.Enable = true
+	EnableCache(config)
+
+	// Test normal operation
+	CacheStore("test-key", []byte("test-value"))
+	retrieved := CacheLookup("test-key")
+	assert.Equal([]byte("test-value"), retrieved)
+
+	// Simulate Redis failure
+	mr.Close()
+
+	// Operations should not panic, but should return errors or nil values
+	CacheStore("another-key", []byte("another-value"))
+	retrieved = CacheLookup("another-key")
+	assert.Nil(retrieved, "Lookup should return nil when Redis is down")
+}

cache/memory/memory.go

@@ -69,11 +69,17 @@ func (c *Cache) Set(key string, value []byte, ttl time.Duration) {
 
 func (c *Cache) Get(key string) ([]byte, bool) {
 	entry, ok := c.entries.Load(key)
-	if !ok || entry.(CacheEntry).ExpiresAt.Before(time.Now()) {
+	if !ok {
 		return nil, false
 	}
-	compressedValue := entry.(CacheEntry).Value
-	value, err := c.decompress(compressedValue)
+
+	cacheEntry := entry.(CacheEntry)
+	if cacheEntry.ExpiresAt.Before(time.Now()) {
+		c.entries.Delete(key)
+		return nil, false
+	}
+
+	value, err := c.decompress(cacheEntry.Value)
 	if err != nil {
 		log.Printf("Error decompressing value for key %s: %v", key, err)
 		return nil, false

cache/memory/memory_bench_test.go

@@ -1,6 +1,7 @@
 package libpack_cache_memory
 
 import (
+	"fmt"
 	"testing"
 	"time"
 )
@@ -52,3 +53,30 @@ func BenchmarkMemCacheStats(b *testing.B) {
 	cache.Set(key, value, 5*time.Second) // Pre-set a value to retrieve
 	cache.Get(key)
 }
+
+func BenchmarkCacheSet(b *testing.B) {
+	cache := New(5 * time.Second)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		cache.Set(fmt.Sprintf("key-%d", i), []byte("value"), 5*time.Second)
+	}
+}
+
+func BenchmarkCacheGet(b *testing.B) {
+	cache := New(5 * time.Second)
+	cache.Set("test-key", []byte("test-value"), 5*time.Second)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		cache.Get("test-key")
+	}
+}
+
+func BenchmarkCacheDelete(b *testing.B) {
+	cache := New(5 * time.Second)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		key := fmt.Sprintf("key-%d", i)
+		cache.Set(key, []byte("value"), 5*time.Second)
+		cache.Delete(key)
+	}
+}

cache/memory/memory_test.go

@@ -1,6 +1,8 @@
 package libpack_cache_memory
 
 import (
+	"fmt"
+	"sync"
 	"testing"
 	"time"
 
@@ -110,3 +112,57 @@ func (suite *MemoryTestSuite) Test_CacheExpire() {
 		})
 	}
 }
+
+func (suite *MemoryTestSuite) Test_ConcurrentReadWrite() {
+	cache := New(5 * time.Second)
+	const numGoroutines = 100
+	const numOperations = 1000
+
+	var wg sync.WaitGroup
+	wg.Add(numGoroutines)
+
+	for i := 0; i < numGoroutines; i++ {
+		go func(id int) {
+			defer wg.Done()
+			for j := 0; j < numOperations; j++ {
+				key := fmt.Sprintf("key-%d-%d", id, j)
+				value := []byte(fmt.Sprintf("value-%d-%d", id, j))
+
+				if j%2 == 0 {
+					cache.Set(key, value, 5*time.Second)
+				} else {
+					_, _ = cache.Get(key)
+				}
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func (suite *MemoryTestSuite) Test_LargeItems() {
+	cache := New(5 * time.Second)
+	largeValue := make([]byte, 10*1024*1024) // 10MB
+	cache.Set("large-key", largeValue, 5*time.Second)
+
+	retrieved, found := cache.Get("large-key")
+	suite.Assert().True(found)
+	suite.Assert().Equal(largeValue, retrieved)
+}
+
+func (suite *MemoryTestSuite) Test_ZeroTTL() {
+	cache := New(5 * time.Second)
+	cache.Set("zero-ttl", []byte("value"), 0)
+
+	_, found := cache.Get("zero-ttl")
+	suite.Assert().False(found, "Item with zero TTL should not be stored")
+}
+
+func (suite *MemoryTestSuite) Test_LongTTL() {
+	cache := New(5 * time.Second)
+	cache.Set("long-ttl", []byte("value"), 24*365*time.Hour) // 1 year
+
+	retrieved, found := cache.Get("long-ttl")
+	suite.Assert().True(found)
+	suite.Assert().Equal([]byte("value"), retrieved)
+}

cache/redis/redis.go

@@ -11,10 +11,10 @@ import (
 )
 
 type RedisConfig struct {
-	client      *redis.Client
 	ctx         context.Context
-	prefix      string
+	client      *redis.Client
 	builderPool *sync.Pool
+	prefix      string
 }
 
 func (c *RedisConfig) prependKeyName(key string) string {
@@ -29,8 +29,8 @@ func (c *RedisConfig) prependKeyName(key string) string {
 type RedisClientConfig struct {
 	RedisServer   string
 	RedisPassword string
-	RedisDB       int
 	Prefix        string
+	RedisDB       int
 }
 
 func New(redisClientConfig *RedisClientConfig) *RedisConfig {

details.go

@@ -11,18 +11,14 @@ import (
 	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
 )
 
-func extractClaimsFromJWTHeader(authorization string) (usr string, role string) {
-	usr, role = "-", "-"
+const defaultValue = "-"
 
-	handleError := func(msg string, details map[string]interface{}) {
-		cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: msg,
-			Pairs:   details,
-		})
-	}
+var emptyMetrics = map[string]string{}
 
-	tokenParts := strings.Split(authorization, ".")
+func extractClaimsFromJWTHeader(authorization string) (usr, role string) {
+	usr, role = defaultValue, defaultValue
+
+	tokenParts := strings.SplitN(authorization, ".", 3)
 	if len(tokenParts) != 3 {
 		handleError("Can't split the token", map[string]interface{}{"token": authorization})
 		return
@@ -40,18 +36,30 @@ func extractClaimsFromJWTHeader(authorization string) (usr string, role string)
 		return
 	}
 
-	extractClaim := func(claimPath string, target *string, name string) {
-		if len(claimPath) > 0 {
-			var ok bool
-			*target, ok = ask.For(claimMap, claimPath).String("-")
-			if !ok {
-				handleError(fmt.Sprintf("Can't find the %s", name), map[string]interface{}{"claim_map": claimMap, "path": claimPath})
-			}
-		}
-	}
-
-	extractClaim(cfg.Client.JWTUserClaimPath, &usr, "user id")
-	extractClaim(cfg.Client.JWTRoleClaimPath, &role, "role")
+	usr = extractClaim(claimMap, cfg.Client.JWTUserClaimPath, "user id")
+	role = extractClaim(claimMap, cfg.Client.JWTRoleClaimPath, "role")
 
 	return
 }
+
+func extractClaim(claimMap map[string]interface{}, claimPath, name string) string {
+	if claimPath == "" {
+		return defaultValue
+	}
+
+	value, ok := ask.For(claimMap, claimPath).String(defaultValue)
+	if !ok {
+		handleError(fmt.Sprintf("Can't find the %s", name), map[string]interface{}{"claim_map": claimMap, "path": claimPath})
+		return defaultValue
+	}
+
+	return value
+}
+
+func handleError(msg string, details map[string]interface{}) {
+	cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, emptyMetrics)
+	cfg.Logger.Error(&libpack_logger.LogMessage{
+		Message: msg,
+		Pairs:   details,
+	})
+}

events.go

@@ -5,73 +5,99 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 )
 
-func enableHasuraEventCleaner() {
-	if cfg.HasuraEventCleaner.Enable {
-		if cfg.HasuraEventCleaner.EventMetadataDb == "" {
-			cfg.Logger.Warning(&libpack_logger.LogMessage{
-				Message: "Event metadata db URL not specified, event cleaner not active",
-				Pairs:   nil,
-			})
-			return
-		}
+const (
+	initialDelay    = 60 * time.Second
+	cleanupInterval = 1 * time.Hour
+)
 
-		ticker := time.NewTicker(1 * time.Hour)
-		defer ticker.Stop()
-		cfg.Logger.Info(&libpack_logger.LogMessage{
-			Message: "Event cleaner enabled",
-			Pairs:   map[string]interface{}{"interval_in_days": cfg.HasuraEventCleaner.ClearOlderThan},
-		})
-
-		time.Sleep(60 * time.Second) // wait for everything to start and settle down
-		cfg.Logger.Info(&libpack_logger.LogMessage{
-			Message: "Initial cleanup of old events",
-			Pairs:   nil,
-		})
-		cleanEvents()
-
-		for {
-			select {
-			case <-ticker.C:
-				cfg.Logger.Info(&libpack_logger.LogMessage{
-					Message: "Cleaning up old events",
-					Pairs:   nil,
-				})
-				cleanEvents()
-			}
-		}
-	}
+var delQueries = [...]string{
+	"DELETE FROM hdb_catalog.event_invocation_logs WHERE created_at < NOW() - interval '%d days';",
+	"DELETE FROM hdb_catalog.event_log WHERE created_at < NOW() - interval '%d days';",
+	"DELETE FROM hdb_catalog.hdb_action_log WHERE created_at < NOW() - INTERVAL '%d days';",
+	"DELETE FROM hdb_catalog.hdb_cron_event_invocation_logs WHERE created_at < NOW() - INTERVAL '%d days';",
+	"DELETE FROM hdb_catalog.hdb_scheduled_event_invocation_logs WHERE created_at < NOW() - INTERVAL '%d days';",
 }
 
-func cleanEvents() {
-	conn, err := pgx.Connect(context.Background(), cfg.HasuraEventCleaner.EventMetadataDb)
-	if err != nil {
-		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "Failed to connect to event metadata db",
-			Pairs:   map[string]interface{}{"error": err},
+func enableHasuraEventCleaner() {
+	if !cfg.HasuraEventCleaner.Enable {
+		return
+	}
+
+	if cfg.HasuraEventCleaner.EventMetadataDb == "" {
+		cfg.Logger.Warning(&libpack_logger.LogMessage{
+			Message: "Event metadata db URL not specified, event cleaner not active",
 		})
 		return
 	}
-	defer conn.Close(context.Background())
 
-	delQueries := []string{
-		fmt.Sprintf("DELETE FROM hdb_catalog.event_invocation_logs WHERE created_at < now() - interval '%d days';", cfg.HasuraEventCleaner.ClearOlderThan),
-		fmt.Sprintf("DELETE FROM hdb_catalog.event_log WHERE created_at < now() - interval '%d days';", cfg.HasuraEventCleaner.ClearOlderThan),
-		fmt.Sprintf("DELETE FROM hdb_catalog.hdb_action_log WHERE created_at < NOW() - INTERVAL '%d days';", cfg.HasuraEventCleaner.ClearOlderThan),
-		fmt.Sprintf("DELETE FROM hdb_catalog.hdb_cron_event_invocation_logs WHERE created_at < NOW() - INTERVAL '%d days';", cfg.HasuraEventCleaner.ClearOlderThan),
-		fmt.Sprintf("DELETE FROM hdb_catalog.hdb_scheduled_event_invocation_logs WHERE created_at < NOW() - INTERVAL '%d days';", cfg.HasuraEventCleaner.ClearOlderThan),
-	}
+	cfg.Logger.Info(&libpack_logger.LogMessage{
+		Message: "Event cleaner enabled",
+		Pairs:   map[string]interface{}{"interval_in_days": cfg.HasuraEventCleaner.ClearOlderThan},
+	})
+
+	go func() {
+		pool, err := pgxpool.New(context.Background(), cfg.HasuraEventCleaner.EventMetadataDb)
+		if err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Failed to create connection pool",
+				Pairs:   map[string]interface{}{"error": err.Error()},
+			})
+			return
+		}
+		defer pool.Close()
+
+		time.Sleep(initialDelay)
+
+		cfg.Logger.Info(&libpack_logger.LogMessage{
+			Message: "Initial cleanup of old events",
+		})
+		cleanEvents(pool)
+
+		ticker := time.NewTicker(cleanupInterval)
+		defer ticker.Stop()
+
+		for range ticker.C {
+			cfg.Logger.Info(&libpack_logger.LogMessage{
+				Message: "Cleaning up old events",
+			})
+			cleanEvents(pool)
+		}
+	}()
+}
+
+func cleanEvents(pool *pgxpool.Pool) {
+	ctx := context.Background()
+	var errors []error
+	var failedQueries []string
 
 	for _, query := range delQueries {
-		_, err := conn.Exec(context.Background(), query)
+		_, err := pool.Exec(ctx, fmt.Sprintf(query, cfg.HasuraEventCleaner.ClearOlderThan))
 		if err != nil {
+			errors = append(errors, err)
+			failedQueries = append(failedQueries, query)
+		} else {
 			cfg.Logger.Debug(&libpack_logger.LogMessage{
-				Message: "Failed to execute query",
-				Pairs:   map[string]interface{}{"query": query, "error": err},
+				Message: "Successfully executed query",
+				Pairs:   map[string]interface{}{"query": query},
 			})
 		}
 	}
+
+	if len(errors) > 0 {
+		var errMsgs []string
+		for _, err := range errors {
+			errMsgs = append(errMsgs, err.Error())
+		}
+		cfg.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Failed to execute some queries",
+			Pairs: map[string]interface{}{
+				"failed_queries": failedQueries,
+				"errors":         errMsgs,
+			},
+		})
+	}
 }

go.mod

@@ -1,56 +1,55 @@
 module github.com/lukaszraczylo/graphql-monitoring-proxy
 
-go 1.21
+go 1.22.4
 
 require (
-	github.com/VictoriaMetrics/metrics v1.33.1
+	github.com/VictoriaMetrics/metrics v1.35.1
 	github.com/alicebob/miniredis/v2 v2.33.0
 	github.com/avast/retry-go/v4 v4.6.0
 	github.com/goccy/go-json v0.10.3
-	github.com/gofiber/fiber/v2 v2.52.4
-	github.com/gofrs/flock v0.8.1
+	github.com/gofiber/fiber/v2 v2.52.5
+	github.com/gofrs/flock v0.12.1
 	github.com/google/uuid v1.6.0
-	github.com/gookit/goutil v0.6.15
+	github.com/gookit/goutil v0.6.17
 	github.com/graphql-go/graphql v0.8.1
-	github.com/jackc/pgx/v5 v5.6.0
-	github.com/lukaszraczylo/ask v0.0.0-20230927103145-2ff1123b4415
-	github.com/lukaszraczylo/go-ratecounter v0.1.8
-	github.com/lukaszraczylo/go-simple-graphql v1.2.14
-	github.com/redis/go-redis/v9 v9.5.3
+	github.com/jackc/pgx/v5 v5.7.1
+	github.com/lukaszraczylo/ask v0.0.0-20240916204100-6e9ef53a62d9
+	github.com/lukaszraczylo/go-ratecounter v0.1.12
+	github.com/lukaszraczylo/go-simple-graphql v1.2.32
+	github.com/redis/go-redis/v9 v9.7.0
 	github.com/stretchr/testify v1.9.0
-	github.com/valyala/fasthttp v1.55.0
+	github.com/valyala/fasthttp v1.57.0
 )
 
 require (
 	github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a // indirect
-	github.com/andybalholm/brotli v1.1.0 // indirect
+	github.com/andybalholm/brotli v1.1.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/gookit/color v1.5.4 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
-	github.com/klauspost/compress v1.17.9 // indirect
-	github.com/kr/pretty v0.3.1 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
+	github.com/klauspost/compress v1.17.11 // 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/mattn/go-runewidth v0.0.15 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/rogpeppe/go-internal v1.11.0 // indirect
-	github.com/rs/zerolog v1.33.0 // indirect
+	github.com/rogpeppe/go-internal v1.12.0 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fastrand v1.1.0 // indirect
 	github.com/valyala/histogram v1.2.0 // indirect
 	github.com/valyala/tcplisten v1.0.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	github.com/yuin/gopher-lua v1.1.1 // indirect
-	golang.org/x/crypto v0.24.0 // indirect
-	golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 // indirect
-	golang.org/x/net v0.26.0 // indirect
-	golang.org/x/sync v0.7.0 // indirect
-	golang.org/x/sys v0.21.0 // indirect
-	golang.org/x/term v0.21.0 // indirect
-	golang.org/x/text v0.16.0 // indirect
+	golang.org/x/crypto v0.30.0 // indirect
+	golang.org/x/net v0.32.0 // indirect
+	golang.org/x/sync v0.10.0 // indirect
+	golang.org/x/sys v0.28.0 // indirect
+	golang.org/x/term v0.27.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,11 +1,11 @@
-github.com/VictoriaMetrics/metrics v1.33.1 h1:CNV3tfm2Kpv7Y9W3ohmvqgFWPR55tV2c7M2U6OIo+UM=
-github.com/VictoriaMetrics/metrics v1.33.1/go.mod h1:r7hveu6xMdUACXvB8TYdAj8WEsKzWB0EkpJN+RDtOf8=
+github.com/VictoriaMetrics/metrics v1.35.1 h1:o84wtBKQbzLdDy14XeskkCZih6anG+veZ1SwJHFGwrU=
+github.com/VictoriaMetrics/metrics v1.35.1/go.mod h1:r7hveu6xMdUACXvB8TYdAj8WEsKzWB0EkpJN+RDtOf8=
 github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a h1:HbKu58rmZpUGpz5+4FfNmIU+FmZg2P3Xaj2v2bfNWmk=
 github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a/go.mod h1:SGnFV6hVsYE877CKEZ6tDNTjaSXYUk6QqoIK6PrAtcc=
 github.com/alicebob/miniredis/v2 v2.33.0 h1:uvTF0EDeu9RLnUEG27Db5I68ESoIxTiXbNUiji6lZrA=
 github.com/alicebob/miniredis/v2 v2.33.0/go.mod h1:MhP4a3EU7aENRi9aO+tHfTBZicLqQevyi/DJpoj6mi0=
-github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
-github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
+github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
+github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
 github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA=
 github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
@@ -14,7 +14,6 @@ github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
 github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-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=
@@ -23,62 +22,56 @@ github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/r
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
 github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
 github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
-github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/gofiber/fiber/v2 v2.52.4 h1:P+T+4iK7VaqUsq2PALYEfBBo6bJZ4q3FP8cZ84EggTM=
-github.com/gofiber/fiber/v2 v2.52.4/go.mod h1:KEOE+cXMhXG0zHc9d8+E38hoX+ZN7bhOtgeF2oT6jrQ=
-github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
-github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
+github.com/goccy/go-reflect v1.2.0 h1:O0T8rZCuNmGXewnATuKYnkL0xm6o8UNOJZd/gOkb9ms=
+github.com/goccy/go-reflect v1.2.0/go.mod h1:n0oYZn8VcV2CkWTxi8B9QjkCoq6GTtCEdfmR66YhFtE=
+github.com/gofiber/fiber/v2 v2.52.5 h1:tWoP1MJQjGEe4GB5TUGOi7P2E0ZMMRx5ZTG4rT+yGMo=
+github.com/gofiber/fiber/v2 v2.52.5/go.mod h1:KEOE+cXMhXG0zHc9d8+E38hoX+ZN7bhOtgeF2oT6jrQ=
+github.com/gofrs/flock v0.12.1 h1:MTLVXXHf8ekldpJk3AKicLij9MdwOWkZ+a/jHHZby9E=
+github.com/gofrs/flock v0.12.1/go.mod h1:9zxTsyu5xtJ9DK+1tFZyibEV7y3uwDxPPfbxeeHCoD0=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 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.15 h1:mMQ0ElojNZoyPD0eVROk5QXJPh2uKR4g06slgPDF5Jo=
-github.com/gookit/goutil v0.6.15/go.mod h1:qdKdYEHQdEtyH+4fNdQNZfJHhI0jUZzHxQVAV3DaMDY=
+github.com/gookit/goutil v0.6.17 h1:SxmbDz2sn2V+O+xJjJhJT/sq1/kQh6rCJ7vLBiRPZjI=
+github.com/gookit/goutil v0.6.17/go.mod h1:rSw1LchE1I3TDWITZvefoAC9tS09SFu3lHXLCV7EaEY=
 github.com/graphql-go/graphql v0.8.1 h1:p7/Ou/WpmulocJeEx7wjQy611rtXGQaAcXGqanuMMgc=
 github.com/graphql-go/graphql v0.8.1/go.mod h1:nKiHzRM0qopJEwCITUuIsxk9PlVlwIiiI8pnJEhordQ=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
-github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
-github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
-github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/jackc/pgx/v5 v5.7.1 h1:x7SYsPBYDkHDksogeSmZZ5xzThcTgRz++I5E+ePFUcs=
+github.com/jackc/pgx/v5 v5.7.1/go.mod h1:e7O26IywZZ+naJtWWos6i6fvWK+29etgITqrqHLfoZA=
+github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
+github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
 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/ask v0.0.0-20230927103145-2ff1123b4415 h1:lvI8Wlbg4PxkRcg2f10wgoaRpfN19v+YdRek3+dLtlM=
-github.com/lukaszraczylo/ask v0.0.0-20230927103145-2ff1123b4415/go.mod h1:M+UVdyqZs++xtEPrascaVmZdOMhCnxjZ2SgH+xHpR0c=
-github.com/lukaszraczylo/go-ratecounter v0.1.8 h1:ZYm6Wkn58ZAlFWRmC7PaD4oAYHWcu8/0MUDWGe3PnJQ=
-github.com/lukaszraczylo/go-ratecounter v0.1.8/go.mod h1:TqXEOCtFJStk1i0tkipprv1kiDHGon1MVUisjSTBSKM=
-github.com/lukaszraczylo/go-simple-graphql v1.2.14 h1:Dth+yZ+1ialCpnslSb6UgHbXszExjDUu/I95QZbnWVU=
-github.com/lukaszraczylo/go-simple-graphql v1.2.14/go.mod h1:pSKmm9OLGoS9pjmIvhBB/fo0+LganRrL29CN3fdkRPw=
+github.com/lukaszraczylo/ask v0.0.0-20240916204100-6e9ef53a62d9 h1:pL8B9mjv6RPUfKYYGm/uJ7QL6Ndf+z+OEl0qJE6KmEc=
+github.com/lukaszraczylo/ask v0.0.0-20240916204100-6e9ef53a62d9/go.mod h1:M+UVdyqZs++xtEPrascaVmZdOMhCnxjZ2SgH+xHpR0c=
+github.com/lukaszraczylo/go-ratecounter v0.1.12 h1:VO6hHYGw/Jy9JUizXf/bS0AI2QX1ueWWAWckMFVJ/w4=
+github.com/lukaszraczylo/go-ratecounter v0.1.12/go.mod h1:TqXEOCtFJStk1i0tkipprv1kiDHGon1MVUisjSTBSKM=
+github.com/lukaszraczylo/go-simple-graphql v1.2.32 h1:CKjXgNHUuwzeBVKIPLXoMw4wPQCqchIV0htFGk5+Hpg=
+github.com/lukaszraczylo/go-simple-graphql v1.2.32/go.mod h1:Y0fEHnPijfPyTF4fzSEpgmu5kaA4lENA0+gQdI1y1+0=
 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/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 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/redis/go-redis/v9 v9.5.3 h1:fOAp1/uJG+ZtcITgZOfYFmTKPE7n4Vclj1wZFgRciUU=
-github.com/redis/go-redis/v9 v9.5.3/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M=
+github.com/redis/go-redis/v9 v9.7.0 h1:HhLSs+B6O021gwzl+locl0zEDnyNkxMtf/Z3NNBMa9E=
+github.com/redis/go-redis/v9 v9.7.0/go.mod h1:f6zhXITC7JUJIlPEiBOTXxJgPLdZcA93GewI7inzyWw=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
-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.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
-github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
@@ -86,8 +79,8 @@ github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsT
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasthttp v1.55.0 h1:Zkefzgt6a7+bVKHnu/YaYSOPfNYNisSVBo/unVCf8k8=
-github.com/valyala/fasthttp v1.55.0/go.mod h1:NkY9JtkrpPKmgwV3HTaS2HWaJss9RSIsRVfcxxoHiOM=
+github.com/valyala/fasthttp v1.57.0 h1:Xw8SjWGEP/+wAAgyy5XTvgrWlOD1+TxbbvNADYCm1Tg=
+github.com/valyala/fasthttp v1.57.0/go.mod h1:h6ZBaPRlzpZ6O3H5t2gEk1Qi33+TmLvfwgLLp0t9CpE=
 github.com/valyala/fastrand v1.1.0 h1:f+5HkLW4rsgzdNoleUOB69hyT9IlD2ZQh9GyDMfb5G8=
 github.com/valyala/fastrand v1.1.0/go.mod h1:HWqCzkrkg6QXT8V2EXWvXCoow7vLwOFN002oeRzjapQ=
 github.com/valyala/histogram v1.2.0 h1:wyYGAZZt3CpwUiIb9AU/Zbllg1llXyrtApRS815OLoQ=
@@ -96,25 +89,26 @@ github.com/valyala/tcplisten v1.0.0 h1:rBHj/Xf+E1tRGZyWIWwJDiRY0zc1Js+CV5DqwacVS
 github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc=
 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=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
 github.com/yuin/gopher-lua v1.1.1 h1:kYKnWBjvbNP4XLT3+bPEwAXJx262OhaHDWDVOPjL46M=
 github.com/yuin/gopher-lua v1.1.1/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=
-golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
-golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM=
-golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
-golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
-golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/crypto v0.30.0 h1:RwoQn3GkWiMkzlX562cLB7OxWvjH1L8xutO2WoJcRoY=
+golang.org/x/crypto v0.30.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+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.32.0 h1:ZqPmj8Kzc+Y6e0+skZsuACbx+wzMgo5MQsJh9Qd6aYI=
+golang.org/x/net v0.32.0/go.mod h1:CwU0IoeOlnQQWJ6ioyFrfRuomB8GKF6KbYXZVyeXNfs=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.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.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA=
-golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 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=

graphql.go

@@ -3,6 +3,7 @@ package main
 import (
 	"strconv"
 	"strings"
+	"sync"
 
 	"github.com/goccy/go-json"
 	fiber "github.com/gofiber/fiber/v2"
@@ -12,48 +13,27 @@ import (
 	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
 )
 
-var introspection_queries = []string{
-	"__schema",
-	"__type",
-	"__typename",
-	"__directive",
-	"__directivelocation",
-	"__field",
-	"__inputvalue",
-	"__enumvalue",
-	"__typekind",
-	"__fieldtype",
-	"__inputobjecttype",
-	"__enumtype",
-	"__uniontype",
-	"__scalars",
-	"__objects",
-	"__interfaces",
-	"__unions",
-	"__enums",
-	"__inputobjects",
-	"__directives",
-}
-
-// Saving the introspection queries as a map O(1) operation instead of O(n) for a slice.
-
-var introspectionQuerySet = map[string]struct{}{}
-var introspectionAllowedQueries = map[string]struct{}{}
-var allowedUrls = map[string]struct{}{}
-
-// Utility function to convert a slice of strings to a map for O(1) lookups.
-func sliceToMap(slice []string) map[string]struct{} {
-	resultMap := make(map[string]struct{}, len(slice))
-	for _, item := range slice {
-		resultMap[strings.ToLower(item)] = struct{}{}
+var (
+	introspectionQueries = map[string]struct{}{
+		"__schema": {}, "__type": {}, "__typename": {}, "__directive": {},
+		"__directivelocation": {}, "__field": {}, "__inputvalue": {},
+		"__enumvalue": {}, "__typekind": {}, "__fieldtype": {},
+		"__inputobjecttype": {}, "__enumtype": {}, "__uniontype": {},
+		"__scalars": {}, "__objects": {}, "__interfaces": {},
+		"__unions": {}, "__enums": {}, "__inputobjects": {}, "__directives": {},
 	}
-	return resultMap
-}
+	introspectionAllowedQueries = make(map[string]struct{})
+	allowedUrls                 = make(map[string]struct{})
+)
 
 func prepareQueriesAndExemptions() {
-	introspectionQuerySet = sliceToMap(introspection_queries)
-	introspectionAllowedQueries = sliceToMap(cfg.Security.IntrospectionAllowed)
-	allowedUrls = sliceToMap(cfg.Server.AllowURLs)
+	for _, q := range cfg.Security.IntrospectionAllowed {
+			introspectionAllowedQueries[strings.ToLower(q)] = struct{}{}
+	}
+
+	for _, u := range cfg.Server.AllowURLs {
+			allowedUrls[u] = struct{}{}
+	}
 }
 
 type parseGraphQLQueryResult struct {
@@ -67,156 +47,191 @@ type parseGraphQLQueryResult struct {
 	shouldIgnore   bool
 }
 
-func parseGraphQLQuery(c *fiber.Ctx) (res *parseGraphQLQueryResult) {
-	res = &parseGraphQLQueryResult{shouldIgnore: true}
-	m := make(map[string]interface{})
-	err := json.Unmarshal(c.Body(), &m)
-	if err != nil {
-		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "Can't unmarshal the request",
-			Pairs:   map[string]interface{}{"error": err.Error(), "body": string(c.Body())},
-		})
-		if ifNotInTest() {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
-		}
-		return
+var (
+	queryPool = sync.Pool{
+		New: func() interface{} {
+			return make(map[string]interface{}, 48)
+		},
 	}
-	// get the query
+	resultPool = sync.Pool{
+		New: func() interface{} {
+			return &parseGraphQLQueryResult{}
+		},
+	}
+)
+
+func parseGraphQLQuery(c *fiber.Ctx) *parseGraphQLQueryResult {
+	res := resultPool.Get().(*parseGraphQLQueryResult)
+	*res = parseGraphQLQueryResult{shouldIgnore: true, activeEndpoint: cfg.Server.HostGraphQL}
+
+	m := queryPool.Get().(map[string]interface{})
+	defer func() {
+			for k := range m {
+					delete(m, k)
+			}
+			queryPool.Put(m)
+	}()
+
+	if err := json.Unmarshal(c.Body(), &m); err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+					Message: "Can't unmarshal the request",
+					Pairs:   map[string]interface{}{"error": err.Error(), "body": string(c.Body())},
+			})
+			if ifNotInTest() {
+					cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
+			}
+			return res
+	}
+
 	query, ok := m["query"].(string)
 	if !ok {
-		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "Can't find the query",
-			Pairs:   map[string]interface{}{"m_val": m},
-		})
-		if ifNotInTest() {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
-		}
-		return
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+					Message: "Can't find the query",
+					Pairs:   map[string]interface{}{"m_val": m},
+			})
+			if ifNotInTest() {
+					cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
+			}
+			return res
 	}
 
 	p, err := parser.Parse(parser.ParseParams{Source: query})
 	if err != nil {
-		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "Can't parse the query",
-			Pairs:   map[string]interface{}{"query": query, "m_val": m},
-		})
-		if ifNotInTest() {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-		}
-		return
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+					Message: "Can't parse the query",
+					Pairs:   map[string]interface{}{"query": query, "m_val": m},
+			})
+			if ifNotInTest() {
+					cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
+			}
+			return res
 	}
 
 	res.shouldIgnore = false
 	res.operationName = "undefined"
-	res.activeEndpoint = cfg.Server.HostGraphQL
 
 	for _, d := range p.Definitions {
-		if oper, ok := d.(*ast.OperationDefinition); ok {
-			res.operationType = strings.ToLower(oper.Operation)
-
-			if oper.Name != nil {
-				res.operationName = oper.Name.Value
-			}
-
-			// If the query is a mutation then direct it to the RW endpoint,
-			// otherwise direct it to the RO endpoint if it's set.
-			if cfg.Server.HostGraphQLReadOnly != "" && res.operationType != "mutation" {
-				res.activeEndpoint = cfg.Server.HostGraphQLReadOnly
-			}
-
-			if res.operationType == "mutation" && cfg.Server.ReadOnlyMode {
-				cfg.Logger.Warning(&libpack_logger.LogMessage{
-					Message: "Mutation blocked",
-					Pairs:   map[string]interface{}{"query": query},
-				})
-				if ifNotInTest() {
-					cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
-				}
-				c.Status(403).SendString("The server is in read-only mode")
-				res.shouldBlock = true
-				return
-			}
-
-			for _, dir := range oper.Directives {
-				if dir.Name.Value == "cached" {
-					res.cacheRequest = true
-					for _, arg := range dir.Arguments {
-						if arg.Name.Value == "ttl" {
-							res.cacheTime, err = strconv.Atoi(arg.Value.GetValue().(string))
-							if err != nil {
-								cfg.Logger.Error(&libpack_logger.LogMessage{
-									Message: "Can't parse the ttl, using global",
-									Pairs:   map[string]interface{}{"bad_ttl": arg.Value.GetValue().(string)},
-								})
-								if ifNotInTest() {
-									cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-								}
-								return
+			if oper, ok := d.(*ast.OperationDefinition); ok {
+					if res.operationType == "" {
+							res.operationType = strings.ToLower(oper.Operation)
+							if oper.Name != nil {
+									res.operationName = oper.Name.Value
 							}
-						}
-						if arg.Name.Value == "refresh" {
-							res.cacheRefresh = arg.Value.GetValue().(bool)
-						}
 					}
-				}
-			}
 
-			if cfg.Security.BlockIntrospection {
-				res.shouldBlock = checkSelections(c, oper.GetSelectionSet().Selections)
-				if res.shouldBlock {
-					return
-				}
+					if cfg.Server.HostGraphQLReadOnly != "" {
+							if res.operationType == "" || res.operationType != "mutation" {
+									res.activeEndpoint = cfg.Server.HostGraphQLReadOnly
+							}
+					}
+
+					if res.operationType == "mutation" && cfg.Server.ReadOnlyMode {
+							cfg.Logger.Warning(&libpack_logger.LogMessage{
+									Message: "Mutation blocked - server in read-only mode",
+									Pairs:   map[string]interface{}{"query": query},
+							})
+							if ifNotInTest() {
+									cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
+							}
+							_ = c.Status(403).SendString("The server is in read-only mode")
+							res.shouldBlock = true
+							resultPool.Put(res)
+							return res
+					}
+
+					for _, dir := range oper.Directives {
+							if dir.Name.Value == "cached" {
+									res.cacheRequest = true
+									for _, arg := range dir.Arguments {
+											switch arg.Name.Value {
+											case "ttl":
+													if v, ok := arg.Value.GetValue().(string); ok {
+															res.cacheTime, _ = strconv.Atoi(v)
+													}
+											case "refresh":
+													if v, ok := arg.Value.GetValue().(bool); ok {
+															res.cacheRefresh = v
+													}
+											}
+									}
+							}
+					}
+
+					if cfg.Security.BlockIntrospection {
+							if checkSelections(c, oper.GetSelectionSet().Selections) {
+									_ = c.Status(403).SendString("Introspection queries are not allowed")
+									res.shouldBlock = true
+									resultPool.Put(res)
+									return res
+							}
+					}
 			}
-		}
 	}
-	return
+	return res
 }
 
 func checkSelections(c *fiber.Ctx, selections []ast.Selection) bool {
 	for _, s := range selections {
-		field, ok := s.(*ast.Field)
-		if !ok {
-			continue // or handle the case where the type assertion fails
-		}
-		shouldBlock := checkIfContainsIntrospection(c, field.Name.Value)
-		if shouldBlock {
-			return true
-		}
-		if field.SelectionSet != nil {
-			if checkSelections(c, field.GetSelectionSet().Selections) {
-				return true
+			switch sel := s.(type) {
+			case *ast.Field:
+					fieldName := strings.ToLower(sel.Name.Value)
+					if _, exists := introspectionQueries[fieldName]; exists {
+							if len(cfg.Security.IntrospectionAllowed) > 0 {
+									if _, allowed := introspectionAllowedQueries[fieldName]; !allowed {
+											return true
+									}
+							} else {
+									return true
+							}
+					}
+					if sel.SelectionSet != nil {
+							if checkSelections(c, sel.GetSelectionSet().Selections) {
+									return true
+							}
+					}
+			case *ast.InlineFragment:
+					if sel.SelectionSet != nil {
+							if checkSelections(c, sel.GetSelectionSet().Selections) {
+									return true
+							}
+					}
 			}
-		}
 	}
 	return false
 }
 
-func checkIfContainsIntrospection(c *fiber.Ctx, whatever string) (shouldBlock bool) {
-	whateverLower := strings.ToLower(whatever)
-	got_exemption := false
-
-	// If the query is an introspection query, we need to check if it's allowed.
-	if _, exists := introspectionQuerySet[whateverLower]; exists {
-		if len(cfg.Security.IntrospectionAllowed) > 0 {
-
-			if _, allowed_exists := introspectionAllowedQueries[whateverLower]; allowed_exists {
-				cfg.Logger.Debug(&libpack_logger.LogMessage{
-					Message: "Introspection query allowed, passing through",
-					Pairs:   map[string]interface{}{"query": whatever},
-				})
-				got_exemption = true
-				shouldBlock = false
+func checkIfContainsIntrospection(c *fiber.Ctx, query string) bool {
+	blocked := false
+	// Try parsing as a complete query first
+	p, err := parser.Parse(parser.ParseParams{Source: query})
+	if err == nil {
+		// It's a complete query, check all selections
+		for _, def := range p.Definitions {
+			if op, ok := def.(*ast.OperationDefinition); ok {
+				if op.SelectionSet != nil {
+					blocked = checkSelections(c, op.GetSelectionSet().Selections)
+				}
 			}
 		}
-		if !got_exemption {
-			shouldBlock = true
+	} else {
+		// Not a complete query, check as a field name
+		whateverLower := strings.ToLower(query)
+		if _, exists := introspectionQueries[whateverLower]; exists {
+			if len(cfg.Security.IntrospectionAllowed) > 0 {
+				if _, allowed := introspectionAllowedQueries[whateverLower]; !allowed {
+					blocked = true
+				}
+			} else {
+				blocked = true
+			}
 		}
 	}
-	if shouldBlock {
+
+	if blocked {
 		if ifNotInTest() {
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
 		}
-		c.Status(403).SendString("Introspection queries are not allowed")
+		_ = c.Status(403).SendString("Introspection queries are not allowed")
 	}
-	return
+	return blocked
 }

graphql_test.go

@@ -1,6 +1,11 @@
 package main
 
 import (
+	"fmt"
+	"strings"
+
+	"github.com/goccy/go-json"
+	fiber "github.com/gofiber/fiber/v2"
 	"github.com/valyala/fasthttp"
 )
 
@@ -318,3 +323,182 @@ func (suite *Tests) Test_parseGraphQLQuery() {
 		})
 	}
 }
+
+func (suite *Tests) Test_parseGraphQLQuery_complex() {
+	// ... existing tests ...
+
+	// Add these new test cases
+	suite.Run("test complex query with multiple operations", func() {
+		query := `
+			query GetUser($id: ID!) {
+					user(id: $id) {
+							name
+							email
+					}
+			}
+			mutation UpdateUser($id: ID!, $name: String!) {
+					updateUser(id: $id, name: $name) {
+							id
+							name
+					}
+			}
+			`
+		body := fmt.Sprintf(`{"query": %q}`, query)
+		ctx := createTestContext(body)
+		result := parseGraphQLQuery(ctx)
+		assert.Equal("query", result.operationType)
+		assert.Equal("GetUser", result.operationName)
+		assert.False(result.shouldBlock)
+	})
+
+	suite.Run("test query with custom directives", func() {
+		query := `
+			query GetUser($id: ID!) @custom(directive: "value") {
+					user(id: $id) {
+							name
+							email
+					}
+			}
+			`
+		body := fmt.Sprintf(`{"query": %q}`, query)
+		ctx := createTestContext(body)
+		result := parseGraphQLQuery(ctx)
+		assert.Equal("query", result.operationType)
+		assert.Equal("GetUser", result.operationName)
+		assert.False(result.shouldBlock)
+		assert.False(result.shouldBlock)
+	})
+}
+
+func (suite *Tests) Test_checkAllowedURLs() {
+	tests := []struct {
+		name     string
+		path     string
+		allowed  []string
+		expected bool
+	}{
+		{"allowed path", "/v1/graphql", []string{"/v1/graphql"}, true},
+		{"disallowed path", "/v2/graphql", []string{"/v1/graphql"}, false},
+		{"empty allowed list", "/v1/graphql", []string{}, true},
+		{"multiple allowed paths", "/v2/graphql", []string{"/v1/graphql", "/v2/graphql"}, true},
+	}
+
+	for _, tt := range tests {
+		suite.Run(tt.name, func() {
+			allowedUrls = make(map[string]struct{})
+			for _, url := range tt.allowed {
+				allowedUrls[url] = struct{}{}
+			}
+			app := fiber.New()
+			ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
+			ctx.Request().SetRequestURI(tt.path)
+			ctx.Request().URI().SetPath(tt.path)
+			result := checkAllowedURLs(ctx)
+			assert.Equal(tt.expected, result, "Unexpected result in test case: "+tt.name)
+		})
+	}
+}
+
+func (suite *Tests) Test_checkIfContainsIntrospection() {
+	tests := []struct {
+		name     string
+		query    string
+		allowed  []string
+		expected bool
+	}{
+		{"allowed introspection", "__schema", []string{"__schema"}, false},
+		{"disallowed introspection", "__type", []string{"__schema"}, true},
+		{"non-introspection query", "normalQuery", []string{}, false},
+		{"allowed introspection with deep nesting of __typename", "{__schema {queryType {fields {name description __typename}}}}", []string{"__schema", "__typename"}, false},
+		{"disallowed introspection with deep nesting of __typename", "{__type {queryType {fields {name description __typename}}}}", []string{"__type"}, true},
+	}
+
+	for _, tt := range tests {
+		suite.Run(tt.name, func() {
+			cfg.Security.IntrospectionAllowed = tt.allowed
+			introspectionAllowedQueries = make(map[string]struct{})
+			for _, q := range tt.allowed {
+				introspectionAllowedQueries[strings.ToLower(q)] = struct{}{}
+			}
+			ctx := createTestContext("")
+			result := checkIfContainsIntrospection(ctx, tt.query)
+			assert.Equal(tt.expected, result)
+		})
+	}
+}
+
+func createTestContext(body string) *fiber.Ctx {
+	app := fiber.New()
+	ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
+	ctx.Request().SetBody([]byte(body))
+	return ctx
+}
+
+func (suite *Tests) Test_DeepIntrospectionQueries() {
+	tests := []struct {
+			name     string
+			query    string
+			allowed  []string
+			expected bool
+	}{
+			{
+					name: "deeply nested single introspection",
+					query: "query { users { profiles { settings { preferences { __typename } } } } }",
+					allowed:  []string{},
+					expected: true,
+			},
+			{
+					name: "multiple nested introspections",
+					query: "query { users { __typename profiles { __schema settings { __type } } } }",
+					allowed:  []string{},
+					expected: true,
+			},
+			{
+					name: "nested with selective allowlist",
+					query: "query { users { __typename profiles { __schema settings { __type } } } }",
+					allowed:  []string{"__typename"},
+					expected: true,
+			},
+			{
+					name: "deeply nested with full allowlist",
+					query: "query { users { __typename profiles { __schema settings { __type } } } }",
+					allowed:  []string{"__typename", "__schema", "__type"},
+					expected: false,
+			},
+			{
+				name: "deeply nested with repeated item from allowlist",
+				query: "query PreloadStaticData {\n  scenario {\n    id\n    name\n    __typename\n  }\n  impact {\n    id\n    description\n    __typename\n  }\n  likelihood {\n    id\n    description\n    __typename\n  }\n  consequence {\n    name\n    __typename\n  }\n  risk_categories {\n    name\n    abbreviation\n    __typename\n  }\n  mitigation {\n    name\n    __typename\n  }\n}",
+				allowed: []string{"__type", "__typename"},
+				expected: false,
+			},
+			{
+				name: "deeply nested with repeated item denied",
+				query: "query PreloadStaticData {\n  scenario {\n    id\n    name\n    __typename\n  }\n  impact {\n    id\n    description\n    __typename\n  }\n  likelihood {\n    id\n    description\n    __typename\n  }\n  consequence {\n    name\n    __typename\n  }\n  risk_categories {\n    name\n    abbreviation\n    __typename\n  }\n  mitigation {\n    name\n    __typename\n  }\n}",
+				allowed: []string{},
+				expected: true,
+			},
+	}
+
+	for _, tt := range tests {
+			suite.Run(tt.name, func() {
+					cfg.Security.BlockIntrospection = true
+					cfg.Security.IntrospectionAllowed = tt.allowed
+					introspectionAllowedQueries = make(map[string]struct{})
+					for _, q := range tt.allowed {
+							introspectionAllowedQueries[strings.ToLower(q)] = struct{}{}
+					}
+					body := map[string]interface{}{
+							"query": tt.query,
+					}
+					bodyBytes, _ := json.Marshal(body)
+					ctx := fiber.New().AcquireCtx(&fasthttp.RequestCtx{})
+					ctx.Request().SetBody(bodyBytes)
+					parseGraphQLQuery(ctx)
+					if tt.expected {
+							suite.Equal(403, ctx.Response().StatusCode())
+					} else {
+							suite.Equal(200, ctx.Response().StatusCode())
+					}
+			})
+	}
+}

logging/logger.go

@@ -2,7 +2,6 @@ package libpack_logger
 
 import (
 	"bytes"
-	"flag"
 	"fmt"
 	"io"
 	"os"
@@ -16,16 +15,14 @@ import (
 )
 
 const (
-	_ = iota
-	LEVEL_DEBUG
+	LEVEL_DEBUG = iota
 	LEVEL_INFO
 	LEVEL_WARN
 	LEVEL_ERROR
 	LEVEL_FATAL
 )
 
-var LevelNames = [...]string{
-	"none",
+var levelNames = []string{
 	"debug",
 	"info",
 	"warn",
@@ -34,74 +31,103 @@ var LevelNames = [...]string{
 }
 
 const (
-	defaultFormat     = time.RFC3339
+	defaultTimeFormat = time.RFC3339
 	defaultMinLevel   = LEVEL_INFO
 	defaultShowCaller = false
 )
 
-var defaultOutput = os.Stdout
-
+// Logger represents the logging object with configurations.
 type Logger struct {
-	format      string
+	output      io.Writer
+	timeFormat  string
 	minLogLevel int
 	showCaller  bool
-	output      io.Writer
 }
 
+// LogMessage represents a log message with optional pairs.
 type LogMessage struct {
+	Pairs   map[string]interface{}
 	Message string
-	Pairs   map[string]any
-	output  io.Writer
 }
 
-func (m *LogMessage) String() string {
-	return m.Message
+// bufferPool is used to reuse bytes.Buffer for efficiency.
+var bufferPool = sync.Pool{
+	New: func() interface{} {
+		return new(bytes.Buffer)
+	},
 }
 
+// fieldNames allows customization of output field names.
 var fieldNames = map[string]string{
 	"timestamp": "timestamp",
 	"level":     "level",
 	"message":   "message",
 }
 
+// New creates a new Logger with default settings.
 func New() *Logger {
 	return &Logger{
-		format:      defaultFormat,
+		timeFormat:  defaultTimeFormat,
 		minLogLevel: defaultMinLevel,
-		output:      defaultOutput,
+		output:      os.Stdout,
 		showCaller:  defaultShowCaller,
 	}
 }
 
+// SetOutput sets the output destination for the logger.
 func (l *Logger) SetOutput(output io.Writer) *Logger {
 	l.output = output
 	return l
 }
 
-var bufferPool = sync.Pool{
-	New: func() any {
-		return new(bytes.Buffer)
-	},
-}
-
-var defaultPairs = make(map[string]any)
-
+// GetLogLevel returns the log level integer corresponding to the given level name.
 func GetLogLevel(level string) int {
-	for i, name := range LevelNames {
-		if name == strings.ToLower(level) {
+	level = strings.ToLower(level)
+	for i, name := range levelNames {
+		if name == level {
 			return i
 		}
 	}
 	return defaultMinLevel
 }
 
+// SetTimeFormat sets the time format for the logger's timestamp field.
+func (l *Logger) SetTimeFormat(format string) *Logger {
+	l.timeFormat = format
+	return l
+}
+
+// SetMinLogLevel sets the minimum log level for the logger.
+func (l *Logger) SetMinLogLevel(level int) *Logger {
+	l.minLogLevel = level
+	return l
+}
+
+// SetFieldName allows customizing the field names in log output.
+func (l *Logger) SetFieldName(field, name string) *Logger {
+	fieldNames[field] = name
+	return l
+}
+
+// SetShowCaller enables or disables including the caller information in log output.
+func (l *Logger) SetShowCaller(show bool) *Logger {
+	l.showCaller = show
+	return l
+}
+
+// shouldLog determines if the message should be logged based on the logger's minimum log level.
+func (l *Logger) shouldLog(level int) bool {
+	return level >= l.minLogLevel
+}
+
+// log writes the log message with the given level.
 func (l *Logger) log(level int, m *LogMessage) {
 	if m.Pairs == nil {
-		m.Pairs = defaultPairs
+		m.Pairs = make(map[string]interface{})
 	}
 
-	m.Pairs[fieldNames["timestamp"]] = time.Now().Format(l.format)
-	m.Pairs[fieldNames["level"]] = LevelNames[level]
+	m.Pairs[fieldNames["timestamp"]] = time.Now().Format(l.timeFormat)
+	m.Pairs[fieldNames["level"]] = levelNames[level]
 	m.Pairs[fieldNames["message"]] = m.Message
 
 	if l.showCaller {
@@ -109,93 +135,73 @@ func (l *Logger) log(level int, m *LogMessage) {
 	}
 
 	buffer := bufferPool.Get().(*bytes.Buffer)
-	defer bufferPool.Put(buffer)
 	buffer.Reset()
+	defer bufferPool.Put(buffer)
 
-	var encoder = json.NewEncoder(buffer)
+	encoder := json.NewEncoder(buffer)
 	err := encoder.Encode(m.Pairs)
 	if err != nil {
-		fmt.Println("Error marshalling log message:", err)
+		fmt.Fprintln(os.Stderr, "Error marshalling log message:", err)
 		return
 	}
 
-	// if not running in test - use stderr and stdout, otherwise - use logger's output setting
-	if flag.Lookup("test.v") != nil {
-		m.output = os.Stdout
-		if level >= LEVEL_ERROR {
-			m.output = os.Stderr
-		}
+	_, err = l.output.Write(buffer.Bytes())
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "Error writing log message:", err)
 	}
-
-	// Use logger's output setting instead of os.Stdout or os.Stderr
-	l.output.Write(buffer.Bytes())
 }
 
+// Debug logs a debug-level message.
 func (l *Logger) Debug(m *LogMessage) {
 	if l.shouldLog(LEVEL_DEBUG) {
 		l.log(LEVEL_DEBUG, m)
 	}
 }
 
+// Info logs an info-level message.
 func (l *Logger) Info(m *LogMessage) {
 	if l.shouldLog(LEVEL_INFO) {
 		l.log(LEVEL_INFO, m)
 	}
 }
 
+// Warn logs a warning-level message.
 func (l *Logger) Warn(m *LogMessage) {
 	if l.shouldLog(LEVEL_WARN) {
 		l.log(LEVEL_WARN, m)
 	}
 }
 
+// Warning is an alias for Warn.
 func (l *Logger) Warning(m *LogMessage) {
 	l.Warn(m)
 }
 
+// Error logs an error-level message.
 func (l *Logger) Error(m *LogMessage) {
 	if l.shouldLog(LEVEL_ERROR) {
 		l.log(LEVEL_ERROR, m)
 	}
 }
 
+// Fatal logs a fatal-level message.
 func (l *Logger) Fatal(m *LogMessage) {
 	if l.shouldLog(LEVEL_FATAL) {
 		l.log(LEVEL_FATAL, m)
 	}
 }
 
+// Critical logs a critical-level message and exits the application.
 func (l *Logger) Critical(m *LogMessage) {
 	l.Fatal(m)
 	os.Exit(1)
 }
 
-func (l *Logger) shouldLog(level int) bool {
-	return level >= l.minLogLevel
-}
-
-func (l *Logger) SetFormat(format string) *Logger {
-	l.format = format
-	return l
-}
-
-func (l *Logger) SetMinLogLevel(level int) *Logger {
-	l.minLogLevel = level
-	return l
-}
-
-func (l *Logger) SetFieldName(field, name string) *Logger {
-	fieldNames[field] = name
-	return l
-}
-
-func (l *Logger) SetShowCaller(show bool) *Logger {
-	l.showCaller = show
-	return l
-}
-
+// getCaller retrieves the file and line number of the caller.
 func getCaller() string {
-	_, file, line, ok := runtime.Caller(3)
+	// Skip 3 stack frames: getCaller -> log -> [Debug|Info|...]
+	const depth = 3
+	_, file, line, ok := runtime.Caller(depth)
 	if !ok {
 		return "unknown:0"
 	}

logging/logger_bench_test.go

@@ -56,11 +56,6 @@ func Benchmark_NewLogger(b *testing.B) {
 		b.Run(tt.name, func(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				got := New()
-
-				if tt.triggers.ModFormat.Format != "" {
-					got = got.SetFormat(tt.triggers.ModFormat.Format)
-				}
-
 				if tt.triggers.ModLevel.Level != 0 {
 					got = got.SetMinLogLevel(tt.triggers.ModLevel.Level)
 				}

logging/logger_test.go

@@ -40,7 +40,7 @@ func (suite *LoggerTestSuite) Test_LogMessageString() {
 		Message: "test message",
 	}
 
-	assert.Equal("test message", msg.String())
+	assert.Equal("test message", msg.Message)
 }
 
 func callLoggerMethod(logger *Logger, methodName string, message *LogMessage) {
@@ -59,13 +59,13 @@ func (suite *LoggerTestSuite) Test_LogsLevelsPrint() {
 	logger := New().SetOutput(output)
 
 	tests := []struct {
+		pairs           map[string]any
 		name            string
 		method          string
+		message         string
 		loggerMinLevel  int
 		messageLogLevel int
-		message         string
-		pairs           map[string]any
-		wantOutput      bool // Whether we expect output to be written
+		wantOutput      bool
 	}{
 		{
 			name:            "Log: Debug, Level: Debug - no pairs",
@@ -125,7 +125,7 @@ func (suite *LoggerTestSuite) Test_LogsLevelsPrint() {
 
 			// Set logger's minimum log level
 			logger.SetMinLogLevel(tt.loggerMinLevel)
-			fmt.Println("Logger min log level:", LevelNames[logger.minLogLevel])
+			fmt.Println("Logger min log level:", levelNames[logger.minLogLevel])
 
 			// Call the logging method
 			callLoggerMethod(logger, tt.method, msg)
@@ -143,7 +143,7 @@ func (suite *LoggerTestSuite) Test_LogsLevelsPrint() {
 				if !containsLogMessage(logOutput, tt.message) {
 					t.Errorf("Expected log message %q, but got %q", tt.message, logOutput)
 				}
-				assert.Equal(LevelNames[tt.messageLogLevel], loggedMessage["level"])
+				assert.Equal(levelNames[tt.messageLogLevel], loggedMessage["level"])
 				if tt.pairs != nil {
 					for k, v := range tt.pairs {
 						assert.Equal(v, loggedMessage[k])
@@ -161,9 +161,9 @@ func containsLogMessage(logOutput, expectedMessage string) bool {
 }
 
 func (suite *LoggerTestSuite) Test_SetFormat() {
-	logger := New().SetFormat(time.RFC3339Nano)
+	logger := New().SetTimeFormat(time.RFC3339Nano)
 
-	assert.Equal(time.RFC3339Nano, logger.format)
+	assert.Equal(time.RFC3339Nano, logger.timeFormat)
 }
 
 func (suite *LoggerTestSuite) Test_SetMinLogLevel() {

main.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/gofiber/fiber/v2/middleware/proxy"
 	"github.com/gookit/goutil/envutil"
@@ -14,47 +15,54 @@ import (
 	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 )
 
-var cfg *config
-var once sync.Once
+var (
+	cfg  *config
+	once sync.Once
+)
 
-// function get value from the env where the value can be anything
+// getDetailsFromEnv retrieves the value from the environment or returns the default.
 func getDetailsFromEnv[T any](key string, defaultValue T) T {
 	var result any
-	if _, ok := os.LookupEnv("GMP_" + key); ok {
-		key = "GMP_" + key
+	envKey := "GMP_" + key
+	if _, ok := os.LookupEnv(envKey); !ok {
+		envKey = key
 	}
 	switch v := any(defaultValue).(type) {
 	case string:
-		result = envutil.Getenv(key, v)
+		result = envutil.Getenv(envKey, v)
 	case int:
-		result = envutil.GetInt(key, v)
+		result = envutil.GetInt(envKey, v)
 	case bool:
-		result = envutil.GetBool(key, v)
+		result = envutil.GetBool(envKey, v)
 	default:
 		result = defaultValue
 	}
 	return result.(T)
 }
 
+// parseConfig loads and parses the configuration.
 func parseConfig() {
 	libpack_config.PKG_NAME = "graphql_proxy"
 	c := config{}
+	// Server configurations
 	c.Server.PortGraphQL = getDetailsFromEnv("PORT_GRAPHQL", 8080)
 	c.Server.PortMonitoring = getDetailsFromEnv("MONITORING_PORT", 9393)
 	c.Server.HostGraphQL = getDetailsFromEnv("HOST_GRAPHQL", "http://localhost/")
 	c.Server.HostGraphQLReadOnly = getDetailsFromEnv("HOST_GRAPHQL_READONLY", "")
+	// Client configurations
 	c.Client.JWTUserClaimPath = getDetailsFromEnv("JWT_USER_CLAIM_PATH", "")
 	c.Client.JWTRoleClaimPath = getDetailsFromEnv("JWT_ROLE_CLAIM_PATH", "")
 	c.Client.RoleFromHeader = getDetailsFromEnv("ROLE_FROM_HEADER", "")
 	c.Client.RoleRateLimit = getDetailsFromEnv("ROLE_RATE_LIMIT", false)
-	/* in-memory cache */
+	// In-memory cache
 	c.Cache.CacheEnable = getDetailsFromEnv("ENABLE_GLOBAL_CACHE", false)
 	c.Cache.CacheTTL = getDetailsFromEnv("CACHE_TTL", 60)
-	/* redis cache */
+	// Redis cache
 	c.Cache.CacheRedisEnable = getDetailsFromEnv("ENABLE_REDIS_CACHE", false)
 	c.Cache.CacheRedisURL = getDetailsFromEnv("CACHE_REDIS_URL", "localhost:6379")
 	c.Cache.CacheRedisPassword = getDetailsFromEnv("CACHE_REDIS_PASSWORD", "")
 	c.Cache.CacheRedisDB = getDetailsFromEnv("CACHE_REDIS_DB", 0)
+	// Security configurations
 	c.Security.BlockIntrospection = getDetailsFromEnv("BLOCK_SCHEMA_INTROSPECTION", false)
 	c.Security.IntrospectionAllowed = func() []string {
 		urls := getDetailsFromEnv("ALLOWED_INTROSPECTION", "")
@@ -64,10 +72,14 @@ func parseConfig() {
 		return strings.Split(urls, ",")
 	}()
 	c.LogLevel = strings.ToUpper(getDetailsFromEnv("LOG_LEVEL", "info"))
-	c.Logger = libpack_logging.New().SetMinLogLevel(libpack_logging.GetLogLevel(c.LogLevel)).SetFieldName("timestamp", "ts").SetFieldName("message", "msg").SetShowCaller(false)
+	// Logger setup
+	c.Logger = libpack_logging.New().SetMinLogLevel(libpack_logging.GetLogLevel(c.LogLevel)).
+		SetFieldName("timestamp", "ts").SetFieldName("message", "msg").SetShowCaller(false)
+	// Health check
 	c.Server.HealthcheckGraphQL = getDetailsFromEnv("HEALTHCHECK_GRAPHQL_URL", "")
 	c.Client.GQLClient = graphql.NewConnection()
 	c.Client.GQLClient.SetEndpoint(c.Server.HealthcheckGraphQL)
+	// Server modes
 	c.Server.AccessLog = getDetailsFromEnv("ENABLE_ACCESS_LOG", false)
 	c.Server.ReadOnlyMode = getDetailsFromEnv("READ_ONLY_MODE", false)
 	c.Server.AllowURLs = func() []string {
@@ -79,22 +91,26 @@ func parseConfig() {
 	}()
 	c.Client.ClientTimeout = getDetailsFromEnv("PROXIED_CLIENT_TIMEOUT", 120)
 	c.Client.FastProxyClient = createFasthttpClient(c.Client.ClientTimeout)
-	proxy.WithClient(c.Client.FastProxyClient) // setting the global proxy client here instead of per request
+	proxy.WithClient(c.Client.FastProxyClient) // Setting the global proxy client
+	// API configurations
 	c.Server.EnableApi = getDetailsFromEnv("ENABLE_API", false)
 	c.Server.ApiPort = getDetailsFromEnv("API_PORT", 9090)
 	c.Api.BannedUsersFile = getDetailsFromEnv("BANNED_USERS_FILE", "/go/src/app/banned_users.json")
 	c.Server.PurgeOnCrawl = getDetailsFromEnv("PURGE_METRICS_ON_CRAWL", false)
 	c.Server.PurgeEvery = getDetailsFromEnv("PURGE_METRICS_ON_TIMER", 0)
+	// Hasura event cleaner
 	c.HasuraEventCleaner.Enable = getDetailsFromEnv("HASURA_EVENT_CLEANER", false)
 	c.HasuraEventCleaner.ClearOlderThan = getDetailsFromEnv("HASURA_EVENT_CLEANER_OLDER_THAN", 1)
 	c.HasuraEventCleaner.EventMetadataDb = getDetailsFromEnv("HASURA_EVENT_METADATA_DB", "")
 	cfg = &c
 
+	// Initialize cache if enabled
 	if cfg.Cache.CacheEnable || cfg.Cache.CacheRedisEnable {
 		cacheConfig := &libpack_cache.CacheConfig{
 			Logger: cfg.Logger,
 			TTL:    cfg.Cache.CacheTTL,
 		}
+		// Redis cache configurations
 		if cfg.Cache.CacheRedisEnable {
 			cacheConfig.Redis.Enable = true
 			cacheConfig.Redis.URL = cfg.Cache.CacheRedisURL
@@ -103,6 +119,7 @@ func parseConfig() {
 		}
 		libpack_cache.EnableCache(cacheConfig)
 	}
+
 	loadRatelimitConfig()
 	once.Do(func() {
 		go enableApi()
@@ -114,9 +131,11 @@ func parseConfig() {
 func main() {
 	parseConfig()
 	StartMonitoringServer()
+	time.Sleep(5 * time.Second)
 	StartHTTPProxy()
 }
 
+// ifNotInTest checks if the program is not running in a test environment.
 func ifNotInTest() bool {
 	return flag.Lookup("test.v") == nil
 }

main_test.go

@@ -112,3 +112,29 @@ func (suite *Tests) Test_envVariableSetting() {
 		})
 	}
 }
+
+func (suite *Tests) Test_getDetailsFromEnv() {
+	tests := []struct {
+		name         string
+		key          string
+		defaultValue interface{}
+		envValue     string
+		expected     interface{}
+	}{
+		{"string value", "TEST_STRING", "default", "envValue", "envValue"},
+		{"int value", "TEST_INT", 0, "123", 123},
+		{"bool value", "TEST_BOOL", false, "true", true},
+		{"default value", "NON_EXISTENT", "default", "", "default"},
+	}
+
+	for _, tt := range tests {
+		suite.Run(tt.name, func() {
+			if tt.envValue != "" {
+				os.Setenv("GMP_"+tt.key, tt.envValue)
+				defer os.Unsetenv("GMP_" + tt.key)
+			}
+			result := getDetailsFromEnv(tt.key, tt.defaultValue)
+			assert.Equal(tt.expected, result)
+		})
+	}
+}

monitoring.go

@@ -4,8 +4,12 @@ import (
 	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
 )
 
+// StartMonitoringServer initializes and starts the monitoring server.
 func StartMonitoringServer() {
-	cfg.Monitoring = libpack_monitoring.NewMonitoring(&libpack_monitoring.InitConfig{PurgeOnCrawl: cfg.Server.PurgeOnCrawl, PurgeEvery: cfg.Server.PurgeEvery})
+	cfg.Monitoring = libpack_monitoring.NewMonitoring(&libpack_monitoring.InitConfig{
+		PurgeOnCrawl: cfg.Server.PurgeOnCrawl,
+		PurgeEvery:   cfg.Server.PurgeEvery,
+	})
 	cfg.Monitoring.AddMetricsPrefix("graphql_proxy")
 	cfg.Monitoring.RegisterDefaultMetrics()
 }

monitoring/helpers.go

@@ -12,17 +12,14 @@ import (
 	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
 )
 
-// Cache for sorted label keys to avoid repeated sorting
 var sortedLabelKeysCache = struct {
-	sync.RWMutex
-	m map[string][]string
-}{m: make(map[string][]string)}
+	m sync.Map
+}{}
 
 func (ms *MetricsSetup) get_metrics_name(name string, labels map[string]string) string {
 	const unknownPodName = "unknown"
 	var buf bytes.Buffer
 
-	// Prepare default labels without initializing a new map
 	podName := getPodName()
 	if labels == nil {
 		labels = defaultLabels(podName)
@@ -30,18 +27,16 @@ func (ms *MetricsSetup) get_metrics_name(name string, labels map[string]string)
 		ensureDefaultLabels(&labels, podName)
 	}
 
-	// Prefix handling
 	if ms.metrics_prefix != "" {
 		buf.WriteString(ms.metrics_prefix)
-		buf.WriteString("_")
+		buf.WriteByte('_')
 	}
 	buf.WriteString(name)
 
-	// Append labels if any
 	if len(labels) > 0 {
-		buf.WriteString("{")
+		buf.WriteByte('{')
 		appendSortedLabels(&buf, labels)
-		buf.WriteString("}")
+		buf.WriteByte('}')
 	}
 
 	return buf.String()
@@ -78,64 +73,64 @@ func appendSortedLabels(buf *bytes.Buffer, labels map[string]string) {
 	keys := getSortedKeys(labels)
 	for i, k := range keys {
 		if i > 0 {
-			buf.WriteString(",")
+			buf.WriteByte(',')
 		}
 		buf.WriteString(k)
-		buf.WriteString("=\"")
+		buf.WriteString(`="`)
 		buf.WriteString(labels[k])
-		buf.WriteString("\"")
+		buf.WriteByte('"')
 	}
 }
 
 func getSortedKeys(labels map[string]string) []string {
 	labelsKey := labelsToString(labels)
 
-	sortedLabelKeysCache.RLock()
-	keys, exists := sortedLabelKeysCache.m[labelsKey]
-	sortedLabelKeysCache.RUnlock()
-
-	if !exists {
-		keys = make([]string, 0, len(labels))
-		for k := range labels {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-
-		sortedLabelKeysCache.Lock()
-		sortedLabelKeysCache.m[labelsKey] = keys
-		sortedLabelKeysCache.Unlock()
+	// Check if the sorted keys are already cached
+	if keys, ok := sortedLabelKeysCache.m.Load(labelsKey); ok {
+		return keys.([]string)
 	}
 
+	// Compute the sorted keys
+	keys := make([]string, 0, len(labels))
+	for k := range labels {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	// Store the sorted keys in the cache
+	sortedLabelKeysCache.m.Store(labelsKey, keys)
+
 	return keys
 }
 
 func labelsToString(labels map[string]string) string {
+	keys := make([]string, 0, len(labels))
+	for k := range labels {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
 	var sb strings.Builder
-	for k, v := range labels {
+	for _, k := range keys {
 		sb.WriteString(k)
-		sb.WriteString("=")
-		sb.WriteString(v)
-		sb.WriteString(";")
+		sb.WriteByte('=')
+		sb.WriteString(labels[k])
+		sb.WriteByte(';')
 	}
 	return sb.String()
 }
 
-// validate_metrics_name validates the name of the metric to adhere to the Prometheus naming conventions
-// https://prometheus.io/docs/practices/naming/
 func validate_metrics_name(name string) error {
 	cleanedName := clean_metric_name(name)
 
-	// Trim leading and trailing underscores
 	finalName := strings.Trim(cleanedName, "_")
 
-	// Check if the processed name matches the original input
 	if finalName != name {
-		return fmt.Errorf("Invalid metric name: %s, expected %s", name, finalName)
+		return fmt.Errorf("invalid metric name: %s, expected %s", name, finalName)
 	}
 	return nil
 }
 
-// clean_metric_name processes the metric name according to Prometheus naming conventions
 func clean_metric_name(name string) string {
 	var buf bytes.Buffer
 	lastWasUnderscore := false
@@ -144,31 +139,27 @@ func clean_metric_name(name string) string {
 		if is_allowed_rune(r) {
 			if is_special_rune(r) {
 				if lastWasUnderscore {
-					continue // Skip if the previous character was also an underscore
+					continue
 				}
-				r = '_' // Convert spaces and special characters to underscores
+				r = '_'
 				lastWasUnderscore = true
 			} else {
 				lastWasUnderscore = false
 			}
 			buf.WriteRune(r)
 		} else if !lastWasUnderscore {
-			buf.WriteRune('_')
+			buf.WriteByte('_')
 			lastWasUnderscore = true
 		}
 	}
 
-	// Remove trailing underscore
-	result := buf.String()
-	return strings.Trim(result, "_")
+	return strings.Trim(buf.String(), "_")
 }
 
-// is_allowed_rune checks if the rune is allowed in the metric name
 func is_allowed_rune(r rune) bool {
 	return unicode.IsLetter(r) || unicode.IsDigit(r) || r == ' ' || r == '_'
 }
 
-// is_special_rune checks if the rune is a space or an underscore
 func is_special_rune(r rune) bool {
 	return r == ' ' || r == '_'
 }
@@ -178,14 +169,12 @@ func compile_metrics_with_labels(name string, labels map[string]string) string {
 
 	buf.WriteString(name)
 
-	// Collect keys and sort them
 	keys := getSortedKeys(labels)
 
-	// Append sorted key-value pairs to the buffer
 	for _, k := range keys {
-		buf.WriteString("_")
+		buf.WriteByte('_')
 		buf.WriteString(k)
-		buf.WriteString("_")
+		buf.WriteByte('_')
 		buf.WriteString(labels[k])
 	}
 

monitoring/helpers_test.go

@@ -167,9 +167,9 @@ func TestEnsureDefaultLabels(t *testing.T) {
 	libpack_config.PKG_NAME = "example_microservice"
 
 	tests := []struct {
-		name           string
 		inputLabels    map[string]string
 		expectedLabels map[string]string
+		name           string
 	}{
 		{
 			name:           "Nil labels",

monitoring/monitoring.go

@@ -1,6 +1,3 @@
-// Package `libpack_monitoring` provides and easy way to add prometheus metrics to your application.
-// It also provides a way to add custom metrics to the already started prometheus registry.
-
 package libpack_monitoring
 
 import (
@@ -22,9 +19,7 @@ type MetricsSetup struct {
 	metrics_prefix     string
 }
 
-var (
-	log *libpack_logger.Logger
-)
+var log = libpack_logger.New().SetMinLogLevel(libpack_logger.LEVEL_INFO)
 
 type InitConfig struct {
 	PurgeOnCrawl bool
@@ -32,11 +27,11 @@ type InitConfig struct {
 }
 
 func NewMonitoring(ic *InitConfig) *MetricsSetup {
-	log = libpack_logger.New().SetMinLogLevel(libpack_logger.LEVEL_INFO)
-	ms := &MetricsSetup{ic: ic}
-	ms.metrics_set = metrics.NewSet()
-	ms.metrics_set_custom = metrics.NewSet()
-	// if not testing, start the prometheus endpoint
+	ms := &MetricsSetup{
+		ic:                 ic,
+		metrics_set:        metrics.NewSet(),
+		metrics_set_custom: metrics.NewSet(),
+	}
 
 	if flag.Lookup("test.v") == nil {
 		go ms.startPrometheusEndpoint()
@@ -60,9 +55,11 @@ func (ms *MetricsSetup) startPrometheusEndpoint() {
 		AppName:               fmt.Sprintf("GraphQL Monitoring Proxy - %s v%s", libpack_config.PKG_NAME, libpack_config.PKG_VERSION),
 	})
 	app.Get("/metrics", ms.metricsEndpoint)
-	err := app.Listen(fmt.Sprintf(":%d", envutil.GetInt("MONITORING_PORT", 9393)))
-	if err != nil {
-		fmt.Println("Can't start the service: ", err)
+	if err := app.Listen(fmt.Sprintf(":%d", envutil.GetInt("MONITORING_PORT", 9393))); err != nil {
+		log.Critical(&libpack_logger.LogMessage{
+			Message: "Can't start the service",
+			Pairs:   map[string]interface{}{"error": err},
+		})
 	}
 }
 
@@ -85,7 +82,7 @@ func (ms *MetricsSetup) ListActiveMetrics() []string {
 }
 
 func (ms *MetricsSetup) RegisterMetricsGauge(metric_name string, labels map[string]string, val float64) *metrics.Gauge {
-	if validate_metrics_name(metric_name) != nil {
+	if err := validate_metrics_name(metric_name); err != nil {
 		log.Critical(&libpack_logger.LogMessage{
 			Message: "RegisterMetricsGauge() error",
 			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
@@ -93,13 +90,12 @@ func (ms *MetricsSetup) RegisterMetricsGauge(metric_name string, labels map[stri
 		return nil
 	}
 	return ms.metrics_set_custom.GetOrCreateGauge(ms.get_metrics_name(metric_name, labels), func() float64 {
-		// get current value of the gauge and add val to it
 		return val
 	})
 }
 
 func (ms *MetricsSetup) RegisterMetricsCounter(metric_name string, labels map[string]string) *metrics.Counter {
-	if validate_metrics_name(metric_name) != nil {
+	if err := validate_metrics_name(metric_name); err != nil {
 		log.Critical(&libpack_logger.LogMessage{
 			Message: "RegisterMetricsCounter() error",
 			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
@@ -113,7 +109,7 @@ func (ms *MetricsSetup) RegisterMetricsCounter(metric_name string, labels map[st
 }
 
 func (ms *MetricsSetup) RegisterFloatCounter(metric_name string, labels map[string]string) *metrics.FloatCounter {
-	if validate_metrics_name(metric_name) != nil {
+	if err := validate_metrics_name(metric_name); err != nil {
 		log.Critical(&libpack_logger.LogMessage{
 			Message: "RegisterFloatCounter() error",
 			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
@@ -124,7 +120,7 @@ func (ms *MetricsSetup) RegisterFloatCounter(metric_name string, labels map[stri
 }
 
 func (ms *MetricsSetup) RegisterMetricsSummary(metric_name string, labels map[string]string) *metrics.Summary {
-	if validate_metrics_name(metric_name) != nil {
+	if err := validate_metrics_name(metric_name); err != nil {
 		log.Critical(&libpack_logger.LogMessage{
 			Message: "RegisterMetricsSummary() error",
 			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
@@ -135,7 +131,7 @@ func (ms *MetricsSetup) RegisterMetricsSummary(metric_name string, labels map[st
 }
 
 func (ms *MetricsSetup) RegisterMetricsHistogram(metric_name string, labels map[string]string) *metrics.Histogram {
-	if validate_metrics_name(metric_name) != nil {
+	if err := validate_metrics_name(metric_name); err != nil {
 		log.Critical(&libpack_logger.LogMessage{
 			Message: "RegisterMetricsHistogram() error",
 			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},

proxy.go

@@ -1,18 +1,23 @@
 package main
 
 import (
+	"bytes"
+	"compress/gzip"
 	"crypto/tls"
 	"fmt"
+	"io"
+	"net/url"
 	"time"
 
 	"github.com/avast/retry-go/v4"
-	fiber "github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v2"
 	"github.com/gofiber/fiber/v2/middleware/proxy"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
 	"github.com/valyala/fasthttp"
 )
 
+// createFasthttpClient creates and configures a fasthttp client.
 func createFasthttpClient(timeout int) *fasthttp.Client {
 	return &fasthttp.Client{
 		Name:                     "graphql_proxy",
@@ -21,14 +26,15 @@ func createFasthttpClient(timeout int) *fasthttp.Client {
 			InsecureSkipVerify: true,
 		},
 		MaxConnsPerHost:               2048,
-		ReadTimeout:                   time.Second * time.Duration(timeout),
-		WriteTimeout:                  time.Second * time.Duration(timeout),
-		MaxIdleConnDuration:           time.Second * time.Duration(timeout),
-		MaxConnDuration:               time.Second * time.Duration(timeout),
+		ReadTimeout:                   time.Duration(timeout) * time.Second,
+		WriteTimeout:                  time.Duration(timeout) * time.Second,
+		MaxIdleConnDuration:           time.Duration(timeout) * time.Second,
+		MaxConnDuration:               time.Duration(timeout) * time.Second,
 		DisableHeaderNamesNormalizing: true,
 	}
 }
 
+// proxyTheRequest handles the request proxying logic.
 func proxyTheRequest(c *fiber.Ctx, currentEndpoint string) error {
 	if !checkAllowedURLs(c) {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
@@ -38,90 +44,121 @@ func proxyTheRequest(c *fiber.Ctx, currentEndpoint string) error {
 		if ifNotInTest() {
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
 		}
-		c.Status(403).SendString("Request blocked - not allowed URL")
-		return nil
-	}
-	c.Request().Header.DisableNormalizing()
-	c.Request().Header.Add("X-Real-IP", c.IP())
-	c.Request().Header.Add(fiber.HeaderXForwardedFor, string(c.Request().Header.Peek("X-Forwarded-For")))
-	c.Request().Header.Del(fiber.HeaderAcceptEncoding)
-
-	// added dummy check for the log level because it executes additional functions which could
-	// potentially slow down the execution.
-	if cfg.LogLevel == "debug" {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Proxying the request",
-			Pairs: map[string]interface{}{
-				"path":         c.Path(),
-				"body":         string(c.Request().Body()),
-				"headers":      c.GetReqHeaders(),
-				"request_uuid": c.Locals("request_uuid"),
-			},
-		})
+		return fmt.Errorf("request blocked - not allowed URL: %s", c.Path())
 	}
 
-	err := retry.Do(
+	proxyURL := currentEndpoint + c.Path()
+	_, err := url.Parse(proxyURL)
+	if err != nil {
+		return fmt.Errorf("invalid URL: %v", err)
+	}
+
+	if cfg.LogLevel == "DEBUG" {
+		logDebugRequest(c)
+	}
+
+	err = retry.Do(
 		func() error {
-			errInt := proxy.DoRedirects(c, currentEndpoint+c.Path(), 3, cfg.Client.FastProxyClient)
-			if errInt != nil {
-				cfg.Logger.Error(&libpack_logger.LogMessage{
-					Message: "Can't proxy the request",
-					Pairs: map[string]interface{}{
-						"error": errInt.Error(),
-					},
-				})
-				if ifNotInTest() {
-					cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-				}
-				return errInt
+			proxyErr := proxy.DoRedirects(c, proxyURL, 3, cfg.Client.FastProxyClient)
+			if proxyErr != nil {
+				return proxyErr
+			}
+			if c.Response().StatusCode() != fiber.StatusOK {
+				return fmt.Errorf("received non-200 response from the GraphQL server: %d", c.Response().StatusCode())
 			}
 			return nil
 		},
+		retry.Attempts(5),
+		retry.DelayType(retry.BackOffDelay),
+		retry.Delay(250*time.Millisecond),
+		retry.MaxDelay(5*time.Second),
 		retry.OnRetry(func(n uint, err error) {
 			cfg.Logger.Warning(&libpack_logger.LogMessage{
 				Message: "Retrying the request",
 				Pairs: map[string]interface{}{
-					"path":  c.Path(),
-					"error": err.Error(),
+					"path":    c.Path(),
+					"attempt": n + 1,
+					"error":   err.Error(),
 				},
 			})
 		}),
-		retry.Attempts(uint(3)),
-		retry.DelayType(retry.BackOffDelay),
-		retry.Delay(time.Duration(250*time.Millisecond)),
 		retry.LastErrorOnly(true),
 	)
 
 	if err != nil {
 		cfg.Logger.Warning(&libpack_logger.LogMessage{
 			Message: "Can't proxy the request",
-			Pairs: map[string]interface{}{
-				"error": err.Error(),
-			},
+			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return err
-	}
-
-	if cfg.LogLevel == "debug" {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Received proxied response",
-			Pairs: map[string]interface{}{
-				"path":          c.Path(),
-				"response_body": string(c.Response().Body()),
-				"response_code": c.Response().StatusCode(),
-				"headers":       c.GetRespHeaders(),
-				"request_uuid":  c.Locals("request_uuid"),
-			},
-		})
-	}
-
-	if c.Response().StatusCode() != 200 {
 		if ifNotInTest() {
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
 		}
-		return fmt.Errorf("Received non-200 response from the GraphQL server: %d", c.Response().StatusCode())
+		return fmt.Errorf("failed to proxy request: %v", err)
+	}
+
+	if cfg.LogLevel == "DEBUG" {
+		logDebugResponse(c)
+	}
+
+	if bytes.EqualFold(c.Response().Header.Peek("Content-Encoding"), []byte("gzip")) {
+		// Decompress gzip response
+		reader, err := gzip.NewReader(bytes.NewReader(c.Response().Body()))
+		if err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Failed to create gzip reader",
+				Pairs:   map[string]interface{}{"error": err.Error()},
+			})
+			return err
+		}
+		defer reader.Close()
+
+		decompressed, err := io.ReadAll(reader)
+		if err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Failed to decompress response",
+				Pairs:   map[string]interface{}{"error": err.Error()},
+			})
+			return err
+		}
+
+		c.Response().SetBody(decompressed)
+		c.Response().Header.Del("Content-Encoding")
+	}
+
+	if c.Response().StatusCode() != fiber.StatusOK {
+		if ifNotInTest() {
+			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
+		}
+		return fmt.Errorf("received non-200 response from the GraphQL server: %d", c.Response().StatusCode())
 	}
 
 	c.Response().Header.Del(fiber.HeaderServer)
 	return nil
 }
+
+// logDebugRequest logs the request details when in debug mode.
+func logDebugRequest(c *fiber.Ctx) {
+	cfg.Logger.Debug(&libpack_logger.LogMessage{
+		Message: "Proxying the request",
+		Pairs: map[string]interface{}{
+			"path":         c.Path(),
+			"body":         string(c.Body()),
+			"headers":      c.GetReqHeaders(),
+			"request_uuid": c.Locals("request_uuid"),
+		},
+	})
+}
+
+// logDebugResponse logs the response details when in debug mode.
+func logDebugResponse(c *fiber.Ctx) {
+	cfg.Logger.Debug(&libpack_logger.LogMessage{
+		Message: "Received proxied response",
+		Pairs: map[string]interface{}{
+			"path":          c.Path(),
+			"response_body": string(c.Response().Body()),
+			"response_code": c.Response().StatusCode(),
+			"headers":       c.GetRespHeaders(),
+			"request_uuid":  c.Locals("request_uuid"),
+		},
+	})
+}

proxy_test.go

@@ -1,6 +1,10 @@
 package main
 
 import (
+	"net/http"
+	"net/http/httptest"
+	"time"
+
 	"github.com/valyala/fasthttp"
 )
 
@@ -12,47 +16,63 @@ func (suite *Tests) Test_proxyTheRequest() {
 	}
 
 	tests := []struct {
-		headers map[string]string
-		name    string
-		body    string
-		host    string
-		hostRO  string
-		path    string
-		wantErr bool
+		headers      map[string]string
+		name         string
+		body         string
+		host         string
+		hostRO       string
+		path         string
+		wantErr      bool
+		wantEndpoint string
 	}{
 		{
-			name:    "test_empty",
-			body:    `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
-			host:    "https://telegram-bot.app/",
-			path:    "/v1/graphql",
-			headers: supplied_headers,
-			wantErr: false,
+			name:         "test_empty",
+			body:         `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
+			host:         "https://telegram-bot.app/",
+			path:         "/v1/graphql",
+			headers:      supplied_headers,
+			wantErr:      false,
+			wantEndpoint: "https://telegram-bot.app/",
 		},
 		{
-			name:    "test_wrong_url",
-			body:    `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
-			host:    "https://google.com/",
-			path:    "/v1/wrongURL",
-			headers: supplied_headers,
-			wantErr: true,
+			name:         "test_wrong_url",
+			body:         `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
+			host:         "https://google.com/",
+			path:         "/v1/wrongURL",
+			headers:      supplied_headers,
+			wantErr:      true,
+			wantEndpoint: "https://google.com/",
 		},
 		{
-			name:    "Test read only mode",
-			body:    `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
-			host:    "https://google.com/",
-			hostRO:  "https://telegram-bot.app/",
-			path:    "/v1/graphql",
-			headers: supplied_headers,
-			wantErr: false,
+			name:         "Test read only mode",
+			body:         `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
+			host:         "https://google.com/",
+			hostRO:       "https://telegram-bot.app/",
+			path:         "/v1/graphql",
+			headers:      supplied_headers,
+			wantErr:      false,
+			wantEndpoint: "https://telegram-bot.app/",
 		},
 		{
-			name:    "Test read only mode wrong host",
-			body:    `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
-			host:    "https://telegram-bot.app/",
-			hostRO:  "https://google.com/",
-			path:    "/v1/graphql",
-			headers: supplied_headers,
-			wantErr: true,
+			name:   "Test read only mode wrong host",
+			body:   `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
+			host:   "https://telegram-bot.app/",
+			hostRO: "https://google.com/",
+
+			path:         "/v1/graphql",
+			headers:      supplied_headers,
+			wantErr:      true,
+			wantEndpoint: "https://google.com/",
+		},
+		{
+			name:         "Test mutation with endpoint flip",
+			body:         `{"query":"mutation {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
+			host:         "https://telegram-bot.app/",
+			hostRO:       "https://google.com/",
+			path:         "/v1/graphql",
+			headers:      supplied_headers,
+			wantErr:      false,
+			wantEndpoint: "https://telegram-bot.app/",
 		},
 	}
 
@@ -92,6 +112,126 @@ func (suite *Tests) Test_proxyTheRequest() {
 			} else {
 				assert.Nil(err, "Error is not nil", tt.name)
 			}
+			assert.Equal(tt.wantEndpoint, res.activeEndpoint, "Unexpected endpoint", tt.name)
+		})
+	}
+}
+
+func (suite *Tests) Test_proxyTheRequestWithPayloads() {
+
+	tests := []struct {
+		name    string
+		payload string
+		url     string
+		wantErr bool
+	}{
+		{
+			name:    "Test with invalid URL",
+			payload: `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
+			url:     "://invalid-url",
+			wantErr: true,
+		},
+		{
+			name:    "Test with network error",
+			payload: `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
+			url:     "http://non-existent-host.invalid",
+			wantErr: true,
+		},
+		// {
+		// 	name:    "Test with large payload",
+		// 	payload: strings.Repeat("a", 10*1024*1024), // 10MB payload
+		// 	url:     "https://google.com/",
+		// 	wantErr: false,
+		// },
+	}
+
+	for _, tt := range tests {
+		suite.Run(tt.name, func() {
+			cfg.Server.HostGraphQL = tt.url
+			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{})
+			err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
+			if tt.wantErr {
+				assert.NotNil(err)
+			} else {
+				assert.Nil(err)
+			}
+		})
+	}
+}
+
+func (suite *Tests) Test_proxyTheRequestWithTimeouts() {
+	originalTimeout := cfg.Client.ClientTimeout
+	defer func() {
+		cfg.Client.ClientTimeout = originalTimeout
+		cfg.Client.FastProxyClient = createFasthttpClient(cfg.Client.ClientTimeout)
+	}()
+
+	// Create a mock server
+	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		sleepDuration, _ := time.ParseDuration(r.Header.Get("X-Sleep-Duration"))
+		time.Sleep(sleepDuration)
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(`{"data":{"test":"response"}}`))
+	}))
+	defer mockServer.Close()
+
+	tests := []struct {
+		name          string
+		clientTimeout int
+		sleepDuration string
+		body          string
+		wantErr       bool
+	}{
+		{
+			name:          "Short timeout, long wait for response",
+			clientTimeout: 1,
+			sleepDuration: "2s",
+			body:          `{"query":"query { test }"}`,
+			wantErr:       true,
+		},
+		{
+			name:          "Short timeout, short wait for response",
+			clientTimeout: 2,
+			sleepDuration: "500ms",
+			body:          `{"query":"query { test }"}`,
+			wantErr:       false,
+		},
+		{
+			name:          "Long timeout, short wait for response",
+			clientTimeout: 10,
+			sleepDuration: "1s",
+			body:          `{"query":"query { test }"}`,
+			wantErr:       false,
+		},
+	}
+
+	for _, tt := range tests {
+		suite.Run(tt.name, func() {
+			cfg.Client.ClientTimeout = tt.clientTimeout
+			cfg.Client.FastProxyClient = createFasthttpClient(cfg.Client.ClientTimeout)
+			cfg.Server.HostGraphQL = mockServer.URL
+
+			req := &fasthttp.Request{}
+			req.SetBody([]byte(tt.body))
+			req.SetRequestURI("/v1/graphql")
+			req.Header.SetMethod("POST")
+			req.Header.Set("Content-Type", "application/json")
+			req.Header.Set("X-Sleep-Duration", tt.sleepDuration)
+
+			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{})
+			ctx.Request().Header.SetMethod("POST")
+			ctx.Request().SetBody(req.Body())
+			ctx.Request().SetRequestURI(string(req.RequestURI())) // Convert []byte to string
+			ctx.Request().Header.SetContentType("application/json")
+			ctx.Request().Header.Set("X-Sleep-Duration", tt.sleepDuration)
+
+			err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
+
+			if tt.wantErr {
+				assert.NotNil(err, "Expected an error for test: %s", tt.name)
+			} else {
+				assert.Nil(err, "Expected no error for test: %s", tt.name)
+			}
 		})
 	}
 }

ratelimit.go

@@ -2,89 +2,82 @@ package main
 
 import (
 	"os"
+	"sync"
 	"time"
 
 	"github.com/goccy/go-json"
-
 	goratecounter "github.com/lukaszraczylo/go-ratecounter"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 )
 
+// RateLimitConfig holds the rate limit configuration for a role
 type RateLimitConfig struct {
 	RateCounterTicker *goratecounter.RateCounter
-	Interval          string `json:"interval"`
-	Req               int    `json:"req"`
+	Interval          time.Duration `json:"interval"`
+	Req               int           `json:"req"`
 }
 
-var rateLimits map[string]RateLimitConfig
-var ratelimit_intervals = map[string]time.Duration{
-	"milli":  time.Millisecond,
-	"micro":  time.Microsecond,
-	"nano":   time.Nanosecond,
-	"second": time.Second,
-	"minute": time.Minute,
-	"hour":   time.Hour,
-	"day":    time.Hour * 24,
-}
+var (
+	rateLimits  = make(map[string]RateLimitConfig)
+	rateLimitMu sync.RWMutex
+)
 
+// loadRatelimitConfig loads the rate limit configurations from file
 func loadRatelimitConfig() error {
 	paths := []string{"/go/src/app/ratelimit.json", "./ratelimit.json", "./static/app/default-ratelimit.json"}
-
 	for _, path := range paths {
-		err := loadConfigFromPath(path)
-		if err == nil {
+		if err := loadConfigFromPath(path); err == nil {
 			return nil
 		}
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Failed to load config",
-			Pairs:   map[string]interface{}{"path": path, "error": err},
-		})
 	}
-
 	cfg.Logger.Error(&libpack_logger.LogMessage{
 		Message: "Rate limit config not found",
 		Pairs:   map[string]interface{}{"paths": paths},
 	})
-
 	return os.ErrNotExist
 }
 
 func loadConfigFromPath(path string) error {
-	file, err := os.Open(path)
+	file, err := os.ReadFile(path)
 	if err != nil {
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Failed to load config",
+			Pairs:   map[string]interface{}{"path": path, "error": err},
+		})
 		return err
 	}
-	defer file.Close()
 
-	config := struct {
+	var config struct {
 		RateLimit map[string]RateLimitConfig `json:"ratelimit"`
-	}{}
+	}
 
-	decoder := json.NewDecoder(file)
-	if err := decoder.Decode(&config); err != nil {
+	if err := json.Unmarshal(file, &config); err != nil {
 		return err
 	}
 
+	newRateLimits := make(map[string]RateLimitConfig, len(config.RateLimit))
 	for key, value := range config.RateLimit {
 		value.RateCounterTicker = goratecounter.NewRateCounter().WithConfig(goratecounter.RateCounterConfig{
-			Interval: time.Duration(value.Req) * ratelimit_intervals[value.Interval],
+			Interval: value.Interval,
 		})
 
-		if cfg.LogLevel == "debug" {
+		if cfg.LogLevel == "DEBUG" {
 			cfg.Logger.Debug(&libpack_logger.LogMessage{
 				Message: "Setting ratelimit config for role",
 				Pairs: map[string]interface{}{
-					"role":              key,
-					"interval_provided": value.Interval,
-					"interval_used":     ratelimit_intervals[value.Interval],
-					"ratelimit":         value.Req,
+					"role":          key,
+					"interval_used": value.Interval,
+					"ratelimit":     value.Req,
 				},
 			})
 		}
-		config.RateLimit[key] = value
+		newRateLimits[key] = value
 	}
 
-	rateLimits = config.RateLimit
+	rateLimitMu.Lock()
+	rateLimits = newRateLimits
+	rateLimitMu.Unlock()
+
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Rate limit config loaded",
 		Pairs:   map[string]interface{}{"ratelimit": rateLimits},
@@ -92,28 +85,15 @@ func loadConfigFromPath(path string) error {
 	return nil
 }
 
-func rateLimitedRequest(userID string, userRole string) (shouldAllow bool) {
-	if rateLimits == nil {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Rate limit config not found",
-			Pairs:   map[string]interface{}{"user_role": userRole},
-		})
-		return true
-	}
-
-	// Fetch role config once to avoid multiple map lookups
+// rateLimitedRequest checks if a request should be rate-limited
+func rateLimitedRequest(userID, userRole string) bool {
+	rateLimitMu.RLock()
 	roleConfig, ok := rateLimits[userRole]
-	if !ok {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Rate limit role not found",
-			Pairs:   map[string]interface{}{"user_role": userRole},
-		})
-		return true
-	}
+	rateLimitMu.RUnlock()
 
-	if roleConfig.RateCounterTicker == nil {
+	if !ok || roleConfig.RateCounterTicker == nil {
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Rate limit ticker not found",
+			Message: "Rate limit role not found or ticker not initialized",
 			Pairs:   map[string]interface{}{"user_role": userRole},
 		})
 		return true

server.go

@@ -16,27 +16,32 @@ import (
 	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
 )
 
-// StartHTTPProxy starts the HTTP and points it to the GraphQL server.
+const (
+	healthCheckQueryStr = `{ __typename }`
+)
+
+// StartHTTPProxy initializes and starts the HTTP proxy server.
 func StartHTTPProxy() {
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Starting the HTTP proxy",
-		Pairs:   nil,
 	})
-	server := fiber.New(fiber.Config{
+
+	serverConfig := fiber.Config{
 		DisableStartupMessage: true,
 		AppName:               fmt.Sprintf("GraphQL Monitoring Proxy - %s v%s", libpack_config.PKG_NAME, libpack_config.PKG_VERSION),
-		IdleTimeout:           time.Duration(cfg.Client.ClientTimeout) * time.Second * 2,
-		ReadTimeout:           time.Duration(cfg.Client.ClientTimeout) * time.Second * 2,
-		WriteTimeout:          time.Duration(cfg.Client.ClientTimeout) * time.Second * 2,
+		IdleTimeout:           time.Duration(cfg.Client.ClientTimeout) * time.Second,
+		ReadTimeout:           time.Duration(cfg.Client.ClientTimeout) * time.Second,
+		WriteTimeout:          time.Duration(cfg.Client.ClientTimeout) * time.Second,
 		JSONEncoder:           json.Marshal,
 		JSONDecoder:           json.Unmarshal,
-	})
+	}
+
+	server := fiber.New(serverConfig)
 
 	server.Use(cors.New(cors.Config{
 		AllowOrigins: "*",
 	}))
 
-	// add middleware to check if the request is a GraphQL query
 	server.Use(AddRequestUUID)
 
 	server.Get("/healthz", healthCheck)
@@ -49,125 +54,109 @@ func StartHTTPProxy() {
 		Message: "GraphQL proxy started",
 		Pairs:   map[string]interface{}{"port": cfg.Server.PortGraphQL},
 	})
-	err := server.Listen(fmt.Sprintf(":%d", cfg.Server.PortGraphQL))
-	if err != nil {
+
+	if err := server.Listen(fmt.Sprintf(":%d", cfg.Server.PortGraphQL)); err != nil {
 		cfg.Logger.Critical(&libpack_logger.LogMessage{
 			Message: "Can't start the service",
-			Pairs:   map[string]interface{}{"port": cfg.Server.PortGraphQL},
+			Pairs:   map[string]interface{}{"port": cfg.Server.PortGraphQL, "error": err.Error()},
 		})
 	}
 }
 
+// proxyTheRequestToDefault proxies the request to the default GraphQL endpoint.
 func proxyTheRequestToDefault(c *fiber.Ctx) error {
 	return proxyTheRequest(c, cfg.Server.HostGraphQL)
 }
 
+// AddRequestUUID adds a unique request UUID to the context.
 func AddRequestUUID(c *fiber.Ctx) error {
 	c.Locals("request_uuid", uuid.NewString())
 	return c.Next()
 }
 
+// checkAllowedURLs checks if the requested URL is allowed.
 func checkAllowedURLs(c *fiber.Ctx) bool {
 	if len(allowedUrls) == 0 {
 		return true
 	}
-	_, ok := allowedUrls[c.Path()]
+	path := c.OriginalURL()
+	_, ok := allowedUrls[path]
 	return ok
 }
 
+// healthCheck performs a health check on the GraphQL server.
 func healthCheck(c *fiber.Ctx) error {
 	if len(cfg.Server.HealthcheckGraphQL) > 0 {
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
 			Message: "Health check enabled",
 			Pairs:   map[string]interface{}{"url": cfg.Server.HealthcheckGraphQL},
 		})
-		query := `{ __typename }`
-		_, err := cfg.Client.GQLClient.Query(query, nil, nil)
+
+		_, err := cfg.Client.GQLClient.Query(healthCheckQueryStr, nil, nil)
 		if err != nil {
 			cfg.Logger.Error(&libpack_logger.LogMessage{
 				Message: "Can't reach the GraphQL server",
 				Pairs:   map[string]interface{}{"error": err.Error()},
 			})
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-			c.Status(500).SendString("Can't reach the GraphQL server with {__typename} query")
-			return err
+			return c.Status(fiber.StatusInternalServerError).SendString("Can't reach the GraphQL server with {__typename} query")
 		}
 	}
+
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Health check returning OK",
-		Pairs:   nil,
 	})
-	c.Status(200).SendString("Health check OK")
-	return nil
+	return c.Status(fiber.StatusOK).SendString("Health check OK")
 }
 
+// processGraphQLRequest handles the incoming GraphQL requests.
 func processGraphQLRequest(c *fiber.Ctx) error {
 	startTime := time.Now()
 
-	// Initialize variables with default values
 	extractedUserID := "-"
 	extractedRoleName := "-"
-	var queryCacheHash string
 
-	authorization := c.Request().Header.Peek("Authorization")
-	if authorization != nil && (len(cfg.Client.JWTUserClaimPath) > 0 || len(cfg.Client.JWTRoleClaimPath) > 0) {
-		extractedUserID, extractedRoleName = extractClaimsFromJWTHeader(string(authorization))
+	if authorization := c.Get("Authorization"); authorization != "" && (len(cfg.Client.JWTUserClaimPath) > 0 || len(cfg.Client.JWTRoleClaimPath) > 0) {
+		extractedUserID, extractedRoleName = extractClaimsFromJWTHeader(authorization)
 	}
 
 	if checkIfUserIsBanned(c, extractedUserID) {
-		c.Status(403).SendString("User is banned")
-		return nil
+		return c.Status(fiber.StatusForbidden).SendString("User is banned")
 	}
 
-	if len(cfg.Client.RoleFromHeader) > 0 {
-		extractedRoleName = string(c.Request().Header.Peek(cfg.Client.RoleFromHeader))
-		if extractedRoleName == "" {
-			extractedRoleName = "-"
+	if cfg.Client.RoleFromHeader != "" {
+		if role := c.Get(cfg.Client.RoleFromHeader); role != "" {
+			extractedRoleName = role
 		}
 	}
 
-	// Implementing rate limiting if enabled
 	if cfg.Client.RoleRateLimit {
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
 			Message: "Rate limiting enabled",
 			Pairs:   map[string]interface{}{"user_id": extractedUserID, "role_name": extractedRoleName},
 		})
 		if !rateLimitedRequest(extractedUserID, extractedRoleName) {
-			c.Status(429).SendString("Rate limit exceeded, try again later")
-			return nil
+			return c.Status(fiber.StatusTooManyRequests).SendString("Rate limit exceeded, try again later")
 		}
 	}
 
-	parsedResult := parseGraphQLQuery(c)
+	parsedResult := parseGraphQLQuery(c) // Ensure this function is defined elsewhere
 	if parsedResult.shouldBlock {
-		c.Status(403).SendString("Request blocked")
-		return nil
+		return c.Status(fiber.StatusForbidden).SendString("Request blocked")
 	}
 
 	if parsedResult.shouldIgnore {
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
 			Message: "Request passed as-is - probably not a GraphQL",
-			Pairs:   nil,
 		})
 		return proxyTheRequest(c, parsedResult.activeEndpoint)
 	}
 
 	calculatedQueryHash := libpack_cache.CalculateHash(c)
 
-	if parsedResult.cacheTime > 0 {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Cache time set via query",
-			Pairs:   map[string]interface{}{"cacheTime": parsedResult.cacheTime},
-		})
-	} else {
-		// If not set via query, try setting via header
-		cacheQuery := c.Request().Header.Peek("X-Cache-Graphql-Query")
-		if cacheQuery != nil {
-			parsedResult.cacheTime, _ = strconv.Atoi(string(cacheQuery))
-			cfg.Logger.Debug(&libpack_logger.LogMessage{
-				Message: "Cache time set via header",
-				Pairs:   map[string]interface{}{"cacheTime": parsedResult.cacheTime},
-			})
+	if parsedResult.cacheTime == 0 {
+		if cacheQuery := c.Get("X-Cache-Graphql-Query"); cacheQuery != "" {
+			parsedResult.cacheTime, _ = strconv.Atoi(cacheQuery)
 		} else {
 			parsedResult.cacheTime = cfg.Cache.CacheTTL
 		}
@@ -183,82 +172,70 @@ func processGraphQLRequest(c *fiber.Ctx) error {
 		libpack_cache.CacheDelete(calculatedQueryHash)
 	}
 
-	// Handling Cache Logic
 	if parsedResult.cacheRequest || cfg.Cache.CacheEnable || cfg.Cache.CacheRedisEnable {
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
 			Message: "Cache enabled",
 			Pairs:   map[string]interface{}{"via_query": parsedResult.cacheRequest, "via_env": cfg.Cache.CacheEnable},
 		})
-		queryCacheHash = calculatedQueryHash
 
-		if cachedResponse := libpack_cache.CacheLookup(queryCacheHash); cachedResponse != nil {
+		if cachedResponse := libpack_cache.CacheLookup(calculatedQueryHash); cachedResponse != nil {
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheHit, nil)
 			cfg.Logger.Debug(&libpack_logger.LogMessage{
 				Message: "Cache hit",
-				Pairs:   map[string]interface{}{"hash": queryCacheHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")},
+				Pairs:   map[string]interface{}{"hash": calculatedQueryHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")},
 			})
-			c.Request().Header.Add("X-Cache-Hit", "true")
-			err := c.Send(cachedResponse)
-			if err != nil {
-				cfg.Logger.Error(&libpack_logger.LogMessage{
-					Message: "Can't send the cached response",
-					Pairs:   map[string]interface{}{"error": err.Error()},
-				})
-				cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-				c.Status(500).SendString("Can't send the cached response - try again later")
-			}
+			c.Set("X-Cache-Hit", "true")
 			wasCached = true
-		} else {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheMiss, nil)
-			cfg.Logger.Debug(&libpack_logger.LogMessage{
-				Message: "Cache miss",
-				Pairs:   map[string]interface{}{"hash": queryCacheHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")},
-			})
-			proxyAndCacheTheRequest(c, queryCacheHash, parsedResult.cacheTime, parsedResult.activeEndpoint)
+			c.Set("Content-Type", "application/json")
+			return c.Send(cachedResponse)
+		}
+
+		cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheMiss, nil)
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Cache miss",
+			Pairs:   map[string]interface{}{"hash": calculatedQueryHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")},
+		})
+		if err := proxyAndCacheTheRequest(c, calculatedQueryHash, parsedResult.cacheTime, parsedResult.activeEndpoint); err != nil {
+			return err
 		}
 	} else {
-		err := proxyTheRequest(c, parsedResult.activeEndpoint)
-		if err != nil {
+		if err := proxyTheRequest(c, parsedResult.activeEndpoint); err != nil {
 			cfg.Logger.Error(&libpack_logger.LogMessage{
 				Message: "Can't proxy the request",
 				Pairs:   map[string]interface{}{"error": err.Error()},
 			})
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-			c.Status(500).SendString("Can't proxy the request - try again later")
-			return nil
+			return c.Status(fiber.StatusInternalServerError).SendString("Can't proxy the request - try again later")
 		}
 	}
 
-	timeTaken := time.Since(startTime)
-
-	// Logging & Monitoring
-	logAndMonitorRequest(c, extractedUserID, parsedResult.operationType, parsedResult.operationName, wasCached, timeTaken, startTime)
+	logAndMonitorRequest(c, extractedUserID, parsedResult.operationType, parsedResult.operationName, wasCached, time.Since(startTime), startTime)
 
 	return nil
 }
 
-// Additional helper function to avoid code repetition
-func proxyAndCacheTheRequest(c *fiber.Ctx, queryCacheHash string, cacheTime int, currentEndpoint string) {
-	err := proxyTheRequest(c, currentEndpoint)
-	if err != nil {
+// proxyAndCacheTheRequest proxies and caches the request if needed.
+func proxyAndCacheTheRequest(c *fiber.Ctx, queryCacheHash string, cacheTime int, currentEndpoint string) error {
+	if err := proxyTheRequest(c, currentEndpoint); err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't proxy the request",
 			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
 		cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-		c.Status(500).SendString("Can't proxy the request - try again later")
-		return
+		return c.Status(fiber.StatusInternalServerError).SendString("Can't proxy the request - try again later")
 	}
+
 	libpack_cache.CacheStoreWithTTL(queryCacheHash, c.Response().Body(), time.Duration(cacheTime)*time.Second)
 	cfg.Monitoring.Increment(libpack_monitoring.MetricsQueriesCached, nil)
-	c.Send(c.Response().Body())
+	return c.Send(c.Response().Body())
 }
 
+// logAndMonitorRequest logs and monitors the request processing.
 func logAndMonitorRequest(c *fiber.Ctx, userID, opType, opName string, wasCached bool, duration time.Duration, startTime time.Time) {
 	labels := map[string]string{
 		"op_type": opType,
 		"op_name": opName,
-		"cached":  fmt.Sprintf("%t", wasCached),
+		"cached":  strconv.FormatBool(wasCached),
 		"user_id": userID,
 	}
 
@@ -267,7 +244,7 @@ func logAndMonitorRequest(c *fiber.Ctx, userID, opType, opName string, wasCached
 			Message: "Request processed",
 			Pairs: map[string]interface{}{
 				"ip":           c.IP(),
-				"fwd-ip":       string(c.Request().Header.Peek("X-Forwarded-For")),
+				"fwd-ip":       c.Get("X-Forwarded-For"),
 				"user_id":      userID,
 				"op_type":      opType,
 				"op_name":      opName,