fixup! fixup! fixup! fixup! fixup! Aligning struct fields for better memory management.

.github/workflows/autoupdate.yaml

@@ -1,4 +1,4 @@
-name: Autoupdate go.mod and go.sum
+name: Test and release
 
 on:
   workflow_dispatch:
@@ -34,16 +34,15 @@ 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
@@ -63,11 +62,12 @@ jobs:
       - 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
-        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"
+        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

.github/workflows/pr.yaml

@@ -15,12 +15,6 @@ 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.
@@ -84,26 +78,7 @@ 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,15 +10,6 @@ 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
@@ -27,46 +18,3 @@ 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,5 +1,3 @@
 graphql-proxy
 test.sh
-banned.json*
-dist/
-coverage.out
+banned.json*

CODEOWNERS

@@ -1,3 +0,0 @@
-### CODEOWNERS
-
-*    @lukaszraczylo @lukaszraczylo-dev

LICENSE

@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

Makefile

@@ -1,6 +1,4 @@
 CI_RUN?=false
-TIMESTAMP := $(shell date +%Y%m%d-%H%M%S)
-
 # ADDITIONAL_BUILD_FLAGS=""
 
 # ifeq ($(CI_RUN), true)
@@ -13,7 +11,7 @@ help:  ## display this help
 
 .PHONY: run
 run: build ## run application
-	@LOG_LEVEL=debug PURGE_METRICS_ON_CRAWL=true BLOCK_SCHEMA_INTROSPECTION=true CACHE_TTL=10 JWT_ROLE_RATE_LIMIT=false JWT_ROLE_CLAIM_PATH="Hasura.x-hasura-default-role" JWT_USER_CLAIM_PATH="Hasura.x-hasura-user-id" HOST_GRAPHQL=https://hasura8.lan/ HEALTHCHECK_GRAPHQL_URL=https://hasura8.lan/v1/graphql PORT_GRAPHQL=8111 ./graphql-proxy
+	@LOG_LEVEL=debug PURGE_METRICS_ON_CRAWL=true BLOCK_SCHEMA_INTROSPECTION=false CACHE_TTL=10 JWT_ROLE_RATE_LIMIT=false JWT_ROLE_CLAIM_PATH="Hasura.x-hasura-default-role" JWT_USER_CLAIM_PATH="Hasura.x-hasura-user-id" HOST_GRAPHQL=https://hasura8.lan/ HEALTHCHECK_GRAPHQL_URL=https://hasura8.lan/v1/graphql ./graphql-proxy
 
 .PHONY: build
 build: ## build the binary
@@ -34,25 +32,3 @@ 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,19 +2,17 @@
 
 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. [Benchmarks](https://lukaszraczylo.github.io/graphql-monitoring-proxy/dev/bench/) are available.
+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.
 
 ![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)
   - [Features](#features)
   - [Configuration](#configuration)
-  - [Tracing](#tracing)
   - [Speed](#speed)
     - [Caching](#caching)
     - [Read-only endpoint](#read-only-endpoint)
@@ -30,6 +28,7 @@ This project is in active use by [telegram-bot.app](https://telegram-bot.app), a
     - [Cache operations](#cache-operations)
   - [General](#general)
     - [Metrics which matter](#metrics-which-matter)
+    - [Tracing](#tracing)
     - [Healthcheck](#healthcheck)
     - [Monitoring endpoint](#monitoring-endpoint)
 
@@ -37,23 +36,13 @@ 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.25.12** - 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.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.
+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.
 
 <details>
   <summary>Click to show working Traefik Ingress Route example.</summary>
@@ -108,7 +97,6 @@ In this case, both proxy and websockets will be available under the `/v1/graphql
 | monitor    | Extracting user id from JWT token and adding it as a label to metrics |
 | monitor    | Extracting the query name and type and adding it as a label to metrics|
 | monitor    | Calculating the query duration and adding it to the metrics           |
-| monitor    | OpenTelemetry tracing support with configurable endpoint              |
 | speed      | Caching the queries, together with per-query cache and TTL            |
 | speed      | Support for READ ONLY graphql endpoint                                |
 | security   | Blocking schema introspection                                         |
@@ -116,7 +104,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 events cleaner                                                 |
+| maintenance | Hasura event cleaner                                                 |
 
 
 ### Configuration
@@ -157,26 +145,8 @@ You can still use the non-prefixed environment variables in the spirit of the ba
 | `HASURA_EVENT_CLEANER`   | Enable the hasura event cleaner          | `false`                    |
 | `HASURA_EVENT_CLEANER_OLDER_THAN` | The interval for the hasura event cleaner (in days) | `1`                  |
 | `HASURA_EVENT_METADATA_DB` | URL to the hasura metadata database    | `postgresql://localhost:5432/hasura` |
-| `ENABLE_TRACE`            | Enable OpenTelemetry tracing           | `false`                    |
-| `TRACE_ENDPOINT`          | OpenTelemetry collector endpoint       | `localhost:4317`           |
-
-### Tracing
-
-The proxy supports OpenTelemetry tracing to help monitor and debug requests. When enabled, it will create spans for each proxied request and send them to the configured OpenTelemetry collector.
-
-To use tracing:
-
-1. Enable tracing by setting `ENABLE_TRACE=true`
-2. Configure the OpenTelemetry collector endpoint using `TRACE_ENDPOINT` (defaults to `localhost:4317`)
-3. Include trace context in your requests using the `X-Trace-Span` header with the following format:
-
-```json
-{
-  "traceparent": "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"
-}
-```
-
-The proxy will extract the trace context from the header and create child spans for each request, allowing you to trace requests through your system.
+| `ENABLE_TRACE` | Enables tracing | `false` |
+| `TRACER_ENDPOINT` | Tracing endpoint | `localhost:4317` |
 
 ### Speed
 
@@ -326,6 +296,18 @@ With the `PURGE_METRICS_ON_CRAWL` enabled, the `graphql_proxy_requests_failed`,
 
 If you prefer more control over the metrics purging - you can enable `PURGE_METRICS_ON_TIMER` environment variable and set the interval in seconds. This will allow you to purge the metrics on a regular basis, for example every 90 seconds. It could be better solution if you have multiple crawlers checking the metrics endpoints and you want to avoid the situation when metrics are purged by for example healthcheck.
 
+#### Tracing
+
+Tracing can be enabled by setting `ENABLE_TRACE` to `true` and providing compatible with OTEL `TRACER_ENDPOINT` value ( default is `localhost:4317` ). From that moment you can include `X-Trace-Span` with content being json encoded in your requests to the proxy endpoint.
+
+The value of X-Trace-Span should be in following format:
+
+```json
+{
+ "traceparent": "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
+}
+```
+
 #### Healthcheck
 
 If you'd like the `/healthz` endpoint to perform actual check for the connectivity to the graphql endpoint - set the `HEALTHCHECK_GRAPHQL_URL` environment variable to the exact URL of the graphql endpoint. The query executed will be `query { __typename }` and if the response is not `200 OK` - the healthcheck will fail. Remember that the endpoint is a full URL which you'd like to check, so it should include the protocol, host and path - for example `http://localhost:8080/v1/graphql` and it's NOT the same as value of `HOST_GRAPHQL` environment variable which should provide only the host, without path, ending with slash.

api.go

@@ -3,7 +3,6 @@ package main
 import (
 	"fmt"
 	"os"
-	"sync"
 	"time"
 
 	"github.com/goccy/go-json"
@@ -14,66 +13,55 @@ import (
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 )
 
-var (
-	bannedUsersIDs      = make(map[string]string)
-	bannedUsersIDsMutex sync.RWMutex
-)
+var bannedUsersIDs map[string]string = make(map[string]string)
 
 func enableApi() {
-	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},
+	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),
 		})
+
+		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() {
-	ticker := time.NewTicker(10 * time.Second)
-	defer ticker.Stop()
-
-	for range ticker.C {
+	for {
 		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, "banned": found},
+		Pairs:   map[string]interface{}{"user_id": userID, "found": found},
 	})
-
 	if found {
 		cfg.Logger.Info(&libpack_logger.LogMessage{
 			Message: "User is banned",
 			Pairs:   map[string]interface{}{"user_id": userID},
 		})
-		c.Status(fiber.StatusForbidden).SendString("User is banned")
+		c.Status(403).SendString("User is banned")
 	}
 	return found
 }
@@ -81,16 +69,28 @@ 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,
 	})
-	return c.SendString("OK: cache cleared")
+	c.Status(200).SendString("OK: cache cleared")
+	return nil
 }
 
 func apiCacheStats(c *fiber.Ctx) error {
-	return c.JSON(libpack_cache.GetCacheStats())
+	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
 }
 
 type apiBanUserRequest struct {
@@ -100,92 +100,71 @@ type apiBanUserRequest struct {
 
 func apiBanUser(c *fiber.Ctx) error {
 	var req apiBanUserRequest
-	if err := c.BodyParser(&req); err != nil {
+	err := c.BodyParser(&req)
+	if err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't parse the ban user request",
 			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return c.Status(fiber.StatusBadRequest).SendString("Invalid request payload")
+		return err
 	}
-
-	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},
 	})
-
-	if err := storeBannedUsers(); err != nil {
-		return c.Status(fiber.StatusInternalServerError).SendString("Failed to store banned users")
-	}
-
-	return c.SendString("OK: user banned")
+	storeBannedUsers()
+	c.Status(200).SendString("OK: user banned")
+	return nil
 }
 
 func apiUnbanUser(c *fiber.Ctx) error {
 	var req apiBanUserRequest
-	if err := c.BodyParser(&req); err != nil {
+	err := c.BodyParser(&req)
+	if err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't parse the unban user request",
 			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return c.Status(fiber.StatusBadRequest).SendString("Invalid request payload")
+		return err
 	}
-
-	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},
 	})
-
-	if err := storeBannedUsers(); err != nil {
-		return c.Status(fiber.StatusInternalServerError).SendString("Failed to store banned users")
-	}
-
-	return c.SendString("OK: user unbanned")
+	storeBannedUsers()
+	c.Status(200).SendString("OK: user unbanned")
+	return nil
 }
 
-func storeBannedUsers() error {
+func storeBannedUsers() {
 	fileLock := flock.New(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-	if err := lockFile(fileLock); err != nil {
-		return err
+	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
 	}
 	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 err
+		return
 	}
-
-	if err := os.WriteFile(cfg.Api.BannedUsersFile, data, 0644); err != nil {
+	err = os.WriteFile(cfg.Api.BannedUsersFile, data, 0644)
+	if err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't write banned users to file",
 			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return err
+		return
 	}
-
-	return nil
 }
 
 func loadBannedUsers() {
@@ -194,9 +173,19 @@ func loadBannedUsers() {
 			Message: "Banned users file doesn't exist - creating it",
 			Pairs:   map[string]interface{}{"file": cfg.Api.BannedUsersFile},
 		})
-		if err := os.WriteFile(cfg.Api.BannedUsersFile, []byte("{}"), 0644); err != nil {
+		_, err := os.Create(cfg.Api.BannedUsersFile)
+		if err != nil {
 			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Can't create and write to the file",
+				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",
 				Pairs:   map[string]interface{}{"error": err.Error()},
 			})
 			return
@@ -204,7 +193,8 @@ func loadBannedUsers() {
 	}
 
 	fileLock := flock.New(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-	if err := lockFileRead(fileLock); err != nil {
+	err := fileLock.RLock() // Use RLock for read lock
+	if err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't lock the file [load]",
 			Pairs:   map[string]interface{}{"error": err.Error()},
@@ -221,39 +211,12 @@ func loadBannedUsers() {
 		})
 		return
 	}
-
-	var newBannedUsers map[string]string
-	if err := json.Unmarshal(data, &newBannedUsers); err != nil {
+	err = json.Unmarshal(data, &bannedUsersIDs)
+	if 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
 }

api_additional_test.go

@@ -1,231 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-func (suite *Tests) Test_PeriodicallyReloadBannedUsers() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-	cfg.Api.BannedUsersFile = filepath.Join(os.TempDir(), "banned_users_reload_test.json")
-
-	// Initial empty banned users
-	bannedUsersIDsMutex.Lock()
-	bannedUsersIDs = make(map[string]string)
-	bannedUsersIDsMutex.Unlock()
-
-	// Create a test version of periodicallyReloadBannedUsers that executes once and signals completion
-	done := make(chan bool)
-	testPeriodicallyReloadBannedUsers := func() {
-		// Just call loadBannedUsers once
-		loadBannedUsers()
-		done <- true
-	}
-
-	// Run the test with initial empty banned users file
-	suite.Run("reload with empty file", func() {
-		// Clear existing file if any
-		os.Remove(cfg.Api.BannedUsersFile)
-		os.Remove(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-
-		// Ensure banned users map is empty
-		bannedUsersIDsMutex.Lock()
-		bannedUsersIDs = make(map[string]string)
-		bannedUsersIDsMutex.Unlock()
-
-		// Execute reloader once
-		go testPeriodicallyReloadBannedUsers()
-		<-done
-
-		// Verify file was created
-		_, err := os.Stat(cfg.Api.BannedUsersFile)
-		assert.NoError(err)
-
-		// Safely check the map
-		bannedUsersIDsMutex.RLock()
-		mapSize := len(bannedUsersIDs)
-		bannedUsersIDsMutex.RUnlock()
-
-		// Verify map is still empty
-		assert.Equal(0, mapSize)
-	})
-
-	// Run the test with a populated banned users file
-	suite.Run("reload with populated file", func() {
-		// Create file with test data
-		testData := map[string]string{
-			"test-user-reload-1": "reason reload 1",
-			"test-user-reload-2": "reason reload 2",
-		}
-		data, _ := json.Marshal(testData)
-		err := os.WriteFile(cfg.Api.BannedUsersFile, data, 0644)
-		assert.NoError(err)
-
-		// Clear the banned users map
-		bannedUsersIDsMutex.Lock()
-		bannedUsersIDs = make(map[string]string)
-		bannedUsersIDsMutex.Unlock()
-
-		// Execute reloader once
-		go testPeriodicallyReloadBannedUsers()
-		<-done
-
-		// Safely check the map
-		bannedUsersIDsMutex.RLock()
-		mapSize := len(bannedUsersIDs)
-		value1 := bannedUsersIDs["test-user-reload-1"]
-		value2 := bannedUsersIDs["test-user-reload-2"]
-		bannedUsersIDsMutex.RUnlock()
-
-		// Verify banned users map was loaded
-		assert.Equal(2, mapSize)
-		assert.Equal("reason reload 1", value1)
-		assert.Equal("reason reload 2", value2)
-	})
-
-	// Test updating banned users file while reloader is running
-	suite.Run("reload with updated file", func() {
-		// Start with initial data
-		initialData := map[string]string{
-			"test-user-initial": "initial reason",
-		}
-		data, _ := json.Marshal(initialData)
-		err := os.WriteFile(cfg.Api.BannedUsersFile, data, 0644)
-		assert.NoError(err)
-
-		// Clear the banned users map
-		bannedUsersIDsMutex.Lock()
-		bannedUsersIDs = make(map[string]string)
-		bannedUsersIDsMutex.Unlock()
-
-		// Execute reloader once to load initial data
-		go testPeriodicallyReloadBannedUsers()
-		<-done
-
-		// Safely check the map
-		bannedUsersIDsMutex.RLock()
-		mapSize := len(bannedUsersIDs)
-		initialValue := bannedUsersIDs["test-user-initial"]
-		bannedUsersIDsMutex.RUnlock()
-
-		// Verify initial data was loaded
-		assert.Equal(1, mapSize)
-		assert.Equal("initial reason", initialValue)
-
-		// Update the file with new data
-		updatedData := map[string]string{
-			"test-user-updated-1": "updated reason 1",
-			"test-user-updated-2": "updated reason 2",
-		}
-		data, _ = json.Marshal(updatedData)
-		err = os.WriteFile(cfg.Api.BannedUsersFile, data, 0644)
-		assert.NoError(err)
-
-		// Execute reloader again to load updated data
-		go testPeriodicallyReloadBannedUsers()
-		<-done
-
-		// Safely check the map
-		bannedUsersIDsMutex.RLock()
-		mapSize = len(bannedUsersIDs)
-		value1 := bannedUsersIDs["test-user-updated-1"]
-		value2 := bannedUsersIDs["test-user-updated-2"]
-		_, exists := bannedUsersIDs["test-user-initial"]
-		bannedUsersIDsMutex.RUnlock()
-
-		// Verify updated data was loaded
-		assert.Equal(2, mapSize)
-		assert.Equal("updated reason 1", value1)
-		assert.Equal("updated reason 2", value2)
-		assert.False(exists)
-	})
-
-	// Cleanup
-	os.Remove(cfg.Api.BannedUsersFile)
-	os.Remove(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-}
-
-// This is a better approach instead of the ticker-based test
-func (suite *Tests) Test_LoadUnloadBannedUsers() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-	cfg.Api.BannedUsersFile = filepath.Join(os.TempDir(), "banned_users_update_test.json")
-
-	// Create a test banned users file with initial content
-	initialData := map[string]string{
-		"user1": "reason1",
-		"user2": "reason2",
-	}
-	data, _ := json.Marshal(initialData)
-	err := os.WriteFile(cfg.Api.BannedUsersFile, data, 0644)
-	assert.NoError(err)
-	defer os.Remove(cfg.Api.BannedUsersFile)
-	defer os.Remove(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-
-	// Test loading banned users
-	suite.Run("load banned users", func() {
-		// Clear the banned users map
-		bannedUsersIDsMutex.Lock()
-		bannedUsersIDs = make(map[string]string)
-		bannedUsersIDsMutex.Unlock()
-
-		// Load banned users
-		loadBannedUsers()
-
-		// Check the banned users map
-		bannedUsersIDsMutex.RLock()
-		count := len(bannedUsersIDs)
-		reason1 := bannedUsersIDs["user1"]
-		reason2 := bannedUsersIDs["user2"]
-		bannedUsersIDsMutex.RUnlock()
-
-		assert.Equal(2, count)
-		assert.Equal("reason1", reason1)
-		assert.Equal("reason2", reason2)
-	})
-
-	// Test updating banned users
-	suite.Run("update banned users", func() {
-		// Update the banned users map
-		bannedUsersIDsMutex.Lock()
-		bannedUsersIDs = map[string]string{
-			"user3": "reason3",
-			"user4": "reason4",
-		}
-		bannedUsersIDsMutex.Unlock()
-
-		// Store the updated banned users
-		err := storeBannedUsers()
-		assert.NoError(err)
-
-		// Clear the banned users map
-		bannedUsersIDsMutex.Lock()
-		bannedUsersIDs = make(map[string]string)
-		bannedUsersIDsMutex.Unlock()
-
-		// Load banned users again
-		loadBannedUsers()
-
-		// Check the banned users map
-		bannedUsersIDsMutex.RLock()
-		count := len(bannedUsersIDs)
-		reason3 := bannedUsersIDs["user3"]
-		reason4 := bannedUsersIDs["user4"]
-		_, user1Exists := bannedUsersIDs["user1"]
-		bannedUsersIDsMutex.RUnlock()
-
-		assert.Equal(2, count)
-		assert.Equal("reason3", reason3)
-		assert.Equal("reason4", reason4)
-		assert.False(user1Exists)
-	})
-}

api_test.go

@@ -1,443 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-
-	"github.com/gofiber/fiber/v2"
-	"github.com/gofrs/flock"
-	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/valyala/fasthttp"
-)
-
-func (suite *Tests) Test_apiBanUser() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-	cfg.Api.BannedUsersFile = filepath.Join(os.TempDir(), "banned_users_test.json")
-
-	// Create a test Fiber app
-	app := fiber.New()
-	app.Post("/api/user-ban", apiBanUser)
-
-	// Test valid ban request
-	suite.Run("valid ban request", func() {
-		// Clear banned users map
-		bannedUsersIDs = make(map[string]string)
-
-		reqBody := `{"user_id": "test-user-123", "reason": "testing"}`
-		req := httptest.NewRequest(http.MethodPost, "/api/user-ban", bytes.NewBufferString(reqBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := app.Test(req)
-		assert.NoError(err)
-		assert.Equal(200, resp.StatusCode)
-
-		body, err := io.ReadAll(resp.Body)
-		assert.NoError(err)
-		assert.Contains(string(body), "OK: user banned")
-
-		// Verify user was added to banned users map
-		bannedUsersIDsMutex.RLock()
-		reason, exists := bannedUsersIDs["test-user-123"]
-		bannedUsersIDsMutex.RUnlock()
-
-		assert.True(exists)
-		assert.Equal("testing", reason)
-
-		// Verify file was created
-		_, err = os.Stat(cfg.Api.BannedUsersFile)
-		assert.NoError(err)
-	})
-
-	// Test missing user_id
-	suite.Run("missing user_id", func() {
-		reqBody := `{"reason": "testing"}`
-		req := httptest.NewRequest(http.MethodPost, "/api/user-ban", bytes.NewBufferString(reqBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := app.Test(req)
-		assert.NoError(err)
-		assert.Equal(400, resp.StatusCode)
-
-		body, err := io.ReadAll(resp.Body)
-		assert.NoError(err)
-		assert.Contains(string(body), "user_id and reason are required")
-	})
-
-	// Test missing reason
-	suite.Run("missing reason", func() {
-		reqBody := `{"user_id": "test-user-123"}`
-		req := httptest.NewRequest(http.MethodPost, "/api/user-ban", bytes.NewBufferString(reqBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := app.Test(req)
-		assert.NoError(err)
-		assert.Equal(400, resp.StatusCode)
-
-		body, err := io.ReadAll(resp.Body)
-		assert.NoError(err)
-		assert.Contains(string(body), "user_id and reason are required")
-	})
-
-	// Test invalid JSON
-	suite.Run("invalid JSON", func() {
-		reqBody := `{"user_id": "test-user-123", "reason": }`
-		req := httptest.NewRequest(http.MethodPost, "/api/user-ban", bytes.NewBufferString(reqBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := app.Test(req)
-		assert.NoError(err)
-		assert.Equal(400, resp.StatusCode)
-
-		body, err := io.ReadAll(resp.Body)
-		assert.NoError(err)
-		assert.Contains(string(body), "Invalid request payload")
-	})
-
-	// Cleanup
-	os.Remove(cfg.Api.BannedUsersFile)
-	os.Remove(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-}
-
-func (suite *Tests) Test_apiUnbanUser() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-	cfg.Api.BannedUsersFile = filepath.Join(os.TempDir(), "banned_users_test.json")
-
-	// Create a test Fiber app
-	app := fiber.New()
-	app.Post("/api/user-unban", apiUnbanUser)
-
-	// Test valid unban request
-	suite.Run("valid unban request", func() {
-		// Add a user to the banned list
-		bannedUsersIDs = make(map[string]string)
-		bannedUsersIDs["test-user-123"] = "testing"
-
-		reqBody := `{"user_id": "test-user-123"}`
-		req := httptest.NewRequest(http.MethodPost, "/api/user-unban", bytes.NewBufferString(reqBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := app.Test(req)
-		assert.NoError(err)
-		assert.Equal(200, resp.StatusCode)
-
-		body, err := io.ReadAll(resp.Body)
-		assert.NoError(err)
-		assert.Contains(string(body), "OK: user unbanned")
-
-		// Verify user was removed from banned users map
-		bannedUsersIDsMutex.RLock()
-		_, exists := bannedUsersIDs["test-user-123"]
-		bannedUsersIDsMutex.RUnlock()
-
-		assert.False(exists)
-	})
-
-	// Test missing user_id
-	suite.Run("missing user_id", func() {
-		reqBody := `{}`
-		req := httptest.NewRequest(http.MethodPost, "/api/user-unban", bytes.NewBufferString(reqBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := app.Test(req)
-		assert.NoError(err)
-		assert.Equal(400, resp.StatusCode)
-
-		body, err := io.ReadAll(resp.Body)
-		assert.NoError(err)
-		assert.Contains(string(body), "user_id is required")
-	})
-
-	// Test invalid JSON
-	suite.Run("invalid JSON", func() {
-		reqBody := `{"user_id": }`
-		req := httptest.NewRequest(http.MethodPost, "/api/user-unban", bytes.NewBufferString(reqBody))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := app.Test(req)
-		assert.NoError(err)
-		assert.Equal(400, resp.StatusCode)
-
-		body, err := io.ReadAll(resp.Body)
-		assert.NoError(err)
-		assert.Contains(string(body), "Invalid request payload")
-	})
-
-	// Cleanup
-	os.Remove(cfg.Api.BannedUsersFile)
-	os.Remove(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-}
-
-func (suite *Tests) Test_apiClearCache() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-
-	// Initialize cache
-	libpack_cache.EnableCache(&libpack_cache.CacheConfig{
-		Logger: cfg.Logger,
-		TTL:    60,
-	})
-
-	// Add some items to cache
-	libpack_cache.CacheStore("test-key-1", []byte("test-value-1"))
-	libpack_cache.CacheStore("test-key-2", []byte("test-value-2"))
-
-	// Create a test Fiber app
-	app := fiber.New()
-	app.Post("/api/cache-clear", apiClearCache)
-
-	// Test cache clear
-	suite.Run("clear cache", func() {
-		req := httptest.NewRequest(http.MethodPost, "/api/cache-clear", nil)
-
-		resp, err := app.Test(req)
-		assert.NoError(err)
-		assert.Equal(200, resp.StatusCode)
-
-		body, err := io.ReadAll(resp.Body)
-		assert.NoError(err)
-		assert.Contains(string(body), "OK: cache cleared")
-
-		// Verify cache was cleared
-		stats := libpack_cache.GetCacheStats()
-		assert.Equal(int64(0), stats.CachedQueries)
-	})
-}
-
-func (suite *Tests) Test_apiCacheStats() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-
-	// Initialize cache
-	libpack_cache.EnableCache(&libpack_cache.CacheConfig{
-		Logger: cfg.Logger,
-		TTL:    60,
-	})
-
-	// Add some items to cache and perform lookups
-	libpack_cache.CacheStore("test-key-1", []byte("test-value-1"))
-	libpack_cache.CacheStore("test-key-2", []byte("test-value-2"))
-	libpack_cache.CacheLookup("test-key-1") // Hit
-	libpack_cache.CacheLookup("test-key-3") // Miss
-
-	// Create a test Fiber app
-	app := fiber.New()
-	app.Get("/api/cache-stats", apiCacheStats)
-
-	// Test get cache stats
-	suite.Run("get cache stats", func() {
-		req := httptest.NewRequest(http.MethodGet, "/api/cache-stats", nil)
-
-		resp, err := app.Test(req)
-		assert.NoError(err)
-		assert.Equal(200, resp.StatusCode)
-
-		var stats libpack_cache.CacheStats
-		err = json.NewDecoder(resp.Body).Decode(&stats)
-		assert.NoError(err)
-
-		assert.Equal(int64(2), stats.CachedQueries)
-		assert.Equal(int64(1), stats.CacheHits)
-		assert.Equal(int64(1), stats.CacheMisses)
-	})
-}
-
-func (suite *Tests) Test_checkIfUserIsBanned() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-
-	// Create a test Fiber app and context
-	app := fiber.New()
-	ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
-	defer app.ReleaseCtx(ctx)
-
-	// Test with non-banned user
-	suite.Run("non-banned user", func() {
-		bannedUsersIDs = make(map[string]string)
-
-		isBanned := checkIfUserIsBanned(ctx, "non-banned-user")
-		assert.False(isBanned)
-		assert.Equal(200, ctx.Response().StatusCode())
-	})
-
-	// Test with banned user
-	suite.Run("banned user", func() {
-		bannedUsersIDs = make(map[string]string)
-		bannedUsersIDs["banned-user"] = "testing"
-
-		isBanned := checkIfUserIsBanned(ctx, "banned-user")
-		assert.True(isBanned)
-		assert.Equal(403, ctx.Response().StatusCode())
-	})
-}
-
-func (suite *Tests) Test_loadBannedUsers() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-	cfg.Api.BannedUsersFile = filepath.Join(os.TempDir(), "banned_users_test.json")
-
-	// Test with non-existent file (should create it)
-	suite.Run("non-existent file", func() {
-		// Remove file if it exists
-		os.Remove(cfg.Api.BannedUsersFile)
-
-		bannedUsersIDs = make(map[string]string)
-		loadBannedUsers()
-
-		// Verify file was created
-		_, err := os.Stat(cfg.Api.BannedUsersFile)
-		assert.NoError(err)
-
-		// Verify banned users map is empty
-		assert.Equal(0, len(bannedUsersIDs))
-	})
-
-	// Test with existing file
-	suite.Run("existing file", func() {
-		// Create file with test data
-		testData := map[string]string{
-			"test-user-1": "reason 1",
-			"test-user-2": "reason 2",
-		}
-		data, _ := json.Marshal(testData)
-		err := os.WriteFile(cfg.Api.BannedUsersFile, data, 0644)
-		assert.NoError(err)
-
-		bannedUsersIDs = make(map[string]string)
-		loadBannedUsers()
-
-		// Verify banned users map was loaded
-		assert.Equal(2, len(bannedUsersIDs))
-		assert.Equal("reason 1", bannedUsersIDs["test-user-1"])
-		assert.Equal("reason 2", bannedUsersIDs["test-user-2"])
-	})
-
-	// Test with invalid JSON
-	suite.Run("invalid JSON", func() {
-		// Create file with invalid JSON
-		err := os.WriteFile(cfg.Api.BannedUsersFile, []byte("{invalid json}"), 0644)
-		assert.NoError(err)
-
-		bannedUsersIDs = make(map[string]string)
-		loadBannedUsers()
-
-		// Verify banned users map is empty (load failed)
-		assert.Equal(0, len(bannedUsersIDs))
-	})
-
-	// Cleanup
-	os.Remove(cfg.Api.BannedUsersFile)
-	os.Remove(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-}
-
-func (suite *Tests) Test_storeBannedUsers() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-	cfg.Api.BannedUsersFile = filepath.Join(os.TempDir(), "banned_users_test.json")
-
-	// Test storing banned users
-	suite.Run("store banned users", func() {
-		// Set up test data
-		bannedUsersIDs = map[string]string{
-			"test-user-1": "reason 1",
-			"test-user-2": "reason 2",
-		}
-
-		err := storeBannedUsers()
-		assert.NoError(err)
-
-		// Verify file was created with correct content
-		data, err := os.ReadFile(cfg.Api.BannedUsersFile)
-		assert.NoError(err)
-
-		var loadedData map[string]string
-		err = json.Unmarshal(data, &loadedData)
-		assert.NoError(err)
-
-		assert.Equal(2, len(loadedData))
-		assert.Equal("reason 1", loadedData["test-user-1"])
-		assert.Equal("reason 2", loadedData["test-user-2"])
-	})
-
-	// Cleanup
-	os.Remove(cfg.Api.BannedUsersFile)
-	os.Remove(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-}
-
-func (suite *Tests) Test_lockFile() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-	lockPath := filepath.Join(os.TempDir(), "test_lock_file.lock")
-
-	// Test locking a file
-	suite.Run("lock file", func() {
-		fileLock := flock.New(lockPath)
-
-		err := lockFile(fileLock)
-		assert.NoError(err)
-
-		// Verify file is locked
-		assert.True(fileLock.Locked())
-
-		// Cleanup
-		fileLock.Unlock()
-	})
-}
-
-func (suite *Tests) Test_lockFileRead() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-	lockPath := filepath.Join(os.TempDir(), "test_lock_file_read.lock")
-
-	// Test read-locking a file
-	suite.Run("read lock file", func() {
-		fileLock := flock.New(lockPath)
-
-		err := lockFileRead(fileLock)
-		assert.NoError(err)
-
-		// Verify file is locked - use RLocked() instead of Locked()
-		assert.True(fileLock.RLocked())
-
-		// Cleanup
-		fileLock.Unlock()
-	})
-}
-
-func (suite *Tests) Test_enableApi() {
-	// This is a partial test since we can't easily test the full server startup
-	suite.Run("api disabled", func() {
-		cfg = &config{}
-		parseConfig()
-		cfg.Server.EnableApi = false
-
-		// This should return immediately without error
-		enableApi()
-	})
-}

cache/cache.go

@@ -1,9 +1,6 @@
 package libpack_cache
 
 import (
-	"bytes"
-	"compress/gzip"
-	"io"
 	"sync/atomic"
 	"time"
 
@@ -58,7 +55,7 @@ func EnableCache(cfg *CacheConfig) {
 	}
 	cacheStats = &CacheStats{}
 	if ShouldUseRedisCache(cfg) {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
+		cfg.Logger.Info(&libpack_logger.LogMessage{
 			Message: "Using Redis cache",
 		})
 		cfg.Client = libpack_cache_redis.New(&libpack_cache_redis.RedisClientConfig{
@@ -67,7 +64,7 @@ func EnableCache(cfg *CacheConfig) {
 			RedisPassword: cfg.Redis.Password,
 		})
 	} else {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
+		cfg.Logger.Info(&libpack_logger.LogMessage{
 			Message: "Using in-memory cache",
 		})
 		cfg.Client = libpack_cache_memory.New(time.Duration(cfg.TTL) * time.Second)
@@ -76,35 +73,9 @@ 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)
@@ -112,9 +83,6 @@ 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},
@@ -124,12 +92,6 @@ 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},
@@ -139,9 +101,6 @@ 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},
@@ -151,9 +110,6 @@ 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",
 	})
@@ -166,9 +122,6 @@ func CacheClear() {
 }
 
 func GetCacheStats() *CacheStats {
-	if !IsCacheInitialized() {
-		return &CacheStats{}
-	}
 	config.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Getting cache stats",
 	})
@@ -179,7 +132,3 @@ func GetCacheStats() *CacheStats {
 func ShouldUseRedisCache(cfg *CacheConfig) bool {
 	return cfg.Redis.Enable
 }
-
-func IsCacheInitialized() bool {
-	return config != nil && config.Client != nil
-}

cache/cache_additional_test.go

@@ -1,367 +0,0 @@
-package libpack_cache
-
-import (
-	"bytes"
-	"compress/gzip"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-	libpack_cache_memory "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/memory"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/valyala/fasthttp"
-)
-
-func (suite *Tests) Test_CalculateHash() {
-	// Setup
-	app := fiber.New()
-	ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
-	defer app.ReleaseCtx(ctx)
-
-	// Test with empty body
-	suite.Run("empty body", func() {
-		ctx.Request().SetBody([]byte(""))
-		hash := CalculateHash(ctx)
-		assert.NotEmpty(hash)
-		assert.Equal(32, len(hash)) // MD5 hash is 32 characters
-	})
-
-	// Test with non-empty body
-	suite.Run("non-empty body", func() {
-		ctx.Request().SetBody([]byte("test body"))
-		hash := CalculateHash(ctx)
-		assert.NotEmpty(hash)
-		assert.Equal(32, len(hash))
-	})
-
-	// Test with different bodies produce different hashes
-	suite.Run("different bodies", func() {
-		ctx.Request().SetBody([]byte("body1"))
-		hash1 := CalculateHash(ctx)
-
-		ctx.Request().SetBody([]byte("body2"))
-		hash2 := CalculateHash(ctx)
-
-		assert.NotEqual(hash1, hash2)
-	})
-}
-
-func (suite *Tests) Test_CacheDelete() {
-	// Setup
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-
-	// Test deleting a cache entry
-	suite.Run("delete existing entry", func() {
-		// Add an entry to cache
-		testKey := "test-delete-key"
-		testValue := []byte("test-delete-value")
-		CacheStore(testKey, testValue)
-
-		// Verify it was added
-		result := CacheLookup(testKey)
-		assert.Equal(testValue, result)
-
-		// Delete the entry
-		CacheDelete(testKey)
-
-		// Verify it was deleted
-		result = CacheLookup(testKey)
-		assert.Nil(result)
-	})
-
-	// Test deleting a non-existent entry
-	suite.Run("delete non-existent entry", func() {
-		// This should not cause any errors
-		CacheDelete("non-existent-key")
-	})
-
-	// Test with uninitialized cache
-	suite.Run("uninitialized cache", func() {
-		// Save current config
-		oldConfig := config
-
-		// Set config to nil
-		config = nil
-
-		// This should not cause any errors
-		CacheDelete("any-key")
-
-		// Restore config
-		config = oldConfig
-	})
-}
-
-func (suite *Tests) Test_CacheStoreWithTTL() {
-	// Setup
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-
-	// Test storing with custom TTL
-	suite.Run("store with custom TTL", func() {
-		testKey := "test-ttl-key"
-		testValue := []byte("test-ttl-value")
-		customTTL := 1 * time.Second
-
-		CacheStoreWithTTL(testKey, testValue, customTTL)
-
-		// Verify it was stored
-		result := CacheLookup(testKey)
-		assert.Equal(testValue, result)
-
-		// Wait for TTL to expire
-		time.Sleep(1100 * time.Millisecond)
-
-		// Verify it was removed
-		result = CacheLookup(testKey)
-		assert.Nil(result)
-	})
-
-	// Test with uninitialized cache
-	suite.Run("uninitialized cache", func() {
-		// Save current config
-		oldConfig := config
-
-		// Set config to nil
-		config = nil
-
-		// This should not cause any errors
-		CacheStoreWithTTL("any-key", []byte("any-value"), 1*time.Second)
-
-		// Restore config
-		config = oldConfig
-	})
-}
-
-func (suite *Tests) Test_CacheGetQueries() {
-	// Setup
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-
-	// Test getting query count
-	suite.Run("get query count", func() {
-		// Clear cache
-		CacheClear()
-
-		// Add some entries
-		CacheStore("test-key-1", []byte("test-value-1"))
-		CacheStore("test-key-2", []byte("test-value-2"))
-
-		// Get query count
-		count := CacheGetQueries()
-		assert.Equal(int64(2), count)
-	})
-
-	// Test with uninitialized cache
-	suite.Run("uninitialized cache", func() {
-		// Save current config
-		oldConfig := config
-
-		// Set config to nil
-		config = nil
-
-		// This should return 0
-		count := CacheGetQueries()
-		assert.Equal(int64(0), count)
-
-		// Restore config
-		config = oldConfig
-	})
-}
-
-func (suite *Tests) Test_CacheClear() {
-	// Setup a new cache for this test to avoid interference
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-
-	// Create a new CacheStats instance
-	cacheStats = &CacheStats{
-		CachedQueries: 0,
-		CacheHits:     0,
-		CacheMisses:   0,
-	}
-
-	// Test clearing cache
-	suite.Run("clear cache", func() {
-		// Add some entries
-		CacheStore("test-key-1", []byte("test-value-1"))
-		CacheStore("test-key-2", []byte("test-value-2"))
-
-		// Verify they were added
-		assert.NotNil(CacheLookup("test-key-1"))
-		assert.NotNil(CacheLookup("test-key-2"))
-
-		// Get the current stats before clearing
-		beforeStats := GetCacheStats()
-
-		// Clear cache
-		CacheClear()
-
-		// Verify cache was cleared
-		assert.Nil(CacheLookup("test-key-1"))
-		assert.Nil(CacheLookup("test-key-2"))
-
-		// Verify stats were reset
-		afterStats := GetCacheStats()
-		assert.Equal(int64(0), afterStats.CachedQueries)
-		assert.Less(afterStats.CachedQueries, beforeStats.CachedQueries)
-	})
-}
-
-func (suite *Tests) Test_GetCacheStats() {
-	// Setup
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-	cacheStats = &CacheStats{}
-
-	// Test getting cache stats
-	suite.Run("get cache stats", func() {
-		// Clear cache
-		CacheClear()
-
-		// Add some entries and perform lookups
-		CacheStore("test-key-1", []byte("test-value-1"))
-		CacheStore("test-key-2", []byte("test-value-2"))
-		CacheLookup("test-key-1") // Hit
-		CacheLookup("test-key-3") // Miss
-
-		// Get stats
-		stats := GetCacheStats()
-		assert.Equal(int64(2), stats.CachedQueries)
-		assert.Equal(int64(1), stats.CacheHits)
-		assert.Equal(int64(1), stats.CacheMisses)
-	})
-
-	// Test with uninitialized cache
-	suite.Run("uninitialized cache", func() {
-		// Save current config
-		oldConfig := config
-
-		// Set config to nil
-		config = nil
-
-		// This should return empty stats
-		stats := GetCacheStats()
-		assert.Equal(int64(0), stats.CachedQueries)
-		assert.Equal(int64(0), stats.CacheHits)
-		assert.Equal(int64(0), stats.CacheMisses)
-
-		// Restore config
-		config = oldConfig
-	})
-}
-
-func (suite *Tests) Test_CacheLookup_Compressed() {
-	// Setup
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-
-	// Test lookup with compressed data
-	suite.Run("lookup compressed data", func() {
-		testKey := "test-compressed-key"
-		testValue := []byte("test-compressed-value")
-
-		// Compress the data
-		var buf bytes.Buffer
-		gzWriter := gzip.NewWriter(&buf)
-		_, err := gzWriter.Write(testValue)
-		assert.NoError(err)
-		err = gzWriter.Close()
-		assert.NoError(err)
-		compressedData := buf.Bytes()
-
-		// Store compressed data directly
-		config.Client.Set(testKey, compressedData, time.Duration(config.TTL)*time.Second)
-
-		// Lookup should automatically decompress
-		result := CacheLookup(testKey)
-		assert.Equal(testValue, result)
-	})
-
-	// Skip the invalid compressed data test as it's causing issues
-	// We'll mock the behavior instead
-	suite.Run("lookup invalid compressed data", func() {
-		// Instead of testing with invalid data, we'll just verify
-		// that the function handles errors properly by checking
-		// the error handling code path is covered
-		assert.NotPanics(func() {
-			// This is just to ensure the test passes
-			// The actual implementation should handle invalid data gracefully
-		})
-	})
-}
-
-func (suite *Tests) Test_ShouldUseRedisCache() {
-	// Test with Redis enabled
-	suite.Run("redis enabled", func() {
-		cfg := &CacheConfig{}
-		cfg.Redis.Enable = true
-
-		result := ShouldUseRedisCache(cfg)
-		assert.True(result)
-	})
-
-	// Test with Redis disabled
-	suite.Run("redis disabled", func() {
-		cfg := &CacheConfig{}
-		cfg.Redis.Enable = false
-
-		result := ShouldUseRedisCache(cfg)
-		assert.False(result)
-	})
-}
-
-func (suite *Tests) Test_IsCacheInitialized() {
-	// Test with initialized cache
-	suite.Run("initialized cache", func() {
-		config = &CacheConfig{
-			Logger: libpack_logger.New(),
-			Client: libpack_cache_memory.New(5 * time.Minute),
-		}
-
-		result := IsCacheInitialized()
-		assert.True(result)
-	})
-
-	// Test with nil config
-	suite.Run("nil config", func() {
-		oldConfig := config
-		config = nil
-
-		result := IsCacheInitialized()
-		assert.False(result)
-
-		config = oldConfig
-	})
-
-	// Test with nil client
-	suite.Run("nil client", func() {
-		oldConfig := config
-		config = &CacheConfig{
-			Logger: libpack_logger.New(),
-			Client: nil,
-		}
-
-		result := IsCacheInitialized()
-		assert.False(result)
-
-		config = oldConfig
-	})
-}

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,7 +20,6 @@ func BenchmarkCacheLookupInMemory(b *testing.B) {
 		Client: libpack_cache_memory.New(5 * time.Minute),
 		TTL:    5,
 	}
-	EnableCache(config)
 
 	hash := "00000000000000000000000000000000001337"
 	data := []byte("it's fine.")
@@ -37,18 +36,16 @@ func BenchmarkCacheLookupInMemory(b *testing.B) {
 }
 
 func BenchmarkCacheLookupRedis(b *testing.B) {
-	redis_server, err := miniredis.Run()
-	if err != nil {
-		panic(err)
-	}
+	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 = redis_server.Addr()
-	config.Redis.Enable = true
-	EnableCache(config)
 
 	hash := "00000000000000000000000000000000001337"
 	data := []byte("it's fine.")
@@ -70,7 +67,6 @@ func BenchmarkCacheStoreInMemory(b *testing.B) {
 		Client: libpack_cache_memory.New(5 * time.Minute),
 		TTL:    5,
 	}
-	EnableCache(config)
 
 	hash := "00000000000000000000000000000000001337"
 	data := []byte("it's fine.")
@@ -86,19 +82,16 @@ func BenchmarkCacheStoreInMemory(b *testing.B) {
 }
 
 func BenchmarkCacheStoreRedis(b *testing.B) {
-	redis_server, err := miniredis.Run()
-	if err != nil {
-		panic(err)
-	}
+	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 = redis_server.Addr()
-	config.Redis.Enable = true
-	EnableCache(config)
 
 	hash := "00000000000000000000000000000000001337"
 	data := []byte("it's fine.")

cache/cache_test.go

@@ -1,12 +1,10 @@
 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"
 )
 
@@ -60,15 +58,23 @@ 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
@@ -111,96 +117,3 @@ 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

@@ -4,22 +4,14 @@ import (
 	"bytes"
 	"compress/gzip"
 	"io"
-	"runtime"
+	"log"
 	"sync"
-	"sync/atomic"
 	"time"
 )
 
-// CompressionThreshold is the minimum size in bytes before a value is compressed
-const CompressionThreshold = 1024 // 1KB
-
-// MaxCacheSize is the maximum number of entries in the cache
-const MaxCacheSize = 10000
-
 type CacheEntry struct {
-	ExpiresAt  time.Time
-	Value      []byte
-	Compressed bool
+	ExpiresAt time.Time
+	Value     []byte
 }
 
 type Cache struct {
@@ -27,7 +19,6 @@ type Cache struct {
 	decompressPool sync.Pool
 	entries        sync.Map
 	globalTTL      time.Duration
-	entryCount     int64
 	sync.RWMutex
 }
 
@@ -47,97 +38,51 @@ func New(globalTTL time.Duration) *Cache {
 		},
 	}
 
-	// Start cleanup routine
 	go cache.cleanupRoutine(globalTTL)
 	return cache
 }
 
 func (c *Cache) cleanupRoutine(globalTTL time.Duration) {
-	// Clean up more frequently when the cache is large
-	ticker := time.NewTicker(globalTTL / 4)
+	ticker := time.NewTicker(globalTTL / 2)
 	defer ticker.Stop()
 
 	for range ticker.C {
 		c.CleanExpiredEntries()
-
-		// Trigger GC if we have a lot of entries
-		if atomic.LoadInt64(&c.entryCount) > MaxCacheSize/2 {
-			runtime.GC()
-		}
 	}
 }
 
 func (c *Cache) Set(key string, value []byte, ttl time.Duration) {
-	// Check if we've reached the maximum cache size
-	if atomic.LoadInt64(&c.entryCount) >= MaxCacheSize {
-		c.evictOldest(MaxCacheSize / 10) // Evict 10% of entries
-	}
-
 	expiresAt := time.Now().Add(ttl)
 
-	// Only compress if the value is larger than the threshold
-	var entry CacheEntry
-	if len(value) > CompressionThreshold {
-		compressedValue, err := c.compress(value)
-		if err == nil && len(compressedValue) < len(value) {
-			entry = CacheEntry{
-				Value:      compressedValue,
-				ExpiresAt:  expiresAt,
-				Compressed: true,
-			}
-		} else {
-			// If compression failed or didn't reduce size, store uncompressed
-			entry = CacheEntry{
-				Value:      value,
-				ExpiresAt:  expiresAt,
-				Compressed: false,
-			}
-		}
-	} else {
-		entry = CacheEntry{
-			Value:      value,
-			ExpiresAt:  expiresAt,
-			Compressed: false,
-		}
+	compressedValue, err := c.compress(value)
+	if err != nil {
+		log.Printf("Error compressing value for key %s: %v", key, err)
+		return
 	}
 
-	// Check if this is a new entry
-	_, exists := c.entries.Load(key)
-	if !exists {
-		atomic.AddInt64(&c.entryCount, 1)
+	entry := CacheEntry{
+		Value:     compressedValue,
+		ExpiresAt: expiresAt,
 	}
-
 	c.entries.Store(key, entry)
 }
 
 func (c *Cache) Get(key string) ([]byte, bool) {
 	entry, ok := c.entries.Load(key)
-	if !ok {
+	if !ok || entry.(CacheEntry).ExpiresAt.Before(time.Now()) {
 		return nil, false
 	}
-
-	cacheEntry := entry.(CacheEntry)
-	if cacheEntry.ExpiresAt.Before(time.Now()) {
-		c.entries.Delete(key)
-		atomic.AddInt64(&c.entryCount, -1)
+	compressedValue := entry.(CacheEntry).Value
+	value, err := c.decompress(compressedValue)
+	if err != nil {
+		log.Printf("Error decompressing value for key %s: %v", key, err)
 		return nil, false
 	}
-
-	if cacheEntry.Compressed {
-		value, err := c.decompress(cacheEntry.Value)
-		if err != nil {
-			return nil, false
-		}
-		return value, true
-	}
-
-	return cacheEntry.Value, true
+	return value, true
 }
 
 func (c *Cache) Delete(key string) {
-	if _, exists := c.entries.LoadAndDelete(key); exists {
-		atomic.AddInt64(&c.entryCount, -1)
-	}
+	c.entries.Delete(key)
 }
 
 func (c *Cache) Clear() {
@@ -145,18 +90,24 @@ func (c *Cache) Clear() {
 		c.entries.Delete(key)
 		return true
 	})
-	atomic.StoreInt64(&c.entryCount, 0)
 }
 
 func (c *Cache) CountQueries() int64 {
-	return atomic.LoadInt64(&c.entryCount)
+	var count int
+	c.entries.Range(func(_, _ interface{}) bool {
+		count++
+		return true
+	})
+	return int64(count)
 }
 
 func (c *Cache) compress(data []byte) ([]byte, error) {
 	var buf bytes.Buffer
 	w := c.compressPool.Get().(*gzip.Writer)
-	defer c.compressPool.Put(w)
-
+	defer func() {
+		w.Close()
+		c.compressPool.Put(w)
+	}()
 	w.Reset(&buf)
 	if _, err := w.Write(data); err != nil {
 		return nil, err
@@ -169,8 +120,6 @@ func (c *Cache) compress(data []byte) ([]byte, error) {
 
 func (c *Cache) decompress(data []byte) ([]byte, error) {
 	r, ok := c.decompressPool.Get().(*gzip.Reader)
-	defer c.decompressPool.Put(r)
-
 	if !ok || r == nil {
 		var err error
 		r, err = gzip.NewReader(bytes.NewReader(data))
@@ -182,8 +131,11 @@ func (c *Cache) decompress(data []byte) ([]byte, error) {
 			return nil, err
 		}
 	}
+	defer func() {
+		r.Close()
+		c.decompressPool.Put(r)
+	}()
 
-	defer r.Close()
 	return io.ReadAll(r)
 }
 
@@ -192,47 +144,8 @@ func (c *Cache) CleanExpiredEntries() {
 	c.entries.Range(func(key, value interface{}) bool {
 		entry := value.(CacheEntry)
 		if entry.ExpiresAt.Before(now) {
-			if _, exists := c.entries.LoadAndDelete(key); exists {
-				atomic.AddInt64(&c.entryCount, -1)
-			}
+			c.entries.Delete(key)
 		}
 		return true
 	})
 }
-
-// evictOldest removes the oldest n entries from the cache
-func (c *Cache) evictOldest(n int) {
-	type keyExpiry struct {
-		key       string
-		expiresAt time.Time
-	}
-
-	// Collect all entries with their expiry times
-	entries := make([]keyExpiry, 0, n*2)
-	c.entries.Range(func(k, v interface{}) bool {
-		key := k.(string)
-		entry := v.(CacheEntry)
-		entries = append(entries, keyExpiry{key, entry.ExpiresAt})
-		return len(entries) < cap(entries)
-	})
-
-	// Sort by expiry time (oldest first)
-	// Using a simple selection sort since we only need to find the n oldest
-	for i := 0; i < n && i < len(entries); i++ {
-		oldest := i
-		for j := i + 1; j < len(entries); j++ {
-			if entries[j].expiresAt.Before(entries[oldest].expiresAt) {
-				oldest = j
-			}
-		}
-		// Swap
-		if oldest != i {
-			entries[i], entries[oldest] = entries[oldest], entries[i]
-		}
-
-		// Delete this entry
-		if _, exists := c.entries.LoadAndDelete(entries[i].key); exists {
-			atomic.AddInt64(&c.entryCount, -1)
-		}
-	}
-}

cache/memory/memory_additional_test.go

@@ -1,90 +0,0 @@
-package libpack_cache_memory
-
-import (
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// Default constants for testing
-const (
-	DefaultTestExpiration = 5 * time.Second
-)
-
-func TestMemoryCacheClear(t *testing.T) {
-	cache := New(DefaultTestExpiration)
-
-	// Add some entries
-	cache.Set("key1", []byte("value1"), DefaultTestExpiration)
-	cache.Set("key2", []byte("value2"), DefaultTestExpiration)
-
-	// Verify entries exist
-	_, found := cache.Get("key1")
-	assert.True(t, found, "Expected key1 to exist before clearing cache")
-
-	// Clear the cache
-	cache.Clear()
-
-	// Verify cache is empty
-	_, found = cache.Get("key1")
-	assert.False(t, found, "Expected key1 to be removed after clearing cache")
-	_, found = cache.Get("key2")
-	assert.False(t, found, "Expected key2 to be removed after clearing cache")
-
-	// Check that counter was reset
-	assert.Equal(t, int64(0), cache.CountQueries(), "Expected count to be 0 after clearing cache")
-}
-
-func TestMemoryCacheCountQueries(t *testing.T) {
-	cache := New(DefaultTestExpiration)
-
-	// Check initial count
-	assert.Equal(t, int64(0), cache.CountQueries(), "Expected initial count to be 0")
-
-	// Add some entries
-	cache.Set("key1", []byte("value1"), DefaultTestExpiration)
-	cache.Set("key2", []byte("value2"), DefaultTestExpiration)
-	cache.Set("key3", []byte("value3"), DefaultTestExpiration)
-
-	// Check count
-	assert.Equal(t, int64(3), cache.CountQueries(), "Expected count to be 3 after adding 3 entries")
-
-	// Delete an entry
-	cache.Delete("key1")
-
-	// Check count after deletion
-	assert.Equal(t, int64(2), cache.CountQueries(), "Expected count to be 2 after deleting 1 entry")
-}
-
-func TestMemoryCacheCleanExpiredEntries(t *testing.T) {
-	// Create a cache with default expiration
-	cache := New(10 * time.Second)
-
-	// Add an entry that will expire quickly
-	cache.Set("expire-soon", []byte("value1"), 10*time.Millisecond)
-
-	// Add an entry that will not expire during the test
-	cache.Set("expire-later", []byte("value3"), 10*time.Minute)
-
-	// Initial count should be 2
-	assert.Equal(t, int64(2), cache.CountQueries(), "Expected count to be 2 after adding entries")
-
-	// Wait for short expiration
-	time.Sleep(20 * time.Millisecond)
-
-	// Get the expired key directly to verify it's expired
-	_, expiredFound := cache.Get("expire-soon")
-	assert.False(t, expiredFound, "Key 'expire-soon' should be expired now")
-
-	// Verify the not-expired key is still there
-	val, nonExpiredFound := cache.Get("expire-later")
-	assert.True(t, nonExpiredFound, "Key 'expire-later' should not be expired")
-	assert.Equal(t, []byte("value3"), val, "Expected correct value for 'expire-later'")
-
-	// Manually clean expired entries
-	cache.CleanExpiredEntries()
-
-	// Count should be 1 now (only the non-expired entry)
-	assert.Equal(t, int64(1), cache.CountQueries(), "Expected count to be 1 after cleaning expired entries")
-}

cache/memory/memory_bench_test.go

@@ -1,7 +1,6 @@
 package libpack_cache_memory
 
 import (
-	"fmt"
 	"testing"
 	"time"
 )
@@ -53,30 +52,3 @@ 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,8 +1,6 @@
 package libpack_cache_memory
 
 import (
-	"fmt"
-	"sync"
 	"testing"
 	"time"
 
@@ -112,57 +110,3 @@ 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_additional_test.go

@@ -1,50 +0,0 @@
-package libpack_cache_redis
-
-import (
-	"testing"
-	"time"
-
-	"github.com/alicebob/miniredis/v2"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestRedisClear(t *testing.T) {
-	// Create a mock Redis server
-	s, err := miniredis.Run()
-	if err != nil {
-		t.Fatalf("Failed to create mock redis server: %v", err)
-	}
-	defer s.Close()
-
-	// Create a Redis client
-	redisConfig := New(&RedisClientConfig{
-		RedisServer:   s.Addr(),
-		RedisPassword: "",
-		RedisDB:       0,
-	})
-
-	// Add some test data
-	ttl := time.Duration(60) * time.Second
-	redisConfig.Set("key1", []byte("value1"), ttl)
-	redisConfig.Set("key2", []byte("value2"), ttl)
-	redisConfig.Set("key3", []byte("value3"), ttl)
-
-	// Verify keys exist
-	count := redisConfig.CountQueries()
-	assert.Equal(t, int64(3), count, "Expected 3 keys before clearing cache")
-
-	// Clear the cache
-	redisConfig.Clear()
-
-	// Verify all keys are gone
-	count = redisConfig.CountQueries()
-	assert.Equal(t, int64(0), count, "Expected 0 keys after clearing cache")
-
-	// Verify individual keys are gone
-	_, found := redisConfig.Get("key1")
-	assert.False(t, found, "Key1 should be deleted after Clear")
-	_, found = redisConfig.Get("key2")
-	assert.False(t, found, "Key2 should be deleted after Clear")
-	_, found = redisConfig.Get("key3")
-	assert.False(t, found, "Key3 should be deleted after Clear")
-}

config/config_test.go

@@ -1,13 +0,0 @@
-package libpack_config
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestConfigConstants(t *testing.T) {
-	// Verify package constants are defined
-	assert.NotEmpty(t, PKG_NAME, "PKG_NAME should be defined")
-	assert.NotEmpty(t, PKG_VERSION, "PKG_VERSION should be defined")
-}

details.go

@@ -11,14 +11,18 @@ import (
 	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
 )
 
-const defaultValue = "-"
+func extractClaimsFromJWTHeader(authorization string) (usr string, role string) {
+	usr, role = "-", "-"
 
-var emptyMetrics = map[string]string{}
+	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,
+		})
+	}
 
-func extractClaimsFromJWTHeader(authorization string) (usr, role string) {
-	usr, role = defaultValue, defaultValue
-
-	tokenParts := strings.SplitN(authorization, ".", 3)
+	tokenParts := strings.Split(authorization, ".")
 	if len(tokenParts) != 3 {
 		handleError("Can't split the token", map[string]interface{}{"token": authorization})
 		return
@@ -36,30 +40,18 @@ func extractClaimsFromJWTHeader(authorization string) (usr, role string) {
 		return
 	}
 
-	usr = extractClaim(claimMap, cfg.Client.JWTUserClaimPath, "user id")
-	role = extractClaim(claimMap, cfg.Client.JWTRoleClaimPath, "role")
+	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")
 
 	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,109 +5,77 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/jackc/pgx/v5"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 )
 
-const (
-	initialDelay    = 60 * time.Second
-	cleanupInterval = 1 * time.Hour
-)
-
-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 enableHasuraEventCleaner() {
-	cfgMutex.RLock()
-	if !cfg.HasuraEventCleaner.Enable {
-		cfgMutex.RUnlock()
-		return
-	}
-
-	eventMetadataDb := cfg.HasuraEventCleaner.EventMetadataDb
-	if eventMetadataDb == "" {
-		logger := cfg.Logger
-		cfgMutex.RUnlock()
-
-		logger.Warning(&libpack_logger.LogMessage{
-			Message: "Event metadata db URL not specified, event cleaner not active",
-		})
-		return
-	}
-
-	clearOlderThan := cfg.HasuraEventCleaner.ClearOlderThan
-	logger := cfg.Logger
-	cfgMutex.RUnlock()
-
-	logger.Info(&libpack_logger.LogMessage{
-		Message: "Event cleaner enabled",
-		Pairs:   map[string]interface{}{"interval_in_days": clearOlderThan},
-	})
-
-	go func(dbURL string, clearOlderThan int, logger *libpack_logger.Logger) {
-		pool, err := pgxpool.New(context.Background(), dbURL)
-		if err != nil {
-			logger.Error(&libpack_logger.LogMessage{
-				Message: "Failed to create connection pool",
-				Pairs:   map[string]interface{}{"error": err.Error()},
+	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
 		}
-		defer pool.Close()
 
-		time.Sleep(initialDelay)
-
-		logger.Info(&libpack_logger.LogMessage{
-			Message: "Initial cleanup of old events",
-		})
-		cleanEvents(pool, clearOlderThan, logger)
-
-		ticker := time.NewTicker(cleanupInterval)
+		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},
+		})
 
-		for range ticker.C {
-			logger.Info(&libpack_logger.LogMessage{
-				Message: "Cleaning up old events",
-			})
-			cleanEvents(pool, clearOlderThan, logger)
+		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()
+			}
 		}
-	}(eventMetadataDb, clearOlderThan, logger)
+	}
 }
 
-func cleanEvents(pool *pgxpool.Pool, clearOlderThan int, logger *libpack_logger.Logger) {
-	ctx := context.Background()
-	var errors []error
-	var failedQueries []string
+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},
+		})
+		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),
+	}
 
 	for _, query := range delQueries {
-		_, err := pool.Exec(ctx, fmt.Sprintf(query, clearOlderThan))
+		_, err := conn.Exec(context.Background(), query)
 		if err != nil {
-			errors = append(errors, err)
-			failedQueries = append(failedQueries, query)
-		} else {
-			logger.Debug(&libpack_logger.LogMessage{
-				Message: "Successfully executed query",
-				Pairs:   map[string]interface{}{"query": query},
+			cfg.Logger.Debug(&libpack_logger.LogMessage{
+				Message: "Failed to execute query",
+				Pairs:   map[string]interface{}{"query": query, "error": err},
 			})
 		}
 	}
-
-	if len(errors) > 0 {
-		var errMsgs []string
-		for _, err := range errors {
-			errMsgs = append(errMsgs, err.Error())
-		}
-		logger.Error(&libpack_logger.LogMessage{
-			Message: "Failed to execute some queries",
-			Pairs: map[string]interface{}{
-				"failed_queries": failedQueries,
-				"errors":         errMsgs,
-			},
-		})
-	}
+	cfg.Logger.Info(&libpack_logger.LogMessage{
+		Message: "Old events cleaned up",
+		Pairs:   nil,
+	})
 }

events_test.go

@@ -1,103 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/stretchr/testify/suite"
-)
-
-type EventsTestSuite struct {
-	suite.Suite
-}
-
-func (suite *EventsTestSuite) SetupTest() {
-	cfgMutex.Lock()
-	if cfg == nil {
-		cfg = &config{}
-	}
-	cfg.Logger = libpack_logging.New()
-	cfgMutex.Unlock()
-}
-
-func TestEventsTestSuite(t *testing.T) {
-	suite.Run(t, new(EventsTestSuite))
-}
-
-func (suite *EventsTestSuite) Test_EnableHasuraEventCleaner() {
-	// Test case: feature is disabled
-	suite.Run("feature disabled", func() {
-		// Save original config with proper synchronization
-		cfgMutex.RLock()
-		originalConfig := cfg.HasuraEventCleaner
-		cfgMutex.RUnlock()
-
-		defer func() {
-			cfgMutex.Lock()
-			cfg.HasuraEventCleaner = originalConfig
-			cfgMutex.Unlock()
-		}()
-
-		// Set up test condition with proper synchronization
-		cfgMutex.Lock()
-		cfg.HasuraEventCleaner.Enable = false
-		cfgMutex.Unlock()
-
-		// Test function
-		enableHasuraEventCleaner()
-
-		// No assertions needed as we're just testing coverage
-		// The function should return early without error
-	})
-
-	// Test case: missing database URL
-	suite.Run("missing database URL", func() {
-		// Save original config with proper synchronization
-		cfgMutex.RLock()
-		originalConfig := cfg.HasuraEventCleaner
-		cfgMutex.RUnlock()
-
-		defer func() {
-			cfgMutex.Lock()
-			cfg.HasuraEventCleaner = originalConfig
-			cfgMutex.Unlock()
-		}()
-
-		// Set up test condition with proper synchronization
-		cfgMutex.Lock()
-		cfg.HasuraEventCleaner.Enable = true
-		cfg.HasuraEventCleaner.EventMetadataDb = ""
-		cfgMutex.Unlock()
-
-		// Test function
-		enableHasuraEventCleaner()
-
-		// No assertions needed as we're just testing coverage
-		// The function should log a warning and return early
-	})
-
-	// Test case: database URL provided but we don't actually connect in the test
-	suite.Run("database URL provided", func() {
-		// Save original config with proper synchronization
-		cfgMutex.RLock()
-		originalConfig := cfg.HasuraEventCleaner
-		cfgMutex.RUnlock()
-
-		defer func() {
-			cfgMutex.Lock()
-			cfg.HasuraEventCleaner = originalConfig
-			cfgMutex.Unlock()
-		}()
-
-		// Set up test condition with proper synchronization
-		cfgMutex.Lock()
-		cfg.HasuraEventCleaner.Enable = true
-		cfg.HasuraEventCleaner.EventMetadataDb = "postgres://fake:fake@localhost:5432/fake"
-		cfg.HasuraEventCleaner.ClearOlderThan = 7
-		cfgMutex.Unlock()
-
-		// We're not going to call enableHasuraEventCleaner() here because it would
-		// try to connect to a database. Instead, we're just increasing coverage
-		// for the configuration path by setting these values.
-	})
-}

go.mod

@@ -1,70 +1,69 @@
 module github.com/lukaszraczylo/graphql-monitoring-proxy
 
-go 1.23.0
-
-toolchain go1.23.6
+go 1.21
 
 require (
-	github.com/VictoriaMetrics/metrics v1.38.0
+	github.com/VictoriaMetrics/metrics v1.33.1
 	github.com/alicebob/miniredis/v2 v2.33.0
-	github.com/avast/retry-go/v4 v4.6.1
-	github.com/goccy/go-json v0.10.5
-	github.com/gofiber/fiber/v2 v2.52.8
-	github.com/gofrs/flock v0.12.1
+	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/google/uuid v1.6.0
-	github.com/gookit/goutil v0.6.18
+	github.com/gookit/goutil v0.6.15
 	github.com/graphql-go/graphql v0.8.1
-	github.com/jackc/pgx/v5 v5.7.5
-	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.78
-	github.com/redis/go-redis/v9 v9.11.0
-	github.com/stretchr/testify v1.10.0
-	github.com/valyala/fasthttp v1.62.0
-	go.opentelemetry.io/otel v1.36.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.36.0
-	go.opentelemetry.io/otel/sdk v1.36.0
-	go.opentelemetry.io/otel/trace v1.36.0
-	google.golang.org/grpc v1.73.0
+	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/stretchr/testify v1.9.0
+	github.com/valyala/fasthttp v1.55.0
+	go.opentelemetry.io/otel v1.27.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.27.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0
+	go.opentelemetry.io/otel/sdk v1.27.0
+	go.opentelemetry.io/otel/trace v1.27.0
 )
 
 require (
 	github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a // indirect
-	github.com/andybalholm/brotli v1.2.0 // indirect
-	github.com/cenkalti/backoff/v5 v5.0.2 // indirect
+	github.com/andybalholm/brotli v1.1.0 // indirect
+	github.com/cenkalti/backoff/v4 v4.3.0 // 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/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/logr v1.4.2 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/gookit/color v1.5.4 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
-	github.com/jackc/puddle/v2 v2.2.2 // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/klauspost/compress v1.17.9 // 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.16 // indirect
+	github.com/mattn/go-runewidth v0.0.15 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/rs/zerolog v1.33.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
-	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.36.0 // indirect
-	go.opentelemetry.io/otel/metric v1.36.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.7.0 // indirect
-	golang.org/x/crypto v0.39.0 // indirect
-	golang.org/x/net v0.41.0 // indirect
-	golang.org/x/sync v0.15.0 // indirect
-	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/term v0.32.0 // indirect
-	golang.org/x/text v0.26.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20250603155806-513f23925822 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822 // indirect
-	google.golang.org/protobuf v1.36.6 // indirect
+	go.opentelemetry.io/otel/metric v1.27.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.3.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
+	google.golang.org/genproto/googleapis/api v0.0.0-20240617180043-68d350f18fd4 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240617180043-68d350f18fd4 // indirect
+	google.golang.org/grpc v1.64.0 // indirect
+	google.golang.org/protobuf v1.34.2 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,150 +1,152 @@
-github.com/VictoriaMetrics/metrics v1.38.0 h1:1d0dRgVH8Nnu8dKMfisKefPC3q7gqf3/odyO0quAvyA=
-github.com/VictoriaMetrics/metrics v1.38.0/go.mod h1:r7hveu6xMdUACXvB8TYdAj8WEsKzWB0EkpJN+RDtOf8=
+github.com/VictoriaMetrics/metrics v1.33.1 h1:CNV3tfm2Kpv7Y9W3ohmvqgFWPR55tV2c7M2U6OIo+UM=
+github.com/VictoriaMetrics/metrics v1.33.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.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ=
-github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
-github.com/avast/retry-go/v4 v4.6.1 h1:VkOLRubHdisGrHnTu89g08aQEWEgRU7LVEop3GbIcMk=
-github.com/avast/retry-go/v4 v4.6.1/go.mod h1:V6oF8njAwxJ5gRo1Q7Cxab24xs5NCWZBeaHHBklR8mA=
+github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
+github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
+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=
 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
 github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
-github.com/cenkalti/backoff/v5 v5.0.2 h1:rIfFVxEf1QsI7E1ZHfp/B4DF/6QBAUhmgkxc0H7Zss8=
-github.com/cenkalti/backoff/v5 v5.0.2/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
+github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
+github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
 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/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
-github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
-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.8 h1:xl4jJQ0BV5EJTA2aWiKw/VddRpHrKeZLF0QPUxqn0x4=
-github.com/gofiber/fiber/v2 v2.52.8/go.mod h1:YEcBbO/FB+5M1IZNBP9FO3J9281zgPAreiI1oqg8nDw=
-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/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+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/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 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.18 h1:MUVj0G16flubWT8zYVicIuisUiHdgirPAkmnfD2kKgw=
-github.com/gookit/goutil v0.6.18/go.mod h1:AY/5sAwKe7Xck+mEbuxj0n/bc3qwrGNe3Oeulln7zBA=
+github.com/gookit/goutil v0.6.15 h1:mMQ0ElojNZoyPD0eVROk5QXJPh2uKR4g06slgPDF5Jo=
+github.com/gookit/goutil v0.6.15/go.mod h1:qdKdYEHQdEtyH+4fNdQNZfJHhI0jUZzHxQVAV3DaMDY=
 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/grpc-ecosystem/grpc-gateway/v2 v2.27.1 h1:X5VWvz21y3gzm9Nw/kaUeku/1+uBhcekkmy4IkffJww=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.1/go.mod h1:Zanoh4+gvIgluNqcfMVTJueD4wSS5hT7zTt4Mrutd90=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 h1:bkypFPDjIYGfCYD5mRBvpqxfYX1YCS1PXdKYWi8FsN0=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0/go.mod h1:P+Lt/0by1T8bfcF3z737NnSbmxQAppXMRziHUxPOC8k=
 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.7.5 h1:JHGfMnQY+IEtGM63d+NGMjoRpysB2JBwDr5fsngwmJs=
-github.com/jackc/pgx/v5 v5.7.5/go.mod h1:aruU7o91Tc2q2cFp5h4uP3f6ztExVpyVv88Xl/8Vl8M=
-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.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+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/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-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.78 h1:Ze+vTC1v3QkVB8++EO1gxyA1f/1DbXRgMFrOQDMtSWk=
-github.com/lukaszraczylo/go-simple-graphql v1.2.78/go.mod h1:PxQYblQDZISmYYj8sNfazAWxAOh1rhAtU208y+uPV8s=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+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/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.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
-github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+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/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/redis/go-redis/v9 v9.11.0 h1:E3S08Gl/nJNn5vkxd2i78wZxWAPNZgUNTp8WIJUAiIs=
-github.com/redis/go-redis/v9 v9.11.0/go.mod h1:huWgSWd8mW6+m0VPhJjSSQ+d6Nh1VICQ6Q5lHuCH/Iw=
+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/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.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
-github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+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/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/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=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+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.62.0 h1:8dKRBX/y2rCzyc6903Zu1+3qN0H/d2MsxPPmVNamiH0=
-github.com/valyala/fasthttp v1.62.0/go.mod h1:FCINgr4GKdKqV8Q0xv8b+UxPV+H/O5nNFo3D+r54Htg=
+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/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=
 github.com/valyala/histogram v1.2.0/go.mod h1:Hb4kBwb4UxsaNbbbh+RRz8ZR6pdodR57tzWUS3BUzXY=
+github.com/valyala/tcplisten v1.0.0 h1:rBHj/Xf+E1tRGZyWIWwJDiRY0zc1Js+CV5DqwacVSA8=
+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=
-go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
-go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.36.0 h1:UumtzIklRBY6cI/lllNZlALOF5nNIzJVb16APdvgTXg=
-go.opentelemetry.io/otel v1.36.0/go.mod h1:/TcFMXYjyRNh8khOAO9ybYkqaDBb/70aVwkNML4pP8E=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.36.0 h1:dNzwXjZKpMpE2JhmO+9HsPl42NIXFIFSUSSs0fiqra0=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.36.0/go.mod h1:90PoxvaEB5n6AOdZvi+yWJQoE95U8Dhhw2bSyRqnTD0=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.36.0 h1:JgtbA0xkWHnTmYk7YusopJFX6uleBmAuZ8n05NEh8nQ=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.36.0/go.mod h1:179AK5aar5R3eS9FucPy6rggvU0g52cvKId8pv4+v0c=
-go.opentelemetry.io/otel/metric v1.36.0 h1:MoWPKVhQvJ+eeXWHFBOPoBOi20jh6Iq2CcCREuTYufE=
-go.opentelemetry.io/otel/metric v1.36.0/go.mod h1:zC7Ks+yeyJt4xig9DEw9kuUFe5C3zLbVjV2PzT6qzbs=
-go.opentelemetry.io/otel/sdk v1.36.0 h1:b6SYIuLRs88ztox4EyrvRti80uXIFy+Sqzoh9kFULbs=
-go.opentelemetry.io/otel/sdk v1.36.0/go.mod h1:+lC+mTgD+MUWfjJubi2vvXWcVxyr9rmlshZni72pXeY=
-go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5JpUCaEqEI9o=
-go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w=
-go.opentelemetry.io/otel/trace v1.36.0 h1:ahxWNuqZjpdiFAyrIoQ4GIiAIhxAunQR6MUoKrsNd4w=
-go.opentelemetry.io/otel/trace v1.36.0/go.mod h1:gQ+OnDZzrybY4k4seLzPAWNwVBBVlF2szhehOBB/tGA=
-go.opentelemetry.io/proto/otlp v1.7.0 h1:jX1VolD6nHuFzOYso2E73H85i92Mv8JQYk0K9vz09os=
-go.opentelemetry.io/proto/otlp v1.7.0/go.mod h1:fSKjH6YJ7HDlwzltzyMj036AJ3ejJLCgCSHGj4efDDo=
+go.opentelemetry.io/otel v1.27.0 h1:9BZoF3yMK/O1AafMiQTVu0YDj5Ea4hPhxCs7sGva+cg=
+go.opentelemetry.io/otel v1.27.0/go.mod h1:DMpAK8fzYRzs+bi3rS5REupisuqTheUlSZJ1WnZaPAQ=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.27.0 h1:R9DE4kQ4k+YtfLI2ULwX82VtNQ2J8yZmA7ZIF/D+7Mc=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.27.0/go.mod h1:OQFyQVrDlbe+R7xrEyDr/2Wr67Ol0hRUgsfA+V5A95s=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0 h1:qFffATk0X+HD+f1Z8lswGiOQYKHRlzfmdJm0wEaVrFA=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.27.0/go.mod h1:MOiCmryaYtc+V0Ei+Tx9o5S1ZjA7kzLucuVuyzBZloQ=
+go.opentelemetry.io/otel/metric v1.27.0 h1:hvj3vdEKyeCi4YaYfNjv2NUje8FqKqUY8IlF0FxV/ik=
+go.opentelemetry.io/otel/metric v1.27.0/go.mod h1:mVFgmRlhljgBiuk/MP/oKylr4hs85GZAylncepAX/ak=
+go.opentelemetry.io/otel/sdk v1.27.0 h1:mlk+/Y1gLPLn84U4tI8d3GNJmGT/eXe3ZuOXN9kTWmI=
+go.opentelemetry.io/otel/sdk v1.27.0/go.mod h1:Ha9vbLwJE6W86YstIywK2xFfPjbWlCuwPtMkKdz/Y4A=
+go.opentelemetry.io/otel/trace v1.27.0 h1:IqYb813p7cmbHk0a5y6pD5JPakbVfftRXABGt5/Rscw=
+go.opentelemetry.io/otel/trace v1.27.0/go.mod h1:6RiD1hkAprV4/q+yd2ln1HG9GoPx39SuvvstaLBl+l4=
+go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0=
+go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
-golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
-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.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
-golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
-golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
-golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+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/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.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
-golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
-golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
-google.golang.org/genproto/googleapis/api v0.0.0-20250603155806-513f23925822 h1:oWVWY3NzT7KJppx2UKhKmzPq4SRe0LdCijVRwvGeikY=
-google.golang.org/genproto/googleapis/api v0.0.0-20250603155806-513f23925822/go.mod h1:h3c4v36UTKzUiuaOKQ6gr3S+0hovBtUrXzTG/i3+XEc=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822 h1:fc6jSaCT0vBduLYZHYrBBNY4dsWuvgyff9noRNDdBeE=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
-google.golang.org/grpc v1.73.0 h1:VIWSmpI2MegBtTuFt5/JWy2oXxtjJ/e89Z70ImfD2ok=
-google.golang.org/grpc v1.73.0/go.mod h1:50sbHOUqWoCQGI8V2HQLJM0B+LMlIUjNSZmow7EVBQc=
-google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+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=
+google.golang.org/genproto/googleapis/api v0.0.0-20240617180043-68d350f18fd4 h1:MuYw1wJzT+ZkybKfaOXKp5hJiZDn2iHaXRw0mRYdHSc=
+google.golang.org/genproto/googleapis/api v0.0.0-20240617180043-68d350f18fd4/go.mod h1:px9SlOOZBg1wM1zdnr8jEL4CNGUBZ+ZKYtNPApNQc4c=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240617180043-68d350f18fd4 h1:Di6ANFilr+S60a4S61ZM00vLdw0IrQOSMS2/6mrnOU0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240617180043-68d350f18fd4/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=
+google.golang.org/grpc v1.64.0 h1:KH3VH9y/MgNQg1dE7b3XfVK0GsPSIzJwdF617gUSbvY=
+google.golang.org/grpc v1.64.0/go.mod h1:oxjF8E3FBnjp+/gVFYdWacaLDx9na1aqy9oovLpxQYg=
+google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
+google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
 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,42 +3,57 @@ package main
 import (
 	"strconv"
 	"strings"
-	"sync"
 
 	"github.com/goccy/go-json"
 	fiber "github.com/gofiber/fiber/v2"
 	"github.com/graphql-go/graphql/language/ast"
 	"github.com/graphql-go/graphql/language/parser"
+	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
 )
 
-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": {},
+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{}{}
 	}
-	introspectionAllowedQueries = make(map[string]struct{})
-	allowedUrls                 = make(map[string]struct{})
-)
+	return resultMap
+}
 
 func prepareQueriesAndExemptions() {
-	introspectionAllowedQueries = make(map[string]struct{})
-	allowedUrls = make(map[string]struct{})
-
-	// Process allowed introspection queries
-	for _, q := range cfg.Security.IntrospectionAllowed {
-		cleanQuery := strings.Trim(strings.TrimSpace(q), `"`)
-		introspectionAllowedQueries[strings.ToLower(cleanQuery)] = struct{}{}
-	}
-
-	// Process allowed URLs
-	for _, u := range cfg.Server.AllowURLs {
-		allowedUrls[u] = struct{}{}
-	}
+	introspectionQuerySet = sliceToMap(introspection_queries)
+	introspectionAllowedQueries = sliceToMap(cfg.Security.IntrospectionAllowed)
+	allowedUrls = sliceToMap(cfg.Server.AllowURLs)
 }
 
 type parseGraphQLQueryResult struct {
@@ -52,216 +67,156 @@ type parseGraphQLQueryResult struct {
 	shouldIgnore   bool
 }
 
-var (
-	queryPool = sync.Pool{
-		New: func() interface{} {
-			return make(map[string]interface{}, 48)
-		},
-	}
-	resultPool = sync.Pool{
-		New: func() interface{} {
-			return &parseGraphQLQueryResult{}
-		},
-	}
-)
-
-func parseGraphQLQuery(c *fiber.Ctx) *parseGraphQLQueryResult {
-	// Get a result object from the pool and initialize it
-	res := resultPool.Get().(*parseGraphQLQueryResult)
-	*res = parseGraphQLQueryResult{shouldIgnore: true, activeEndpoint: cfg.Server.HostGraphQL}
-
-	// Get a map from the pool for JSON unmarshaling
-	m := queryPool.Get().(map[string]interface{})
-	defer func() {
-		// Clear and return the map to the pool
-		for k := range m {
-			delete(m, k)
-		}
-		queryPool.Put(m)
-	}()
-
-	// Unmarshal the request body
-	if err := json.Unmarshal(c.Body(), &m); err != nil {
+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 res
+		return
 	}
-
-	// Extract the query string
+	// get the query
 	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 res
+		return
 	}
 
-	// Parse the GraphQL query
 	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 res
+		return
 	}
 
-	// Mark as a valid GraphQL query
 	res.shouldIgnore = false
 	res.operationName = "undefined"
+	res.activeEndpoint = cfg.Server.HostGraphQL
 
-	// Process each definition in the query
 	for _, d := range p.Definitions {
 		if oper, ok := d.(*ast.OperationDefinition); ok {
-			// Extract operation type and name
-			if res.operationType == "" {
-				res.operationType = strings.ToLower(oper.Operation)
-				if oper.Name != nil {
-					res.operationName = oper.Name.Value
-				}
+			res.operationType = strings.ToLower(oper.Operation)
+
+			if oper.Name != nil {
+				res.operationName = oper.Name.Value
 			}
 
-			// Handle read-only endpoint routing
-			if cfg.Server.HostGraphQLReadOnly != "" && (res.operationType == "" || res.operationType != "mutation") {
+			// 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
 			}
 
-			// Block mutations in read-only mode
 			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")
+				c.Status(403).SendString("The server is in read-only mode")
 				res.shouldBlock = true
-				resultPool.Put(res)
-				return res
+				return
 			}
 
-			// Process directives (like @cached)
-			processDirectives(oper, res)
-
-			// Check for introspection queries if they're blocked
-			if cfg.Security.BlockIntrospection && checkSelections(c, oper.GetSelectionSet().Selections) {
-				_ = c.Status(403).SendString("Introspection queries are not allowed")
-				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 {
+						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 arg.Name.Value == "refresh" {
+							res.cacheRefresh = arg.Value.GetValue().(bool)
+						}
+					}
+				}
 			}
-		}
-	}
-	return res
-}
 
-// processDirectives extracts caching directives from the operation
-func processDirectives(oper *ast.OperationDefinition, res *parseGraphQLQueryResult) {
-	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 {
+				res.shouldBlock = checkSelections(c, oper.GetSelectionSet().Selections)
+				if res.shouldBlock {
+					return
 				}
 			}
 		}
 	}
+	return
 }
 
-// checkSelections recursively checks if any selection is an introspection query that should be blocked
 func checkSelections(c *fiber.Ctx, selections []ast.Selection) bool {
-	if len(selections) == 0 {
-		return false
-	}
-
-	// Fast path: if no introspection blocking is configured, return immediately
-	if !cfg.Security.BlockIntrospection {
-		return false
-	}
-
-	// Fast path: if there are no allowed introspection queries, check only top level
-	hasAllowList := len(cfg.Security.IntrospectionAllowed) > 0
-
 	for _, s := range selections {
-		switch sel := s.(type) {
-		case *ast.Field:
-			fieldName := strings.ToLower(sel.Name.Value)
-
-			// Check if this is an introspection query
-			if _, exists := introspectionQueries[fieldName]; exists {
-				if hasAllowList {
-					// Check if it's in the allowed list
-					if _, allowed := introspectionAllowedQueries[fieldName]; !allowed {
-						return true // Block if not allowed
-					}
-				} else {
-					return true // Block if no allowlist exists
-				}
-			}
-
-			// Check nested selections if present
-			if sel.SelectionSet != nil && len(sel.GetSelectionSet().Selections) > 0 {
-				if checkSelections(c, sel.GetSelectionSet().Selections) {
-					return true
-				}
-			}
-
-		case *ast.InlineFragment:
-			// Check nested selections in fragments
-			if sel.SelectionSet != nil && len(sel.GetSelectionSet().Selections) > 0 {
-				if checkSelections(c, sel.GetSelectionSet().Selections) {
-					return true
-				}
+		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
 			}
 		}
 	}
-
 	return false
 }
 
-func checkIfContainsIntrospection(c *fiber.Ctx, query string) bool {
-	blocked := false
+func checkIfContainsIntrospection(c *fiber.Ctx, whatever string) (shouldBlock bool) {
+	whateverLower := strings.ToLower(whatever)
+	got_exemption := false
 
-	// Enable introspection blocking for tests
-	if !cfg.Security.BlockIntrospection {
-		cfg.Security.BlockIntrospection = true
-	}
+	// 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 {
 
-	// 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 _, 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
 			}
 		}
-	} 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 !got_exemption {
+			shouldBlock = true
 		}
 	}
-
-	if blocked {
+	if shouldBlock {
 		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 blocked
+	return
 }

graphql_test.go

@@ -1,14 +1,6 @@
 package main
 
 import (
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/goccy/go-json"
-	fiber "github.com/gofiber/fiber/v2"
-	"github.com/graphql-go/graphql/language/ast"
-	"github.com/graphql-go/graphql/language/parser"
 	"github.com/valyala/fasthttp"
 )
 
@@ -282,19 +274,23 @@ func (suite *Tests) Test_parseGraphQLQuery() {
 		suite.Run(tt.name, func() {
 			cfg = &config{}
 			parseConfig()
-			// Create a context first, then modify its request directly
-			reqCtx := &fasthttp.RequestCtx{}
-			
-			// Set headers directly on the request
-			for k, v := range tt.suppliedQuery.headers {
-				reqCtx.Request.Header.Add(k, v)
+			ctx_headers := func() *fasthttp.RequestHeader {
+				h := fasthttp.RequestHeader{}
+				for k, v := range tt.suppliedQuery.headers {
+					h.Add(k, v)
+				}
+				return &h
+			}()
+
+			ctx_request := fasthttp.Request{
+				Header: *ctx_headers,
 			}
-			
-			// Set the body
-			reqCtx.Request.AppendBody([]byte(tt.suppliedQuery.body))
-			
-			// Now create the fiber context with the request context
-			ctx := suite.app.AcquireCtx(reqCtx)
+
+			ctx_request.AppendBody([]byte(tt.suppliedQuery.body))
+
+			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{
+				Request: ctx_request,
+			})
 
 			// defer func() {
 			// 	cfg = &config{}
@@ -322,286 +318,3 @@ 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())
-			}
-		})
-	}
-}
-
-func TestIntrospectionQueryHandling(t *testing.T) {
-	tests := []struct {
-		name               string
-		blockIntrospection bool
-		allowedQueries     []string
-		query              string
-		wantBlocked        bool
-	}{
-		{
-			name:               "allows __typename when in allowed list",
-			blockIntrospection: true,
-			allowedQueries:     []string{"__typename"},
-			query: `{
-							users {
-									id
-									name
-									__typename
-							}
-					}`,
-			wantBlocked: false,
-		},
-		{
-			name:               "case insensitive matching for allowed queries",
-			blockIntrospection: true,
-			allowedQueries:     []string{"__TYPENAME"},
-			query: `{
-							users {
-									__typename
-							}
-					}`,
-			wantBlocked: false,
-		},
-		{
-			name:               "blocks other introspection queries",
-			blockIntrospection: true,
-			allowedQueries:     []string{"__typename"},
-			query: `{
-							__schema {
-									types {
-											name
-									}
-							}
-					}`,
-			wantBlocked: true,
-		},
-		{
-			name:               "allows multiple __typename occurrences",
-			blockIntrospection: true,
-			allowedQueries:     []string{"__typename"},
-			query: `{
-							users {
-									__typename
-									posts {
-											__typename
-									}
-							}
-					}`,
-			wantBlocked: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			// Setup config
-			cfg = &config{
-				Security: struct {
-					IntrospectionAllowed []string
-					BlockIntrospection   bool
-				}{
-					IntrospectionAllowed: tt.allowedQueries,
-					BlockIntrospection:   tt.blockIntrospection,
-				},
-			}
-
-			// Initialize allowed queries
-			prepareQueriesAndExemptions()
-
-			// Parse query
-			p, err := parser.Parse(parser.ParseParams{Source: tt.query})
-			if err != nil {
-				t.Fatalf("failed to parse query: %v", err)
-			}
-
-			// Create mock fiber context
-			app := fiber.New()
-			ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
-			defer app.ReleaseCtx(ctx)
-
-			// Check selections
-			var blocked bool
-			for _, def := range p.Definitions {
-				if op, ok := def.(*ast.OperationDefinition); ok {
-					blocked = checkSelections(ctx, op.GetSelectionSet().Selections)
-					break
-				}
-			}
-
-			if blocked != tt.wantBlocked {
-				t.Errorf("checkSelections() blocked = %v, want %v", blocked, tt.wantBlocked)
-			}
-		})
-	}
-}

logging/logger.go

@@ -2,6 +2,7 @@ package libpack_logger
 
 import (
 	"bytes"
+	"flag"
 	"fmt"
 	"io"
 	"os"
@@ -15,14 +16,16 @@ import (
 )
 
 const (
-	LEVEL_DEBUG = iota
+	_ = iota
+	LEVEL_DEBUG
 	LEVEL_INFO
 	LEVEL_WARN
 	LEVEL_ERROR
 	LEVEL_FATAL
 )
 
-var levelNames = []string{
+var LevelNames = [...]string{
+	"none",
 	"debug",
 	"info",
 	"warn",
@@ -31,109 +34,74 @@ var levelNames = []string{
 }
 
 const (
-	defaultTimeFormat = time.RFC3339
+	defaultFormat     = time.RFC3339
 	defaultMinLevel   = LEVEL_INFO
 	defaultShowCaller = false
 )
 
-// Logger represents the logging object with configurations.
+var defaultOutput = os.Stdout
+
 type Logger struct {
 	output      io.Writer
-	timeFormat  string
+	format      string
 	minLogLevel int
 	showCaller  bool
 }
 
-// LogMessage represents a log message with optional pairs.
 type LogMessage struct {
-	Pairs   map[string]interface{}
+	output  io.Writer
+	Pairs   map[string]any
 	Message string
 }
 
-// bufferPool is used to reuse bytes.Buffer for efficiency.
-var bufferPool = sync.Pool{
-	New: func() interface{} {
-		return new(bytes.Buffer)
-	},
+func (m *LogMessage) String() string {
+	return m.Message
 }
 
-// fieldNames allows customization of output field names.
 var fieldNames = map[string]string{
 	"timestamp": "timestamp",
 	"level":     "level",
 	"message":   "message",
 }
 
-// osExit is a variable to allow mocking os.Exit in tests
-var osExit = os.Exit
-
-// exitMutex ensures thread-safe access to osExit
-var exitMutex sync.RWMutex
-
-// New creates a new Logger with default settings.
 func New() *Logger {
 	return &Logger{
-		timeFormat:  defaultTimeFormat,
+		format:      defaultFormat,
 		minLogLevel: defaultMinLevel,
-		output:      os.Stdout,
+		output:      defaultOutput,
 		showCaller:  defaultShowCaller,
 	}
 }
 
-// SetOutput sets the output destination for the logger.
 func (l *Logger) SetOutput(output io.Writer) *Logger {
 	l.output = output
 	return l
 }
 
-// GetLogLevel returns the log level integer corresponding to the given level name.
+var bufferPool = sync.Pool{
+	New: func() any {
+		return new(bytes.Buffer)
+	},
+}
+
+var defaultPairs = make(map[string]any)
+
 func GetLogLevel(level string) int {
-	level = strings.ToLower(level)
-	for i, name := range levelNames {
-		if name == level {
+	for i, name := range LevelNames {
+		if name == strings.ToLower(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 = make(map[string]interface{})
+		m.Pairs = defaultPairs
 	}
 
-	m.Pairs[fieldNames["timestamp"]] = time.Now().Format(l.timeFormat)
-	m.Pairs[fieldNames["level"]] = levelNames[level]
+	m.Pairs[fieldNames["timestamp"]] = time.Now().Format(l.format)
+	m.Pairs[fieldNames["level"]] = LevelNames[level]
 	m.Pairs[fieldNames["message"]] = m.Message
 
 	if l.showCaller {
@@ -141,75 +109,93 @@ func (l *Logger) log(level int, m *LogMessage) {
 	}
 
 	buffer := bufferPool.Get().(*bytes.Buffer)
-	buffer.Reset()
 	defer bufferPool.Put(buffer)
+	buffer.Reset()
 
-	encoder := json.NewEncoder(buffer)
+	var encoder = json.NewEncoder(buffer)
 	err := encoder.Encode(m.Pairs)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, "Error marshalling log message:", err)
+		fmt.Println("Error marshalling log message:", err)
 		return
 	}
 
-	_, err = l.output.Write(buffer.Bytes())
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "Error writing log message:", err)
+	// 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
+		}
 	}
+
+	// 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)
-	exitMutex.RLock()
-	defer exitMutex.RUnlock()
-	osExit(1)
+	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 {
-	// Skip 3 stack frames: getCaller -> log -> [Debug|Info|...]
-	const depth = 3
-	_, file, line, ok := runtime.Caller(depth)
+	_, file, line, ok := runtime.Caller(3)
 	if !ok {
 		return "unknown:0"
 	}

logging/logger_additional_test.go

@@ -1,178 +0,0 @@
-package libpack_logger
-
-import (
-	"bytes"
-	"testing"
-
-	assertions "github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-// LoggerAdditionalTestSuite extends testing for functions with low coverage
-type LoggerAdditionalTestSuite struct {
-	suite.Suite
-	logger *Logger
-	output *bytes.Buffer
-	assert *assertions.Assertions
-}
-
-func (suite *LoggerAdditionalTestSuite) SetupTest() {
-	suite.output = &bytes.Buffer{}
-	suite.logger = New().SetOutput(suite.output).SetShowCaller(false)
-	suite.assert = assertions.New(suite.T())
-}
-
-func TestLoggerAdditionalTestSuite(t *testing.T) {
-	suite.Run(t, new(LoggerAdditionalTestSuite))
-}
-
-// Test GetLogLevel function
-func (suite *LoggerAdditionalTestSuite) TestGetLogLevel() {
-	tests := []struct {
-		name     string
-		level    string
-		expected int
-	}{
-		{"debug level", "debug", LEVEL_DEBUG},
-		{"info level", "info", LEVEL_INFO},
-		{"warn level", "warn", LEVEL_WARN},
-		{"error level", "error", LEVEL_ERROR},
-		{"fatal level", "fatal", LEVEL_FATAL},
-		{"uppercase level", "DEBUG", LEVEL_DEBUG},
-		{"mixed case level", "WaRn", LEVEL_WARN},
-		{"invalid level", "invalid", defaultMinLevel},
-		{"empty level", "", defaultMinLevel},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			result := GetLogLevel(tt.level)
-			suite.assert.Equal(tt.expected, result)
-		})
-	}
-}
-
-// Test SetFieldName function
-func (suite *LoggerAdditionalTestSuite) TestSetFieldName() {
-	// Save original field names
-	originalFieldNames := make(map[string]string)
-	for k, v := range fieldNames {
-		originalFieldNames[k] = v
-	}
-
-	// Restore original field names after test
-	defer func() {
-		for k, v := range originalFieldNames {
-			fieldNames[k] = v
-		}
-	}()
-
-	// Test with custom field names
-	customTimestampField := "time"
-	customLevelField := "severity"
-	customMessageField := "text"
-
-	suite.logger.SetFieldName("timestamp", customTimestampField)
-	suite.logger.SetFieldName("level", customLevelField)
-	suite.logger.SetFieldName("message", customMessageField)
-
-	// Verify field names were changed
-	suite.assert.Equal(customTimestampField, fieldNames["timestamp"])
-	suite.assert.Equal(customLevelField, fieldNames["level"])
-	suite.assert.Equal(customMessageField, fieldNames["message"])
-
-	// Test logging with custom field names
-	suite.output.Reset()
-	suite.logger.Info(&LogMessage{Message: "test custom fields"})
-	output := suite.output.String()
-
-	// Check if custom field names are used in the output
-	suite.assert.Contains(output, customTimestampField)
-	suite.assert.Contains(output, customLevelField)
-	suite.assert.Contains(output, customMessageField)
-	suite.assert.NotContains(output, "timestamp")
-	suite.assert.NotContains(output, "level")
-	suite.assert.NotContains(output, "message")
-}
-
-// Test SetShowCaller and getCaller functions
-func (suite *LoggerAdditionalTestSuite) TestSetShowCaller() {
-	// Make sure caller info is disabled
-	suite.logger.SetShowCaller(false)
-
-	// Test with caller info disabled
-	suite.output.Reset()
-	suite.logger.Info(&LogMessage{Message: "test without cal__ler"})
-	output := suite.output.String()
-	suite.assert.NotContains(output, "caller")
-
-	// Test with caller info enabled
-	suite.output.Reset()
-	suite.logger.SetShowCaller(true)
-	suite.logger.Info(&LogMessage{Message: "test with caller"})
-	output = suite.output.String()
-	suite.assert.Contains(output, "caller")
-
-	// Verify the caller info format (file:line)
-	suite.assert.Regexp(`"caller":"[^:]+:\d+"`, output)
-}
-
-// Test Warning function
-func (suite *LoggerAdditionalTestSuite) TestWarning() {
-	suite.output.Reset()
-	msg := &LogMessage{Message: "test warning"}
-	suite.logger.Warning(msg)
-	output := suite.output.String()
-	suite.assert.Contains(output, "warn")
-	suite.assert.Contains(output, "test warning")
-}
-
-// Test Error function
-func (suite *LoggerAdditionalTestSuite) TestError() {
-	suite.output.Reset()
-	msg := &LogMessage{Message: "test error"}
-	suite.logger.Error(msg)
-	output := suite.output.String()
-	suite.assert.Contains(output, "error")
-	suite.assert.Contains(output, "test error")
-}
-
-// Test Fatal function
-func (suite *LoggerAdditionalTestSuite) TestFatal() {
-	suite.output.Reset()
-	msg := &LogMessage{Message: "test fatal"}
-	suite.logger.Fatal(msg)
-	output := suite.output.String()
-	suite.assert.Contains(output, "fatal")
-	suite.assert.Contains(output, "test fatal")
-}
-
-// Test Critical function without exiting
-func (suite *LoggerAdditionalTestSuite) TestCritical() {
-	// Safely intercept os.Exit call with proper synchronization
-	exitMutex.Lock()
-	originalOsExit := osExit
-
-	var exitCode int
-	osExit = func(code int) {
-		exitCode = code
-		// Don't actually exit
-	}
-	exitMutex.Unlock()
-
-	// Ensure we restore the original osExit function
-	defer func() {
-		exitMutex.Lock()
-		osExit = originalOsExit
-		exitMutex.Unlock()
-	}()
-
-	suite.output.Reset()
-	msg := &LogMessage{Message: "test critical"}
-	suite.logger.Critical(msg)
-	output := suite.output.String()
-
-	suite.assert.Contains(output, "fatal")
-	suite.assert.Contains(output, "test critical")
-	suite.assert.Equal(1, exitCode)
-}

logging/logger_bench_test.go

@@ -55,7 +55,15 @@ func Benchmark_NewLogger(b *testing.B) {
 	for _, tt := range tests {
 		b.Run(tt.name, func(b *testing.B) {
 			for i := 0; i < b.N; i++ {
-				_ = New()
+				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

@@ -3,6 +3,7 @@ package libpack_logger
 import (
 	"bytes"
 	"fmt"
+	"os"
 	"reflect"
 	"testing"
 	"time"
@@ -10,12 +11,36 @@ import (
 	"github.com/goccy/go-json"
 )
 
+func captureStderr(f func()) string {
+	originalStderr := os.Stderr
+	r, w, _ := os.Pipe()
+	os.Stderr = w
+	f()
+	w.Close()
+	var buf bytes.Buffer
+	buf.ReadFrom(r)
+	os.Stderr = originalStderr
+	return buf.String()
+}
+
+func captureStdOut(f func()) string {
+	originalStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+	f()
+	w.Close()
+	var buf bytes.Buffer
+	buf.ReadFrom(r)
+	os.Stdout = originalStdout
+	return buf.String()
+}
+
 func (suite *LoggerTestSuite) Test_LogMessageString() {
 	msg := &LogMessage{
 		Message: "test message",
 	}
 
-	assert.Equal("test message", msg.Message)
+	assert.Equal("test message", msg.String())
 }
 
 func callLoggerMethod(logger *Logger, methodName string, message *LogMessage) {
@@ -100,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)
@@ -118,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])
@@ -136,9 +161,9 @@ func containsLogMessage(logOutput, expectedMessage string) bool {
 }
 
 func (suite *LoggerTestSuite) Test_SetFormat() {
-	logger := New().SetTimeFormat(time.RFC3339Nano)
+	logger := New().SetFormat(time.RFC3339Nano)
 
-	assert.Equal(time.RFC3339Nano, logger.timeFormat)
+	assert.Equal(time.RFC3339Nano, logger.format)
 }
 
 func (suite *LoggerTestSuite) Test_SetMinLogLevel() {

main.go

@@ -1,15 +1,10 @@
 package main
 
 import (
-	"context"
 	"flag"
 	"os"
-	"os/signal"
-	"strconv"
 	"strings"
 	"sync"
-	"syscall"
-	"time"
 
 	"github.com/gofiber/fiber/v2/middleware/proxy"
 	"github.com/gookit/goutil/envutil"
@@ -17,68 +12,50 @@ import (
 	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
 	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
 	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	libpack_tracing "github.com/lukaszraczylo/graphql-monitoring-proxy/tracing"
+	libpack_trace "github.com/lukaszraczylo/graphql-monitoring-proxy/tracing"
 )
 
-var (
-	cfg      *config
-	cfgMutex sync.RWMutex
-	once     sync.Once
-	tracer   *libpack_tracing.TracingSetup
-)
+var cfg *config
+var once sync.Once
 
-// getDetailsFromEnv retrieves the value from the environment or returns the default.
-// It first checks for a prefixed environment variable (GMP_KEY), then falls back to the unprefixed version.
+// function get value from the env where the value can be anything
 func getDetailsFromEnv[T any](key string, defaultValue T) T {
-	prefixedKey := "GMP_" + key
-
+	var result any
+	if _, ok := os.LookupEnv("GMP_" + key); ok {
+		key = "GMP_" + key
+	}
 	switch v := any(defaultValue).(type) {
 	case string:
-		if val, ok := os.LookupEnv(prefixedKey); ok {
-			return any(val).(T)
-		}
-		return any(envutil.Getenv(key, v)).(T)
+		result = envutil.Getenv(key, v)
 	case int:
-		if val, ok := os.LookupEnv(prefixedKey); ok {
-			if intVal, err := strconv.Atoi(val); err == nil {
-				return any(intVal).(T)
-			}
-		}
-		return any(envutil.GetInt(key, v)).(T)
+		result = envutil.GetInt(key, v)
 	case bool:
-		if val, ok := os.LookupEnv(prefixedKey); ok {
-			boolVal := strings.ToLower(val) == "true" || val == "1"
-			return any(boolVal).(T)
-		}
-		return any(envutil.GetBool(key, v)).(T)
+		result = envutil.GetBool(key, v)
 	default:
-		return defaultValue
+		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", "")
@@ -88,14 +65,10 @@ func parseConfig() {
 		return strings.Split(urls, ",")
 	}()
 	c.LogLevel = strings.ToUpper(getDetailsFromEnv("LOG_LEVEL", "info"))
-	// Logger setup
-	c.Logger = libpack_logging.New().SetMinLogLevel(libpack_logging.GetLogLevel(c.LogLevel)).
-		SetFieldName("timestamp", "ts").SetFieldName("message", "msg").SetShowCaller(false)
-	// Health check
+	c.Logger = libpack_logging.New().SetMinLogLevel(libpack_logging.GetLogLevel(c.LogLevel)).SetFieldName("timestamp", "ts").SetFieldName("message", "msg").SetShowCaller(false)
 	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 {
@@ -107,59 +80,24 @@ 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
-	// API configurations
+	proxy.WithClient(c.Client.FastProxyClient) // setting the global proxy client here instead of per request
 	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", "")
-	// Tracing configuration
-	c.Tracing.Enable = getDetailsFromEnv("ENABLE_TRACE", false)
-	c.Tracing.Endpoint = getDetailsFromEnv("TRACE_ENDPOINT", "localhost:4317")
-
-	cfgMutex.Lock()
+	c.Trace.Enable = getDetailsFromEnv("ENABLE_TRACE", false)
+	c.Trace.TraceEndpoint = getDetailsFromEnv("TRACER_ENDPOINT", "localhost:4317")
 	cfg = &c
-	cfgMutex.Unlock()
 
-	// Initialize tracing if enabled
-	if cfg.Tracing.Enable {
-		if cfg.Tracing.Endpoint == "" {
-			cfg.Logger.Warning(&libpack_logging.LogMessage{
-				Message: "Tracing endpoint not configured, using default localhost:4317",
-			})
-			cfg.Tracing.Endpoint = "localhost:4317"
-		}
-
-		var err error
-		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-
-		tracer, err = libpack_tracing.NewTracing(ctx, cfg.Tracing.Endpoint)
-		if err != nil {
-			cfg.Logger.Error(&libpack_logging.LogMessage{
-				Message: "Failed to initialize tracing",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-		} else {
-			cfg.Logger.Info(&libpack_logging.LogMessage{
-				Message: "Tracing initialized",
-				Pairs:   map[string]interface{}{"endpoint": cfg.Tracing.Endpoint},
-			})
-		}
-	}
-
-	// 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
@@ -171,6 +109,18 @@ func parseConfig() {
 
 	loadRatelimitConfig()
 	once.Do(func() {
+		if cfg.Trace.Enable {
+			var err error
+			cfg.Trace.Client, err = libpack_trace.NewClient(cfg.Logger, cfg.Trace.TraceEndpoint)
+			if err != nil {
+				cfg.Logger.Error(&libpack_logging.LogMessage{
+					Message: "Failed to start tracer",
+					Pairs: map[string]interface{}{
+						"error": err,
+					},
+				})
+			}
+		}
 		go enableApi()
 		go enableHasuraEventCleaner()
 	})
@@ -178,85 +128,11 @@ func parseConfig() {
 }
 
 func main() {
-	// Parse configuration
 	parseConfig()
-
-	// Setup graceful shutdown
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// Create a wait group to manage goroutines
-	var wg sync.WaitGroup
-
-	// Setup signal handling for graceful shutdown
-	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
-	go func() {
-		<-sigCh
-		cfg.Logger.Info(&libpack_logging.LogMessage{
-			Message: "Shutdown signal received, stopping services...",
-		})
-		cancel()
-	}()
-
-	// Start monitoring server in a goroutine
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		StartMonitoringServer()
-	}()
-
-	// Give monitoring server time to initialize
-	time.Sleep(2 * time.Second)
-
-	// Start HTTP proxy in a goroutine
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		StartHTTPProxy()
-	}()
-
-	// Wait for context cancellation
-	<-ctx.Done()
-
-	// Perform cleanup
-	cfg.Logger.Info(&libpack_logging.LogMessage{
-		Message: "Shutting down services...",
-	})
-
-	// Cleanup tracing
-	if tracer != nil {
-		shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer shutdownCancel()
-
-		if err := tracer.Shutdown(shutdownCtx); err != nil {
-			cfg.Logger.Error(&libpack_logging.LogMessage{
-				Message: "Error shutting down tracer",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-		}
-	}
-
-	// Wait for all goroutines to finish (with timeout)
-	waitCh := make(chan struct{})
-	go func() {
-		wg.Wait()
-		close(waitCh)
-	}()
-
-	select {
-	case <-waitCh:
-		cfg.Logger.Info(&libpack_logging.LogMessage{
-			Message: "All services shut down gracefully",
-		})
-	case <-time.After(10 * time.Second):
-		cfg.Logger.Warning(&libpack_logging.LogMessage{
-			Message: "Some services didn't shut down gracefully within timeout",
-		})
-	}
+	StartMonitoringServer()
+	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

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"os"
 	"testing"
 	"time"
@@ -12,7 +11,6 @@ import (
 	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 	assertions "github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
-	"github.com/valyala/fasthttp"
 )
 
 type Tests struct {
@@ -42,13 +40,7 @@ func (suite *Tests) SetupTest() {
 	parseConfig()
 	enableApi()
 	StartMonitoringServer()
-
-	// Update logger with proper synchronization
-	logger := libpack_logging.New().SetMinLogLevel(libpack_logging.GetLogLevel(getDetailsFromEnv("LOG_LEVEL", "info")))
-	cfgMutex.Lock()
-	cfg.Logger = logger
-	cfgMutex.Unlock()
-
+	cfg.Logger = libpack_logging.New().SetMinLogLevel(libpack_logging.GetLogLevel(getDetailsFromEnv("LOG_LEVEL", "info")))
 	// Setup environment variables here if needed
 	os.Setenv("GMP_TEST_STRING", "testValue")
 	os.Setenv("GMP_TEST_INT", "123")
@@ -68,9 +60,7 @@ func (suite *Tests) TearDownTest() {
 // func (suite *Tests) AfterTest(suiteName, testName string) {)
 
 func TestSuite(t *testing.T) {
-	cfgMutex.Lock()
 	cfg = &config{}
-	cfgMutex.Unlock()
 	parseConfig()
 	StartMonitoringServer()
 	suite.Run(t, new(Tests))
@@ -122,150 +112,3 @@ 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)
-		})
-	}
-}
-
-func (suite *Tests) TestIntrospectionEnvironmentConfig() {
-	// Save original env vars
-	oldEnv := make(map[string]string)
-	varsToSave := []string{
-		"BLOCK_SCHEMA_INTROSPECTION",
-		"ALLOWED_INTROSPECTION",
-		"GMP_BLOCK_SCHEMA_INTROSPECTION",
-		"GMP_ALLOWED_INTROSPECTION",
-	}
-	for _, env := range varsToSave {
-		if val, exists := os.LookupEnv(env); exists {
-			oldEnv[env] = val
-			os.Unsetenv(env)
-		}
-	}
-	defer func() {
-		// Restore original env vars
-		for k, v := range oldEnv {
-			os.Setenv(k, v)
-		}
-	}()
-
-	tests := []struct {
-		name         string
-		envVars      map[string]string
-		query        string
-		wantBlocked  bool
-		wantEndpoint string
-	}{
-		{
-			name: "basic typename allowed",
-			envVars: map[string]string{
-				"BLOCK_SCHEMA_INTROSPECTION": "true",
-				"ALLOWED_INTROSPECTION":      "__typename",
-			},
-			query: `{
-							users {
-									id
-									__typename
-							}
-					}`,
-			wantBlocked: false,
-		},
-		{
-			name: "GMP prefix takes precedence",
-			envVars: map[string]string{
-				"BLOCK_SCHEMA_INTROSPECTION":     "false",
-				"GMP_BLOCK_SCHEMA_INTROSPECTION": "true",
-				"ALLOWED_INTROSPECTION":          "__type",
-				"GMP_ALLOWED_INTROSPECTION":      "__typename",
-			},
-			query: `{
-							users {
-									__typename
-							}
-					}`,
-			wantBlocked: false,
-		},
-		{
-			name: "multiple allowed queries",
-			envVars: map[string]string{
-				"BLOCK_SCHEMA_INTROSPECTION": "true",
-				"ALLOWED_INTROSPECTION":      "__typename,__schema",
-			},
-			query: `{
-							__schema {
-									types {
-											name
-											__typename
-									}
-							}
-					}`,
-			wantBlocked: false,
-		},
-		{
-			name: "multiple allowed queries with one of them blocked",
-			envVars: map[string]string{
-				"BLOCK_SCHEMA_INTROSPECTION": "true",
-				"ALLOWED_INTROSPECTION":      "__schema",
-			},
-			query: `{
-							__schema {
-									types {
-											name
-											__typename
-									}
-							}
-					}`,
-			wantBlocked: true,
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			// Set test env vars
-			for k, v := range tt.envVars {
-				os.Setenv(k, v)
-			}
-
-			// Reset global config with proper synchronization
-			cfgMutex.Lock()
-			cfg = nil
-			cfgMutex.Unlock()
-			parseConfig()
-
-			// Create test request
-			app := fiber.New()
-			ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
-			defer app.ReleaseCtx(ctx)
-			ctx.Request().Header.SetMethod("POST")
-			ctx.Request().SetBody([]byte(fmt.Sprintf(`{"query": %q}`, tt.query)))
-
-			result := parseGraphQLQuery(ctx)
-			assert.Equal(tt.wantBlocked, result.shouldBlock)
-			for k := range tt.envVars {
-				os.Unsetenv(k)
-			}
-		})
-	}
-}

monitoring.go

@@ -4,12 +4,8 @@ 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,13 +12,17 @@ import (
 	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
 )
 
+// Cache for sorted label keys to avoid repeated sorting
 var sortedLabelKeysCache = struct {
-	m sync.Map
-}{}
+	m map[string][]string
+	sync.RWMutex
+}{m: make(map[string][]string)}
 
 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)
@@ -26,16 +30,18 @@ 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.WriteByte('_')
+		buf.WriteString("_")
 	}
 	buf.WriteString(name)
 
+	// Append labels if any
 	if len(labels) > 0 {
-		buf.WriteByte('{')
+		buf.WriteString("{")
 		appendSortedLabels(&buf, labels)
-		buf.WriteByte('}')
+		buf.WriteString("}")
 	}
 
 	return buf.String()
@@ -72,64 +78,64 @@ func appendSortedLabels(buf *bytes.Buffer, labels map[string]string) {
 	keys := getSortedKeys(labels)
 	for i, k := range keys {
 		if i > 0 {
-			buf.WriteByte(',')
+			buf.WriteString(",")
 		}
 		buf.WriteString(k)
-		buf.WriteString(`="`)
+		buf.WriteString("=\"")
 		buf.WriteString(labels[k])
-		buf.WriteByte('"')
+		buf.WriteString("\"")
 	}
 }
 
 func getSortedKeys(labels map[string]string) []string {
 	labelsKey := labelsToString(labels)
 
-	// Check if the sorted keys are already cached
-	if keys, ok := sortedLabelKeysCache.m.Load(labelsKey); ok {
-		return keys.([]string)
-	}
+	sortedLabelKeysCache.RLock()
+	keys, exists := sortedLabelKeysCache.m[labelsKey]
+	sortedLabelKeysCache.RUnlock()
 
-	// Compute the sorted keys
-	keys := make([]string, 0, len(labels))
-	for k := range labels {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
+	if !exists {
+		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)
+		sortedLabelKeysCache.Lock()
+		sortedLabelKeysCache.m[labelsKey] = keys
+		sortedLabelKeysCache.Unlock()
+	}
 
 	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 := range keys {
+	for k, v := range labels {
 		sb.WriteString(k)
-		sb.WriteByte('=')
-		sb.WriteString(labels[k])
-		sb.WriteByte(';')
+		sb.WriteString("=")
+		sb.WriteString(v)
+		sb.WriteString(";")
 	}
 	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
@@ -138,27 +144,31 @@ func clean_metric_name(name string) string {
 		if is_allowed_rune(r) {
 			if is_special_rune(r) {
 				if lastWasUnderscore {
-					continue
+					continue // Skip if the previous character was also an underscore
 				}
-				r = '_'
+				r = '_' // Convert spaces and special characters to underscores
 				lastWasUnderscore = true
 			} else {
 				lastWasUnderscore = false
 			}
 			buf.WriteRune(r)
 		} else if !lastWasUnderscore {
-			buf.WriteByte('_')
+			buf.WriteRune('_')
 			lastWasUnderscore = true
 		}
 	}
 
-	return strings.Trim(buf.String(), "_")
+	// Remove trailing underscore
+	result := buf.String()
+	return strings.Trim(result, "_")
 }
 
+// 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 == '_'
 }
@@ -168,12 +178,14 @@ 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.WriteByte('_')
+		buf.WriteString("_")
 		buf.WriteString(k)
-		buf.WriteByte('_')
+		buf.WriteString("_")
 		buf.WriteString(labels[k])
 	}
 

monitoring/monitoring.go

@@ -1,3 +1,6 @@
+// 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 (
@@ -19,7 +22,9 @@ type MetricsSetup struct {
 	metrics_prefix     string
 }
 
-var log = libpack_logger.New().SetMinLogLevel(libpack_logger.LEVEL_INFO)
+var (
+	log *libpack_logger.Logger
+)
 
 type InitConfig struct {
 	PurgeOnCrawl bool
@@ -27,11 +32,11 @@ type InitConfig struct {
 }
 
 func NewMonitoring(ic *InitConfig) *MetricsSetup {
-	ms := &MetricsSetup{
-		ic:                 ic,
-		metrics_set:        metrics.NewSet(),
-		metrics_set_custom: metrics.NewSet(),
-	}
+	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
 
 	if flag.Lookup("test.v") == nil {
 		go ms.startPrometheusEndpoint()
@@ -55,11 +60,9 @@ 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)
-	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},
-		})
+	err := app.Listen(fmt.Sprintf(":%d", envutil.GetInt("MONITORING_PORT", 9393)))
+	if err != nil {
+		fmt.Println("Can't start the service: ", err)
 	}
 }
 
@@ -82,7 +85,7 @@ func (ms *MetricsSetup) ListActiveMetrics() []string {
 }
 
 func (ms *MetricsSetup) RegisterMetricsGauge(metric_name string, labels map[string]string, val float64) *metrics.Gauge {
-	if err := validate_metrics_name(metric_name); err != nil {
+	if validate_metrics_name(metric_name) != nil {
 		log.Critical(&libpack_logger.LogMessage{
 			Message: "RegisterMetricsGauge() error",
 			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
@@ -90,12 +93,13 @@ 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 err := validate_metrics_name(metric_name); err != nil {
+	if validate_metrics_name(metric_name) != nil {
 		log.Critical(&libpack_logger.LogMessage{
 			Message: "RegisterMetricsCounter() error",
 			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
@@ -109,7 +113,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 err := validate_metrics_name(metric_name); err != nil {
+	if validate_metrics_name(metric_name) != nil {
 		log.Critical(&libpack_logger.LogMessage{
 			Message: "RegisterFloatCounter() error",
 			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
@@ -120,7 +124,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 err := validate_metrics_name(metric_name); err != nil {
+	if validate_metrics_name(metric_name) != nil {
 		log.Critical(&libpack_logger.LogMessage{
 			Message: "RegisterMetricsSummary() error",
 			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
@@ -131,7 +135,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 err := validate_metrics_name(metric_name); err != nil {
+	if validate_metrics_name(metric_name) != nil {
 		log.Critical(&libpack_logger.LogMessage{
 			Message: "RegisterMetricsHistogram() error",
 			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},

monitoring/monitoring_additional_test.go

@@ -1,113 +0,0 @@
-package libpack_monitoring
-
-import (
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type MonitoringAdditionalTestSuite struct {
-	suite.Suite
-	ms *MetricsSetup
-}
-
-func (suite *MonitoringAdditionalTestSuite) SetupTest() {
-	// Create monitoring with testing configuration
-	suite.ms = NewMonitoring(&InitConfig{
-		PurgeOnCrawl: true,
-		PurgeEvery:   0, // Disable auto-purge to have predictable tests
-	})
-}
-
-func TestMonitoringAdditionalTestSuite(t *testing.T) {
-	suite.Run(t, new(MonitoringAdditionalTestSuite))
-}
-
-// TestListActiveMetrics tests the ListActiveMetrics method
-func (suite *MonitoringAdditionalTestSuite) TestListActiveMetrics() {
-	// Register metrics directly to the set to ensure they're there
-	suite.ms.metrics_set_custom.GetOrCreateCounter("test_counter{label=\"value\"}")
-	suite.ms.metrics_set_custom.GetOrCreateGauge("test_gauge{label=\"value\"}", func() float64 { return 42.0 })
-
-	// Get list of metrics
-	metricsList := suite.ms.ListActiveMetrics()
-
-	// Verify metrics were registered - the metrics_set_custom doesn't get listed by ListActiveMetrics,
-	// so we'll just check that the function runs without error
-	assert.NotNil(suite.T(), metricsList, "Metrics list should not be nil")
-}
-
-// TestRegisterFloatCounter tests the full flow of RegisterFloatCounter
-func (suite *MonitoringAdditionalTestSuite) TestRegisterFloatCounter() {
-	// Test valid metric name
-	counter := suite.ms.RegisterFloatCounter("test_float_counter", map[string]string{
-		"label1": "value1",
-	})
-	assert.NotNil(suite.T(), counter)
-
-	// Test using the counter
-	counter.Add(42.5)
-
-	// We don't need to test invalid metric names since they log a critical message
-	// which can cause the test to exit, and that's the expected behavior
-}
-
-// TestRegisterMetricsSummary tests the RegisterMetricsSummary method
-func (suite *MonitoringAdditionalTestSuite) TestRegisterMetricsSummary() {
-	// Test valid metric name
-	summary := suite.ms.RegisterMetricsSummary("test_summary", map[string]string{
-		"label1": "value1",
-	})
-	assert.NotNil(suite.T(), summary)
-
-	// Test using the summary
-	summary.Update(42.5)
-}
-
-// TestRegisterMetricsHistogram tests the RegisterMetricsHistogram method
-func (suite *MonitoringAdditionalTestSuite) TestRegisterMetricsHistogram() {
-	// Test valid metric name
-	histogram := suite.ms.RegisterMetricsHistogram("test_histogram", map[string]string{
-		"label1": "value1",
-	})
-	assert.NotNil(suite.T(), histogram)
-
-	// Test using the histogram
-	histogram.Update(42.5)
-}
-
-// TestUpdateDuration tests the UpdateDuration method
-func (suite *MonitoringAdditionalTestSuite) TestUpdateDuration() {
-	// Register histogram for duration tracking
-	metricName := "test_duration"
-	labels := map[string]string{
-		"label1": "value1",
-	}
-
-	// Use UpdateDuration
-	startTime := time.Now().Add(-time.Second) // 1 second ago
-	suite.ms.UpdateDuration(metricName, labels, startTime)
-
-	// Since we can't easily verify the duration was recorded correctly in a test,
-	// we'll just verify the method doesn't crash
-}
-
-// Skip the purge test as it depends on timing and may be flaky
-// Instead, test the PurgeMetrics method directly
-func (suite *MonitoringAdditionalTestSuite) TestPurgeMetrics() {
-	// Register a custom metric
-	suite.ms.RegisterMetricsCounter("test_purge_counter", nil)
-
-	// Purge the metrics
-	suite.ms.PurgeMetrics()
-
-	// Verify the custom metrics were purged
-	// We need to check the actual customSet instead of calling ListActiveMetrics
-	customMetrics := suite.ms.metrics_set_custom.ListMetricNames()
-
-	// The metrics might not be immediately cleared due to internal implementation details,
-	// so this test might be flaky. We'll check that it doesn't panic instead.
-	assert.NotNil(suite.T(), customMetrics, "Custom metrics list shouldn't be nil")
-}

monitoring/monitoring_test.go

@@ -1,214 +0,0 @@
-package libpack_monitoring
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewMonitoring(t *testing.T) {
-	// Test creating a new monitoring instance
-	mon := NewMonitoring(&InitConfig{
-		PurgeOnCrawl: true,
-		PurgeEvery:   60,
-	})
-	assert.NotNil(t, mon)
-	assert.NotNil(t, mon.metrics_set)
-	assert.NotNil(t, mon.metrics_set_custom)
-}
-
-func TestAddMetricsPrefix(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test adding prefix to a name
-	mon.AddMetricsPrefix("test")
-	assert.Equal(t, "test", mon.metrics_prefix)
-
-	// Test with empty prefix
-	mon.AddMetricsPrefix("")
-	assert.Equal(t, "", mon.metrics_prefix)
-}
-
-func TestRegisterMetricsGauge(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test registering a gauge
-	gauge := mon.RegisterMetricsGauge("valid_gauge", map[string]string{"label1": "value1"}, 42.0)
-	assert.NotNil(t, gauge)
-
-	// Test with invalid metric name - we'll skip this test since it causes fatal errors
-	// gauge = mon.RegisterMetricsGauge("invalid metric name", map[string]string{"label1": "value1"}, 42.0)
-	// assert.Nil(t, gauge)
-}
-
-func TestRegisterMetricsCounter(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test registering a counter
-	counter := mon.RegisterMetricsCounter("valid_counter", map[string]string{"label1": "value1"})
-	assert.NotNil(t, counter)
-
-	// Test with default metrics
-	counter = mon.RegisterMetricsCounter(MetricsSucceeded, map[string]string{"label1": "value1"})
-	assert.NotNil(t, counter)
-}
-
-func TestRegisterFloatCounter(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test registering a float counter
-	counter := mon.RegisterFloatCounter("valid_float_counter", map[string]string{"label1": "value1"})
-	assert.NotNil(t, counter)
-}
-
-func TestRegisterMetricsSummary(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test registering a summary
-	summary := mon.RegisterMetricsSummary("valid_summary", map[string]string{"label1": "value1"})
-	assert.NotNil(t, summary)
-}
-
-func TestRegisterMetricsHistogram(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test registering a histogram
-	histogram := mon.RegisterMetricsHistogram("valid_histogram", map[string]string{"label1": "value1"})
-	assert.NotNil(t, histogram)
-}
-
-func TestIncrement(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test incrementing a counter
-	mon.Increment("increment_counter", map[string]string{"label1": "value1"})
-
-	// We can't easily verify the value was incremented in a test,
-	// but we can verify the function doesn't panic
-}
-
-func TestIncrementFloat(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test incrementing a float counter
-	mon.IncrementFloat("float_counter", map[string]string{"label1": "value1"}, 1.5)
-}
-
-func TestSet(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test setting a gauge
-	mon.Set("set_gauge", map[string]string{"label1": "value1"}, 42)
-}
-
-func TestUpdate(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test updating a histogram
-	mon.Update("update_histogram", map[string]string{"label1": "value1"}, 42.0)
-}
-
-func TestUpdateSummary(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test updating a summary
-	mon.UpdateSummary("update_summary", map[string]string{"label1": "value1"}, 42.0)
-}
-
-func TestRemoveMetrics(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Register a metric first
-	mon.RegisterMetricsGauge("remove_gauge", map[string]string{"label1": "value1"}, 42.0)
-
-	// Test removing a metric
-	mon.RemoveMetrics("remove_gauge", map[string]string{"label1": "value1"})
-}
-
-func TestPurgeMetrics(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Register some metrics first
-	mon.RegisterMetricsGauge("purge_gauge1", map[string]string{"label1": "value1"}, 42.0)
-	mon.RegisterMetricsGauge("purge_gauge2", map[string]string{"label1": "value1"}, 42.0)
-
-	// Test purging all metrics
-	mon.PurgeMetrics()
-}
-
-func TestListActiveMetrics(t *testing.T) {
-	// Skip this test as it's causing issues with the metrics registry
-	t.Skip("Skipping test due to issues with metrics registry")
-
-	mon := NewMonitoring(&InitConfig{})
-
-	// Register some metrics first - use the default metrics set
-	mon.RegisterDefaultMetrics()
-
-	// Give some time for metrics to register
-	time.Sleep(100 * time.Millisecond)
-
-	// Test listing active metrics
-	metrics := mon.ListActiveMetrics()
-	assert.NotEmpty(t, metrics)
-}
-
-func TestMetricsEndpoint(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Register a metric
-	mon.RegisterMetricsGauge("endpoint_gauge", map[string]string{}, 42.0)
-
-	// Create a test Fiber app
-	app := fiber.New()
-	app.Get("/metrics", mon.metricsEndpoint)
-
-	// Create a test request
-	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
-	resp, err := app.Test(req)
-
-	// Verify the response
-	assert.NoError(t, err)
-	assert.Equal(t, http.StatusOK, resp.StatusCode)
-}
-
-func TestRegisterDefaultMetricsFunc(t *testing.T) {
-	mon := NewMonitoring(&InitConfig{})
-
-	// Test registering default metrics
-	mon.RegisterDefaultMetrics()
-
-	// We can't easily verify the metrics were registered in a test,
-	// but we can verify the function doesn't panic
-	assert.NotPanics(t, func() {
-		mon.RegisterDefaultMetrics()
-	})
-}
-
-func TestHelperFunctions(t *testing.T) {
-	// Test is_allowed_rune
-	t.Run("is_allowed_rune", func(t *testing.T) {
-		assert.True(t, is_allowed_rune('a'))
-		assert.True(t, is_allowed_rune('1'))
-		assert.True(t, is_allowed_rune('_'))
-		assert.True(t, is_allowed_rune(' '))
-		assert.False(t, is_allowed_rune('-'))
-	})
-
-	// Test is_special_rune
-	t.Run("is_special_rune", func(t *testing.T) {
-		assert.True(t, is_special_rune('_'))
-		assert.True(t, is_special_rune(' '))
-		assert.False(t, is_special_rune('a'))
-	})
-}
-
-func TestGetPodNameFunc(t *testing.T) {
-	// Test getting pod name
-	podName := getPodName()
-	assert.NotEmpty(t, podName)
-}

proxy.go

@@ -1,27 +1,21 @@
 package main
 
 import (
-	"bytes"
-	"compress/gzip"
 	"context"
 	"crypto/tls"
 	"fmt"
-	"io"
-	"net/url"
 	"time"
 
-	"go.opentelemetry.io/otel/trace"
-
 	"github.com/avast/retry-go/v4"
-	"github.com/gofiber/fiber/v2"
+	"github.com/goccy/go-json"
+	fiber "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"
-	libpack_tracing "github.com/lukaszraczylo/graphql-monitoring-proxy/tracing"
+	libpack_trace "github.com/lukaszraczylo/graphql-monitoring-proxy/tracing"
 	"github.com/valyala/fasthttp"
 )
 
-// createFasthttpClient creates and configures a fasthttp client.
 func createFasthttpClient(timeout int) *fasthttp.Client {
 	return &fasthttp.Client{
 		Name:                     "graphql_proxy",
@@ -30,186 +24,133 @@ func createFasthttpClient(timeout int) *fasthttp.Client {
 			InsecureSkipVerify: true,
 		},
 		MaxConnsPerHost:               2048,
-		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: false,
+		ReadTimeout:                   time.Second * time.Duration(timeout),
+		WriteTimeout:                  time.Second * time.Duration(timeout),
+		MaxIdleConnDuration:           time.Second * time.Duration(timeout),
+		MaxConnDuration:               time.Second * time.Duration(timeout),
+		DisableHeaderNamesNormalizing: true,
 	}
 }
 
-// proxyTheRequest handles the request proxying logic.
-func proxyTheRequest(c *fiber.Ctx, currentEndpoint string) error {
-	// Setup tracing if enabled
-	var span trace.Span
-	var ctx context.Context
-
-	if cfg.Tracing.Enable && tracer != nil {
-		ctx = setupTracing(c)
-		span, _ = tracer.StartSpan(ctx, "proxy_request")
-		defer span.End()
-	}
-
-	// Check if URL is allowed
+func proxyTheRequest(c *fiber.Ctx, currentEndpoint string, ctx context.Context) error {
 	if !checkAllowedURLs(c) {
+		cfg.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Request blocked",
+			Pairs:   map[string]interface{}{"path": c.Path()},
+		})
 		if ifNotInTest() {
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
 		}
-		return fmt.Errorf("request blocked - not allowed URL: %s", c.Path())
+		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"),
+			},
+		})
 	}
 
-	// Construct and validate proxy URL
-	proxyURL := currentEndpoint + c.Path()
-	if _, err := url.Parse(proxyURL); err != nil {
-		return fmt.Errorf("invalid URL: %v", err)
-	}
-
-	// Log request details in debug mode
-	if cfg.LogLevel == "DEBUG" {
-		logDebugRequest(c)
-	}
-
-	// Perform the proxy request with retries
-	if err := performProxyRequest(c, proxyURL); err != nil {
-		if ifNotInTest() {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-		}
-		return err
-	}
-
-	// Log response details in debug mode
-	if cfg.LogLevel == "DEBUG" {
-		logDebugResponse(c)
-	}
-
-	// Handle gzipped responses
-	if err := handleGzippedResponse(c); err != nil {
-		return err
-	}
-
-	// Final status check
-	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())
-	}
-
-	// Remove server header for security
-	c.Response().Header.Del(fiber.HeaderServer)
-	return nil
-}
-
-// setupTracing extracts and sets up tracing context from request headers
-func setupTracing(c *fiber.Ctx) context.Context {
-	ctx := context.Background()
-
-	if !cfg.Tracing.Enable || tracer == nil {
-		return ctx
-	}
-
-	// Extract trace information from header
-	if traceHeader := c.Get("X-Trace-Span"); traceHeader != "" {
-		spanInfo, err := libpack_tracing.ParseTraceHeader(traceHeader)
-		if err != nil {
-			cfg.Logger.Warning(&libpack_logger.LogMessage{
-				Message: "Failed to parse trace header",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-		} else if spanCtx, err := tracer.ExtractSpanContext(spanInfo); err == nil {
-			ctx = trace.ContextWithSpanContext(ctx, spanCtx)
-		}
-	}
-
-	return ctx
-}
-
-// performProxyRequest executes the proxy request with retries
-func performProxyRequest(c *fiber.Ctx, proxyURL string) error {
-	return retry.Do(
+	err := retry.Do(
 		func() error {
-			if err := proxy.DoRedirects(c, proxyURL, 3, cfg.Client.FastProxyClient); err != nil {
-				return err
-			}
-			if c.Response().StatusCode() != fiber.StatusOK {
-				return fmt.Errorf("received non-200 response: %d", c.Response().StatusCode())
+			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
 			}
 			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(),
-					"attempt": n + 1,
-					"error":   err.Error(),
+					"path":  c.Path(),
+					"error": err.Error(),
 				},
 			})
 		}),
+		retry.Attempts(uint(3)),
+		retry.DelayType(retry.BackOffDelay),
+		retry.Delay(time.Duration(250*time.Millisecond)),
 		retry.LastErrorOnly(true),
 	)
-}
 
-// handleGzippedResponse decompresses gzipped responses
-func handleGzippedResponse(c *fiber.Ctx) error {
-	if !bytes.EqualFold(c.Response().Header.Peek("Content-Encoding"), []byte("gzip")) {
-		return nil
-	}
-
-	// Create a pooled gzip reader
-	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()
-
-	// Read decompressed data
-	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()},
+		cfg.Logger.Warning(&libpack_logger.LogMessage{
+			Message: "Can't proxy the request",
+			Pairs: map[string]interface{}{
+				"error": err.Error(),
+			},
 		})
 		return err
 	}
 
-	// Update response
-	c.Response().SetBody(decompressed)
-	c.Response().Header.Del("Content-Encoding")
+	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)
+		}
+		cfg.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Received non-200 response from the GraphQL server",
+			Pairs: map[string]interface{}{
+				"status_code": c.Response().StatusCode(),
+			},
+		})
+		return fmt.Errorf("Received non-200 response from the GraphQL server: %d", c.Response().StatusCode())
+	}
+
+	c.Response().Header.Del(fiber.HeaderServer)
+	if cfg.Trace.Enable {
+		tracingContext := libpack_trace.TraceContextInject(ctx)
+		if tracingContext == nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Can't inject empty tracing context",
+			})
+			return nil
+		}
+		traceJsonEncoded, err := json.Marshal(tracingContext)
+		if err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Can't convert tracing context to JSON",
+				Pairs: map[string]interface{}{
+					"error": err.Error(),
+				},
+			})
+			return err
+		}
+		c.Response().Header.Set("X-Trace-Span", string(traceJsonEncoded))
+	}
 	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,10 +1,6 @@
 package main
 
 import (
-	"net/http"
-	"net/http/httptest"
-	"time"
-
 	"github.com/valyala/fasthttp"
 )
 
@@ -16,63 +12,47 @@ func (suite *Tests) Test_proxyTheRequest() {
 	}
 
 	tests := []struct {
-		headers      map[string]string
-		name         string
-		body         string
-		host         string
-		hostRO       string
-		path         string
-		wantErr      bool
-		wantEndpoint string
+		headers map[string]string
+		name    string
+		body    string
+		host    string
+		hostRO  string
+		path    string
+		wantErr bool
 	}{
 		{
-			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_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_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_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 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",
+			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 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/",
+			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,
 		},
 	}
 
@@ -87,21 +67,23 @@ func (suite *Tests) Test_proxyTheRequest() {
 				cfg.Server.HostGraphQLReadOnly = tt.hostRO
 			}
 
-			// Create a request context first
-			reqCtx := &fasthttp.RequestCtx{}
-			
-			// Set headers directly on the request
-			for k, v := range tt.headers {
-				reqCtx.Request.Header.Add(k, v)
+			ctx_headers := func() *fasthttp.RequestHeader {
+				h := fasthttp.RequestHeader{}
+				for k, v := range tt.headers {
+					h.Add(k, v)
+				}
+				return &h
+			}()
+
+			ctx_request := fasthttp.Request{
+				Header: *ctx_headers,
 			}
-			
-			// Set the body and other request properties
-			reqCtx.Request.SetBody([]byte(tt.body))
-			reqCtx.Request.SetRequestURI(tt.path)
-			reqCtx.Request.Header.SetMethod("POST")
-			
-			// Create fiber context with the request context
-			ctx := suite.app.AcquireCtx(reqCtx)
+			ctx_request.SetBody([]byte(tt.body))
+			ctx_request.SetRequestURI(tt.path)
+			ctx_request.Header.SetMethod("POST")
+			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{
+				Request: ctx_request,
+			})
 			res := parseGraphQLQuery(ctx)
 			assert.NotNil(ctx, "Fiber context is nil", tt.name)
 			err := proxyTheRequest(ctx, res.activeEndpoint)
@@ -110,126 +92,6 @@ 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,82 +2,89 @@ 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          time.Duration `json:"interval"`
-	Req               int           `json:"req"`
+	Interval          string `json:"interval"`
+	Req               int    `json:"req"`
 }
 
-var (
-	rateLimits  = make(map[string]RateLimitConfig)
-	rateLimitMu sync.RWMutex
-)
+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,
+}
 
-// 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 {
-		if err := loadConfigFromPath(path); err == nil {
+		err := loadConfigFromPath(path)
+		if err == nil {
 			return nil
 		}
-	}
-	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.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
 	}
 
-	var config struct {
+	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)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	config := struct {
 		RateLimit map[string]RateLimitConfig `json:"ratelimit"`
-	}
+	}{}
 
-	if err := json.Unmarshal(file, &config); err != nil {
+	decoder := json.NewDecoder(file)
+	if err := decoder.Decode(&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: value.Interval,
+			Interval: time.Duration(value.Req) * ratelimit_intervals[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_used": value.Interval,
-					"ratelimit":     value.Req,
+					"role":              key,
+					"interval_provided": value.Interval,
+					"interval_used":     ratelimit_intervals[value.Interval],
+					"ratelimit":         value.Req,
 				},
 			})
 		}
-		newRateLimits[key] = value
+		config.RateLimit[key] = value
 	}
 
-	rateLimitMu.Lock()
-	rateLimits = newRateLimits
-	rateLimitMu.Unlock()
-
+	rateLimits = config.RateLimit
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Rate limit config loaded",
 		Pairs:   map[string]interface{}{"ratelimit": rateLimits},
@@ -85,15 +92,28 @@ func loadConfigFromPath(path string) error {
 	return nil
 }
 
-// rateLimitedRequest checks if a request should be rate-limited
-func rateLimitedRequest(userID, userRole string) bool {
-	rateLimitMu.RLock()
-	roleConfig, ok := rateLimits[userRole]
-	rateLimitMu.RUnlock()
-
-	if !ok || roleConfig.RateCounterTicker == nil {
+func rateLimitedRequest(userID string, userRole string) (shouldAllow bool) {
+	if rateLimits == nil {
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Rate limit role not found or ticker not initialized",
+			Message: "Rate limit config not found",
+			Pairs:   map[string]interface{}{"user_role": userRole},
+		})
+		return true
+	}
+
+	// Fetch role config once to avoid multiple map lookups
+	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
+	}
+
+	if roleConfig.RateCounterTicker == nil {
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Rate limit ticker not found",
 			Pairs:   map[string]interface{}{"user_role": userRole},
 		})
 		return true

ratelimit_test.go

@@ -1,194 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/goccy/go-json"
-	goratecounter "github.com/lukaszraczylo/go-ratecounter"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-func (suite *Tests) Test_loadRatelimitConfig() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-
-	// Create a temporary test ratelimit.json file
-	tempDir := os.TempDir()
-	testConfigPath := filepath.Join(tempDir, "test_ratelimit.json")
-
-	testConfig := struct {
-		RateLimit map[string]RateLimitConfig `json:"ratelimit"`
-	}{
-		RateLimit: map[string]RateLimitConfig{
-			"admin": {
-				Interval: 1 * time.Second,
-				Req:      100,
-			},
-			"user": {
-				Interval: 1 * time.Second,
-				Req:      10,
-			},
-		},
-	}
-
-	configData, err := json.Marshal(testConfig)
-	assert.NoError(err)
-
-	err = os.WriteFile(testConfigPath, configData, 0644)
-	assert.NoError(err)
-	defer os.Remove(testConfigPath)
-
-	// Test loading config from custom path
-	suite.Run("load from custom path", func() {
-		// Clear existing rate limits
-		rateLimitMu.Lock()
-		rateLimits = make(map[string]RateLimitConfig)
-		rateLimitMu.Unlock()
-
-		err := loadConfigFromPath(testConfigPath)
-		assert.NoError(err)
-
-		// Verify rate limits were loaded
-		rateLimitMu.RLock()
-		defer rateLimitMu.RUnlock()
-
-		assert.Equal(2, len(rateLimits))
-		assert.Contains(rateLimits, "admin")
-		assert.Contains(rateLimits, "user")
-		assert.Equal(100, rateLimits["admin"].Req)
-		assert.Equal(10, rateLimits["user"].Req)
-		assert.NotNil(rateLimits["admin"].RateCounterTicker)
-		assert.NotNil(rateLimits["user"].RateCounterTicker)
-	})
-
-	// Test loading config from non-existent path
-	suite.Run("load from non-existent path", func() {
-		err := loadConfigFromPath("/non/existent/path.json")
-		assert.Error(err)
-	})
-
-	// Test loading config with invalid JSON
-	suite.Run("load invalid JSON", func() {
-		invalidPath := filepath.Join(tempDir, "invalid_ratelimit.json")
-		err := os.WriteFile(invalidPath, []byte("{invalid json}"), 0644)
-		assert.NoError(err)
-		defer os.Remove(invalidPath)
-
-		err = loadConfigFromPath(invalidPath)
-		assert.Error(err)
-	})
-
-	// Test with a temporary ratelimit.json file in the current directory
-	suite.Run("load from current directory", func() {
-		// Create a temporary ratelimit.json in current directory
-		currentDirPath := "./ratelimit.json"
-		err := os.WriteFile(currentDirPath, configData, 0644)
-		assert.NoError(err)
-		defer os.Remove(currentDirPath)
-
-		// Clear existing rate limits
-		rateLimitMu.Lock()
-		rateLimits = make(map[string]RateLimitConfig)
-		rateLimitMu.Unlock()
-
-		// This should find the file in the current directory
-		err = loadRatelimitConfig()
-		assert.NoError(err)
-
-		// Verify rate limits were loaded
-		rateLimitMu.RLock()
-		defer rateLimitMu.RUnlock()
-
-		assert.Equal(2, len(rateLimits))
-	})
-
-	// Test with all files missing
-	suite.Run("all files missing", func() {
-		// Save the original file if it exists
-		currentDirPath := "./ratelimit.json"
-		_, originalExists := os.Stat(currentDirPath)
-		var originalData []byte
-		if originalExists == nil {
-			originalData, _ = os.ReadFile(currentDirPath)
-			os.Remove(currentDirPath)
-		}
-		defer func() {
-			if originalExists == nil {
-				os.WriteFile(currentDirPath, originalData, 0644)
-			}
-		}()
-
-		// Clear existing rate limits
-		rateLimitMu.Lock()
-		rateLimits = make(map[string]RateLimitConfig)
-		rateLimitMu.Unlock()
-
-		// This should fail as all files are missing
-		err = loadRatelimitConfig()
-		assert.Error(err)
-		assert.Equal(os.ErrNotExist, err)
-	})
-}
-
-func (suite *Tests) Test_rateLimitedRequest() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-
-	// Create test rate limits
-	rateLimitMu.Lock()
-	rateLimits = make(map[string]RateLimitConfig)
-
-	// Admin role with high limit
-	adminCounter := goratecounter.NewRateCounter().WithConfig(goratecounter.RateCounterConfig{
-		Interval: 1 * time.Second,
-	})
-	rateLimits["admin"] = RateLimitConfig{
-		RateCounterTicker: adminCounter,
-		Interval:          1 * time.Second,
-		Req:               100,
-	}
-
-	// User role with low limit
-	userCounter := goratecounter.NewRateCounter().WithConfig(goratecounter.RateCounterConfig{
-		Interval: 1 * time.Second,
-	})
-	rateLimits["user"] = RateLimitConfig{
-		RateCounterTicker: userCounter,
-		Interval:          1 * time.Second,
-		Req:               2, // Set very low for testing
-	}
-	rateLimitMu.Unlock()
-
-	// Test non-existent role
-	suite.Run("non-existent role", func() {
-		allowed := rateLimitedRequest("test-user-1", "non-existent-role")
-		assert.True(allowed, "Unknown roles should return true")
-	})
-
-	// Test admin role (high limit)
-	suite.Run("admin role within limit", func() {
-		allowed := rateLimitedRequest("admin-user", "admin")
-		assert.True(allowed, "Admin should be within rate limit")
-	})
-
-	// Test user role (low limit)
-	suite.Run("user role within limit", func() {
-		// First request should be allowed
-		allowed := rateLimitedRequest("regular-user", "user")
-		assert.True(allowed, "First request should be within rate limit")
-
-		// Second request should be allowed
-		allowed = rateLimitedRequest("regular-user", "user")
-		assert.True(allowed, "Second request should be within rate limit")
-
-		// Third request should exceed limit
-		allowed = rateLimitedRequest("regular-user", "user")
-		assert.False(allowed, "Third request should exceed rate limit")
-	})
-}

server.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"strconv"
 	"time"
@@ -14,34 +15,30 @@ import (
 	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
+	libpack_trace "github.com/lukaszraczylo/graphql-monitoring-proxy/tracing"
 )
 
-const (
-	healthCheckQueryStr = `{ __typename }`
-)
-
-// StartHTTPProxy initializes and starts the HTTP proxy server.
+// StartHTTPProxy starts the HTTP and points it to the GraphQL server.
 func StartHTTPProxy() {
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Starting the HTTP proxy",
+		Pairs:   nil,
 	})
-
-	serverConfig := fiber.Config{
+	server := fiber.New(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,
-		ReadTimeout:           time.Duration(cfg.Client.ClientTimeout) * time.Second,
-		WriteTimeout:          time.Duration(cfg.Client.ClientTimeout) * time.Second,
+		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,
 		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)
@@ -54,192 +51,226 @@ func StartHTTPProxy() {
 		Message: "GraphQL proxy started",
 		Pairs:   map[string]interface{}{"port": cfg.Server.PortGraphQL},
 	})
-
-	if err := server.Listen(fmt.Sprintf(":%d", cfg.Server.PortGraphQL)); err != nil {
+	err := server.Listen(fmt.Sprintf(":%d", cfg.Server.PortGraphQL))
+	if err != nil {
 		cfg.Logger.Critical(&libpack_logger.LogMessage{
 			Message: "Can't start the service",
-			Pairs:   map[string]interface{}{"port": cfg.Server.PortGraphQL, "error": err.Error()},
+			Pairs:   map[string]interface{}{"port": cfg.Server.PortGraphQL},
 		})
 	}
 }
 
-// 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
 	}
-	path := c.OriginalURL()
-	_, ok := allowedUrls[path]
+	_, ok := allowedUrls[c.Path()]
 	return ok
 }
 
-// healthCheck performs a health check on the GraphQL server.
+func extractTraceHeaders(c *fiber.Ctx) (found bool, traceHeaders map[string]string) {
+	if !cfg.Trace.Enable {
+		return
+	}
+	headers := c.Request().Header
+	traceHeader := headers.Peek("X-Trace-Span")
+	if traceHeader != nil {
+		traceHeaders = make(map[string]string)
+		if err := json.Unmarshal(traceHeader, &traceHeaders); err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Error unmarshalling tracer header",
+				Pairs:   map[string]interface{}{"error": err},
+			})
+			return
+		}
+		found = true
+	}
+	return
+}
+
 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},
 		})
-
-		_, err := cfg.Client.GQLClient.Query(healthCheckQueryStr, nil, nil)
+		query := `{ __typename }`
+		_, err := cfg.Client.GQLClient.Query(query, 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)
-			return c.Status(fiber.StatusInternalServerError).SendString("Can't reach the GraphQL server with {__typename} query")
+			c.Status(500).SendString("Can't reach the GraphQL server with {__typename} query")
+			return err
 		}
 	}
-
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Health check returning OK",
+		Pairs:   nil,
 	})
-	return c.Status(fiber.StatusOK).SendString("Health check OK")
-}
-
-// processGraphQLRequest handles the incoming GraphQL requests.
-// processGraphQLRequest handles the incoming GraphQL requests.
-func processGraphQLRequest(c *fiber.Ctx) error {
-	startTime := time.Now()
-
-	// Extract user information and check permissions
-	extractedUserID, extractedRoleName := extractUserInfo(c)
-
-	// Check if user is banned
-	if checkIfUserIsBanned(c, extractedUserID) {
-		return c.Status(fiber.StatusForbidden).SendString("User is banned")
-	}
-
-	// Apply rate limiting if enabled
-	if cfg.Client.RoleRateLimit && !rateLimitedRequest(extractedUserID, extractedRoleName) {
-		return c.Status(fiber.StatusTooManyRequests).SendString("Rate limit exceeded, try again later")
-	}
-
-	// Parse the GraphQL query
-	parsedResult := parseGraphQLQuery(c)
-	if parsedResult.shouldBlock {
-		return c.Status(fiber.StatusForbidden).SendString("Request blocked")
-	}
-
-	// Handle non-GraphQL requests
-	if parsedResult.shouldIgnore {
-		return proxyTheRequest(c, parsedResult.activeEndpoint)
-	}
-
-	// Handle caching
-	wasCached, err := handleCaching(c, parsedResult, extractedUserID)
-	if err != nil {
-		return err
-	}
-
-	// Log and monitor the request
-	logAndMonitorRequest(c, extractedUserID, parsedResult.operationType, parsedResult.operationName, wasCached, time.Since(startTime), startTime)
-
+	c.Status(200).SendString("Health check OK")
 	return nil
 }
 
-// extractUserInfo extracts user ID and role from request headers
-func extractUserInfo(c *fiber.Ctx) (string, string) {
-	extractedUserID := "-"
-	extractedRoleName := "-"
+func processGraphQLRequest(c *fiber.Ctx) error {
+	startTime := time.Now()
 
-	// Extract from JWT if available
-	if authorization := c.Get("Authorization"); authorization != "" &&
-		(len(cfg.Client.JWTUserClaimPath) > 0 || len(cfg.Client.JWTRoleClaimPath) > 0) {
-		extractedUserID, extractedRoleName = extractClaimsFromJWTHeader(authorization)
+	// Initialize variables with default values
+	extractedUserID, extractedRoleName := "-", "-"
+
+	// Pre-fetch headers and trace header processing
+	headers := c.Request().Header
+	authorization := headers.Peek("Authorization")
+	ctx := context.Background()
+	traceHeaderFound, traceHeader := extractTraceHeaders(c)
+
+	if traceHeaderFound {
+		ctx = libpack_trace.TraceContextExtract(ctx, traceHeader)
+		_, span := libpack_trace.ContinueSpanFromContext(ctx, "GraphQLRequest")
+		defer span.End()
 	}
 
-	// Override role from header if configured
-	if cfg.Client.RoleFromHeader != "" {
-		if role := c.Get(cfg.Client.RoleFromHeader); role != "" {
-			extractedRoleName = role
+	// JWT and role extraction with pre-check
+	if authorization != nil && (len(cfg.Client.JWTUserClaimPath) > 0 || len(cfg.Client.JWTRoleClaimPath) > 0) {
+		extractedUserID, extractedRoleName = extractClaimsFromJWTHeader(string(authorization))
+	}
+
+	// Check for banned users early
+	if checkIfUserIsBanned(c, extractedUserID) {
+		return c.Status(403).SendString("User is banned")
+	}
+
+	// Role extraction from header
+	if len(cfg.Client.RoleFromHeader) > 0 {
+		extractedRoleName = string(headers.Peek(cfg.Client.RoleFromHeader))
+		if extractedRoleName == "" {
+			extractedRoleName = "-"
 		}
 	}
 
-	return extractedUserID, extractedRoleName
-}
+	// Rate limiting check
+	if cfg.Client.RoleRateLimit && !rateLimitedRequest(extractedUserID, extractedRoleName) {
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Rate limiting enabled",
+			Pairs:   map[string]interface{}{"user_id": extractedUserID, "role_name": extractedRoleName},
+		})
+		return c.Status(429).SendString("Rate limit exceeded, try again later")
+	}
 
-// handleCaching manages the caching logic for GraphQL requests
-func handleCaching(c *fiber.Ctx, parsedResult *parseGraphQLQueryResult, userID string) (bool, error) {
-	// Calculate query hash for cache key
-	calculatedQueryHash := libpack_cache.CalculateHash(c)
-
-	// Set cache time from header or default
+	// Parsing GraphQL query
+	parsedResult := parseGraphQLQuery(c)
+	if parsedResult.shouldBlock {
+		return c.Status(403).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, ctx)
+	}
+	// Cache handling logic
+	queryCacheHash := libpack_cache.CalculateHash(c)
 	if parsedResult.cacheTime == 0 {
-		if cacheQuery := c.Get("X-Cache-Graphql-Query"); cacheQuery != "" {
-			parsedResult.cacheTime, _ = strconv.Atoi(cacheQuery)
+		cacheQuery := headers.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},
+			})
 		} else {
 			parsedResult.cacheTime = cfg.Cache.CacheTTL
 		}
 	}
 
-	// Handle cache refresh directive
 	if parsedResult.cacheRefresh {
-		libpack_cache.CacheDelete(calculatedQueryHash)
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Cache refresh requested via query",
+			Pairs:   map[string]interface{}{"user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")},
+		})
+		libpack_cache.CacheDelete(queryCacheHash)
 	}
 
-	// Check if caching is enabled
-	cacheEnabled := parsedResult.cacheRequest || cfg.Cache.CacheEnable || cfg.Cache.CacheRedisEnable
-	if !cacheEnabled {
-		// No caching, just proxy the request
-		if err := proxyTheRequest(c, parsedResult.activeEndpoint); err != nil {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-			return false, c.Status(fiber.StatusInternalServerError).SendString("Can't proxy the request - try again later")
+	wasCached := false
+	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},
+		})
+		if cachedResponse := libpack_cache.CacheLookup(queryCacheHash); 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")},
+			})
+			headers.Add("X-Cache-Hit", "true")
+			if err := c.Send(cachedResponse); 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)
+				return c.Status(500).SendString("Can't send the cached response - try again later")
+			}
+			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, ctx)
+		}
+	} else {
+		if err := proxyTheRequest(c, parsedResult.activeEndpoint, ctx); 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)
+			return c.Status(500).SendString("Can't proxy the request - try again later")
 		}
-		return false, nil
 	}
 
-	// Try to get from cache
-	if cachedResponse := libpack_cache.CacheLookup(calculatedQueryHash); cachedResponse != nil {
-		cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheHit, nil)
-		c.Set("X-Cache-Hit", "true")
-		c.Set("Content-Type", "application/json")
-		return true, c.Send(cachedResponse)
-	}
-
-	// Cache miss, proxy and cache
-	cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheMiss, nil)
-	if err := proxyAndCacheTheRequest(c, calculatedQueryHash, parsedResult.cacheTime, parsedResult.activeEndpoint); err != nil {
-		return false, err
-	}
-
-	return false, nil
+	timeTaken := time.Since(startTime)
+	logAndMonitorRequest(c, extractedUserID, parsedResult.operationType, parsedResult.operationName, wasCached, timeTaken, startTime)
+	return 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 {
+// Additional helper function to avoid code repetition
+func proxyAndCacheTheRequest(c *fiber.Ctx, queryCacheHash string, cacheTime int, currentEndpoint string, ctx context.Context) {
+	err := proxyTheRequest(c, currentEndpoint, ctx)
+	if 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)
-		return c.Status(fiber.StatusInternalServerError).SendString("Can't proxy the request - try again later")
+		c.Status(500).SendString("Can't proxy the request - try again later")
+		return
 	}
-
 	libpack_cache.CacheStoreWithTTL(queryCacheHash, c.Response().Body(), time.Duration(cacheTime)*time.Second)
 	cfg.Monitoring.Increment(libpack_monitoring.MetricsQueriesCached, nil)
-	return c.Send(c.Response().Body())
+	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":  strconv.FormatBool(wasCached),
+		"cached":  fmt.Sprintf("%t", wasCached),
 		"user_id": userID,
 	}
 
@@ -248,7 +279,7 @@ func logAndMonitorRequest(c *fiber.Ctx, userID, opType, opName string, wasCached
 			Message: "Request processed",
 			Pairs: map[string]interface{}{
 				"ip":           c.IP(),
-				"fwd-ip":       c.Get("X-Forwarded-For"),
+				"fwd-ip":       string(c.Request().Header.Peek("X-Forwarded-For")),
 				"user_id":      userID,
 				"op_type":      opType,
 				"op_name":      opName,

struct_config.go

@@ -9,15 +9,16 @@ import (
 
 // config is a struct that holds the configuration of the application.
 type config struct {
+	Trace struct {
+		Client        func()
+		TraceEndpoint string
+		Enable        bool
+	}
 	Logger     *libpack_logging.Logger
 	LogLevel   string
 	Monitoring *libpack_monitoring.MetricsSetup
-	Tracing    struct {
-		Enable   bool
-		Endpoint string
-	}
-	Api    struct{ BannedUsersFile string }
-	Client struct {
+	Api        struct{ BannedUsersFile string }
+	Client     struct {
 		GQLClient        *graphql.BaseClient
 		FastProxyClient  *fasthttp.Client
 		JWTUserClaimPath string

tracing/tracing.go

@@ -1,171 +1,98 @@
-package tracing
+package libpack_trace
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"time"
 
+	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
+	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
 	"go.opentelemetry.io/otel/propagation"
 	"go.opentelemetry.io/otel/sdk/resource"
-	sdktrace "go.opentelemetry.io/otel/sdk/trace"
-	semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
-	"go.opentelemetry.io/otel/trace"
-	"google.golang.org/grpc"
+	"go.opentelemetry.io/otel/sdk/trace"
+	oteltrace "go.opentelemetry.io/otel/trace"
+
+	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
 )
 
-type TracingSetup struct {
-	tracerProvider *sdktrace.TracerProvider
-	tracer         trace.Tracer
-}
+func NewClient(log *libpack_logging.Logger, otelGRPCCollector string, attr ...attribute.KeyValue) (func(), error) {
+	attr = append(attr, semconv.ServiceNameKey.String(libpack_config.PKG_NAME))
+	fmt.Printf("Starting OpenTelemetry tracer: otlp, configured with endpoint: %s\n", otelGRPCCollector)
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
 
-type TraceSpanInfo struct {
-	TraceParent string `json:"traceparent"`
-}
-
-// NewTracing creates a new tracing setup with OTLP exporter
-func NewTracing(ctx context.Context, endpoint string) (*TracingSetup, error) {
-	if ctx == nil {
-		return nil, fmt.Errorf("context cannot be nil")
-	}
-	if endpoint == "" {
-		return nil, fmt.Errorf("endpoint cannot be empty")
-	}
-
-	// Validate endpoint format
-	// A simple validation to check if the endpoint has a reasonable format
-	// We're looking for hostname:port where port is a valid port number (0-65535)
-	var host string
-	var port int
-	if n, err := fmt.Sscanf(endpoint, "%s:%d", &host, &port); err != nil || n != 2 {
-		return nil, fmt.Errorf("invalid endpoint format: must be 'hostname:port'")
-	}
-	if port < 0 || port > 65535 {
-		return nil, fmt.Errorf("invalid port number: must be between 0 and 65535")
-	}
-
-	// Create the exporter directly with the endpoint
-	exporter, err := otlptracegrpc.New(ctx,
-		otlptracegrpc.WithEndpoint(endpoint),
+	client := otlptracegrpc.NewClient(
 		otlptracegrpc.WithInsecure(),
-		otlptracegrpc.WithTimeout(5*time.Second),
-		otlptracegrpc.WithDialOption(grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(16*1024*1024))), // 16MB max message size
+		otlptracegrpc.WithEndpoint(otelGRPCCollector),
 	)
+
+	exporter, err := otlptrace.New(ctx, client)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create trace exporter: %w", err)
+		log.Error(&libpack_logging.LogMessage{
+			Message: "Failed to create exporter",
+			Pairs:   map[string]interface{}{"error": err},
+		})
+		return nil, err
 	}
 
-	// Create a resource with more detailed attributes
-	res, err := resource.New(ctx,
-		resource.WithAttributes(
-			semconv.ServiceName("graphql-monitoring-proxy"),
-			semconv.ServiceVersion("1.0"),
-			semconv.DeploymentEnvironment("production"),
-			attribute.String("application.type", "proxy"),
-		),
-		resource.WithHost(),       // Add host information
-		resource.WithOSType(),     // Add OS information
-		resource.WithProcessPID(), // Add process information
-	)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create resource: %w", err)
-	}
-
-	// Create the tracer provider with improved configuration
-	tracerProvider := sdktrace.NewTracerProvider(
-		sdktrace.WithBatcher(exporter,
-			// Configure batch processing
-			sdktrace.WithMaxExportBatchSize(512),
-			sdktrace.WithBatchTimeout(3*time.Second),
-			sdktrace.WithMaxQueueSize(2048),
-		),
-		sdktrace.WithResource(res),
-		sdktrace.WithSampler(sdktrace.TraceIDRatioBased(0.1)), // Sample 10% of traces
+	tp := trace.NewTracerProvider(
+		trace.WithSampler(trace.AlwaysSample()),
+		trace.WithBatcher(exporter, trace.WithMaxExportBatchSize(1), trace.WithBatchTimeout(30*time.Second)),
+		trace.WithResource(resource.NewWithAttributes(semconv.SchemaURL, attr...)),
 	)
 
-	// Set the global tracer provider and propagator
-	otel.SetTracerProvider(tracerProvider)
-	otel.SetTextMapPropagator(propagation.TraceContext{})
+	otel.SetTracerProvider(tp)
+	otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
 
-	// Create a tracer
-	tracer := tracerProvider.Tracer("graphql-monitoring-proxy")
+	shutdownFunc := func() {
+		shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer shutdownCancel()
+		log.Info(&libpack_logging.LogMessage{
+			Message: "Shutting down tracer",
+			Pairs:   nil,
+		})
+		if err := tp.Shutdown(shutdownCtx); err != nil {
+			log.Warning(&libpack_logging.LogMessage{
+				Message: "Failed to shutdown tracer provider",
+				Pairs:   map[string]interface{}{"error": err},
+			})
+		}
+	}
 
-	return &TracingSetup{
-		tracerProvider: tracerProvider,
-		tracer:         tracer,
-	}, nil
+	return shutdownFunc, nil
 }
 
-// ExtractSpanContext extracts span context from TraceSpanInfo
-func (ts *TracingSetup) ExtractSpanContext(spanInfo *TraceSpanInfo) (trace.SpanContext, error) {
-	carrier := propagation.MapCarrier{
-		"traceparent": spanInfo.TraceParent,
-	}
-	ctx := context.Background()
-	ctx = otel.GetTextMapPropagator().Extract(ctx, carrier)
-	spanCtx := trace.SpanContextFromContext(ctx)
-	if !spanCtx.IsValid() {
-		return trace.SpanContext{}, fmt.Errorf("invalid span context")
-	}
-	return spanCtx, nil
+func TraceContextInject(ctx context.Context) map[string]string {
+	carrier := propagation.MapCarrier{}
+	propagator := otel.GetTextMapPropagator()
+	propagator.Inject(ctx, carrier)
+	return map[string]string(carrier)
 }
 
-// ParseTraceHeader parses X-Trace-Span header content
-func ParseTraceHeader(headerContent string) (*TraceSpanInfo, error) {
-	var spanInfo TraceSpanInfo
-	if err := json.Unmarshal([]byte(headerContent), &spanInfo); err != nil {
-		return nil, fmt.Errorf("failed to parse trace header: %w", err)
-	}
-	return &spanInfo, nil
+func TraceContextExtract(ctx context.Context, traceContext map[string]string) context.Context {
+	carrier := propagation.MapCarrier(traceContext)
+	propagator := otel.GetTextMapPropagator()
+	return propagator.Extract(ctx, carrier)
 }
 
-// Shutdown cleanly shuts down the tracer provider
-func (ts *TracingSetup) Shutdown(ctx context.Context) error {
-	if ts.tracerProvider == nil {
-		return nil
-	}
-	return ts.tracerProvider.Shutdown(ctx)
+func StartSpanFromContext(ctx context.Context, operationName string) (context.Context, oteltrace.Span) {
+	tr := otel.GetTracerProvider().Tracer("")
+	return tr.Start(ctx, operationName, oteltrace.WithSpanKind(oteltrace.SpanKindServer))
 }
 
-// StartSpan starts a new span with the given name and parent context
-func (ts *TracingSetup) StartSpan(ctx context.Context, name string) (trace.Span, context.Context) {
-	if ts == nil || ts.tracer == nil {
-		// Return a no-op span if tracing is not configured
-		return trace.SpanFromContext(ctx), ctx
+func ContinueSpanFromContext(ctx context.Context, operationName string) (context.Context, oteltrace.Span) {
+	tr := otel.GetTracerProvider().Tracer("")
+	options := []oteltrace.SpanStartOption{
+		oteltrace.WithSpanKind(oteltrace.SpanKindInternal),
+		oteltrace.WithAttributes(attribute.String("cont", "true")),
 	}
-
-	// Add common attributes to all spans
-	opts := []trace.SpanStartOption{
-		trace.WithAttributes(
-			semconv.ServiceName("graphql-monitoring-proxy"),
-			semconv.ServiceVersion("1.0"),
-		),
-	}
-
-	ctx, span := ts.tracer.Start(ctx, name, opts...)
-	return span, ctx
+	return tr.Start(ctx, operationName, options...)
 }
 
-// StartSpanWithAttributes starts a new span with custom attributes
-func (ts *TracingSetup) StartSpanWithAttributes(ctx context.Context, name string, attrs map[string]string) (trace.Span, context.Context) {
-	if ts == nil || ts.tracer == nil {
-		return trace.SpanFromContext(ctx), ctx
-	}
-
-	// Convert string attributes to KeyValue pairs
-	attributes := make([]attribute.KeyValue, 0, len(attrs)+2)
-	attributes = append(attributes,
-		semconv.ServiceName("graphql-monitoring-proxy"),
-		semconv.ServiceVersion("1.0"),
-	)
-
-	for k, v := range attrs {
-		attributes = append(attributes, attribute.String(k, v))
-	}
-
-	ctx, span := ts.tracer.Start(ctx, name, trace.WithAttributes(attributes...))
-	return span, ctx
+func AddAttributesToSpan(span oteltrace.Span, attributes ...attribute.KeyValue) {
+	span.SetAttributes(attributes...)
 }

tracing/tracing_additional_test.go

@@ -1,167 +0,0 @@
-package tracing
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/trace"
-	"go.opentelemetry.io/otel/trace/noop"
-)
-
-func TestStartSpanWithAttributes(t *testing.T) {
-	// Create a minimal tracing setup without actual connection
-	ts := &TracingSetup{
-		tracer: noop.NewTracerProvider().Tracer("test"),
-	}
-
-	// Test with attributes
-	t.Run("with attributes", func(t *testing.T) {
-		ctx := context.Background()
-		attrs := map[string]string{
-			"key1": "value1",
-			"key2": "value2",
-		}
-
-		span, newCtx := ts.StartSpanWithAttributes(ctx, "test-span", attrs)
-		assert.NotNil(t, span)
-		assert.NotNil(t, newCtx)
-
-		// We can't easily test the attributes were set since it's a noop tracer,
-		// but we can verify the function doesn't panic
-		span.End()
-	})
-
-	// Test with nil attributes
-	t.Run("with nil attributes", func(t *testing.T) {
-		ctx := context.Background()
-
-		span, newCtx := ts.StartSpanWithAttributes(ctx, "test-span", nil)
-		assert.NotNil(t, span)
-		assert.NotNil(t, newCtx)
-		span.End()
-	})
-
-	// Test with nil tracer
-	t.Run("with nil tracer", func(t *testing.T) {
-		ctx := context.Background()
-		nilTS := &TracingSetup{tracer: nil}
-
-		span, newCtx := nilTS.StartSpanWithAttributes(ctx, "test-span", map[string]string{"key": "value"})
-		assert.NotNil(t, span)
-		assert.NotNil(t, newCtx)
-		// Should not panic when ending the span
-		span.End()
-	})
-}
-
-func TestNewTracingWithInvalidEndpoint(t *testing.T) {
-	// Skip endpoint tests that are already covered in the main test file
-	t.Run("invalid endpoint format", func(t *testing.T) {
-		t.Skip("This test is now handled in the main test file")
-	})
-
-	// Skip the unreachable endpoint test as it's flaky and already tested
-	t.Run("unreachable endpoint", func(t *testing.T) {
-		t.Skip("This test is now handled in the main test file")
-	})
-}
-
-func TestTracingSetupWithMockTracer(t *testing.T) {
-	// Create a mock tracer provider
-	mockTracerProvider := noop.NewTracerProvider()
-	mockTracer := mockTracerProvider.Tracer("mock-tracer")
-
-	ts := &TracingSetup{
-		tracerProvider: nil, // We don't need the provider for these tests
-		tracer:         mockTracer,
-	}
-
-	// Test StartSpan
-	t.Run("start span", func(t *testing.T) {
-		ctx := context.Background()
-		span, newCtx := ts.StartSpan(ctx, "test-span")
-
-		assert.NotNil(t, span)
-		assert.NotNil(t, newCtx)
-
-		// Add some attributes and events to ensure no panics
-		span.SetAttributes(attribute.String("test", "value"))
-		span.AddEvent("test-event")
-
-		// End the span
-		span.End()
-	})
-
-	// Test StartSpanWithAttributes
-	t.Run("start span with attributes", func(t *testing.T) {
-		ctx := context.Background()
-		attrs := map[string]string{
-			"service": "test-service",
-			"version": "1.0.0",
-		}
-
-		span, newCtx := ts.StartSpanWithAttributes(ctx, "test-span-with-attrs", attrs)
-
-		assert.NotNil(t, span)
-		assert.NotNil(t, newCtx)
-
-		// End the span
-		span.End()
-	})
-}
-
-func TestShutdownWithNilProvider(t *testing.T) {
-	ts := &TracingSetup{
-		tracerProvider: nil,
-		tracer:         noop.NewTracerProvider().Tracer("test"),
-	}
-
-	ctx := context.Background()
-	err := ts.Shutdown(ctx)
-
-	assert.NoError(t, err)
-}
-
-func TestExtractSpanContextWithInvalidTraceParent(t *testing.T) {
-	ts := &TracingSetup{
-		tracer: noop.NewTracerProvider().Tracer("test"),
-	}
-
-	// Test with invalid traceparent format
-	t.Run("invalid traceparent format", func(t *testing.T) {
-		spanInfo := &TraceSpanInfo{
-			TraceParent: "invalid-format",
-		}
-
-		// Explicitly type the result to use trace package
-		var spanCtx trace.SpanContext
-		var err error
-		spanCtx, err = ts.ExtractSpanContext(spanInfo)
-
-		assert.Error(t, err)
-		assert.Contains(t, err.Error(), "invalid span context")
-		assert.False(t, spanCtx.IsValid())
-	})
-}
-
-func TestParseTraceHeaderWithEmptyHeader(t *testing.T) {
-	// Test with empty header
-	t.Run("empty header", func(t *testing.T) {
-		_, err := ParseTraceHeader("")
-		assert.Error(t, err)
-	})
-
-	// Test with invalid JSON
-	t.Run("invalid JSON", func(t *testing.T) {
-		_, err := ParseTraceHeader("{invalid json}")
-		assert.Error(t, err)
-	})
-
-	// Test with valid JSON but missing traceparent
-	t.Run("missing traceparent", func(t *testing.T) {
-		_, err := ParseTraceHeader(`{"other": "value"}`)
-		assert.NoError(t, err) // This should parse but the traceparent will be empty
-	})
-}

tracing/tracing_test.go

@@ -1,104 +1,109 @@
-package tracing
+package libpack_trace
 
 import (
-	"context"
-	"encoding/json"
 	"testing"
 
+	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
+
 	"github.com/stretchr/testify/assert"
-	"go.opentelemetry.io/otel/trace"
+	"github.com/stretchr/testify/suite"
 )
 
-func TestParseTraceHeader(t *testing.T) {
-	tests := []struct {
-		name    string
-		header  string
-		want    *TraceSpanInfo
-		wantErr bool
-	}{
-		{
-			name:   "valid trace header",
-			header: `{"traceparent": "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"}`,
-			want: &TraceSpanInfo{
-				TraceParent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
-			},
-			wantErr: false,
-		},
-		{
-			name:    "invalid json",
-			header:  `{"traceparent": invalid}`,
-			want:    nil,
-			wantErr: true,
-		},
-		{
-			name:    "empty header",
-			header:  "",
-			want:    nil,
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := ParseTraceHeader(tt.header)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ParseTraceHeader() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr {
-				gotJSON, _ := json.Marshal(got)
-				wantJSON, _ := json.Marshal(tt.want)
-				if string(gotJSON) != string(wantJSON) {
-					t.Errorf("ParseTraceHeader() = %v, want %v", string(gotJSON), string(wantJSON))
-				}
-			}
-		})
-	}
+type TraceTestSuite struct {
+	suite.Suite
+	logger *libpack_logging.Logger
 }
 
-func TestNewTracing(t *testing.T) {
-	// Skip actual connection tests since they require a running collector
-	t.Run("empty endpoint", func(t *testing.T) {
-		ctx := context.Background()
-		_, err := NewTracing(ctx, "")
-		assert.Error(t, err, "Expected error for empty endpoint")
-		assert.Contains(t, err.Error(), "endpoint cannot be empty")
-	})
-
-	t.Run("invalid endpoint", func(t *testing.T) {
-		// We'll use a more severe syntax error in the endpoint to trigger a validation error
-		ctx := context.Background()
-		// Use a port that exceeds the maximum valid port number
-		_, err := NewTracing(ctx, "localhost:999999")
-		assert.Error(t, err, "Expected error for invalid endpoint format")
-	})
+func (suite *TraceTestSuite) SetupTest() {
+	suite.logger = libpack_logging.New()
 }
 
-func TestTracingSetup_ExtractSpanContext(t *testing.T) {
-	ts := &TracingSetup{}
-	spanInfo := &TraceSpanInfo{
-		TraceParent: "invalid-traceparent",
-	}
-
-	_, err := ts.ExtractSpanContext(spanInfo)
-	assert.Error(t, err, "Expected error for invalid traceparent")
-	assert.Contains(t, err.Error(), "invalid span context")
+func (suite *TraceTestSuite) TearDownTest() {
+	// Any cleanup logic can be added here
 }
 
-func TestTracingSetup_StartSpan(t *testing.T) {
-	ts := &TracingSetup{}
-	ctx := context.Background()
-
-	span, newCtx := ts.StartSpan(ctx, "test-span")
-	assert.NotNil(t, span, "Expected non-nil span even when tracer is nil")
-	assert.NotNil(t, newCtx, "Expected non-nil context")
-	assert.Equal(t, trace.SpanFromContext(ctx), span, "Expected span from context when tracer is nil")
+func TestTraceTestSuite(t *testing.T) {
+	suite.Run(t, new(TraceTestSuite))
 }
 
-func TestTracingSetup_Shutdown(t *testing.T) {
-	ts := &TracingSetup{}
-	ctx := context.Background()
+func (suite *TraceTestSuite) Test_NewClient() {
+	shutdownFunc, err := NewClient(suite.logger, "localhost:4317")
+	assert.NoError(suite.T(), err)
+	assert.NotNil(suite.T(), shutdownFunc)
 
-	err := ts.Shutdown(ctx)
-	assert.NoError(t, err, "Expected no error when shutting down nil tracer provider")
+	shutdownFunc()
 }
+
+// func (suite *TraceTestSuite) Test_TraceContextInjectExtract() {
+// 	ctx := context.Background()
+// 	traceContext := TraceContextInject(ctx)
+// 	assert.NotEmpty(suite.T(), traceContext)
+
+// 	extractedCtx := TraceContextExtract(ctx, traceContext)
+// 	assert.NotNil(suite.T(), extractedCtx)
+// }
+
+// func (suite *TraceTestSuite) Test_StartSpanFromContext() {
+// 	ctx := context.Background()
+// 	ctx, span := StartSpanFromContext(ctx, "operation")
+// 	assert.NotNil(suite.T(), ctx)
+// 	assert.NotNil(suite.T(), span)
+// 	span.End()
+// }
+
+// func (suite *TraceTestSuite) Test_ContinueSpanFromContext() {
+// 	ctx := context.Background()
+// 	ctx, span := ContinueSpanFromContext(ctx, "operation")
+// 	assert.NotNil(suite.T(), ctx)
+// 	assert.NotNil(suite.T(), span)
+// 	span.End()
+// }
+
+// func (suite *TraceTestSuite) Test_AddAttributesToSpan() {
+// 	ctx := context.Background()
+// 	_, span := StartSpanFromContext(ctx, "operation")
+
+// 	attributes := []attribute.KeyValue{
+// 		attribute.String("key1", "value1"),
+// 		attribute.Int("key2", 2),
+// 	}
+// 	AddAttributesToSpan(span, attributes...)
+// 	span.End()
+
+// 	// Create an in-memory span exporter
+// 	exporter := tracetest.NewSpanRecorder()
+// 	tracerProvider := trace.NewTracerProvider(trace.WithSpanProcessor(exporter))
+// 	otel.SetTracerProvider(tracerProvider)
+
+// 	// Verify the span attributes
+// 	spans := exporter.Ended()
+// 	assert.Len(suite.T(), spans, 1)
+// 	exportedSpan := spans[0]
+
+// 	for _, attr := range attributes {
+// 		assert.Contains(suite.T(), exportedSpan.Attributes(), attr)
+// 	}
+// }
+
+// func (suite *TraceTestSuite) Test_Shutdown() {
+// 	shutdownFunc, err := NewClient(suite.logger, "localhost:4317")
+// 	assert.NoError(suite.T(), err)
+// 	assert.NotNil(suite.T(), shutdownFunc)
+
+// 	shutdownFunc()
+// 	logOutput := captureStdOut(func() { suite.logger.Info(&libpack_logging.LogMessage{Message: "Shutting down tracer"}) })
+// 	assert.Contains(suite.T(), logOutput, "Shutting down tracer")
+// }
+
+// // Helper function to capture standard output for testing logs
+// func captureStdOut(f func()) string {
+// 	originalStdout := os.Stdout
+// 	r, w, _ := os.Pipe()
+// 	os.Stdout = w
+// 	f()
+// 	w.Close()
+// 	var buf bytes.Buffer
+// 	buf.ReadFrom(r)
+// 	os.Stdout = originalStdout
+// 	return buf.String()
+// }