Add appropriate labels to the container

.gitignore

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

Dockerfile

@@ -6,3 +6,9 @@ ARG TARGETOS
 COPY --chmod=777 --chown=nonroot:nonroot static/app /go/src/app
 ADD dist/bot-$TARGETOS-$TARGETARCH /go/src/app/graphql-proxy
 ENTRYPOINT ["/go/src/app/graphql-proxy"]
+
+LABEL org.opencontainers.image.maintainer="lukasz@raczylo.com" \
+      org.opencontainers.image.authors="lukasz@raczylo.com" \
+      org.opencontainers.image.title="graphql-monitoring-proxy" \
+      org.opencontainers.image.description="GraphQL monitoring proxy" \
+      org.opencontainers.image.url="https://github.com/lukaszraczylo/graphql-monitoring-proxy"

README.md

@@ -351,3 +351,5 @@ graphql_proxy_cache_hit{microservice="graphql_proxy",pod="hasura-w-proxy-interna
 graphql_proxy_cache_hit{pod="hasura-w-proxy-internal-6b5f4b4bbb-9xwfc",microservice="graphql_proxy"} 1
 graphql_proxy_cache_miss{microservice="graphql_proxy",pod="hasura-w-proxy-internal-6b5f4b4bbb-9xwfc"} 23
 ```
+
+.

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_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/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,66 +38,32 @@ 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)
 }
 
@@ -119,25 +76,19 @@ func (c *Cache) Get(key string) ([]byte, bool) {
 	cacheEntry := entry.(CacheEntry)
 	if cacheEntry.ExpiresAt.Before(time.Now()) {
 		c.entries.Delete(key)
-		atomic.AddInt64(&c.entryCount, -1)
 		return nil, false
 	}
 
-	if cacheEntry.Compressed {
-		value, err := c.decompress(cacheEntry.Value)
-		if err != nil {
-			return nil, false
-		}
-		return value, true
+	value, err := c.decompress(cacheEntry.Value)
+	if err != nil {
+		log.Printf("Error decompressing value for key %s: %v", key, err)
+		return nil, false
 	}
-
-	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 +96,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 +126,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 +137,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 +150,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/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")
-}

events.go

@@ -23,36 +23,26 @@ var delQueries = [...]string{
 }
 
 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{
+	if cfg.HasuraEventCleaner.EventMetadataDb == "" {
+		cfg.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{
+	cfg.Logger.Info(&libpack_logger.LogMessage{
 		Message: "Event cleaner enabled",
-		Pairs:   map[string]interface{}{"interval_in_days": clearOlderThan},
+		Pairs:   map[string]interface{}{"interval_in_days": cfg.HasuraEventCleaner.ClearOlderThan},
 	})
 
-	go func(dbURL string, clearOlderThan int, logger *libpack_logger.Logger) {
-		pool, err := pgxpool.New(context.Background(), dbURL)
+	go func() {
+		pool, err := pgxpool.New(context.Background(), cfg.HasuraEventCleaner.EventMetadataDb)
 		if err != nil {
-			logger.Error(&libpack_logger.LogMessage{
+			cfg.Logger.Error(&libpack_logger.LogMessage{
 				Message: "Failed to create connection pool",
 				Pairs:   map[string]interface{}{"error": err.Error()},
 			})
@@ -62,35 +52,35 @@ func enableHasuraEventCleaner() {
 
 		time.Sleep(initialDelay)
 
-		logger.Info(&libpack_logger.LogMessage{
+		cfg.Logger.Info(&libpack_logger.LogMessage{
 			Message: "Initial cleanup of old events",
 		})
-		cleanEvents(pool, clearOlderThan, logger)
+		cleanEvents(pool)
 
 		ticker := time.NewTicker(cleanupInterval)
 		defer ticker.Stop()
 
 		for range ticker.C {
-			logger.Info(&libpack_logger.LogMessage{
+			cfg.Logger.Info(&libpack_logger.LogMessage{
 				Message: "Cleaning up old events",
 			})
-			cleanEvents(pool, clearOlderThan, logger)
+			cleanEvents(pool)
 		}
-	}(eventMetadataDb, clearOlderThan, logger)
+	}()
 }
 
-func cleanEvents(pool *pgxpool.Pool, clearOlderThan int, logger *libpack_logger.Logger) {
+func cleanEvents(pool *pgxpool.Pool) {
 	ctx := context.Background()
 	var errors []error
 	var failedQueries []string
 
 	for _, query := range delQueries {
-		_, err := pool.Exec(ctx, fmt.Sprintf(query, clearOlderThan))
+		_, err := pool.Exec(ctx, fmt.Sprintf(query, cfg.HasuraEventCleaner.ClearOlderThan))
 		if err != nil {
 			errors = append(errors, err)
 			failedQueries = append(failedQueries, query)
 		} else {
-			logger.Debug(&libpack_logger.LogMessage{
+			cfg.Logger.Debug(&libpack_logger.LogMessage{
 				Message: "Successfully executed query",
 				Pairs:   map[string]interface{}{"query": query},
 			})
@@ -102,7 +92,7 @@ func cleanEvents(pool *pgxpool.Pool, clearOlderThan int, logger *libpack_logger.
 		for _, err := range errors {
 			errMsgs = append(errMsgs, err.Error())
 		}
-		logger.Error(&libpack_logger.LogMessage{
+		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Failed to execute some queries",
 			Pairs: map[string]interface{}{
 				"failed_queries": failedQueries,

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,13 +1,13 @@
 module github.com/lukaszraczylo/graphql-monitoring-proxy
 
-go 1.23.0
+go 1.22.7
 
-toolchain go1.23.6
+toolchain go1.23.4
 
 require (
 	github.com/VictoriaMetrics/metrics v1.35.2
 	github.com/alicebob/miniredis/v2 v2.33.0
-	github.com/avast/retry-go/v4 v4.6.1
+	github.com/avast/retry-go/v4 v4.6.0
 	github.com/goccy/go-json v0.10.5
 	github.com/gofiber/fiber/v2 v2.52.6
 	github.com/gofrs/flock v0.12.1
@@ -17,10 +17,10 @@ require (
 	github.com/jackc/pgx/v5 v5.7.2
 	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.43
-	github.com/redis/go-redis/v9 v9.7.1
+	github.com/lukaszraczylo/go-simple-graphql v1.2.41
+	github.com/redis/go-redis/v9 v9.7.0
 	github.com/stretchr/testify v1.10.0
-	github.com/valyala/fasthttp v1.59.0
+	github.com/valyala/fasthttp v1.58.0
 	go.opentelemetry.io/otel v1.34.0
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.34.0
 	go.opentelemetry.io/otel/sdk v1.34.0
@@ -38,11 +38,11 @@ require (
 	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.26.1 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.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/klauspost/compress v1.17.11 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
@@ -51,20 +51,21 @@ require (
 	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.34.0 // indirect
 	go.opentelemetry.io/otel/metric v1.34.0 // indirect
 	go.opentelemetry.io/proto/otlp v1.5.0 // indirect
-	golang.org/x/crypto v0.35.0 // indirect
-	golang.org/x/net v0.35.0 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
+	golang.org/x/net v0.34.0 // indirect
 	golang.org/x/sync v0.11.0 // indirect
 	golang.org/x/sys v0.30.0 // indirect
 	golang.org/x/term v0.29.0 // indirect
 	golang.org/x/text v0.22.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20250224174004-546df14abb99 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250204164813-702378808489 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489 // indirect
 	google.golang.org/protobuf v1.36.5 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -6,8 +6,8 @@ github.com/alicebob/miniredis/v2 v2.33.0 h1:uvTF0EDeu9RLnUEG27Db5I68ESoIxTiXbNUi
 github.com/alicebob/miniredis/v2 v2.33.0/go.mod h1:MhP4a3EU7aENRi9aO+tHfTBZicLqQevyi/DJpoj6mi0=
 github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
 github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
-github.com/avast/retry-go/v4 v4.6.1 h1:VkOLRubHdisGrHnTu89g08aQEWEgRU7LVEop3GbIcMk=
-github.com/avast/retry-go/v4 v4.6.1/go.mod h1:V6oF8njAwxJ5gRo1Q7Cxab24xs5NCWZBeaHHBklR8mA=
+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=
@@ -46,8 +46,8 @@ 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/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.26.1 h1:e9Rjr40Z98/clHv5Yg79Is0NtosR5LXRvdr7o/6NwbA=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.1/go.mod h1:tIxuGz/9mpox++sgp9fJjHO0+q1X9/UOWd798aAm22M=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.0 h1:VD1gqscl4nYs1YxVuSdemTrSgTKrwOWDK0FVFMqm+Cg=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.0/go.mod h1:4EgsQoS4TOhJizV+JTFg40qx1Ofh3XmXEQNBpgvNT40=
 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=
@@ -56,8 +56,8 @@ github.com/jackc/pgx/v5 v5.7.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI=
 github.com/jackc/pgx/v5 v5.7.2/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=
 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/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -66,10 +66,8 @@ github.com/lukaszraczylo/ask v0.0.0-20240916204100-6e9ef53a62d9 h1:pL8B9mjv6RPUf
 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.42 h1:u27/Z6gC+vHLeNwsQ2UIy75LgW80p2wJtAAQrNNfft4=
-github.com/lukaszraczylo/go-simple-graphql v1.2.42/go.mod h1:TATbOjdO26pt1S681Sm88nvKEZds3dqInIVtjvi5y40=
-github.com/lukaszraczylo/go-simple-graphql v1.2.43 h1:VXpspGCaD65R7jjcdxvVqPYu6pNKAt5XzbXeyRL0VMw=
-github.com/lukaszraczylo/go-simple-graphql v1.2.43/go.mod h1:myxqYhrROlFXVtFj9CnATnNt8dI4l+PFvBwLFN3U4e0=
+github.com/lukaszraczylo/go-simple-graphql v1.2.41 h1:RNFEjntCsjvKA5VADdio3zid3nH0+rO9qdKJvXmRpfQ=
+github.com/lukaszraczylo/go-simple-graphql v1.2.41/go.mod h1:i0R9B7tR025qduN4/t6ujolMBdWyiMlAppqczrnPfLc=
 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/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
@@ -78,8 +76,8 @@ github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6T
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/redis/go-redis/v9 v9.7.1 h1:4LhKRCIduqXqtvCUlaq9c8bdHOkICjDMrr1+Zb3osAc=
-github.com/redis/go-redis/v9 v9.7.1/go.mod h1:f6zhXITC7JUJIlPEiBOTXxJgPLdZcA93GewI7inzyWw=
+github.com/redis/go-redis/v9 v9.7.0 h1:HhLSs+B6O021gwzl+locl0zEDnyNkxMtf/Z3NNBMa9E=
+github.com/redis/go-redis/v9 v9.7.0/go.mod h1:f6zhXITC7JUJIlPEiBOTXxJgPLdZcA93GewI7inzyWw=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
@@ -92,12 +90,14 @@ github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOf
 github.com/stretchr/testify v1.10.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.59.0 h1:Qu0qYHfXvPk1mSLNqcFtEk6DpxgA26hy6bmydotDpRI=
-github.com/valyala/fasthttp v1.59.0/go.mod h1:GTxNb9Bc6r2a9D0TWNSPwDz78UxnTGBViY3xZNEqyYU=
+github.com/valyala/fasthttp v1.58.0 h1:GGB2dWxSbEprU9j0iMJHgdKYJVDyjrOwF9RE59PbRuE=
+github.com/valyala/fasthttp v1.58.0/go.mod h1:SYXvHHaFp7QZHGKSHmoMipInhrI5StHrhDTYVEjK/Kw=
 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=
@@ -124,12 +124,12 @@ go.opentelemetry.io/proto/otlp v1.5.0 h1:xJvq7gMzB31/d406fB8U5CBdyQGw4P399D1aQWU
 go.opentelemetry.io/proto/otlp v1.5.0/go.mod h1:keN8WnHxOy8PG0rQZjJJ5A2ebUoafqWp0eVQ4yIXvJ4=
 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.35.0 h1:b15kiHdrGCHrP6LvwaQ3c03kgNhhiMgvlhxHQhmg2Xs=
-golang.org/x/crypto v0.35.0/go.mod h1:dy7dXNW32cAb/6/PRuTNsix8T+vJAqvuIy5Bli/x0YQ=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
 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.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
-golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
 golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
 golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -139,10 +139,10 @@ golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
 golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
 golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
 golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
-google.golang.org/genproto/googleapis/api v0.0.0-20250224174004-546df14abb99 h1:ilJhrCga0AptpJZXmUYG4MCrx/zf3l1okuYz7YK9PPw=
-google.golang.org/genproto/googleapis/api v0.0.0-20250224174004-546df14abb99/go.mod h1:Xsh8gBVxGCcbV8ZeTB9wI5XPyZ5RvC6V3CTeeplHbiA=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99 h1:ZSlhAUqC4r8TPzqLXQ0m3upBNZeF+Y8jQ3c4CR3Ujms=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250224174004-546df14abb99/go.mod h1:LuRYeWDFV6WOn90g357N17oMCaxpgCnbi/44qJvDn2I=
+google.golang.org/genproto/googleapis/api v0.0.0-20250204164813-702378808489 h1:fCuMM4fowGzigT89NCIsW57Pk9k2D12MMi2ODn+Nk+o=
+google.golang.org/genproto/googleapis/api v0.0.0-20250204164813-702378808489/go.mod h1:iYONQfRdizDB8JJBybql13nArx91jcUk7zCXEsOofM4=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489 h1:5bKytslY8ViY0Cj/ewmRtrWHW64bNF03cAatUUFCdFI=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489/go.mod h1:8BS3B93F/U1juMFq9+EDk+qOT5CO1R9IzXxG3PTqiRk=
 google.golang.org/grpc v1.70.0 h1:pWFv03aZoHzlRKHWicjsZytKAiYCtNS0dHbXnIdq7jQ=
 google.golang.org/grpc v1.70.0/go.mod h1:ofIJqVKDXx/JiXrwr2IG4/zwdH9txy3IlF40RmcJSQw=
 google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=

graphql.go

@@ -9,6 +9,7 @@ import (
 	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"
 )
 
@@ -66,54 +67,57 @@ var (
 )
 
 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 {
+		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
 	}
 
-	// Extract the query string
 	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
 	}
 
-	// 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
 	}
 
-	// Mark as a valid GraphQL query
 	res.shouldIgnore = false
 	res.operationName = "undefined"
 
-	// 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 {
@@ -121,13 +125,17 @@ func parseGraphQLQuery(c *fiber.Ctx) *parseGraphQLQueryResult {
 				}
 			}
 
-			// Handle read-only endpoint routing
-			if cfg.Server.HostGraphQLReadOnly != "" && (res.operationType == "" || res.operationType != "mutation") {
-				res.activeEndpoint = cfg.Server.HostGraphQLReadOnly
+			if cfg.Server.HostGraphQLReadOnly != "" {
+				if res.operationType == "" || 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 - server in read-only mode",
+					Pairs:   map[string]interface{}{"query": query},
+				})
 				if ifNotInTest() {
 					cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
 				}
@@ -137,101 +145,72 @@ func parseGraphQLQuery(c *fiber.Ctx) *parseGraphQLQueryResult {
 				return res
 			}
 
-			// Process directives (like @cached)
-			processDirectives(oper, res)
+			for _, dir := range oper.Directives {
+				if dir.Name.Value == "cached" {
+					res.cacheRequest = true
+					for _, arg := range dir.Arguments {
+						switch arg.Name.Value {
+						case "ttl":
+							if v, ok := arg.Value.GetValue().(string); ok {
+								res.cacheTime, _ = strconv.Atoi(v)
+							}
+						case "refresh":
+							if v, ok := arg.Value.GetValue().(bool); ok {
+								res.cacheRefresh = v
+							}
+						}
+					}
+				}
+			}
 
-			// 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
+			if cfg.Security.BlockIntrospection {
+				if checkSelections(c, oper.GetSelectionSet().Selections) {
+					_ = c.Status(403).SendString("Introspection queries are not allowed")
+					res.shouldBlock = true
+					resultPool.Put(res)
+					return res
+				}
 			}
 		}
 	}
 	return 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
-					}
-				}
-			}
-		}
-	}
-}
-
-// 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
+				if len(cfg.Security.IntrospectionAllowed) > 0 {
+					_, allowed := introspectionAllowedQueries[fieldName]
+					if !allowed {
+						return true // Block if this field isn't allowed
 					}
+					// Even if this field is allowed, we need to check its nested selections
 				} else {
 					return true // Block if no allowlist exists
 				}
 			}
-
-			// Check nested selections if present
-			if sel.SelectionSet != nil && len(sel.GetSelectionSet().Selections) > 0 {
+			// Always check nested selections
+			if sel.SelectionSet != nil {
 				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 sel.SelectionSet != nil {
 				if checkSelections(c, sel.GetSelectionSet().Selections) {
 					return true
 				}
 			}
 		}
 	}
-
 	return false
 }
 
 func checkIfContainsIntrospection(c *fiber.Ctx, query string) bool {
 	blocked := false
-
-	// Enable introspection blocking for tests
-	if !cfg.Security.BlockIntrospection {
-		cfg.Security.BlockIntrospection = true
-	}
-
 	// Try parsing as a complete query first
 	p, err := parser.Parse(parser.ParseParams{Source: query})
 	if err == nil {

graphql_test.go

@@ -282,19 +282,15 @@ 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{}
+			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{})
 			
-			// Set headers directly on the request
+			// Set headers
 			for k, v := range tt.suppliedQuery.headers {
-				reqCtx.Request.Header.Add(k, v)
+				ctx.Request().Header.Add(k, v)
 			}
-			
-			// Set the body
-			reqCtx.Request.AppendBody([]byte(tt.suppliedQuery.body))
-			
-			// Now create the fiber context with the request context
-			ctx := suite.app.AcquireCtx(reqCtx)
+
+			// Set body
+			ctx.Request().AppendBody([]byte(tt.suppliedQuery.body))
 
 			// defer func() {
 			// 	cfg = &config{}

logging/logger.go

@@ -64,12 +64,6 @@ var fieldNames = map[string]string{
 	"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{
@@ -200,9 +194,7 @@ func (l *Logger) Fatal(m *LogMessage) {
 // 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)
 }
 
 // getCaller retrieves the file and line number of the caller.

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,10 @@ 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()
+				logger := New()
+				if tt.triggers.ModLevel.Level != 0 {
+					logger.SetMinLogLevel(tt.triggers.ModLevel.Level)
+				}
 			}
 		})
 	}

main.go

@@ -4,11 +4,8 @@ import (
 	"context"
 	"flag"
 	"os"
-	"os/signal"
-	"strconv"
 	"strings"
 	"sync"
-	"syscall"
 	"time"
 
 	"github.com/gofiber/fiber/v2/middleware/proxy"
@@ -21,39 +18,29 @@ import (
 )
 
 var (
-	cfg      *config
-	cfgMutex sync.RWMutex
-	once     sync.Once
-	tracer   *libpack_tracing.TracingSetup
+	cfg    *config
+	once   sync.Once
+	tracer *libpack_tracing.TracingSetup
 )
 
 // 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.
 func getDetailsFromEnv[T any](key string, defaultValue T) T {
-	prefixedKey := "GMP_" + key
-
+	var result any
+	envKey := "GMP_" + key
+	if _, ok := os.LookupEnv(envKey); !ok {
+		envKey = 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(envKey, 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(envKey, 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(envKey, v)
 	default:
-		return defaultValue
+		result = defaultValue
 	}
+	return result.(T)
 }
 
 // parseConfig loads and parses the configuration.
@@ -121,10 +108,7 @@ func parseConfig() {
 	// Tracing configuration
 	c.Tracing.Enable = getDetailsFromEnv("ENABLE_TRACE", false)
 	c.Tracing.Endpoint = getDetailsFromEnv("TRACE_ENDPOINT", "localhost:4317")
-
-	cfgMutex.Lock()
 	cfg = &c
-	cfgMutex.Unlock()
 
 	// Initialize tracing if enabled
 	if cfg.Tracing.Enable {
@@ -178,82 +162,20 @@ func parseConfig() {
 }
 
 func main() {
-	// Parse configuration
 	parseConfig()
+	StartMonitoringServer()
+	time.Sleep(5 * time.Second)
+	StartHTTPProxy()
 
-	// 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
+	// Cleanup tracing on exit
 	if tracer != nil {
-		shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer shutdownCancel()
-
-		if err := tracer.Shutdown(shutdownCtx); err != nil {
+		if err := tracer.Shutdown(context.Background()); 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",
-		})
-	}
 }
 
 // ifNotInTest checks if the program is not running in a test environment.

main_test.go

@@ -42,13 +42,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 +62,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))
@@ -248,10 +240,8 @@ func (suite *Tests) TestIntrospectionEnvironmentConfig() {
 				os.Setenv(k, v)
 			}
 
-			// Reset global config with proper synchronization
-			cfgMutex.Lock()
+			// Reset global config
 			cfg = nil
-			cfgMutex.Unlock()
 			parseConfig()
 
 			// Create test request

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

@@ -40,99 +40,58 @@ func createFasthttpClient(timeout int) *fasthttp.Client {
 
 // 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")
+		var span trace.Span
+		spanCtx := context.Background()
+		// 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 extractedSpanCtx, err := tracer.ExtractSpanContext(spanInfo); err == nil {
+					spanCtx = trace.ContextWithSpanContext(spanCtx, extractedSpanCtx)
+				}
+			}
+		}
+
+		// Start a new span
+		span, _ = tracer.StartSpan(spanCtx, "proxy_request")
 		defer span.End()
 	}
 
-	// Check if URL is allowed
 	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())
 	}
 
-	// Construct and validate proxy URL
 	proxyURL := currentEndpoint + c.Path()
-	if _, err := url.Parse(proxyURL); err != nil {
+	_, err := url.Parse(proxyURL)
+	if 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
+			proxyErr := proxy.DoRedirects(c, proxyURL, 3, cfg.Client.FastProxyClient)
+			if proxyErr != nil {
+				return proxyErr
 			}
 			if c.Response().StatusCode() != fiber.StatusOK {
-				return fmt.Errorf("received non-200 response: %d", c.Response().StatusCode())
+				return fmt.Errorf("received non-200 response from the GraphQL server: %d", c.Response().StatusCode())
 			}
 			return nil
 		},
@@ -152,38 +111,55 @@ func performProxyRequest(c *fiber.Ctx, proxyURL string) error {
 		}),
 		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",
+		cfg.Logger.Warning(&libpack_logger.LogMessage{
+			Message: "Can't proxy the request",
 			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()},
-		})
-		return err
+		if ifNotInTest() {
+			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
+		}
+		return fmt.Errorf("failed to proxy request: %v", err)
 	}
 
-	// Update response
-	c.Response().SetBody(decompressed)
-	c.Response().Header.Del("Content-Encoding")
+	if cfg.LogLevel == "DEBUG" {
+		logDebugResponse(c)
+	}
+
+	if bytes.EqualFold(c.Response().Header.Peek("Content-Encoding"), []byte("gzip")) {
+		// Decompress gzip response
+		reader, err := gzip.NewReader(bytes.NewReader(c.Response().Body()))
+		if err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Failed to create gzip reader",
+				Pairs:   map[string]interface{}{"error": err.Error()},
+			})
+			return err
+		}
+		defer reader.Close()
+
+		decompressed, err := io.ReadAll(reader)
+		if err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Failed to decompress response",
+				Pairs:   map[string]interface{}{"error": err.Error()},
+			})
+			return err
+		}
+
+		c.Response().SetBody(decompressed)
+		c.Response().Header.Del("Content-Encoding")
+	}
+
+	if c.Response().StatusCode() != fiber.StatusOK {
+		if ifNotInTest() {
+			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
+		}
+		return fmt.Errorf("received non-200 response from the GraphQL server: %d", c.Response().StatusCode())
+	}
+
+	c.Response().Header.Del(fiber.HeaderServer)
 	return nil
 }
 

proxy_test.go

@@ -87,21 +87,17 @@ func (suite *Tests) Test_proxyTheRequest() {
 				cfg.Server.HostGraphQLReadOnly = tt.hostRO
 			}
 
-			// Create a request context first
-			reqCtx := &fasthttp.RequestCtx{}
+			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{})
 			
-			// Set headers directly on the request
+			// Set headers
 			for k, v := range tt.headers {
-				reqCtx.Request.Header.Add(k, v)
+				ctx.Request().Header.Add(k, v)
 			}
-			
-			// 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)
+
+			// Set body and other request properties
+			ctx.Request().SetBody([]byte(tt.body))
+			ctx.Request().SetRequestURI(tt.path)
+			ctx.Request().Header.SetMethod("POST")
 			res := parseGraphQLQuery(ctx)
 			assert.NotNil(ctx, "Fiber context is nil", tt.name)
 			err := proxyTheRequest(ctx, res.activeEndpoint)

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

@@ -109,74 +109,51 @@ func healthCheck(c *fiber.Ctx) error {
 	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)
+	extractedUserID := "-"
+	extractedRoleName := "-"
+
+	if authorization := c.Get("Authorization"); authorization != "" && (len(cfg.Client.JWTUserClaimPath) > 0 || len(cfg.Client.JWTRoleClaimPath) > 0) {
+		extractedUserID, extractedRoleName = extractClaimsFromJWTHeader(authorization)
+	}
 
-	// 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)
-
-	return nil
-}
-
-// extractUserInfo extracts user ID and role from request headers
-func extractUserInfo(c *fiber.Ctx) (string, string) {
-	extractedUserID := "-"
-	extractedRoleName := "-"
-
-	// 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)
-	}
-
-	// Override role from header if configured
 	if cfg.Client.RoleFromHeader != "" {
 		if role := c.Get(cfg.Client.RoleFromHeader); role != "" {
 			extractedRoleName = role
 		}
 	}
 
-	return extractedUserID, extractedRoleName
-}
+	if cfg.Client.RoleRateLimit {
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Rate limiting enabled",
+			Pairs:   map[string]interface{}{"user_id": extractedUserID, "role_name": extractedRoleName},
+		})
+		if !rateLimitedRequest(extractedUserID, extractedRoleName) {
+			return c.Status(fiber.StatusTooManyRequests).SendString("Rate limit exceeded, try again later")
+		}
+	}
+
+	parsedResult := parseGraphQLQuery(c) // Ensure this function is defined elsewhere
+	if parsedResult.shouldBlock {
+		return c.Status(fiber.StatusForbidden).SendString("Request blocked")
+	}
+
+	if parsedResult.shouldIgnore {
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Request passed as-is - probably not a GraphQL",
+		})
+		return proxyTheRequest(c, parsedResult.activeEndpoint)
+	}
 
-// 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
 	if parsedResult.cacheTime == 0 {
 		if cacheQuery := c.Get("X-Cache-Graphql-Query"); cacheQuery != "" {
 			parsedResult.cacheTime, _ = strconv.Atoi(cacheQuery)
@@ -185,37 +162,56 @@ func handleCaching(c *fiber.Ctx, parsedResult *parseGraphQLQueryResult, userID s
 		}
 	}
 
-	// Handle cache refresh directive
+	wasCached := false //nolint:ineffassign
+
 	if parsedResult.cacheRefresh {
+		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(calculatedQueryHash)
 	}
 
-	// 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")
+	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(calculatedQueryHash); cachedResponse != nil {
+			cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheHit, nil)
+			cfg.Logger.Debug(&libpack_logger.LogMessage{
+				Message: "Cache hit",
+				Pairs:   map[string]interface{}{"hash": calculatedQueryHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")},
+			})
+			c.Set("X-Cache-Hit", "true")
+			wasCached = true
+			c.Set("Content-Type", "application/json")
+			return c.Send(cachedResponse)
+		}
+
+		cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheMiss, nil)
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Cache miss",
+			Pairs:   map[string]interface{}{"hash": calculatedQueryHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")},
+		})
+		if err := proxyAndCacheTheRequest(c, calculatedQueryHash, parsedResult.cacheTime, parsedResult.activeEndpoint); err != nil {
+			return err
+		}
+	} else {
+		if err := proxyTheRequest(c, parsedResult.activeEndpoint); err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Can't proxy the request",
+				Pairs:   map[string]interface{}{"error": err.Error()},
+			})
+			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
+			return c.Status(fiber.StatusInternalServerError).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)
-	}
+	logAndMonitorRequest(c, extractedUserID, parsedResult.operationType, parsedResult.operationName, wasCached, time.Since(startTime), startTime)
 
-	// 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
+	return nil
 }
 
 // proxyAndCacheTheRequest proxies and caches the request if needed.

tracing/tracing.go

@@ -4,17 +4,14 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"time"
 
 	"go.opentelemetry.io/otel"
-	"go.opentelemetry.io/otel/attribute"
 	"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"
 )
 
 type TracingSetup struct {
@@ -28,69 +25,37 @@ type TraceSpanInfo struct {
 
 // 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 ctx.Err() != nil {
+		return nil, fmt.Errorf("invalid context: %v", ctx.Err())
 	}
 	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),
 		otlptracegrpc.WithInsecure(),
-		otlptracegrpc.WithTimeout(5*time.Second),
-		otlptracegrpc.WithDialOption(grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(16*1024*1024))), // 16MB max message size
 	)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create trace exporter: %w", 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.WithBatcher(exporter),
 		sdktrace.WithResource(res),
-		sdktrace.WithSampler(sdktrace.TraceIDRatioBased(0.1)), // Sample 10% of traces
 	)
-
-	// Set the global tracer provider and propagator
 	otel.SetTracerProvider(tracerProvider)
 	otel.SetTextMapPropagator(propagation.TraceContext{})
 
-	// Create a tracer
 	tracer := tracerProvider.Tracer("graphql-monitoring-proxy")
 
 	return &TracingSetup{
@@ -132,40 +97,9 @@ func (ts *TracingSetup) Shutdown(ctx context.Context) error {
 
 // 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
+	if ts.tracer == nil {
 		return trace.SpanFromContext(ctx), ctx
 	}
-
-	// 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
-}
-
-// 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...))
+	ctx, span := ts.tracer.Start(ctx, name)
 	return span, ctx
 }

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

@@ -65,12 +65,11 @@ func TestNewTracing(t *testing.T) {
 		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")
+	t.Run("invalid context", func(t *testing.T) {
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel() // Cancel the context immediately
+		_, err := NewTracing(ctx, "localhost:4317")
+		assert.Error(t, err, "Expected error for invalid context")
 	})
 }